1 /* 2 * ChromeOS EC multi-function device (SPI) 3 * 4 * Copyright (C) 2012 Google, Inc 5 * 6 * This software is licensed under the terms of the GNU General Public 7 * License version 2, as published by the Free Software Foundation, and 8 * may be copied, distributed, and modified under those terms. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 */ 15 16 #include <linux/delay.h> 17 #include <linux/kernel.h> 18 #include <linux/module.h> 19 #include <linux/mfd/cros_ec.h> 20 #include <linux/mfd/cros_ec_commands.h> 21 #include <linux/of.h> 22 #include <linux/platform_device.h> 23 #include <linux/slab.h> 24 #include <linux/spi/spi.h> 25 26 27 /* The header byte, which follows the preamble */ 28 #define EC_MSG_HEADER 0xec 29 30 /* 31 * Number of EC preamble bytes we read at a time. Since it takes 32 * about 400-500us for the EC to respond there is not a lot of 33 * point in tuning this. If the EC could respond faster then 34 * we could increase this so that might expect the preamble and 35 * message to occur in a single transaction. However, the maximum 36 * SPI transfer size is 256 bytes, so at 5MHz we need a response 37 * time of perhaps <320us (200 bytes / 1600 bits). 38 */ 39 #define EC_MSG_PREAMBLE_COUNT 32 40 41 /* 42 * Allow for a long time for the EC to respond. We support i2c 43 * tunneling and support fairly long messages for the tunnel (249 44 * bytes long at the moment). If we're talking to a 100 kHz device 45 * on the other end and need to transfer ~256 bytes, then we need: 46 * 10 us/bit * ~10 bits/byte * ~256 bytes = ~25ms 47 * 48 * We'll wait 8 times that to handle clock stretching and other 49 * paranoia. Note that some battery gas gauge ICs claim to have a 50 * clock stretch of 144ms in rare situations. That's incentive for 51 * not directly passing i2c through, but it's too late for that for 52 * existing hardware. 53 * 54 * It's pretty unlikely that we'll really see a 249 byte tunnel in 55 * anything other than testing. If this was more common we might 56 * consider having slow commands like this require a GET_STATUS 57 * wait loop. The 'flash write' command would be another candidate 58 * for this, clocking in at 2-3ms. 59 */ 60 #define EC_MSG_DEADLINE_MS 200 61 62 /* 63 * Time between raising the SPI chip select (for the end of a 64 * transaction) and dropping it again (for the next transaction). 65 * If we go too fast, the EC will miss the transaction. We know that we 66 * need at least 70 us with the 16 MHz STM32 EC, so go with 200 us to be 67 * safe. 68 */ 69 #define EC_SPI_RECOVERY_TIME_NS (200 * 1000) 70 71 /** 72 * struct cros_ec_spi - information about a SPI-connected EC 73 * 74 * @spi: SPI device we are connected to 75 * @last_transfer_ns: time that we last finished a transfer. 76 * @start_of_msg_delay: used to set the delay_usecs on the spi_transfer that 77 * is sent when we want to turn on CS at the start of a transaction. 78 * @end_of_msg_delay: used to set the delay_usecs on the spi_transfer that 79 * is sent when we want to turn off CS at the end of a transaction. 80 */ 81 struct cros_ec_spi { 82 struct spi_device *spi; 83 s64 last_transfer_ns; 84 unsigned int start_of_msg_delay; 85 unsigned int end_of_msg_delay; 86 }; 87 88 static void debug_packet(struct device *dev, const char *name, u8 *ptr, 89 int len) 90 { 91 #ifdef DEBUG 92 int i; 93 94 dev_dbg(dev, "%s: ", name); 95 for (i = 0; i < len; i++) 96 pr_cont(" %02x", ptr[i]); 97 98 pr_cont("\n"); 99 #endif 100 } 101 102 static int terminate_request(struct cros_ec_device *ec_dev) 103 { 104 struct cros_ec_spi *ec_spi = ec_dev->priv; 105 struct spi_message msg; 106 struct spi_transfer trans; 107 int ret; 108 109 /* 110 * Turn off CS, possibly adding a delay to ensure the rising edge 111 * doesn't come too soon after the end of the data. 112 */ 113 spi_message_init(&msg); 114 memset(&trans, 0, sizeof(trans)); 115 trans.delay_usecs = ec_spi->end_of_msg_delay; 116 spi_message_add_tail(&trans, &msg); 117 118 ret = spi_sync_locked(ec_spi->spi, &msg); 119 120 /* Reset end-of-response timer */ 121 ec_spi->last_transfer_ns = ktime_get_ns(); 122 if (ret < 0) { 123 dev_err(ec_dev->dev, 124 "cs-deassert spi transfer failed: %d\n", 125 ret); 126 } 127 128 return ret; 129 } 130 131 /** 132 * receive_n_bytes - receive n bytes from the EC. 133 * 134 * Assumes buf is a pointer into the ec_dev->din buffer 135 */ 136 static int receive_n_bytes(struct cros_ec_device *ec_dev, u8 *buf, int n) 137 { 138 struct cros_ec_spi *ec_spi = ec_dev->priv; 139 struct spi_transfer trans; 140 struct spi_message msg; 141 int ret; 142 143 BUG_ON(buf - ec_dev->din + n > ec_dev->din_size); 144 145 memset(&trans, 0, sizeof(trans)); 146 trans.cs_change = 1; 147 trans.rx_buf = buf; 148 trans.len = n; 149 150 spi_message_init(&msg); 151 spi_message_add_tail(&trans, &msg); 152 ret = spi_sync_locked(ec_spi->spi, &msg); 153 if (ret < 0) 154 dev_err(ec_dev->dev, "spi transfer failed: %d\n", ret); 155 156 return ret; 157 } 158 159 /** 160 * cros_ec_spi_receive_packet - Receive a packet from the EC. 161 * 162 * This function has two phases: reading the preamble bytes (since if we read 163 * data from the EC before it is ready to send, we just get preamble) and 164 * reading the actual message. 165 * 166 * The received data is placed into ec_dev->din. 167 * 168 * @ec_dev: ChromeOS EC device 169 * @need_len: Number of message bytes we need to read 170 */ 171 static int cros_ec_spi_receive_packet(struct cros_ec_device *ec_dev, 172 int need_len) 173 { 174 struct ec_host_response *response; 175 u8 *ptr, *end; 176 int ret; 177 unsigned long deadline; 178 int todo; 179 180 BUG_ON(ec_dev->din_size < EC_MSG_PREAMBLE_COUNT); 181 182 /* Receive data until we see the header byte */ 183 deadline = jiffies + msecs_to_jiffies(EC_MSG_DEADLINE_MS); 184 while (true) { 185 unsigned long start_jiffies = jiffies; 186 187 ret = receive_n_bytes(ec_dev, 188 ec_dev->din, 189 EC_MSG_PREAMBLE_COUNT); 190 if (ret < 0) 191 return ret; 192 193 ptr = ec_dev->din; 194 for (end = ptr + EC_MSG_PREAMBLE_COUNT; ptr != end; ptr++) { 195 if (*ptr == EC_SPI_FRAME_START) { 196 dev_dbg(ec_dev->dev, "msg found at %zd\n", 197 ptr - ec_dev->din); 198 break; 199 } 200 } 201 if (ptr != end) 202 break; 203 204 /* 205 * Use the time at the start of the loop as a timeout. This 206 * gives us one last shot at getting the transfer and is useful 207 * in case we got context switched out for a while. 208 */ 209 if (time_after(start_jiffies, deadline)) { 210 dev_warn(ec_dev->dev, "EC failed to respond in time\n"); 211 return -ETIMEDOUT; 212 } 213 } 214 215 /* 216 * ptr now points to the header byte. Copy any valid data to the 217 * start of our buffer 218 */ 219 todo = end - ++ptr; 220 BUG_ON(todo < 0 || todo > ec_dev->din_size); 221 todo = min(todo, need_len); 222 memmove(ec_dev->din, ptr, todo); 223 ptr = ec_dev->din + todo; 224 dev_dbg(ec_dev->dev, "need %d, got %d bytes from preamble\n", 225 need_len, todo); 226 need_len -= todo; 227 228 /* If the entire response struct wasn't read, get the rest of it. */ 229 if (todo < sizeof(*response)) { 230 ret = receive_n_bytes(ec_dev, ptr, sizeof(*response) - todo); 231 if (ret < 0) 232 return -EBADMSG; 233 ptr += (sizeof(*response) - todo); 234 todo = sizeof(*response); 235 } 236 237 response = (struct ec_host_response *)ec_dev->din; 238 239 /* Abort if data_len is too large. */ 240 if (response->data_len > ec_dev->din_size) 241 return -EMSGSIZE; 242 243 /* Receive data until we have it all */ 244 while (need_len > 0) { 245 /* 246 * We can't support transfers larger than the SPI FIFO size 247 * unless we have DMA. We don't have DMA on the ISP SPI ports 248 * for Exynos. We need a way of asking SPI driver for 249 * maximum-supported transfer size. 250 */ 251 todo = min(need_len, 256); 252 dev_dbg(ec_dev->dev, "loop, todo=%d, need_len=%d, ptr=%zd\n", 253 todo, need_len, ptr - ec_dev->din); 254 255 ret = receive_n_bytes(ec_dev, ptr, todo); 256 if (ret < 0) 257 return ret; 258 259 ptr += todo; 260 need_len -= todo; 261 } 262 263 dev_dbg(ec_dev->dev, "loop done, ptr=%zd\n", ptr - ec_dev->din); 264 265 return 0; 266 } 267 268 /** 269 * cros_ec_spi_receive_response - Receive a response from the EC. 270 * 271 * This function has two phases: reading the preamble bytes (since if we read 272 * data from the EC before it is ready to send, we just get preamble) and 273 * reading the actual message. 274 * 275 * The received data is placed into ec_dev->din. 276 * 277 * @ec_dev: ChromeOS EC device 278 * @need_len: Number of message bytes we need to read 279 */ 280 static int cros_ec_spi_receive_response(struct cros_ec_device *ec_dev, 281 int need_len) 282 { 283 u8 *ptr, *end; 284 int ret; 285 unsigned long deadline; 286 int todo; 287 288 BUG_ON(ec_dev->din_size < EC_MSG_PREAMBLE_COUNT); 289 290 /* Receive data until we see the header byte */ 291 deadline = jiffies + msecs_to_jiffies(EC_MSG_DEADLINE_MS); 292 while (true) { 293 unsigned long start_jiffies = jiffies; 294 295 ret = receive_n_bytes(ec_dev, 296 ec_dev->din, 297 EC_MSG_PREAMBLE_COUNT); 298 if (ret < 0) 299 return ret; 300 301 ptr = ec_dev->din; 302 for (end = ptr + EC_MSG_PREAMBLE_COUNT; ptr != end; ptr++) { 303 if (*ptr == EC_SPI_FRAME_START) { 304 dev_dbg(ec_dev->dev, "msg found at %zd\n", 305 ptr - ec_dev->din); 306 break; 307 } 308 } 309 if (ptr != end) 310 break; 311 312 /* 313 * Use the time at the start of the loop as a timeout. This 314 * gives us one last shot at getting the transfer and is useful 315 * in case we got context switched out for a while. 316 */ 317 if (time_after(start_jiffies, deadline)) { 318 dev_warn(ec_dev->dev, "EC failed to respond in time\n"); 319 return -ETIMEDOUT; 320 } 321 } 322 323 /* 324 * ptr now points to the header byte. Copy any valid data to the 325 * start of our buffer 326 */ 327 todo = end - ++ptr; 328 BUG_ON(todo < 0 || todo > ec_dev->din_size); 329 todo = min(todo, need_len); 330 memmove(ec_dev->din, ptr, todo); 331 ptr = ec_dev->din + todo; 332 dev_dbg(ec_dev->dev, "need %d, got %d bytes from preamble\n", 333 need_len, todo); 334 need_len -= todo; 335 336 /* Receive data until we have it all */ 337 while (need_len > 0) { 338 /* 339 * We can't support transfers larger than the SPI FIFO size 340 * unless we have DMA. We don't have DMA on the ISP SPI ports 341 * for Exynos. We need a way of asking SPI driver for 342 * maximum-supported transfer size. 343 */ 344 todo = min(need_len, 256); 345 dev_dbg(ec_dev->dev, "loop, todo=%d, need_len=%d, ptr=%zd\n", 346 todo, need_len, ptr - ec_dev->din); 347 348 ret = receive_n_bytes(ec_dev, ptr, todo); 349 if (ret < 0) 350 return ret; 351 352 debug_packet(ec_dev->dev, "interim", ptr, todo); 353 ptr += todo; 354 need_len -= todo; 355 } 356 357 dev_dbg(ec_dev->dev, "loop done, ptr=%zd\n", ptr - ec_dev->din); 358 359 return 0; 360 } 361 362 /** 363 * cros_ec_pkt_xfer_spi - Transfer a packet over SPI and receive the reply 364 * 365 * @ec_dev: ChromeOS EC device 366 * @ec_msg: Message to transfer 367 */ 368 static int cros_ec_pkt_xfer_spi(struct cros_ec_device *ec_dev, 369 struct cros_ec_command *ec_msg) 370 { 371 struct ec_host_response *response; 372 struct cros_ec_spi *ec_spi = ec_dev->priv; 373 struct spi_transfer trans, trans_delay; 374 struct spi_message msg; 375 int i, len; 376 u8 *ptr; 377 u8 *rx_buf; 378 u8 sum; 379 u8 rx_byte; 380 int ret = 0, final_ret; 381 unsigned long delay; 382 383 len = cros_ec_prepare_tx(ec_dev, ec_msg); 384 dev_dbg(ec_dev->dev, "prepared, len=%d\n", len); 385 386 /* If it's too soon to do another transaction, wait */ 387 delay = ktime_get_ns() - ec_spi->last_transfer_ns; 388 if (delay < EC_SPI_RECOVERY_TIME_NS) 389 ndelay(EC_SPI_RECOVERY_TIME_NS - delay); 390 391 rx_buf = kzalloc(len, GFP_KERNEL); 392 if (!rx_buf) 393 return -ENOMEM; 394 395 spi_bus_lock(ec_spi->spi->master); 396 397 /* 398 * Leave a gap between CS assertion and clocking of data to allow the 399 * EC time to wakeup. 400 */ 401 spi_message_init(&msg); 402 if (ec_spi->start_of_msg_delay) { 403 memset(&trans_delay, 0, sizeof(trans_delay)); 404 trans_delay.delay_usecs = ec_spi->start_of_msg_delay; 405 spi_message_add_tail(&trans_delay, &msg); 406 } 407 408 /* Transmit phase - send our message */ 409 memset(&trans, 0, sizeof(trans)); 410 trans.tx_buf = ec_dev->dout; 411 trans.rx_buf = rx_buf; 412 trans.len = len; 413 trans.cs_change = 1; 414 spi_message_add_tail(&trans, &msg); 415 ret = spi_sync_locked(ec_spi->spi, &msg); 416 417 /* Get the response */ 418 if (!ret) { 419 /* Verify that EC can process command */ 420 for (i = 0; i < len; i++) { 421 rx_byte = rx_buf[i]; 422 /* 423 * Seeing the PAST_END, RX_BAD_DATA, or NOT_READY 424 * markers are all signs that the EC didn't fully 425 * receive our command. e.g., if the EC is flashing 426 * itself, it can't respond to any commands and instead 427 * clocks out EC_SPI_PAST_END from its SPI hardware 428 * buffer. Similar occurrences can happen if the AP is 429 * too slow to clock out data after asserting CS -- the 430 * EC will abort and fill its buffer with 431 * EC_SPI_RX_BAD_DATA. 432 * 433 * In all cases, these errors should be safe to retry. 434 * Report -EAGAIN and let the caller decide what to do 435 * about that. 436 */ 437 if (rx_byte == EC_SPI_PAST_END || 438 rx_byte == EC_SPI_RX_BAD_DATA || 439 rx_byte == EC_SPI_NOT_READY) { 440 ret = -EAGAIN; 441 break; 442 } 443 } 444 } 445 446 if (!ret) 447 ret = cros_ec_spi_receive_packet(ec_dev, 448 ec_msg->insize + sizeof(*response)); 449 else if (ret != -EAGAIN) 450 dev_err(ec_dev->dev, "spi transfer failed: %d\n", ret); 451 452 final_ret = terminate_request(ec_dev); 453 454 spi_bus_unlock(ec_spi->spi->master); 455 456 if (!ret) 457 ret = final_ret; 458 if (ret < 0) 459 goto exit; 460 461 ptr = ec_dev->din; 462 463 /* check response error code */ 464 response = (struct ec_host_response *)ptr; 465 ec_msg->result = response->result; 466 467 ret = cros_ec_check_result(ec_dev, ec_msg); 468 if (ret) 469 goto exit; 470 471 len = response->data_len; 472 sum = 0; 473 if (len > ec_msg->insize) { 474 dev_err(ec_dev->dev, "packet too long (%d bytes, expected %d)", 475 len, ec_msg->insize); 476 ret = -EMSGSIZE; 477 goto exit; 478 } 479 480 for (i = 0; i < sizeof(*response); i++) 481 sum += ptr[i]; 482 483 /* copy response packet payload and compute checksum */ 484 memcpy(ec_msg->data, ptr + sizeof(*response), len); 485 for (i = 0; i < len; i++) 486 sum += ec_msg->data[i]; 487 488 if (sum) { 489 dev_err(ec_dev->dev, 490 "bad packet checksum, calculated %x\n", 491 sum); 492 ret = -EBADMSG; 493 goto exit; 494 } 495 496 ret = len; 497 exit: 498 kfree(rx_buf); 499 if (ec_msg->command == EC_CMD_REBOOT_EC) 500 msleep(EC_REBOOT_DELAY_MS); 501 502 return ret; 503 } 504 505 /** 506 * cros_ec_cmd_xfer_spi - Transfer a message over SPI and receive the reply 507 * 508 * @ec_dev: ChromeOS EC device 509 * @ec_msg: Message to transfer 510 */ 511 static int cros_ec_cmd_xfer_spi(struct cros_ec_device *ec_dev, 512 struct cros_ec_command *ec_msg) 513 { 514 struct cros_ec_spi *ec_spi = ec_dev->priv; 515 struct spi_transfer trans; 516 struct spi_message msg; 517 int i, len; 518 u8 *ptr; 519 u8 *rx_buf; 520 u8 rx_byte; 521 int sum; 522 int ret = 0, final_ret; 523 unsigned long delay; 524 525 len = cros_ec_prepare_tx(ec_dev, ec_msg); 526 dev_dbg(ec_dev->dev, "prepared, len=%d\n", len); 527 528 /* If it's too soon to do another transaction, wait */ 529 delay = ktime_get_ns() - ec_spi->last_transfer_ns; 530 if (delay < EC_SPI_RECOVERY_TIME_NS) 531 ndelay(EC_SPI_RECOVERY_TIME_NS - delay); 532 533 rx_buf = kzalloc(len, GFP_KERNEL); 534 if (!rx_buf) 535 return -ENOMEM; 536 537 spi_bus_lock(ec_spi->spi->master); 538 539 /* Transmit phase - send our message */ 540 debug_packet(ec_dev->dev, "out", ec_dev->dout, len); 541 memset(&trans, 0, sizeof(trans)); 542 trans.tx_buf = ec_dev->dout; 543 trans.rx_buf = rx_buf; 544 trans.len = len; 545 trans.cs_change = 1; 546 spi_message_init(&msg); 547 spi_message_add_tail(&trans, &msg); 548 ret = spi_sync_locked(ec_spi->spi, &msg); 549 550 /* Get the response */ 551 if (!ret) { 552 /* Verify that EC can process command */ 553 for (i = 0; i < len; i++) { 554 rx_byte = rx_buf[i]; 555 /* See comments in cros_ec_pkt_xfer_spi() */ 556 if (rx_byte == EC_SPI_PAST_END || 557 rx_byte == EC_SPI_RX_BAD_DATA || 558 rx_byte == EC_SPI_NOT_READY) { 559 ret = -EAGAIN; 560 break; 561 } 562 } 563 } 564 565 if (!ret) 566 ret = cros_ec_spi_receive_response(ec_dev, 567 ec_msg->insize + EC_MSG_TX_PROTO_BYTES); 568 else if (ret != -EAGAIN) 569 dev_err(ec_dev->dev, "spi transfer failed: %d\n", ret); 570 571 final_ret = terminate_request(ec_dev); 572 573 spi_bus_unlock(ec_spi->spi->master); 574 575 if (!ret) 576 ret = final_ret; 577 if (ret < 0) 578 goto exit; 579 580 ptr = ec_dev->din; 581 582 /* check response error code */ 583 ec_msg->result = ptr[0]; 584 ret = cros_ec_check_result(ec_dev, ec_msg); 585 if (ret) 586 goto exit; 587 588 len = ptr[1]; 589 sum = ptr[0] + ptr[1]; 590 if (len > ec_msg->insize) { 591 dev_err(ec_dev->dev, "packet too long (%d bytes, expected %d)", 592 len, ec_msg->insize); 593 ret = -ENOSPC; 594 goto exit; 595 } 596 597 /* copy response packet payload and compute checksum */ 598 for (i = 0; i < len; i++) { 599 sum += ptr[i + 2]; 600 if (ec_msg->insize) 601 ec_msg->data[i] = ptr[i + 2]; 602 } 603 sum &= 0xff; 604 605 debug_packet(ec_dev->dev, "in", ptr, len + 3); 606 607 if (sum != ptr[len + 2]) { 608 dev_err(ec_dev->dev, 609 "bad packet checksum, expected %02x, got %02x\n", 610 sum, ptr[len + 2]); 611 ret = -EBADMSG; 612 goto exit; 613 } 614 615 ret = len; 616 exit: 617 kfree(rx_buf); 618 if (ec_msg->command == EC_CMD_REBOOT_EC) 619 msleep(EC_REBOOT_DELAY_MS); 620 621 return ret; 622 } 623 624 static void cros_ec_spi_dt_probe(struct cros_ec_spi *ec_spi, struct device *dev) 625 { 626 struct device_node *np = dev->of_node; 627 u32 val; 628 int ret; 629 630 ret = of_property_read_u32(np, "google,cros-ec-spi-pre-delay", &val); 631 if (!ret) 632 ec_spi->start_of_msg_delay = val; 633 634 ret = of_property_read_u32(np, "google,cros-ec-spi-msg-delay", &val); 635 if (!ret) 636 ec_spi->end_of_msg_delay = val; 637 } 638 639 static int cros_ec_spi_probe(struct spi_device *spi) 640 { 641 struct device *dev = &spi->dev; 642 struct cros_ec_device *ec_dev; 643 struct cros_ec_spi *ec_spi; 644 int err; 645 646 spi->bits_per_word = 8; 647 spi->mode = SPI_MODE_0; 648 err = spi_setup(spi); 649 if (err < 0) 650 return err; 651 652 ec_spi = devm_kzalloc(dev, sizeof(*ec_spi), GFP_KERNEL); 653 if (ec_spi == NULL) 654 return -ENOMEM; 655 ec_spi->spi = spi; 656 ec_dev = devm_kzalloc(dev, sizeof(*ec_dev), GFP_KERNEL); 657 if (!ec_dev) 658 return -ENOMEM; 659 660 /* Check for any DT properties */ 661 cros_ec_spi_dt_probe(ec_spi, dev); 662 663 spi_set_drvdata(spi, ec_dev); 664 ec_dev->dev = dev; 665 ec_dev->priv = ec_spi; 666 ec_dev->irq = spi->irq; 667 ec_dev->cmd_xfer = cros_ec_cmd_xfer_spi; 668 ec_dev->pkt_xfer = cros_ec_pkt_xfer_spi; 669 ec_dev->phys_name = dev_name(&ec_spi->spi->dev); 670 ec_dev->din_size = EC_MSG_PREAMBLE_COUNT + 671 sizeof(struct ec_host_response) + 672 sizeof(struct ec_response_get_protocol_info); 673 ec_dev->dout_size = sizeof(struct ec_host_request); 674 675 ec_spi->last_transfer_ns = ktime_get_ns(); 676 677 err = cros_ec_register(ec_dev); 678 if (err) { 679 dev_err(dev, "cannot register EC\n"); 680 return err; 681 } 682 683 device_init_wakeup(&spi->dev, true); 684 685 return 0; 686 } 687 688 static int cros_ec_spi_remove(struct spi_device *spi) 689 { 690 struct cros_ec_device *ec_dev; 691 692 ec_dev = spi_get_drvdata(spi); 693 cros_ec_remove(ec_dev); 694 695 return 0; 696 } 697 698 #ifdef CONFIG_PM_SLEEP 699 static int cros_ec_spi_suspend(struct device *dev) 700 { 701 struct cros_ec_device *ec_dev = dev_get_drvdata(dev); 702 703 return cros_ec_suspend(ec_dev); 704 } 705 706 static int cros_ec_spi_resume(struct device *dev) 707 { 708 struct cros_ec_device *ec_dev = dev_get_drvdata(dev); 709 710 return cros_ec_resume(ec_dev); 711 } 712 #endif 713 714 static SIMPLE_DEV_PM_OPS(cros_ec_spi_pm_ops, cros_ec_spi_suspend, 715 cros_ec_spi_resume); 716 717 static const struct of_device_id cros_ec_spi_of_match[] = { 718 { .compatible = "google,cros-ec-spi", }, 719 { /* sentinel */ }, 720 }; 721 MODULE_DEVICE_TABLE(of, cros_ec_spi_of_match); 722 723 static const struct spi_device_id cros_ec_spi_id[] = { 724 { "cros-ec-spi", 0 }, 725 { } 726 }; 727 MODULE_DEVICE_TABLE(spi, cros_ec_spi_id); 728 729 static struct spi_driver cros_ec_driver_spi = { 730 .driver = { 731 .name = "cros-ec-spi", 732 .of_match_table = of_match_ptr(cros_ec_spi_of_match), 733 .pm = &cros_ec_spi_pm_ops, 734 }, 735 .probe = cros_ec_spi_probe, 736 .remove = cros_ec_spi_remove, 737 .id_table = cros_ec_spi_id, 738 }; 739 740 module_spi_driver(cros_ec_driver_spi); 741 742 MODULE_LICENSE("GPL v2"); 743 MODULE_DESCRIPTION("ChromeOS EC multi function device (SPI)"); 744