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 struct { 1547 struct cros_ec_command msg; 1548 u8 data[0x100]; 1549 } __packed buf; 1550 1551 ec_dev->max_request = 0xff; 1552 ec_dev->max_response = 0xee; 1553 ec_dev->max_passthru = 0xdd; 1554 1555 buf.msg.version = 0; 1556 buf.msg.command = EC_CMD_HELLO; 1557 buf.msg.insize = 4; 1558 buf.msg.outsize = 2; 1559 buf.data[0] = 0x55; 1560 buf.data[1] = 0xaa; 1561 1562 { 1563 u8 *data; 1564 1565 mock = cros_kunit_ec_xfer_mock_add(test, 4); 1566 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1567 1568 data = (u8 *)mock->o_data; 1569 data[0] = 0xaa; 1570 data[1] = 0x55; 1571 data[2] = 0xcc; 1572 data[3] = 0x33; 1573 } 1574 1575 ret = cros_ec_cmd_xfer(ec_dev, &buf.msg); 1576 KUNIT_EXPECT_EQ(test, ret, 4); 1577 1578 { 1579 u8 *data; 1580 1581 mock = cros_kunit_ec_xfer_mock_next(); 1582 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1583 1584 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1585 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO); 1586 KUNIT_EXPECT_EQ(test, mock->msg.insize, 4); 1587 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 2); 1588 1589 data = (u8 *)mock->i_data; 1590 KUNIT_EXPECT_EQ(test, data[0], 0x55); 1591 KUNIT_EXPECT_EQ(test, data[1], 0xaa); 1592 1593 KUNIT_EXPECT_EQ(test, buf.data[0], 0xaa); 1594 KUNIT_EXPECT_EQ(test, buf.data[1], 0x55); 1595 KUNIT_EXPECT_EQ(test, buf.data[2], 0xcc); 1596 KUNIT_EXPECT_EQ(test, buf.data[3], 0x33); 1597 } 1598 } 1599 1600 static void cros_ec_proto_test_cmd_xfer_excess_msg_insize(struct kunit *test) 1601 { 1602 struct cros_ec_proto_test_priv *priv = test->priv; 1603 struct cros_ec_device *ec_dev = &priv->ec_dev; 1604 struct ec_xfer_mock *mock; 1605 int ret; 1606 struct { 1607 struct cros_ec_command msg; 1608 u8 data[0x100]; 1609 } __packed buf; 1610 1611 ec_dev->max_request = 0xff; 1612 ec_dev->max_response = 0xee; 1613 ec_dev->max_passthru = 0xdd; 1614 1615 buf.msg.version = 0; 1616 buf.msg.command = EC_CMD_HELLO; 1617 buf.msg.insize = 0xee + 1; 1618 buf.msg.outsize = 2; 1619 1620 { 1621 mock = cros_kunit_ec_xfer_mock_add(test, 0xcc); 1622 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1623 } 1624 1625 ret = cros_ec_cmd_xfer(ec_dev, &buf.msg); 1626 KUNIT_EXPECT_EQ(test, ret, 0xcc); 1627 1628 { 1629 mock = cros_kunit_ec_xfer_mock_next(); 1630 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1631 1632 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1633 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO); 1634 KUNIT_EXPECT_EQ(test, mock->msg.insize, 0xee); 1635 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 2); 1636 } 1637 } 1638 1639 static void cros_ec_proto_test_cmd_xfer_excess_msg_outsize_without_passthru(struct kunit *test) 1640 { 1641 struct cros_ec_proto_test_priv *priv = test->priv; 1642 struct cros_ec_device *ec_dev = &priv->ec_dev; 1643 int ret; 1644 struct { 1645 struct cros_ec_command msg; 1646 u8 data[0x100]; 1647 } __packed buf; 1648 1649 ec_dev->max_request = 0xff; 1650 ec_dev->max_response = 0xee; 1651 ec_dev->max_passthru = 0xdd; 1652 1653 buf.msg.version = 0; 1654 buf.msg.command = EC_CMD_HELLO; 1655 buf.msg.insize = 4; 1656 buf.msg.outsize = 0xff + 1; 1657 1658 ret = cros_ec_cmd_xfer(ec_dev, &buf.msg); 1659 KUNIT_EXPECT_EQ(test, ret, -EMSGSIZE); 1660 } 1661 1662 static void cros_ec_proto_test_cmd_xfer_excess_msg_outsize_with_passthru(struct kunit *test) 1663 { 1664 struct cros_ec_proto_test_priv *priv = test->priv; 1665 struct cros_ec_device *ec_dev = &priv->ec_dev; 1666 int ret; 1667 struct { 1668 struct cros_ec_command msg; 1669 u8 data[0x100]; 1670 } __packed buf; 1671 1672 ec_dev->max_request = 0xff; 1673 ec_dev->max_response = 0xee; 1674 ec_dev->max_passthru = 0xdd; 1675 1676 buf.msg.version = 0; 1677 buf.msg.command = EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) + EC_CMD_HELLO; 1678 buf.msg.insize = 4; 1679 buf.msg.outsize = 0xdd + 1; 1680 1681 ret = cros_ec_cmd_xfer(ec_dev, &buf.msg); 1682 KUNIT_EXPECT_EQ(test, ret, -EMSGSIZE); 1683 } 1684 1685 static void cros_ec_proto_test_cmd_xfer_protocol_v3_normal(struct kunit *test) 1686 { 1687 struct cros_ec_proto_test_priv *priv = test->priv; 1688 struct cros_ec_device *ec_dev = &priv->ec_dev; 1689 int ret; 1690 struct cros_ec_command msg; 1691 1692 memset(&msg, 0, sizeof(msg)); 1693 1694 ec_dev->proto_version = 3; 1695 ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock; 1696 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1697 1698 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1699 KUNIT_EXPECT_EQ(test, ret, 0); 1700 1701 KUNIT_EXPECT_EQ(test, cros_kunit_ec_cmd_xfer_mock_called, 0); 1702 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 1); 1703 } 1704 1705 static void cros_ec_proto_test_cmd_xfer_protocol_v3_no_op(struct kunit *test) 1706 { 1707 struct cros_ec_proto_test_priv *priv = test->priv; 1708 struct cros_ec_device *ec_dev = &priv->ec_dev; 1709 int ret; 1710 struct cros_ec_command msg; 1711 1712 memset(&msg, 0, sizeof(msg)); 1713 1714 ec_dev->proto_version = 3; 1715 ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock; 1716 ec_dev->pkt_xfer = NULL; 1717 1718 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1719 KUNIT_EXPECT_EQ(test, ret, -EIO); 1720 } 1721 1722 static void cros_ec_proto_test_cmd_xfer_protocol_v2_normal(struct kunit *test) 1723 { 1724 struct cros_ec_proto_test_priv *priv = test->priv; 1725 struct cros_ec_device *ec_dev = &priv->ec_dev; 1726 int ret; 1727 struct cros_ec_command msg; 1728 1729 memset(&msg, 0, sizeof(msg)); 1730 1731 ec_dev->proto_version = 2; 1732 ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock; 1733 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1734 1735 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1736 KUNIT_EXPECT_EQ(test, ret, 0); 1737 1738 KUNIT_EXPECT_EQ(test, cros_kunit_ec_cmd_xfer_mock_called, 1); 1739 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 0); 1740 } 1741 1742 static void cros_ec_proto_test_cmd_xfer_protocol_v2_no_op(struct kunit *test) 1743 { 1744 struct cros_ec_proto_test_priv *priv = test->priv; 1745 struct cros_ec_device *ec_dev = &priv->ec_dev; 1746 int ret; 1747 struct cros_ec_command msg; 1748 1749 memset(&msg, 0, sizeof(msg)); 1750 1751 ec_dev->proto_version = 2; 1752 ec_dev->cmd_xfer = NULL; 1753 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1754 1755 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1756 KUNIT_EXPECT_EQ(test, ret, -EIO); 1757 } 1758 1759 static void cros_ec_proto_test_cmd_xfer_in_progress_normal(struct kunit *test) 1760 { 1761 struct cros_ec_proto_test_priv *priv = test->priv; 1762 struct cros_ec_device *ec_dev = &priv->ec_dev; 1763 struct ec_xfer_mock *mock; 1764 int ret; 1765 struct cros_ec_command msg; 1766 1767 memset(&msg, 0, sizeof(msg)); 1768 1769 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1770 1771 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1772 { 1773 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1774 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1775 } 1776 1777 /* For EC_CMD_GET_COMMS_STATUS. */ 1778 { 1779 struct ec_response_get_comms_status *data; 1780 1781 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1782 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1783 1784 data = (struct ec_response_get_comms_status *)mock->o_data; 1785 data->flags = 0; 1786 } 1787 1788 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1789 KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_comms_status)); 1790 1791 KUNIT_EXPECT_EQ(test, msg.result, EC_RES_SUCCESS); 1792 1793 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1794 { 1795 mock = cros_kunit_ec_xfer_mock_next(); 1796 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1797 } 1798 1799 /* For EC_CMD_GET_COMMS_STATUS. */ 1800 { 1801 mock = cros_kunit_ec_xfer_mock_next(); 1802 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 1803 1804 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 1805 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_COMMS_STATUS); 1806 KUNIT_EXPECT_EQ(test, mock->msg.insize, 1807 sizeof(struct ec_response_get_comms_status)); 1808 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 1809 } 1810 1811 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2); 1812 } 1813 1814 static void cros_ec_proto_test_cmd_xfer_in_progress_retries_eagain(struct kunit *test) 1815 { 1816 struct cros_ec_proto_test_priv *priv = test->priv; 1817 struct cros_ec_device *ec_dev = &priv->ec_dev; 1818 struct ec_xfer_mock *mock; 1819 int ret; 1820 struct cros_ec_command msg; 1821 1822 memset(&msg, 0, sizeof(msg)); 1823 1824 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1825 1826 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1827 { 1828 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1829 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1830 } 1831 1832 /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */ 1833 cros_kunit_ec_xfer_mock_default_ret = -EAGAIN; 1834 1835 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1836 KUNIT_EXPECT_EQ(test, ret, -EAGAIN); 1837 1838 /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */ 1839 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 51); 1840 } 1841 1842 static void cros_ec_proto_test_cmd_xfer_in_progress_retries_status_processing(struct kunit *test) 1843 { 1844 struct cros_ec_proto_test_priv *priv = test->priv; 1845 struct cros_ec_device *ec_dev = &priv->ec_dev; 1846 struct ec_xfer_mock *mock; 1847 int ret; 1848 struct cros_ec_command msg; 1849 1850 memset(&msg, 0, sizeof(msg)); 1851 1852 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1853 1854 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1855 { 1856 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1857 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1858 } 1859 1860 /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */ 1861 { 1862 struct ec_response_get_comms_status *data; 1863 int i; 1864 1865 for (i = 0; i < 50; ++i) { 1866 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 1867 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1868 1869 data = (struct ec_response_get_comms_status *)mock->o_data; 1870 data->flags |= EC_COMMS_STATUS_PROCESSING; 1871 } 1872 } 1873 1874 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1875 KUNIT_EXPECT_EQ(test, ret, -EAGAIN); 1876 1877 /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */ 1878 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 51); 1879 } 1880 1881 static void cros_ec_proto_test_cmd_xfer_in_progress_xfer_error(struct kunit *test) 1882 { 1883 struct cros_ec_proto_test_priv *priv = test->priv; 1884 struct cros_ec_device *ec_dev = &priv->ec_dev; 1885 struct ec_xfer_mock *mock; 1886 int ret; 1887 struct cros_ec_command msg; 1888 1889 memset(&msg, 0, sizeof(msg)); 1890 1891 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1892 { 1893 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1894 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1895 } 1896 1897 /* For EC_CMD_GET_COMMS_STATUS. */ 1898 { 1899 mock = cros_kunit_ec_xfer_mock_addx(test, -EIO, EC_RES_SUCCESS, 0); 1900 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1901 } 1902 1903 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1904 KUNIT_EXPECT_EQ(test, ret, -EIO); 1905 } 1906 1907 static void cros_ec_proto_test_cmd_xfer_in_progress_return_error(struct kunit *test) 1908 { 1909 struct cros_ec_proto_test_priv *priv = test->priv; 1910 struct cros_ec_device *ec_dev = &priv->ec_dev; 1911 struct ec_xfer_mock *mock; 1912 int ret; 1913 struct cros_ec_command msg; 1914 1915 memset(&msg, 0, sizeof(msg)); 1916 1917 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1918 1919 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1920 { 1921 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1922 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1923 } 1924 1925 /* For EC_CMD_GET_COMMS_STATUS. */ 1926 { 1927 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0); 1928 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1929 } 1930 1931 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1932 KUNIT_EXPECT_EQ(test, ret, 0); 1933 1934 KUNIT_EXPECT_EQ(test, msg.result, EC_RES_INVALID_COMMAND); 1935 1936 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2); 1937 } 1938 1939 static void cros_ec_proto_test_cmd_xfer_in_progress_return0(struct kunit *test) 1940 { 1941 struct cros_ec_proto_test_priv *priv = test->priv; 1942 struct cros_ec_device *ec_dev = &priv->ec_dev; 1943 struct ec_xfer_mock *mock; 1944 int ret; 1945 struct cros_ec_command msg; 1946 1947 memset(&msg, 0, sizeof(msg)); 1948 1949 ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock; 1950 1951 /* For the first host command to return EC_RES_IN_PROGRESS. */ 1952 { 1953 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0); 1954 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1955 } 1956 1957 /* For EC_CMD_GET_COMMS_STATUS. */ 1958 { 1959 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1960 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1961 } 1962 1963 ret = cros_ec_cmd_xfer(ec_dev, &msg); 1964 KUNIT_EXPECT_EQ(test, ret, -EPROTO); 1965 1966 KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2); 1967 } 1968 1969 static void cros_ec_proto_test_cmd_xfer_status_normal(struct kunit *test) 1970 { 1971 struct cros_ec_proto_test_priv *priv = test->priv; 1972 struct cros_ec_device *ec_dev = &priv->ec_dev; 1973 struct ec_xfer_mock *mock; 1974 int ret; 1975 struct cros_ec_command msg; 1976 1977 memset(&msg, 0, sizeof(msg)); 1978 1979 /* For cros_ec_cmd_xfer(). */ 1980 { 1981 mock = cros_kunit_ec_xfer_mock_add(test, 0); 1982 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 1983 } 1984 1985 ret = cros_ec_cmd_xfer_status(ec_dev, &msg); 1986 KUNIT_EXPECT_EQ(test, ret, 0); 1987 } 1988 1989 static void cros_ec_proto_test_cmd_xfer_status_xfer_error(struct kunit *test) 1990 { 1991 struct cros_ec_proto_test_priv *priv = test->priv; 1992 struct cros_ec_device *ec_dev = &priv->ec_dev; 1993 struct ec_xfer_mock *mock; 1994 int ret; 1995 struct cros_ec_command msg; 1996 1997 memset(&msg, 0, sizeof(msg)); 1998 1999 /* For cros_ec_cmd_xfer(). */ 2000 { 2001 mock = cros_kunit_ec_xfer_mock_addx(test, -EPROTO, EC_RES_SUCCESS, 0); 2002 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2003 } 2004 2005 ret = cros_ec_cmd_xfer_status(ec_dev, &msg); 2006 KUNIT_EXPECT_EQ(test, ret, -EPROTO); 2007 } 2008 2009 static void cros_ec_proto_test_cmd_xfer_status_return_error(struct kunit *test) 2010 { 2011 struct cros_ec_proto_test_priv *priv = test->priv; 2012 struct cros_ec_device *ec_dev = &priv->ec_dev; 2013 struct ec_xfer_mock *mock; 2014 int ret, i; 2015 struct cros_ec_command msg; 2016 static const int map[] = { 2017 [EC_RES_SUCCESS] = 0, 2018 [EC_RES_INVALID_COMMAND] = -EOPNOTSUPP, 2019 [EC_RES_ERROR] = -EIO, 2020 [EC_RES_INVALID_PARAM] = -EINVAL, 2021 [EC_RES_ACCESS_DENIED] = -EACCES, 2022 [EC_RES_INVALID_RESPONSE] = -EPROTO, 2023 [EC_RES_INVALID_VERSION] = -ENOPROTOOPT, 2024 [EC_RES_INVALID_CHECKSUM] = -EBADMSG, 2025 /* 2026 * EC_RES_IN_PROGRESS is special because cros_ec_send_command() has extra logic to 2027 * handle it. Note that default cros_kunit_ec_xfer_mock_default_ret == 0 thus 2028 * cros_ec_xfer_command() in cros_ec_wait_until_complete() returns 0. As a result, 2029 * it returns -EPROTO without calling cros_ec_map_error(). 2030 */ 2031 [EC_RES_IN_PROGRESS] = -EPROTO, 2032 [EC_RES_UNAVAILABLE] = -ENODATA, 2033 [EC_RES_TIMEOUT] = -ETIMEDOUT, 2034 [EC_RES_OVERFLOW] = -EOVERFLOW, 2035 [EC_RES_INVALID_HEADER] = -EBADR, 2036 [EC_RES_REQUEST_TRUNCATED] = -EBADR, 2037 [EC_RES_RESPONSE_TOO_BIG] = -EFBIG, 2038 [EC_RES_BUS_ERROR] = -EFAULT, 2039 [EC_RES_BUSY] = -EBUSY, 2040 [EC_RES_INVALID_HEADER_VERSION] = -EBADMSG, 2041 [EC_RES_INVALID_HEADER_CRC] = -EBADMSG, 2042 [EC_RES_INVALID_DATA_CRC] = -EBADMSG, 2043 [EC_RES_DUP_UNAVAILABLE] = -ENODATA, 2044 }; 2045 2046 memset(&msg, 0, sizeof(msg)); 2047 2048 for (i = 0; i < ARRAY_SIZE(map); ++i) { 2049 mock = cros_kunit_ec_xfer_mock_addx(test, 0, i, 0); 2050 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2051 2052 ret = cros_ec_cmd_xfer_status(ec_dev, &msg); 2053 KUNIT_EXPECT_EQ(test, ret, map[i]); 2054 } 2055 } 2056 2057 static void cros_ec_proto_test_get_next_event_no_mkbp_event(struct kunit *test) 2058 { 2059 struct cros_ec_proto_test_priv *priv = test->priv; 2060 struct cros_ec_device *ec_dev = &priv->ec_dev; 2061 struct ec_xfer_mock *mock; 2062 int ret; 2063 bool wake_event, more_events; 2064 2065 ec_dev->max_request = 0xff; 2066 ec_dev->max_response = 0xee; 2067 ec_dev->mkbp_event_supported = 0; 2068 2069 /* Set some garbage bytes. */ 2070 wake_event = false; 2071 more_events = true; 2072 2073 /* For get_keyboard_state_event(). */ 2074 { 2075 union ec_response_get_next_data_v1 *data; 2076 2077 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 2078 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2079 2080 data = (union ec_response_get_next_data_v1 *)mock->o_data; 2081 data->host_event = 0xbeef; 2082 } 2083 2084 ret = cros_ec_get_next_event(ec_dev, &wake_event, &more_events); 2085 KUNIT_EXPECT_EQ(test, ret, sizeof(union ec_response_get_next_data_v1)); 2086 2087 KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_KEY_MATRIX); 2088 KUNIT_EXPECT_EQ(test, ec_dev->event_data.data.host_event, 0xbeef); 2089 2090 KUNIT_EXPECT_TRUE(test, wake_event); 2091 KUNIT_EXPECT_FALSE(test, more_events); 2092 2093 /* For get_keyboard_state_event(). */ 2094 { 2095 mock = cros_kunit_ec_xfer_mock_next(); 2096 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2097 2098 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 2099 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MKBP_STATE); 2100 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(union ec_response_get_next_data_v1)); 2101 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2102 } 2103 } 2104 2105 static void cros_ec_proto_test_get_next_event_mkbp_event_ec_suspended(struct kunit *test) 2106 { 2107 struct cros_ec_proto_test_priv *priv = test->priv; 2108 struct cros_ec_device *ec_dev = &priv->ec_dev; 2109 int ret; 2110 2111 ec_dev->mkbp_event_supported = 1; 2112 ec_dev->suspended = true; 2113 2114 ret = cros_ec_get_next_event(ec_dev, NULL, NULL); 2115 KUNIT_EXPECT_EQ(test, ret, -EHOSTDOWN); 2116 } 2117 2118 static void cros_ec_proto_test_get_next_event_mkbp_event_version0(struct kunit *test) 2119 { 2120 struct cros_ec_proto_test_priv *priv = test->priv; 2121 struct cros_ec_device *ec_dev = &priv->ec_dev; 2122 struct ec_xfer_mock *mock; 2123 int ret; 2124 bool wake_event, more_events; 2125 2126 ec_dev->max_request = 0xff; 2127 ec_dev->max_response = 0xee; 2128 ec_dev->mkbp_event_supported = 1; 2129 2130 /* Set some garbage bytes. */ 2131 wake_event = true; 2132 more_events = false; 2133 2134 /* For get_next_event_xfer(). */ 2135 { 2136 struct ec_response_get_next_event *data; 2137 2138 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 2139 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2140 2141 data = (struct ec_response_get_next_event *)mock->o_data; 2142 data->event_type = EC_MKBP_EVENT_SENSOR_FIFO | EC_MKBP_HAS_MORE_EVENTS; 2143 data->data.sysrq = 0xbeef; 2144 } 2145 2146 ret = cros_ec_get_next_event(ec_dev, &wake_event, &more_events); 2147 KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_next_event)); 2148 2149 KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_SENSOR_FIFO); 2150 KUNIT_EXPECT_EQ(test, ec_dev->event_data.data.sysrq, 0xbeef); 2151 2152 KUNIT_EXPECT_FALSE(test, wake_event); 2153 KUNIT_EXPECT_TRUE(test, more_events); 2154 2155 /* For get_next_event_xfer(). */ 2156 { 2157 mock = cros_kunit_ec_xfer_mock_next(); 2158 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2159 2160 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 2161 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT); 2162 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_get_next_event)); 2163 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2164 } 2165 } 2166 2167 static void cros_ec_proto_test_get_next_event_mkbp_event_version2(struct kunit *test) 2168 { 2169 struct cros_ec_proto_test_priv *priv = test->priv; 2170 struct cros_ec_device *ec_dev = &priv->ec_dev; 2171 struct ec_xfer_mock *mock; 2172 int ret; 2173 bool wake_event, more_events; 2174 2175 ec_dev->max_request = 0xff; 2176 ec_dev->max_response = 0xee; 2177 ec_dev->mkbp_event_supported = 3; 2178 2179 /* Set some garbage bytes. */ 2180 wake_event = false; 2181 more_events = true; 2182 2183 /* For get_next_event_xfer(). */ 2184 { 2185 struct ec_response_get_next_event_v1 *data; 2186 2187 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 2188 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2189 2190 data = (struct ec_response_get_next_event_v1 *)mock->o_data; 2191 data->event_type = EC_MKBP_EVENT_FINGERPRINT; 2192 data->data.sysrq = 0xbeef; 2193 } 2194 2195 ret = cros_ec_get_next_event(ec_dev, &wake_event, &more_events); 2196 KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_next_event_v1)); 2197 2198 KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_FINGERPRINT); 2199 KUNIT_EXPECT_EQ(test, ec_dev->event_data.data.sysrq, 0xbeef); 2200 2201 KUNIT_EXPECT_TRUE(test, wake_event); 2202 KUNIT_EXPECT_FALSE(test, more_events); 2203 2204 /* For get_next_event_xfer(). */ 2205 { 2206 mock = cros_kunit_ec_xfer_mock_next(); 2207 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2208 2209 KUNIT_EXPECT_EQ(test, mock->msg.version, 2); 2210 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT); 2211 KUNIT_EXPECT_EQ(test, mock->msg.insize, 2212 sizeof(struct ec_response_get_next_event_v1)); 2213 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2214 } 2215 } 2216 2217 static void cros_ec_proto_test_get_next_event_mkbp_event_host_event_rtc(struct kunit *test) 2218 { 2219 struct cros_ec_proto_test_priv *priv = test->priv; 2220 struct cros_ec_device *ec_dev = &priv->ec_dev; 2221 struct ec_xfer_mock *mock; 2222 int ret; 2223 bool wake_event; 2224 struct ec_response_get_next_event_v1 *data; 2225 2226 ec_dev->max_request = 0xff; 2227 ec_dev->max_response = 0xee; 2228 ec_dev->mkbp_event_supported = 3; 2229 ec_dev->host_event_wake_mask = U32_MAX; 2230 2231 /* Set some garbage bytes. */ 2232 wake_event = true; 2233 2234 /* For get_next_event_xfer(). */ 2235 { 2236 mock = cros_kunit_ec_xfer_mock_add(test, 2237 sizeof(data->event_type) + 2238 sizeof(data->data.host_event)); 2239 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2240 2241 data = (struct ec_response_get_next_event_v1 *)mock->o_data; 2242 data->event_type = EC_MKBP_EVENT_HOST_EVENT; 2243 put_unaligned_le32(EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC), &data->data.host_event); 2244 } 2245 2246 ret = cros_ec_get_next_event(ec_dev, &wake_event, NULL); 2247 KUNIT_EXPECT_EQ(test, ret, sizeof(data->event_type) + sizeof(data->data.host_event)); 2248 2249 KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_HOST_EVENT); 2250 2251 KUNIT_EXPECT_FALSE(test, wake_event); 2252 2253 /* For get_next_event_xfer(). */ 2254 { 2255 mock = cros_kunit_ec_xfer_mock_next(); 2256 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2257 2258 KUNIT_EXPECT_EQ(test, mock->msg.version, 2); 2259 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT); 2260 KUNIT_EXPECT_EQ(test, mock->msg.insize, 2261 sizeof(struct ec_response_get_next_event_v1)); 2262 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2263 } 2264 } 2265 2266 static void cros_ec_proto_test_get_next_event_mkbp_event_host_event_masked(struct kunit *test) 2267 { 2268 struct cros_ec_proto_test_priv *priv = test->priv; 2269 struct cros_ec_device *ec_dev = &priv->ec_dev; 2270 struct ec_xfer_mock *mock; 2271 int ret; 2272 bool wake_event; 2273 struct ec_response_get_next_event_v1 *data; 2274 2275 ec_dev->max_request = 0xff; 2276 ec_dev->max_response = 0xee; 2277 ec_dev->mkbp_event_supported = 3; 2278 ec_dev->host_event_wake_mask = U32_MAX & ~EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED); 2279 2280 /* Set some garbage bytes. */ 2281 wake_event = true; 2282 2283 /* For get_next_event_xfer(). */ 2284 { 2285 mock = cros_kunit_ec_xfer_mock_add(test, 2286 sizeof(data->event_type) + 2287 sizeof(data->data.host_event)); 2288 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2289 2290 data = (struct ec_response_get_next_event_v1 *)mock->o_data; 2291 data->event_type = EC_MKBP_EVENT_HOST_EVENT; 2292 put_unaligned_le32(EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED), 2293 &data->data.host_event); 2294 } 2295 2296 ret = cros_ec_get_next_event(ec_dev, &wake_event, NULL); 2297 KUNIT_EXPECT_EQ(test, ret, sizeof(data->event_type) + sizeof(data->data.host_event)); 2298 2299 KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_HOST_EVENT); 2300 2301 KUNIT_EXPECT_FALSE(test, wake_event); 2302 2303 /* For get_next_event_xfer(). */ 2304 { 2305 mock = cros_kunit_ec_xfer_mock_next(); 2306 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2307 2308 KUNIT_EXPECT_EQ(test, mock->msg.version, 2); 2309 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT); 2310 KUNIT_EXPECT_EQ(test, mock->msg.insize, 2311 sizeof(struct ec_response_get_next_event_v1)); 2312 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2313 } 2314 } 2315 2316 static void cros_ec_proto_test_get_host_event_no_mkbp_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 = 0; 2323 2324 ret = cros_ec_get_host_event(ec_dev); 2325 KUNIT_EXPECT_EQ(test, ret, 0); 2326 } 2327 2328 static void cros_ec_proto_test_get_host_event_not_host_event(struct kunit *test) 2329 { 2330 struct cros_ec_proto_test_priv *priv = test->priv; 2331 struct cros_ec_device *ec_dev = &priv->ec_dev; 2332 int ret; 2333 2334 ec_dev->mkbp_event_supported = 1; 2335 ec_dev->event_data.event_type = EC_MKBP_EVENT_FINGERPRINT; 2336 2337 ret = cros_ec_get_host_event(ec_dev); 2338 KUNIT_EXPECT_EQ(test, ret, 0); 2339 } 2340 2341 static void cros_ec_proto_test_get_host_event_wrong_event_size(struct kunit *test) 2342 { 2343 struct cros_ec_proto_test_priv *priv = test->priv; 2344 struct cros_ec_device *ec_dev = &priv->ec_dev; 2345 int ret; 2346 2347 ec_dev->mkbp_event_supported = 1; 2348 ec_dev->event_data.event_type = EC_MKBP_EVENT_HOST_EVENT; 2349 ec_dev->event_size = 0xff; 2350 2351 ret = cros_ec_get_host_event(ec_dev); 2352 KUNIT_EXPECT_EQ(test, ret, 0); 2353 } 2354 2355 static void cros_ec_proto_test_get_host_event_normal(struct kunit *test) 2356 { 2357 struct cros_ec_proto_test_priv *priv = test->priv; 2358 struct cros_ec_device *ec_dev = &priv->ec_dev; 2359 int ret; 2360 2361 ec_dev->mkbp_event_supported = 1; 2362 ec_dev->event_data.event_type = EC_MKBP_EVENT_HOST_EVENT; 2363 ec_dev->event_size = sizeof(ec_dev->event_data.data.host_event); 2364 put_unaligned_le32(EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC), 2365 &ec_dev->event_data.data.host_event); 2366 2367 ret = cros_ec_get_host_event(ec_dev); 2368 KUNIT_EXPECT_EQ(test, ret, EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC)); 2369 } 2370 2371 static void cros_ec_proto_test_check_features_cached(struct kunit *test) 2372 { 2373 int ret, i; 2374 static struct cros_ec_dev ec; 2375 2376 ec.features.flags[0] = EC_FEATURE_MASK_0(EC_FEATURE_FINGERPRINT); 2377 ec.features.flags[1] = EC_FEATURE_MASK_0(EC_FEATURE_SCP); 2378 2379 for (i = 0; i < EC_FEATURE_TYPEC_MUX_REQUIRE_AP_ACK; ++i) { 2380 ret = cros_ec_check_features(&ec, i); 2381 switch (i) { 2382 case EC_FEATURE_FINGERPRINT: 2383 case EC_FEATURE_SCP: 2384 KUNIT_EXPECT_TRUE(test, ret); 2385 break; 2386 default: 2387 KUNIT_EXPECT_FALSE(test, ret); 2388 break; 2389 } 2390 } 2391 } 2392 2393 static void cros_ec_proto_test_check_features_not_cached(struct kunit *test) 2394 { 2395 struct cros_ec_proto_test_priv *priv = test->priv; 2396 struct cros_ec_device *ec_dev = &priv->ec_dev; 2397 struct ec_xfer_mock *mock; 2398 int ret, i; 2399 static struct cros_ec_dev ec; 2400 2401 ec_dev->max_request = 0xff; 2402 ec_dev->max_response = 0xee; 2403 ec.ec_dev = ec_dev; 2404 ec.dev = ec_dev->dev; 2405 ec.cmd_offset = 0; 2406 ec.features.flags[0] = -1; 2407 ec.features.flags[1] = -1; 2408 2409 /* For EC_CMD_GET_FEATURES. */ 2410 { 2411 struct ec_response_get_features *data; 2412 2413 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 2414 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2415 2416 data = (struct ec_response_get_features *)mock->o_data; 2417 data->flags[0] = EC_FEATURE_MASK_0(EC_FEATURE_FINGERPRINT); 2418 data->flags[1] = EC_FEATURE_MASK_0(EC_FEATURE_SCP); 2419 } 2420 2421 for (i = 0; i < EC_FEATURE_TYPEC_MUX_REQUIRE_AP_ACK; ++i) { 2422 ret = cros_ec_check_features(&ec, i); 2423 switch (i) { 2424 case EC_FEATURE_FINGERPRINT: 2425 case EC_FEATURE_SCP: 2426 KUNIT_EXPECT_TRUE(test, ret); 2427 break; 2428 default: 2429 KUNIT_EXPECT_FALSE(test, ret); 2430 break; 2431 } 2432 } 2433 2434 /* For EC_CMD_GET_FEATURES. */ 2435 { 2436 mock = cros_kunit_ec_xfer_mock_next(); 2437 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2438 2439 KUNIT_EXPECT_EQ(test, mock->msg.version, 0); 2440 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_FEATURES); 2441 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_get_features)); 2442 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0); 2443 } 2444 } 2445 2446 static void cros_ec_proto_test_get_sensor_count_normal(struct kunit *test) 2447 { 2448 struct cros_ec_proto_test_priv *priv = test->priv; 2449 struct cros_ec_device *ec_dev = &priv->ec_dev; 2450 struct ec_xfer_mock *mock; 2451 int ret; 2452 static struct cros_ec_dev ec; 2453 2454 ec_dev->max_request = 0xff; 2455 ec_dev->max_response = 0xee; 2456 ec.ec_dev = ec_dev; 2457 ec.dev = ec_dev->dev; 2458 ec.cmd_offset = 0; 2459 2460 /* For EC_CMD_MOTION_SENSE_CMD. */ 2461 { 2462 struct ec_response_motion_sense *data; 2463 2464 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data)); 2465 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2466 2467 data = (struct ec_response_motion_sense *)mock->o_data; 2468 data->dump.sensor_count = 0xbf; 2469 } 2470 2471 ret = cros_ec_get_sensor_count(&ec); 2472 KUNIT_EXPECT_EQ(test, ret, 0xbf); 2473 2474 /* For EC_CMD_MOTION_SENSE_CMD. */ 2475 { 2476 struct ec_params_motion_sense *data; 2477 2478 mock = cros_kunit_ec_xfer_mock_next(); 2479 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2480 2481 KUNIT_EXPECT_EQ(test, mock->msg.version, 1); 2482 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MOTION_SENSE_CMD); 2483 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_motion_sense)); 2484 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 2485 2486 data = (struct ec_params_motion_sense *)mock->i_data; 2487 KUNIT_EXPECT_EQ(test, data->cmd, MOTIONSENSE_CMD_DUMP); 2488 } 2489 } 2490 2491 static void cros_ec_proto_test_get_sensor_count_xfer_error(struct kunit *test) 2492 { 2493 struct cros_ec_proto_test_priv *priv = test->priv; 2494 struct cros_ec_device *ec_dev = &priv->ec_dev; 2495 struct ec_xfer_mock *mock; 2496 int ret; 2497 static struct cros_ec_dev ec; 2498 2499 ec_dev->max_request = 0xff; 2500 ec_dev->max_response = 0xee; 2501 ec.ec_dev = ec_dev; 2502 ec.dev = ec_dev->dev; 2503 ec.cmd_offset = 0; 2504 2505 /* For EC_CMD_MOTION_SENSE_CMD. */ 2506 { 2507 mock = cros_kunit_ec_xfer_mock_addx(test, -EPROTO, EC_RES_SUCCESS, 0); 2508 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2509 } 2510 2511 ret = cros_ec_get_sensor_count(&ec); 2512 KUNIT_EXPECT_EQ(test, ret, -EPROTO); 2513 2514 /* For EC_CMD_MOTION_SENSE_CMD. */ 2515 { 2516 struct ec_params_motion_sense *data; 2517 2518 mock = cros_kunit_ec_xfer_mock_next(); 2519 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2520 2521 KUNIT_EXPECT_EQ(test, mock->msg.version, 1); 2522 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MOTION_SENSE_CMD); 2523 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_motion_sense)); 2524 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 2525 2526 data = (struct ec_params_motion_sense *)mock->i_data; 2527 KUNIT_EXPECT_EQ(test, data->cmd, MOTIONSENSE_CMD_DUMP); 2528 } 2529 } 2530 2531 static void cros_ec_proto_test_get_sensor_count_legacy(struct kunit *test) 2532 { 2533 struct cros_ec_proto_test_priv *priv = test->priv; 2534 struct cros_ec_device *ec_dev = &priv->ec_dev; 2535 struct ec_xfer_mock *mock; 2536 int ret, i; 2537 static struct cros_ec_dev ec; 2538 struct { 2539 u8 readmem_data; 2540 int expected_result; 2541 } test_data[] = { 2542 { 0, 0 }, 2543 { EC_MEMMAP_ACC_STATUS_PRESENCE_BIT, 2 }, 2544 }; 2545 2546 ec_dev->max_request = 0xff; 2547 ec_dev->max_response = 0xee; 2548 ec_dev->cmd_readmem = cros_kunit_readmem_mock; 2549 ec.ec_dev = ec_dev; 2550 ec.dev = ec_dev->dev; 2551 ec.cmd_offset = 0; 2552 2553 for (i = 0; i < ARRAY_SIZE(test_data); ++i) { 2554 /* For EC_CMD_MOTION_SENSE_CMD. */ 2555 { 2556 mock = cros_kunit_ec_xfer_mock_addx(test, -EPROTO, EC_RES_SUCCESS, 0); 2557 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2558 } 2559 2560 /* For readmem. */ 2561 { 2562 cros_kunit_readmem_mock_data = kunit_kzalloc(test, 1, GFP_KERNEL); 2563 KUNIT_ASSERT_PTR_NE(test, cros_kunit_readmem_mock_data, NULL); 2564 cros_kunit_readmem_mock_data[0] = test_data[i].readmem_data; 2565 2566 cros_kunit_ec_xfer_mock_default_ret = 1; 2567 } 2568 2569 ret = cros_ec_get_sensor_count(&ec); 2570 KUNIT_EXPECT_EQ(test, ret, test_data[i].expected_result); 2571 2572 /* For EC_CMD_MOTION_SENSE_CMD. */ 2573 { 2574 struct ec_params_motion_sense *data; 2575 2576 mock = cros_kunit_ec_xfer_mock_next(); 2577 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2578 2579 KUNIT_EXPECT_EQ(test, mock->msg.version, 1); 2580 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MOTION_SENSE_CMD); 2581 KUNIT_EXPECT_EQ(test, mock->msg.insize, 2582 sizeof(struct ec_response_motion_sense)); 2583 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data)); 2584 2585 data = (struct ec_params_motion_sense *)mock->i_data; 2586 KUNIT_EXPECT_EQ(test, data->cmd, MOTIONSENSE_CMD_DUMP); 2587 } 2588 2589 /* For readmem. */ 2590 { 2591 KUNIT_EXPECT_EQ(test, cros_kunit_readmem_mock_offset, EC_MEMMAP_ACC_STATUS); 2592 } 2593 } 2594 } 2595 2596 static void cros_ec_proto_test_ec_cmd(struct kunit *test) 2597 { 2598 struct cros_ec_proto_test_priv *priv = test->priv; 2599 struct cros_ec_device *ec_dev = &priv->ec_dev; 2600 struct ec_xfer_mock *mock; 2601 int ret; 2602 u8 out[3], in[2]; 2603 2604 ec_dev->max_request = 0xff; 2605 ec_dev->max_response = 0xee; 2606 2607 out[0] = 0xdd; 2608 out[1] = 0xcc; 2609 out[2] = 0xbb; 2610 2611 { 2612 u8 *data; 2613 2614 mock = cros_kunit_ec_xfer_mock_add(test, 2); 2615 KUNIT_ASSERT_PTR_NE(test, mock, NULL); 2616 2617 data = (u8 *)mock->o_data; 2618 data[0] = 0xaa; 2619 data[1] = 0x99; 2620 } 2621 2622 ret = cros_ec_cmd(ec_dev, 0x88, 0x77, out, ARRAY_SIZE(out), in, ARRAY_SIZE(in)); 2623 KUNIT_EXPECT_EQ(test, ret, 2); 2624 2625 { 2626 u8 *data; 2627 2628 mock = cros_kunit_ec_xfer_mock_next(); 2629 KUNIT_EXPECT_PTR_NE(test, mock, NULL); 2630 2631 KUNIT_EXPECT_EQ(test, mock->msg.version, 0x88); 2632 KUNIT_EXPECT_EQ(test, mock->msg.command, 0x77); 2633 KUNIT_EXPECT_EQ(test, mock->msg.insize, ARRAY_SIZE(in)); 2634 KUNIT_EXPECT_EQ(test, mock->msg.outsize, ARRAY_SIZE(out)); 2635 2636 data = (u8 *)mock->i_data; 2637 KUNIT_EXPECT_EQ(test, data[0], 0xdd); 2638 KUNIT_EXPECT_EQ(test, data[1], 0xcc); 2639 KUNIT_EXPECT_EQ(test, data[2], 0xbb); 2640 } 2641 } 2642 2643 static void cros_ec_proto_test_release(struct device *dev) 2644 { 2645 } 2646 2647 static int cros_ec_proto_test_init(struct kunit *test) 2648 { 2649 struct cros_ec_proto_test_priv *priv; 2650 struct cros_ec_device *ec_dev; 2651 2652 priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL); 2653 if (!priv) 2654 return -ENOMEM; 2655 test->priv = priv; 2656 2657 ec_dev = &priv->ec_dev; 2658 ec_dev->dout = (u8 *)priv->dout; 2659 ec_dev->dout_size = ARRAY_SIZE(priv->dout); 2660 ec_dev->din = (u8 *)priv->din; 2661 ec_dev->din_size = ARRAY_SIZE(priv->din); 2662 ec_dev->proto_version = EC_HOST_REQUEST_VERSION; 2663 ec_dev->dev = kunit_kzalloc(test, sizeof(*ec_dev->dev), GFP_KERNEL); 2664 if (!ec_dev->dev) 2665 return -ENOMEM; 2666 device_initialize(ec_dev->dev); 2667 dev_set_name(ec_dev->dev, "cros_ec_proto_test"); 2668 ec_dev->dev->release = cros_ec_proto_test_release; 2669 ec_dev->cmd_xfer = cros_kunit_ec_xfer_mock; 2670 ec_dev->pkt_xfer = cros_kunit_ec_xfer_mock; 2671 mutex_init(&ec_dev->lock); 2672 2673 priv->msg = (struct cros_ec_command *)priv->_msg; 2674 2675 cros_kunit_mock_reset(); 2676 2677 return 0; 2678 } 2679 2680 static void cros_ec_proto_test_exit(struct kunit *test) 2681 { 2682 struct cros_ec_proto_test_priv *priv = test->priv; 2683 struct cros_ec_device *ec_dev = &priv->ec_dev; 2684 2685 put_device(ec_dev->dev); 2686 } 2687 2688 static struct kunit_case cros_ec_proto_test_cases[] = { 2689 KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_normal), 2690 KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_bad_msg_outsize), 2691 KUNIT_CASE(cros_ec_proto_test_prepare_tx_normal), 2692 KUNIT_CASE(cros_ec_proto_test_prepare_tx_bad_msg_outsize), 2693 KUNIT_CASE(cros_ec_proto_test_check_result), 2694 KUNIT_CASE(cros_ec_proto_test_query_all_normal), 2695 KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return_error), 2696 KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return0), 2697 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return_error), 2698 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return0), 2699 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_xfer_error), 2700 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return_error), 2701 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error), 2702 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return0), 2703 KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp), 2704 KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return_error), 2705 KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return0), 2706 KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep), 2707 KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep_return0), 2708 KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error), 2709 KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return0), 2710 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_normal), 2711 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_insize), 2712 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_outsize_without_passthru), 2713 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_outsize_with_passthru), 2714 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v3_normal), 2715 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v3_no_op), 2716 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v2_normal), 2717 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v2_no_op), 2718 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_normal), 2719 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_retries_eagain), 2720 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_retries_status_processing), 2721 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_xfer_error), 2722 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_return_error), 2723 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_return0), 2724 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_status_normal), 2725 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_status_xfer_error), 2726 KUNIT_CASE(cros_ec_proto_test_cmd_xfer_status_return_error), 2727 KUNIT_CASE(cros_ec_proto_test_get_next_event_no_mkbp_event), 2728 KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_ec_suspended), 2729 KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_version0), 2730 KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_version2), 2731 KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_host_event_rtc), 2732 KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_host_event_masked), 2733 KUNIT_CASE(cros_ec_proto_test_get_host_event_no_mkbp_event), 2734 KUNIT_CASE(cros_ec_proto_test_get_host_event_not_host_event), 2735 KUNIT_CASE(cros_ec_proto_test_get_host_event_wrong_event_size), 2736 KUNIT_CASE(cros_ec_proto_test_get_host_event_normal), 2737 KUNIT_CASE(cros_ec_proto_test_check_features_cached), 2738 KUNIT_CASE(cros_ec_proto_test_check_features_not_cached), 2739 KUNIT_CASE(cros_ec_proto_test_get_sensor_count_normal), 2740 KUNIT_CASE(cros_ec_proto_test_get_sensor_count_xfer_error), 2741 KUNIT_CASE(cros_ec_proto_test_get_sensor_count_legacy), 2742 KUNIT_CASE(cros_ec_proto_test_ec_cmd), 2743 {} 2744 }; 2745 2746 static struct kunit_suite cros_ec_proto_test_suite = { 2747 .name = "cros_ec_proto_test", 2748 .init = cros_ec_proto_test_init, 2749 .exit = cros_ec_proto_test_exit, 2750 .test_cases = cros_ec_proto_test_cases, 2751 }; 2752 2753 kunit_test_suite(cros_ec_proto_test_suite); 2754 2755 MODULE_LICENSE("GPL"); 2756