1 // SPDX-License-Identifier: GPL-2.0 2 // ChromeOS EC communication protocol helper functions 3 // 4 // Copyright (C) 2015 Google, Inc 5 6 #include <linux/delay.h> 7 #include <linux/device.h> 8 #include <linux/module.h> 9 #include <linux/platform_data/cros_ec_commands.h> 10 #include <linux/platform_data/cros_ec_proto.h> 11 #include <linux/slab.h> 12 #include <asm/unaligned.h> 13 14 #include "cros_ec_trace.h" 15 16 #define EC_COMMAND_RETRIES 50 17 18 static const int cros_ec_error_map[] = { 19 [EC_RES_INVALID_COMMAND] = -EOPNOTSUPP, 20 [EC_RES_ERROR] = -EIO, 21 [EC_RES_INVALID_PARAM] = -EINVAL, 22 [EC_RES_ACCESS_DENIED] = -EACCES, 23 [EC_RES_INVALID_RESPONSE] = -EPROTO, 24 [EC_RES_INVALID_VERSION] = -ENOPROTOOPT, 25 [EC_RES_INVALID_CHECKSUM] = -EBADMSG, 26 [EC_RES_IN_PROGRESS] = -EINPROGRESS, 27 [EC_RES_UNAVAILABLE] = -ENODATA, 28 [EC_RES_TIMEOUT] = -ETIMEDOUT, 29 [EC_RES_OVERFLOW] = -EOVERFLOW, 30 [EC_RES_INVALID_HEADER] = -EBADR, 31 [EC_RES_REQUEST_TRUNCATED] = -EBADR, 32 [EC_RES_RESPONSE_TOO_BIG] = -EFBIG, 33 [EC_RES_BUS_ERROR] = -EFAULT, 34 [EC_RES_BUSY] = -EBUSY, 35 [EC_RES_INVALID_HEADER_VERSION] = -EBADMSG, 36 [EC_RES_INVALID_HEADER_CRC] = -EBADMSG, 37 [EC_RES_INVALID_DATA_CRC] = -EBADMSG, 38 [EC_RES_DUP_UNAVAILABLE] = -ENODATA, 39 }; 40 41 static int cros_ec_map_error(uint32_t result) 42 { 43 int ret = 0; 44 45 if (result != EC_RES_SUCCESS) { 46 if (result < ARRAY_SIZE(cros_ec_error_map) && cros_ec_error_map[result]) 47 ret = cros_ec_error_map[result]; 48 else 49 ret = -EPROTO; 50 } 51 52 return ret; 53 } 54 55 static int prepare_packet(struct cros_ec_device *ec_dev, 56 struct cros_ec_command *msg) 57 { 58 struct ec_host_request *request; 59 u8 *out; 60 int i; 61 u8 csum = 0; 62 63 BUG_ON(ec_dev->proto_version != EC_HOST_REQUEST_VERSION); 64 BUG_ON(msg->outsize + sizeof(*request) > ec_dev->dout_size); 65 66 out = ec_dev->dout; 67 request = (struct ec_host_request *)out; 68 request->struct_version = EC_HOST_REQUEST_VERSION; 69 request->checksum = 0; 70 request->command = msg->command; 71 request->command_version = msg->version; 72 request->reserved = 0; 73 request->data_len = msg->outsize; 74 75 for (i = 0; i < sizeof(*request); i++) 76 csum += out[i]; 77 78 /* Copy data and update checksum */ 79 memcpy(out + sizeof(*request), msg->data, msg->outsize); 80 for (i = 0; i < msg->outsize; i++) 81 csum += msg->data[i]; 82 83 request->checksum = -csum; 84 85 return sizeof(*request) + msg->outsize; 86 } 87 88 static int send_command(struct cros_ec_device *ec_dev, 89 struct cros_ec_command *msg) 90 { 91 int ret; 92 int (*xfer_fxn)(struct cros_ec_device *ec, struct cros_ec_command *msg); 93 94 if (ec_dev->proto_version > 2) 95 xfer_fxn = ec_dev->pkt_xfer; 96 else 97 xfer_fxn = ec_dev->cmd_xfer; 98 99 if (!xfer_fxn) { 100 /* 101 * This error can happen if a communication error happened and 102 * the EC is trying to use protocol v2, on an underlying 103 * communication mechanism that does not support v2. 104 */ 105 dev_err_once(ec_dev->dev, 106 "missing EC transfer API, cannot send command\n"); 107 return -EIO; 108 } 109 110 trace_cros_ec_request_start(msg); 111 ret = (*xfer_fxn)(ec_dev, msg); 112 trace_cros_ec_request_done(msg, ret); 113 if (msg->result == EC_RES_IN_PROGRESS) { 114 int i; 115 struct cros_ec_command *status_msg; 116 struct ec_response_get_comms_status *status; 117 118 status_msg = kmalloc(sizeof(*status_msg) + sizeof(*status), 119 GFP_KERNEL); 120 if (!status_msg) 121 return -ENOMEM; 122 123 status_msg->version = 0; 124 status_msg->command = EC_CMD_GET_COMMS_STATUS; 125 status_msg->insize = sizeof(*status); 126 status_msg->outsize = 0; 127 128 /* 129 * Query the EC's status until it's no longer busy or 130 * we encounter an error. 131 */ 132 for (i = 0; i < EC_COMMAND_RETRIES; i++) { 133 usleep_range(10000, 11000); 134 135 trace_cros_ec_request_start(status_msg); 136 ret = (*xfer_fxn)(ec_dev, status_msg); 137 trace_cros_ec_request_done(status_msg, ret); 138 if (ret == -EAGAIN) 139 continue; 140 if (ret < 0) 141 break; 142 143 msg->result = status_msg->result; 144 if (status_msg->result != EC_RES_SUCCESS) 145 break; 146 147 status = (struct ec_response_get_comms_status *) 148 status_msg->data; 149 if (!(status->flags & EC_COMMS_STATUS_PROCESSING)) 150 break; 151 } 152 153 kfree(status_msg); 154 } 155 156 return ret; 157 } 158 159 /** 160 * cros_ec_prepare_tx() - Prepare an outgoing message in the output buffer. 161 * @ec_dev: Device to register. 162 * @msg: Message to write. 163 * 164 * This is intended to be used by all ChromeOS EC drivers, but at present 165 * only SPI uses it. Once LPC uses the same protocol it can start using it. 166 * I2C could use it now, with a refactor of the existing code. 167 * 168 * Return: 0 on success or negative error code. 169 */ 170 int cros_ec_prepare_tx(struct cros_ec_device *ec_dev, 171 struct cros_ec_command *msg) 172 { 173 u8 *out; 174 u8 csum; 175 int i; 176 177 if (ec_dev->proto_version > 2) 178 return prepare_packet(ec_dev, msg); 179 180 BUG_ON(msg->outsize > EC_PROTO2_MAX_PARAM_SIZE); 181 out = ec_dev->dout; 182 out[0] = EC_CMD_VERSION0 + msg->version; 183 out[1] = msg->command; 184 out[2] = msg->outsize; 185 csum = out[0] + out[1] + out[2]; 186 for (i = 0; i < msg->outsize; i++) 187 csum += out[EC_MSG_TX_HEADER_BYTES + i] = msg->data[i]; 188 out[EC_MSG_TX_HEADER_BYTES + msg->outsize] = csum; 189 190 return EC_MSG_TX_PROTO_BYTES + msg->outsize; 191 } 192 EXPORT_SYMBOL(cros_ec_prepare_tx); 193 194 /** 195 * cros_ec_check_result() - Check ec_msg->result. 196 * @ec_dev: EC device. 197 * @msg: Message to check. 198 * 199 * This is used by ChromeOS EC drivers to check the ec_msg->result for 200 * errors and to warn about them. 201 * 202 * Return: 0 on success or negative error code. 203 */ 204 int cros_ec_check_result(struct cros_ec_device *ec_dev, 205 struct cros_ec_command *msg) 206 { 207 switch (msg->result) { 208 case EC_RES_SUCCESS: 209 return 0; 210 case EC_RES_IN_PROGRESS: 211 dev_dbg(ec_dev->dev, "command 0x%02x in progress\n", 212 msg->command); 213 return -EAGAIN; 214 default: 215 dev_dbg(ec_dev->dev, "command 0x%02x returned %d\n", 216 msg->command, msg->result); 217 return 0; 218 } 219 } 220 EXPORT_SYMBOL(cros_ec_check_result); 221 222 /* 223 * cros_ec_get_host_event_wake_mask 224 * 225 * Get the mask of host events that cause wake from suspend. 226 * 227 * @ec_dev: EC device to call 228 * @msg: message structure to use 229 * @mask: result when function returns >=0. 230 * 231 * LOCKING: 232 * the caller has ec_dev->lock mutex, or the caller knows there is 233 * no other command in progress. 234 */ 235 static int cros_ec_get_host_event_wake_mask(struct cros_ec_device *ec_dev, 236 struct cros_ec_command *msg, 237 uint32_t *mask) 238 { 239 struct ec_response_host_event_mask *r; 240 int ret; 241 242 msg->command = EC_CMD_HOST_EVENT_GET_WAKE_MASK; 243 msg->version = 0; 244 msg->outsize = 0; 245 msg->insize = sizeof(*r); 246 247 ret = send_command(ec_dev, msg); 248 if (ret >= 0) { 249 if (msg->result == EC_RES_INVALID_COMMAND) 250 return -EOPNOTSUPP; 251 if (msg->result != EC_RES_SUCCESS) 252 return -EPROTO; 253 } 254 if (ret > 0) { 255 r = (struct ec_response_host_event_mask *)msg->data; 256 *mask = r->mask; 257 } 258 259 return ret; 260 } 261 262 static int cros_ec_host_command_proto_query(struct cros_ec_device *ec_dev, 263 int devidx, 264 struct cros_ec_command *msg) 265 { 266 /* 267 * Try using v3+ to query for supported protocols. If this 268 * command fails, fall back to v2. Returns the highest protocol 269 * supported by the EC. 270 * Also sets the max request/response/passthru size. 271 */ 272 int ret; 273 274 if (!ec_dev->pkt_xfer) 275 return -EPROTONOSUPPORT; 276 277 memset(msg, 0, sizeof(*msg)); 278 msg->command = EC_CMD_PASSTHRU_OFFSET(devidx) | EC_CMD_GET_PROTOCOL_INFO; 279 msg->insize = sizeof(struct ec_response_get_protocol_info); 280 281 ret = send_command(ec_dev, msg); 282 283 if (ret < 0) { 284 dev_dbg(ec_dev->dev, 285 "failed to check for EC[%d] protocol version: %d\n", 286 devidx, ret); 287 return ret; 288 } 289 290 if (devidx > 0 && msg->result == EC_RES_INVALID_COMMAND) 291 return -ENODEV; 292 else if (msg->result != EC_RES_SUCCESS) 293 return msg->result; 294 295 return 0; 296 } 297 298 static int cros_ec_host_command_proto_query_v2(struct cros_ec_device *ec_dev) 299 { 300 struct cros_ec_command *msg; 301 struct ec_params_hello *hello_params; 302 struct ec_response_hello *hello_response; 303 int ret; 304 int len = max(sizeof(*hello_params), sizeof(*hello_response)); 305 306 msg = kmalloc(sizeof(*msg) + len, GFP_KERNEL); 307 if (!msg) 308 return -ENOMEM; 309 310 msg->version = 0; 311 msg->command = EC_CMD_HELLO; 312 hello_params = (struct ec_params_hello *)msg->data; 313 msg->outsize = sizeof(*hello_params); 314 hello_response = (struct ec_response_hello *)msg->data; 315 msg->insize = sizeof(*hello_response); 316 317 hello_params->in_data = 0xa0b0c0d0; 318 319 ret = send_command(ec_dev, msg); 320 321 if (ret < 0) { 322 dev_dbg(ec_dev->dev, 323 "EC failed to respond to v2 hello: %d\n", 324 ret); 325 goto exit; 326 } else if (msg->result != EC_RES_SUCCESS) { 327 dev_err(ec_dev->dev, 328 "EC responded to v2 hello with error: %d\n", 329 msg->result); 330 ret = msg->result; 331 goto exit; 332 } else if (hello_response->out_data != 0xa1b2c3d4) { 333 dev_err(ec_dev->dev, 334 "EC responded to v2 hello with bad result: %u\n", 335 hello_response->out_data); 336 ret = -EBADMSG; 337 goto exit; 338 } 339 340 ret = 0; 341 342 exit: 343 kfree(msg); 344 return ret; 345 } 346 347 /* 348 * cros_ec_get_host_command_version_mask 349 * 350 * Get the version mask of a given command. 351 * 352 * @ec_dev: EC device to call 353 * @msg: message structure to use 354 * @cmd: command to get the version of. 355 * @mask: result when function returns 0. 356 * 357 * @return 0 on success, error code otherwise 358 * 359 * LOCKING: 360 * the caller has ec_dev->lock mutex or the caller knows there is 361 * no other command in progress. 362 */ 363 static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev, 364 u16 cmd, u32 *mask) 365 { 366 struct ec_params_get_cmd_versions *pver; 367 struct ec_response_get_cmd_versions *rver; 368 struct cros_ec_command *msg; 369 int ret; 370 371 msg = kmalloc(sizeof(*msg) + max(sizeof(*rver), sizeof(*pver)), 372 GFP_KERNEL); 373 if (!msg) 374 return -ENOMEM; 375 376 msg->version = 0; 377 msg->command = EC_CMD_GET_CMD_VERSIONS; 378 msg->insize = sizeof(*rver); 379 msg->outsize = sizeof(*pver); 380 381 pver = (struct ec_params_get_cmd_versions *)msg->data; 382 pver->cmd = cmd; 383 384 ret = send_command(ec_dev, msg); 385 if (ret > 0) { 386 rver = (struct ec_response_get_cmd_versions *)msg->data; 387 *mask = rver->version_mask; 388 } 389 390 kfree(msg); 391 392 return ret; 393 } 394 395 /** 396 * cros_ec_query_all() - Query the protocol version supported by the 397 * ChromeOS EC. 398 * @ec_dev: Device to register. 399 * 400 * Return: 0 on success or negative error code. 401 */ 402 int cros_ec_query_all(struct cros_ec_device *ec_dev) 403 { 404 struct device *dev = ec_dev->dev; 405 struct cros_ec_command *proto_msg; 406 struct ec_response_get_protocol_info *proto_info; 407 u32 ver_mask = 0; 408 int ret; 409 410 proto_msg = kzalloc(sizeof(*proto_msg) + sizeof(*proto_info), 411 GFP_KERNEL); 412 if (!proto_msg) 413 return -ENOMEM; 414 415 /* First try sending with proto v3. */ 416 ec_dev->proto_version = 3; 417 ret = cros_ec_host_command_proto_query(ec_dev, 0, proto_msg); 418 419 if (ret == 0) { 420 proto_info = (struct ec_response_get_protocol_info *) 421 proto_msg->data; 422 ec_dev->max_request = proto_info->max_request_packet_size - 423 sizeof(struct ec_host_request); 424 ec_dev->max_response = proto_info->max_response_packet_size - 425 sizeof(struct ec_host_response); 426 ec_dev->proto_version = 427 min(EC_HOST_REQUEST_VERSION, 428 fls(proto_info->protocol_versions) - 1); 429 dev_dbg(ec_dev->dev, 430 "using proto v%u\n", 431 ec_dev->proto_version); 432 433 ec_dev->din_size = ec_dev->max_response + 434 sizeof(struct ec_host_response) + 435 EC_MAX_RESPONSE_OVERHEAD; 436 ec_dev->dout_size = ec_dev->max_request + 437 sizeof(struct ec_host_request) + 438 EC_MAX_REQUEST_OVERHEAD; 439 440 /* 441 * Check for PD 442 */ 443 ret = cros_ec_host_command_proto_query(ec_dev, 1, proto_msg); 444 445 if (ret) { 446 dev_dbg(ec_dev->dev, "no PD chip found: %d\n", ret); 447 ec_dev->max_passthru = 0; 448 } else { 449 dev_dbg(ec_dev->dev, "found PD chip\n"); 450 ec_dev->max_passthru = 451 proto_info->max_request_packet_size - 452 sizeof(struct ec_host_request); 453 } 454 } else { 455 /* Try querying with a v2 hello message. */ 456 ec_dev->proto_version = 2; 457 ret = cros_ec_host_command_proto_query_v2(ec_dev); 458 459 if (ret == 0) { 460 /* V2 hello succeeded. */ 461 dev_dbg(ec_dev->dev, "falling back to proto v2\n"); 462 463 ec_dev->max_request = EC_PROTO2_MAX_PARAM_SIZE; 464 ec_dev->max_response = EC_PROTO2_MAX_PARAM_SIZE; 465 ec_dev->max_passthru = 0; 466 ec_dev->pkt_xfer = NULL; 467 ec_dev->din_size = EC_PROTO2_MSG_BYTES; 468 ec_dev->dout_size = EC_PROTO2_MSG_BYTES; 469 } else { 470 /* 471 * It's possible for a test to occur too early when 472 * the EC isn't listening. If this happens, we'll 473 * test later when the first command is run. 474 */ 475 ec_dev->proto_version = EC_PROTO_VERSION_UNKNOWN; 476 dev_dbg(ec_dev->dev, "EC query failed: %d\n", ret); 477 goto exit; 478 } 479 } 480 481 devm_kfree(dev, ec_dev->din); 482 devm_kfree(dev, ec_dev->dout); 483 484 ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL); 485 if (!ec_dev->din) { 486 ret = -ENOMEM; 487 goto exit; 488 } 489 490 ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL); 491 if (!ec_dev->dout) { 492 devm_kfree(dev, ec_dev->din); 493 ret = -ENOMEM; 494 goto exit; 495 } 496 497 /* Probe if MKBP event is supported */ 498 ret = cros_ec_get_host_command_version_mask(ec_dev, 499 EC_CMD_GET_NEXT_EVENT, 500 &ver_mask); 501 if (ret < 0 || ver_mask == 0) 502 ec_dev->mkbp_event_supported = 0; 503 else 504 ec_dev->mkbp_event_supported = fls(ver_mask); 505 506 dev_dbg(ec_dev->dev, "MKBP support version %u\n", 507 ec_dev->mkbp_event_supported - 1); 508 509 /* Probe if host sleep v1 is supported for S0ix failure detection. */ 510 ret = cros_ec_get_host_command_version_mask(ec_dev, 511 EC_CMD_HOST_SLEEP_EVENT, 512 &ver_mask); 513 ec_dev->host_sleep_v1 = (ret >= 0 && (ver_mask & EC_VER_MASK(1))); 514 515 /* Get host event wake mask. */ 516 ret = cros_ec_get_host_event_wake_mask(ec_dev, proto_msg, 517 &ec_dev->host_event_wake_mask); 518 if (ret < 0) { 519 /* 520 * If the EC doesn't support EC_CMD_HOST_EVENT_GET_WAKE_MASK, 521 * use a reasonable default. Note that we ignore various 522 * battery, AC status, and power-state events, because (a) 523 * those can be quite common (e.g., when sitting at full 524 * charge, on AC) and (b) these are not actionable wake events; 525 * if anything, we'd like to continue suspending (to save 526 * power), not wake up. 527 */ 528 ec_dev->host_event_wake_mask = U32_MAX & 529 ~(BIT(EC_HOST_EVENT_AC_DISCONNECTED) | 530 BIT(EC_HOST_EVENT_BATTERY_LOW) | 531 BIT(EC_HOST_EVENT_BATTERY_CRITICAL) | 532 BIT(EC_HOST_EVENT_PD_MCU) | 533 BIT(EC_HOST_EVENT_BATTERY_STATUS)); 534 /* 535 * Old ECs may not support this command. Complain about all 536 * other errors. 537 */ 538 if (ret != -EOPNOTSUPP) 539 dev_err(ec_dev->dev, 540 "failed to retrieve wake mask: %d\n", ret); 541 } 542 543 ret = 0; 544 545 exit: 546 kfree(proto_msg); 547 return ret; 548 } 549 EXPORT_SYMBOL(cros_ec_query_all); 550 551 /** 552 * cros_ec_cmd_xfer_status() - Send a command to the ChromeOS EC. 553 * @ec_dev: EC device. 554 * @msg: Message to write. 555 * 556 * Call this to send a command to the ChromeOS EC. This should be used instead of calling the EC's 557 * cmd_xfer() callback directly. It returns success status only if both the command was transmitted 558 * successfully and the EC replied with success status. 559 * 560 * Return: 561 * >=0 - The number of bytes transferred 562 * <0 - Linux error code 563 */ 564 int cros_ec_cmd_xfer_status(struct cros_ec_device *ec_dev, 565 struct cros_ec_command *msg) 566 { 567 int ret, mapped; 568 569 mutex_lock(&ec_dev->lock); 570 if (ec_dev->proto_version == EC_PROTO_VERSION_UNKNOWN) { 571 ret = cros_ec_query_all(ec_dev); 572 if (ret) { 573 dev_err(ec_dev->dev, 574 "EC version unknown and query failed; aborting command\n"); 575 mutex_unlock(&ec_dev->lock); 576 return ret; 577 } 578 } 579 580 if (msg->insize > ec_dev->max_response) { 581 dev_dbg(ec_dev->dev, "clamping message receive buffer\n"); 582 msg->insize = ec_dev->max_response; 583 } 584 585 if (msg->command < EC_CMD_PASSTHRU_OFFSET(1)) { 586 if (msg->outsize > ec_dev->max_request) { 587 dev_err(ec_dev->dev, 588 "request of size %u is too big (max: %u)\n", 589 msg->outsize, 590 ec_dev->max_request); 591 mutex_unlock(&ec_dev->lock); 592 return -EMSGSIZE; 593 } 594 } else { 595 if (msg->outsize > ec_dev->max_passthru) { 596 dev_err(ec_dev->dev, 597 "passthru rq of size %u is too big (max: %u)\n", 598 msg->outsize, 599 ec_dev->max_passthru); 600 mutex_unlock(&ec_dev->lock); 601 return -EMSGSIZE; 602 } 603 } 604 605 ret = send_command(ec_dev, msg); 606 mutex_unlock(&ec_dev->lock); 607 608 mapped = cros_ec_map_error(msg->result); 609 if (mapped) { 610 dev_dbg(ec_dev->dev, "Command result (err: %d [%d])\n", 611 msg->result, mapped); 612 ret = mapped; 613 } 614 615 return ret; 616 } 617 EXPORT_SYMBOL(cros_ec_cmd_xfer_status); 618 619 static int get_next_event_xfer(struct cros_ec_device *ec_dev, 620 struct cros_ec_command *msg, 621 struct ec_response_get_next_event_v1 *event, 622 int version, uint32_t size) 623 { 624 int ret; 625 626 msg->version = version; 627 msg->command = EC_CMD_GET_NEXT_EVENT; 628 msg->insize = size; 629 msg->outsize = 0; 630 631 ret = cros_ec_cmd_xfer_status(ec_dev, msg); 632 if (ret > 0) { 633 ec_dev->event_size = ret - 1; 634 ec_dev->event_data = *event; 635 } 636 637 return ret; 638 } 639 640 static int get_next_event(struct cros_ec_device *ec_dev) 641 { 642 struct { 643 struct cros_ec_command msg; 644 struct ec_response_get_next_event_v1 event; 645 } __packed buf; 646 struct cros_ec_command *msg = &buf.msg; 647 struct ec_response_get_next_event_v1 *event = &buf.event; 648 const int cmd_version = ec_dev->mkbp_event_supported - 1; 649 650 memset(msg, 0, sizeof(*msg)); 651 if (ec_dev->suspended) { 652 dev_dbg(ec_dev->dev, "Device suspended.\n"); 653 return -EHOSTDOWN; 654 } 655 656 if (cmd_version == 0) 657 return get_next_event_xfer(ec_dev, msg, event, 0, 658 sizeof(struct ec_response_get_next_event)); 659 660 return get_next_event_xfer(ec_dev, msg, event, cmd_version, 661 sizeof(struct ec_response_get_next_event_v1)); 662 } 663 664 static int get_keyboard_state_event(struct cros_ec_device *ec_dev) 665 { 666 u8 buffer[sizeof(struct cros_ec_command) + 667 sizeof(ec_dev->event_data.data)]; 668 struct cros_ec_command *msg = (struct cros_ec_command *)&buffer; 669 670 msg->version = 0; 671 msg->command = EC_CMD_MKBP_STATE; 672 msg->insize = sizeof(ec_dev->event_data.data); 673 msg->outsize = 0; 674 675 ec_dev->event_size = cros_ec_cmd_xfer_status(ec_dev, msg); 676 ec_dev->event_data.event_type = EC_MKBP_EVENT_KEY_MATRIX; 677 memcpy(&ec_dev->event_data.data, msg->data, 678 sizeof(ec_dev->event_data.data)); 679 680 return ec_dev->event_size; 681 } 682 683 /** 684 * cros_ec_get_next_event() - Fetch next event from the ChromeOS EC. 685 * @ec_dev: Device to fetch event from. 686 * @wake_event: Pointer to a bool set to true upon return if the event might be 687 * treated as a wake event. Ignored if null. 688 * @has_more_events: Pointer to bool set to true if more than one event is 689 * pending. 690 * Some EC will set this flag to indicate cros_ec_get_next_event() 691 * can be called multiple times in a row. 692 * It is an optimization to prevent issuing a EC command for 693 * nothing or wait for another interrupt from the EC to process 694 * the next message. 695 * Ignored if null. 696 * 697 * Return: negative error code on errors; 0 for no data; or else number of 698 * bytes received (i.e., an event was retrieved successfully). Event types are 699 * written out to @ec_dev->event_data.event_type on success. 700 */ 701 int cros_ec_get_next_event(struct cros_ec_device *ec_dev, 702 bool *wake_event, 703 bool *has_more_events) 704 { 705 u8 event_type; 706 u32 host_event; 707 int ret; 708 709 /* 710 * Default value for wake_event. 711 * Wake up on keyboard event, wake up for spurious interrupt or link 712 * error to the EC. 713 */ 714 if (wake_event) 715 *wake_event = true; 716 717 /* 718 * Default value for has_more_events. 719 * EC will raise another interrupt if AP does not process all events 720 * anyway. 721 */ 722 if (has_more_events) 723 *has_more_events = false; 724 725 if (!ec_dev->mkbp_event_supported) 726 return get_keyboard_state_event(ec_dev); 727 728 ret = get_next_event(ec_dev); 729 if (ret <= 0) 730 return ret; 731 732 if (has_more_events) 733 *has_more_events = ec_dev->event_data.event_type & 734 EC_MKBP_HAS_MORE_EVENTS; 735 ec_dev->event_data.event_type &= EC_MKBP_EVENT_TYPE_MASK; 736 737 if (wake_event) { 738 event_type = ec_dev->event_data.event_type; 739 host_event = cros_ec_get_host_event(ec_dev); 740 741 /* 742 * Sensor events need to be parsed by the sensor sub-device. 743 * Defer them, and don't report the wakeup here. 744 */ 745 if (event_type == EC_MKBP_EVENT_SENSOR_FIFO) { 746 *wake_event = false; 747 } else if (host_event) { 748 /* rtc_update_irq() already handles wakeup events. */ 749 if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC)) 750 *wake_event = false; 751 /* Masked host-events should not count as wake events. */ 752 if (!(host_event & ec_dev->host_event_wake_mask)) 753 *wake_event = false; 754 } 755 } 756 757 return ret; 758 } 759 EXPORT_SYMBOL(cros_ec_get_next_event); 760 761 /** 762 * cros_ec_get_host_event() - Return a mask of event set by the ChromeOS EC. 763 * @ec_dev: Device to fetch event from. 764 * 765 * When MKBP is supported, when the EC raises an interrupt, we collect the 766 * events raised and call the functions in the ec notifier. This function 767 * is a helper to know which events are raised. 768 * 769 * Return: 0 on error or non-zero bitmask of one or more EC_HOST_EVENT_*. 770 */ 771 u32 cros_ec_get_host_event(struct cros_ec_device *ec_dev) 772 { 773 u32 host_event; 774 775 BUG_ON(!ec_dev->mkbp_event_supported); 776 777 if (ec_dev->event_data.event_type != EC_MKBP_EVENT_HOST_EVENT) 778 return 0; 779 780 if (ec_dev->event_size != sizeof(host_event)) { 781 dev_warn(ec_dev->dev, "Invalid host event size\n"); 782 return 0; 783 } 784 785 host_event = get_unaligned_le32(&ec_dev->event_data.data.host_event); 786 787 return host_event; 788 } 789 EXPORT_SYMBOL(cros_ec_get_host_event); 790 791 /** 792 * cros_ec_check_features() - Test for the presence of EC features 793 * 794 * @ec: EC device, does not have to be connected directly to the AP, 795 * can be daisy chained through another device. 796 * @feature: One of ec_feature_code bit. 797 * 798 * Call this function to test whether the ChromeOS EC supports a feature. 799 * 800 * Return: 1 if supported, 0 if not 801 */ 802 int cros_ec_check_features(struct cros_ec_dev *ec, int feature) 803 { 804 struct cros_ec_command *msg; 805 int ret; 806 807 if (ec->features[0] == -1U && ec->features[1] == -1U) { 808 /* features bitmap not read yet */ 809 msg = kzalloc(sizeof(*msg) + sizeof(ec->features), GFP_KERNEL); 810 if (!msg) 811 return -ENOMEM; 812 813 msg->command = EC_CMD_GET_FEATURES + ec->cmd_offset; 814 msg->insize = sizeof(ec->features); 815 816 ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg); 817 if (ret < 0) { 818 dev_warn(ec->dev, "cannot get EC features: %d/%d\n", 819 ret, msg->result); 820 memset(ec->features, 0, sizeof(ec->features)); 821 } else { 822 memcpy(ec->features, msg->data, sizeof(ec->features)); 823 } 824 825 dev_dbg(ec->dev, "EC features %08x %08x\n", 826 ec->features[0], ec->features[1]); 827 828 kfree(msg); 829 } 830 831 return ec->features[feature / 32] & EC_FEATURE_MASK_0(feature); 832 } 833 EXPORT_SYMBOL_GPL(cros_ec_check_features); 834 835 /** 836 * cros_ec_get_sensor_count() - Return the number of MEMS sensors supported. 837 * 838 * @ec: EC device, does not have to be connected directly to the AP, 839 * can be daisy chained through another device. 840 * Return: < 0 in case of error. 841 */ 842 int cros_ec_get_sensor_count(struct cros_ec_dev *ec) 843 { 844 /* 845 * Issue a command to get the number of sensor reported. 846 * If not supported, check for legacy mode. 847 */ 848 int ret, sensor_count; 849 struct ec_params_motion_sense *params; 850 struct ec_response_motion_sense *resp; 851 struct cros_ec_command *msg; 852 struct cros_ec_device *ec_dev = ec->ec_dev; 853 u8 status; 854 855 msg = kzalloc(sizeof(*msg) + max(sizeof(*params), sizeof(*resp)), 856 GFP_KERNEL); 857 if (!msg) 858 return -ENOMEM; 859 860 msg->version = 1; 861 msg->command = EC_CMD_MOTION_SENSE_CMD + ec->cmd_offset; 862 msg->outsize = sizeof(*params); 863 msg->insize = sizeof(*resp); 864 865 params = (struct ec_params_motion_sense *)msg->data; 866 params->cmd = MOTIONSENSE_CMD_DUMP; 867 868 ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg); 869 if (ret < 0) { 870 sensor_count = ret; 871 } else { 872 resp = (struct ec_response_motion_sense *)msg->data; 873 sensor_count = resp->dump.sensor_count; 874 } 875 kfree(msg); 876 877 /* 878 * Check legacy mode: Let's find out if sensors are accessible 879 * via LPC interface. 880 */ 881 if (sensor_count < 0 && ec->cmd_offset == 0 && ec_dev->cmd_readmem) { 882 ret = ec_dev->cmd_readmem(ec_dev, EC_MEMMAP_ACC_STATUS, 883 1, &status); 884 if (ret >= 0 && 885 (status & EC_MEMMAP_ACC_STATUS_PRESENCE_BIT)) { 886 /* 887 * We have 2 sensors, one in the lid, one in the base. 888 */ 889 sensor_count = 2; 890 } else { 891 /* 892 * EC uses LPC interface and no sensors are presented. 893 */ 894 sensor_count = 0; 895 } 896 } 897 return sensor_count; 898 } 899 EXPORT_SYMBOL_GPL(cros_ec_get_sensor_count); 900