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 * Send command once again when timeout occurred. 284 * Fingerprint MCU (FPMCU) is restarted during system boot which 285 * introduces small window in which FPMCU won't respond for any 286 * messages sent by kernel. There is no need to wait before next 287 * attempt because we waited at least EC_MSG_DEADLINE_MS. 288 */ 289 if (ret == -ETIMEDOUT) 290 ret = send_command(ec_dev, msg); 291 292 if (ret < 0) { 293 dev_dbg(ec_dev->dev, 294 "failed to check for EC[%d] protocol version: %d\n", 295 devidx, ret); 296 return ret; 297 } 298 299 if (devidx > 0 && msg->result == EC_RES_INVALID_COMMAND) 300 return -ENODEV; 301 else if (msg->result != EC_RES_SUCCESS) 302 return msg->result; 303 304 return 0; 305 } 306 307 static int cros_ec_host_command_proto_query_v2(struct cros_ec_device *ec_dev) 308 { 309 struct cros_ec_command *msg; 310 struct ec_params_hello *hello_params; 311 struct ec_response_hello *hello_response; 312 int ret; 313 int len = max(sizeof(*hello_params), sizeof(*hello_response)); 314 315 msg = kmalloc(sizeof(*msg) + len, GFP_KERNEL); 316 if (!msg) 317 return -ENOMEM; 318 319 msg->version = 0; 320 msg->command = EC_CMD_HELLO; 321 hello_params = (struct ec_params_hello *)msg->data; 322 msg->outsize = sizeof(*hello_params); 323 hello_response = (struct ec_response_hello *)msg->data; 324 msg->insize = sizeof(*hello_response); 325 326 hello_params->in_data = 0xa0b0c0d0; 327 328 ret = send_command(ec_dev, msg); 329 330 if (ret < 0) { 331 dev_dbg(ec_dev->dev, 332 "EC failed to respond to v2 hello: %d\n", 333 ret); 334 goto exit; 335 } else if (msg->result != EC_RES_SUCCESS) { 336 dev_err(ec_dev->dev, 337 "EC responded to v2 hello with error: %d\n", 338 msg->result); 339 ret = msg->result; 340 goto exit; 341 } else if (hello_response->out_data != 0xa1b2c3d4) { 342 dev_err(ec_dev->dev, 343 "EC responded to v2 hello with bad result: %u\n", 344 hello_response->out_data); 345 ret = -EBADMSG; 346 goto exit; 347 } 348 349 ret = 0; 350 351 exit: 352 kfree(msg); 353 return ret; 354 } 355 356 /* 357 * cros_ec_get_host_command_version_mask 358 * 359 * Get the version mask of a given command. 360 * 361 * @ec_dev: EC device to call 362 * @msg: message structure to use 363 * @cmd: command to get the version of. 364 * @mask: result when function returns 0. 365 * 366 * @return 0 on success, error code otherwise 367 * 368 * LOCKING: 369 * the caller has ec_dev->lock mutex or the caller knows there is 370 * no other command in progress. 371 */ 372 static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev, 373 u16 cmd, u32 *mask) 374 { 375 struct ec_params_get_cmd_versions *pver; 376 struct ec_response_get_cmd_versions *rver; 377 struct cros_ec_command *msg; 378 int ret; 379 380 msg = kmalloc(sizeof(*msg) + max(sizeof(*rver), sizeof(*pver)), 381 GFP_KERNEL); 382 if (!msg) 383 return -ENOMEM; 384 385 msg->version = 0; 386 msg->command = EC_CMD_GET_CMD_VERSIONS; 387 msg->insize = sizeof(*rver); 388 msg->outsize = sizeof(*pver); 389 390 pver = (struct ec_params_get_cmd_versions *)msg->data; 391 pver->cmd = cmd; 392 393 ret = send_command(ec_dev, msg); 394 if (ret > 0) { 395 rver = (struct ec_response_get_cmd_versions *)msg->data; 396 *mask = rver->version_mask; 397 } 398 399 kfree(msg); 400 401 return ret; 402 } 403 404 /** 405 * cros_ec_query_all() - Query the protocol version supported by the 406 * ChromeOS EC. 407 * @ec_dev: Device to register. 408 * 409 * Return: 0 on success or negative error code. 410 */ 411 int cros_ec_query_all(struct cros_ec_device *ec_dev) 412 { 413 struct device *dev = ec_dev->dev; 414 struct cros_ec_command *proto_msg; 415 struct ec_response_get_protocol_info *proto_info; 416 u32 ver_mask = 0; 417 int ret; 418 419 proto_msg = kzalloc(sizeof(*proto_msg) + sizeof(*proto_info), 420 GFP_KERNEL); 421 if (!proto_msg) 422 return -ENOMEM; 423 424 /* First try sending with proto v3. */ 425 ec_dev->proto_version = 3; 426 ret = cros_ec_host_command_proto_query(ec_dev, 0, proto_msg); 427 428 if (ret == 0) { 429 proto_info = (struct ec_response_get_protocol_info *) 430 proto_msg->data; 431 ec_dev->max_request = proto_info->max_request_packet_size - 432 sizeof(struct ec_host_request); 433 ec_dev->max_response = proto_info->max_response_packet_size - 434 sizeof(struct ec_host_response); 435 ec_dev->proto_version = 436 min(EC_HOST_REQUEST_VERSION, 437 fls(proto_info->protocol_versions) - 1); 438 dev_dbg(ec_dev->dev, 439 "using proto v%u\n", 440 ec_dev->proto_version); 441 442 ec_dev->din_size = ec_dev->max_response + 443 sizeof(struct ec_host_response) + 444 EC_MAX_RESPONSE_OVERHEAD; 445 ec_dev->dout_size = ec_dev->max_request + 446 sizeof(struct ec_host_request) + 447 EC_MAX_REQUEST_OVERHEAD; 448 449 /* 450 * Check for PD 451 */ 452 ret = cros_ec_host_command_proto_query(ec_dev, 1, proto_msg); 453 454 if (ret) { 455 dev_dbg(ec_dev->dev, "no PD chip found: %d\n", ret); 456 ec_dev->max_passthru = 0; 457 } else { 458 dev_dbg(ec_dev->dev, "found PD chip\n"); 459 ec_dev->max_passthru = 460 proto_info->max_request_packet_size - 461 sizeof(struct ec_host_request); 462 } 463 } else { 464 /* Try querying with a v2 hello message. */ 465 ec_dev->proto_version = 2; 466 ret = cros_ec_host_command_proto_query_v2(ec_dev); 467 468 if (ret == 0) { 469 /* V2 hello succeeded. */ 470 dev_dbg(ec_dev->dev, "falling back to proto v2\n"); 471 472 ec_dev->max_request = EC_PROTO2_MAX_PARAM_SIZE; 473 ec_dev->max_response = EC_PROTO2_MAX_PARAM_SIZE; 474 ec_dev->max_passthru = 0; 475 ec_dev->pkt_xfer = NULL; 476 ec_dev->din_size = EC_PROTO2_MSG_BYTES; 477 ec_dev->dout_size = EC_PROTO2_MSG_BYTES; 478 } else { 479 /* 480 * It's possible for a test to occur too early when 481 * the EC isn't listening. If this happens, we'll 482 * test later when the first command is run. 483 */ 484 ec_dev->proto_version = EC_PROTO_VERSION_UNKNOWN; 485 dev_dbg(ec_dev->dev, "EC query failed: %d\n", ret); 486 goto exit; 487 } 488 } 489 490 devm_kfree(dev, ec_dev->din); 491 devm_kfree(dev, ec_dev->dout); 492 493 ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL); 494 if (!ec_dev->din) { 495 ret = -ENOMEM; 496 goto exit; 497 } 498 499 ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL); 500 if (!ec_dev->dout) { 501 devm_kfree(dev, ec_dev->din); 502 ret = -ENOMEM; 503 goto exit; 504 } 505 506 /* Probe if MKBP event is supported */ 507 ret = cros_ec_get_host_command_version_mask(ec_dev, 508 EC_CMD_GET_NEXT_EVENT, 509 &ver_mask); 510 if (ret < 0 || ver_mask == 0) 511 ec_dev->mkbp_event_supported = 0; 512 else 513 ec_dev->mkbp_event_supported = fls(ver_mask); 514 515 dev_dbg(ec_dev->dev, "MKBP support version %u\n", 516 ec_dev->mkbp_event_supported - 1); 517 518 /* Probe if host sleep v1 is supported for S0ix failure detection. */ 519 ret = cros_ec_get_host_command_version_mask(ec_dev, 520 EC_CMD_HOST_SLEEP_EVENT, 521 &ver_mask); 522 ec_dev->host_sleep_v1 = (ret >= 0 && (ver_mask & EC_VER_MASK(1))); 523 524 /* Get host event wake mask. */ 525 ret = cros_ec_get_host_event_wake_mask(ec_dev, proto_msg, 526 &ec_dev->host_event_wake_mask); 527 if (ret < 0) { 528 /* 529 * If the EC doesn't support EC_CMD_HOST_EVENT_GET_WAKE_MASK, 530 * use a reasonable default. Note that we ignore various 531 * battery, AC status, and power-state events, because (a) 532 * those can be quite common (e.g., when sitting at full 533 * charge, on AC) and (b) these are not actionable wake events; 534 * if anything, we'd like to continue suspending (to save 535 * power), not wake up. 536 */ 537 ec_dev->host_event_wake_mask = U32_MAX & 538 ~(EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED) | 539 EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED) | 540 EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_LOW) | 541 EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_CRITICAL) | 542 EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY) | 543 EC_HOST_EVENT_MASK(EC_HOST_EVENT_PD_MCU) | 544 EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_STATUS)); 545 /* 546 * Old ECs may not support this command. Complain about all 547 * other errors. 548 */ 549 if (ret != -EOPNOTSUPP) 550 dev_err(ec_dev->dev, 551 "failed to retrieve wake mask: %d\n", ret); 552 } 553 554 ret = 0; 555 556 exit: 557 kfree(proto_msg); 558 return ret; 559 } 560 EXPORT_SYMBOL(cros_ec_query_all); 561 562 /** 563 * cros_ec_cmd_xfer_status() - Send a command to the ChromeOS EC. 564 * @ec_dev: EC device. 565 * @msg: Message to write. 566 * 567 * Call this to send a command to the ChromeOS EC. This should be used instead of calling the EC's 568 * cmd_xfer() callback directly. It returns success status only if both the command was transmitted 569 * successfully and the EC replied with success status. 570 * 571 * Return: 572 * >=0 - The number of bytes transferred 573 * <0 - Linux error code 574 */ 575 int cros_ec_cmd_xfer_status(struct cros_ec_device *ec_dev, 576 struct cros_ec_command *msg) 577 { 578 int ret, mapped; 579 580 mutex_lock(&ec_dev->lock); 581 if (ec_dev->proto_version == EC_PROTO_VERSION_UNKNOWN) { 582 ret = cros_ec_query_all(ec_dev); 583 if (ret) { 584 dev_err(ec_dev->dev, 585 "EC version unknown and query failed; aborting command\n"); 586 mutex_unlock(&ec_dev->lock); 587 return ret; 588 } 589 } 590 591 if (msg->insize > ec_dev->max_response) { 592 dev_dbg(ec_dev->dev, "clamping message receive buffer\n"); 593 msg->insize = ec_dev->max_response; 594 } 595 596 if (msg->command < EC_CMD_PASSTHRU_OFFSET(1)) { 597 if (msg->outsize > ec_dev->max_request) { 598 dev_err(ec_dev->dev, 599 "request of size %u is too big (max: %u)\n", 600 msg->outsize, 601 ec_dev->max_request); 602 mutex_unlock(&ec_dev->lock); 603 return -EMSGSIZE; 604 } 605 } else { 606 if (msg->outsize > ec_dev->max_passthru) { 607 dev_err(ec_dev->dev, 608 "passthru rq of size %u is too big (max: %u)\n", 609 msg->outsize, 610 ec_dev->max_passthru); 611 mutex_unlock(&ec_dev->lock); 612 return -EMSGSIZE; 613 } 614 } 615 616 ret = send_command(ec_dev, msg); 617 mutex_unlock(&ec_dev->lock); 618 619 mapped = cros_ec_map_error(msg->result); 620 if (mapped) { 621 dev_dbg(ec_dev->dev, "Command result (err: %d [%d])\n", 622 msg->result, mapped); 623 ret = mapped; 624 } 625 626 return ret; 627 } 628 EXPORT_SYMBOL(cros_ec_cmd_xfer_status); 629 630 static int get_next_event_xfer(struct cros_ec_device *ec_dev, 631 struct cros_ec_command *msg, 632 struct ec_response_get_next_event_v1 *event, 633 int version, uint32_t size) 634 { 635 int ret; 636 637 msg->version = version; 638 msg->command = EC_CMD_GET_NEXT_EVENT; 639 msg->insize = size; 640 msg->outsize = 0; 641 642 ret = cros_ec_cmd_xfer_status(ec_dev, msg); 643 if (ret > 0) { 644 ec_dev->event_size = ret - 1; 645 ec_dev->event_data = *event; 646 } 647 648 return ret; 649 } 650 651 static int get_next_event(struct cros_ec_device *ec_dev) 652 { 653 struct { 654 struct cros_ec_command msg; 655 struct ec_response_get_next_event_v1 event; 656 } __packed buf; 657 struct cros_ec_command *msg = &buf.msg; 658 struct ec_response_get_next_event_v1 *event = &buf.event; 659 const int cmd_version = ec_dev->mkbp_event_supported - 1; 660 661 memset(msg, 0, sizeof(*msg)); 662 if (ec_dev->suspended) { 663 dev_dbg(ec_dev->dev, "Device suspended.\n"); 664 return -EHOSTDOWN; 665 } 666 667 if (cmd_version == 0) 668 return get_next_event_xfer(ec_dev, msg, event, 0, 669 sizeof(struct ec_response_get_next_event)); 670 671 return get_next_event_xfer(ec_dev, msg, event, cmd_version, 672 sizeof(struct ec_response_get_next_event_v1)); 673 } 674 675 static int get_keyboard_state_event(struct cros_ec_device *ec_dev) 676 { 677 u8 buffer[sizeof(struct cros_ec_command) + 678 sizeof(ec_dev->event_data.data)]; 679 struct cros_ec_command *msg = (struct cros_ec_command *)&buffer; 680 681 msg->version = 0; 682 msg->command = EC_CMD_MKBP_STATE; 683 msg->insize = sizeof(ec_dev->event_data.data); 684 msg->outsize = 0; 685 686 ec_dev->event_size = cros_ec_cmd_xfer_status(ec_dev, msg); 687 ec_dev->event_data.event_type = EC_MKBP_EVENT_KEY_MATRIX; 688 memcpy(&ec_dev->event_data.data, msg->data, 689 sizeof(ec_dev->event_data.data)); 690 691 return ec_dev->event_size; 692 } 693 694 /** 695 * cros_ec_get_next_event() - Fetch next event from the ChromeOS EC. 696 * @ec_dev: Device to fetch event from. 697 * @wake_event: Pointer to a bool set to true upon return if the event might be 698 * treated as a wake event. Ignored if null. 699 * @has_more_events: Pointer to bool set to true if more than one event is 700 * pending. 701 * Some EC will set this flag to indicate cros_ec_get_next_event() 702 * can be called multiple times in a row. 703 * It is an optimization to prevent issuing a EC command for 704 * nothing or wait for another interrupt from the EC to process 705 * the next message. 706 * Ignored if null. 707 * 708 * Return: negative error code on errors; 0 for no data; or else number of 709 * bytes received (i.e., an event was retrieved successfully). Event types are 710 * written out to @ec_dev->event_data.event_type on success. 711 */ 712 int cros_ec_get_next_event(struct cros_ec_device *ec_dev, 713 bool *wake_event, 714 bool *has_more_events) 715 { 716 u8 event_type; 717 u32 host_event; 718 int ret; 719 720 /* 721 * Default value for wake_event. 722 * Wake up on keyboard event, wake up for spurious interrupt or link 723 * error to the EC. 724 */ 725 if (wake_event) 726 *wake_event = true; 727 728 /* 729 * Default value for has_more_events. 730 * EC will raise another interrupt if AP does not process all events 731 * anyway. 732 */ 733 if (has_more_events) 734 *has_more_events = false; 735 736 if (!ec_dev->mkbp_event_supported) 737 return get_keyboard_state_event(ec_dev); 738 739 ret = get_next_event(ec_dev); 740 if (ret <= 0) 741 return ret; 742 743 if (has_more_events) 744 *has_more_events = ec_dev->event_data.event_type & 745 EC_MKBP_HAS_MORE_EVENTS; 746 ec_dev->event_data.event_type &= EC_MKBP_EVENT_TYPE_MASK; 747 748 if (wake_event) { 749 event_type = ec_dev->event_data.event_type; 750 host_event = cros_ec_get_host_event(ec_dev); 751 752 /* 753 * Sensor events need to be parsed by the sensor sub-device. 754 * Defer them, and don't report the wakeup here. 755 */ 756 if (event_type == EC_MKBP_EVENT_SENSOR_FIFO) { 757 *wake_event = false; 758 } else if (host_event) { 759 /* rtc_update_irq() already handles wakeup events. */ 760 if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC)) 761 *wake_event = false; 762 /* Masked host-events should not count as wake events. */ 763 if (!(host_event & ec_dev->host_event_wake_mask)) 764 *wake_event = false; 765 } 766 } 767 768 return ret; 769 } 770 EXPORT_SYMBOL(cros_ec_get_next_event); 771 772 /** 773 * cros_ec_get_host_event() - Return a mask of event set by the ChromeOS EC. 774 * @ec_dev: Device to fetch event from. 775 * 776 * When MKBP is supported, when the EC raises an interrupt, we collect the 777 * events raised and call the functions in the ec notifier. This function 778 * is a helper to know which events are raised. 779 * 780 * Return: 0 on error or non-zero bitmask of one or more EC_HOST_EVENT_*. 781 */ 782 u32 cros_ec_get_host_event(struct cros_ec_device *ec_dev) 783 { 784 u32 host_event; 785 786 BUG_ON(!ec_dev->mkbp_event_supported); 787 788 if (ec_dev->event_data.event_type != EC_MKBP_EVENT_HOST_EVENT) 789 return 0; 790 791 if (ec_dev->event_size != sizeof(host_event)) { 792 dev_warn(ec_dev->dev, "Invalid host event size\n"); 793 return 0; 794 } 795 796 host_event = get_unaligned_le32(&ec_dev->event_data.data.host_event); 797 798 return host_event; 799 } 800 EXPORT_SYMBOL(cros_ec_get_host_event); 801 802 /** 803 * cros_ec_check_features() - Test for the presence of EC features 804 * 805 * @ec: EC device, does not have to be connected directly to the AP, 806 * can be daisy chained through another device. 807 * @feature: One of ec_feature_code bit. 808 * 809 * Call this function to test whether the ChromeOS EC supports a feature. 810 * 811 * Return: true if supported, false if not (or if an error was encountered). 812 */ 813 bool cros_ec_check_features(struct cros_ec_dev *ec, int feature) 814 { 815 struct ec_response_get_features *features = &ec->features; 816 int ret; 817 818 if (features->flags[0] == -1U && features->flags[1] == -1U) { 819 /* features bitmap not read yet */ 820 ret = cros_ec_command(ec->ec_dev, 0, EC_CMD_GET_FEATURES + ec->cmd_offset, 821 NULL, 0, features, sizeof(*features)); 822 if (ret < 0) { 823 dev_warn(ec->dev, "cannot get EC features: %d\n", ret); 824 memset(features, 0, sizeof(*features)); 825 } 826 827 dev_dbg(ec->dev, "EC features %08x %08x\n", 828 features->flags[0], features->flags[1]); 829 } 830 831 return !!(features->flags[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 901 /** 902 * cros_ec_command - Send a command to the EC. 903 * 904 * @ec_dev: EC device 905 * @version: EC command version 906 * @command: EC command 907 * @outdata: EC command output data 908 * @outsize: Size of outdata 909 * @indata: EC command input data 910 * @insize: Size of indata 911 * 912 * Return: >= 0 on success, negative error number on failure. 913 */ 914 int cros_ec_command(struct cros_ec_device *ec_dev, 915 unsigned int version, 916 int command, 917 void *outdata, 918 int outsize, 919 void *indata, 920 int insize) 921 { 922 struct cros_ec_command *msg; 923 int ret; 924 925 msg = kzalloc(sizeof(*msg) + max(insize, outsize), GFP_KERNEL); 926 if (!msg) 927 return -ENOMEM; 928 929 msg->version = version; 930 msg->command = command; 931 msg->outsize = outsize; 932 msg->insize = insize; 933 934 if (outsize) 935 memcpy(msg->data, outdata, outsize); 936 937 ret = cros_ec_cmd_xfer_status(ec_dev, msg); 938 if (ret < 0) 939 goto error; 940 941 if (insize) 942 memcpy(indata, msg->data, insize); 943 error: 944 kfree(msg); 945 return ret; 946 } 947 EXPORT_SYMBOL_GPL(cros_ec_command); 948