Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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
··· 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
··· 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