1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Kunit tests for ChromeOS Embedded Controller protocol. 4 */ 5 6 #include <kunit/test.h> 7 8 #include <asm/unaligned.h> 9 10 #include <linux/platform_data/cros_ec_commands.h> 11 #include <linux/platform_data/cros_ec_proto.h> 12 13 #include "cros_ec.h" 14 #include "cros_ec_proto_test_util.h" 15 16 #define BUFSIZE 512 17 18 struct cros_ec_proto_test_priv { 19 struct cros_ec_device ec_dev; 20 u8 dout[BUFSIZE]; 21 u8 din[BUFSIZE]; 22 struct cros_ec_command *msg; 23 u8 _msg[BUFSIZE]; 24 }; 25 26 static void cros_ec_proto_test_prepare_tx_legacy_normal(struct kunit *test) 27 { 28 struct cros_ec_proto_test_priv *priv = test->priv; 29 struct cros_ec_device *ec_dev = &priv->ec_dev; 30 struct cros_ec_command *msg = priv->msg; 31 int ret, i; 32 u8 csum; 33 34 ec_dev->proto_version = 2; 35 36 msg->command = EC_CMD_HELLO; 37 msg->outsize = EC_PROTO2_MAX_PARAM_SIZE; 38 msg->data[0] = 0xde; 39 msg->data[1] = 0xad; 40 msg->data[2] = 0xbe; 41 msg->data[3] = 0xef; 42 43 ret = cros_ec_prepare_tx(ec_dev, msg); 44 45 KUNIT_EXPECT_EQ(test, ret, EC_MSG_TX_PROTO_BYTES + EC_PROTO2_MAX_PARAM_SIZE); 46 KUNIT_EXPECT_EQ(test, ec_dev->dout[0], EC_CMD_VERSION0); 47 KUNIT_EXPECT_EQ(test, ec_dev->dout[1], EC_CMD_HELLO); 48 KUNIT_EXPECT_EQ(test, ec_dev->dout[2], EC_PROTO2_MAX_PARAM_SIZE); 49 KUNIT_EXPECT_EQ(test, EC_MSG_TX_HEADER_BYTES, 3); 50 KUNIT_EXPECT_EQ(test, ec_dev->dout[EC_MSG_TX_HEADER_BYTES + 0], 0xde); 51 KUNIT_EXPECT_EQ(test, ec_dev->dout[EC_MSG_TX_HEADER_BYTES + 1], 0xad); 52 KUNIT_EXPECT_EQ(test, ec_dev->dout[EC_MSG_TX_HEADER_BYTES + 2], 0xbe); 53 KUNIT_EXPECT_EQ(test, ec_dev->dout[EC_MSG_TX_HEADER_BYTES + 3], 0xef); 54 for (i = 4; i < EC_PROTO2_MAX_PARAM_SIZE; ++i) 55 KUNIT_EXPECT_EQ(test, ec_dev->dout[EC_MSG_TX_HEADER_BYTES + i], 0); 56 57 csum = EC_CMD_VERSION0; 58 csum += EC_CMD_HELLO; 59 csum += EC_PROTO2_MAX_PARAM_SIZE; 60 csum += 0xde; 61 csum += 0xad; 62 csum += 0xbe; 63 csum += 0xef; 64 KUNIT_EXPECT_EQ(test, 65 ec_dev->dout[EC_MSG_TX_HEADER_BYTES + EC_PROTO2_MAX_PARAM_SIZE], 66 csum); 67 } 68 69 static void cros_ec_proto_test_prepare_tx_legacy_bad_msg_outsize(struct kunit *test) 70 { 71 struct cros_ec_proto_test_priv *priv = test->priv; 72 struct cros_ec_device *ec_dev = &priv->ec_dev; 73 struct cros_ec_command *msg = priv->msg; 74 int ret; 75 76 ec_dev->proto_version = 2; 77 78 msg->outsize = EC_PROTO2_MAX_PARAM_SIZE + 1; 79 80 ret = cros_ec_prepare_tx(ec_dev, msg); 81 KUNIT_EXPECT_EQ(test, ret, -EINVAL); 82 } 83 84 static void cros_ec_proto_test_prepare_tx_normal(struct kunit *test) 85 { 86 struct cros_ec_proto_test_priv *priv = test->priv; 87 struct cros_ec_device *ec_dev = &priv->ec_dev; 88 struct cros_ec_command *msg = priv->msg; 89 struct ec_host_request *request = (struct ec_host_request *)ec_dev->dout; 90 int ret, i; 91 u8 csum; 92 93 msg->command = EC_CMD_HELLO; 94 msg->outsize = 0x88; 95 msg->data[0] = 0xde; 96 msg->data[1] = 0xad; 97 msg->data[2] = 0xbe; 98 msg->data[3] = 0xef; 99 100 ret = cros_ec_prepare_tx(ec_dev, msg); 101 102 KUNIT_EXPECT_EQ(test, ret, sizeof(*request) + 0x88); 103 104 KUNIT_EXPECT_EQ(test, request->struct_version, EC_HOST_REQUEST_VERSION); 105 KUNIT_EXPECT_EQ(test, request->command, EC_CMD_HELLO); 106 KUNIT_EXPECT_EQ(test, request->command_version, 0); 107 KUNIT_EXPECT_EQ(test, request->data_len, 0x88); 108 KUNIT_EXPECT_EQ(test, ec_dev->dout[sizeof(*request) + 0], 0xde); 109 KUNIT_EXPECT_EQ(test, ec_dev->dout[sizeof(*request) + 1], 0xad); 110 KUNIT_EXPECT_EQ(test, ec_dev->dout[sizeof(*request) + 2], 0xbe); 111 KUNIT_EXPECT_EQ(test, ec_dev->dout[sizeof(*request) + 3], 0xef); 112 for (i = 4; i < 0x88; ++i) 113 KUNIT_EXPECT_EQ(test, ec_dev->dout[sizeof(*request) + i], 0); 114 115 csum = EC_HOST_REQUEST_VERSION; 116 csum += EC_CMD_HELLO; 117 csum += 0x88; 118 csum += 0xde; 119 csum += 0xad; 120 csum += 0xbe; 121 csum += 0xef; 122 KUNIT_EXPECT_EQ(test, request->checksum, (u8)-csum); 123 } 124 125 static void cros_ec_proto_test_prepare_tx_bad_msg_outsize(struct kunit *test) 126 { 127 struct cros_ec_proto_test_priv *priv = test->priv; 128 struct cros_ec_device *ec_dev = &priv->ec_dev; 129 struct cros_ec_command *msg = priv->msg; 130 int ret; 131 132 msg->outsize = ec_dev->dout_size - sizeof(struct ec_host_request) + 1; 133 134 ret = cros_ec_prepare_tx(ec_dev, msg); 135 KUNIT_EXPECT_EQ(test, ret, -EINVAL); 136 } 137 138 static void cros_ec_proto_test_check_result(struct kunit *test) 139 { 140 struct cros_ec_proto_test_priv *priv = test->priv; 141 struct cros_ec_device *ec_dev = &priv->ec_dev; 142 struct cros_ec_command *msg = priv->msg; 143 int ret, i; 144 static enum ec_status status[] = { 145 EC_RES_SUCCESS, 146 EC_RES_INVALID_COMMAND, 147 EC_RES_ERROR, 148 EC_RES_INVALID_PARAM, 149 EC_RES_ACCESS_DENIED, 150 EC_RES_INVALID_RESPONSE, 151 EC_RES_INVALID_VERSION, 152 EC_RES_INVALID_CHECKSUM, 153 EC_RES_UNAVAILABLE, 154 EC_RES_TIMEOUT, 155 EC_RES_OVERFLOW, 156 EC_RES_INVALID_HEADER, 157 EC_RES_REQUEST_TRUNCATED, 158 EC_RES_RESPONSE_TOO_BIG, 159 EC_RES_BUS_ERROR, 160 EC_RES_BUSY, 161 EC_RES_INVALID_HEADER_VERSION, 162 EC_RES_INVALID_HEADER_CRC, 163 EC_RES_INVALID_DATA_CRC, 164 EC_RES_DUP_UNAVAILABLE, 165 }; 166 167 for (i = 0; i < ARRAY_SIZE(status); ++i) { 168 msg->result = status[i]; 169 ret = cros_ec_check_result(ec_dev, msg); 170 KUNIT_EXPECT_EQ(test, ret, 0); 171 } 172 173 msg->result = EC_RES_IN_PROGRESS; 174 ret = cros_ec_check_result(ec_dev, msg); 175 KUNIT_EXPECT_EQ(test, ret, -EAGAIN); 176 } 177 178 static void cros_ec_proto_test_query_all_pretest(struct kunit *test) 179 { 180 struct cros_ec_proto_test_priv *priv = test->priv; 181 struct cros_ec_device *ec_dev = &priv->ec_dev; 182 183 /* 184 * cros_ec_query_all() will free din and dout and allocate them again to fit the usage by 185 * calling devm_kfree() and devm_kzalloc(). Set them to NULL as they aren't managed by 186 * ec_dev->dev but allocated statically in struct cros_ec_proto_test_priv 187 * (see cros_ec_proto_test_init()). 188 */ 189 ec_dev->din = NULL; 190 ec_dev->dout = NULL; 191 } 192 193 static void cros_ec_proto_test_query_all_normal(struct kunit *test) 194 { 195 struct cros_ec_proto_test_priv *priv = test->priv; 196 struct cros_ec_device *ec_dev = &priv->ec_dev; 197 struct ec_xfer_mock *mock; 198 int ret; 199 200 /* For cros_ec_get_proto_info() without passthru. */ 201 { 202 struct ec_response_get_protocol_info *data; 203 204 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 205 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 206 207 data = (struct ec_response_get_protocol_info *)mock->o_data; 208 data->protocol_versions = BIT(3) | BIT(2); 209 data->max_request_packet_size = 0xbe; 210 data->max_response_packet_size = 0xef; 211 } 212 213 /* For cros_ec_get_proto_info() with passthru. */ 214 { 215 struct ec_response_get_protocol_info *data; 216 217 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 218 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 219 220 data = (struct ec_response_get_protocol_info *)mock->o_data; 221 data->max_request_packet_size = 0xbf; 222 } 223 224 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 225 { 226 struct ec_response_get_cmd_versions *data; 227 228 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 229 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 230 231 data = (struct ec_response_get_cmd_versions *)mock->o_data; 232 data->version_mask = BIT(6) | BIT(5); 233 } 234 235 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */ 236 { 237 struct ec_response_get_cmd_versions *data; 238 239 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 240 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 241 242 data = (struct ec_response_get_cmd_versions *)mock->o_data; 243 data->version_mask = BIT(1); 244 } 245 246 /* For cros_ec_get_host_event_wake_mask(). */ 247 { 248 struct ec_response_host_event_mask *data; 249 250 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 251 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 252 253 data = (struct ec_response_host_event_mask *)mock->o_data; 254 data->mask = 0xbeef; 255 } 256 257 cros_ec_proto_test_query_all_pretest(test); 258 ret = cros_ec_query_all(ec_dev); 259 KUNIT_EXPECT_EQ(test, ret, 0); 260 261 /* For cros_ec_get_proto_info() without passthru. */ 262 { 263 mock = cros_kunit_ec_xfer_mock_next(); 264 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 265 266 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 267 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 268 KUNIT_EXPECT_EQ(test, mock->msg.insize, 269 sizeof(struct ec_response_get_protocol_info)); 270 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 271 272 KUNIT_EXPECT_EQ(test, ec_dev->max_request, 0xbe - sizeof(struct ec_host_request)); 273 KUNIT_EXPECT_EQ(test, ec_dev->max_response, 0xef - sizeof(struct ec_host_response)); 274 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 3); 275 KUNIT_EXPECT_EQ(test, ec_dev->din_size, 0xef + EC_MAX_RESPONSE_OVERHEAD); 276 KUNIT_EXPECT_EQ(test, ec_dev->dout_size, 0xbe + EC_MAX_REQUEST_OVERHEAD); 277 } 278 279 /* For cros_ec_get_proto_info() with passthru. */ 280 { 281 mock = cros_kunit_ec_xfer_mock_next(); 282 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 283 284 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 285 KUNIT_EXPECT_EQ(test, mock->msg.command, 286 EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) | 287 EC_CMD_GET_PROTOCOL_INFO); 288 KUNIT_EXPECT_EQ(test, mock->msg.insize, 289 sizeof(struct ec_response_get_protocol_info)); 290 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 291 292 KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0xbf - sizeof(struct ec_host_request)); 293 } 294 295 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 296 { 297 struct ec_params_get_cmd_versions *data; 298 299 mock = cros_kunit_ec_xfer_mock_next(); 300 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 301 302 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 303 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 304 KUNIT_EXPECT_EQ(test, mock->msg.insize, 305 sizeof(struct ec_response_get_cmd_versions)); 306 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 307 308 data = (struct ec_params_get_cmd_versions *)mock->i_data; 309 KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT); 310 311 KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 7); 312 } 313 314 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */ 315 { 316 struct ec_params_get_cmd_versions *data; 317 318 mock = cros_kunit_ec_xfer_mock_next(); 319 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 320 321 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 322 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 323 KUNIT_EXPECT_EQ(test, mock->msg.insize, 324 sizeof(struct ec_response_get_cmd_versions)); 325 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 326 327 data = (struct ec_params_get_cmd_versions *)mock->i_data; 328 KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_HOST_SLEEP_EVENT); 329 330 KUNIT_EXPECT_TRUE(test, ec_dev->host_sleep_v1); 331 } 332 333 /* For cros_ec_get_host_event_wake_mask(). */ 334 { 335 mock = cros_kunit_ec_xfer_mock_next(); 336 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 337 338 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 339 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK); 340 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask)); 341 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 342 343 KUNIT_EXPECT_EQ(test, ec_dev->host_event_wake_mask, 0xbeef); 344 } 345 } 346 347 static void cros_ec_proto_test_query_all_no_pd_return_error(struct kunit *test) 348 { 349 struct cros_ec_proto_test_priv *priv = test->priv; 350 struct cros_ec_device *ec_dev = &priv->ec_dev; 351 struct ec_xfer_mock *mock; 352 int ret; 353 354 /* Set some garbage bytes. */ 355 ec_dev->max_passthru = 0xbf; 356 357 /* For cros_ec_get_proto_info() without passthru. */ 358 { 359 struct ec_response_get_protocol_info *data; 360 361 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 362 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 363 364 /* 365 * Although it doesn't check the value, provides valid sizes so that 366 * cros_ec_query_all() allocates din and dout correctly. 367 */ 368 data = (struct ec_response_get_protocol_info *)mock->o_data; 369 data->max_request_packet_size = 0xbe; 370 data->max_response_packet_size = 0xef; 371 } 372 373 /* For cros_ec_get_proto_info() with passthru. */ 374 { 375 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 376 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 377 } 378 379 cros_ec_proto_test_query_all_pretest(test); 380 ret = cros_ec_query_all(ec_dev); 381 KUNIT_EXPECT_EQ(test, ret, 0); 382 383 /* For cros_ec_get_proto_info() without passthru. */ 384 { 385 mock = cros_kunit_ec_xfer_mock_next(); 386 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 387 388 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 389 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 390 KUNIT_EXPECT_EQ(test, mock->msg.insize, 391 sizeof(struct ec_response_get_protocol_info)); 392 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 393 } 394 395 /* For cros_ec_get_proto_info() with passthru. */ 396 { 397 mock = cros_kunit_ec_xfer_mock_next(); 398 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 399 400 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 401 KUNIT_EXPECT_EQ(test, mock->msg.command, 402 EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) | 403 EC_CMD_GET_PROTOCOL_INFO); 404 KUNIT_EXPECT_EQ(test, mock->msg.insize, 405 sizeof(struct ec_response_get_protocol_info)); 406 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 407 408 KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0); 409 } 410 } 411 412 static void cros_ec_proto_test_query_all_no_pd_return0(struct kunit *test) 413 { 414 struct cros_ec_proto_test_priv *priv = test->priv; 415 struct cros_ec_device *ec_dev = &priv->ec_dev; 416 struct ec_xfer_mock *mock; 417 int ret; 418 419 /* Set some garbage bytes. */ 420 ec_dev->max_passthru = 0xbf; 421 422 /* For cros_ec_get_proto_info() without passthru. */ 423 { 424 struct ec_response_get_protocol_info *data; 425 426 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 427 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 428 429 /* 430 * Although it doesn't check the value, provides valid sizes so that 431 * cros_ec_query_all() allocates din and dout correctly. 432 */ 433 data = (struct ec_response_get_protocol_info *)mock->o_data; 434 data->max_request_packet_size = 0xbe; 435 data->max_response_packet_size = 0xef; 436 } 437 438 /* For cros_ec_get_proto_info() with passthru. */ 439 { 440 mock = cros_kunit_ec_xfer_mock_add(test, 0); 441 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 442 } 443 444 cros_ec_proto_test_query_all_pretest(test); 445 ret = cros_ec_query_all(ec_dev); 446 KUNIT_EXPECT_EQ(test, ret, 0); 447 448 /* For cros_ec_get_proto_info() without passthru. */ 449 { 450 mock = cros_kunit_ec_xfer_mock_next(); 451 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 452 453 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 454 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 455 KUNIT_EXPECT_EQ(test, mock->msg.insize, 456 sizeof(struct ec_response_get_protocol_info)); 457 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 458 } 459 460 /* For cros_ec_get_proto_info() with passthru. */ 461 { 462 mock = cros_kunit_ec_xfer_mock_next(); 463 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 464 465 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 466 KUNIT_EXPECT_EQ(test, mock->msg.command, 467 EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) | 468 EC_CMD_GET_PROTOCOL_INFO); 469 KUNIT_EXPECT_EQ(test, mock->msg.insize, 470 sizeof(struct ec_response_get_protocol_info)); 471 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 472 473 KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0); 474 } 475 } 476 477 static void cros_ec_proto_test_query_all_legacy_normal_v3_return_error(struct kunit *test) 478 { 479 struct cros_ec_proto_test_priv *priv = test->priv; 480 struct cros_ec_device *ec_dev = &priv->ec_dev; 481 struct ec_xfer_mock *mock; 482 int ret; 483 484 /* For cros_ec_get_proto_info() without passthru. */ 485 { 486 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 487 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 488 } 489 490 /* For cros_ec_get_proto_info_legacy(). */ 491 { 492 struct ec_response_hello *data; 493 494 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 495 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 496 497 data = (struct ec_response_hello *)mock->o_data; 498 data->out_data = 0xa1b2c3d4; 499 } 500 501 cros_ec_proto_test_query_all_pretest(test); 502 ret = cros_ec_query_all(ec_dev); 503 KUNIT_EXPECT_EQ(test, ret, 0); 504 505 /* For cros_ec_get_proto_info() without passthru. */ 506 { 507 mock = cros_kunit_ec_xfer_mock_next(); 508 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 509 510 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 511 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 512 KUNIT_EXPECT_EQ(test, mock->msg.insize, 513 sizeof(struct ec_response_get_protocol_info)); 514 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 515 } 516 517 /* For cros_ec_get_proto_info_legacy(). */ 518 { 519 struct ec_params_hello *data; 520 521 mock = cros_kunit_ec_xfer_mock_next(); 522 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 523 524 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 525 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO); 526 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello)); 527 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 528 529 data = (struct ec_params_hello *)mock->i_data; 530 KUNIT_EXPECT_EQ(test, data->in_data, 0xa0b0c0d0); 531 532 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 2); 533 KUNIT_EXPECT_EQ(test, ec_dev->max_request, EC_PROTO2_MAX_PARAM_SIZE); 534 KUNIT_EXPECT_EQ(test, ec_dev->max_response, EC_PROTO2_MAX_PARAM_SIZE); 535 KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0); 536 KUNIT_EXPECT_PTR_EQ(test, ec_dev->pkt_xfer, NULL); 537 KUNIT_EXPECT_EQ(test, ec_dev->din_size, EC_PROTO2_MSG_BYTES); 538 KUNIT_EXPECT_EQ(test, ec_dev->dout_size, EC_PROTO2_MSG_BYTES); 539 } 540 } 541 542 static void cros_ec_proto_test_query_all_legacy_normal_v3_return0(struct kunit *test) 543 { 544 struct cros_ec_proto_test_priv *priv = test->priv; 545 struct cros_ec_device *ec_dev = &priv->ec_dev; 546 struct ec_xfer_mock *mock; 547 int ret; 548 549 /* For cros_ec_get_proto_info() without passthru. */ 550 { 551 mock = cros_kunit_ec_xfer_mock_add(test, 0); 552 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 553 } 554 555 /* For cros_ec_get_proto_info_legacy(). */ 556 { 557 struct ec_response_hello *data; 558 559 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 560 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 561 562 data = (struct ec_response_hello *)mock->o_data; 563 data->out_data = 0xa1b2c3d4; 564 } 565 566 cros_ec_proto_test_query_all_pretest(test); 567 ret = cros_ec_query_all(ec_dev); 568 KUNIT_EXPECT_EQ(test, ret, 0); 569 570 /* For cros_ec_get_proto_info() without passthru. */ 571 { 572 mock = cros_kunit_ec_xfer_mock_next(); 573 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 574 575 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 576 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 577 KUNIT_EXPECT_EQ(test, mock->msg.insize, 578 sizeof(struct ec_response_get_protocol_info)); 579 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 580 } 581 582 /* For cros_ec_get_proto_info_legacy(). */ 583 { 584 struct ec_params_hello *data; 585 586 mock = cros_kunit_ec_xfer_mock_next(); 587 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 588 589 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 590 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO); 591 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello)); 592 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 593 594 data = (struct ec_params_hello *)mock->i_data; 595 KUNIT_EXPECT_EQ(test, data->in_data, 0xa0b0c0d0); 596 597 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 2); 598 KUNIT_EXPECT_EQ(test, ec_dev->max_request, EC_PROTO2_MAX_PARAM_SIZE); 599 KUNIT_EXPECT_EQ(test, ec_dev->max_response, EC_PROTO2_MAX_PARAM_SIZE); 600 KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0); 601 KUNIT_EXPECT_PTR_EQ(test, ec_dev->pkt_xfer, NULL); 602 KUNIT_EXPECT_EQ(test, ec_dev->din_size, EC_PROTO2_MSG_BYTES); 603 KUNIT_EXPECT_EQ(test, ec_dev->dout_size, EC_PROTO2_MSG_BYTES); 604 } 605 } 606 607 static void cros_ec_proto_test_query_all_legacy_xfer_error(struct kunit *test) 608 { 609 struct cros_ec_proto_test_priv *priv = test->priv; 610 struct cros_ec_device *ec_dev = &priv->ec_dev; 611 struct ec_xfer_mock *mock; 612 int ret; 613 614 /* For cros_ec_get_proto_info() without passthru. */ 615 { 616 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 617 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 618 } 619 620 /* For cros_ec_get_proto_info_legacy(). */ 621 { 622 mock = cros_kunit_ec_xfer_mock_addx(test, -EIO, EC_RES_SUCCESS, 0); 623 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 624 } 625 626 cros_ec_proto_test_query_all_pretest(test); 627 ret = cros_ec_query_all(ec_dev); 628 KUNIT_EXPECT_EQ(test, ret, -EIO); 629 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN); 630 631 /* For cros_ec_get_proto_info() without passthru. */ 632 { 633 mock = cros_kunit_ec_xfer_mock_next(); 634 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 635 636 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 637 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 638 KUNIT_EXPECT_EQ(test, mock->msg.insize, 639 sizeof(struct ec_response_get_protocol_info)); 640 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 641 } 642 643 /* For cros_ec_get_proto_info_legacy(). */ 644 { 645 mock = cros_kunit_ec_xfer_mock_next(); 646 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 647 648 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 649 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO); 650 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello)); 651 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello)); 652 } 653 } 654 655 static void cros_ec_proto_test_query_all_legacy_return_error(struct kunit *test) 656 { 657 struct cros_ec_proto_test_priv *priv = test->priv; 658 struct cros_ec_device *ec_dev = &priv->ec_dev; 659 struct ec_xfer_mock *mock; 660 int ret; 661 662 /* For cros_ec_get_proto_info() without passthru. */ 663 { 664 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 665 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 666 } 667 668 /* For cros_ec_get_proto_info_legacy(). */ 669 { 670 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 671 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 672 } 673 674 cros_ec_proto_test_query_all_pretest(test); 675 ret = cros_ec_query_all(ec_dev); 676 KUNIT_EXPECT_EQ(test, ret, -EOPNOTSUPP); 677 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN); 678 679 /* For cros_ec_get_proto_info() without passthru. */ 680 { 681 mock = cros_kunit_ec_xfer_mock_next(); 682 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 683 684 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 685 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 686 KUNIT_EXPECT_EQ(test, mock->msg.insize, 687 sizeof(struct ec_response_get_protocol_info)); 688 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 689 } 690 691 /* For cros_ec_get_proto_info_legacy(). */ 692 { 693 mock = cros_kunit_ec_xfer_mock_next(); 694 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 695 696 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 697 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO); 698 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello)); 699 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello)); 700 } 701 } 702 703 static void cros_ec_proto_test_query_all_legacy_data_error(struct kunit *test) 704 { 705 struct cros_ec_proto_test_priv *priv = test->priv; 706 struct cros_ec_device *ec_dev = &priv->ec_dev; 707 struct ec_xfer_mock *mock; 708 int ret; 709 710 /* For cros_ec_get_proto_info() without passthru. */ 711 { 712 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 713 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 714 } 715 716 /* For cros_ec_get_proto_info_legacy(). */ 717 { 718 struct ec_response_hello *data; 719 720 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 721 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 722 723 data = (struct ec_response_hello *)mock->o_data; 724 data->out_data = 0xbeefbfbf; 725 } 726 727 cros_ec_proto_test_query_all_pretest(test); 728 ret = cros_ec_query_all(ec_dev); 729 KUNIT_EXPECT_EQ(test, ret, -EBADMSG); 730 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN); 731 732 /* For cros_ec_get_proto_info() without passthru. */ 733 { 734 mock = cros_kunit_ec_xfer_mock_next(); 735 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 736 737 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 738 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 739 KUNIT_EXPECT_EQ(test, mock->msg.insize, 740 sizeof(struct ec_response_get_protocol_info)); 741 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 742 } 743 744 /* For cros_ec_get_proto_info_legacy(). */ 745 { 746 mock = cros_kunit_ec_xfer_mock_next(); 747 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 748 749 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 750 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO); 751 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello)); 752 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello)); 753 } 754 } 755 756 static void cros_ec_proto_test_query_all_legacy_return0(struct kunit *test) 757 { 758 struct cros_ec_proto_test_priv *priv = test->priv; 759 struct cros_ec_device *ec_dev = &priv->ec_dev; 760 struct ec_xfer_mock *mock; 761 int ret; 762 763 /* For cros_ec_get_proto_info() without passthru. */ 764 { 765 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 766 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 767 } 768 769 /* For cros_ec_get_proto_info_legacy(). */ 770 { 771 mock = cros_kunit_ec_xfer_mock_add(test, 0); 772 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 773 } 774 775 cros_ec_proto_test_query_all_pretest(test); 776 ret = cros_ec_query_all(ec_dev); 777 KUNIT_EXPECT_EQ(test, ret, -EPROTO); 778 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN); 779 780 /* For cros_ec_get_proto_info() without passthru. */ 781 { 782 mock = cros_kunit_ec_xfer_mock_next(); 783 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 784 785 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 786 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 787 KUNIT_EXPECT_EQ(test, mock->msg.insize, 788 sizeof(struct ec_response_get_protocol_info)); 789 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 790 } 791 792 /* For cros_ec_get_proto_info_legacy(). */ 793 { 794 mock = cros_kunit_ec_xfer_mock_next(); 795 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 796 797 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 798 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO); 799 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello)); 800 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello)); 801 } 802 } 803 804 static void cros_ec_proto_test_query_all_no_mkbp(struct kunit *test) 805 { 806 struct cros_ec_proto_test_priv *priv = test->priv; 807 struct cros_ec_device *ec_dev = &priv->ec_dev; 808 struct ec_xfer_mock *mock; 809 int ret; 810 811 /* Set some garbage bytes. */ 812 ec_dev->mkbp_event_supported = 0xbf; 813 814 /* For cros_ec_get_proto_info() without passthru. */ 815 { 816 struct ec_response_get_protocol_info *data; 817 818 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 819 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 820 821 /* 822 * Although it doesn't check the value, provides valid sizes so that 823 * cros_ec_query_all() allocates din and dout correctly. 824 */ 825 data = (struct ec_response_get_protocol_info *)mock->o_data; 826 data->max_request_packet_size = 0xbe; 827 data->max_response_packet_size = 0xef; 828 } 829 830 /* For cros_ec_get_proto_info() with passthru. */ 831 { 832 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 833 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 834 } 835 836 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 837 { 838 struct ec_response_get_cmd_versions *data; 839 840 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 841 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 842 843 data = (struct ec_response_get_cmd_versions *)mock->o_data; 844 data->version_mask = 0; 845 } 846 847 cros_ec_proto_test_query_all_pretest(test); 848 ret = cros_ec_query_all(ec_dev); 849 KUNIT_EXPECT_EQ(test, ret, 0); 850 851 /* For cros_ec_get_proto_info() without passthru. */ 852 { 853 mock = cros_kunit_ec_xfer_mock_next(); 854 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 855 856 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 857 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 858 KUNIT_EXPECT_EQ(test, mock->msg.insize, 859 sizeof(struct ec_response_get_protocol_info)); 860 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 861 } 862 863 /* For cros_ec_get_proto_info() with passthru. */ 864 { 865 mock = cros_kunit_ec_xfer_mock_next(); 866 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 867 868 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 869 KUNIT_EXPECT_EQ(test, mock->msg.command, 870 EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) | 871 EC_CMD_GET_PROTOCOL_INFO); 872 KUNIT_EXPECT_EQ(test, mock->msg.insize, 873 sizeof(struct ec_response_get_protocol_info)); 874 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 875 } 876 877 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 878 { 879 struct ec_params_get_cmd_versions *data; 880 881 mock = cros_kunit_ec_xfer_mock_next(); 882 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 883 884 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 885 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 886 KUNIT_EXPECT_EQ(test, mock->msg.insize, 887 sizeof(struct ec_response_get_cmd_versions)); 888 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 889 890 data = (struct ec_params_get_cmd_versions *)mock->i_data; 891 KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT); 892 893 KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0); 894 } 895 } 896 897 static void cros_ec_proto_test_query_all_no_mkbp_return_error(struct kunit *test) 898 { 899 struct cros_ec_proto_test_priv *priv = test->priv; 900 struct cros_ec_device *ec_dev = &priv->ec_dev; 901 struct ec_xfer_mock *mock; 902 int ret; 903 904 /* Set some garbage bytes. */ 905 ec_dev->mkbp_event_supported = 0xbf; 906 907 /* For cros_ec_get_proto_info() without passthru. */ 908 { 909 struct ec_response_get_protocol_info *data; 910 911 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 912 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 913 914 /* 915 * Although it doesn't check the value, provides valid sizes so that 916 * cros_ec_query_all() allocates din and dout correctly. 917 */ 918 data = (struct ec_response_get_protocol_info *)mock->o_data; 919 data->max_request_packet_size = 0xbe; 920 data->max_response_packet_size = 0xef; 921 } 922 923 /* For cros_ec_get_proto_info() with passthru. */ 924 { 925 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 926 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 927 } 928 929 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 930 { 931 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 932 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 933 } 934 935 cros_ec_proto_test_query_all_pretest(test); 936 ret = cros_ec_query_all(ec_dev); 937 KUNIT_EXPECT_EQ(test, ret, 0); 938 939 /* For cros_ec_get_proto_info() without passthru. */ 940 { 941 mock = cros_kunit_ec_xfer_mock_next(); 942 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 943 944 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 945 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 946 KUNIT_EXPECT_EQ(test, mock->msg.insize, 947 sizeof(struct ec_response_get_protocol_info)); 948 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 949 } 950 951 /* For cros_ec_get_proto_info() with passthru. */ 952 { 953 mock = cros_kunit_ec_xfer_mock_next(); 954 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 955 956 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 957 KUNIT_EXPECT_EQ(test, mock->msg.command, 958 EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) | 959 EC_CMD_GET_PROTOCOL_INFO); 960 KUNIT_EXPECT_EQ(test, mock->msg.insize, 961 sizeof(struct ec_response_get_protocol_info)); 962 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 963 } 964 965 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 966 { 967 struct ec_params_get_cmd_versions *data; 968 969 mock = cros_kunit_ec_xfer_mock_next(); 970 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 971 972 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 973 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 974 KUNIT_EXPECT_EQ(test, mock->msg.insize, 975 sizeof(struct ec_response_get_cmd_versions)); 976 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 977 978 data = (struct ec_params_get_cmd_versions *)mock->i_data; 979 KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT); 980 981 KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0); 982 } 983 } 984 985 static void cros_ec_proto_test_query_all_no_mkbp_return0(struct kunit *test) 986 { 987 struct cros_ec_proto_test_priv *priv = test->priv; 988 struct cros_ec_device *ec_dev = &priv->ec_dev; 989 struct ec_xfer_mock *mock; 990 int ret; 991 992 /* Set some garbage bytes. */ 993 ec_dev->mkbp_event_supported = 0xbf; 994 995 /* For cros_ec_get_proto_info() without passthru. */ 996 { 997 struct ec_response_get_protocol_info *data; 998 999 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1000 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1001 1002 /* 1003 * Although it doesn't check the value, provides valid sizes so that 1004 * cros_ec_query_all() allocates din and dout correctly. 1005 */ 1006 data = (struct ec_response_get_protocol_info *)mock->o_data; 1007 data->max_request_packet_size = 0xbe; 1008 data->max_response_packet_size = 0xef; 1009 } 1010 1011 /* For cros_ec_get_proto_info() with passthru. */ 1012 { 1013 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 1014 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1015 } 1016 1017 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 1018 { 1019 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1020 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1021 } 1022 1023 cros_ec_proto_test_query_all_pretest(test); 1024 ret = cros_ec_query_all(ec_dev); 1025 KUNIT_EXPECT_EQ(test, ret, 0); 1026 1027 /* For cros_ec_get_proto_info() without passthru. */ 1028 { 1029 mock = cros_kunit_ec_xfer_mock_next(); 1030 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1031 1032 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1033 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 1034 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1035 sizeof(struct ec_response_get_protocol_info)); 1036 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1037 } 1038 1039 /* For cros_ec_get_proto_info() with passthru. */ 1040 { 1041 mock = cros_kunit_ec_xfer_mock_next(); 1042 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1043 1044 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1045 KUNIT_EXPECT_EQ(test, mock->msg.command, 1046 EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) | 1047 EC_CMD_GET_PROTOCOL_INFO); 1048 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1049 sizeof(struct ec_response_get_protocol_info)); 1050 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1051 } 1052 1053 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 1054 { 1055 struct ec_params_get_cmd_versions *data; 1056 1057 mock = cros_kunit_ec_xfer_mock_next(); 1058 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1059 1060 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1061 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 1062 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1063 sizeof(struct ec_response_get_cmd_versions)); 1064 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 1065 1066 data = (struct ec_params_get_cmd_versions *)mock->i_data; 1067 KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT); 1068 1069 KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0); 1070 } 1071 } 1072 1073 static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test) 1074 { 1075 struct cros_ec_proto_test_priv *priv = test->priv; 1076 struct cros_ec_device *ec_dev = &priv->ec_dev; 1077 struct ec_xfer_mock *mock; 1078 int ret; 1079 1080 /* Set some garbage bytes. */ 1081 ec_dev->host_sleep_v1 = true; 1082 1083 /* For cros_ec_get_proto_info() without passthru. */ 1084 { 1085 struct ec_response_get_protocol_info *data; 1086 1087 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1088 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1089 1090 /* 1091 * Although it doesn't check the value, provides valid sizes so that 1092 * cros_ec_query_all() allocates din and dout correctly. 1093 */ 1094 data = (struct ec_response_get_protocol_info *)mock->o_data; 1095 data->max_request_packet_size = 0xbe; 1096 data->max_response_packet_size = 0xef; 1097 } 1098 1099 /* For cros_ec_get_proto_info() with passthru. */ 1100 { 1101 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 1102 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1103 } 1104 1105 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 1106 { 1107 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1108 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1109 } 1110 1111 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */ 1112 { 1113 struct ec_response_get_cmd_versions *data; 1114 1115 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1116 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1117 1118 data = (struct ec_response_get_cmd_versions *)mock->o_data; 1119 data->version_mask = 0; 1120 } 1121 1122 cros_ec_proto_test_query_all_pretest(test); 1123 ret = cros_ec_query_all(ec_dev); 1124 KUNIT_EXPECT_EQ(test, ret, 0); 1125 1126 /* For cros_ec_get_proto_info() without passthru. */ 1127 { 1128 mock = cros_kunit_ec_xfer_mock_next(); 1129 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1130 1131 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1132 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 1133 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1134 sizeof(struct ec_response_get_protocol_info)); 1135 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1136 } 1137 1138 /* For cros_ec_get_proto_info() with passthru. */ 1139 { 1140 mock = cros_kunit_ec_xfer_mock_next(); 1141 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1142 1143 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1144 KUNIT_EXPECT_EQ(test, mock->msg.command, 1145 EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) | 1146 EC_CMD_GET_PROTOCOL_INFO); 1147 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1148 sizeof(struct ec_response_get_protocol_info)); 1149 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1150 } 1151 1152 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 1153 { 1154 mock = cros_kunit_ec_xfer_mock_next(); 1155 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1156 1157 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1158 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 1159 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1160 sizeof(struct ec_response_get_cmd_versions)); 1161 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions)); 1162 } 1163 1164 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */ 1165 { 1166 mock = cros_kunit_ec_xfer_mock_next(); 1167 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1168 1169 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1170 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 1171 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1172 sizeof(struct ec_response_get_cmd_versions)); 1173 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions)); 1174 1175 KUNIT_EXPECT_FALSE(test, ec_dev->host_sleep_v1); 1176 } 1177 } 1178 1179 static void cros_ec_proto_test_query_all_no_host_sleep_return0(struct kunit *test) 1180 { 1181 struct cros_ec_proto_test_priv *priv = test->priv; 1182 struct cros_ec_device *ec_dev = &priv->ec_dev; 1183 struct ec_xfer_mock *mock; 1184 int ret; 1185 1186 /* Set some garbage bytes. */ 1187 ec_dev->host_sleep_v1 = true; 1188 1189 /* For cros_ec_get_proto_info() without passthru. */ 1190 { 1191 struct ec_response_get_protocol_info *data; 1192 1193 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1194 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1195 1196 /* 1197 * Although it doesn't check the value, provides valid sizes so that 1198 * cros_ec_query_all() allocates din and dout correctly. 1199 */ 1200 data = (struct ec_response_get_protocol_info *)mock->o_data; 1201 data->max_request_packet_size = 0xbe; 1202 data->max_response_packet_size = 0xef; 1203 } 1204 1205 /* For cros_ec_get_proto_info() with passthru. */ 1206 { 1207 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 1208 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1209 } 1210 1211 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 1212 { 1213 struct ec_response_get_cmd_versions *data; 1214 1215 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1216 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1217 1218 /* In order to pollute next cros_ec_get_host_command_version_mask(). */ 1219 data = (struct ec_response_get_cmd_versions *)mock->o_data; 1220 data->version_mask = 0xbeef; 1221 } 1222 1223 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */ 1224 { 1225 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1226 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1227 } 1228 1229 cros_ec_proto_test_query_all_pretest(test); 1230 ret = cros_ec_query_all(ec_dev); 1231 KUNIT_EXPECT_EQ(test, ret, 0); 1232 1233 /* For cros_ec_get_proto_info() without passthru. */ 1234 { 1235 mock = cros_kunit_ec_xfer_mock_next(); 1236 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1237 1238 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1239 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 1240 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1241 sizeof(struct ec_response_get_protocol_info)); 1242 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1243 } 1244 1245 /* For cros_ec_get_proto_info() with passthru. */ 1246 { 1247 mock = cros_kunit_ec_xfer_mock_next(); 1248 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1249 1250 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1251 KUNIT_EXPECT_EQ(test, mock->msg.command, 1252 EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) | 1253 EC_CMD_GET_PROTOCOL_INFO); 1254 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1255 sizeof(struct ec_response_get_protocol_info)); 1256 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1257 } 1258 1259 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 1260 { 1261 mock = cros_kunit_ec_xfer_mock_next(); 1262 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1263 1264 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1265 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 1266 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1267 sizeof(struct ec_response_get_cmd_versions)); 1268 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions)); 1269 } 1270 1271 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */ 1272 { 1273 mock = cros_kunit_ec_xfer_mock_next(); 1274 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1275 1276 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1277 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 1278 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1279 sizeof(struct ec_response_get_cmd_versions)); 1280 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions)); 1281 1282 KUNIT_EXPECT_FALSE(test, ec_dev->host_sleep_v1); 1283 } 1284 } 1285 1286 static void cros_ec_proto_test_query_all_default_wake_mask_return_error(struct kunit *test) 1287 { 1288 struct cros_ec_proto_test_priv *priv = test->priv; 1289 struct cros_ec_device *ec_dev = &priv->ec_dev; 1290 struct ec_xfer_mock *mock; 1291 int ret; 1292 1293 /* Set some garbage bytes. */ 1294 ec_dev->host_event_wake_mask = U32_MAX; 1295 1296 /* For cros_ec_get_proto_info() without passthru. */ 1297 { 1298 struct ec_response_get_protocol_info *data; 1299 1300 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1301 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1302 1303 /* 1304 * Although it doesn't check the value, provides valid sizes so that 1305 * cros_ec_query_all() allocates din and dout correctly. 1306 */ 1307 data = (struct ec_response_get_protocol_info *)mock->o_data; 1308 data->max_request_packet_size = 0xbe; 1309 data->max_response_packet_size = 0xef; 1310 } 1311 1312 /* For cros_ec_get_proto_info() with passthru. */ 1313 { 1314 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 1315 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1316 } 1317 1318 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 1319 { 1320 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1321 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1322 } 1323 1324 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */ 1325 { 1326 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1327 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1328 } 1329 1330 /* For cros_ec_get_host_event_wake_mask(). */ 1331 { 1332 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 1333 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1334 } 1335 1336 cros_ec_proto_test_query_all_pretest(test); 1337 ret = cros_ec_query_all(ec_dev); 1338 KUNIT_EXPECT_EQ(test, ret, 0); 1339 1340 /* For cros_ec_get_proto_info() without passthru. */ 1341 { 1342 mock = cros_kunit_ec_xfer_mock_next(); 1343 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1344 1345 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1346 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 1347 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1348 sizeof(struct ec_response_get_protocol_info)); 1349 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1350 } 1351 1352 /* For cros_ec_get_proto_info() with passthru. */ 1353 { 1354 mock = cros_kunit_ec_xfer_mock_next(); 1355 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1356 1357 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1358 KUNIT_EXPECT_EQ(test, mock->msg.command, 1359 EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) | 1360 EC_CMD_GET_PROTOCOL_INFO); 1361 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1362 sizeof(struct ec_response_get_protocol_info)); 1363 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1364 } 1365 1366 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 1367 { 1368 mock = cros_kunit_ec_xfer_mock_next(); 1369 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1370 1371 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1372 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 1373 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1374 sizeof(struct ec_response_get_cmd_versions)); 1375 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions)); 1376 } 1377 1378 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */ 1379 { 1380 mock = cros_kunit_ec_xfer_mock_next(); 1381 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1382 1383 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1384 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 1385 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1386 sizeof(struct ec_response_get_cmd_versions)); 1387 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions)); 1388 } 1389 1390 /* For cros_ec_get_host_event_wake_mask(). */ 1391 { 1392 u32 mask; 1393 1394 mock = cros_kunit_ec_xfer_mock_next(); 1395 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1396 1397 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1398 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK); 1399 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask)); 1400 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1401 1402 mask = ec_dev->host_event_wake_mask; 1403 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED), 0); 1404 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED), 0); 1405 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_LOW), 0); 1406 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_CRITICAL), 0); 1407 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY), 0); 1408 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_PD_MCU), 0); 1409 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_STATUS), 0); 1410 } 1411 } 1412 1413 static void cros_ec_proto_test_query_all_default_wake_mask_return0(struct kunit *test) 1414 { 1415 struct cros_ec_proto_test_priv *priv = test->priv; 1416 struct cros_ec_device *ec_dev = &priv->ec_dev; 1417 struct ec_xfer_mock *mock; 1418 int ret; 1419 1420 /* Set some garbage bytes. */ 1421 ec_dev->host_event_wake_mask = U32_MAX; 1422 1423 /* For cros_ec_get_proto_info() without passthru. */ 1424 { 1425 struct ec_response_get_protocol_info *data; 1426 1427 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1428 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1429 1430 /* 1431 * Although it doesn't check the value, provides valid sizes so that 1432 * cros_ec_query_all() allocates din and dout correctly. 1433 */ 1434 data = (struct ec_response_get_protocol_info *)mock->o_data; 1435 data->max_request_packet_size = 0xbe; 1436 data->max_response_packet_size = 0xef; 1437 } 1438 1439 /* For cros_ec_get_proto_info() with passthru. */ 1440 { 1441 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 1442 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1443 } 1444 1445 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 1446 { 1447 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1448 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1449 } 1450 1451 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */ 1452 { 1453 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1454 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1455 } 1456 1457 /* For get_host_event_wake_mask(). */ 1458 { 1459 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1460 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1461 } 1462 1463 cros_ec_proto_test_query_all_pretest(test); 1464 ret = cros_ec_query_all(ec_dev); 1465 KUNIT_EXPECT_EQ(test, ret, 0); 1466 1467 /* For cros_ec_get_proto_info() without passthru. */ 1468 { 1469 mock = cros_kunit_ec_xfer_mock_next(); 1470 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1471 1472 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1473 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO); 1474 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1475 sizeof(struct ec_response_get_protocol_info)); 1476 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1477 } 1478 1479 /* For cros_ec_get_proto_info() with passthru. */ 1480 { 1481 mock = cros_kunit_ec_xfer_mock_next(); 1482 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1483 1484 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1485 KUNIT_EXPECT_EQ(test, mock->msg.command, 1486 EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) | 1487 EC_CMD_GET_PROTOCOL_INFO); 1488 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1489 sizeof(struct ec_response_get_protocol_info)); 1490 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1491 } 1492 1493 /* For cros_ec_get_host_command_version_mask() for MKBP. */ 1494 { 1495 mock = cros_kunit_ec_xfer_mock_next(); 1496 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1497 1498 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1499 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 1500 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1501 sizeof(struct ec_response_get_cmd_versions)); 1502 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions)); 1503 } 1504 1505 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */ 1506 { 1507 mock = cros_kunit_ec_xfer_mock_next(); 1508 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1509 1510 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1511 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS); 1512 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1513 sizeof(struct ec_response_get_cmd_versions)); 1514 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions)); 1515 } 1516 1517 /* For get_host_event_wake_mask(). */ 1518 { 1519 u32 mask; 1520 1521 mock = cros_kunit_ec_xfer_mock_next(); 1522 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1523 1524 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1525 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK); 1526 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask)); 1527 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1528 1529 mask = ec_dev->host_event_wake_mask; 1530 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED), 0); 1531 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED), 0); 1532 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_LOW), 0); 1533 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_CRITICAL), 0); 1534 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY), 0); 1535 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_PD_MCU), 0); 1536 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_STATUS), 0); 1537 } 1538 } 1539 1540 static void cros_ec_proto_test_cmd_xfer_normal(struct kunit *test) 1541 { 1542 struct cros_ec_proto_test_priv *priv = test->priv; 1543 struct cros_ec_device *ec_dev = &priv->ec_dev; 1544 struct ec_xfer_mock *mock; 1545 int ret; 1546 DEFINE_RAW_FLEX(struct cros_ec_command, buf, data, 0x100); 1547 1548 ec_dev->max_request = 0xff; 1549 ec_dev->max_response = 0xee; 1550 ec_dev->max_passthru = 0xdd; 1551 1552 buf->version = 0; 1553 buf->command = EC_CMD_HELLO; 1554 buf->insize = 4; 1555 buf->outsize = 2; 1556 buf->data[0] = 0x55; 1557 buf->data[1] = 0xaa; 1558 1559 { 1560 u8 *data; 1561 1562 mock = cros_kunit_ec_xfer_mock_add(test, 4); 1563 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1564 1565 data = (u8 *)mock->o_data; 1566 data[0] = 0xaa; 1567 data[1] = 0x55; 1568 data[2] = 0xcc; 1569 data[3] = 0x33; 1570 } 1571 1572 ret = cros_ec_cmd_xfer(ec_dev, buf); 1573 KUNIT_EXPECT_EQ(test, ret, 4); 1574 1575 { 1576 u8 *data; 1577 1578 mock = cros_kunit_ec_xfer_mock_next(); 1579 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1580 1581 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1582 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO); 1583 KUNIT_EXPECT_EQ(test, mock->msg.insize, 4); 1584 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 2); 1585 1586 data = (u8 *)mock->i_data; 1587 KUNIT_EXPECT_EQ(test, data[0], 0x55); 1588 KUNIT_EXPECT_EQ(test, data[1], 0xaa); 1589 1590 KUNIT_EXPECT_EQ(test, buf->data[0], 0xaa); 1591 KUNIT_EXPECT_EQ(test, buf->data[1], 0x55); 1592 KUNIT_EXPECT_EQ(test, buf->data[2], 0xcc); 1593 KUNIT_EXPECT_EQ(test, buf->data[3], 0x33); 1594 } 1595 } 1596 1597 static void cros_ec_proto_test_cmd_xfer_excess_msg_insize(struct kunit *test) 1598 { 1599 struct cros_ec_proto_test_priv *priv = test->priv; 1600 struct cros_ec_device *ec_dev = &priv->ec_dev; 1601 struct ec_xfer_mock *mock; 1602 int ret; 1603 DEFINE_RAW_FLEX(struct cros_ec_command, buf, data, 0x100); 1604 1605 ec_dev->max_request = 0xff; 1606 ec_dev->max_response = 0xee; 1607 ec_dev->max_passthru = 0xdd; 1608 1609 buf->version = 0; 1610 buf->command = EC_CMD_HELLO; 1611 buf->insize = 0xee + 1; 1612 buf->outsize = 2; 1613 1614 { 1615 mock = cros_kunit_ec_xfer_mock_add(test, 0xcc); 1616 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1617 } 1618 1619 ret = cros_ec_cmd_xfer(ec_dev, buf); 1620 KUNIT_EXPECT_EQ(test, ret, 0xcc); 1621 1622 { 1623 mock = cros_kunit_ec_xfer_mock_next(); 1624 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1625 1626 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1627 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO); 1628 KUNIT_EXPECT_EQ(test, mock->msg.insize, 0xee); 1629 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 2); 1630 } 1631 } 1632 1633 static void cros_ec_proto_test_cmd_xfer_excess_msg_outsize_without_passthru(struct kunit *test) 1634 { 1635 struct cros_ec_proto_test_priv *priv = test->priv; 1636 struct cros_ec_device *ec_dev = &priv->ec_dev; 1637 int ret; 1638 DEFINE_RAW_FLEX(struct cros_ec_command, buf, data, 0x100); 1639 1640 ec_dev->max_request = 0xff; 1641 ec_dev->max_response = 0xee; 1642 ec_dev->max_passthru = 0xdd; 1643 1644 buf->version = 0; 1645 buf->command = EC_CMD_HELLO; 1646 buf->insize = 4; 1647 buf->outsize = 0xff + 1; 1648 1649 ret = cros_ec_cmd_xfer(ec_dev, buf); 1650 KUNIT_EXPECT_EQ(test, ret, -EMSGSIZE); 1651 } 1652 1653 static void cros_ec_proto_test_cmd_xfer_excess_msg_outsize_with_passthru(struct kunit *test) 1654 { 1655 struct cros_ec_proto_test_priv *priv = test->priv; 1656 struct cros_ec_device *ec_dev = &priv->ec_dev; 1657 int ret; 1658 DEFINE_RAW_FLEX(struct cros_ec_command, buf, data, 0x100); 1659 1660 ec_dev->max_request = 0xff; 1661 ec_dev->max_response = 0xee; 1662 ec_dev->max_passthru = 0xdd; 1663 1664 buf->version = 0; 1665 buf->command = EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) + EC_CMD_HELLO; 1666 buf->insize = 4; 1667 buf->outsize = 0xdd + 1; 1668 1669 ret = cros_ec_cmd_xfer(ec_dev, buf); 1670 KUNIT_EXPECT_EQ(test, ret, -EMSGSIZE); 1671 } 1672 1673 static void cros_ec_proto_test_cmd_xfer_protocol_v3_normal(struct kunit *test) 1674 { 1675 struct cros_ec_proto_test_priv *priv = test->priv; 1676 struct cros_ec_device *ec_dev = &priv->ec_dev; 1677 int ret; 1678 struct cros_ec_command msg; 1679 1680 memset(&msg, 0, sizeof(msg)); 1681 1682 ec_dev->proto_version = 3; 1683 ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock; 1684 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1685 1686 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1687 KUNIT_EXPECT_EQ(test, ret, 0); 1688 1689 KUNIT_EXPECT_EQ(test, cros_kunit_ec_cmd_xfer_mock_called, 0); 1690 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 1); 1691 } 1692 1693 static void cros_ec_proto_test_cmd_xfer_protocol_v3_no_op(struct kunit *test) 1694 { 1695 struct cros_ec_proto_test_priv *priv = test->priv; 1696 struct cros_ec_device *ec_dev = &priv->ec_dev; 1697 int ret; 1698 struct cros_ec_command msg; 1699 1700 memset(&msg, 0, sizeof(msg)); 1701 1702 ec_dev->proto_version = 3; 1703 ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock; 1704 ec_dev->pkt_xfer = NULL; 1705 1706 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1707 KUNIT_EXPECT_EQ(test, ret, -EIO); 1708 } 1709 1710 static void cros_ec_proto_test_cmd_xfer_protocol_v2_normal(struct kunit *test) 1711 { 1712 struct cros_ec_proto_test_priv *priv = test->priv; 1713 struct cros_ec_device *ec_dev = &priv->ec_dev; 1714 int ret; 1715 struct cros_ec_command msg; 1716 1717 memset(&msg, 0, sizeof(msg)); 1718 1719 ec_dev->proto_version = 2; 1720 ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock; 1721 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1722 1723 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1724 KUNIT_EXPECT_EQ(test, ret, 0); 1725 1726 KUNIT_EXPECT_EQ(test, cros_kunit_ec_cmd_xfer_mock_called, 1); 1727 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 0); 1728 } 1729 1730 static void cros_ec_proto_test_cmd_xfer_protocol_v2_no_op(struct kunit *test) 1731 { 1732 struct cros_ec_proto_test_priv *priv = test->priv; 1733 struct cros_ec_device *ec_dev = &priv->ec_dev; 1734 int ret; 1735 struct cros_ec_command msg; 1736 1737 memset(&msg, 0, sizeof(msg)); 1738 1739 ec_dev->proto_version = 2; 1740 ec_dev->cmd_xfer = NULL; 1741 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1742 1743 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1744 KUNIT_EXPECT_EQ(test, ret, -EIO); 1745 } 1746 1747 static void cros_ec_proto_test_cmd_xfer_in_progress_normal(struct kunit *test) 1748 { 1749 struct cros_ec_proto_test_priv *priv = test->priv; 1750 struct cros_ec_device *ec_dev = &priv->ec_dev; 1751 struct ec_xfer_mock *mock; 1752 int ret; 1753 struct cros_ec_command msg; 1754 1755 memset(&msg, 0, sizeof(msg)); 1756 1757 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1758 1759 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1760 { 1761 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1762 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1763 } 1764 1765 /* For EC_CMD_GET_COMMS_STATUS. */ 1766 { 1767 struct ec_response_get_comms_status *data; 1768 1769 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1770 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1771 1772 data = (struct ec_response_get_comms_status *)mock->o_data; 1773 data->flags = 0; 1774 } 1775 1776 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1777 KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_comms_status)); 1778 1779 KUNIT_EXPECT_EQ(test, msg.result, EC_RES_SUCCESS); 1780 1781 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1782 { 1783 mock = cros_kunit_ec_xfer_mock_next(); 1784 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1785 } 1786 1787 /* For EC_CMD_GET_COMMS_STATUS. */ 1788 { 1789 mock = cros_kunit_ec_xfer_mock_next(); 1790 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1791 1792 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1793 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_COMMS_STATUS); 1794 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1795 sizeof(struct ec_response_get_comms_status)); 1796 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1797 } 1798 1799 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2); 1800 } 1801 1802 static void cros_ec_proto_test_cmd_xfer_in_progress_retries_eagain(struct kunit *test) 1803 { 1804 struct cros_ec_proto_test_priv *priv = test->priv; 1805 struct cros_ec_device *ec_dev = &priv->ec_dev; 1806 struct ec_xfer_mock *mock; 1807 int ret; 1808 struct cros_ec_command msg; 1809 1810 memset(&msg, 0, sizeof(msg)); 1811 1812 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1813 1814 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1815 { 1816 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1817 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1818 } 1819 1820 /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */ 1821 cros_kunit_ec_xfer_mock_default_ret = -EAGAIN; 1822 1823 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1824 KUNIT_EXPECT_EQ(test, ret, -EAGAIN); 1825 1826 /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */ 1827 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 51); 1828 } 1829 1830 static void cros_ec_proto_test_cmd_xfer_in_progress_retries_status_processing(struct kunit *test) 1831 { 1832 struct cros_ec_proto_test_priv *priv = test->priv; 1833 struct cros_ec_device *ec_dev = &priv->ec_dev; 1834 struct ec_xfer_mock *mock; 1835 int ret; 1836 struct cros_ec_command msg; 1837 1838 memset(&msg, 0, sizeof(msg)); 1839 1840 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1841 1842 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1843 { 1844 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1845 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1846 } 1847 1848 /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */ 1849 { 1850 struct ec_response_get_comms_status *data; 1851 int i; 1852 1853 for (i = 0; i < 50; ++i) { 1854 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1855 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1856 1857 data = (struct ec_response_get_comms_status *)mock->o_data; 1858 data->flags |= EC_COMMS_STATUS_PROCESSING; 1859 } 1860 } 1861 1862 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1863 KUNIT_EXPECT_EQ(test, ret, -EAGAIN); 1864 1865 /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */ 1866 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 51); 1867 } 1868 1869 static void cros_ec_proto_test_cmd_xfer_in_progress_xfer_error(struct kunit *test) 1870 { 1871 struct cros_ec_proto_test_priv *priv = test->priv; 1872 struct cros_ec_device *ec_dev = &priv->ec_dev; 1873 struct ec_xfer_mock *mock; 1874 int ret; 1875 struct cros_ec_command msg; 1876 1877 memset(&msg, 0, sizeof(msg)); 1878 1879 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1880 { 1881 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1882 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1883 } 1884 1885 /* For EC_CMD_GET_COMMS_STATUS. */ 1886 { 1887 mock = cros_kunit_ec_xfer_mock_addx(test, -EIO, EC_RES_SUCCESS, 0); 1888 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1889 } 1890 1891 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1892 KUNIT_EXPECT_EQ(test, ret, -EIO); 1893 } 1894 1895 static void cros_ec_proto_test_cmd_xfer_in_progress_return_error(struct kunit *test) 1896 { 1897 struct cros_ec_proto_test_priv *priv = test->priv; 1898 struct cros_ec_device *ec_dev = &priv->ec_dev; 1899 struct ec_xfer_mock *mock; 1900 int ret; 1901 struct cros_ec_command msg; 1902 1903 memset(&msg, 0, sizeof(msg)); 1904 1905 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1906 1907 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1908 { 1909 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1910 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1911 } 1912 1913 /* For EC_CMD_GET_COMMS_STATUS. */ 1914 { 1915 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 1916 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1917 } 1918 1919 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1920 KUNIT_EXPECT_EQ(test, ret, 0); 1921 1922 KUNIT_EXPECT_EQ(test, msg.result, EC_RES_INVALID_COMMAND); 1923 1924 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2); 1925 } 1926 1927 static void cros_ec_proto_test_cmd_xfer_in_progress_return0(struct kunit *test) 1928 { 1929 struct cros_ec_proto_test_priv *priv = test->priv; 1930 struct cros_ec_device *ec_dev = &priv->ec_dev; 1931 struct ec_xfer_mock *mock; 1932 int ret; 1933 struct cros_ec_command msg; 1934 1935 memset(&msg, 0, sizeof(msg)); 1936 1937 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1938 1939 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1940 { 1941 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1942 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1943 } 1944 1945 /* For EC_CMD_GET_COMMS_STATUS. */ 1946 { 1947 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1948 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1949 } 1950 1951 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1952 KUNIT_EXPECT_EQ(test, ret, -EPROTO); 1953 1954 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2); 1955 } 1956 1957 static void cros_ec_proto_test_cmd_xfer_status_normal(struct kunit *test) 1958 { 1959 struct cros_ec_proto_test_priv *priv = test->priv; 1960 struct cros_ec_device *ec_dev = &priv->ec_dev; 1961 struct ec_xfer_mock *mock; 1962 int ret; 1963 struct cros_ec_command msg; 1964 1965 memset(&msg, 0, sizeof(msg)); 1966 1967 /* For cros_ec_cmd_xfer(). */ 1968 { 1969 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1970 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1971 } 1972 1973 ret = cros_ec_cmd_xfer_status(ec_dev, &msg); 1974 KUNIT_EXPECT_EQ(test, ret, 0); 1975 } 1976 1977 static void cros_ec_proto_test_cmd_xfer_status_xfer_error(struct kunit *test) 1978 { 1979 struct cros_ec_proto_test_priv *priv = test->priv; 1980 struct cros_ec_device *ec_dev = &priv->ec_dev; 1981 struct ec_xfer_mock *mock; 1982 int ret; 1983 struct cros_ec_command msg; 1984 1985 memset(&msg, 0, sizeof(msg)); 1986 1987 /* For cros_ec_cmd_xfer(). */ 1988 { 1989 mock = cros_kunit_ec_xfer_mock_addx(test, -EPROTO, EC_RES_SUCCESS, 0); 1990 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1991 } 1992 1993 ret = cros_ec_cmd_xfer_status(ec_dev, &msg); 1994 KUNIT_EXPECT_EQ(test, ret, -EPROTO); 1995 } 1996 1997 static void cros_ec_proto_test_cmd_xfer_status_return_error(struct kunit *test) 1998 { 1999 struct cros_ec_proto_test_priv *priv = test->priv; 2000 struct cros_ec_device *ec_dev = &priv->ec_dev; 2001 struct ec_xfer_mock *mock; 2002 int ret, i; 2003 struct cros_ec_command msg; 2004 static const int map[] = { 2005 [EC_RES_SUCCESS] = 0, 2006 [EC_RES_INVALID_COMMAND] = -EOPNOTSUPP, 2007 [EC_RES_ERROR] = -EIO, 2008 [EC_RES_INVALID_PARAM] = -EINVAL, 2009 [EC_RES_ACCESS_DENIED] = -EACCES, 2010 [EC_RES_INVALID_RESPONSE] = -EPROTO, 2011 [EC_RES_INVALID_VERSION] = -ENOPROTOOPT, 2012 [EC_RES_INVALID_CHECKSUM] = -EBADMSG, 2013 /* 2014 * EC_RES_IN_PROGRESS is special because cros_ec_send_command() has extra logic to 2015 * handle it. Note that default cros_kunit_ec_xfer_mock_default_ret == 0 thus 2016 * cros_ec_xfer_command() in cros_ec_wait_until_complete() returns 0. As a result, 2017 * it returns -EPROTO without calling cros_ec_map_error(). 2018 */ 2019 [EC_RES_IN_PROGRESS] = -EPROTO, 2020 [EC_RES_UNAVAILABLE] = -ENODATA, 2021 [EC_RES_TIMEOUT] = -ETIMEDOUT, 2022 [EC_RES_OVERFLOW] = -EOVERFLOW, 2023 [EC_RES_INVALID_HEADER] = -EBADR, 2024 [EC_RES_REQUEST_TRUNCATED] = -EBADR, 2025 [EC_RES_RESPONSE_TOO_BIG] = -EFBIG, 2026 [EC_RES_BUS_ERROR] = -EFAULT, 2027 [EC_RES_BUSY] = -EBUSY, 2028 [EC_RES_INVALID_HEADER_VERSION] = -EBADMSG, 2029 [EC_RES_INVALID_HEADER_CRC] = -EBADMSG, 2030 [EC_RES_INVALID_DATA_CRC] = -EBADMSG, 2031 [EC_RES_DUP_UNAVAILABLE] = -ENODATA, 2032 }; 2033 2034 memset(&msg, 0, sizeof(msg)); 2035 2036 for (i = 0; i < ARRAY_SIZE(map); ++i) { 2037 mock = cros_kunit_ec_xfer_mock_addx(test, 0, i, 0); 2038 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2039 2040 ret = cros_ec_cmd_xfer_status(ec_dev, &msg); 2041 KUNIT_EXPECT_EQ(test, ret, map[i]); 2042 } 2043 } 2044 2045 static void cros_ec_proto_test_get_next_event_no_mkbp_event(struct kunit *test) 2046 { 2047 struct cros_ec_proto_test_priv *priv = test->priv; 2048 struct cros_ec_device *ec_dev = &priv->ec_dev; 2049 struct ec_xfer_mock *mock; 2050 int ret; 2051 bool wake_event, more_events; 2052 2053 ec_dev->max_request = 0xff; 2054 ec_dev->max_response = 0xee; 2055 ec_dev->mkbp_event_supported = 0; 2056 2057 /* Set some garbage bytes. */ 2058 wake_event = false; 2059 more_events = true; 2060 2061 /* For get_keyboard_state_event(). */ 2062 { 2063 union ec_response_get_next_data_v1 *data; 2064 2065 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 2066 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2067 2068 data = (union ec_response_get_next_data_v1 *)mock->o_data; 2069 data->host_event = 0xbeef; 2070 } 2071 2072 ret = cros_ec_get_next_event(ec_dev, &wake_event, &more_events); 2073 KUNIT_EXPECT_EQ(test, ret, sizeof(union ec_response_get_next_data_v1)); 2074 2075 KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_KEY_MATRIX); 2076 KUNIT_EXPECT_EQ(test, ec_dev->event_data.data.host_event, 0xbeef); 2077 2078 KUNIT_EXPECT_TRUE(test, wake_event); 2079 KUNIT_EXPECT_FALSE(test, more_events); 2080 2081 /* For get_keyboard_state_event(). */ 2082 { 2083 mock = cros_kunit_ec_xfer_mock_next(); 2084 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2085 2086 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 2087 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MKBP_STATE); 2088 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(union ec_response_get_next_data_v1)); 2089 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2090 } 2091 } 2092 2093 static void cros_ec_proto_test_get_next_event_mkbp_event_ec_suspended(struct kunit *test) 2094 { 2095 struct cros_ec_proto_test_priv *priv = test->priv; 2096 struct cros_ec_device *ec_dev = &priv->ec_dev; 2097 int ret; 2098 2099 ec_dev->mkbp_event_supported = 1; 2100 ec_dev->suspended = true; 2101 2102 ret = cros_ec_get_next_event(ec_dev, NULL, NULL); 2103 KUNIT_EXPECT_EQ(test, ret, -EHOSTDOWN); 2104 } 2105 2106 static void cros_ec_proto_test_get_next_event_mkbp_event_version0(struct kunit *test) 2107 { 2108 struct cros_ec_proto_test_priv *priv = test->priv; 2109 struct cros_ec_device *ec_dev = &priv->ec_dev; 2110 struct ec_xfer_mock *mock; 2111 int ret; 2112 bool wake_event, more_events; 2113 2114 ec_dev->max_request = 0xff; 2115 ec_dev->max_response = 0xee; 2116 ec_dev->mkbp_event_supported = 1; 2117 2118 /* Set some garbage bytes. */ 2119 wake_event = true; 2120 more_events = false; 2121 2122 /* For get_next_event_xfer(). */ 2123 { 2124 struct ec_response_get_next_event *data; 2125 2126 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 2127 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2128 2129 data = (struct ec_response_get_next_event *)mock->o_data; 2130 data->event_type = EC_MKBP_EVENT_SENSOR_FIFO | EC_MKBP_HAS_MORE_EVENTS; 2131 data->data.sysrq = 0xbeef; 2132 } 2133 2134 ret = cros_ec_get_next_event(ec_dev, &wake_event, &more_events); 2135 KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_next_event)); 2136 2137 KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_SENSOR_FIFO); 2138 KUNIT_EXPECT_EQ(test, ec_dev->event_data.data.sysrq, 0xbeef); 2139 2140 KUNIT_EXPECT_FALSE(test, wake_event); 2141 KUNIT_EXPECT_TRUE(test, more_events); 2142 2143 /* For get_next_event_xfer(). */ 2144 { 2145 mock = cros_kunit_ec_xfer_mock_next(); 2146 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2147 2148 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 2149 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT); 2150 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_get_next_event)); 2151 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2152 } 2153 } 2154 2155 static void cros_ec_proto_test_get_next_event_mkbp_event_version2(struct kunit *test) 2156 { 2157 struct cros_ec_proto_test_priv *priv = test->priv; 2158 struct cros_ec_device *ec_dev = &priv->ec_dev; 2159 struct ec_xfer_mock *mock; 2160 int ret; 2161 bool wake_event, more_events; 2162 2163 ec_dev->max_request = 0xff; 2164 ec_dev->max_response = 0xee; 2165 ec_dev->mkbp_event_supported = 3; 2166 2167 /* Set some garbage bytes. */ 2168 wake_event = false; 2169 more_events = true; 2170 2171 /* For get_next_event_xfer(). */ 2172 { 2173 struct ec_response_get_next_event_v1 *data; 2174 2175 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 2176 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2177 2178 data = (struct ec_response_get_next_event_v1 *)mock->o_data; 2179 data->event_type = EC_MKBP_EVENT_FINGERPRINT; 2180 data->data.sysrq = 0xbeef; 2181 } 2182 2183 ret = cros_ec_get_next_event(ec_dev, &wake_event, &more_events); 2184 KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_next_event_v1)); 2185 2186 KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_FINGERPRINT); 2187 KUNIT_EXPECT_EQ(test, ec_dev->event_data.data.sysrq, 0xbeef); 2188 2189 KUNIT_EXPECT_TRUE(test, wake_event); 2190 KUNIT_EXPECT_FALSE(test, more_events); 2191 2192 /* For get_next_event_xfer(). */ 2193 { 2194 mock = cros_kunit_ec_xfer_mock_next(); 2195 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2196 2197 KUNIT_EXPECT_EQ(test, mock->msg.version, 2); 2198 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT); 2199 KUNIT_EXPECT_EQ(test, mock->msg.insize, 2200 sizeof(struct ec_response_get_next_event_v1)); 2201 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2202 } 2203 } 2204 2205 static void cros_ec_proto_test_get_next_event_mkbp_event_host_event_rtc(struct kunit *test) 2206 { 2207 struct cros_ec_proto_test_priv *priv = test->priv; 2208 struct cros_ec_device *ec_dev = &priv->ec_dev; 2209 struct ec_xfer_mock *mock; 2210 int ret; 2211 bool wake_event; 2212 struct ec_response_get_next_event_v1 *data; 2213 2214 ec_dev->max_request = 0xff; 2215 ec_dev->max_response = 0xee; 2216 ec_dev->mkbp_event_supported = 3; 2217 ec_dev->host_event_wake_mask = U32_MAX; 2218 2219 /* Set some garbage bytes. */ 2220 wake_event = true; 2221 2222 /* For get_next_event_xfer(). */ 2223 { 2224 mock = cros_kunit_ec_xfer_mock_add(test, 2225 sizeof(data->event_type) + 2226 sizeof(data->data.host_event)); 2227 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2228 2229 data = (struct ec_response_get_next_event_v1 *)mock->o_data; 2230 data->event_type = EC_MKBP_EVENT_HOST_EVENT; 2231 put_unaligned_le32(EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC), &data->data.host_event); 2232 } 2233 2234 ret = cros_ec_get_next_event(ec_dev, &wake_event, NULL); 2235 KUNIT_EXPECT_EQ(test, ret, sizeof(data->event_type) + sizeof(data->data.host_event)); 2236 2237 KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_HOST_EVENT); 2238 2239 KUNIT_EXPECT_FALSE(test, wake_event); 2240 2241 /* For get_next_event_xfer(). */ 2242 { 2243 mock = cros_kunit_ec_xfer_mock_next(); 2244 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2245 2246 KUNIT_EXPECT_EQ(test, mock->msg.version, 2); 2247 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT); 2248 KUNIT_EXPECT_EQ(test, mock->msg.insize, 2249 sizeof(struct ec_response_get_next_event_v1)); 2250 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2251 } 2252 } 2253 2254 static void cros_ec_proto_test_get_next_event_mkbp_event_host_event_masked(struct kunit *test) 2255 { 2256 struct cros_ec_proto_test_priv *priv = test->priv; 2257 struct cros_ec_device *ec_dev = &priv->ec_dev; 2258 struct ec_xfer_mock *mock; 2259 int ret; 2260 bool wake_event; 2261 struct ec_response_get_next_event_v1 *data; 2262 2263 ec_dev->max_request = 0xff; 2264 ec_dev->max_response = 0xee; 2265 ec_dev->mkbp_event_supported = 3; 2266 ec_dev->host_event_wake_mask = U32_MAX & ~EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED); 2267 2268 /* Set some garbage bytes. */ 2269 wake_event = true; 2270 2271 /* For get_next_event_xfer(). */ 2272 { 2273 mock = cros_kunit_ec_xfer_mock_add(test, 2274 sizeof(data->event_type) + 2275 sizeof(data->data.host_event)); 2276 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2277 2278 data = (struct ec_response_get_next_event_v1 *)mock->o_data; 2279 data->event_type = EC_MKBP_EVENT_HOST_EVENT; 2280 put_unaligned_le32(EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED), 2281 &data->data.host_event); 2282 } 2283 2284 ret = cros_ec_get_next_event(ec_dev, &wake_event, NULL); 2285 KUNIT_EXPECT_EQ(test, ret, sizeof(data->event_type) + sizeof(data->data.host_event)); 2286 2287 KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_HOST_EVENT); 2288 2289 KUNIT_EXPECT_FALSE(test, wake_event); 2290 2291 /* For get_next_event_xfer(). */ 2292 { 2293 mock = cros_kunit_ec_xfer_mock_next(); 2294 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2295 2296 KUNIT_EXPECT_EQ(test, mock->msg.version, 2); 2297 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT); 2298 KUNIT_EXPECT_EQ(test, mock->msg.insize, 2299 sizeof(struct ec_response_get_next_event_v1)); 2300 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2301 } 2302 } 2303 2304 static void cros_ec_proto_test_get_host_event_no_mkbp_event(struct kunit *test) 2305 { 2306 struct cros_ec_proto_test_priv *priv = test->priv; 2307 struct cros_ec_device *ec_dev = &priv->ec_dev; 2308 int ret; 2309 2310 ec_dev->mkbp_event_supported = 0; 2311 2312 ret = cros_ec_get_host_event(ec_dev); 2313 KUNIT_EXPECT_EQ(test, ret, 0); 2314 } 2315 2316 static void cros_ec_proto_test_get_host_event_not_host_event(struct kunit *test) 2317 { 2318 struct cros_ec_proto_test_priv *priv = test->priv; 2319 struct cros_ec_device *ec_dev = &priv->ec_dev; 2320 int ret; 2321 2322 ec_dev->mkbp_event_supported = 1; 2323 ec_dev->event_data.event_type = EC_MKBP_EVENT_FINGERPRINT; 2324 2325 ret = cros_ec_get_host_event(ec_dev); 2326 KUNIT_EXPECT_EQ(test, ret, 0); 2327 } 2328 2329 static void cros_ec_proto_test_get_host_event_wrong_event_size(struct kunit *test) 2330 { 2331 struct cros_ec_proto_test_priv *priv = test->priv; 2332 struct cros_ec_device *ec_dev = &priv->ec_dev; 2333 int ret; 2334 2335 ec_dev->mkbp_event_supported = 1; 2336 ec_dev->event_data.event_type = EC_MKBP_EVENT_HOST_EVENT; 2337 ec_dev->event_size = 0xff; 2338 2339 ret = cros_ec_get_host_event(ec_dev); 2340 KUNIT_EXPECT_EQ(test, ret, 0); 2341 } 2342 2343 static void cros_ec_proto_test_get_host_event_normal(struct kunit *test) 2344 { 2345 struct cros_ec_proto_test_priv *priv = test->priv; 2346 struct cros_ec_device *ec_dev = &priv->ec_dev; 2347 int ret; 2348 2349 ec_dev->mkbp_event_supported = 1; 2350 ec_dev->event_data.event_type = EC_MKBP_EVENT_HOST_EVENT; 2351 ec_dev->event_size = sizeof(ec_dev->event_data.data.host_event); 2352 put_unaligned_le32(EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC), 2353 &ec_dev->event_data.data.host_event); 2354 2355 ret = cros_ec_get_host_event(ec_dev); 2356 KUNIT_EXPECT_EQ(test, ret, EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC)); 2357 } 2358 2359 static void cros_ec_proto_test_check_features_cached(struct kunit *test) 2360 { 2361 int ret, i; 2362 static struct cros_ec_dev ec; 2363 2364 ec.features.flags[0] = EC_FEATURE_MASK_0(EC_FEATURE_FINGERPRINT); 2365 ec.features.flags[1] = EC_FEATURE_MASK_0(EC_FEATURE_SCP); 2366 2367 for (i = 0; i < EC_FEATURE_TYPEC_MUX_REQUIRE_AP_ACK; ++i) { 2368 ret = cros_ec_check_features(&ec, i); 2369 switch (i) { 2370 case EC_FEATURE_FINGERPRINT: 2371 case EC_FEATURE_SCP: 2372 KUNIT_EXPECT_TRUE(test, ret); 2373 break; 2374 default: 2375 KUNIT_EXPECT_FALSE(test, ret); 2376 break; 2377 } 2378 } 2379 } 2380 2381 static void cros_ec_proto_test_check_features_not_cached(struct kunit *test) 2382 { 2383 struct cros_ec_proto_test_priv *priv = test->priv; 2384 struct cros_ec_device *ec_dev = &priv->ec_dev; 2385 struct ec_xfer_mock *mock; 2386 int ret, i; 2387 static struct cros_ec_dev ec; 2388 2389 ec_dev->max_request = 0xff; 2390 ec_dev->max_response = 0xee; 2391 ec.ec_dev = ec_dev; 2392 ec.dev = ec_dev->dev; 2393 ec.cmd_offset = 0; 2394 ec.features.flags[0] = -1; 2395 ec.features.flags[1] = -1; 2396 2397 /* For EC_CMD_GET_FEATURES. */ 2398 { 2399 struct ec_response_get_features *data; 2400 2401 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 2402 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2403 2404 data = (struct ec_response_get_features *)mock->o_data; 2405 data->flags[0] = EC_FEATURE_MASK_0(EC_FEATURE_FINGERPRINT); 2406 data->flags[1] = EC_FEATURE_MASK_0(EC_FEATURE_SCP); 2407 } 2408 2409 for (i = 0; i < EC_FEATURE_TYPEC_MUX_REQUIRE_AP_ACK; ++i) { 2410 ret = cros_ec_check_features(&ec, i); 2411 switch (i) { 2412 case EC_FEATURE_FINGERPRINT: 2413 case EC_FEATURE_SCP: 2414 KUNIT_EXPECT_TRUE(test, ret); 2415 break; 2416 default: 2417 KUNIT_EXPECT_FALSE(test, ret); 2418 break; 2419 } 2420 } 2421 2422 /* For EC_CMD_GET_FEATURES. */ 2423 { 2424 mock = cros_kunit_ec_xfer_mock_next(); 2425 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2426 2427 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 2428 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_FEATURES); 2429 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_get_features)); 2430 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2431 } 2432 } 2433 2434 static void cros_ec_proto_test_get_sensor_count_normal(struct kunit *test) 2435 { 2436 struct cros_ec_proto_test_priv *priv = test->priv; 2437 struct cros_ec_device *ec_dev = &priv->ec_dev; 2438 struct ec_xfer_mock *mock; 2439 int ret; 2440 static struct cros_ec_dev ec; 2441 2442 ec_dev->max_request = 0xff; 2443 ec_dev->max_response = 0xee; 2444 ec.ec_dev = ec_dev; 2445 ec.dev = ec_dev->dev; 2446 ec.cmd_offset = 0; 2447 2448 /* For EC_CMD_MOTION_SENSE_CMD. */ 2449 { 2450 struct ec_response_motion_sense *data; 2451 2452 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 2453 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2454 2455 data = (struct ec_response_motion_sense *)mock->o_data; 2456 data->dump.sensor_count = 0xbf; 2457 } 2458 2459 ret = cros_ec_get_sensor_count(&ec); 2460 KUNIT_EXPECT_EQ(test, ret, 0xbf); 2461 2462 /* For EC_CMD_MOTION_SENSE_CMD. */ 2463 { 2464 struct ec_params_motion_sense *data; 2465 2466 mock = cros_kunit_ec_xfer_mock_next(); 2467 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2468 2469 KUNIT_EXPECT_EQ(test, mock->msg.version, 1); 2470 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MOTION_SENSE_CMD); 2471 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_motion_sense)); 2472 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 2473 2474 data = (struct ec_params_motion_sense *)mock->i_data; 2475 KUNIT_EXPECT_EQ(test, data->cmd, MOTIONSENSE_CMD_DUMP); 2476 } 2477 } 2478 2479 static void cros_ec_proto_test_get_sensor_count_xfer_error(struct kunit *test) 2480 { 2481 struct cros_ec_proto_test_priv *priv = test->priv; 2482 struct cros_ec_device *ec_dev = &priv->ec_dev; 2483 struct ec_xfer_mock *mock; 2484 int ret; 2485 static struct cros_ec_dev ec; 2486 2487 ec_dev->max_request = 0xff; 2488 ec_dev->max_response = 0xee; 2489 ec.ec_dev = ec_dev; 2490 ec.dev = ec_dev->dev; 2491 ec.cmd_offset = 0; 2492 2493 /* For EC_CMD_MOTION_SENSE_CMD. */ 2494 { 2495 mock = cros_kunit_ec_xfer_mock_addx(test, -EPROTO, EC_RES_SUCCESS, 0); 2496 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2497 } 2498 2499 ret = cros_ec_get_sensor_count(&ec); 2500 KUNIT_EXPECT_EQ(test, ret, -EPROTO); 2501 2502 /* For EC_CMD_MOTION_SENSE_CMD. */ 2503 { 2504 struct ec_params_motion_sense *data; 2505 2506 mock = cros_kunit_ec_xfer_mock_next(); 2507 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2508 2509 KUNIT_EXPECT_EQ(test, mock->msg.version, 1); 2510 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MOTION_SENSE_CMD); 2511 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_motion_sense)); 2512 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 2513 2514 data = (struct ec_params_motion_sense *)mock->i_data; 2515 KUNIT_EXPECT_EQ(test, data->cmd, MOTIONSENSE_CMD_DUMP); 2516 } 2517 } 2518 2519 static void cros_ec_proto_test_get_sensor_count_legacy(struct kunit *test) 2520 { 2521 struct cros_ec_proto_test_priv *priv = test->priv; 2522 struct cros_ec_device *ec_dev = &priv->ec_dev; 2523 struct ec_xfer_mock *mock; 2524 int ret, i; 2525 static struct cros_ec_dev ec; 2526 struct { 2527 u8 readmem_data; 2528 int expected_result; 2529 } test_data[] = { 2530 { 0, 0 }, 2531 { EC_MEMMAP_ACC_STATUS_PRESENCE_BIT, 2 }, 2532 }; 2533 2534 ec_dev->max_request = 0xff; 2535 ec_dev->max_response = 0xee; 2536 ec_dev->cmd_readmem = cros_kunit_readmem_mock; 2537 ec.ec_dev = ec_dev; 2538 ec.dev = ec_dev->dev; 2539 ec.cmd_offset = 0; 2540 2541 for (i = 0; i < ARRAY_SIZE(test_data); ++i) { 2542 /* For EC_CMD_MOTION_SENSE_CMD. */ 2543 { 2544 mock = cros_kunit_ec_xfer_mock_addx(test, -EPROTO, EC_RES_SUCCESS, 0); 2545 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2546 } 2547 2548 /* For readmem. */ 2549 { 2550 cros_kunit_readmem_mock_data = kunit_kzalloc(test, 1, GFP_KERNEL); 2551 KUNIT_ASSERT_PTR_NE(test, cros_kunit_readmem_mock_data, NULL); 2552 cros_kunit_readmem_mock_data[0] = test_data[i].readmem_data; 2553 2554 cros_kunit_ec_xfer_mock_default_ret = 1; 2555 } 2556 2557 ret = cros_ec_get_sensor_count(&ec); 2558 KUNIT_EXPECT_EQ(test, ret, test_data[i].expected_result); 2559 2560 /* For EC_CMD_MOTION_SENSE_CMD. */ 2561 { 2562 struct ec_params_motion_sense *data; 2563 2564 mock = cros_kunit_ec_xfer_mock_next(); 2565 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2566 2567 KUNIT_EXPECT_EQ(test, mock->msg.version, 1); 2568 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MOTION_SENSE_CMD); 2569 KUNIT_EXPECT_EQ(test, mock->msg.insize, 2570 sizeof(struct ec_response_motion_sense)); 2571 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 2572 2573 data = (struct ec_params_motion_sense *)mock->i_data; 2574 KUNIT_EXPECT_EQ(test, data->cmd, MOTIONSENSE_CMD_DUMP); 2575 } 2576 2577 /* For readmem. */ 2578 { 2579 KUNIT_EXPECT_EQ(test, cros_kunit_readmem_mock_offset, EC_MEMMAP_ACC_STATUS); 2580 } 2581 } 2582 } 2583 2584 static void cros_ec_proto_test_ec_cmd(struct kunit *test) 2585 { 2586 struct cros_ec_proto_test_priv *priv = test->priv; 2587 struct cros_ec_device *ec_dev = &priv->ec_dev; 2588 struct ec_xfer_mock *mock; 2589 int ret; 2590 u8 out[3], in[2]; 2591 2592 ec_dev->max_request = 0xff; 2593 ec_dev->max_response = 0xee; 2594 2595 out[0] = 0xdd; 2596 out[1] = 0xcc; 2597 out[2] = 0xbb; 2598 2599 { 2600 u8 *data; 2601 2602 mock = cros_kunit_ec_xfer_mock_add(test, 2); 2603 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2604 2605 data = (u8 *)mock->o_data; 2606 data[0] = 0xaa; 2607 data[1] = 0x99; 2608 } 2609 2610 ret = cros_ec_cmd(ec_dev, 0x88, 0x77, out, ARRAY_SIZE(out), in, ARRAY_SIZE(in)); 2611 KUNIT_EXPECT_EQ(test, ret, 2); 2612 2613 { 2614 u8 *data; 2615 2616 mock = cros_kunit_ec_xfer_mock_next(); 2617 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2618 2619 KUNIT_EXPECT_EQ(test, mock->msg.version, 0x88); 2620 KUNIT_EXPECT_EQ(test, mock->msg.command, 0x77); 2621 KUNIT_EXPECT_EQ(test, mock->msg.insize, ARRAY_SIZE(in)); 2622 KUNIT_EXPECT_EQ(test, mock->msg.outsize, ARRAY_SIZE(out)); 2623 2624 data = (u8 *)mock->i_data; 2625 KUNIT_EXPECT_EQ(test, data[0], 0xdd); 2626 KUNIT_EXPECT_EQ(test, data[1], 0xcc); 2627 KUNIT_EXPECT_EQ(test, data[2], 0xbb); 2628 } 2629 } 2630 2631 static void cros_ec_proto_test_release(struct device *dev) 2632 { 2633 } 2634 2635 static int cros_ec_proto_test_init(struct kunit *test) 2636 { 2637 struct cros_ec_proto_test_priv *priv; 2638 struct cros_ec_device *ec_dev; 2639 2640 priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL); 2641 if (!priv) 2642 return -ENOMEM; 2643 test->priv = priv; 2644 2645 ec_dev = &priv->ec_dev; 2646 ec_dev->dout = (u8 *)priv->dout; 2647 ec_dev->dout_size = ARRAY_SIZE(priv->dout); 2648 ec_dev->din = (u8 *)priv->din; 2649 ec_dev->din_size = ARRAY_SIZE(priv->din); 2650 ec_dev->proto_version = EC_HOST_REQUEST_VERSION; 2651 ec_dev->dev = kunit_kzalloc(test, sizeof(*ec_dev->dev), GFP_KERNEL); 2652 if (!ec_dev->dev) 2653 return -ENOMEM; 2654 device_initialize(ec_dev->dev); 2655 dev_set_name(ec_dev->dev, "cros_ec_proto_test"); 2656 ec_dev->dev->release = cros_ec_proto_test_release; 2657 ec_dev->cmd_xfer = cros_kunit_ec_xfer_mock; 2658 ec_dev->pkt_xfer = cros_kunit_ec_xfer_mock; 2659 mutex_init(&ec_dev->lock); 2660 2661 priv->msg = (struct cros_ec_command *)priv->_msg; 2662 2663 cros_kunit_mock_reset(); 2664 2665 return 0; 2666 } 2667 2668 static void cros_ec_proto_test_exit(struct kunit *test) 2669 { 2670 struct cros_ec_proto_test_priv *priv = test->priv; 2671 struct cros_ec_device *ec_dev = &priv->ec_dev; 2672 2673 put_device(ec_dev->dev); 2674 } 2675 2676 static struct kunit_case cros_ec_proto_test_cases[] = { 2677 KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_normal), 2678 KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_bad_msg_outsize), 2679 KUNIT_CASE(cros_ec_proto_test_prepare_tx_normal), 2680 KUNIT_CASE(cros_ec_proto_test_prepare_tx_bad_msg_outsize), 2681 KUNIT_CASE(cros_ec_proto_test_check_result), 2682 KUNIT_CASE(cros_ec_proto_test_query_all_normal), 2683 KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return_error), 2684 KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return0), 2685 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return_error), 2686 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return0), 2687 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_xfer_error), 2688 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return_error), 2689 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error), 2690 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return0), 2691 KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp), 2692 KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return_error), 2693 KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return0), 2694 KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep), 2695 KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep_return0), 2696 KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error), 2697 KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return0), 2698 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_normal), 2699 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_insize), 2700 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_outsize_without_passthru), 2701 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_outsize_with_passthru), 2702 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v3_normal), 2703 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v3_no_op), 2704 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v2_normal), 2705 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v2_no_op), 2706 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_normal), 2707 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_retries_eagain), 2708 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_retries_status_processing), 2709 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_xfer_error), 2710 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_return_error), 2711 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_return0), 2712 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_status_normal), 2713 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_status_xfer_error), 2714 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_status_return_error), 2715 KUNIT_CASE(cros_ec_proto_test_get_next_event_no_mkbp_event), 2716 KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_ec_suspended), 2717 KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_version0), 2718 KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_version2), 2719 KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_host_event_rtc), 2720 KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_host_event_masked), 2721 KUNIT_CASE(cros_ec_proto_test_get_host_event_no_mkbp_event), 2722 KUNIT_CASE(cros_ec_proto_test_get_host_event_not_host_event), 2723 KUNIT_CASE(cros_ec_proto_test_get_host_event_wrong_event_size), 2724 KUNIT_CASE(cros_ec_proto_test_get_host_event_normal), 2725 KUNIT_CASE(cros_ec_proto_test_check_features_cached), 2726 KUNIT_CASE(cros_ec_proto_test_check_features_not_cached), 2727 KUNIT_CASE(cros_ec_proto_test_get_sensor_count_normal), 2728 KUNIT_CASE(cros_ec_proto_test_get_sensor_count_xfer_error), 2729 KUNIT_CASE(cros_ec_proto_test_get_sensor_count_legacy), 2730 KUNIT_CASE(cros_ec_proto_test_ec_cmd), 2731 {} 2732 }; 2733 2734 static struct kunit_suite cros_ec_proto_test_suite = { 2735 .name = "cros_ec_proto_test", 2736 .init = cros_ec_proto_test_init, 2737 .exit = cros_ec_proto_test_exit, 2738 .test_cases = cros_ec_proto_test_cases, 2739 }; 2740 2741 kunit_test_suite(cros_ec_proto_test_suite); 2742 2743 MODULE_LICENSE("GPL"); 2744