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