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_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 */
quickspi_dev_init(struct pci_dev * pdev,void __iomem * mem_addr,const struct pci_device_id * id)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 */
quickspi_dev_deinit(struct quickspi_device * qsdev)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 */
quickspi_dma_init(struct quickspi_device * qsdev)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 */
quickspi_dma_deinit(struct quickspi_device * qsdev)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 */
quickspi_alloc_report_buf(struct quickspi_device * qsdev)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 */
quickspi_probe(struct pci_dev * pdev,const struct pci_device_id * id)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 */
quickspi_remove(struct pci_dev * pdev)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 */
quickspi_shutdown(struct pci_dev * pdev)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
quickspi_suspend(struct device * device)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
quickspi_resume(struct device * device)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
quickspi_freeze(struct device * device)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
quickspi_thaw(struct device * device)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
quickspi_poweroff(struct device * device)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
quickspi_restore(struct device * device)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
quickspi_runtime_suspend(struct device * device)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
quickspi_runtime_resume(struct device * device)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