1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2026 Intel Corporation 4 */ 5 6 #include <linux/acpi.h> 7 #include <linux/cleanup.h> 8 #include <linux/delay.h> 9 #include <linux/device.h> 10 #include <linux/gpio/consumer.h> 11 #include <linux/i2c.h> 12 #include <linux/init.h> 13 #include <linux/interrupt.h> 14 #include <linux/jiffies.h> 15 #include <linux/module.h> 16 #include <linux/pci.h> 17 #include <linux/platform_device.h> 18 #include <linux/pm_runtime.h> 19 #include <linux/slab.h> 20 #include <linux/time64.h> 21 #include <linux/workqueue.h> 22 23 #include <media/ipu-bridge.h> 24 #include <media/ipu6-pci-table.h> 25 26 #include "icvs.h" 27 28 /* Command timeouts determined experimentally */ 29 #define CMD_TIMEOUT (5 * HZ) 30 #define FW_READY_DELAY_MS 100 31 32 #define PCI_DEVICE_ID_INTEL_IPU7 0x645d /* MTL / LNL */ 33 #define PCI_DEVICE_ID_INTEL_IPU7P5 0xb05d /* ARL / PTL */ 34 #define PCI_DEVICE_ID_INTEL_IPU8 0xd719 /* NVL */ 35 36 /* 37 * IPU7 PCI device IDs not covered by ipu6_pci_tbl in ipu6-pci-table.h. 38 * Once the IPU6 driver gains support for IPU7, this table can be dropped. 39 */ 40 static const struct pci_device_id icvs_ipu7_tbl[] = { 41 { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IPU7) }, 42 { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IPU7P5) }, 43 { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IPU8) }, 44 { } 45 }; 46 47 static const struct acpi_gpio_params gpio_wake = { 0, 0, false }; 48 static const struct acpi_gpio_params gpio_rst = { 1, 0, false }; 49 static const struct acpi_gpio_params gpio_req = { 2, 0, false }; 50 static const struct acpi_gpio_params gpio_resp = { 3, 0, false }; 51 static const struct acpi_gpio_mapping icvs_acpi_gpios[] = { 52 { "wake-gpio", &gpio_wake, 1 }, 53 { "rst-gpio", &gpio_rst, 1 }, 54 { "req-gpio", &gpio_req, 1 }, 55 { "resp-gpio", &gpio_resp, 1 }, 56 { } 57 }; 58 59 static const struct acpi_gpio_params lgpio_req = { 0, 0, false }; 60 static const struct acpi_gpio_params lgpio_resp = { 1, 0, false }; 61 static const struct acpi_gpio_mapping icvs_acpi_lgpios[] = { 62 { "req-gpio", &lgpio_req, 1 }, 63 { "resp-gpio", &lgpio_resp, 1 }, 64 { } 65 }; 66 67 /* Device quirk table */ 68 static const struct icvs_device_quirk cvs_quirk_table[] = { 69 { 0x2ac1, 0x20d0, ICVS_NO_MIPI_CONFIG | 70 ICVS_NO_CAPS | 71 ICVS_NO_FW_UPDATE 72 }, /* Lattice NX33 */ 73 { 0x06CB, 0x0701, ICVS_SKIP_FW_RESET | 74 ICVS_HOST_SENSOR_PWR_CTRL | 75 ICVS_HOST_PRIV_CTRL | 76 ICVS_FW_BUF_SIZE_256 | 77 ICVS_FW_HEADER_SIZE_256 78 }, /* Synaptics SVP7xxx */ 79 { } 80 }; 81 82 /** 83 * cvs_set_quirks - Match device VID/PID and set quirks 84 * @ctx: CVS device context 85 * @vid: Vendor ID 86 * @pid: Product ID 87 * 88 * Searches the quirk table for a matching VID/PID and populates ctx->quirks 89 * with the corresponding quirk flags. 90 * If no match is found, quirks is set to 0. 91 */ 92 static void cvs_set_quirks(struct icvs *ctx, u16 vid, u16 pid) 93 { 94 ctx->quirks = 0; 95 96 for (unsigned int i = 0; i < ARRAY_SIZE(cvs_quirk_table); i++) { 97 if (cvs_quirk_table[i].vid == vid && 98 cvs_quirk_table[i].pid == pid) { 99 ctx->quirks = cvs_quirk_table[i].quirks; 100 dev_info(cvs_dev(ctx), 101 "Quirks: 0x%lx (VID:0x%04x PID:0x%04x)\n", 102 ctx->quirks, vid, pid); 103 return; 104 } 105 } 106 107 dev_info(cvs_dev(ctx), 108 "No quirks for device (VID:0x%04x PID:0x%04x)\n", vid, pid); 109 } 110 111 /* I2C transport helpers */ 112 113 /** 114 * cvs_read_i2c - Issue a read-type command and fetch device response 115 * @ctx: CVS device context 116 * @cmd_id: Command identifier (big endian) 117 * @resp: Destination buffer for response payload 118 * @size: Size of payload to read into @resp (without prefix) 119 * 120 * Sends @cmd_id and reads back the response in a single I2C transaction. 121 * When the device prepends a 4-byte protocol prefix, the combined 122 * prefix+payload is read into a temporary buffer and only the payload is 123 * copied to @resp, avoiding any dependency on the layout of the caller's 124 * buffer. 125 * 126 * Return: 0 on success or negative errno. 127 */ 128 static int cvs_read_i2c(struct icvs *ctx, __be16 cmd_id, void *resp, 129 size_t size) 130 { 131 size_t prefix_size = ctx->prefix ? sizeof(u32) : 0; 132 size_t read_size = size + prefix_size; 133 struct i2c_client *i2c = ctx->i2c_client; 134 u8 *buf __free(kfree) = NULL; 135 int cnt; 136 137 if (!resp || !size) 138 return -EINVAL; 139 140 cnt = i2c_master_send(i2c, (const char *)&cmd_id, sizeof(cmd_id)); 141 if (cnt != sizeof(cmd_id)) 142 return cnt < 0 ? cnt : -EIO; 143 144 buf = kmalloc(read_size, GFP_KERNEL); 145 if (!buf) 146 return -ENOMEM; 147 148 cnt = i2c_master_recv(i2c, buf, read_size); 149 if (cnt != read_size) { 150 dev_dbg(cvs_dev(ctx), "recv cmd 0x%04x short read (%d/%zu)\n", 151 be16_to_cpu(cmd_id), cnt, read_size); 152 return cnt < 0 ? cnt : -EIO; 153 } 154 155 memcpy(resp, buf + prefix_size, size); 156 157 return 0; 158 } 159 160 /** 161 * cvs_write_i2c - Write a raw command buffer to the device over I2C 162 * @ctx: CVS device context 163 * @data: Buffer containing command + payload 164 * @size: Total bytes to write 165 * 166 * Return: 0 on success or negative errno. 167 */ 168 static int cvs_write_i2c(struct icvs *ctx, const void *data, int size) 169 { 170 struct i2c_client *i2c = ctx->i2c_client; 171 int cnt; 172 173 if (size < 0 || !data) 174 return -EINVAL; 175 176 cnt = i2c_master_send(i2c, data, size); 177 if (cnt != size) { 178 dev_dbg(cvs_dev(ctx), "send short (%d/%d)\n", cnt, size); 179 return cnt < 0 ? cnt : -EIO; 180 } 181 182 return 0; 183 } 184 185 /** 186 * cvs_checksum - Simple additive checksum helper 187 * @data: 32-bit aligned data buffer 188 * @len: Length in bytes (multiple of 4) 189 * 190 * Return: 32-bit additive checksum of the dwords in @data. 191 */ 192 static u32 cvs_checksum(const void *data, size_t len) 193 { 194 const u32 *words = data; 195 u32 csum = 0; 196 197 if (WARN_ON_ONCE(len % sizeof(u32))) 198 return 0; 199 200 for (unsigned int i = 0; i < len / sizeof(u32); i++) 201 csum += words[i]; 202 203 return csum; 204 } 205 206 /** 207 * cvs_schedule_and_wait - Schedule polling work then wait for completion 208 * @ctx: CVS device context 209 * @work_delay_ms: Delay in milliseconds before polling work executes 210 * @wait_jiffies: Timeout (jiffies) to wait for cmd completion 211 * 212 * Queues ctx->work to run after @work_delay_ms and then waits up to 213 * @wait_jiffies for ctx->cmd_completion. 214 * 215 * Return: 0 on success, -ETIMEDOUT on timeout, negative errno on error. 216 */ 217 static int cvs_schedule_and_wait(struct icvs *ctx, unsigned int work_delay_ms, 218 unsigned long wait_jiffies) 219 { 220 int ret; 221 222 schedule_delayed_work(&ctx->work, msecs_to_jiffies(work_delay_ms)); 223 ret = wait_for_completion_killable_timeout(&ctx->cmd_completion, 224 wait_jiffies); 225 if (ret < 0) 226 return ret; 227 if (!ret) 228 return -ETIMEDOUT; 229 230 return 0; 231 } 232 233 /** 234 * cvs_wait_wake_or_sleep - Wait for wake IRQ or sleep fallback 235 * @ctx: CVS device context 236 * @timeout_jiffies: Timeout (jiffies) for wake event on full-cap devices 237 * @sleep_ms: Milliseconds to sleep on light-cap devices 238 * 239 * For full capability devices (ICVS_FULLCAP) waits interruptibly on 240 * ctx->hostwake_event until ctx->hostwake_event_arg becomes true or 241 * @timeout_jiffies elapses. The flag is cleared after the wait. 242 * For light capability devices performs a blocking msleep(@sleep_ms). 243 * 244 * Return codes normalized for caller switch handling: 245 * <0 : error / interrupted 246 * -ETIMEDOUT : timeout (wake event not observed) 247 * 0 : success (wake observed OR light-cap sleep elapsed) 248 * 249 * Return: negative errno, -ETIMEDOUT on timeout, 0 on success. 250 */ 251 static int cvs_wait_wake_or_sleep(struct icvs *ctx, 252 unsigned long timeout_jiffies, 253 unsigned int sleep_ms) 254 { 255 int ret; 256 257 if (ctx->res == ICVS_FULLCAP) { 258 ret = wait_event_interruptible_timeout(ctx->hostwake_event, 259 ctx->hostwake_event_arg, 260 timeout_jiffies); 261 ctx->hostwake_event_arg = false; 262 if (ret < 0) 263 return ret; 264 if (!ret) 265 return -ETIMEDOUT; 266 return 0; 267 } 268 269 msleep(sleep_ms); 270 271 return 0; /* treat sleep path as success */ 272 } 273 274 /** 275 * cvs_config_mipi - Send a HOST_SET_MIPI_CONFIG command 276 * @ctx: CVS device context 277 * @c: Command container with conf field populated 278 * @len: Length of original command structure (unused except for symmetry) 279 * 280 * Packages @c->param.conf into a cvs_mipi_data_packet including size and 281 * checksum, then writes it to the device. 282 * 283 * Firmware note: the CVS firmware expects the MIPI configuration to be 284 * sent as a single transaction, including all relevant parameters and checksum. 285 * 286 * Return: 0 on success, NO_MIPI_CONFIG or negative errno from I2C write. 287 */ 288 static int cvs_config_mipi(struct icvs *ctx, struct icvs_cmd *c, size_t len) 289 { 290 struct icvs_mipi_data_packet pkt = { 291 .cmd_id = c->cmd_id, 292 .size = sizeof(c->param.conf), 293 .crc = cvs_checksum(&c->param.conf, sizeof(c->param.conf)), 294 .conf = c->param.conf, 295 }; 296 297 if (ctx->quirks & ICVS_NO_MIPI_CONFIG) 298 return 0; 299 300 return cvs_write_i2c(ctx, &pkt, sizeof(pkt)); 301 } 302 303 /** 304 * cvs_get_device_state - Query current device state bitfield 305 * @ctx: CVS device context 306 * @state: Returned state value 307 * 308 * Issues GET_DEV_STATE and fills @state. 309 * 310 * Return: 0 on success or negative errno. 311 */ 312 static int cvs_get_device_state(struct icvs *ctx, u8 *state) 313 { 314 struct icvs_resp n = { 315 .cmd_id = cpu_to_be16(ICVS_GET_DEV_STATE), 316 }; 317 int ret; 318 319 ret = cvs_read_i2c(ctx, n.cmd_id, &n.resp.state, sizeof(n.resp.state)); 320 if (ret) 321 return ret; 322 323 *state = n.resp.state; 324 325 return 0; 326 } 327 328 /** 329 * cvs_get_device_caps - Read protocol capabilities 330 * @ctx: CVS device context 331 * @caps: Capability structure to populate 332 * 333 * Return: 0 on success or negative errno. 334 */ 335 static int cvs_get_device_caps(struct icvs *ctx, 336 struct icvs_dev_capabilities *caps) 337 { 338 struct icvs_resp n = { 339 .cmd_id = cpu_to_be16(ICVS_GET_DEV_CAPABILITY), 340 }; 341 int ret; 342 343 if (ctx->quirks & ICVS_NO_CAPS) 344 return 0; 345 346 ret = cvs_read_i2c(ctx, n.cmd_id, &n.resp.cap, sizeof(n.resp.cap)); 347 if (ret) 348 return ret; 349 350 *caps = n.resp.cap; 351 352 return 0; 353 } 354 355 /** 356 * cvs_hw_init - Probe device for prefix support and apply quirks 357 * @ctx: CVS device context 358 * 359 * Sends GET_DEV_VID_PID and probes for a 32-bit prefix. 360 * If it matches ICVS_PREFIX_VAL, sets ctx->prefix for subsequent reads. 361 * Then reads VID/PID and applies matching quirks. 362 * GET_DEV_VID_PID is supported by all protocol versions. 363 * 364 * Return: 0 on success or negative errno. 365 */ 366 static int cvs_hw_init(struct icvs *ctx) 367 { 368 struct icvs_resp n = { }; 369 __be16 cmd = cpu_to_be16(ICVS_GET_DEV_VID_PID); 370 u32 resp; 371 int ret; 372 373 /* 374 * Clear prefix so cvs_read_i2c always reads exactly sizeof(u32) bytes 375 * here, regardless of any value left over from a previous call (e.g. 376 * on resume). 377 */ 378 ctx->prefix = false; 379 ret = cvs_read_i2c(ctx, cmd, &resp, sizeof(resp)); 380 if (ret) 381 return ret; 382 383 ctx->prefix = resp == ICVS_PREFIX_VAL; 384 385 /* Now read VID/PID to apply quirks */ 386 ret = cvs_read_i2c(ctx, cmd, 387 &n.resp.vid_pid, sizeof(n.resp.vid_pid)); 388 if (ret) 389 return ret; 390 391 cvs_set_quirks(ctx, n.resp.vid_pid.v_id, n.resp.vid_pid.p_id); 392 393 return 0; 394 } 395 396 /** 397 * cvs_irq_handler - Wake IRQ handler (full capability devices) 398 * @irq: IRQ number 399 * @dev_id: Device context pointer 400 * 401 * Sets a waitqueue flag and wakes up sleeping waiters. 402 * 403 * Return: IRQ_HANDLED always. 404 */ 405 static irqreturn_t cvs_irq_handler(int irq, void *dev_id) 406 { 407 struct icvs *ctx = dev_id; 408 409 ctx->hostwake_event_arg = true; 410 wake_up_interruptible(&ctx->hostwake_event); 411 412 return IRQ_HANDLED; 413 } 414 415 /** 416 * cvs_reset - Toggle reset GPIO for full capability devices 417 * @ctx: CVS device context 418 * 419 * Drives reset low briefly then high if device resources indicate full 420 * capability. Light devices have no reset line. 421 */ 422 static void cvs_reset(struct icvs *ctx) 423 { 424 if (ctx->quirks & ICVS_SKIP_FW_RESET) 425 return; 426 427 if (ctx->res == ICVS_FULLCAP) { 428 gpiod_set_value(ctx->rst, 0); 429 fsleep(2000); 430 gpiod_set_value(ctx->rst, 1); 431 } 432 } 433 434 /** 435 * cvs_recv - Delayed work handler polling for command completion 436 * @work: Embedded delayed_work member 437 * 438 * Re-reads device state; if device_busy remains set, re-schedules itself. 439 * Otherwise stores state into wq_resp and completes the command. 440 */ 441 static void cvs_recv(struct work_struct *work) 442 { 443 struct icvs *ctx = container_of(work, struct icvs, work.work); 444 u8 state = 0; 445 int ret; 446 447 ret = cvs_get_device_state(ctx, &state); 448 if (ret < 0) { 449 dev_dbg(cvs_dev(ctx), "state read failed: %d\n", ret); 450 return; 451 } 452 453 if (state & ICVS_DEV_STATE_BUSY) { 454 dev_dbg(cvs_dev(ctx), "device busy, reschedule\n"); 455 schedule_delayed_work(&ctx->work, 456 msecs_to_jiffies(FW_READY_DELAY_MS)); 457 return; 458 } 459 460 ctx->wq_resp.resp.state = state; 461 complete(&ctx->cmd_completion); 462 } 463 464 /** 465 * cvs_send - Common command submission path 466 * @ctx: CVS device context 467 * @cmd: Command buffer (icvs_cmd) with cmd_id and param populated 468 * @len: Buffer length 469 * 470 * Dispatches a set of supported commands: 471 * - ICVS_SET_DEV_HOST_ID, 472 * - ICVS_HOST_SENSOR_OWNER, 473 * - ICVS_HOST_SET_MIPI_CONFIG 474 * - ICVS_FW_LOADER_* 475 * 476 * For I2C based commands it sets big-endian cmd ids, writes to the device 477 * and waits (via delayed work) for completion or timeout. 478 * GPIO based ownership toggles are handled locally. 479 * 480 * Caller must hold ctx->lock when invoking this function and check for i2c 481 * bus availability. 482 * 483 * Return: 0 on success, negative errno, -EINVAL for unsupported command 484 * or status from device in ctx->wq_resp. 485 */ 486 int cvs_send(struct icvs *ctx, struct icvs_cmd *cmd, size_t len) 487 { 488 int ret, status = 0; 489 490 lockdep_assert_held(&ctx->lock); 491 492 dev_dbg(cvs_dev(ctx), "send cmd = 0x%04x", be16_to_cpu(cmd->cmd_id)); 493 494 reinit_completion(&ctx->cmd_completion); 495 496 switch (be16_to_cpu(cmd->cmd_id)) { 497 case ICVS_SET_DEV_HOST_ID: 498 cmd->cmd_id = cpu_to_be16(ICVS_SET_DEV_HOST_ID); 499 ret = cvs_write_i2c(ctx, cmd, len); 500 if (ret < 0) 501 break; 502 503 ret = cvs_schedule_and_wait(ctx, FW_READY_DELAY_MS, 504 CMD_TIMEOUT); 505 if (ret < 0) 506 break; 507 508 status = ctx->wq_resp.resp.state & 509 ICVS_DEV_STATE_ERROR ? -EINVAL : 0; 510 break; 511 case ICVS_HOST_SENSOR_OWNER: 512 gpiod_set_value_cansleep(ctx->req, cmd->param.param); 513 fsleep(FW_READY_DELAY_MS * USEC_PER_MSEC); 514 ret = gpiod_get_value_cansleep(ctx->resp); 515 status = cmd->param.param == ret ? 0 : -EINVAL; 516 ret = 0; /* success */ 517 break; 518 case ICVS_HOST_SET_MIPI_CONFIG: 519 cmd->cmd_id = cpu_to_be16(ICVS_HOST_SET_MIPI_CONFIG); 520 ret = cvs_config_mipi(ctx, cmd, len); 521 if (ret < 0) 522 break; 523 524 ret = cvs_schedule_and_wait(ctx, FW_READY_DELAY_MS, 525 CMD_TIMEOUT); 526 status = (ctx->wq_resp.resp.state & 527 ICVS_DEV_STATE_ERROR) ? -EINVAL : 0; 528 break; 529 case ICVS_FW_LOADER_START: 530 cmd->cmd_id = cpu_to_be16(ICVS_FW_LOADER_START); 531 ret = cvs_write_i2c(ctx, cmd, len); 532 if (ret < 0) 533 break; 534 535 ret = cvs_wait_wake_or_sleep(ctx, CMD_TIMEOUT, 536 FW_READY_DELAY_MS); 537 if (ret) 538 break; 539 540 ret = cvs_schedule_and_wait(ctx, FW_READY_DELAY_MS, 541 CMD_TIMEOUT); 542 status = (ctx->wq_resp.resp.state & 543 ICVS_DEV_STATE_DOWNLOAD) ? 0 : -EINVAL; 544 break; 545 case ICVS_FW_LOADER_DATA: 546 /* Quirk for older protocols */ 547 if (ctx->caps.protocol_version_major >= 2 && 548 ctx->caps.protocol_version_minor >= 2) { 549 cmd->cmd_id = cpu_to_be16(ICVS_FW_LOADER_DATA); 550 ret = cvs_write_i2c(ctx, cmd, len); 551 } else { 552 ret = cvs_write_i2c(ctx, &cmd->param, 553 len - sizeof(cmd->cmd_id)); 554 } 555 556 if (ret < 0) 557 return ret; 558 559 ret = cvs_wait_wake_or_sleep(ctx, FW_READY_DELAY_MS, 560 FW_READY_DELAY_MS); 561 if (ret) 562 break; 563 564 ret = cvs_schedule_and_wait(ctx, FW_READY_DELAY_MS, 565 CMD_TIMEOUT); 566 status = ctx->wq_resp.resp.state & 567 ICVS_DEV_STATE_ERROR ? -EINVAL : 0; 568 break; 569 case ICVS_FW_LOADER_END: 570 cmd->cmd_id = cpu_to_be16(ICVS_FW_LOADER_END); 571 ret = cvs_write_i2c(ctx, cmd, len); 572 if (ret < 0) 573 break; 574 575 ret = cvs_wait_wake_or_sleep(ctx, CMD_TIMEOUT, 576 FW_READY_DELAY_MS); 577 if (ret) 578 break; 579 580 ret = cvs_schedule_and_wait(ctx, FW_READY_DELAY_MS, 581 CMD_TIMEOUT); 582 status = !(ctx->wq_resp.resp.state & 583 ICVS_DEV_STATE_DOWNLOAD) ? 0 : -EINVAL; 584 break; 585 default: 586 ret = -EINVAL; 587 break; 588 } 589 590 if (ret < 0) 591 return ret; 592 593 return ctx->wq_resp.status = status; 594 } 595 596 /** 597 * cvs_set_link_owner - Switch CSI-2 link ownership between host and device 598 * @ctx: CVS device context 599 * @owner: Desired owner (ICVS_CSI_LINK_HOST or ICVS_CSI_LINK_CVS) 600 * 601 * Called from runtime PM callbacks to claim or release the CSI-2 link. 602 * Also callable directly for error recovery paths. 603 * 604 * Return: 0 on success or negative errno. 605 */ 606 int cvs_set_link_owner(struct icvs *ctx, enum icvs_csi_link_owner owner) 607 { 608 struct icvs_cmd cmd = { 609 .cmd_id = cpu_to_be16(ICVS_HOST_SENSOR_OWNER), 610 .param.param = owner, 611 }; 612 size_t cmd_size = sizeof(cmd.cmd_id) + sizeof(cmd.param.param); 613 614 guard(mutex)(&ctx->lock); 615 return cvs_send(ctx, &cmd, cmd_size); 616 } 617 618 /** 619 * cvs_configure_dev_caps - Configure device capability ownership bits 620 * @ctx: CVS device context 621 * 622 * Tells the CVS device which of its features (privacy LED, RGB camera 623 * power-up, vision sensing) are controlled by the host, then sends 624 * SET_DEV_HOST_ID. 625 * 626 * Return: 0 on success or negative errno. 627 */ 628 static int cvs_configure_dev_caps(struct icvs *ctx) 629 { 630 struct icvs_cmd cmd = { .cmd_id = cpu_to_be16(ICVS_SET_DEV_HOST_ID) }; 631 size_t sz = sizeof(cmd.cmd_id) + sizeof(cmd.param.host_id); 632 633 if (ctx->quirks & ICVS_NO_CAPS) 634 return 0; 635 636 if (ctx->quirks & ICVS_HOST_VISION_SENSING) 637 cmd.param.host_id |= ICVS_HOST_ID_VISION_SENSING; 638 if (ctx->quirks & ICVS_HOST_PRIV_CTRL) 639 cmd.param.host_id |= ICVS_HOST_ID_PRIVACY_LED; 640 if (ctx->quirks & ICVS_HOST_SENSOR_PWR_CTRL) 641 cmd.param.host_id |= ICVS_HOST_ID_RGBCAMERA_PWRUP; 642 643 guard(mutex)(&ctx->lock); 644 return cvs_send(ctx, &cmd, sz); 645 } 646 647 /** 648 * cvs_core_probe - Shared probe path for I2C & platform instantiation 649 * @dev: Parent device 650 * @i2c: I2C client (NULL for platform devices) 651 * 652 * Discovers IPU, parses ACPI resources, sets up GPIOs/IRQs, initializes 653 * sub-device (CSI) and host identifier, and exposes sysfs firmware interface. 654 * 655 * Return: 0 on success or negative errno. 656 */ 657 static int cvs_core_probe(struct device *dev, struct i2c_client *i2c) 658 { 659 struct pci_dev *ipu = NULL; 660 struct icvs *ctx; 661 int ret; 662 663 /* Locate IPU device */ 664 for (unsigned int i = 0; !ipu && ipu6_pci_tbl[i].vendor; i++) 665 ipu = pci_get_device(ipu6_pci_tbl[i].vendor, 666 ipu6_pci_tbl[i].device, NULL); 667 for (unsigned int i = 0; !ipu && icvs_ipu7_tbl[i].vendor; i++) 668 ipu = pci_get_device(icvs_ipu7_tbl[i].vendor, 669 icvs_ipu7_tbl[i].device, NULL); 670 if (!ipu) 671 return -ENODEV; 672 673 ret = ipu_bridge_init(&ipu->dev, ipu_bridge_parse_ssdb); 674 if (ret < 0) 675 goto err_put_ipu; 676 677 if (!dev_fwnode(dev)) { 678 ret = -ENXIO; 679 goto err_put_ipu; 680 } 681 682 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); 683 if (!ctx) { 684 ret = -ENOMEM; 685 goto err_put_ipu; 686 } 687 688 ctx->i2c_client = i2c; 689 690 ret = gpiod_count(dev, NULL); 691 switch (ret) { 692 case ICVS_GPIO_SYNC: 693 ctx->res = ICVS_LIGHTCAP; 694 break; 695 case ICVS_GPIO_ASYNC: 696 ctx->res = ICVS_FULLCAP; 697 break; 698 default: 699 dev_err(dev, "unexpected GPIO count %d\n", ret); 700 ret = -EINVAL; 701 goto err_put_ipu; 702 } 703 704 ret = devm_acpi_dev_add_driver_gpios(dev, 705 ctx->res == ICVS_FULLCAP ? 706 icvs_acpi_gpios : 707 icvs_acpi_lgpios); 708 if (ret) { 709 dev_err_probe(dev, ret, "failed to add ACPI GPIOs\n"); 710 goto err_put_ipu; 711 } 712 713 ctx->req = devm_gpiod_get(dev, "req", GPIOD_OUT_HIGH); 714 if (IS_ERR(ctx->req)) { 715 ret = dev_err_probe(dev, PTR_ERR(ctx->req), 716 "failed to get req GPIO\n"); 717 goto err_put_ipu; 718 } 719 720 ctx->resp = devm_gpiod_get(dev, "resp", GPIOD_IN); 721 if (IS_ERR(ctx->resp)) { 722 ret = dev_err_probe(dev, PTR_ERR(ctx->resp), 723 "failed to get resp GPIO\n"); 724 goto err_put_ipu; 725 } 726 727 if (ctx->res == ICVS_FULLCAP) { 728 struct gpio_desc *wake; 729 730 ctx->rst = devm_gpiod_get(dev, "rst", GPIOD_OUT_HIGH); 731 if (IS_ERR(ctx->rst)) { 732 ret = dev_err_probe(dev, PTR_ERR(ctx->rst), 733 "failed to get rst GPIO\n"); 734 goto err_put_ipu; 735 } 736 737 wake = devm_gpiod_get(dev, "wake", GPIOD_IN); 738 if (IS_ERR(wake)) { 739 ret = dev_err_probe(dev, PTR_ERR(wake), 740 "failed to get wake GPIO\n"); 741 goto err_put_ipu; 742 } 743 744 ctx->irq = gpiod_to_irq(wake); 745 if (ctx->irq < 0) { 746 ret = dev_err_probe(dev, ctx->irq, 747 "failed to get wake IRQ\n"); 748 goto err_put_ipu; 749 } 750 751 ret = devm_request_threaded_irq(dev, ctx->irq, NULL, 752 cvs_irq_handler, 753 IRQF_ONESHOT | IRQF_NO_SUSPEND, 754 "cvs_wake", ctx); 755 if (ret) { 756 dev_err_probe(dev, ret, "failed to request IRQ\n"); 757 goto err_put_ipu; 758 } 759 } 760 761 ret = devm_mutex_init(dev, &ctx->lock); 762 if (ret) 763 goto err_put_ipu; 764 765 init_completion(&ctx->cmd_completion); 766 init_waitqueue_head(&ctx->hostwake_event); 767 INIT_DELAYED_WORK(&ctx->work, cvs_recv); 768 769 if (i2c) { 770 ret = cvs_hw_init(ctx); 771 if (ret) { 772 dev_err(dev, "HW init failed (%d)\n", ret); 773 /* 774 * Fallback to GPIO-only mode. 775 * Some BIOS show the device on the I2C bus, however, 776 * the device is not accessible via I2C. 777 */ 778 ctx->i2c_client = NULL; 779 goto fail_i2c; 780 } 781 782 ret = cvs_get_device_caps(ctx, &ctx->caps); 783 if (ret) { 784 dev_err_probe(dev, ret, "get caps failed\n"); 785 goto err_put_ipu; 786 } 787 788 ret = cvs_configure_dev_caps(ctx); 789 if (ret) { 790 dev_err_probe(dev, ret, 791 "configure dev caps failed\n"); 792 goto err_put_ipu; 793 } 794 } 795 796 fail_i2c: 797 ret = cvs_csi_init(ctx, dev, i2c); 798 if (ret) { 799 dev_err_probe(dev, ret, "CSI init failed\n"); 800 goto err_put_ipu; 801 } 802 803 dev_set_drvdata(dev, ctx); 804 pm_runtime_set_autosuspend_delay(dev, 1000); 805 pm_runtime_use_autosuspend(dev); 806 pm_runtime_enable(dev); 807 pm_runtime_idle(dev); 808 809 /* 810 * Create a PM runtime device link with IPU as consumer and CVS as 811 * supplier. When the IPU runtime-resumes to start streaming, the PM 812 * framework automatically resumes CVS first, triggering 813 * cvs_runtime_resume() which hands CSI-2 link ownership to the host. 814 */ 815 ctx->ipu_link = device_link_add(&ipu->dev, dev, 816 DL_FLAG_PM_RUNTIME | 817 DL_FLAG_RPM_ACTIVE | 818 DL_FLAG_STATELESS); 819 if (!ctx->ipu_link) { 820 dev_err(dev, "IPU device link failed\n"); 821 ret = -ENODEV; 822 goto err_csi_remove; 823 } 824 825 if (has_acpi_companion(dev)) 826 acpi_dev_clear_dependencies(ACPI_COMPANION(dev)); 827 828 put_device(&ipu->dev); 829 830 return 0; 831 832 err_csi_remove: 833 if (ctx->ipu_link) 834 device_link_del(ctx->ipu_link); 835 cvs_csi_remove(ctx); 836 pm_runtime_dont_use_autosuspend(dev); 837 pm_runtime_disable(dev); 838 pm_runtime_set_suspended(dev); 839 840 err_put_ipu: 841 put_device(&ipu->dev); 842 843 return ret; 844 } 845 846 /** 847 * cvs_probe - I2C driver probe entry 848 * @i2c: I2C client 849 * 850 * Return: 0 on success or negative errno. 851 */ 852 static int cvs_probe(struct i2c_client *i2c) 853 { 854 return cvs_core_probe(&i2c->dev, i2c); 855 } 856 857 /** 858 * cvs_core_remove - Shared remove logic 859 * @dev: Device 860 */ 861 static void cvs_core_remove(struct device *dev) 862 { 863 struct icvs *ctx = dev_get_drvdata(dev); 864 865 cancel_delayed_work_sync(&ctx->work); 866 cvs_csi_remove(ctx); 867 868 if (ctx->ipu_link) 869 device_link_del(ctx->ipu_link); 870 871 pm_runtime_put_noidle(dev); 872 pm_runtime_disable(dev); 873 pm_runtime_set_suspended(dev); 874 875 cvs_reset(ctx); 876 } 877 878 /** 879 * cvs_remove - I2C driver remove 880 * @client: I2C client 881 */ 882 static void cvs_remove(struct i2c_client *client) 883 { 884 cvs_core_remove(&client->dev); 885 } 886 887 /** 888 * cvs_suspend - System suspend callback 889 * @dev: Device 890 * 891 * Return: 0. 892 */ 893 static int __maybe_unused cvs_suspend(struct device *dev) 894 { 895 struct icvs *ctx = dev_get_drvdata(dev); 896 897 cancel_delayed_work_sync(&ctx->work); 898 899 return 0; 900 } 901 902 /** 903 * cvs_resume - System resume callback 904 * @dev: Device 905 * 906 * Re-validates I2C link prefix and re-sends host id if transport available. 907 * 908 * Return: 0 on success or negative errno if I2C check fails. 909 */ 910 static int __maybe_unused cvs_resume(struct device *dev) 911 { 912 struct icvs *ctx = dev_get_drvdata(dev); 913 int ret; 914 915 if (ctx->i2c_client) { 916 ret = cvs_hw_init(ctx); 917 if (ret) 918 return ret; 919 return cvs_configure_dev_caps(ctx); 920 } 921 922 return 0; 923 } 924 925 /** 926 * cvs_runtime_resume - Runtime PM resume: claim CSI-2 link ownership 927 * @dev: Device 928 * 929 * Triggered automatically when the IPU (consumer) runtime-resumes, because 930 * a DL_FLAG_PM_RUNTIME device link makes CVS the supplier. Transfers CSI-2 931 * link ownership to the host so the IPU can start receiving sensor frames. 932 * 933 * Return: 0 on success or negative errno. 934 */ 935 static int __maybe_unused cvs_runtime_resume(struct device *dev) 936 { 937 struct icvs *ctx = dev_get_drvdata(dev); 938 939 return cvs_set_link_owner(ctx, ICVS_CSI_LINK_HOST); 940 } 941 942 /** 943 * cvs_runtime_suspend - Runtime PM suspend: release CSI-2 link ownership 944 * @dev: Device 945 * 946 * Called when the streaming reference is dropped by cvs_csi_disable_streams 947 * via pm_runtime_put_autosuspend. Returns CSI-2 link ownership to CVS firmware. 948 * 949 * Return: 0 on success or negative errno. 950 */ 951 static int __maybe_unused cvs_runtime_suspend(struct device *dev) 952 { 953 struct icvs *ctx = dev_get_drvdata(dev); 954 955 return cvs_set_link_owner(ctx, ICVS_CSI_LINK_CVS); 956 } 957 958 static const struct dev_pm_ops __maybe_unused cvs_pm_ops = { 959 SET_SYSTEM_SLEEP_PM_OPS(cvs_suspend, cvs_resume) 960 SET_RUNTIME_PM_OPS(cvs_runtime_suspend, cvs_runtime_resume, NULL) 961 }; 962 963 static const struct acpi_device_id intel_cvs_acpi_match[] = { 964 { "INTC10DE" }, /* LNL */ 965 { "INTC10E0" }, /* ARL */ 966 { "INTC10E1" }, /* PTL */ 967 { "INTC10FA" }, /* NVL */ 968 { } 969 }; 970 MODULE_DEVICE_TABLE(acpi, intel_cvs_acpi_match); 971 972 static struct i2c_driver cvs_driver = { 973 .driver = { 974 .name = "intel_cvs", 975 .acpi_match_table = intel_cvs_acpi_match, 976 .pm = pm_ptr(&cvs_pm_ops), 977 }, 978 .probe = cvs_probe, 979 .remove = cvs_remove, 980 }; 981 982 static int cvs_platform_probe(struct platform_device *pdev) 983 { 984 return cvs_core_probe(&pdev->dev, NULL); 985 } 986 987 static void cvs_platform_remove(struct platform_device *pdev) 988 { 989 cvs_core_remove(&pdev->dev); 990 } 991 992 /* 993 * Platform driver structure. 994 * 995 * Some platforms may instantiate the CVS device as a platform device 996 * without I2C support. This driver binding allows such platforms to use the 997 * CVS core functionality (GPIOs, CSI sub-device) without I2C. 998 */ 999 static struct platform_driver cvs_platform_driver = { 1000 .driver = { 1001 .name = "cvs_platform", 1002 .acpi_match_table = intel_cvs_acpi_match, 1003 .pm = pm_ptr(&cvs_pm_ops), 1004 }, 1005 .probe = cvs_platform_probe, 1006 .remove = cvs_platform_remove, 1007 }; 1008 1009 /** 1010 * cvs_init - Module init registering I2C and platform drivers 1011 * 1012 * Return: 0 on success or negative errno. 1013 */ 1014 static int __init cvs_init(void) 1015 { 1016 int ret; 1017 1018 ret = i2c_add_driver(&cvs_driver); 1019 if (ret) 1020 return ret; 1021 1022 ret = platform_driver_register(&cvs_platform_driver); 1023 if (ret) { 1024 i2c_del_driver(&cvs_driver); 1025 return ret; 1026 } 1027 1028 return 0; 1029 } 1030 1031 /** 1032 * cvs_exit - Module exit unregistering drivers 1033 */ 1034 static void __exit cvs_exit(void) 1035 { 1036 platform_driver_unregister(&cvs_platform_driver); 1037 i2c_del_driver(&cvs_driver); 1038 } 1039 module_init(cvs_init); 1040 module_exit(cvs_exit); 1041 1042 MODULE_IMPORT_NS("INTEL_IPU_BRIDGE"); 1043 MODULE_AUTHOR("Miguel Vadillo <miguel.vadillo@intel.com>"); 1044 MODULE_DESCRIPTION("Intel Vision Sensing Controller driver"); 1045 MODULE_LICENSE("GPL"); 1046