1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* Copyright (c) 2024 Intel Corporation */ 3 4 #include <linux/acpi.h> 5 #include <linux/bitfield.h> 6 #include <linux/device.h> 7 #include <linux/dma-mapping.h> 8 #include <linux/err.h> 9 #include <linux/interrupt.h> 10 #include <linux/irqreturn.h> 11 #include <linux/pci.h> 12 #include <linux/pm_runtime.h> 13 14 #include "intel-thc-dev.h" 15 #include "intel-thc-hw.h" 16 17 #include "quickspi-dev.h" 18 #include "quickspi-hid.h" 19 #include "quickspi-protocol.h" 20 21 struct quickspi_driver_data mtl = { 22 .max_packet_size_value = MAX_PACKET_SIZE_VALUE_MTL, 23 }; 24 25 struct quickspi_driver_data lnl = { 26 .max_packet_size_value = MAX_PACKET_SIZE_VALUE_LNL, 27 }; 28 29 struct quickspi_driver_data ptl = { 30 .max_packet_size_value = MAX_PACKET_SIZE_VALUE_LNL, 31 }; 32 33 /* THC QuickSPI ACPI method to get device properties */ 34 /* HIDSPI Method: {6e2ac436-0fcf-41af-a265-b32a220dcfab} */ 35 static guid_t hidspi_guid = 36 GUID_INIT(0x6e2ac436, 0x0fcf, 0x41af, 0xa2, 0x65, 0xb3, 0x2a, 37 0x22, 0x0d, 0xcf, 0xab); 38 39 /* QuickSpi Method: {300D35b7-ac20-413e-8e9c-92e4dafd0afe} */ 40 static guid_t thc_quickspi_guid = 41 GUID_INIT(0x300d35b7, 0xac20, 0x413e, 0x8e, 0x9c, 0x92, 0xe4, 42 0xda, 0xfd, 0x0a, 0xfe); 43 44 /* Platform Method: {84005682-5b71-41a4-0x8d668130f787a138} */ 45 static guid_t thc_platform_guid = 46 GUID_INIT(0x84005682, 0x5b71, 0x41a4, 0x8d, 0x66, 0x81, 0x30, 47 0xf7, 0x87, 0xa1, 0x38); 48 49 /** 50 * thc_acpi_get_property - Query device ACPI parameter 51 * 52 * @adev: point to ACPI device 53 * @guid: ACPI method's guid 54 * @rev: ACPI method's revision 55 * @func: ACPI method's function number 56 * @type: ACPI parameter's data type 57 * @prop_buf: point to return buffer 58 * 59 * This is a helper function for device to query its ACPI parameters. 60 * 61 * Return: 0 if successful or ENODEV on failed. 62 */ 63 static int thc_acpi_get_property(struct acpi_device *adev, const guid_t *guid, 64 u64 rev, u64 func, acpi_object_type type, void *prop_buf) 65 { 66 acpi_handle handle = acpi_device_handle(adev); 67 union acpi_object *obj; 68 69 obj = acpi_evaluate_dsm_typed(handle, guid, rev, func, NULL, type); 70 if (!obj) { 71 acpi_handle_err(handle, 72 "Error _DSM call failed, rev: %llu, func: %llu, type: %u\n", 73 rev, func, type); 74 return -ENODEV; 75 } 76 77 if (type == ACPI_TYPE_INTEGER) 78 *(u32 *)prop_buf = (u32)obj->integer.value; 79 else if (type == ACPI_TYPE_BUFFER) 80 memcpy(prop_buf, obj->buffer.pointer, obj->buffer.length); 81 82 ACPI_FREE(obj); 83 84 return 0; 85 } 86 87 /** 88 * quickspi_get_acpi_resources - Query all quickspi devices' ACPI parameters 89 * 90 * @qsdev: point to quickspi device 91 * 92 * This function gets all quickspi devices' ACPI resource. 93 * 94 * Return: 0 if successful or error code on failed. 95 */ 96 static int quickspi_get_acpi_resources(struct quickspi_device *qsdev) 97 { 98 struct acpi_device *adev = ACPI_COMPANION(qsdev->dev); 99 int ret = -EINVAL; 100 101 if (!adev) { 102 dev_err(qsdev->dev, "no valid ACPI companion\n"); 103 return ret; 104 } 105 106 qsdev->acpi_dev = adev; 107 108 ret = thc_acpi_get_property(adev, &hidspi_guid, 109 ACPI_QUICKSPI_REVISION_NUM, 110 ACPI_QUICKSPI_FUNC_NUM_INPUT_REP_HDR_ADDR, 111 ACPI_TYPE_INTEGER, 112 &qsdev->input_report_hdr_addr); 113 if (ret) 114 return ret; 115 116 ret = thc_acpi_get_property(adev, &hidspi_guid, 117 ACPI_QUICKSPI_REVISION_NUM, 118 ACPI_QUICKSPI_FUNC_NUM_INPUT_REP_BDY_ADDR, 119 ACPI_TYPE_INTEGER, 120 &qsdev->input_report_bdy_addr); 121 if (ret) 122 return ret; 123 124 ret = thc_acpi_get_property(adev, &hidspi_guid, 125 ACPI_QUICKSPI_REVISION_NUM, 126 ACPI_QUICKSPI_FUNC_NUM_OUTPUT_REP_ADDR, 127 ACPI_TYPE_INTEGER, 128 &qsdev->output_report_addr); 129 if (ret) 130 return ret; 131 132 ret = thc_acpi_get_property(adev, &hidspi_guid, 133 ACPI_QUICKSPI_REVISION_NUM, 134 ACPI_QUICKSPI_FUNC_NUM_READ_OPCODE, 135 ACPI_TYPE_BUFFER, 136 &qsdev->spi_read_opcode); 137 if (ret) 138 return ret; 139 140 ret = thc_acpi_get_property(adev, &hidspi_guid, 141 ACPI_QUICKSPI_REVISION_NUM, 142 ACPI_QUICKSPI_FUNC_NUM_WRITE_OPCODE, 143 ACPI_TYPE_BUFFER, 144 &qsdev->spi_write_opcode); 145 if (ret) 146 return ret; 147 148 ret = thc_acpi_get_property(adev, &hidspi_guid, 149 ACPI_QUICKSPI_REVISION_NUM, 150 ACPI_QUICKSPI_FUNC_NUM_IO_MODE, 151 ACPI_TYPE_INTEGER, 152 &qsdev->spi_read_io_mode); 153 if (ret) 154 return ret; 155 156 if (qsdev->spi_read_io_mode & SPI_WRITE_IO_MODE) 157 qsdev->spi_write_io_mode = FIELD_GET(SPI_IO_MODE_OPCODE, qsdev->spi_read_io_mode); 158 else 159 qsdev->spi_write_io_mode = THC_SINGLE_IO; 160 161 qsdev->spi_read_io_mode = FIELD_GET(SPI_IO_MODE_OPCODE, qsdev->spi_read_io_mode); 162 163 ret = thc_acpi_get_property(adev, &thc_quickspi_guid, 164 ACPI_QUICKSPI_REVISION_NUM, 165 ACPI_QUICKSPI_FUNC_NUM_CONNECTION_SPEED, 166 ACPI_TYPE_INTEGER, 167 &qsdev->spi_freq_val); 168 if (ret) 169 return ret; 170 171 ret = thc_acpi_get_property(adev, &thc_quickspi_guid, 172 ACPI_QUICKSPI_REVISION_NUM, 173 ACPI_QUICKSPI_FUNC_NUM_LIMIT_PACKET_SIZE, 174 ACPI_TYPE_INTEGER, 175 &qsdev->limit_packet_size); 176 if (ret) 177 return ret; 178 179 if (qsdev->limit_packet_size || !qsdev->driver_data) 180 qsdev->spi_packet_size = DEFAULT_MIN_PACKET_SIZE_VALUE; 181 else 182 qsdev->spi_packet_size = qsdev->driver_data->max_packet_size_value; 183 184 ret = thc_acpi_get_property(adev, &thc_quickspi_guid, 185 ACPI_QUICKSPI_REVISION_NUM, 186 ACPI_QUICKSPI_FUNC_NUM_PERFORMANCE_LIMIT, 187 ACPI_TYPE_INTEGER, 188 &qsdev->performance_limit); 189 if (ret) 190 return ret; 191 192 qsdev->performance_limit = FIELD_GET(PERFORMANCE_LIMITATION, qsdev->performance_limit); 193 194 ret = thc_acpi_get_property(adev, &thc_platform_guid, 195 ACPI_QUICKSPI_REVISION_NUM, 196 ACPI_QUICKSPI_FUNC_NUM_ACTIVE_LTR, 197 ACPI_TYPE_INTEGER, 198 &qsdev->active_ltr_val); 199 if (ret) 200 return ret; 201 202 ret = thc_acpi_get_property(adev, &thc_platform_guid, 203 ACPI_QUICKSPI_REVISION_NUM, 204 ACPI_QUICKSPI_FUNC_NUM_LP_LTR, 205 ACPI_TYPE_INTEGER, 206 &qsdev->low_power_ltr_val); 207 if (ret) 208 return ret; 209 210 return 0; 211 } 212 213 /** 214 * quickspi_irq_quick_handler - The ISR of the quickspi driver 215 * 216 * @irq: The irq number 217 * @dev_id: pointer to the device structure 218 * 219 * Return: IRQ_WAKE_THREAD if further process needed. 220 */ 221 static irqreturn_t quickspi_irq_quick_handler(int irq, void *dev_id) 222 { 223 struct quickspi_device *qsdev = dev_id; 224 225 if (qsdev->state == QUICKSPI_DISABLED) 226 return IRQ_HANDLED; 227 228 /* Disable THC interrupt before current interrupt be handled */ 229 thc_interrupt_enable(qsdev->thc_hw, false); 230 231 return IRQ_WAKE_THREAD; 232 } 233 234 /** 235 * try_recover - Try to recovery THC and Device 236 * @qsdev: pointer to quickspi device 237 * 238 * This function is a error handler, called when fatal error happens. 239 * It try to reset Touch Device and re-configure THC to recovery 240 * transferring between Device and THC. 241 * 242 * Return: 0 if successful or error code on failed. 243 */ 244 static int try_recover(struct quickspi_device *qsdev) 245 { 246 int ret; 247 248 ret = reset_tic(qsdev); 249 if (ret) { 250 dev_err(qsdev->dev, "Reset touch device failed, ret = %d\n", ret); 251 return ret; 252 } 253 254 thc_dma_unconfigure(qsdev->thc_hw); 255 256 ret = thc_dma_configure(qsdev->thc_hw); 257 if (ret) { 258 dev_err(qsdev->dev, "Re-configure THC DMA failed, ret = %d\n", ret); 259 return ret; 260 } 261 262 return 0; 263 } 264 265 /** 266 * quickspi_irq_thread_handler - IRQ thread handler of quickspi driver 267 * 268 * @irq: The IRQ number 269 * @dev_id: pointer to the quickspi device structure 270 * 271 * Return: IRQ_HANDLED to finish this handler. 272 */ 273 static irqreturn_t quickspi_irq_thread_handler(int irq, void *dev_id) 274 { 275 struct quickspi_device *qsdev = dev_id; 276 size_t input_len; 277 int read_finished = 0; 278 int err_recover = 0; 279 int int_mask; 280 int ret; 281 282 if (qsdev->state == QUICKSPI_DISABLED) 283 return IRQ_HANDLED; 284 285 ret = pm_runtime_resume_and_get(qsdev->dev); 286 if (ret) 287 return IRQ_HANDLED; 288 289 int_mask = thc_interrupt_handler(qsdev->thc_hw); 290 291 if (int_mask & BIT(THC_FATAL_ERR_INT) || int_mask & BIT(THC_TXN_ERR_INT)) { 292 err_recover = 1; 293 goto end; 294 } 295 296 if (int_mask & BIT(THC_NONDMA_INT)) { 297 if (qsdev->state == QUICKSPI_RESETING) { 298 qsdev->reset_ack = true; 299 wake_up_interruptible(&qsdev->reset_ack_wq); 300 } else { 301 qsdev->nondma_int_received = true; 302 wake_up_interruptible(&qsdev->nondma_int_received_wq); 303 } 304 } 305 306 if (int_mask & BIT(THC_RXDMA2_INT)) { 307 while (!read_finished) { 308 ret = thc_rxdma_read(qsdev->thc_hw, THC_RXDMA2, qsdev->input_buf, 309 &input_len, &read_finished); 310 if (ret) { 311 err_recover = 1; 312 goto end; 313 } 314 315 quickspi_handle_input_data(qsdev, input_len); 316 } 317 } 318 319 end: 320 thc_interrupt_enable(qsdev->thc_hw, true); 321 322 if (err_recover) 323 if (try_recover(qsdev)) 324 qsdev->state = QUICKSPI_DISABLED; 325 326 pm_runtime_mark_last_busy(qsdev->dev); 327 pm_runtime_put_autosuspend(qsdev->dev); 328 329 return IRQ_HANDLED; 330 } 331 332 /** 333 * quickspi_dev_init - Initialize quickspi device 334 * 335 * @pdev: pointer to the thc pci device 336 * @mem_addr: The pointer of MMIO memory address 337 * @id: point to pci_device_id structure 338 * 339 * Alloc quickspi device structure and initialized THC device, 340 * then configure THC to HIDSPI mode. 341 * 342 * If success, enable THC hardware interrupt. 343 * 344 * Return: pointer to the quickspi device structure if success 345 * or NULL on failed. 346 */ 347 static struct quickspi_device *quickspi_dev_init(struct pci_dev *pdev, void __iomem *mem_addr, 348 const struct pci_device_id *id) 349 { 350 struct device *dev = &pdev->dev; 351 struct quickspi_device *qsdev; 352 int ret; 353 354 qsdev = devm_kzalloc(dev, sizeof(struct quickspi_device), GFP_KERNEL); 355 if (!qsdev) 356 return ERR_PTR(-ENOMEM); 357 358 qsdev->pdev = pdev; 359 qsdev->dev = dev; 360 qsdev->mem_addr = mem_addr; 361 qsdev->state = QUICKSPI_DISABLED; 362 qsdev->driver_data = (struct quickspi_driver_data *)id->driver_data; 363 364 init_waitqueue_head(&qsdev->reset_ack_wq); 365 init_waitqueue_head(&qsdev->nondma_int_received_wq); 366 init_waitqueue_head(&qsdev->report_desc_got_wq); 367 init_waitqueue_head(&qsdev->get_report_cmpl_wq); 368 init_waitqueue_head(&qsdev->set_report_cmpl_wq); 369 370 /* thc hw init */ 371 qsdev->thc_hw = thc_dev_init(qsdev->dev, qsdev->mem_addr); 372 if (IS_ERR(qsdev->thc_hw)) { 373 ret = PTR_ERR(qsdev->thc_hw); 374 dev_err(dev, "Failed to initialize THC device context, ret = %d.\n", ret); 375 return ERR_PTR(ret); 376 } 377 378 ret = thc_interrupt_quiesce(qsdev->thc_hw, true); 379 if (ret) 380 return ERR_PTR(ret); 381 382 ret = thc_port_select(qsdev->thc_hw, THC_PORT_TYPE_SPI); 383 if (ret) { 384 dev_err(dev, "Failed to select THC port, ret = %d.\n", ret); 385 return ERR_PTR(ret); 386 } 387 388 ret = quickspi_get_acpi_resources(qsdev); 389 if (ret) { 390 dev_err(dev, "Get ACPI resources failed, ret = %d\n", ret); 391 return ERR_PTR(ret); 392 } 393 394 /* THC config for input/output address */ 395 thc_spi_input_output_address_config(qsdev->thc_hw, 396 qsdev->input_report_hdr_addr, 397 qsdev->input_report_bdy_addr, 398 qsdev->output_report_addr); 399 400 /* THC config for spi read operation */ 401 ret = thc_spi_read_config(qsdev->thc_hw, qsdev->spi_freq_val, 402 qsdev->spi_read_io_mode, 403 qsdev->spi_read_opcode, 404 qsdev->spi_packet_size); 405 if (ret) { 406 dev_err(dev, "thc_spi_read_config failed, ret = %d\n", ret); 407 return ERR_PTR(ret); 408 } 409 410 /* THC config for spi write operation */ 411 ret = thc_spi_write_config(qsdev->thc_hw, qsdev->spi_freq_val, 412 qsdev->spi_write_io_mode, 413 qsdev->spi_write_opcode, 414 qsdev->spi_packet_size, 415 qsdev->performance_limit); 416 if (ret) { 417 dev_err(dev, "thc_spi_write_config failed, ret = %d\n", ret); 418 return ERR_PTR(ret); 419 } 420 421 thc_ltr_config(qsdev->thc_hw, 422 qsdev->active_ltr_val, 423 qsdev->low_power_ltr_val); 424 425 thc_interrupt_config(qsdev->thc_hw); 426 427 thc_interrupt_enable(qsdev->thc_hw, true); 428 429 qsdev->state = QUICKSPI_INITIATED; 430 431 return qsdev; 432 } 433 434 /** 435 * quickspi_dev_deinit - De-initialize quickspi device 436 * 437 * @qsdev: pointer to the quickspi device structure 438 * 439 * Disable THC interrupt and deinitilize THC. 440 */ 441 static void quickspi_dev_deinit(struct quickspi_device *qsdev) 442 { 443 thc_interrupt_enable(qsdev->thc_hw, false); 444 thc_ltr_unconfig(qsdev->thc_hw); 445 446 qsdev->state = QUICKSPI_DISABLED; 447 } 448 449 /** 450 * quickspi_dma_init - Configure THC DMA for quickspi device 451 * @qsdev: pointer to the quickspi device structure 452 * 453 * This function uses TIC's parameters(such as max input length, max output 454 * length) to allocate THC DMA buffers and configure THC DMA engines. 455 * 456 * Return: 0 if successful or error code on failed. 457 */ 458 static int quickspi_dma_init(struct quickspi_device *qsdev) 459 { 460 int ret; 461 462 ret = thc_dma_set_max_packet_sizes(qsdev->thc_hw, 0, 463 le16_to_cpu(qsdev->dev_desc.max_input_len), 464 le16_to_cpu(qsdev->dev_desc.max_output_len), 465 0); 466 if (ret) 467 return ret; 468 469 ret = thc_dma_allocate(qsdev->thc_hw); 470 if (ret) { 471 dev_err(qsdev->dev, "Allocate THC DMA buffer failed, ret = %d\n", ret); 472 return ret; 473 } 474 475 /* Enable RxDMA */ 476 ret = thc_dma_configure(qsdev->thc_hw); 477 if (ret) { 478 dev_err(qsdev->dev, "Configure THC DMA failed, ret = %d\n", ret); 479 thc_dma_unconfigure(qsdev->thc_hw); 480 thc_dma_release(qsdev->thc_hw); 481 return ret; 482 } 483 484 return ret; 485 } 486 487 /** 488 * quickspi_dma_deinit - Release THC DMA for quickspi device 489 * @qsdev: pointer to the quickspi device structure 490 * 491 * Stop THC DMA engines and release all DMA buffers. 492 * 493 */ 494 static void quickspi_dma_deinit(struct quickspi_device *qsdev) 495 { 496 thc_dma_unconfigure(qsdev->thc_hw); 497 thc_dma_release(qsdev->thc_hw); 498 } 499 500 /** 501 * quickspi_alloc_report_buf - Alloc report buffers 502 * @qsdev: pointer to the quickspi device structure 503 * 504 * Allocate report descriptor buffer, it will be used for restore TIC HID 505 * report descriptor. 506 * 507 * Allocate input report buffer, it will be used for receive HID input report 508 * data from TIC. 509 * 510 * Allocate output report buffer, it will be used for store HID output report, 511 * such as set feature. 512 * 513 * Return: 0 if successful or error code on failed. 514 */ 515 static int quickspi_alloc_report_buf(struct quickspi_device *qsdev) 516 { 517 size_t max_report_len; 518 size_t max_input_len; 519 520 qsdev->report_descriptor = devm_kzalloc(qsdev->dev, 521 le16_to_cpu(qsdev->dev_desc.rep_desc_len), 522 GFP_KERNEL); 523 if (!qsdev->report_descriptor) 524 return -ENOMEM; 525 526 max_input_len = max(le16_to_cpu(qsdev->dev_desc.rep_desc_len), 527 le16_to_cpu(qsdev->dev_desc.max_input_len)); 528 529 qsdev->input_buf = devm_kzalloc(qsdev->dev, max_input_len, GFP_KERNEL); 530 if (!qsdev->input_buf) 531 return -ENOMEM; 532 533 max_report_len = max(le16_to_cpu(qsdev->dev_desc.max_output_len), 534 le16_to_cpu(qsdev->dev_desc.max_input_len)); 535 536 qsdev->report_buf = devm_kzalloc(qsdev->dev, max_report_len, GFP_KERNEL); 537 if (!qsdev->report_buf) 538 return -ENOMEM; 539 540 return 0; 541 } 542 543 /* 544 * quickspi_probe: Quickspi driver probe function 545 * 546 * @pdev: point to pci device 547 * @id: point to pci_device_id structure 548 * 549 * This function initializes THC and HIDSPI device, the flow is: 550 * - do THC pci device initialization 551 * - query HIDSPI ACPI parameters 552 * - configure THC to HIDSPI mode 553 * - go through HIDSPI enumeration flow 554 * |- reset HIDSPI device 555 * |- read device descriptor 556 * - enable THC interrupt and DMA 557 * - read report descriptor 558 * - register HID device 559 * - enable runtime power management 560 * 561 * Return 0 if success or error code on failure. 562 */ 563 static int quickspi_probe(struct pci_dev *pdev, 564 const struct pci_device_id *id) 565 { 566 struct quickspi_device *qsdev; 567 void __iomem *mem_addr; 568 int ret; 569 570 ret = pcim_enable_device(pdev); 571 if (ret) { 572 dev_err(&pdev->dev, "Failed to enable PCI device, ret = %d.\n", ret); 573 return ret; 574 } 575 576 pci_set_master(pdev); 577 578 mem_addr = pcim_iomap_region(pdev, 0, KBUILD_MODNAME); 579 ret = PTR_ERR_OR_ZERO(mem_addr); 580 if (ret) { 581 dev_err(&pdev->dev, "Failed to get PCI regions, ret = %d.\n", ret); 582 goto disable_pci_device; 583 } 584 585 ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)); 586 if (ret) { 587 ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 588 if (ret) { 589 dev_err(&pdev->dev, "No usable DMA configuration %d\n", ret); 590 goto disable_pci_device; 591 } 592 } 593 594 ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES); 595 if (ret < 0) { 596 dev_err(&pdev->dev, 597 "Failed to allocate IRQ vectors. ret = %d\n", ret); 598 goto disable_pci_device; 599 } 600 601 pdev->irq = pci_irq_vector(pdev, 0); 602 603 qsdev = quickspi_dev_init(pdev, mem_addr, id); 604 if (IS_ERR(qsdev)) { 605 dev_err(&pdev->dev, "QuickSPI device init failed\n"); 606 ret = PTR_ERR(qsdev); 607 goto disable_pci_device; 608 } 609 610 pci_set_drvdata(pdev, qsdev); 611 612 ret = devm_request_threaded_irq(&pdev->dev, pdev->irq, 613 quickspi_irq_quick_handler, 614 quickspi_irq_thread_handler, 615 IRQF_ONESHOT, KBUILD_MODNAME, 616 qsdev); 617 if (ret) { 618 dev_err(&pdev->dev, 619 "Failed to request threaded IRQ, irq = %d.\n", pdev->irq); 620 goto dev_deinit; 621 } 622 623 ret = reset_tic(qsdev); 624 if (ret) { 625 dev_err(&pdev->dev, "Reset Touch Device failed, ret = %d\n", ret); 626 goto dev_deinit; 627 } 628 629 ret = quickspi_alloc_report_buf(qsdev); 630 if (ret) { 631 dev_err(&pdev->dev, "Alloc report buffers failed, ret= %d\n", ret); 632 goto dev_deinit; 633 } 634 635 ret = quickspi_dma_init(qsdev); 636 if (ret) { 637 dev_err(&pdev->dev, "Setup THC DMA failed, ret= %d\n", ret); 638 goto dev_deinit; 639 } 640 641 ret = quickspi_get_report_descriptor(qsdev); 642 if (ret) { 643 dev_err(&pdev->dev, "Get report descriptor failed, ret = %d\n", ret); 644 goto dma_deinit; 645 } 646 647 ret = quickspi_hid_probe(qsdev); 648 if (ret) { 649 dev_err(&pdev->dev, "Failed to register HID device, ret = %d\n", ret); 650 goto dma_deinit; 651 } 652 653 qsdev->state = QUICKSPI_ENABLED; 654 655 /* Enable runtime power management */ 656 pm_runtime_use_autosuspend(qsdev->dev); 657 pm_runtime_set_autosuspend_delay(qsdev->dev, DEFAULT_AUTO_SUSPEND_DELAY_MS); 658 pm_runtime_mark_last_busy(qsdev->dev); 659 pm_runtime_put_noidle(qsdev->dev); 660 pm_runtime_put_autosuspend(qsdev->dev); 661 662 dev_dbg(&pdev->dev, "QuickSPI probe success\n"); 663 664 return 0; 665 666 dma_deinit: 667 quickspi_dma_deinit(qsdev); 668 dev_deinit: 669 quickspi_dev_deinit(qsdev); 670 disable_pci_device: 671 pci_clear_master(pdev); 672 673 return ret; 674 } 675 676 /** 677 * quickspi_remove - Device Removal Routine 678 * 679 * @pdev: PCI device structure 680 * 681 * This is called by the PCI subsystem to alert the driver 682 * that it should release a PCI device. 683 */ 684 static void quickspi_remove(struct pci_dev *pdev) 685 { 686 struct quickspi_device *qsdev; 687 688 qsdev = pci_get_drvdata(pdev); 689 if (!qsdev) 690 return; 691 692 quickspi_hid_remove(qsdev); 693 quickspi_dma_deinit(qsdev); 694 695 pm_runtime_get_noresume(qsdev->dev); 696 697 quickspi_dev_deinit(qsdev); 698 699 pci_clear_master(pdev); 700 } 701 702 /** 703 * quickspi_shutdown - Device Shutdown Routine 704 * 705 * @pdev: PCI device structure 706 * 707 * This is called from the reboot notifier 708 * it's a simplified version of remove so we go down 709 * faster. 710 */ 711 static void quickspi_shutdown(struct pci_dev *pdev) 712 { 713 struct quickspi_device *qsdev; 714 715 qsdev = pci_get_drvdata(pdev); 716 if (!qsdev) 717 return; 718 719 /* Must stop DMA before reboot to avoid DMA entering into unknown state */ 720 quickspi_dma_deinit(qsdev); 721 722 quickspi_dev_deinit(qsdev); 723 } 724 725 static int quickspi_suspend(struct device *device) 726 { 727 struct pci_dev *pdev = to_pci_dev(device); 728 struct quickspi_device *qsdev; 729 int ret; 730 731 qsdev = pci_get_drvdata(pdev); 732 if (!qsdev) 733 return -ENODEV; 734 735 ret = quickspi_set_power(qsdev, HIDSPI_SLEEP); 736 if (ret) 737 return ret; 738 739 ret = thc_interrupt_quiesce(qsdev->thc_hw, true); 740 if (ret) 741 return ret; 742 743 thc_interrupt_enable(qsdev->thc_hw, false); 744 745 thc_dma_unconfigure(qsdev->thc_hw); 746 747 return 0; 748 } 749 750 static int quickspi_resume(struct device *device) 751 { 752 struct pci_dev *pdev = to_pci_dev(device); 753 struct quickspi_device *qsdev; 754 int ret; 755 756 qsdev = pci_get_drvdata(pdev); 757 if (!qsdev) 758 return -ENODEV; 759 760 ret = thc_port_select(qsdev->thc_hw, THC_PORT_TYPE_SPI); 761 if (ret) 762 return ret; 763 764 thc_interrupt_config(qsdev->thc_hw); 765 766 thc_interrupt_enable(qsdev->thc_hw, true); 767 768 ret = thc_dma_configure(qsdev->thc_hw); 769 if (ret) 770 return ret; 771 772 ret = thc_interrupt_quiesce(qsdev->thc_hw, false); 773 if (ret) 774 return ret; 775 776 ret = quickspi_set_power(qsdev, HIDSPI_ON); 777 if (ret) 778 return ret; 779 780 return 0; 781 } 782 783 static int quickspi_freeze(struct device *device) 784 { 785 struct pci_dev *pdev = to_pci_dev(device); 786 struct quickspi_device *qsdev; 787 int ret; 788 789 qsdev = pci_get_drvdata(pdev); 790 if (!qsdev) 791 return -ENODEV; 792 793 ret = thc_interrupt_quiesce(qsdev->thc_hw, true); 794 if (ret) 795 return ret; 796 797 thc_interrupt_enable(qsdev->thc_hw, false); 798 799 thc_dma_unconfigure(qsdev->thc_hw); 800 801 return 0; 802 } 803 804 static int quickspi_thaw(struct device *device) 805 { 806 struct pci_dev *pdev = to_pci_dev(device); 807 struct quickspi_device *qsdev; 808 int ret; 809 810 qsdev = pci_get_drvdata(pdev); 811 if (!qsdev) 812 return -ENODEV; 813 814 ret = thc_dma_configure(qsdev->thc_hw); 815 if (ret) 816 return ret; 817 818 thc_interrupt_enable(qsdev->thc_hw, true); 819 820 ret = thc_interrupt_quiesce(qsdev->thc_hw, false); 821 if (ret) 822 return ret; 823 824 return 0; 825 } 826 827 static int quickspi_poweroff(struct device *device) 828 { 829 struct pci_dev *pdev = to_pci_dev(device); 830 struct quickspi_device *qsdev; 831 int ret; 832 833 qsdev = pci_get_drvdata(pdev); 834 if (!qsdev) 835 return -ENODEV; 836 837 ret = thc_interrupt_quiesce(qsdev->thc_hw, true); 838 if (ret) 839 return ret; 840 841 thc_interrupt_enable(qsdev->thc_hw, false); 842 843 thc_ltr_unconfig(qsdev->thc_hw); 844 845 quickspi_dma_deinit(qsdev); 846 847 return 0; 848 } 849 850 static int quickspi_restore(struct device *device) 851 { 852 struct pci_dev *pdev = to_pci_dev(device); 853 struct quickspi_device *qsdev; 854 int ret; 855 856 qsdev = pci_get_drvdata(pdev); 857 if (!qsdev) 858 return -ENODEV; 859 860 ret = thc_interrupt_quiesce(qsdev->thc_hw, true); 861 if (ret) 862 return ret; 863 864 /* Reconfig THC HW when back from hibernate */ 865 ret = thc_port_select(qsdev->thc_hw, THC_PORT_TYPE_SPI); 866 if (ret) 867 return ret; 868 869 thc_spi_input_output_address_config(qsdev->thc_hw, 870 qsdev->input_report_hdr_addr, 871 qsdev->input_report_bdy_addr, 872 qsdev->output_report_addr); 873 874 ret = thc_spi_read_config(qsdev->thc_hw, qsdev->spi_freq_val, 875 qsdev->spi_read_io_mode, 876 qsdev->spi_read_opcode, 877 qsdev->spi_packet_size); 878 if (ret) 879 return ret; 880 881 ret = thc_spi_write_config(qsdev->thc_hw, qsdev->spi_freq_val, 882 qsdev->spi_write_io_mode, 883 qsdev->spi_write_opcode, 884 qsdev->spi_packet_size, 885 qsdev->performance_limit); 886 if (ret) 887 return ret; 888 889 thc_interrupt_config(qsdev->thc_hw); 890 891 thc_interrupt_enable(qsdev->thc_hw, true); 892 893 /* TIC may lose power, needs go through reset flow */ 894 ret = reset_tic(qsdev); 895 if (ret) 896 return ret; 897 898 ret = thc_dma_configure(qsdev->thc_hw); 899 if (ret) 900 return ret; 901 902 thc_ltr_config(qsdev->thc_hw, 903 qsdev->active_ltr_val, 904 qsdev->low_power_ltr_val); 905 906 thc_change_ltr_mode(qsdev->thc_hw, THC_LTR_MODE_ACTIVE); 907 908 qsdev->state = QUICKSPI_ENABLED; 909 910 return 0; 911 } 912 913 static int quickspi_runtime_suspend(struct device *device) 914 { 915 struct pci_dev *pdev = to_pci_dev(device); 916 struct quickspi_device *qsdev; 917 918 qsdev = pci_get_drvdata(pdev); 919 if (!qsdev) 920 return -ENODEV; 921 922 thc_change_ltr_mode(qsdev->thc_hw, THC_LTR_MODE_LP); 923 924 pci_save_state(pdev); 925 926 return 0; 927 } 928 929 static int quickspi_runtime_resume(struct device *device) 930 { 931 struct pci_dev *pdev = to_pci_dev(device); 932 struct quickspi_device *qsdev; 933 934 qsdev = pci_get_drvdata(pdev); 935 if (!qsdev) 936 return -ENODEV; 937 938 thc_change_ltr_mode(qsdev->thc_hw, THC_LTR_MODE_ACTIVE); 939 940 return 0; 941 } 942 943 static const struct dev_pm_ops quickspi_pm_ops = { 944 .suspend = quickspi_suspend, 945 .resume = quickspi_resume, 946 .freeze = quickspi_freeze, 947 .thaw = quickspi_thaw, 948 .poweroff = quickspi_poweroff, 949 .restore = quickspi_restore, 950 .runtime_suspend = quickspi_runtime_suspend, 951 .runtime_resume = quickspi_runtime_resume, 952 .runtime_idle = NULL, 953 }; 954 955 static const struct pci_device_id quickspi_pci_tbl[] = { 956 {PCI_DEVICE_DATA(INTEL, THC_MTL_DEVICE_ID_SPI_PORT1, &mtl), }, 957 {PCI_DEVICE_DATA(INTEL, THC_MTL_DEVICE_ID_SPI_PORT2, &mtl), }, 958 {PCI_DEVICE_DATA(INTEL, THC_LNL_DEVICE_ID_SPI_PORT1, &lnl), }, 959 {PCI_DEVICE_DATA(INTEL, THC_LNL_DEVICE_ID_SPI_PORT2, &lnl), }, 960 {PCI_DEVICE_DATA(INTEL, THC_PTL_H_DEVICE_ID_SPI_PORT1, &ptl), }, 961 {PCI_DEVICE_DATA(INTEL, THC_PTL_H_DEVICE_ID_SPI_PORT2, &ptl), }, 962 {PCI_DEVICE_DATA(INTEL, THC_PTL_U_DEVICE_ID_SPI_PORT1, &ptl), }, 963 {PCI_DEVICE_DATA(INTEL, THC_PTL_U_DEVICE_ID_SPI_PORT2, &ptl), }, 964 {} 965 }; 966 MODULE_DEVICE_TABLE(pci, quickspi_pci_tbl); 967 968 static struct pci_driver quickspi_driver = { 969 .name = KBUILD_MODNAME, 970 .id_table = quickspi_pci_tbl, 971 .probe = quickspi_probe, 972 .remove = quickspi_remove, 973 .shutdown = quickspi_shutdown, 974 .driver.pm = &quickspi_pm_ops, 975 .driver.probe_type = PROBE_PREFER_ASYNCHRONOUS, 976 }; 977 978 module_pci_driver(quickspi_driver); 979 980 MODULE_AUTHOR("Xinpeng Sun <xinpeng.sun@intel.com>"); 981 MODULE_AUTHOR("Even Xu <even.xu@intel.com>"); 982 983 MODULE_DESCRIPTION("Intel(R) QuickSPI Driver"); 984 MODULE_LICENSE("GPL"); 985 MODULE_IMPORT_NS("INTEL_THC"); 986