1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Intel ECLite opregion driver for talking to ECLite firmware running on 4 * Intel Integrated Sensor Hub (ISH) using ISH Transport Protocol (ISHTP) 5 * 6 * Copyright (c) 2021, Intel Corporation. 7 */ 8 9 #include <linux/acpi.h> 10 #include <linux/bitops.h> 11 #include <linux/device.h> 12 #include <linux/errno.h> 13 #include <linux/intel-ish-client-if.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/mutex.h> 17 #include <linux/slab.h> 18 #include <linux/suspend.h> 19 #include <linux/types.h> 20 #include <linux/uuid.h> 21 #include <linux/uaccess.h> 22 23 #define ECLITE_DATA_OPREGION_ID 0x9E 24 #define ECLITE_CMD_OPREGION_ID 0x9F 25 26 #define ECL_MSG_DATA 0x1 27 #define ECL_MSG_EVENT 0x2 28 29 #define ECL_ISH_READ 0x1 30 #define ECL_ISH_WRITE 0x2 31 #define ECL_ISH_HEADER_VERSION 0 32 33 #define ECL_CL_RX_RING_SIZE 16 34 #define ECL_CL_TX_RING_SIZE 8 35 36 #define ECL_DATA_OPR_BUFLEN 384 37 #define ECL_EVENTS_NOTIFY 333 38 39 #define cmd_opr_offsetof(element) offsetof(struct opregion_cmd, element) 40 #define cl_data_to_dev(opr_dev) ishtp_device((opr_dev)->cl_device) 41 42 #ifndef BITS_TO_BYTES 43 #define BITS_TO_BYTES(x) ((x) / 8) 44 #endif 45 46 struct opregion_cmd { 47 unsigned int command; 48 unsigned int offset; 49 unsigned int length; 50 unsigned int event_id; 51 }; 52 53 struct opregion_data { 54 char data[ECL_DATA_OPR_BUFLEN]; 55 }; 56 57 struct opregion_context { 58 struct opregion_cmd cmd_area; 59 struct opregion_data data_area; 60 }; 61 62 struct ecl_message_header { 63 unsigned int version:2; 64 unsigned int data_type:2; 65 unsigned int request_type:2; 66 unsigned int offset:9; 67 unsigned int data_len:9; 68 unsigned int event:8; 69 }; 70 71 struct ecl_message { 72 struct ecl_message_header header; 73 char payload[ECL_DATA_OPR_BUFLEN]; 74 }; 75 76 struct ishtp_opregion_dev { 77 struct opregion_context opr_context; 78 struct ishtp_cl *ecl_ishtp_cl; 79 struct ishtp_cl_device *cl_device; 80 struct ishtp_fw_client *fw_client; 81 struct ishtp_cl_rb *rb; 82 struct acpi_device *adev; 83 unsigned int dsm_event_id; 84 unsigned int ish_link_ready; 85 unsigned int ish_read_done; 86 unsigned int acpi_init_done; 87 wait_queue_head_t read_wait; 88 struct work_struct event_work; 89 struct work_struct reset_work; 90 /* lock for opregion context */ 91 struct mutex lock; 92 93 }; 94 95 /* eclite ishtp client UUID: 6a19cc4b-d760-4de3-b14d-f25ebd0fbcd9 */ 96 static const struct ishtp_device_id ecl_ishtp_id_table[] = { 97 { .guid = GUID_INIT(0x6a19cc4b, 0xd760, 0x4de3, 98 0xb1, 0x4d, 0xf2, 0x5e, 0xbd, 0xf, 0xbc, 0xd9), }, 99 { } 100 }; 101 MODULE_DEVICE_TABLE(ishtp, ecl_ishtp_id_table); 102 103 /* ACPI DSM UUID: 91d936a7-1f01-49c6-a6b4-72f00ad8d8a5 */ 104 static const guid_t ecl_acpi_guid = 105 GUID_INIT(0x91d936a7, 0x1f01, 0x49c6, 0xa6, 106 0xb4, 0x72, 0xf0, 0x0a, 0xd8, 0xd8, 0xa5); 107 108 /** 109 * ecl_ish_cl_read() - Read data from eclite FW 110 * 111 * @opr_dev: pointer to opregion device 112 * 113 * This function issues a read request to eclite FW and waits until it 114 * receives a response. When response is received the read data is copied to 115 * opregion buffer. 116 */ 117 static int ecl_ish_cl_read(struct ishtp_opregion_dev *opr_dev) 118 { 119 struct ecl_message_header header; 120 int len, rv; 121 122 if (!opr_dev->ish_link_ready) 123 return -EIO; 124 125 if ((opr_dev->opr_context.cmd_area.offset + 126 opr_dev->opr_context.cmd_area.length) > ECL_DATA_OPR_BUFLEN) { 127 return -EINVAL; 128 } 129 130 header.version = ECL_ISH_HEADER_VERSION; 131 header.data_type = ECL_MSG_DATA; 132 header.request_type = ECL_ISH_READ; 133 header.offset = opr_dev->opr_context.cmd_area.offset; 134 header.data_len = opr_dev->opr_context.cmd_area.length; 135 header.event = opr_dev->opr_context.cmd_area.event_id; 136 len = sizeof(header); 137 138 opr_dev->ish_read_done = false; 139 rv = ishtp_cl_send(opr_dev->ecl_ishtp_cl, (uint8_t *)&header, len); 140 if (rv) { 141 dev_err(cl_data_to_dev(opr_dev), "ish-read : send failed\n"); 142 return -EIO; 143 } 144 145 dev_dbg(cl_data_to_dev(opr_dev), 146 "[ish_rd] Req: off : %x, len : %x\n", 147 header.offset, 148 header.data_len); 149 150 rv = wait_event_interruptible_timeout(opr_dev->read_wait, 151 opr_dev->ish_read_done, 152 2 * HZ); 153 if (!rv) { 154 dev_err(cl_data_to_dev(opr_dev), 155 "[ish_rd] No response from firmware\n"); 156 return -EIO; 157 } 158 159 return 0; 160 } 161 162 /** 163 * ecl_ish_cl_write() - This function writes data to eclite FW. 164 * 165 * @opr_dev: pointer to opregion device 166 * 167 * This function writes data to eclite FW. 168 */ 169 static int ecl_ish_cl_write(struct ishtp_opregion_dev *opr_dev) 170 { 171 struct ecl_message message; 172 int len; 173 174 if (!opr_dev->ish_link_ready) 175 return -EIO; 176 177 if ((opr_dev->opr_context.cmd_area.offset + 178 opr_dev->opr_context.cmd_area.length) > ECL_DATA_OPR_BUFLEN) { 179 return -EINVAL; 180 } 181 182 message.header.version = ECL_ISH_HEADER_VERSION; 183 message.header.data_type = ECL_MSG_DATA; 184 message.header.request_type = ECL_ISH_WRITE; 185 message.header.offset = opr_dev->opr_context.cmd_area.offset; 186 message.header.data_len = opr_dev->opr_context.cmd_area.length; 187 message.header.event = opr_dev->opr_context.cmd_area.event_id; 188 len = sizeof(struct ecl_message_header) + message.header.data_len; 189 190 memcpy(message.payload, 191 opr_dev->opr_context.data_area.data + message.header.offset, 192 message.header.data_len); 193 194 dev_dbg(cl_data_to_dev(opr_dev), 195 "[ish_wr] off : %x, len : %x\n", 196 message.header.offset, 197 message.header.data_len); 198 199 return ishtp_cl_send(opr_dev->ecl_ishtp_cl, (uint8_t *)&message, len); 200 } 201 202 static acpi_status 203 ecl_opregion_cmd_handler(u32 function, acpi_physical_address address, 204 u32 bits, u64 *value64, 205 void *handler_context, void *region_context) 206 { 207 struct ishtp_opregion_dev *opr_dev; 208 struct opregion_cmd *cmd; 209 acpi_status status = AE_OK; 210 211 if (!region_context || !value64) 212 return AE_BAD_PARAMETER; 213 214 if (function == ACPI_READ) 215 return AE_ERROR; 216 217 opr_dev = (struct ishtp_opregion_dev *)region_context; 218 219 mutex_lock(&opr_dev->lock); 220 221 cmd = &opr_dev->opr_context.cmd_area; 222 223 switch (address) { 224 case cmd_opr_offsetof(command): 225 cmd->command = (u32)*value64; 226 227 if (cmd->command == ECL_ISH_READ) 228 status = ecl_ish_cl_read(opr_dev); 229 else if (cmd->command == ECL_ISH_WRITE) 230 status = ecl_ish_cl_write(opr_dev); 231 else 232 status = AE_ERROR; 233 break; 234 case cmd_opr_offsetof(offset): 235 cmd->offset = (u32)*value64; 236 break; 237 case cmd_opr_offsetof(length): 238 cmd->length = (u32)*value64; 239 break; 240 case cmd_opr_offsetof(event_id): 241 cmd->event_id = (u32)*value64; 242 break; 243 default: 244 status = AE_ERROR; 245 } 246 247 mutex_unlock(&opr_dev->lock); 248 249 return status; 250 } 251 252 static acpi_status 253 ecl_opregion_data_handler(u32 function, acpi_physical_address address, 254 u32 bits, u64 *value64, 255 void *handler_context, void *region_context) 256 { 257 struct ishtp_opregion_dev *opr_dev; 258 unsigned int bytes = BITS_TO_BYTES(bits); 259 void *data_addr; 260 261 if (!region_context || !value64) 262 return AE_BAD_PARAMETER; 263 264 if (address + bytes > ECL_DATA_OPR_BUFLEN) 265 return AE_BAD_PARAMETER; 266 267 opr_dev = (struct ishtp_opregion_dev *)region_context; 268 269 mutex_lock(&opr_dev->lock); 270 271 data_addr = &opr_dev->opr_context.data_area.data[address]; 272 273 if (function == ACPI_READ) { 274 memcpy(value64, data_addr, bytes); 275 } else if (function == ACPI_WRITE) { 276 memcpy(data_addr, value64, bytes); 277 } else { 278 mutex_unlock(&opr_dev->lock); 279 return AE_BAD_PARAMETER; 280 } 281 282 mutex_unlock(&opr_dev->lock); 283 284 return AE_OK; 285 } 286 287 static int acpi_find_eclite_device(struct ishtp_opregion_dev *opr_dev) 288 { 289 struct acpi_device *adev; 290 291 /* Find ECLite device and save reference */ 292 adev = acpi_dev_get_first_match_dev("INTC1035", NULL, -1); 293 if (!adev) { 294 dev_err(cl_data_to_dev(opr_dev), "eclite ACPI device not found\n"); 295 return -ENODEV; 296 } 297 298 opr_dev->adev = adev; 299 300 return 0; 301 } 302 303 static int acpi_opregion_init(struct ishtp_opregion_dev *opr_dev) 304 { 305 acpi_status status; 306 307 status = acpi_install_address_space_handler(opr_dev->adev->handle, 308 ECLITE_CMD_OPREGION_ID, 309 ecl_opregion_cmd_handler, 310 NULL, opr_dev); 311 if (ACPI_FAILURE(status)) { 312 dev_err(cl_data_to_dev(opr_dev), 313 "cmd space handler install failed\n"); 314 return -ENODEV; 315 } 316 317 status = acpi_install_address_space_handler(opr_dev->adev->handle, 318 ECLITE_DATA_OPREGION_ID, 319 ecl_opregion_data_handler, 320 NULL, opr_dev); 321 if (ACPI_FAILURE(status)) { 322 dev_err(cl_data_to_dev(opr_dev), 323 "data space handler install failed\n"); 324 325 acpi_remove_address_space_handler(opr_dev->adev->handle, 326 ECLITE_CMD_OPREGION_ID, 327 ecl_opregion_cmd_handler); 328 return -ENODEV; 329 } 330 opr_dev->acpi_init_done = true; 331 332 dev_dbg(cl_data_to_dev(opr_dev), "Opregion handlers are installed\n"); 333 334 return 0; 335 } 336 337 static void acpi_opregion_deinit(struct ishtp_opregion_dev *opr_dev) 338 { 339 acpi_remove_address_space_handler(opr_dev->adev->handle, 340 ECLITE_CMD_OPREGION_ID, 341 ecl_opregion_cmd_handler); 342 343 acpi_remove_address_space_handler(opr_dev->adev->handle, 344 ECLITE_DATA_OPREGION_ID, 345 ecl_opregion_data_handler); 346 opr_dev->acpi_init_done = false; 347 } 348 349 static void ecl_acpi_invoke_dsm(struct work_struct *work) 350 { 351 struct ishtp_opregion_dev *opr_dev; 352 union acpi_object *obj; 353 354 opr_dev = container_of(work, struct ishtp_opregion_dev, event_work); 355 if (!opr_dev->acpi_init_done) 356 return; 357 358 obj = acpi_evaluate_dsm(opr_dev->adev->handle, &ecl_acpi_guid, 0, 359 opr_dev->dsm_event_id, NULL); 360 if (!obj) { 361 dev_warn(cl_data_to_dev(opr_dev), "_DSM fn call failed\n"); 362 return; 363 } 364 365 dev_dbg(cl_data_to_dev(opr_dev), "Exec DSM function code: %d success\n", 366 opr_dev->dsm_event_id); 367 368 ACPI_FREE(obj); 369 } 370 371 static void ecl_ish_process_rx_data(struct ishtp_opregion_dev *opr_dev) 372 { 373 struct ecl_message *message = 374 (struct ecl_message *)opr_dev->rb->buffer.data; 375 376 dev_dbg(cl_data_to_dev(opr_dev), 377 "[ish_rd] Resp: off : %x, len : %x\n", 378 message->header.offset, 379 message->header.data_len); 380 381 if ((message->header.offset + message->header.data_len) > 382 ECL_DATA_OPR_BUFLEN) { 383 return; 384 } 385 386 memcpy(opr_dev->opr_context.data_area.data + message->header.offset, 387 message->payload, message->header.data_len); 388 389 opr_dev->ish_read_done = true; 390 wake_up_interruptible(&opr_dev->read_wait); 391 } 392 393 static void ecl_ish_process_rx_event(struct ishtp_opregion_dev *opr_dev) 394 { 395 struct ecl_message_header *header = 396 (struct ecl_message_header *)opr_dev->rb->buffer.data; 397 398 dev_dbg(cl_data_to_dev(opr_dev), 399 "[ish_ev] Evt received: %8x\n", header->event); 400 401 opr_dev->dsm_event_id = header->event; 402 schedule_work(&opr_dev->event_work); 403 } 404 405 static int ecl_ish_cl_enable_events(struct ishtp_opregion_dev *opr_dev, 406 bool config_enable) 407 { 408 struct ecl_message message; 409 int len; 410 411 message.header.version = ECL_ISH_HEADER_VERSION; 412 message.header.data_type = ECL_MSG_DATA; 413 message.header.request_type = ECL_ISH_WRITE; 414 message.header.offset = ECL_EVENTS_NOTIFY; 415 message.header.data_len = 1; 416 message.payload[0] = config_enable; 417 418 len = sizeof(struct ecl_message_header) + message.header.data_len; 419 420 return ishtp_cl_send(opr_dev->ecl_ishtp_cl, (uint8_t *)&message, len); 421 } 422 423 static void ecl_ishtp_cl_event_cb(struct ishtp_cl_device *cl_device) 424 { 425 struct ishtp_cl *ecl_ishtp_cl = ishtp_get_drvdata(cl_device); 426 struct ishtp_opregion_dev *opr_dev; 427 struct ecl_message_header *header; 428 struct ishtp_cl_rb *rb; 429 430 opr_dev = ishtp_get_client_data(ecl_ishtp_cl); 431 while ((rb = ishtp_cl_rx_get_rb(opr_dev->ecl_ishtp_cl)) != NULL) { 432 opr_dev->rb = rb; 433 header = (struct ecl_message_header *)rb->buffer.data; 434 435 if (header->data_type == ECL_MSG_DATA) 436 ecl_ish_process_rx_data(opr_dev); 437 else if (header->data_type == ECL_MSG_EVENT) 438 ecl_ish_process_rx_event(opr_dev); 439 else 440 /* Got an event with wrong data_type, ignore it */ 441 dev_err(cl_data_to_dev(opr_dev), 442 "[ish_cb] Received wrong data_type\n"); 443 444 ishtp_cl_io_rb_recycle(rb); 445 } 446 } 447 448 static int ecl_ishtp_cl_init(struct ishtp_cl *ecl_ishtp_cl) 449 { 450 struct ishtp_opregion_dev *opr_dev = 451 ishtp_get_client_data(ecl_ishtp_cl); 452 struct ishtp_fw_client *fw_client; 453 struct ishtp_device *dev; 454 int rv; 455 456 rv = ishtp_cl_link(ecl_ishtp_cl); 457 if (rv) { 458 dev_err(cl_data_to_dev(opr_dev), "ishtp_cl_link failed\n"); 459 return rv; 460 } 461 462 dev = ishtp_get_ishtp_device(ecl_ishtp_cl); 463 464 /* Connect to FW client */ 465 ishtp_set_tx_ring_size(ecl_ishtp_cl, ECL_CL_TX_RING_SIZE); 466 ishtp_set_rx_ring_size(ecl_ishtp_cl, ECL_CL_RX_RING_SIZE); 467 468 fw_client = ishtp_fw_cl_get_client(dev, &ecl_ishtp_id_table[0].guid); 469 if (!fw_client) { 470 dev_err(cl_data_to_dev(opr_dev), "fw client not found\n"); 471 return -ENOENT; 472 } 473 474 ishtp_cl_set_fw_client_id(ecl_ishtp_cl, 475 ishtp_get_fw_client_id(fw_client)); 476 477 ishtp_set_connection_state(ecl_ishtp_cl, ISHTP_CL_CONNECTING); 478 479 rv = ishtp_cl_connect(ecl_ishtp_cl); 480 if (rv) { 481 dev_err(cl_data_to_dev(opr_dev), "client connect failed\n"); 482 483 ishtp_cl_unlink(ecl_ishtp_cl); 484 return rv; 485 } 486 487 dev_dbg(cl_data_to_dev(opr_dev), "Host connected to fw client\n"); 488 489 return 0; 490 } 491 492 static void ecl_ishtp_cl_deinit(struct ishtp_cl *ecl_ishtp_cl) 493 { 494 ishtp_cl_unlink(ecl_ishtp_cl); 495 ishtp_cl_flush_queues(ecl_ishtp_cl); 496 ishtp_cl_free(ecl_ishtp_cl); 497 } 498 499 static void ecl_ishtp_cl_reset_handler(struct work_struct *work) 500 { 501 struct ishtp_opregion_dev *opr_dev; 502 struct ishtp_cl_device *cl_device; 503 struct ishtp_cl *ecl_ishtp_cl; 504 int rv; 505 int retry; 506 507 opr_dev = container_of(work, struct ishtp_opregion_dev, reset_work); 508 509 opr_dev->ish_link_ready = false; 510 511 cl_device = opr_dev->cl_device; 512 ecl_ishtp_cl = opr_dev->ecl_ishtp_cl; 513 514 ecl_ishtp_cl_deinit(ecl_ishtp_cl); 515 516 ecl_ishtp_cl = ishtp_cl_allocate(cl_device); 517 if (!ecl_ishtp_cl) 518 return; 519 520 ishtp_set_drvdata(cl_device, ecl_ishtp_cl); 521 ishtp_set_client_data(ecl_ishtp_cl, opr_dev); 522 523 opr_dev->ecl_ishtp_cl = ecl_ishtp_cl; 524 525 for (retry = 0; retry < 3; ++retry) { 526 rv = ecl_ishtp_cl_init(ecl_ishtp_cl); 527 if (!rv) 528 break; 529 } 530 if (rv) { 531 ishtp_cl_free(ecl_ishtp_cl); 532 opr_dev->ecl_ishtp_cl = NULL; 533 dev_err(cl_data_to_dev(opr_dev), 534 "[ish_rst] Reset failed. Link not ready.\n"); 535 return; 536 } 537 538 ishtp_register_event_cb(cl_device, ecl_ishtp_cl_event_cb); 539 dev_info(cl_data_to_dev(opr_dev), 540 "[ish_rst] Reset Success. Link ready.\n"); 541 542 opr_dev->ish_link_ready = true; 543 544 if (opr_dev->acpi_init_done) 545 return; 546 547 rv = acpi_opregion_init(opr_dev); 548 if (rv) { 549 dev_err(cl_data_to_dev(opr_dev), 550 "ACPI opregion init failed\n"); 551 } 552 } 553 554 static int ecl_ishtp_cl_probe(struct ishtp_cl_device *cl_device) 555 { 556 struct ishtp_cl *ecl_ishtp_cl; 557 struct ishtp_opregion_dev *opr_dev; 558 int rv; 559 560 opr_dev = devm_kzalloc(ishtp_device(cl_device), sizeof(*opr_dev), 561 GFP_KERNEL); 562 if (!opr_dev) 563 return -ENOMEM; 564 565 ecl_ishtp_cl = ishtp_cl_allocate(cl_device); 566 if (!ecl_ishtp_cl) 567 return -ENOMEM; 568 569 ishtp_set_drvdata(cl_device, ecl_ishtp_cl); 570 ishtp_set_client_data(ecl_ishtp_cl, opr_dev); 571 opr_dev->ecl_ishtp_cl = ecl_ishtp_cl; 572 opr_dev->cl_device = cl_device; 573 574 init_waitqueue_head(&opr_dev->read_wait); 575 INIT_WORK(&opr_dev->event_work, ecl_acpi_invoke_dsm); 576 INIT_WORK(&opr_dev->reset_work, ecl_ishtp_cl_reset_handler); 577 578 /* Initialize ish client device */ 579 rv = ecl_ishtp_cl_init(ecl_ishtp_cl); 580 if (rv) { 581 dev_err(cl_data_to_dev(opr_dev), "Client init failed\n"); 582 goto err_exit; 583 } 584 585 dev_dbg(cl_data_to_dev(opr_dev), "eclite-ishtp client initialised\n"); 586 587 opr_dev->ish_link_ready = true; 588 mutex_init(&opr_dev->lock); 589 590 rv = acpi_find_eclite_device(opr_dev); 591 if (rv) { 592 dev_err(cl_data_to_dev(opr_dev), "ECLite ACPI ID not found\n"); 593 goto err_exit; 594 } 595 596 /* Register a handler for eclite fw events */ 597 ishtp_register_event_cb(cl_device, ecl_ishtp_cl_event_cb); 598 599 /* Now init opregion handlers */ 600 rv = acpi_opregion_init(opr_dev); 601 if (rv) { 602 dev_err(cl_data_to_dev(opr_dev), "ACPI opregion init failed\n"); 603 goto err_exit; 604 } 605 606 /* Reprobe devices depending on ECLite - battery, fan, etc. */ 607 acpi_dev_clear_dependencies(opr_dev->adev); 608 609 return 0; 610 err_exit: 611 ishtp_set_connection_state(ecl_ishtp_cl, ISHTP_CL_DISCONNECTING); 612 ishtp_cl_disconnect(ecl_ishtp_cl); 613 ecl_ishtp_cl_deinit(ecl_ishtp_cl); 614 615 return rv; 616 } 617 618 static void ecl_ishtp_cl_remove(struct ishtp_cl_device *cl_device) 619 { 620 struct ishtp_cl *ecl_ishtp_cl = ishtp_get_drvdata(cl_device); 621 struct ishtp_opregion_dev *opr_dev = 622 ishtp_get_client_data(ecl_ishtp_cl); 623 624 if (opr_dev->acpi_init_done) 625 acpi_opregion_deinit(opr_dev); 626 627 acpi_dev_put(opr_dev->adev); 628 629 ishtp_set_connection_state(ecl_ishtp_cl, ISHTP_CL_DISCONNECTING); 630 ishtp_cl_disconnect(ecl_ishtp_cl); 631 ecl_ishtp_cl_deinit(ecl_ishtp_cl); 632 633 cancel_work_sync(&opr_dev->reset_work); 634 cancel_work_sync(&opr_dev->event_work); 635 } 636 637 static int ecl_ishtp_cl_reset(struct ishtp_cl_device *cl_device) 638 { 639 struct ishtp_cl *ecl_ishtp_cl = ishtp_get_drvdata(cl_device); 640 struct ishtp_opregion_dev *opr_dev = 641 ishtp_get_client_data(ecl_ishtp_cl); 642 643 schedule_work(&opr_dev->reset_work); 644 645 return 0; 646 } 647 648 static int ecl_ishtp_cl_suspend(struct device *device) 649 { 650 struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(device); 651 struct ishtp_cl *ecl_ishtp_cl = ishtp_get_drvdata(cl_device); 652 struct ishtp_opregion_dev *opr_dev = 653 ishtp_get_client_data(ecl_ishtp_cl); 654 655 if (acpi_target_system_state() == ACPI_STATE_S0) 656 return 0; 657 658 acpi_opregion_deinit(opr_dev); 659 ecl_ish_cl_enable_events(opr_dev, false); 660 661 return 0; 662 } 663 664 static int ecl_ishtp_cl_resume(struct device *device) 665 { 666 /* A reset is expected to call after an Sx. At this point 667 * we are not sure if the link is up or not to restore anything, 668 * so do nothing in resume path 669 */ 670 return 0; 671 } 672 673 static const struct dev_pm_ops ecl_ishtp_pm_ops = { 674 .suspend = ecl_ishtp_cl_suspend, 675 .resume = ecl_ishtp_cl_resume, 676 }; 677 678 static struct ishtp_cl_driver ecl_ishtp_cl_driver = { 679 .name = "ishtp-eclite", 680 .id = ecl_ishtp_id_table, 681 .probe = ecl_ishtp_cl_probe, 682 .remove = ecl_ishtp_cl_remove, 683 .reset = ecl_ishtp_cl_reset, 684 .driver.pm = &ecl_ishtp_pm_ops, 685 }; 686 687 static int __init ecl_ishtp_init(void) 688 { 689 return ishtp_cl_driver_register(&ecl_ishtp_cl_driver, THIS_MODULE); 690 } 691 692 static void __exit ecl_ishtp_exit(void) 693 { 694 return ishtp_cl_driver_unregister(&ecl_ishtp_cl_driver); 695 } 696 697 late_initcall(ecl_ishtp_init); 698 module_exit(ecl_ishtp_exit); 699 700 MODULE_DESCRIPTION("ISH ISHTP eclite client opregion driver"); 701 MODULE_AUTHOR("K Naduvalath, Sumesh <sumesh.k.naduvalath@intel.com>"); 702 703 MODULE_LICENSE("GPL v2"); 704