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