From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-oa1-f45.google.com (mail-oa1-f45.google.com [209.85.160.45]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 007E81B4223 for ; Fri, 3 Apr 2026 13:14:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.160.45 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775222072; cv=none; b=ufSwTN7zU2AN4r/fufqsOzv0wd5wYaLyBVTHY+pgm54RRAD3pzVJUWDCsZE9NFjJhSsuVx0QfrXd1DvTBjb4Z4KHjkmkFK8vZvIfDOu9fEf5LVGLFUbU2wpZM6F24AE3d02VwvNZcSxDLS8pkxNusD30GEzwCcyrm+rOMi+ENT4= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775222072; c=relaxed/simple; bh=vmqPXFb7MDH6oYjVSS2Fx5a7MRjH3pW8GRIStQq6dOE=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=hCYJxG4sMROalbnzDurcT+zI/We+Wl7w4MWED8eZ8IDdFmK8N/kiUIlUoHdhFy5kzFkmJ0RhHRPK0ixqyUSUj180l5Pz7sk9nW7zWRWBZtx+Lb+rap83LTQmbONZqBGDIGusIIQN5lXO0lZ/qNBEwJ/NkqttHPeUaVLGcVanV70= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=minyard.net; spf=pass smtp.mailfrom=minyard.net; dkim=pass (2048-bit key) header.d=minyard.net header.i=@minyard.net header.b=W672UpfM; arc=none smtp.client-ip=209.85.160.45 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=minyard.net Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=minyard.net Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=minyard.net header.i=@minyard.net header.b="W672UpfM" Received: by mail-oa1-f45.google.com with SMTP id 586e51a60fabf-40429b1d8baso702098fac.0 for ; Fri, 03 Apr 2026 06:14:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=minyard.net; s=google; t=1775222070; x=1775826870; darn=vger.kernel.org; h=in-reply-to:content-disposition:mime-version:references:reply-to :message-id:subject:cc:to:from:date:from:to:cc:subject:date :message-id:reply-to; bh=HcIMJ6EXC/zS9rTrRxoES4H6wJbRTcaNQfLiwvMJPGo=; b=W672UpfMxGfv3UVNlb9zA2nxjB4jNd8nC3CUqx7SzaZs5a1oiqdGtvXdD5E6WoFFDP 4vYa5N3S6HeJfDACUzG31NCgcLdxBUXM+U5SlB4qhU/Sv4Z9mlf/ei53vHALcI/bse/W IAfzqxd5858GQts5DEdOrRaqj9eHlZ9W6zZqsbKgu/OQymHMUrHPWvL4fzabd93kUs0M SIHU2uUkSz1SUCyLr+Ao/muSUYCAYD+uohqWbJMrlQzRQieMvxMR8DTAjD6XzfIu7NwV +hPepJmqDZCYcSTgYgk9DrvkGPhmUz+IcxexEmo6Mv0dMnL8O2daFsMXVbuo//tg5NP6 BSPg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1775222070; x=1775826870; h=in-reply-to:content-disposition:mime-version:references:reply-to :message-id:subject:cc:to:from:date:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=HcIMJ6EXC/zS9rTrRxoES4H6wJbRTcaNQfLiwvMJPGo=; b=bSwSb+ehwpgGMQOSaiFICopjOygqOOGkJONq3EGHOFvwCLXapTnTMOqY3Qpxa8AXvF XDMyh+EEnbDRxCmwV1fcJfCJYZTrDlPovFX+g3q99XO7JQmTd2SErwU5hChHjpzjIT/c mQeOQ6/uxCt540XIuGG3rDzPqGMjM50bRm9bibIXKKGmMysicMniYm/6sQdRYJU9779t 10uKOJIALBQ7OcoUG/gmU/G7Nb5KEK6kQzvAbcG++4Tvs1SDaftv2xi2ZpjX8KrvMshH l/TmjVCN07lpb3krcEjYOeix744NaeDMUrW3HC1ecu6OqBivyWcxwjrs0wMG01QdbdRd jPmw== X-Forwarded-Encrypted: i=1; AJvYcCVuZhrmq4UtxOlf2/6pCsH1l2WrIf72G73p8E/L8Ulk0h4kHqGWt8IQoPDggtjcxEH2poB/pMv3d1tekSY=@vger.kernel.org X-Gm-Message-State: AOJu0YyWCODtuhCTj74i0Q+jDr2H7wyLEBExodSPVCs1w5LRP41gIYhH E/VbmexDTwfMdYdJPDpSp3XE7Y1TqN285iKdejTUPcIAAM4PzpH7RjvdCgEChd4MzvE= X-Gm-Gg: AeBDietHZWo2MRgmzncHBtfyOu088wukLvGZuPRFxqSqgDzWnYrKQVXgYh0sgNpRyVw wt79vizuR+0NjRTxODQ9fEfdS5cM2Gp64nNbu127SSlmBrGX/RSU0x7NGI2GKezc0/3PvPdIuEu 8CnpNd7Yv53dMNTw0gbqXOWkV/fGU7MtZ5dlTB/ZiqLb1Dsl3fDmH54LJ0OLmkXDL9l47S30P7k 0SfHznykbyvYvD+OMNBWI6dFixEJKzGJbVGoAys0uRRmy2rnm6836kUrb1Vn+90sSvfMIc79aYY iSvR4Pc6kfZD2PhHuXdzsuD9WRNfOyZJGdmrF2dN5awjczsxrhPhhC3XKEuVvApWKM6XCVVBz0/ eemd0gQ6VB4i30xhNPcEu5JSPsTMA/GH8cSLd2t/tiEyiZdV/dqtN2tcE5zLpSG8+vGwwASJJ+w tztrDRmW0ySg3aAC8y9q9bQahk3557IHv3/hmsQt7o2fyVLQqnIsrGvjZQYjn+ceEm3KJFgKhmW ZJIfwWgcwRu3Oo= X-Received: by 2002:a05:6871:e023:b0:41c:3225:f98b with SMTP id 586e51a60fabf-4230fcb1c36mr1403751fac.10.1775222069661; Fri, 03 Apr 2026 06:14:29 -0700 (PDT) Received: from mail.minyard.net ([2001:470:b8f6:1b:67f7:eb47:a398:6ff2]) by smtp.gmail.com with ESMTPSA id 586e51a60fabf-4231f7712bcsm904373fac.18.2026.04.03.06.14.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 03 Apr 2026 06:14:29 -0700 (PDT) Date: Fri, 3 Apr 2026 08:14:25 -0500 From: Corey Minyard To: Jian Zhang Cc: Quan Nguyen , openipmi-developer@lists.sourceforge.net, linux-kernel@vger.kernel.org Subject: Re: [PATCH v2 5/5] ipmi: ssif_bmc: add unit test for state machine Message-ID: Reply-To: corey@minyard.net References: <20260403090603.3988423-1-zhangjian.3032@bytedance.com> <20260403090603.3988423-5-zhangjian.3032@bytedance.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20260403090603.3988423-5-zhangjian.3032@bytedance.com> On Fri, Apr 03, 2026 at 05:06:02PM +0800, Jian Zhang wrote: > Add some unit test for state machine when in SSIF_ABORTING state. > > Fixes: dd2bc5cc9e25 ("ipmi: ssif_bmc: Add SSIF BMC driver") > Signed-off-by: Jian Zhang > --- > v2: remove undefined symbol response_in_send > > drivers/char/ipmi/Kconfig | 10 + > drivers/char/ipmi/ssif_bmc.c | 401 +++++++++++++++++++++++++++++++++++ > 2 files changed, 411 insertions(+) > > diff --git a/drivers/char/ipmi/Kconfig b/drivers/char/ipmi/Kconfig > index 92bed266d07c..709820f80266 100644 > --- a/drivers/char/ipmi/Kconfig > +++ b/drivers/char/ipmi/Kconfig > @@ -187,6 +187,16 @@ config SSIF_IPMI_BMC > The driver implements the BMC side of the SMBus system > interface (SSIF). > > +config SSIF_IPMI_BMC_KUNIT_TEST > + bool "KUnit tests for SSIF IPMI BMC driver" if !KUNIT_ALL_TESTS > + depends on KUNIT=y > + depends on SSIF_IPMI_BMC=y Any reason for the "=y" in the above two? It's best to remove them if they are not needed so it can work in a module. I can make that change, there's no need for a new series for that. Oh, and I forgot to say in the reply on the first change, thanks Quan for reviewing these. -corey > + default KUNIT_ALL_TESTS > + help > + This option builds unit tests that exercise the SSIF BMC state > + machine, including request handling, response transmission, > + and error paths such as aborted or truncated transfers. > + > config IPMB_DEVICE_INTERFACE > tristate 'IPMB Interface handler' > depends on I2C > diff --git a/drivers/char/ipmi/ssif_bmc.c b/drivers/char/ipmi/ssif_bmc.c > index 646a1e9ffbb7..726626126cea 100644 > --- a/drivers/char/ipmi/ssif_bmc.c > +++ b/drivers/char/ipmi/ssif_bmc.c > @@ -18,6 +18,9 @@ > #include > #include > #include > +#if IS_ENABLED(CONFIG_SSIF_IPMI_BMC_KUNIT_TEST) > +#include > +#endif > > #define DEVICE_NAME "ipmi-ssif-host" > > @@ -886,6 +889,404 @@ static struct i2c_driver ssif_bmc_driver = { > .id_table = ssif_bmc_id, > }; > > +#if IS_ENABLED(CONFIG_SSIF_IPMI_BMC_KUNIT_TEST) > +struct ssif_bmc_test_ctx { > + struct ssif_bmc_ctx ssif_bmc; > + struct i2c_client client; > + struct i2c_adapter adapter; > + struct i2c_algorithm algo; > +}; > + > +static int ssif_bmc_test_init(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx; > + > + test_ctx = kunit_kzalloc(test, sizeof(*test_ctx), GFP_KERNEL); > + if (!test_ctx) > + return -ENOMEM; > + > + test_ctx->adapter.algo = &test_ctx->algo; > + test_ctx->client.addr = 0x20; > + test_ctx->client.adapter = &test_ctx->adapter; > + > + spin_lock_init(&test_ctx->ssif_bmc.lock); > + init_waitqueue_head(&test_ctx->ssif_bmc.wait_queue); > + test_ctx->ssif_bmc.client = &test_ctx->client; > + i2c_set_clientdata(&test_ctx->client, &test_ctx->ssif_bmc); > + > + test->priv = test_ctx; > + > + return 0; > +} > + > +static void ssif_bmc_test_exit(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + > + if (test_ctx->ssif_bmc.response_timer_inited) > + timer_delete_sync(&test_ctx->ssif_bmc.response_timer); > +} > + > +static int ssif_bmc_test_run_event_val(struct ssif_bmc_test_ctx *test_ctx, > + enum i2c_slave_event event, > + u8 *value) > +{ > + return ssif_bmc_cb(&test_ctx->client, event, value); > +} > + > +static int ssif_bmc_test_run_event(struct ssif_bmc_test_ctx *test_ctx, > + enum i2c_slave_event event, u8 value) > +{ > + return ssif_bmc_test_run_event_val(test_ctx, event, &value); > +} > + > +static void ssif_bmc_test_singlepart_req(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; > + > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, > + GET_8BIT_ADDR(test_ctx->client.addr)); > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, > + SSIF_IPMI_SINGLEPART_WRITE); > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2); > + > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xaa); > + > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x55); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY); > + > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY); > + KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available); > + KUNIT_EXPECT_TRUE(test, ssif_bmc->busy); > + KUNIT_EXPECT_FALSE(test, ssif_bmc->aborting); > + KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 2); > + KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0xaa); > + KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[1], 0x55); > + KUNIT_EXPECT_TRUE(test, ssif_bmc->response_timer_inited); > +} > + > +static void ssif_bmc_test_restart_write_without_stop(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; > + > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, > + GET_8BIT_ADDR(test_ctx->client.addr)), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, > + SSIF_IPMI_SINGLEPART_WRITE), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xde), 0); > + > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING); > + > + /* Write transaction, without stop, and new request coming */ > + ssif_bmc_test_singlepart_req(test); > +} > + > + > +static void ssif_bmc_test_restart_after_invalid_command(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; > + > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, > + GET_8BIT_ADDR(test_ctx->client.addr)), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xff), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0); > + > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_ABORTING); > + KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting); > + > + /* After An Invalid Command, expect could handle new request */ > + ssif_bmc_test_singlepart_req(test); > +} > + > +static void ssif_bmc_test_restart_after_invalid_length(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; > + int i; > + > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, > + GET_8BIT_ADDR(test_ctx->client.addr)), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, > + SSIF_IPMI_SINGLEPART_WRITE), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, > + MAX_PAYLOAD_PER_TRANSACTION + 1), 0); > + > + for (i = 0; i < MAX_PAYLOAD_PER_TRANSACTION + 1; i++) > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, > + I2C_SLAVE_WRITE_RECEIVED, i), 0); > + > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0); > + KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting); > + KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available); > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING); > + > + ssif_bmc_test_singlepart_req(test); > +} > + > +static void ssif_bmc_test_singlepart_read_response_completion(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; > + u8 value; > + > + ssif_bmc->state = SSIF_SMBUS_CMD; > + ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ; > + ssif_bmc->response.len = 2; > + ssif_bmc->response.payload[0] = 0x11; > + ssif_bmc->response.payload[1] = 0x22; > + ssif_bmc->response_in_progress = true; > + ssif_bmc->is_singlepart_read = true; > + ssif_bmc->pec_support = true; > + > + value = 0; > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED, > + &value), 0); > + KUNIT_EXPECT_EQ(test, value, 2); > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING); > + > + value = 0; > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED, > + &value), 0); > + KUNIT_EXPECT_EQ(test, value, 0x11); > + > + value = 0; > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED, > + &value), 0); > + KUNIT_EXPECT_EQ(test, value, 0x22); > + > + value = 0; > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED, > + &value), 0); > + KUNIT_EXPECT_EQ(test, value, ssif_bmc->part_buf.pec); > + > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0); > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY); > + KUNIT_EXPECT_FALSE(test, ssif_bmc->response_in_progress); > + KUNIT_EXPECT_EQ(test, ssif_bmc->response.len, 0); > +} > + > +static void ssif_bmc_test_stop_during_start_discards_partial_request(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; > + > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, > + GET_8BIT_ADDR(test_ctx->client.addr)), 0); > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_START); > + > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0); > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY); > + KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available); > + KUNIT_EXPECT_EQ(test, ssif_bmc->msg_idx, 0); > + > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, > + GET_8BIT_ADDR(test_ctx->client.addr)), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, > + SSIF_IPMI_SINGLEPART_WRITE), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x77), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY); > + > + KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available); > + KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1); > + KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0x77); > +} > + > +static void ssif_bmc_test_read_interrupts_partial_write(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; > + u8 value = 0xff; > + > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, > + GET_8BIT_ADDR(test_ctx->client.addr)), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, > + SSIF_IPMI_SINGLEPART_WRITE), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xab), 0); > + > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED, > + &value), 0); > + KUNIT_EXPECT_EQ(test, value, 0); > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_ABORTING); > + > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0); > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY); > + KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available); > + KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 0); > + > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, > + GET_8BIT_ADDR(test_ctx->client.addr)), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, > + SSIF_IPMI_SINGLEPART_WRITE), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xcd), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY); > + > + KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available); > + KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1); > + KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0xcd); > +} > + > +static void ssif_bmc_test_write_interrupts_response_send(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; > + u8 value = 0; > + > + ssif_bmc->state = SSIF_SMBUS_CMD; > + ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ; > + ssif_bmc->response.len = 1; > + ssif_bmc->response.payload[0] = 0x66; > + ssif_bmc->response_in_progress = true; > + ssif_bmc->is_singlepart_read = true; > + > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED, > + &value), 0); > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING); > + > + /* READ_REQUESTED transaction */ > + ssif_bmc_test_singlepart_req(test); > +} > + > +static void ssif_bmc_test_write_interrupts_response_sending(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; > + u8 value = 0; > + > + ssif_bmc->state = SSIF_SMBUS_CMD; > + ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ; > + ssif_bmc->response.len = 1; > + ssif_bmc->response.payload[0] = 0x66; > + ssif_bmc->response_in_progress = true; > + ssif_bmc->is_singlepart_read = true; > + > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED, > + &value), 0); > + KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING); > + > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED, > + &value), 0); > + KUNIT_EXPECT_EQ(test, value, 0x66); > + > + /* READ_REQUESTED transaction */ > + ssif_bmc_test_singlepart_req(test); > +} > + > +static void ssif_bmc_test_timeout_interrupt_allows_retry(struct kunit *test) > +{ > + struct ssif_bmc_test_ctx *test_ctx = test->priv; > + struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc; > + > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, > + GET_8BIT_ADDR(test_ctx->client.addr)), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, > + SSIF_IPMI_SINGLEPART_WRITE), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x21), 0); > + KUNIT_ASSERT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY); > + > + KUNIT_ASSERT_TRUE(test, timer_pending(&ssif_bmc->response_timer)); > + timer_delete_sync(&ssif_bmc->response_timer); > + response_timeout(&ssif_bmc->response_timer); > + > + KUNIT_EXPECT_FALSE(test, ssif_bmc->busy); > + KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting); > + KUNIT_EXPECT_FALSE(test, ssif_bmc->response_timer_inited); > + > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED, > + GET_8BIT_ADDR(test_ctx->client.addr)), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, > + SSIF_IPMI_SINGLEPART_WRITE), 0); > + KUNIT_EXPECT_FALSE(test, ssif_bmc->aborting); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x22), 0); > + KUNIT_EXPECT_EQ(test, > + ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY); > + > + KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available); > + KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1); > + KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0x22); > +} > + > +static struct kunit_case ssif_bmc_test_cases[] = { > + KUNIT_CASE(ssif_bmc_test_singlepart_req), > + KUNIT_CASE(ssif_bmc_test_restart_write_without_stop), > + KUNIT_CASE(ssif_bmc_test_restart_after_invalid_command), > + KUNIT_CASE(ssif_bmc_test_restart_after_invalid_length), > + KUNIT_CASE(ssif_bmc_test_singlepart_read_response_completion), > + KUNIT_CASE(ssif_bmc_test_stop_during_start_discards_partial_request), > + KUNIT_CASE(ssif_bmc_test_read_interrupts_partial_write), > + KUNIT_CASE(ssif_bmc_test_write_interrupts_response_send), > + KUNIT_CASE(ssif_bmc_test_write_interrupts_response_sending), > + KUNIT_CASE(ssif_bmc_test_timeout_interrupt_allows_retry), > + {} > +}; > + > +static struct kunit_suite ssif_bmc_test_suite = { > + .name = "ssif_bmc_test", > + .init = ssif_bmc_test_init, > + .exit = ssif_bmc_test_exit, > + .test_cases = ssif_bmc_test_cases, > +}; > + > +kunit_test_suite(ssif_bmc_test_suite); > +#endif > + > module_i2c_driver(ssif_bmc_driver); > > MODULE_AUTHOR("Quan Nguyen "); > -- > 2.20.1