1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2023, Intel Corporation.
4 * Intel Visual Sensing Controller Transport Layer Linux driver
7 #include <linux/acpi.h>
8 #include <linux/cleanup.h>
9 #include <linux/crc32.h>
10 #include <linux/delay.h>
11 #include <linux/device.h>
12 #include <linux/interrupt.h>
13 #include <linux/iopoll.h>
14 #include <linux/irq.h>
15 #include <linux/irqreturn.h>
16 #include <linux/module.h>
17 #include <linux/mutex.h>
18 #include <linux/platform_device.h>
19 #include <linux/spi/spi.h>
20 #include <linux/types.h>
24 #define VSC_TP_RESET_PIN_TOGGLE_INTERVAL_MS 20
25 #define VSC_TP_ROM_BOOTUP_DELAY_MS 10
26 #define VSC_TP_ROM_XFER_POLL_TIMEOUT_US (500 * USEC_PER_MSEC)
27 #define VSC_TP_ROM_XFER_POLL_DELAY_US (20 * USEC_PER_MSEC)
28 #define VSC_TP_WAIT_FW_POLL_TIMEOUT (2 * HZ)
29 #define VSC_TP_WAIT_FW_POLL_DELAY_US (20 * USEC_PER_MSEC)
30 #define VSC_TP_MAX_XFER_COUNT 5
32 #define VSC_TP_PACKET_SYNC 0x31
33 #define VSC_TP_CRC_SIZE sizeof(u32)
34 #define VSC_TP_MAX_MSG_SIZE 2048
35 /* SPI xfer timeout size */
36 #define VSC_TP_XFER_TIMEOUT_BYTES 700
37 #define VSC_TP_PACKET_PADDING_SIZE 1
38 #define VSC_TP_PACKET_SIZE(pkt) \
39 (sizeof(struct vsc_tp_packet) + le16_to_cpu((pkt)->len) + VSC_TP_CRC_SIZE)
40 #define VSC_TP_MAX_PACKET_SIZE \
41 (sizeof(struct vsc_tp_packet) + VSC_TP_MAX_MSG_SIZE + VSC_TP_CRC_SIZE)
42 #define VSC_TP_MAX_XFER_SIZE \
43 (VSC_TP_MAX_PACKET_SIZE + VSC_TP_XFER_TIMEOUT_BYTES)
44 #define VSC_TP_NEXT_XFER_LEN(len, offset) \
45 (len + sizeof(struct vsc_tp_packet) + VSC_TP_CRC_SIZE - offset + VSC_TP_PACKET_PADDING_SIZE)
47 struct vsc_tp_packet {
52 __u8 buf[] __counted_by(len);
56 /* do the actual data transfer */
57 struct spi_device *spi;
59 /* bind with mei framework */
60 struct platform_device *pdev;
62 struct gpio_desc *wakeuphost;
63 struct gpio_desc *resetfw;
64 struct gpio_desc *wakeupfw;
66 /* command sequence number */
74 wait_queue_head_t xfer_wait;
76 vsc_tp_event_cb_t event_notify;
77 void *event_notify_context;
79 /* used to protect command download */
84 static const struct acpi_gpio_params wakeuphost_gpio = { 0, 0, false };
85 static const struct acpi_gpio_params wakeuphostint_gpio = { 1, 0, false };
86 static const struct acpi_gpio_params resetfw_gpio = { 2, 0, false };
87 static const struct acpi_gpio_params wakeupfw = { 3, 0, false };
89 static const struct acpi_gpio_mapping vsc_tp_acpi_gpios[] = {
90 { "wakeuphost-gpios", &wakeuphost_gpio, 1 },
91 { "wakeuphostint-gpios", &wakeuphostint_gpio, 1 },
92 { "resetfw-gpios", &resetfw_gpio, 1 },
93 { "wakeupfw-gpios", &wakeupfw, 1 },
97 /* wakeup firmware and wait for response */
98 static int vsc_tp_wakeup_request(struct vsc_tp *tp)
102 gpiod_set_value_cansleep(tp->wakeupfw, 0);
104 ret = wait_event_timeout(tp->xfer_wait,
105 atomic_read(&tp->assert_cnt),
106 VSC_TP_WAIT_FW_POLL_TIMEOUT);
110 return read_poll_timeout(gpiod_get_value_cansleep, ret, ret,
111 VSC_TP_WAIT_FW_POLL_DELAY_US,
112 VSC_TP_WAIT_FW_POLL_TIMEOUT, false,
116 static void vsc_tp_wakeup_release(struct vsc_tp *tp)
118 atomic_dec_if_positive(&tp->assert_cnt);
120 gpiod_set_value_cansleep(tp->wakeupfw, 1);
123 static int vsc_tp_dev_xfer(struct vsc_tp *tp, void *obuf, void *ibuf, size_t len)
125 struct spi_message msg = { 0 };
126 struct spi_transfer xfer = {
132 spi_message_init_with_transfers(&msg, &xfer, 1);
134 return spi_sync_locked(tp->spi, &msg);
137 static int vsc_tp_xfer_helper(struct vsc_tp *tp, struct vsc_tp_packet *pkt,
138 void *ibuf, u16 ilen)
140 int ret, offset = 0, cpy_len, src_len, dst_len = sizeof(struct vsc_tp_packet);
141 int next_xfer_len = VSC_TP_PACKET_SIZE(pkt) + VSC_TP_XFER_TIMEOUT_BYTES;
142 u8 *src, *crc_src, *rx_buf = tp->rx_buf;
143 int count_down = VSC_TP_MAX_XFER_COUNT;
144 u32 recv_crc = 0, crc = ~0;
145 struct vsc_tp_packet ack;
146 u8 *dst = (u8 *)&ack;
150 ret = vsc_tp_dev_xfer(tp, pkt, rx_buf, next_xfer_len);
153 memset(pkt, 0, VSC_TP_MAX_XFER_SIZE);
157 src_len = next_xfer_len;
159 src = memchr(rx_buf, VSC_TP_PACKET_SYNC, next_xfer_len);
163 src_len = next_xfer_len - (src - rx_buf);
166 /* traverse received data */
167 while (src_len > 0) {
168 cpy_len = min(src_len, dst_len);
169 memcpy(dst, src, cpy_len);
176 if (offset < sizeof(ack)) {
178 crc = crc32(crc, crc_src, cpy_len);
183 if (le16_to_cpu(ack.len)) {
185 dst_len = min(ilen, le16_to_cpu(ack.len));
187 dst = (u8 *)&recv_crc;
188 dst_len = sizeof(recv_crc);
190 } else if (offset < sizeof(ack) + le16_to_cpu(ack.len)) {
192 crc = crc32(crc, crc_src, cpy_len);
195 int remain = sizeof(ack) + le16_to_cpu(ack.len) - offset;
197 cpy_len = min(src_len, remain);
199 crc = crc32(crc, src, cpy_len);
203 dst = (u8 *)&recv_crc;
204 dst_len = sizeof(recv_crc);
208 next_xfer_len = VSC_TP_NEXT_XFER_LEN(le16_to_cpu(ack.len), offset);
209 } else if (offset < sizeof(ack) + le16_to_cpu(ack.len) + VSC_TP_CRC_SIZE) {
213 /* terminate the traverse */
217 next_xfer_len = VSC_TP_NEXT_XFER_LEN(le16_to_cpu(ack.len), offset);
220 } while (next_xfer_len > 0 && --count_down);
222 if (next_xfer_len > 0)
225 if (~recv_crc != crc || le32_to_cpu(ack.seq) != tp->seq) {
226 dev_err(&tp->spi->dev, "recv crc or seq error\n");
230 if (ack.cmd == VSC_TP_CMD_ACK || ack.cmd == VSC_TP_CMD_NACK ||
231 ack.cmd == VSC_TP_CMD_BUSY) {
232 dev_err(&tp->spi->dev, "recv cmd ack error\n");
236 return min(le16_to_cpu(ack.len), ilen);
240 * vsc_tp_xfer - transfer data to firmware
241 * @tp: vsc_tp device handle
242 * @cmd: the command to be sent to the device
243 * @obuf: the tx buffer to be sent to the device
244 * @olen: the length of tx buffer
245 * @ibuf: the rx buffer to receive from the device
246 * @ilen: the length of rx buffer
247 * Return: the length of received data in case of success,
248 * otherwise negative value
250 int vsc_tp_xfer(struct vsc_tp *tp, u8 cmd, const void *obuf, size_t olen,
251 void *ibuf, size_t ilen)
253 struct vsc_tp_packet *pkt = tp->tx_buf;
257 if (!obuf || !ibuf || olen > VSC_TP_MAX_MSG_SIZE)
260 guard(mutex)(&tp->mutex);
262 pkt->sync = VSC_TP_PACKET_SYNC;
264 pkt->len = cpu_to_le16(olen);
265 pkt->seq = cpu_to_le32(++tp->seq);
266 memcpy(pkt->buf, obuf, olen);
268 crc = ~crc32(~0, (u8 *)pkt, sizeof(pkt) + olen);
269 memcpy(pkt->buf + olen, &crc, sizeof(crc));
271 ret = vsc_tp_wakeup_request(tp);
273 dev_err(&tp->spi->dev, "wakeup firmware failed ret: %d\n", ret);
275 ret = vsc_tp_xfer_helper(tp, pkt, ibuf, ilen);
277 vsc_tp_wakeup_release(tp);
281 EXPORT_SYMBOL_NS_GPL(vsc_tp_xfer, VSC_TP);
284 * vsc_tp_rom_xfer - transfer data to rom code
285 * @tp: vsc_tp device handle
286 * @obuf: the data buffer to be sent to the device
287 * @ibuf: the buffer to receive data from the device
288 * @len: the length of tx buffer and rx buffer
289 * Return: 0 in case of success, negative value in case of error
291 int vsc_tp_rom_xfer(struct vsc_tp *tp, const void *obuf, void *ibuf, size_t len)
293 size_t words = len / sizeof(__be32);
296 if (len % sizeof(__be32) || len > VSC_TP_MAX_MSG_SIZE)
299 guard(mutex)(&tp->mutex);
301 /* rom xfer is big endian */
302 cpu_to_be32_array(tp->tx_buf, obuf, words);
304 ret = read_poll_timeout(gpiod_get_value_cansleep, ret,
305 !ret, VSC_TP_ROM_XFER_POLL_DELAY_US,
306 VSC_TP_ROM_XFER_POLL_TIMEOUT_US, false,
309 dev_err(&tp->spi->dev, "wait rom failed ret: %d\n", ret);
313 ret = vsc_tp_dev_xfer(tp, tp->tx_buf, tp->rx_buf, len);
318 cpu_to_be32_array(ibuf, tp->rx_buf, words);
324 * vsc_tp_reset - reset vsc transport layer
325 * @tp: vsc_tp device handle
327 void vsc_tp_reset(struct vsc_tp *tp)
329 disable_irq(tp->spi->irq);
331 /* toggle reset pin */
332 gpiod_set_value_cansleep(tp->resetfw, 0);
333 msleep(VSC_TP_RESET_PIN_TOGGLE_INTERVAL_MS);
334 gpiod_set_value_cansleep(tp->resetfw, 1);
337 msleep(VSC_TP_ROM_BOOTUP_DELAY_MS);
340 * Set default host wakeup pin to non-active
341 * to avoid unexpected host irq interrupt.
343 gpiod_set_value_cansleep(tp->wakeupfw, 1);
345 atomic_set(&tp->assert_cnt, 0);
347 enable_irq(tp->spi->irq);
349 EXPORT_SYMBOL_NS_GPL(vsc_tp_reset, VSC_TP);
352 * vsc_tp_need_read - check if device has data to sent
353 * @tp: vsc_tp device handle
354 * Return: true if device has data to sent, otherwise false
356 bool vsc_tp_need_read(struct vsc_tp *tp)
358 if (!atomic_read(&tp->assert_cnt))
360 if (!gpiod_get_value_cansleep(tp->wakeuphost))
362 if (!gpiod_get_value_cansleep(tp->wakeupfw))
367 EXPORT_SYMBOL_NS_GPL(vsc_tp_need_read, VSC_TP);
370 * vsc_tp_register_event_cb - register a callback function to receive event
371 * @tp: vsc_tp device handle
372 * @event_cb: callback function
373 * @context: execution context of event callback
374 * Return: 0 in case of success, negative value in case of error
376 int vsc_tp_register_event_cb(struct vsc_tp *tp, vsc_tp_event_cb_t event_cb,
379 tp->event_notify = event_cb;
380 tp->event_notify_context = context;
384 EXPORT_SYMBOL_NS_GPL(vsc_tp_register_event_cb, VSC_TP);
387 * vsc_tp_intr_synchronize - synchronize vsc_tp interrupt
388 * @tp: vsc_tp device handle
390 void vsc_tp_intr_synchronize(struct vsc_tp *tp)
392 synchronize_irq(tp->spi->irq);
394 EXPORT_SYMBOL_NS_GPL(vsc_tp_intr_synchronize, VSC_TP);
397 * vsc_tp_intr_enable - enable vsc_tp interrupt
398 * @tp: vsc_tp device handle
400 void vsc_tp_intr_enable(struct vsc_tp *tp)
402 enable_irq(tp->spi->irq);
404 EXPORT_SYMBOL_NS_GPL(vsc_tp_intr_enable, VSC_TP);
407 * vsc_tp_intr_disable - disable vsc_tp interrupt
408 * @tp: vsc_tp device handle
410 void vsc_tp_intr_disable(struct vsc_tp *tp)
412 disable_irq(tp->spi->irq);
414 EXPORT_SYMBOL_NS_GPL(vsc_tp_intr_disable, VSC_TP);
416 static irqreturn_t vsc_tp_isr(int irq, void *data)
418 struct vsc_tp *tp = data;
420 atomic_inc(&tp->assert_cnt);
422 return IRQ_WAKE_THREAD;
425 static irqreturn_t vsc_tp_thread_isr(int irq, void *data)
427 struct vsc_tp *tp = data;
429 wake_up(&tp->xfer_wait);
431 if (tp->event_notify)
432 tp->event_notify(tp->event_notify_context);
437 static int vsc_tp_match_any(struct acpi_device *adev, void *data)
439 struct acpi_device **__adev = data;
446 static int vsc_tp_probe(struct spi_device *spi)
449 struct platform_device_info pinfo = {
452 .size_data = sizeof(tp),
453 .id = PLATFORM_DEVID_NONE,
455 struct device *dev = &spi->dev;
456 struct platform_device *pdev;
457 struct acpi_device *adev;
460 tp = devm_kzalloc(dev, sizeof(*tp), GFP_KERNEL);
464 tp->tx_buf = devm_kzalloc(dev, VSC_TP_MAX_XFER_SIZE, GFP_KERNEL);
468 tp->rx_buf = devm_kzalloc(dev, VSC_TP_MAX_XFER_SIZE, GFP_KERNEL);
472 ret = devm_acpi_dev_add_driver_gpios(dev, vsc_tp_acpi_gpios);
476 tp->wakeuphost = devm_gpiod_get(dev, "wakeuphost", GPIOD_IN);
477 if (IS_ERR(tp->wakeuphost))
478 return PTR_ERR(tp->wakeuphost);
480 tp->resetfw = devm_gpiod_get(dev, "resetfw", GPIOD_OUT_HIGH);
481 if (IS_ERR(tp->resetfw))
482 return PTR_ERR(tp->resetfw);
484 tp->wakeupfw = devm_gpiod_get(dev, "wakeupfw", GPIOD_OUT_HIGH);
485 if (IS_ERR(tp->wakeupfw))
486 return PTR_ERR(tp->wakeupfw);
488 atomic_set(&tp->assert_cnt, 0);
489 init_waitqueue_head(&tp->xfer_wait);
492 irq_set_status_flags(spi->irq, IRQ_DISABLE_UNLAZY);
493 ret = devm_request_threaded_irq(dev, spi->irq, vsc_tp_isr,
495 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
500 mutex_init(&tp->mutex);
502 /* only one child acpi device */
503 ret = acpi_dev_for_each_child(ACPI_COMPANION(dev),
504 vsc_tp_match_any, &adev);
507 goto err_destroy_lock;
510 pinfo.fwnode = acpi_fwnode_handle(adev);
511 pdev = platform_device_register_full(&pinfo);
514 goto err_destroy_lock;
518 spi_set_drvdata(spi, tp);
523 mutex_destroy(&tp->mutex);
528 static void vsc_tp_remove(struct spi_device *spi)
530 struct vsc_tp *tp = spi_get_drvdata(spi);
532 platform_device_unregister(tp->pdev);
534 mutex_destroy(&tp->mutex);
537 static const struct acpi_device_id vsc_tp_acpi_ids[] = {
538 { "INTC1009" }, /* Raptor Lake */
539 { "INTC1058" }, /* Tiger Lake */
540 { "INTC1094" }, /* Alder Lake */
541 { "INTC10D0" }, /* Meteor Lake */
544 MODULE_DEVICE_TABLE(acpi, vsc_tp_acpi_ids);
546 static struct spi_driver vsc_tp_driver = {
547 .probe = vsc_tp_probe,
548 .remove = vsc_tp_remove,
551 .acpi_match_table = vsc_tp_acpi_ids,
554 module_spi_driver(vsc_tp_driver);
556 MODULE_AUTHOR("Wentong Wu <wentong.wu@intel.com>");
557 MODULE_AUTHOR("Zhifeng Wang <zhifeng.wang@intel.com>");
558 MODULE_DESCRIPTION("Intel Visual Sensing Controller Transport Layer");
559 MODULE_LICENSE("GPL");