Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
ipmi: ssif_bmc: add unit test for state machine
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 <zhangjian.3032@bytedance.com>
Message-ID: <20260403143939.434017-1-zhangjian.3032@bytedance.com>
Signed-off-by: Corey Minyard <corey@minyard.net>
authored by
Jian Zhang
and committed by
Corey Minyard
d4464694
c9c99b7b
+380
+10
drivers/char/ipmi/Kconfig
+10
drivers/char/ipmi/Kconfig
···
187
187
The driver implements the BMC side of the SMBus system
188
188
interface (SSIF).
189
189
190
+
config SSIF_IPMI_BMC_KUNIT_TEST
191
+
bool "KUnit tests for SSIF IPMI BMC driver" if !KUNIT_ALL_TESTS
192
+
depends on KUNIT
193
+
depends on SSIF_IPMI_BMC
194
+
default KUNIT_ALL_TESTS
195
+
help
196
+
This option builds unit tests that exercise the SSIF BMC state
197
+
machine, including request handling, response transmission,
198
+
and error paths such as aborted or truncated transfers.
199
+
190
200
config IPMB_DEVICE_INTERFACE
191
201
tristate 'IPMB Interface handler'
192
202
depends on I2C
+370
drivers/char/ipmi/ssif_bmc.c
+370
drivers/char/ipmi/ssif_bmc.c
···
18
18
#include <linux/timer.h>
19
19
#include <linux/jiffies.h>
20
20
#include <linux/ipmi_ssif_bmc.h>
21
+
#if IS_ENABLED(CONFIG_SSIF_IPMI_BMC_KUNIT_TEST)
22
+
#include <kunit/test.h>
23
+
#endif
21
24
22
25
#define DEVICE_NAME "ipmi-ssif-host"
23
26
···
888
885
.remove = ssif_bmc_remove,
889
886
.id_table = ssif_bmc_id,
890
887
};
888
+
889
+
#if IS_ENABLED(CONFIG_SSIF_IPMI_BMC_KUNIT_TEST)
890
+
struct ssif_bmc_test_ctx {
891
+
struct ssif_bmc_ctx ssif_bmc;
892
+
struct i2c_client client;
893
+
struct i2c_adapter adapter;
894
+
struct i2c_algorithm algo;
895
+
};
896
+
897
+
static int ssif_bmc_test_init(struct kunit *test)
898
+
{
899
+
struct ssif_bmc_test_ctx *test_ctx;
900
+
901
+
test_ctx = kunit_kzalloc(test, sizeof(*test_ctx), GFP_KERNEL);
902
+
if (!test_ctx)
903
+
return -ENOMEM;
904
+
905
+
test_ctx->adapter.algo = &test_ctx->algo;
906
+
test_ctx->client.addr = 0x20;
907
+
test_ctx->client.adapter = &test_ctx->adapter;
908
+
909
+
spin_lock_init(&test_ctx->ssif_bmc.lock);
910
+
init_waitqueue_head(&test_ctx->ssif_bmc.wait_queue);
911
+
test_ctx->ssif_bmc.client = &test_ctx->client;
912
+
i2c_set_clientdata(&test_ctx->client, &test_ctx->ssif_bmc);
913
+
914
+
test->priv = test_ctx;
915
+
916
+
return 0;
917
+
}
918
+
919
+
static void ssif_bmc_test_exit(struct kunit *test)
920
+
{
921
+
struct ssif_bmc_test_ctx *test_ctx = test->priv;
922
+
923
+
if (test_ctx->ssif_bmc.response_timer_inited)
924
+
timer_delete_sync(&test_ctx->ssif_bmc.response_timer);
925
+
}
926
+
927
+
static int ssif_bmc_test_run_event_val(struct ssif_bmc_test_ctx *test_ctx,
928
+
enum i2c_slave_event event,
929
+
u8 *value)
930
+
{
931
+
return ssif_bmc_cb(&test_ctx->client, event, value);
932
+
}
933
+
934
+
static int ssif_bmc_test_run_event(struct ssif_bmc_test_ctx *test_ctx,
935
+
enum i2c_slave_event event, u8 value)
936
+
{
937
+
return ssif_bmc_test_run_event_val(test_ctx, event, &value);
938
+
}
939
+
940
+
static void ssif_bmc_test_singlepart_req(struct kunit *test)
941
+
{
942
+
struct ssif_bmc_test_ctx *test_ctx = test->priv;
943
+
struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
944
+
945
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
946
+
GET_8BIT_ADDR(test_ctx->client.addr));
947
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
948
+
SSIF_IPMI_SINGLEPART_WRITE);
949
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2);
950
+
951
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xaa);
952
+
953
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x55);
954
+
KUNIT_EXPECT_EQ(test,
955
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);
956
+
957
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
958
+
KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
959
+
KUNIT_EXPECT_TRUE(test, ssif_bmc->busy);
960
+
KUNIT_EXPECT_FALSE(test, ssif_bmc->aborting);
961
+
KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 2);
962
+
KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0xaa);
963
+
KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[1], 0x55);
964
+
KUNIT_EXPECT_TRUE(test, ssif_bmc->response_timer_inited);
965
+
}
966
+
967
+
static void ssif_bmc_test_restart_write_without_stop(struct kunit *test)
968
+
{
969
+
struct ssif_bmc_test_ctx *test_ctx = test->priv;
970
+
struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
971
+
972
+
KUNIT_ASSERT_EQ(test,
973
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
974
+
GET_8BIT_ADDR(test_ctx->client.addr)), 0);
975
+
KUNIT_ASSERT_EQ(test,
976
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
977
+
SSIF_IPMI_SINGLEPART_WRITE), 0);
978
+
KUNIT_ASSERT_EQ(test,
979
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2), 0);
980
+
KUNIT_ASSERT_EQ(test,
981
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xde), 0);
982
+
983
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING);
984
+
985
+
/* Write transaction, without stop, and new request coming */
986
+
ssif_bmc_test_singlepart_req(test);
987
+
}
988
+
989
+
990
+
static void ssif_bmc_test_restart_after_invalid_command(struct kunit *test)
991
+
{
992
+
struct ssif_bmc_test_ctx *test_ctx = test->priv;
993
+
struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
994
+
995
+
KUNIT_ASSERT_EQ(test,
996
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
997
+
GET_8BIT_ADDR(test_ctx->client.addr)), 0);
998
+
KUNIT_ASSERT_EQ(test,
999
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xff), 0);
1000
+
KUNIT_ASSERT_EQ(test,
1001
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
1002
+
1003
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_ABORTING);
1004
+
KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting);
1005
+
1006
+
/* After An Invalid Command, expect could handle new request */
1007
+
ssif_bmc_test_singlepart_req(test);
1008
+
}
1009
+
1010
+
static void ssif_bmc_test_singlepart_read_response_completion(struct kunit *test)
1011
+
{
1012
+
struct ssif_bmc_test_ctx *test_ctx = test->priv;
1013
+
struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1014
+
u8 value;
1015
+
1016
+
ssif_bmc->state = SSIF_SMBUS_CMD;
1017
+
ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ;
1018
+
ssif_bmc->response.len = 2;
1019
+
ssif_bmc->response.payload[0] = 0x11;
1020
+
ssif_bmc->response.payload[1] = 0x22;
1021
+
ssif_bmc->response_in_progress = true;
1022
+
ssif_bmc->is_singlepart_read = true;
1023
+
ssif_bmc->pec_support = true;
1024
+
1025
+
value = 0;
1026
+
KUNIT_ASSERT_EQ(test,
1027
+
ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
1028
+
&value), 0);
1029
+
KUNIT_EXPECT_EQ(test, value, 2);
1030
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING);
1031
+
1032
+
value = 0;
1033
+
KUNIT_EXPECT_EQ(test,
1034
+
ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
1035
+
&value), 0);
1036
+
KUNIT_EXPECT_EQ(test, value, 0x11);
1037
+
1038
+
value = 0;
1039
+
KUNIT_EXPECT_EQ(test,
1040
+
ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
1041
+
&value), 0);
1042
+
KUNIT_EXPECT_EQ(test, value, 0x22);
1043
+
1044
+
value = 0;
1045
+
KUNIT_EXPECT_EQ(test,
1046
+
ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
1047
+
&value), 0);
1048
+
KUNIT_EXPECT_EQ(test, value, ssif_bmc->part_buf.pec);
1049
+
1050
+
KUNIT_EXPECT_EQ(test,
1051
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0);
1052
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
1053
+
KUNIT_EXPECT_FALSE(test, ssif_bmc->response_in_progress);
1054
+
KUNIT_EXPECT_EQ(test, ssif_bmc->response.len, 0);
1055
+
}
1056
+
1057
+
static void ssif_bmc_test_stop_during_start_discards_partial_request(struct kunit *test)
1058
+
{
1059
+
struct ssif_bmc_test_ctx *test_ctx = test->priv;
1060
+
struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1061
+
1062
+
KUNIT_ASSERT_EQ(test,
1063
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1064
+
GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1065
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_START);
1066
+
1067
+
KUNIT_EXPECT_EQ(test,
1068
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0);
1069
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
1070
+
KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available);
1071
+
KUNIT_EXPECT_EQ(test, ssif_bmc->msg_idx, 0);
1072
+
1073
+
KUNIT_EXPECT_EQ(test,
1074
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1075
+
GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1076
+
KUNIT_EXPECT_EQ(test,
1077
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
1078
+
SSIF_IPMI_SINGLEPART_WRITE), 0);
1079
+
KUNIT_EXPECT_EQ(test,
1080
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
1081
+
KUNIT_EXPECT_EQ(test,
1082
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x77), 0);
1083
+
KUNIT_EXPECT_EQ(test,
1084
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);
1085
+
1086
+
KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
1087
+
KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1);
1088
+
KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0x77);
1089
+
}
1090
+
1091
+
static void ssif_bmc_test_read_interrupts_partial_write(struct kunit *test)
1092
+
{
1093
+
struct ssif_bmc_test_ctx *test_ctx = test->priv;
1094
+
struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1095
+
u8 value = 0xff;
1096
+
1097
+
KUNIT_ASSERT_EQ(test,
1098
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1099
+
GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1100
+
KUNIT_ASSERT_EQ(test,
1101
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
1102
+
SSIF_IPMI_SINGLEPART_WRITE), 0);
1103
+
KUNIT_ASSERT_EQ(test,
1104
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2), 0);
1105
+
KUNIT_ASSERT_EQ(test,
1106
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xab), 0);
1107
+
1108
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING);
1109
+
KUNIT_EXPECT_EQ(test,
1110
+
ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
1111
+
&value), 0);
1112
+
KUNIT_EXPECT_EQ(test, value, 0);
1113
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_ABORTING);
1114
+
1115
+
KUNIT_EXPECT_EQ(test,
1116
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0);
1117
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
1118
+
KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available);
1119
+
KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 0);
1120
+
1121
+
KUNIT_EXPECT_EQ(test,
1122
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1123
+
GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1124
+
KUNIT_EXPECT_EQ(test,
1125
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
1126
+
SSIF_IPMI_SINGLEPART_WRITE), 0);
1127
+
KUNIT_EXPECT_EQ(test,
1128
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
1129
+
KUNIT_EXPECT_EQ(test,
1130
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xcd), 0);
1131
+
KUNIT_EXPECT_EQ(test,
1132
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);
1133
+
1134
+
KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
1135
+
KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1);
1136
+
KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0xcd);
1137
+
}
1138
+
1139
+
static void ssif_bmc_test_write_interrupts_response_send(struct kunit *test)
1140
+
{
1141
+
struct ssif_bmc_test_ctx *test_ctx = test->priv;
1142
+
struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1143
+
u8 value = 0;
1144
+
1145
+
ssif_bmc->state = SSIF_SMBUS_CMD;
1146
+
ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ;
1147
+
ssif_bmc->response.len = 1;
1148
+
ssif_bmc->response.payload[0] = 0x66;
1149
+
ssif_bmc->response_in_progress = true;
1150
+
ssif_bmc->is_singlepart_read = true;
1151
+
1152
+
KUNIT_ASSERT_EQ(test,
1153
+
ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
1154
+
&value), 0);
1155
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING);
1156
+
1157
+
/* READ_REQUESTED transaction */
1158
+
ssif_bmc_test_singlepart_req(test);
1159
+
}
1160
+
1161
+
static void ssif_bmc_test_write_interrupts_response_sending(struct kunit *test)
1162
+
{
1163
+
struct ssif_bmc_test_ctx *test_ctx = test->priv;
1164
+
struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1165
+
u8 value = 0;
1166
+
1167
+
ssif_bmc->state = SSIF_SMBUS_CMD;
1168
+
ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ;
1169
+
ssif_bmc->response.len = 1;
1170
+
ssif_bmc->response.payload[0] = 0x66;
1171
+
ssif_bmc->response_in_progress = true;
1172
+
ssif_bmc->is_singlepart_read = true;
1173
+
1174
+
KUNIT_ASSERT_EQ(test,
1175
+
ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
1176
+
&value), 0);
1177
+
KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING);
1178
+
1179
+
KUNIT_ASSERT_EQ(test,
1180
+
ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
1181
+
&value), 0);
1182
+
KUNIT_EXPECT_EQ(test, value, 0x66);
1183
+
1184
+
/* READ_REQUESTED transaction */
1185
+
ssif_bmc_test_singlepart_req(test);
1186
+
}
1187
+
1188
+
static void ssif_bmc_test_timeout_interrupt_allows_retry(struct kunit *test)
1189
+
{
1190
+
struct ssif_bmc_test_ctx *test_ctx = test->priv;
1191
+
struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
1192
+
1193
+
KUNIT_ASSERT_EQ(test,
1194
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1195
+
GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1196
+
KUNIT_ASSERT_EQ(test,
1197
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
1198
+
SSIF_IPMI_SINGLEPART_WRITE), 0);
1199
+
KUNIT_ASSERT_EQ(test,
1200
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
1201
+
KUNIT_ASSERT_EQ(test,
1202
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x21), 0);
1203
+
KUNIT_ASSERT_EQ(test,
1204
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);
1205
+
1206
+
KUNIT_ASSERT_TRUE(test, timer_pending(&ssif_bmc->response_timer));
1207
+
timer_delete_sync(&ssif_bmc->response_timer);
1208
+
response_timeout(&ssif_bmc->response_timer);
1209
+
1210
+
KUNIT_EXPECT_FALSE(test, ssif_bmc->busy);
1211
+
KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting);
1212
+
KUNIT_EXPECT_FALSE(test, ssif_bmc->response_timer_inited);
1213
+
1214
+
KUNIT_EXPECT_EQ(test,
1215
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
1216
+
GET_8BIT_ADDR(test_ctx->client.addr)), 0);
1217
+
KUNIT_EXPECT_EQ(test,
1218
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
1219
+
SSIF_IPMI_SINGLEPART_WRITE), 0);
1220
+
KUNIT_EXPECT_FALSE(test, ssif_bmc->aborting);
1221
+
KUNIT_EXPECT_EQ(test,
1222
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
1223
+
KUNIT_EXPECT_EQ(test,
1224
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x22), 0);
1225
+
KUNIT_EXPECT_EQ(test,
1226
+
ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);
1227
+
1228
+
KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
1229
+
KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1);
1230
+
KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0x22);
1231
+
}
1232
+
1233
+
static struct kunit_case ssif_bmc_test_cases[] = {
1234
+
KUNIT_CASE(ssif_bmc_test_singlepart_req),
1235
+
KUNIT_CASE(ssif_bmc_test_restart_write_without_stop),
1236
+
KUNIT_CASE(ssif_bmc_test_restart_after_invalid_command),
1237
+
KUNIT_CASE(ssif_bmc_test_singlepart_read_response_completion),
1238
+
KUNIT_CASE(ssif_bmc_test_stop_during_start_discards_partial_request),
1239
+
KUNIT_CASE(ssif_bmc_test_read_interrupts_partial_write),
1240
+
KUNIT_CASE(ssif_bmc_test_write_interrupts_response_send),
1241
+
KUNIT_CASE(ssif_bmc_test_write_interrupts_response_sending),
1242
+
KUNIT_CASE(ssif_bmc_test_timeout_interrupt_allows_retry),
1243
+
{}
1244
+
};
1245
+
1246
+
static struct kunit_suite ssif_bmc_test_suite = {
1247
+
.name = "ssif_bmc_test",
1248
+
.init = ssif_bmc_test_init,
1249
+
.exit = ssif_bmc_test_exit,
1250
+
.test_cases = ssif_bmc_test_cases,
1251
+
};
1252
+
1253
+
kunit_test_suite(ssif_bmc_test_suite);
1254
+
#endif
891
1255
892
1256
module_i2c_driver(ssif_bmc_driver);
893
1257