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 */
thc_acpi_get_property(struct acpi_device * adev,const guid_t * guid,u64 rev,u64 func,acpi_object_type type,void * prop_buf)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 */
quickspi_get_acpi_resources(struct quickspi_device * qsdev)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 */
quickspi_irq_quick_handler(int irq,void * dev_id)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 */
try_recover(struct quickspi_device * qsdev)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 */
quickspi_irq_thread_handler(int irq,void * dev_id)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_put_autosuspend(qsdev->dev);
343
344 return IRQ_HANDLED;
345 }
346
347 /**
348 * quickspi_dev_init - Initialize quickspi device
349 *
350 * @pdev: pointer to the thc pci device
351 * @mem_addr: The pointer of MMIO memory address
352 * @id: point to pci_device_id structure
353 *
354 * Alloc quickspi device structure and initialized THC device,
355 * then configure THC to HIDSPI mode.
356 *
357 * If success, enable THC hardware interrupt.
358 *
359 * Return: pointer to the quickspi device structure if success
360 * or NULL on failed.
361 */
quickspi_dev_init(struct pci_dev * pdev,void __iomem * mem_addr,const struct pci_device_id * id)362 static struct quickspi_device *quickspi_dev_init(struct pci_dev *pdev, void __iomem *mem_addr,
363 const struct pci_device_id *id)
364 {
365 struct device *dev = &pdev->dev;
366 struct quickspi_device *qsdev;
367 int ret;
368
369 qsdev = devm_kzalloc(dev, sizeof(struct quickspi_device), GFP_KERNEL);
370 if (!qsdev)
371 return ERR_PTR(-ENOMEM);
372
373 qsdev->pdev = pdev;
374 qsdev->dev = dev;
375 qsdev->mem_addr = mem_addr;
376 qsdev->state = QUICKSPI_DISABLED;
377 qsdev->driver_data = (struct quickspi_driver_data *)id->driver_data;
378
379 init_waitqueue_head(&qsdev->reset_ack_wq);
380 init_waitqueue_head(&qsdev->nondma_int_received_wq);
381 init_waitqueue_head(&qsdev->report_desc_got_wq);
382 init_waitqueue_head(&qsdev->get_report_cmpl_wq);
383 init_waitqueue_head(&qsdev->set_report_cmpl_wq);
384
385 /* thc hw init */
386 qsdev->thc_hw = thc_dev_init(qsdev->dev, qsdev->mem_addr);
387 if (IS_ERR(qsdev->thc_hw)) {
388 ret = PTR_ERR(qsdev->thc_hw);
389 dev_err(dev, "Failed to initialize THC device context, ret = %d.\n", ret);
390 return ERR_PTR(ret);
391 }
392
393 ret = thc_interrupt_quiesce(qsdev->thc_hw, true);
394 if (ret)
395 return ERR_PTR(ret);
396
397 ret = thc_port_select(qsdev->thc_hw, THC_PORT_TYPE_SPI);
398 if (ret) {
399 dev_err(dev, "Failed to select THC port, ret = %d.\n", ret);
400 return ERR_PTR(ret);
401 }
402
403 ret = quickspi_get_acpi_resources(qsdev);
404 if (ret) {
405 dev_err(dev, "Get ACPI resources failed, ret = %d\n", ret);
406 return ERR_PTR(ret);
407 }
408
409 /* THC config for input/output address */
410 thc_spi_input_output_address_config(qsdev->thc_hw,
411 qsdev->input_report_hdr_addr,
412 qsdev->input_report_bdy_addr,
413 qsdev->output_report_addr);
414
415 /* THC config for spi read operation */
416 ret = thc_spi_read_config(qsdev->thc_hw, qsdev->spi_freq_val,
417 qsdev->spi_read_io_mode,
418 qsdev->spi_read_opcode,
419 qsdev->spi_packet_size);
420 if (ret) {
421 dev_err(dev, "thc_spi_read_config failed, ret = %d\n", ret);
422 return ERR_PTR(ret);
423 }
424
425 /* THC config for spi write operation */
426 ret = thc_spi_write_config(qsdev->thc_hw, qsdev->spi_freq_val,
427 qsdev->spi_write_io_mode,
428 qsdev->spi_write_opcode,
429 qsdev->spi_packet_size,
430 qsdev->performance_limit);
431 if (ret) {
432 dev_err(dev, "thc_spi_write_config failed, ret = %d\n", ret);
433 return ERR_PTR(ret);
434 }
435
436 thc_ltr_config(qsdev->thc_hw,
437 qsdev->active_ltr_val,
438 qsdev->low_power_ltr_val);
439
440 thc_interrupt_config(qsdev->thc_hw);
441
442 thc_interrupt_enable(qsdev->thc_hw, true);
443
444 thc_wot_config(qsdev->thc_hw, &quickspi_gpios[0]);
445
446 qsdev->state = QUICKSPI_INITIATED;
447
448 return qsdev;
449 }
450
451 /**
452 * quickspi_dev_deinit - De-initialize quickspi device
453 *
454 * @qsdev: pointer to the quickspi device structure
455 *
456 * Disable THC interrupt and deinitilize THC.
457 */
quickspi_dev_deinit(struct quickspi_device * qsdev)458 static void quickspi_dev_deinit(struct quickspi_device *qsdev)
459 {
460 thc_interrupt_enable(qsdev->thc_hw, false);
461 thc_ltr_unconfig(qsdev->thc_hw);
462 thc_wot_unconfig(qsdev->thc_hw);
463
464 qsdev->state = QUICKSPI_DISABLED;
465 }
466
467 /**
468 * quickspi_dma_init - Configure THC DMA for quickspi device
469 * @qsdev: pointer to the quickspi device structure
470 *
471 * This function uses TIC's parameters(such as max input length, max output
472 * length) to allocate THC DMA buffers and configure THC DMA engines.
473 *
474 * Return: 0 if successful or error code on failed.
475 */
quickspi_dma_init(struct quickspi_device * qsdev)476 static int quickspi_dma_init(struct quickspi_device *qsdev)
477 {
478 int ret;
479
480 ret = thc_dma_set_max_packet_sizes(qsdev->thc_hw, 0,
481 le16_to_cpu(qsdev->dev_desc.max_input_len),
482 le16_to_cpu(qsdev->dev_desc.max_output_len),
483 0);
484 if (ret)
485 return ret;
486
487 ret = thc_dma_allocate(qsdev->thc_hw);
488 if (ret) {
489 dev_err(qsdev->dev, "Allocate THC DMA buffer failed, ret = %d\n", ret);
490 return ret;
491 }
492
493 /* Enable RxDMA */
494 ret = thc_dma_configure(qsdev->thc_hw);
495 if (ret) {
496 dev_err(qsdev->dev, "Configure THC DMA failed, ret = %d\n", ret);
497 thc_dma_unconfigure(qsdev->thc_hw);
498 thc_dma_release(qsdev->thc_hw);
499 return ret;
500 }
501
502 return ret;
503 }
504
505 /**
506 * quickspi_dma_deinit - Release THC DMA for quickspi device
507 * @qsdev: pointer to the quickspi device structure
508 *
509 * Stop THC DMA engines and release all DMA buffers.
510 *
511 */
quickspi_dma_deinit(struct quickspi_device * qsdev)512 static void quickspi_dma_deinit(struct quickspi_device *qsdev)
513 {
514 thc_dma_unconfigure(qsdev->thc_hw);
515 thc_dma_release(qsdev->thc_hw);
516 }
517
518 /**
519 * quickspi_alloc_report_buf - Alloc report buffers
520 * @qsdev: pointer to the quickspi device structure
521 *
522 * Allocate report descriptor buffer, it will be used for restore TIC HID
523 * report descriptor.
524 *
525 * Allocate input report buffer, it will be used for receive HID input report
526 * data from TIC.
527 *
528 * Allocate output report buffer, it will be used for store HID output report,
529 * such as set feature.
530 *
531 * Return: 0 if successful or error code on failed.
532 */
quickspi_alloc_report_buf(struct quickspi_device * qsdev)533 static int quickspi_alloc_report_buf(struct quickspi_device *qsdev)
534 {
535 size_t max_report_len;
536 size_t max_input_len;
537
538 qsdev->report_descriptor = devm_kzalloc(qsdev->dev,
539 le16_to_cpu(qsdev->dev_desc.rep_desc_len),
540 GFP_KERNEL);
541 if (!qsdev->report_descriptor)
542 return -ENOMEM;
543
544 max_input_len = max(le16_to_cpu(qsdev->dev_desc.rep_desc_len),
545 le16_to_cpu(qsdev->dev_desc.max_input_len));
546
547 qsdev->input_buf = devm_kzalloc(qsdev->dev, max_input_len, GFP_KERNEL);
548 if (!qsdev->input_buf)
549 return -ENOMEM;
550
551 max_report_len = max(le16_to_cpu(qsdev->dev_desc.max_output_len),
552 le16_to_cpu(qsdev->dev_desc.max_input_len));
553
554 qsdev->report_buf = devm_kzalloc(qsdev->dev, max_report_len, GFP_KERNEL);
555 if (!qsdev->report_buf)
556 return -ENOMEM;
557
558 return 0;
559 }
560
561 /*
562 * quickspi_probe: Quickspi driver probe function
563 *
564 * @pdev: point to pci device
565 * @id: point to pci_device_id structure
566 *
567 * This function initializes THC and HIDSPI device, the flow is:
568 * - do THC pci device initialization
569 * - query HIDSPI ACPI parameters
570 * - configure THC to HIDSPI mode
571 * - go through HIDSPI enumeration flow
572 * |- reset HIDSPI device
573 * |- read device descriptor
574 * - enable THC interrupt and DMA
575 * - read report descriptor
576 * - register HID device
577 * - enable runtime power management
578 *
579 * Return 0 if success or error code on failure.
580 */
quickspi_probe(struct pci_dev * pdev,const struct pci_device_id * id)581 static int quickspi_probe(struct pci_dev *pdev,
582 const struct pci_device_id *id)
583 {
584 struct quickspi_device *qsdev;
585 void __iomem *mem_addr;
586 int ret;
587
588 ret = pcim_enable_device(pdev);
589 if (ret) {
590 dev_err(&pdev->dev, "Failed to enable PCI device, ret = %d.\n", ret);
591 return ret;
592 }
593
594 pci_set_master(pdev);
595
596 mem_addr = pcim_iomap_region(pdev, 0, KBUILD_MODNAME);
597 ret = PTR_ERR_OR_ZERO(mem_addr);
598 if (ret) {
599 dev_err(&pdev->dev, "Failed to get PCI regions, ret = %d.\n", ret);
600 goto disable_pci_device;
601 }
602
603 ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
604 if (ret) {
605 ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
606 if (ret) {
607 dev_err(&pdev->dev, "No usable DMA configuration %d\n", ret);
608 goto disable_pci_device;
609 }
610 }
611
612 ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
613 if (ret < 0) {
614 dev_err(&pdev->dev,
615 "Failed to allocate IRQ vectors. ret = %d\n", ret);
616 goto disable_pci_device;
617 }
618
619 pdev->irq = pci_irq_vector(pdev, 0);
620
621 qsdev = quickspi_dev_init(pdev, mem_addr, id);
622 if (IS_ERR(qsdev)) {
623 dev_err(&pdev->dev, "QuickSPI device init failed\n");
624 ret = PTR_ERR(qsdev);
625 goto disable_pci_device;
626 }
627
628 pci_set_drvdata(pdev, qsdev);
629
630 ret = devm_request_threaded_irq(&pdev->dev, pdev->irq,
631 quickspi_irq_quick_handler,
632 quickspi_irq_thread_handler,
633 IRQF_ONESHOT, KBUILD_MODNAME,
634 qsdev);
635 if (ret) {
636 dev_err(&pdev->dev,
637 "Failed to request threaded IRQ, irq = %d.\n", pdev->irq);
638 goto dev_deinit;
639 }
640
641 ret = reset_tic(qsdev);
642 if (ret) {
643 dev_err(&pdev->dev, "Reset Touch Device failed, ret = %d\n", ret);
644 goto dev_deinit;
645 }
646
647 ret = quickspi_alloc_report_buf(qsdev);
648 if (ret) {
649 dev_err(&pdev->dev, "Alloc report buffers failed, ret= %d\n", ret);
650 goto dev_deinit;
651 }
652
653 ret = quickspi_dma_init(qsdev);
654 if (ret) {
655 dev_err(&pdev->dev, "Setup THC DMA failed, ret= %d\n", ret);
656 goto dev_deinit;
657 }
658
659 ret = quickspi_get_report_descriptor(qsdev);
660 if (ret) {
661 dev_err(&pdev->dev, "Get report descriptor failed, ret = %d\n", ret);
662 goto dma_deinit;
663 }
664
665 ret = quickspi_hid_probe(qsdev);
666 if (ret) {
667 dev_err(&pdev->dev, "Failed to register HID device, ret = %d\n", ret);
668 goto dma_deinit;
669 }
670
671 qsdev->state = QUICKSPI_ENABLED;
672
673 /* Enable runtime power management */
674 pm_runtime_use_autosuspend(qsdev->dev);
675 pm_runtime_set_autosuspend_delay(qsdev->dev, DEFAULT_AUTO_SUSPEND_DELAY_MS);
676 pm_runtime_put_noidle(qsdev->dev);
677 pm_runtime_put_autosuspend(qsdev->dev);
678
679 dev_dbg(&pdev->dev, "QuickSPI probe success\n");
680
681 return 0;
682
683 dma_deinit:
684 quickspi_dma_deinit(qsdev);
685 dev_deinit:
686 quickspi_dev_deinit(qsdev);
687 disable_pci_device:
688 pci_clear_master(pdev);
689
690 return ret;
691 }
692
693 /**
694 * quickspi_remove - Device Removal Routine
695 *
696 * @pdev: PCI device structure
697 *
698 * This is called by the PCI subsystem to alert the driver
699 * that it should release a PCI device.
700 */
quickspi_remove(struct pci_dev * pdev)701 static void quickspi_remove(struct pci_dev *pdev)
702 {
703 struct quickspi_device *qsdev;
704
705 qsdev = pci_get_drvdata(pdev);
706 if (!qsdev)
707 return;
708
709 quickspi_hid_remove(qsdev);
710 quickspi_dma_deinit(qsdev);
711
712 pm_runtime_get_noresume(qsdev->dev);
713
714 quickspi_dev_deinit(qsdev);
715
716 pci_clear_master(pdev);
717 }
718
719 /**
720 * quickspi_shutdown - Device Shutdown Routine
721 *
722 * @pdev: PCI device structure
723 *
724 * This is called from the reboot notifier
725 * it's a simplified version of remove so we go down
726 * faster.
727 */
quickspi_shutdown(struct pci_dev * pdev)728 static void quickspi_shutdown(struct pci_dev *pdev)
729 {
730 struct quickspi_device *qsdev;
731
732 qsdev = pci_get_drvdata(pdev);
733 if (!qsdev)
734 return;
735
736 /* Must stop DMA before reboot to avoid DMA entering into unknown state */
737 quickspi_dma_deinit(qsdev);
738
739 quickspi_dev_deinit(qsdev);
740 }
741
quickspi_suspend(struct device * device)742 static int quickspi_suspend(struct device *device)
743 {
744 struct pci_dev *pdev = to_pci_dev(device);
745 struct quickspi_device *qsdev;
746 int ret;
747
748 qsdev = pci_get_drvdata(pdev);
749 if (!qsdev)
750 return -ENODEV;
751
752 ret = quickspi_set_power(qsdev, HIDSPI_SLEEP);
753 if (ret)
754 return ret;
755
756 ret = thc_interrupt_quiesce(qsdev->thc_hw, true);
757 if (ret)
758 return ret;
759
760 thc_interrupt_enable(qsdev->thc_hw, false);
761
762 thc_dma_unconfigure(qsdev->thc_hw);
763
764 return 0;
765 }
766
quickspi_resume(struct device * device)767 static int quickspi_resume(struct device *device)
768 {
769 struct pci_dev *pdev = to_pci_dev(device);
770 struct quickspi_device *qsdev;
771 int ret;
772
773 qsdev = pci_get_drvdata(pdev);
774 if (!qsdev)
775 return -ENODEV;
776
777 ret = thc_port_select(qsdev->thc_hw, THC_PORT_TYPE_SPI);
778 if (ret)
779 return ret;
780
781 thc_interrupt_config(qsdev->thc_hw);
782
783 thc_interrupt_enable(qsdev->thc_hw, true);
784
785 ret = thc_dma_configure(qsdev->thc_hw);
786 if (ret)
787 return ret;
788
789 ret = thc_interrupt_quiesce(qsdev->thc_hw, false);
790 if (ret)
791 return ret;
792
793 ret = quickspi_set_power(qsdev, HIDSPI_ON);
794 if (ret)
795 return ret;
796
797 return 0;
798 }
799
quickspi_freeze(struct device * device)800 static int quickspi_freeze(struct device *device)
801 {
802 struct pci_dev *pdev = to_pci_dev(device);
803 struct quickspi_device *qsdev;
804 int ret;
805
806 qsdev = pci_get_drvdata(pdev);
807 if (!qsdev)
808 return -ENODEV;
809
810 ret = thc_interrupt_quiesce(qsdev->thc_hw, true);
811 if (ret)
812 return ret;
813
814 thc_interrupt_enable(qsdev->thc_hw, false);
815
816 thc_dma_unconfigure(qsdev->thc_hw);
817
818 return 0;
819 }
820
quickspi_thaw(struct device * device)821 static int quickspi_thaw(struct device *device)
822 {
823 struct pci_dev *pdev = to_pci_dev(device);
824 struct quickspi_device *qsdev;
825 int ret;
826
827 qsdev = pci_get_drvdata(pdev);
828 if (!qsdev)
829 return -ENODEV;
830
831 ret = thc_dma_configure(qsdev->thc_hw);
832 if (ret)
833 return ret;
834
835 thc_interrupt_enable(qsdev->thc_hw, true);
836
837 ret = thc_interrupt_quiesce(qsdev->thc_hw, false);
838 if (ret)
839 return ret;
840
841 return 0;
842 }
843
quickspi_poweroff(struct device * device)844 static int quickspi_poweroff(struct device *device)
845 {
846 struct pci_dev *pdev = to_pci_dev(device);
847 struct quickspi_device *qsdev;
848 int ret;
849
850 qsdev = pci_get_drvdata(pdev);
851 if (!qsdev)
852 return -ENODEV;
853
854 ret = thc_interrupt_quiesce(qsdev->thc_hw, true);
855 if (ret)
856 return ret;
857
858 thc_interrupt_enable(qsdev->thc_hw, false);
859
860 thc_ltr_unconfig(qsdev->thc_hw);
861
862 quickspi_dma_deinit(qsdev);
863
864 return 0;
865 }
866
quickspi_restore(struct device * device)867 static int quickspi_restore(struct device *device)
868 {
869 struct pci_dev *pdev = to_pci_dev(device);
870 struct quickspi_device *qsdev;
871 int ret;
872
873 qsdev = pci_get_drvdata(pdev);
874 if (!qsdev)
875 return -ENODEV;
876
877 ret = thc_interrupt_quiesce(qsdev->thc_hw, true);
878 if (ret)
879 return ret;
880
881 /* Reconfig THC HW when back from hibernate */
882 ret = thc_port_select(qsdev->thc_hw, THC_PORT_TYPE_SPI);
883 if (ret)
884 return ret;
885
886 thc_spi_input_output_address_config(qsdev->thc_hw,
887 qsdev->input_report_hdr_addr,
888 qsdev->input_report_bdy_addr,
889 qsdev->output_report_addr);
890
891 ret = thc_spi_read_config(qsdev->thc_hw, qsdev->spi_freq_val,
892 qsdev->spi_read_io_mode,
893 qsdev->spi_read_opcode,
894 qsdev->spi_packet_size);
895 if (ret)
896 return ret;
897
898 ret = thc_spi_write_config(qsdev->thc_hw, qsdev->spi_freq_val,
899 qsdev->spi_write_io_mode,
900 qsdev->spi_write_opcode,
901 qsdev->spi_packet_size,
902 qsdev->performance_limit);
903 if (ret)
904 return ret;
905
906 thc_interrupt_config(qsdev->thc_hw);
907
908 thc_interrupt_enable(qsdev->thc_hw, true);
909
910 /* TIC may lose power, needs go through reset flow */
911 ret = reset_tic(qsdev);
912 if (ret)
913 return ret;
914
915 ret = thc_dma_configure(qsdev->thc_hw);
916 if (ret)
917 return ret;
918
919 thc_ltr_config(qsdev->thc_hw,
920 qsdev->active_ltr_val,
921 qsdev->low_power_ltr_val);
922
923 thc_change_ltr_mode(qsdev->thc_hw, THC_LTR_MODE_ACTIVE);
924
925 qsdev->state = QUICKSPI_ENABLED;
926
927 return 0;
928 }
929
quickspi_runtime_suspend(struct device * device)930 static int quickspi_runtime_suspend(struct device *device)
931 {
932 struct pci_dev *pdev = to_pci_dev(device);
933 struct quickspi_device *qsdev;
934
935 qsdev = pci_get_drvdata(pdev);
936 if (!qsdev)
937 return -ENODEV;
938
939 thc_change_ltr_mode(qsdev->thc_hw, THC_LTR_MODE_LP);
940
941 pci_save_state(pdev);
942
943 return 0;
944 }
945
quickspi_runtime_resume(struct device * device)946 static int quickspi_runtime_resume(struct device *device)
947 {
948 struct pci_dev *pdev = to_pci_dev(device);
949 struct quickspi_device *qsdev;
950
951 qsdev = pci_get_drvdata(pdev);
952 if (!qsdev)
953 return -ENODEV;
954
955 thc_change_ltr_mode(qsdev->thc_hw, THC_LTR_MODE_ACTIVE);
956
957 return 0;
958 }
959
960 static const struct dev_pm_ops quickspi_pm_ops = {
961 .suspend = quickspi_suspend,
962 .resume = quickspi_resume,
963 .freeze = quickspi_freeze,
964 .thaw = quickspi_thaw,
965 .poweroff = quickspi_poweroff,
966 .restore = quickspi_restore,
967 .runtime_suspend = quickspi_runtime_suspend,
968 .runtime_resume = quickspi_runtime_resume,
969 .runtime_idle = NULL,
970 };
971
972 static const struct pci_device_id quickspi_pci_tbl[] = {
973 {PCI_DEVICE_DATA(INTEL, THC_MTL_DEVICE_ID_SPI_PORT1, &mtl), },
974 {PCI_DEVICE_DATA(INTEL, THC_MTL_DEVICE_ID_SPI_PORT2, &mtl), },
975 {PCI_DEVICE_DATA(INTEL, THC_LNL_DEVICE_ID_SPI_PORT1, &lnl), },
976 {PCI_DEVICE_DATA(INTEL, THC_LNL_DEVICE_ID_SPI_PORT2, &lnl), },
977 {PCI_DEVICE_DATA(INTEL, THC_PTL_H_DEVICE_ID_SPI_PORT1, &ptl), },
978 {PCI_DEVICE_DATA(INTEL, THC_PTL_H_DEVICE_ID_SPI_PORT2, &ptl), },
979 {PCI_DEVICE_DATA(INTEL, THC_PTL_U_DEVICE_ID_SPI_PORT1, &ptl), },
980 {PCI_DEVICE_DATA(INTEL, THC_PTL_U_DEVICE_ID_SPI_PORT2, &ptl), },
981 {PCI_DEVICE_DATA(INTEL, THC_WCL_DEVICE_ID_SPI_PORT1, &ptl), },
982 {PCI_DEVICE_DATA(INTEL, THC_WCL_DEVICE_ID_SPI_PORT2, &ptl), },
983 {PCI_DEVICE_DATA(INTEL, THC_ARL_DEVICE_ID_SPI_PORT1, &arl), },
984 {PCI_DEVICE_DATA(INTEL, THC_ARL_DEVICE_ID_SPI_PORT2, &arl), },
985 {}
986 };
987 MODULE_DEVICE_TABLE(pci, quickspi_pci_tbl);
988
989 static struct pci_driver quickspi_driver = {
990 .name = KBUILD_MODNAME,
991 .id_table = quickspi_pci_tbl,
992 .probe = quickspi_probe,
993 .remove = quickspi_remove,
994 .shutdown = quickspi_shutdown,
995 .driver.pm = &quickspi_pm_ops,
996 .driver.probe_type = PROBE_PREFER_ASYNCHRONOUS,
997 };
998
999 module_pci_driver(quickspi_driver);
1000
1001 MODULE_AUTHOR("Xinpeng Sun <xinpeng.sun@intel.com>");
1002 MODULE_AUTHOR("Even Xu <even.xu@intel.com>");
1003
1004 MODULE_DESCRIPTION("Intel(R) QuickSPI Driver");
1005 MODULE_LICENSE("GPL");
1006 MODULE_IMPORT_NS("INTEL_THC");
1007