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