1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2023, Intel Corporation. 4 * Intel Visual Sensing Controller Transport Layer Linux driver 5 */ 6 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> 21 22 #include "vsc-tp.h" 23 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_ASSERTED_TIMEOUT (2 * HZ) 29 #define VSC_TP_MAX_XFER_COUNT 5 30 31 #define VSC_TP_PACKET_SYNC 0x31 32 #define VSC_TP_CRC_SIZE sizeof(u32) 33 #define VSC_TP_MAX_MSG_SIZE 2048 34 /* SPI xfer timeout size */ 35 #define VSC_TP_XFER_TIMEOUT_BYTES 700 36 #define VSC_TP_PACKET_PADDING_SIZE 1 37 #define VSC_TP_PACKET_SIZE(pkt) \ 38 (sizeof(struct vsc_tp_packet) + le16_to_cpu((pkt)->len) + VSC_TP_CRC_SIZE) 39 #define VSC_TP_MAX_PACKET_SIZE \ 40 (sizeof(struct vsc_tp_packet) + VSC_TP_MAX_MSG_SIZE + VSC_TP_CRC_SIZE) 41 #define VSC_TP_MAX_XFER_SIZE \ 42 (VSC_TP_MAX_PACKET_SIZE + VSC_TP_XFER_TIMEOUT_BYTES) 43 #define VSC_TP_NEXT_XFER_LEN(len, offset) \ 44 (len + sizeof(struct vsc_tp_packet) + VSC_TP_CRC_SIZE - offset + VSC_TP_PACKET_PADDING_SIZE) 45 46 struct vsc_tp_packet { 47 __u8 sync; 48 __u8 cmd; 49 __le16 len; 50 __le32 seq; 51 __u8 buf[] __counted_by(len); 52 }; 53 54 struct vsc_tp { 55 /* do the actual data transfer */ 56 struct spi_device *spi; 57 58 /* bind with mei framework */ 59 struct platform_device *pdev; 60 61 struct gpio_desc *wakeuphost; 62 struct gpio_desc *resetfw; 63 struct gpio_desc *wakeupfw; 64 65 /* command sequence number */ 66 u32 seq; 67 68 /* command buffer */ 69 void *tx_buf; 70 void *rx_buf; 71 72 atomic_t assert_cnt; 73 wait_queue_head_t xfer_wait; 74 75 vsc_tp_event_cb_t event_notify; 76 void *event_notify_context; 77 78 /* used to protect command download */ 79 struct mutex mutex; 80 }; 81 82 /* GPIO resources */ 83 static const struct acpi_gpio_params wakeuphost_gpio = { 0, 0, false }; 84 static const struct acpi_gpio_params wakeuphostint_gpio = { 1, 0, false }; 85 static const struct acpi_gpio_params resetfw_gpio = { 2, 0, false }; 86 static const struct acpi_gpio_params wakeupfw = { 3, 0, false }; 87 88 static const struct acpi_gpio_mapping vsc_tp_acpi_gpios[] = { 89 { "wakeuphost-gpios", &wakeuphost_gpio, 1 }, 90 { "wakeuphostint-gpios", &wakeuphostint_gpio, 1 }, 91 { "resetfw-gpios", &resetfw_gpio, 1 }, 92 { "wakeupfw-gpios", &wakeupfw, 1 }, 93 {} 94 }; 95 96 /* wakeup firmware and wait for response */ 97 static int vsc_tp_wakeup_request(struct vsc_tp *tp) 98 { 99 int ret; 100 101 gpiod_set_value_cansleep(tp->wakeupfw, 0); 102 103 ret = wait_event_timeout(tp->xfer_wait, 104 atomic_read(&tp->assert_cnt) && 105 gpiod_get_value_cansleep(tp->wakeuphost), 106 VSC_TP_WAIT_FW_ASSERTED_TIMEOUT); 107 if (!ret) 108 return -ETIMEDOUT; 109 110 return 0; 111 } 112 113 static void vsc_tp_wakeup_release(struct vsc_tp *tp) 114 { 115 atomic_dec_if_positive(&tp->assert_cnt); 116 117 gpiod_set_value_cansleep(tp->wakeupfw, 1); 118 } 119 120 static int vsc_tp_dev_xfer(struct vsc_tp *tp, void *obuf, void *ibuf, size_t len) 121 { 122 struct spi_message msg = { 0 }; 123 struct spi_transfer xfer = { 124 .tx_buf = obuf, 125 .rx_buf = ibuf, 126 .len = len, 127 }; 128 129 spi_message_init_with_transfers(&msg, &xfer, 1); 130 131 return spi_sync_locked(tp->spi, &msg); 132 } 133 134 static int vsc_tp_xfer_helper(struct vsc_tp *tp, struct vsc_tp_packet *pkt, 135 void *ibuf, u16 ilen) 136 { 137 int ret, offset = 0, cpy_len, src_len, dst_len = sizeof(struct vsc_tp_packet); 138 int next_xfer_len = VSC_TP_PACKET_SIZE(pkt) + VSC_TP_XFER_TIMEOUT_BYTES; 139 u8 *src, *crc_src, *rx_buf = tp->rx_buf; 140 int count_down = VSC_TP_MAX_XFER_COUNT; 141 u32 recv_crc = 0, crc = ~0; 142 struct vsc_tp_packet ack; 143 u8 *dst = (u8 *)&ack; 144 bool synced = false; 145 146 do { 147 ret = vsc_tp_dev_xfer(tp, pkt, rx_buf, next_xfer_len); 148 if (ret) 149 return ret; 150 memset(pkt, 0, VSC_TP_MAX_XFER_SIZE); 151 152 if (synced) { 153 src = rx_buf; 154 src_len = next_xfer_len; 155 } else { 156 src = memchr(rx_buf, VSC_TP_PACKET_SYNC, next_xfer_len); 157 if (!src) 158 continue; 159 synced = true; 160 src_len = next_xfer_len - (src - rx_buf); 161 } 162 163 /* traverse received data */ 164 while (src_len > 0) { 165 cpy_len = min(src_len, dst_len); 166 memcpy(dst, src, cpy_len); 167 crc_src = src; 168 src += cpy_len; 169 src_len -= cpy_len; 170 dst += cpy_len; 171 dst_len -= cpy_len; 172 173 if (offset < sizeof(ack)) { 174 offset += cpy_len; 175 crc = crc32(crc, crc_src, cpy_len); 176 177 if (!src_len) 178 continue; 179 180 if (le16_to_cpu(ack.len)) { 181 dst = ibuf; 182 dst_len = min(ilen, le16_to_cpu(ack.len)); 183 } else { 184 dst = (u8 *)&recv_crc; 185 dst_len = sizeof(recv_crc); 186 } 187 } else if (offset < sizeof(ack) + le16_to_cpu(ack.len)) { 188 offset += cpy_len; 189 crc = crc32(crc, crc_src, cpy_len); 190 191 if (src_len) { 192 int remain = sizeof(ack) + le16_to_cpu(ack.len) - offset; 193 194 cpy_len = min(src_len, remain); 195 offset += cpy_len; 196 crc = crc32(crc, src, cpy_len); 197 src += cpy_len; 198 src_len -= cpy_len; 199 if (src_len) { 200 dst = (u8 *)&recv_crc; 201 dst_len = sizeof(recv_crc); 202 continue; 203 } 204 } 205 next_xfer_len = VSC_TP_NEXT_XFER_LEN(le16_to_cpu(ack.len), offset); 206 } else if (offset < sizeof(ack) + le16_to_cpu(ack.len) + VSC_TP_CRC_SIZE) { 207 offset += cpy_len; 208 209 if (src_len) { 210 /* terminate the traverse */ 211 next_xfer_len = 0; 212 break; 213 } 214 next_xfer_len = VSC_TP_NEXT_XFER_LEN(le16_to_cpu(ack.len), offset); 215 } 216 } 217 } while (next_xfer_len > 0 && --count_down); 218 219 if (next_xfer_len > 0) 220 return -EAGAIN; 221 222 if (~recv_crc != crc || le32_to_cpu(ack.seq) != tp->seq) { 223 dev_err(&tp->spi->dev, "recv crc or seq error\n"); 224 return -EINVAL; 225 } 226 227 if (ack.cmd == VSC_TP_CMD_ACK || ack.cmd == VSC_TP_CMD_NACK || 228 ack.cmd == VSC_TP_CMD_BUSY) { 229 dev_err(&tp->spi->dev, "recv cmd ack error\n"); 230 return -EAGAIN; 231 } 232 233 return min(le16_to_cpu(ack.len), ilen); 234 } 235 236 /** 237 * vsc_tp_xfer - transfer data to firmware 238 * @tp: vsc_tp device handle 239 * @cmd: the command to be sent to the device 240 * @obuf: the tx buffer to be sent to the device 241 * @olen: the length of tx buffer 242 * @ibuf: the rx buffer to receive from the device 243 * @ilen: the length of rx buffer 244 * Return: the length of received data in case of success, 245 * otherwise negative value 246 */ 247 int vsc_tp_xfer(struct vsc_tp *tp, u8 cmd, const void *obuf, size_t olen, 248 void *ibuf, size_t ilen) 249 { 250 struct vsc_tp_packet *pkt = tp->tx_buf; 251 u32 crc; 252 int ret; 253 254 if (!obuf || !ibuf || olen > VSC_TP_MAX_MSG_SIZE) 255 return -EINVAL; 256 257 guard(mutex)(&tp->mutex); 258 259 pkt->sync = VSC_TP_PACKET_SYNC; 260 pkt->cmd = cmd; 261 pkt->len = cpu_to_le16(olen); 262 pkt->seq = cpu_to_le32(++tp->seq); 263 memcpy(pkt->buf, obuf, olen); 264 265 crc = ~crc32(~0, (u8 *)pkt, sizeof(pkt) + olen); 266 memcpy(pkt->buf + olen, &crc, sizeof(crc)); 267 268 ret = vsc_tp_wakeup_request(tp); 269 if (unlikely(ret)) 270 dev_err(&tp->spi->dev, "wakeup firmware failed ret: %d\n", ret); 271 else 272 ret = vsc_tp_xfer_helper(tp, pkt, ibuf, ilen); 273 274 vsc_tp_wakeup_release(tp); 275 276 return ret; 277 } 278 EXPORT_SYMBOL_NS_GPL(vsc_tp_xfer, VSC_TP); 279 280 /** 281 * vsc_tp_rom_xfer - transfer data to rom code 282 * @tp: vsc_tp device handle 283 * @obuf: the data buffer to be sent to the device 284 * @ibuf: the buffer to receive data from the device 285 * @len: the length of tx buffer and rx buffer 286 * Return: 0 in case of success, negative value in case of error 287 */ 288 int vsc_tp_rom_xfer(struct vsc_tp *tp, const void *obuf, void *ibuf, size_t len) 289 { 290 size_t words = len / sizeof(__be32); 291 int ret; 292 293 if (len % sizeof(__be32) || len > VSC_TP_MAX_MSG_SIZE) 294 return -EINVAL; 295 296 guard(mutex)(&tp->mutex); 297 298 /* rom xfer is big endian */ 299 cpu_to_be32_array(tp->tx_buf, obuf, words); 300 301 ret = read_poll_timeout(gpiod_get_value_cansleep, ret, 302 !ret, VSC_TP_ROM_XFER_POLL_DELAY_US, 303 VSC_TP_ROM_XFER_POLL_TIMEOUT_US, false, 304 tp->wakeuphost); 305 if (ret) { 306 dev_err(&tp->spi->dev, "wait rom failed ret: %d\n", ret); 307 return ret; 308 } 309 310 ret = vsc_tp_dev_xfer(tp, tp->tx_buf, tp->rx_buf, len); 311 if (ret) 312 return ret; 313 314 if (ibuf) 315 cpu_to_be32_array(ibuf, tp->rx_buf, words); 316 317 return ret; 318 } 319 320 /** 321 * vsc_tp_reset - reset vsc transport layer 322 * @tp: vsc_tp device handle 323 */ 324 void vsc_tp_reset(struct vsc_tp *tp) 325 { 326 disable_irq(tp->spi->irq); 327 328 /* toggle reset pin */ 329 gpiod_set_value_cansleep(tp->resetfw, 0); 330 msleep(VSC_TP_RESET_PIN_TOGGLE_INTERVAL_MS); 331 gpiod_set_value_cansleep(tp->resetfw, 1); 332 333 /* wait for ROM */ 334 msleep(VSC_TP_ROM_BOOTUP_DELAY_MS); 335 336 /* 337 * Set default host wakeup pin to non-active 338 * to avoid unexpected host irq interrupt. 339 */ 340 gpiod_set_value_cansleep(tp->wakeupfw, 1); 341 342 atomic_set(&tp->assert_cnt, 0); 343 344 enable_irq(tp->spi->irq); 345 } 346 EXPORT_SYMBOL_NS_GPL(vsc_tp_reset, VSC_TP); 347 348 /** 349 * vsc_tp_need_read - check if device has data to sent 350 * @tp: vsc_tp device handle 351 * Return: true if device has data to sent, otherwise false 352 */ 353 bool vsc_tp_need_read(struct vsc_tp *tp) 354 { 355 if (!atomic_read(&tp->assert_cnt)) 356 return false; 357 if (!gpiod_get_value_cansleep(tp->wakeuphost)) 358 return false; 359 if (!gpiod_get_value_cansleep(tp->wakeupfw)) 360 return false; 361 362 return true; 363 } 364 EXPORT_SYMBOL_NS_GPL(vsc_tp_need_read, VSC_TP); 365 366 /** 367 * vsc_tp_register_event_cb - register a callback function to receive event 368 * @tp: vsc_tp device handle 369 * @event_cb: callback function 370 * @context: execution context of event callback 371 * Return: 0 in case of success, negative value in case of error 372 */ 373 int vsc_tp_register_event_cb(struct vsc_tp *tp, vsc_tp_event_cb_t event_cb, 374 void *context) 375 { 376 tp->event_notify = event_cb; 377 tp->event_notify_context = context; 378 379 return 0; 380 } 381 EXPORT_SYMBOL_NS_GPL(vsc_tp_register_event_cb, VSC_TP); 382 383 /** 384 * vsc_tp_intr_synchronize - synchronize vsc_tp interrupt 385 * @tp: vsc_tp device handle 386 */ 387 void vsc_tp_intr_synchronize(struct vsc_tp *tp) 388 { 389 synchronize_irq(tp->spi->irq); 390 } 391 EXPORT_SYMBOL_NS_GPL(vsc_tp_intr_synchronize, VSC_TP); 392 393 /** 394 * vsc_tp_intr_enable - enable vsc_tp interrupt 395 * @tp: vsc_tp device handle 396 */ 397 void vsc_tp_intr_enable(struct vsc_tp *tp) 398 { 399 enable_irq(tp->spi->irq); 400 } 401 EXPORT_SYMBOL_NS_GPL(vsc_tp_intr_enable, VSC_TP); 402 403 /** 404 * vsc_tp_intr_disable - disable vsc_tp interrupt 405 * @tp: vsc_tp device handle 406 */ 407 void vsc_tp_intr_disable(struct vsc_tp *tp) 408 { 409 disable_irq(tp->spi->irq); 410 } 411 EXPORT_SYMBOL_NS_GPL(vsc_tp_intr_disable, VSC_TP); 412 413 static irqreturn_t vsc_tp_isr(int irq, void *data) 414 { 415 struct vsc_tp *tp = data; 416 417 atomic_inc(&tp->assert_cnt); 418 419 wake_up(&tp->xfer_wait); 420 421 return IRQ_WAKE_THREAD; 422 } 423 424 static irqreturn_t vsc_tp_thread_isr(int irq, void *data) 425 { 426 struct vsc_tp *tp = data; 427 428 if (tp->event_notify) 429 tp->event_notify(tp->event_notify_context); 430 431 return IRQ_HANDLED; 432 } 433 434 static int vsc_tp_match_any(struct acpi_device *adev, void *data) 435 { 436 struct acpi_device **__adev = data; 437 438 *__adev = adev; 439 440 return 1; 441 } 442 443 static int vsc_tp_probe(struct spi_device *spi) 444 { 445 struct platform_device_info pinfo = { 0 }; 446 struct device *dev = &spi->dev; 447 struct platform_device *pdev; 448 struct acpi_device *adev; 449 struct vsc_tp *tp; 450 int ret; 451 452 tp = devm_kzalloc(dev, sizeof(*tp), GFP_KERNEL); 453 if (!tp) 454 return -ENOMEM; 455 456 tp->tx_buf = devm_kzalloc(dev, VSC_TP_MAX_XFER_SIZE, GFP_KERNEL); 457 if (!tp->tx_buf) 458 return -ENOMEM; 459 460 tp->rx_buf = devm_kzalloc(dev, VSC_TP_MAX_XFER_SIZE, GFP_KERNEL); 461 if (!tp->rx_buf) 462 return -ENOMEM; 463 464 ret = devm_acpi_dev_add_driver_gpios(dev, vsc_tp_acpi_gpios); 465 if (ret) 466 return ret; 467 468 tp->wakeuphost = devm_gpiod_get(dev, "wakeuphost", GPIOD_IN); 469 if (IS_ERR(tp->wakeuphost)) 470 return PTR_ERR(tp->wakeuphost); 471 472 tp->resetfw = devm_gpiod_get(dev, "resetfw", GPIOD_OUT_HIGH); 473 if (IS_ERR(tp->resetfw)) 474 return PTR_ERR(tp->resetfw); 475 476 tp->wakeupfw = devm_gpiod_get(dev, "wakeupfw", GPIOD_OUT_HIGH); 477 if (IS_ERR(tp->wakeupfw)) 478 return PTR_ERR(tp->wakeupfw); 479 480 atomic_set(&tp->assert_cnt, 0); 481 init_waitqueue_head(&tp->xfer_wait); 482 tp->spi = spi; 483 484 irq_set_status_flags(spi->irq, IRQ_DISABLE_UNLAZY); 485 ret = devm_request_threaded_irq(dev, spi->irq, vsc_tp_isr, 486 vsc_tp_thread_isr, 487 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 488 dev_name(dev), tp); 489 if (ret) 490 return ret; 491 492 mutex_init(&tp->mutex); 493 494 /* only one child acpi device */ 495 ret = acpi_dev_for_each_child(ACPI_COMPANION(dev), 496 vsc_tp_match_any, &adev); 497 if (!ret) { 498 ret = -ENODEV; 499 goto err_destroy_lock; 500 } 501 pinfo.fwnode = acpi_fwnode_handle(adev); 502 503 pinfo.name = "intel_vsc"; 504 pinfo.data = &tp; 505 pinfo.size_data = sizeof(tp); 506 pinfo.id = PLATFORM_DEVID_NONE; 507 508 pdev = platform_device_register_full(&pinfo); 509 if (IS_ERR(pdev)) { 510 ret = PTR_ERR(pdev); 511 goto err_destroy_lock; 512 } 513 514 tp->pdev = pdev; 515 spi_set_drvdata(spi, tp); 516 517 return 0; 518 519 err_destroy_lock: 520 mutex_destroy(&tp->mutex); 521 522 return ret; 523 } 524 525 static void vsc_tp_remove(struct spi_device *spi) 526 { 527 struct vsc_tp *tp = spi_get_drvdata(spi); 528 529 platform_device_unregister(tp->pdev); 530 531 mutex_destroy(&tp->mutex); 532 } 533 534 static const struct acpi_device_id vsc_tp_acpi_ids[] = { 535 { "INTC1009" }, /* Raptor Lake */ 536 { "INTC1058" }, /* Tiger Lake */ 537 { "INTC1094" }, /* Alder Lake */ 538 {} 539 }; 540 MODULE_DEVICE_TABLE(acpi, vsc_tp_acpi_ids); 541 542 static struct spi_driver vsc_tp_driver = { 543 .probe = vsc_tp_probe, 544 .remove = vsc_tp_remove, 545 .driver = { 546 .name = "vsc-tp", 547 .acpi_match_table = vsc_tp_acpi_ids, 548 }, 549 }; 550 module_spi_driver(vsc_tp_driver); 551 552 MODULE_AUTHOR("Wentong Wu <wentong.wu@intel.com>"); 553 MODULE_AUTHOR("Zhifeng Wang <zhifeng.wang@intel.com>"); 554 MODULE_DESCRIPTION("Intel Visual Sensing Controller Transport Layer"); 555 MODULE_LICENSE("GPL"); 556