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 */
thc_acpi_get_property(struct acpi_device * adev,const guid_t * guid,u64 rev,u64 func,acpi_object_type type,void * prop_buf)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 */
quickspi_get_acpi_resources(struct quickspi_device * qsdev)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 */
quickspi_irq_quick_handler(int irq,void * dev_id)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 */
try_recover(struct quickspi_device * qsdev)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 */
quickspi_irq_thread_handler(int irq,void * dev_id)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 */
quickspi_dev_init(struct pci_dev * pdev,void __iomem * mem_addr,const struct pci_device_id * id)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 */
quickspi_dev_deinit(struct quickspi_device * qsdev)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 */
quickspi_dma_init(struct quickspi_device * qsdev)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 */
quickspi_dma_deinit(struct quickspi_device * qsdev)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 */
quickspi_alloc_report_buf(struct quickspi_device * qsdev)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 */
quickspi_probe(struct pci_dev * pdev,const struct pci_device_id * id)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 */
quickspi_remove(struct pci_dev * pdev)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 */
quickspi_shutdown(struct pci_dev * pdev)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
quickspi_suspend(struct device * device)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
quickspi_resume(struct device * device)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
quickspi_freeze(struct device * device)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
quickspi_thaw(struct device * device)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
quickspi_poweroff(struct device * device)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
quickspi_restore(struct device * device)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
quickspi_runtime_suspend(struct device * device)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
quickspi_runtime_resume(struct device * device)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