1 // SPDX-License-Identifier: GPL-2.0 2 /* Author: Dan Scally <djrscally@gmail.com> */ 3 4 #include <linux/acpi.h> 5 #include <acpi/acpi_bus.h> 6 #include <linux/cleanup.h> 7 #include <linux/device.h> 8 #include <linux/dmi.h> 9 #include <linux/i2c.h> 10 #include <linux/mei_cl_bus.h> 11 #include <linux/platform_device.h> 12 #include <linux/pm_runtime.h> 13 #include <linux/property.h> 14 #include <linux/string.h> 15 #include <linux/workqueue.h> 16 17 #include <media/ipu-bridge.h> 18 #include <media/v4l2-fwnode.h> 19 20 #define ADEV_DEV(adev) ACPI_PTR(&((adev)->dev)) 21 22 /* 23 * 92335fcf-3203-4472-af93-7b4453ac29da 24 * 25 * Used to build MEI CSI device name to lookup MEI CSI device by 26 * device_find_child_by_name(). 27 */ 28 #define MEI_CSI_UUID \ 29 UUID_LE(0x92335FCF, 0x3203, 0x4472, \ 30 0xAF, 0x93, 0x7B, 0x44, 0x53, 0xAC, 0x29, 0xDA) 31 32 /* 33 * IVSC device name 34 * 35 * Used to match IVSC device by ipu_bridge_match_ivsc_dev() 36 */ 37 #define IVSC_DEV_NAME "intel_vsc" 38 39 /* 40 * Extend this array with ACPI Hardware IDs of devices known to be working 41 * plus the number of link-frequencies expected by their drivers, along with 42 * the frequency values in hertz. This is somewhat opportunistic way of adding 43 * support for this for now in the hopes of a better source for the information 44 * (possibly some encoded value in the SSDB buffer that we're unaware of) 45 * becoming apparent in the future. 46 * 47 * Do not add an entry for a sensor that is not actually supported. 48 * 49 * Please keep the list sorted by ACPI HID. 50 */ 51 static const struct ipu_sensor_config ipu_supported_sensors[] = { 52 /* Himax HM11B1 */ 53 IPU_SENSOR_CONFIG("HIMX11B1", 1, 384000000), 54 /* Himax HM2170 */ 55 IPU_SENSOR_CONFIG("HIMX2170", 1, 384000000), 56 /* Himax HM2172 */ 57 IPU_SENSOR_CONFIG("HIMX2172", 1, 384000000), 58 /* GalaxyCore GC0310 */ 59 IPU_SENSOR_CONFIG("INT0310", 1, 55692000), 60 /* Omnivision OV5693 */ 61 IPU_SENSOR_CONFIG("INT33BE", 1, 419200000), 62 /* Onsemi MT9M114 */ 63 IPU_SENSOR_CONFIG("INT33F0", 1, 384000000), 64 /* Omnivision OV2740 */ 65 IPU_SENSOR_CONFIG("INT3474", 1, 180000000), 66 /* Omnivision OV5670 */ 67 IPU_SENSOR_CONFIG("INT3479", 1, 422400000), 68 /* Omnivision OV8865 */ 69 IPU_SENSOR_CONFIG("INT347A", 1, 360000000), 70 /* Omnivision OV7251 */ 71 IPU_SENSOR_CONFIG("INT347E", 1, 319200000), 72 /* Hynix Hi-556 */ 73 IPU_SENSOR_CONFIG("INT3537", 1, 437000000), 74 /* Lontium lt6911uxe */ 75 IPU_SENSOR_CONFIG("INTC10C5", 0), 76 /* Omnivision OV01A10 / OV01A1S */ 77 IPU_SENSOR_CONFIG("OVTI01A0", 1, 400000000), 78 IPU_SENSOR_CONFIG("OVTI01AS", 1, 400000000), 79 /* Omnivision OV02C10 */ 80 IPU_SENSOR_CONFIG("OVTI02C1", 1, 400000000), 81 /* Omnivision OV02E10 */ 82 IPU_SENSOR_CONFIG("OVTI02E1", 1, 360000000), 83 /* Omnivision ov05c10 */ 84 IPU_SENSOR_CONFIG("OVTI05C1", 1, 480000000), 85 /* Omnivision OV08A10 */ 86 IPU_SENSOR_CONFIG("OVTI08A1", 1, 500000000), 87 /* Omnivision OV08x40 */ 88 IPU_SENSOR_CONFIG("OVTI08F4", 3, 400000000, 749000000, 800000000), 89 /* Omnivision OV13B10 */ 90 IPU_SENSOR_CONFIG("OVTI13B1", 1, 560000000), 91 IPU_SENSOR_CONFIG("OVTIDB10", 1, 560000000), 92 /* Omnivision OV2680 */ 93 IPU_SENSOR_CONFIG("OVTI2680", 1, 331200000), 94 /* Omnivision OV5675 */ 95 IPU_SENSOR_CONFIG("OVTI5675", 1, 450000000), 96 /* Omnivision OV8856 */ 97 IPU_SENSOR_CONFIG("OVTI8856", 3, 180000000, 360000000, 720000000), 98 /* Sony IMX471 */ 99 IPU_SENSOR_CONFIG("SONY471A", 1, 200000000), 100 /* Toshiba T4KA3 */ 101 IPU_SENSOR_CONFIG("XMCC0003", 1, 321468000), 102 }; 103 104 /* 105 * DMI matches for laptops which have their sensor mounted upside-down 106 * without reporting a rotation of 180° in neither the SSDB nor the _PLD. 107 */ 108 static const struct dmi_system_id upside_down_sensor_dmi_ids[] = { 109 { 110 .matches = { 111 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 112 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "XPS 13 9340"), 113 }, 114 .driver_data = "OVTI02C1", 115 }, 116 { 117 .matches = { 118 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 119 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "XPS 13 9350"), 120 }, 121 .driver_data = "OVTI02C1", 122 }, 123 { 124 .matches = { 125 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 126 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "XPS 14 9440"), 127 }, 128 .driver_data = "OVTI02C1", 129 }, 130 { 131 .matches = { 132 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 133 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "XPS 16 9640"), 134 }, 135 .driver_data = "OVTI02C1", 136 }, 137 {} /* Terminating entry */ 138 }; 139 140 static const struct ipu_property_names prop_names = { 141 .clock_frequency = "clock-frequency", 142 .rotation = "rotation", 143 .orientation = "orientation", 144 .bus_type = "bus-type", 145 .data_lanes = "data-lanes", 146 .remote_endpoint = "remote-endpoint", 147 .link_frequencies = "link-frequencies", 148 }; 149 150 static const char * const ipu_vcm_types[] = { 151 "ad5823", 152 "dw9714", 153 "ad5816", 154 "dw9719", 155 "dw9718", 156 "dw9806b", 157 "wv517s", 158 "lc898122xa", 159 "lc898212axb", 160 }; 161 162 /* 163 * Used to figure out IVSC acpi device by ipu_bridge_get_ivsc_acpi_dev() 164 * instead of device and driver match to probe IVSC device. 165 */ 166 static const struct acpi_device_id ivsc_acpi_ids[] = { 167 { "INTC1059" }, 168 { "INTC1095" }, 169 { "INTC100A" }, 170 { "INTC10CF" }, 171 }; 172 173 static struct acpi_device *ipu_bridge_get_ivsc_acpi_dev(struct acpi_device *adev) 174 { 175 unsigned int i; 176 177 for (i = 0; i < ARRAY_SIZE(ivsc_acpi_ids); i++) { 178 const struct acpi_device_id *acpi_id = &ivsc_acpi_ids[i]; 179 struct acpi_device *consumer, *ivsc_adev; 180 181 acpi_handle handle = acpi_device_handle(ACPI_PTR(adev)); 182 for_each_acpi_dev_match(ivsc_adev, acpi_id->id, NULL, -1) 183 /* camera sensor depends on IVSC in DSDT if exist */ 184 for_each_acpi_consumer_dev(ivsc_adev, consumer) 185 if (ACPI_PTR(consumer->handle) == handle) { 186 acpi_dev_put(consumer); 187 return ivsc_adev; 188 } 189 } 190 191 return NULL; 192 } 193 194 static int ipu_bridge_match_ivsc_dev(struct device *dev, const void *adev) 195 { 196 if (ACPI_COMPANION(dev) != adev) 197 return 0; 198 199 if (!sysfs_streq(dev_name(dev), IVSC_DEV_NAME)) 200 return 0; 201 202 return 1; 203 } 204 205 static struct device *ipu_bridge_get_ivsc_csi_dev(struct acpi_device *adev) 206 { 207 struct device *dev, *csi_dev; 208 uuid_le uuid = MEI_CSI_UUID; 209 char name[64]; 210 211 /* IVSC device on platform bus */ 212 dev = bus_find_device(&platform_bus_type, NULL, adev, 213 ipu_bridge_match_ivsc_dev); 214 if (dev) { 215 snprintf(name, sizeof(name), "%s-%pUl", dev_name(dev), &uuid); 216 217 csi_dev = device_find_child_by_name(dev, name); 218 219 put_device(dev); 220 221 return csi_dev; 222 } 223 224 return NULL; 225 } 226 227 static int ipu_bridge_check_ivsc_dev(struct ipu_sensor *sensor, 228 struct acpi_device *sensor_adev) 229 { 230 struct acpi_device *adev; 231 struct device *csi_dev; 232 233 adev = ipu_bridge_get_ivsc_acpi_dev(sensor_adev); 234 if (adev) { 235 csi_dev = ipu_bridge_get_ivsc_csi_dev(adev); 236 if (!csi_dev) { 237 acpi_dev_put(adev); 238 dev_err(ADEV_DEV(adev), "Failed to find MEI CSI dev\n"); 239 return -ENODEV; 240 } 241 242 sensor->csi_dev = csi_dev; 243 sensor->ivsc_adev = adev; 244 } 245 246 return 0; 247 } 248 249 static int ipu_bridge_read_acpi_buffer(struct acpi_device *adev, char *id, 250 void *data, u32 size) 251 { 252 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 253 union acpi_object *obj; 254 acpi_status status; 255 int ret = 0; 256 257 status = acpi_evaluate_object(ACPI_PTR(adev->handle), 258 id, NULL, &buffer); 259 if (ACPI_FAILURE(status)) 260 return -ENODEV; 261 262 obj = buffer.pointer; 263 if (!obj) { 264 dev_err(ADEV_DEV(adev), "Couldn't locate ACPI buffer\n"); 265 return -ENODEV; 266 } 267 268 if (obj->type != ACPI_TYPE_BUFFER) { 269 dev_err(ADEV_DEV(adev), "Not an ACPI buffer\n"); 270 ret = -ENODEV; 271 goto out_free_buff; 272 } 273 274 if (obj->buffer.length > size) { 275 dev_err(ADEV_DEV(adev), "Given buffer is too small\n"); 276 ret = -EINVAL; 277 goto out_free_buff; 278 } 279 280 memcpy(data, obj->buffer.pointer, obj->buffer.length); 281 282 out_free_buff: 283 kfree(buffer.pointer); 284 return ret; 285 } 286 287 static u32 ipu_bridge_parse_rotation(struct acpi_device *adev, 288 struct ipu_sensor_ssdb *ssdb) 289 { 290 const struct dmi_system_id *dmi_id; 291 292 dmi_id = dmi_first_match(upside_down_sensor_dmi_ids); 293 if (dmi_id && acpi_dev_hid_match(adev, dmi_id->driver_data)) 294 return 180; 295 296 switch (ssdb->degree) { 297 case IPU_SENSOR_ROTATION_NORMAL: 298 return 0; 299 case IPU_SENSOR_ROTATION_INVERTED: 300 return 180; 301 default: 302 dev_warn(ADEV_DEV(adev), 303 "Unknown rotation %d. Assume 0 degree rotation\n", 304 ssdb->degree); 305 return 0; 306 } 307 } 308 309 static enum v4l2_fwnode_orientation ipu_bridge_parse_orientation(struct acpi_device *adev) 310 { 311 enum v4l2_fwnode_orientation orientation; 312 struct acpi_pld_info *pld = NULL; 313 314 if (!acpi_get_physical_device_location(ACPI_PTR(adev->handle), &pld)) { 315 dev_warn(ADEV_DEV(adev), "_PLD call failed, using default orientation\n"); 316 return V4L2_FWNODE_ORIENTATION_EXTERNAL; 317 } 318 319 switch (pld->panel) { 320 case ACPI_PLD_PANEL_FRONT: 321 orientation = V4L2_FWNODE_ORIENTATION_FRONT; 322 break; 323 case ACPI_PLD_PANEL_BACK: 324 orientation = V4L2_FWNODE_ORIENTATION_BACK; 325 break; 326 case ACPI_PLD_PANEL_TOP: 327 case ACPI_PLD_PANEL_LEFT: 328 case ACPI_PLD_PANEL_RIGHT: 329 case ACPI_PLD_PANEL_UNKNOWN: 330 orientation = V4L2_FWNODE_ORIENTATION_EXTERNAL; 331 break; 332 default: 333 dev_warn(ADEV_DEV(adev), "Unknown _PLD panel val %d\n", 334 pld->panel); 335 orientation = V4L2_FWNODE_ORIENTATION_EXTERNAL; 336 break; 337 } 338 339 ACPI_FREE(pld); 340 return orientation; 341 } 342 343 int ipu_bridge_parse_ssdb(struct acpi_device *adev, struct ipu_sensor *sensor) 344 { 345 struct ipu_sensor_ssdb ssdb = {}; 346 int ret; 347 348 ret = ipu_bridge_read_acpi_buffer(adev, "SSDB", &ssdb, sizeof(ssdb)); 349 if (ret) 350 return ret; 351 352 if (ssdb.vcmtype > ARRAY_SIZE(ipu_vcm_types)) { 353 dev_warn(ADEV_DEV(adev), "Unknown VCM type %d\n", ssdb.vcmtype); 354 ssdb.vcmtype = 0; 355 } 356 357 if (ssdb.lanes > IPU_MAX_LANES) { 358 dev_err(ADEV_DEV(adev), "Number of lanes in SSDB is invalid\n"); 359 return -EINVAL; 360 } 361 362 sensor->link = ssdb.link; 363 sensor->lanes = ssdb.lanes; 364 sensor->mclkspeed = ssdb.mclkspeed; 365 sensor->rotation = ipu_bridge_parse_rotation(adev, &ssdb); 366 sensor->orientation = ipu_bridge_parse_orientation(adev); 367 368 if (ssdb.vcmtype) 369 sensor->vcm_type = ipu_vcm_types[ssdb.vcmtype - 1]; 370 371 return 0; 372 } 373 EXPORT_SYMBOL_NS_GPL(ipu_bridge_parse_ssdb, "INTEL_IPU_BRIDGE"); 374 375 static void ipu_bridge_create_fwnode_properties( 376 struct ipu_sensor *sensor, 377 struct ipu_bridge *bridge, 378 const struct ipu_sensor_config *cfg) 379 { 380 struct ipu_property_names *names = &sensor->prop_names; 381 struct software_node *nodes = sensor->swnodes; 382 383 sensor->prop_names = prop_names; 384 385 if (sensor->csi_dev) { 386 sensor->local_ref[0] = 387 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IVSC_SENSOR_ENDPOINT]); 388 sensor->remote_ref[0] = 389 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IVSC_IPU_ENDPOINT]); 390 sensor->ivsc_sensor_ref[0] = 391 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_SENSOR_ENDPOINT]); 392 sensor->ivsc_ipu_ref[0] = 393 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IPU_ENDPOINT]); 394 395 sensor->ivsc_sensor_ep_properties[0] = 396 PROPERTY_ENTRY_U32(names->bus_type, 397 V4L2_FWNODE_BUS_TYPE_CSI2_DPHY); 398 sensor->ivsc_sensor_ep_properties[1] = 399 PROPERTY_ENTRY_U32_ARRAY_LEN(names->data_lanes, 400 bridge->data_lanes, 401 sensor->lanes); 402 sensor->ivsc_sensor_ep_properties[2] = 403 PROPERTY_ENTRY_REF_ARRAY(names->remote_endpoint, 404 sensor->ivsc_sensor_ref); 405 406 sensor->ivsc_ipu_ep_properties[0] = 407 PROPERTY_ENTRY_U32(names->bus_type, 408 V4L2_FWNODE_BUS_TYPE_CSI2_DPHY); 409 sensor->ivsc_ipu_ep_properties[1] = 410 PROPERTY_ENTRY_U32_ARRAY_LEN(names->data_lanes, 411 bridge->data_lanes, 412 sensor->lanes); 413 sensor->ivsc_ipu_ep_properties[2] = 414 PROPERTY_ENTRY_REF_ARRAY(names->remote_endpoint, 415 sensor->ivsc_ipu_ref); 416 } else { 417 sensor->local_ref[0] = 418 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IPU_ENDPOINT]); 419 sensor->remote_ref[0] = 420 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_SENSOR_ENDPOINT]); 421 } 422 423 sensor->dev_properties[0] = PROPERTY_ENTRY_U32( 424 sensor->prop_names.clock_frequency, 425 sensor->mclkspeed); 426 sensor->dev_properties[1] = PROPERTY_ENTRY_U32( 427 sensor->prop_names.rotation, 428 sensor->rotation); 429 sensor->dev_properties[2] = PROPERTY_ENTRY_U32( 430 sensor->prop_names.orientation, 431 sensor->orientation); 432 if (sensor->vcm_type) { 433 sensor->vcm_ref[0] = 434 SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_VCM]); 435 sensor->dev_properties[3] = 436 PROPERTY_ENTRY_REF_ARRAY("lens-focus", sensor->vcm_ref); 437 } 438 439 sensor->ep_properties[0] = PROPERTY_ENTRY_U32( 440 sensor->prop_names.bus_type, 441 V4L2_FWNODE_BUS_TYPE_CSI2_DPHY); 442 sensor->ep_properties[1] = PROPERTY_ENTRY_U32_ARRAY_LEN( 443 sensor->prop_names.data_lanes, 444 bridge->data_lanes, sensor->lanes); 445 sensor->ep_properties[2] = PROPERTY_ENTRY_REF_ARRAY( 446 sensor->prop_names.remote_endpoint, 447 sensor->local_ref); 448 449 if (cfg->nr_link_freqs > 0) 450 sensor->ep_properties[3] = PROPERTY_ENTRY_U64_ARRAY_LEN( 451 sensor->prop_names.link_frequencies, 452 cfg->link_freqs, 453 cfg->nr_link_freqs); 454 455 sensor->ipu_properties[0] = PROPERTY_ENTRY_U32_ARRAY_LEN( 456 sensor->prop_names.data_lanes, 457 bridge->data_lanes, sensor->lanes); 458 sensor->ipu_properties[1] = PROPERTY_ENTRY_REF_ARRAY( 459 sensor->prop_names.remote_endpoint, 460 sensor->remote_ref); 461 } 462 463 static void ipu_bridge_init_swnode_names(struct ipu_sensor *sensor) 464 { 465 snprintf(sensor->node_names.remote_port, 466 sizeof(sensor->node_names.remote_port), 467 SWNODE_GRAPH_PORT_NAME_FMT, sensor->link); 468 snprintf(sensor->node_names.port, 469 sizeof(sensor->node_names.port), 470 SWNODE_GRAPH_PORT_NAME_FMT, 0); /* Always port 0 */ 471 snprintf(sensor->node_names.endpoint, 472 sizeof(sensor->node_names.endpoint), 473 SWNODE_GRAPH_ENDPOINT_NAME_FMT, 0); /* And endpoint 0 */ 474 if (sensor->vcm_type) { 475 /* append link to distinguish nodes with same model VCM */ 476 snprintf(sensor->node_names.vcm, sizeof(sensor->node_names.vcm), 477 "%s-%u", sensor->vcm_type, sensor->link); 478 } 479 480 if (sensor->csi_dev) { 481 snprintf(sensor->node_names.ivsc_sensor_port, 482 sizeof(sensor->node_names.ivsc_sensor_port), 483 SWNODE_GRAPH_PORT_NAME_FMT, 0); 484 snprintf(sensor->node_names.ivsc_ipu_port, 485 sizeof(sensor->node_names.ivsc_ipu_port), 486 SWNODE_GRAPH_PORT_NAME_FMT, 1); 487 } 488 } 489 490 static void ipu_bridge_init_swnode_group(struct ipu_sensor *sensor) 491 { 492 struct software_node *nodes = sensor->swnodes; 493 494 sensor->group[SWNODE_SENSOR_HID] = &nodes[SWNODE_SENSOR_HID]; 495 sensor->group[SWNODE_SENSOR_PORT] = &nodes[SWNODE_SENSOR_PORT]; 496 sensor->group[SWNODE_SENSOR_ENDPOINT] = &nodes[SWNODE_SENSOR_ENDPOINT]; 497 sensor->group[SWNODE_IPU_PORT] = &nodes[SWNODE_IPU_PORT]; 498 sensor->group[SWNODE_IPU_ENDPOINT] = &nodes[SWNODE_IPU_ENDPOINT]; 499 if (sensor->vcm_type) 500 sensor->group[SWNODE_VCM] = &nodes[SWNODE_VCM]; 501 502 if (sensor->csi_dev) { 503 sensor->group[SWNODE_IVSC_HID] = 504 &nodes[SWNODE_IVSC_HID]; 505 sensor->group[SWNODE_IVSC_SENSOR_PORT] = 506 &nodes[SWNODE_IVSC_SENSOR_PORT]; 507 sensor->group[SWNODE_IVSC_SENSOR_ENDPOINT] = 508 &nodes[SWNODE_IVSC_SENSOR_ENDPOINT]; 509 sensor->group[SWNODE_IVSC_IPU_PORT] = 510 &nodes[SWNODE_IVSC_IPU_PORT]; 511 sensor->group[SWNODE_IVSC_IPU_ENDPOINT] = 512 &nodes[SWNODE_IVSC_IPU_ENDPOINT]; 513 514 if (sensor->vcm_type) 515 sensor->group[SWNODE_VCM] = &nodes[SWNODE_VCM]; 516 } else { 517 if (sensor->vcm_type) 518 sensor->group[SWNODE_IVSC_HID] = &nodes[SWNODE_VCM]; 519 } 520 } 521 522 static void ipu_bridge_create_connection_swnodes(struct ipu_bridge *bridge, 523 struct ipu_sensor *sensor) 524 { 525 struct ipu_node_names *names = &sensor->node_names; 526 struct software_node *nodes = sensor->swnodes; 527 528 ipu_bridge_init_swnode_names(sensor); 529 530 nodes[SWNODE_SENSOR_HID] = NODE_SENSOR(sensor->name, 531 sensor->dev_properties); 532 nodes[SWNODE_SENSOR_PORT] = NODE_PORT(sensor->node_names.port, 533 &nodes[SWNODE_SENSOR_HID]); 534 nodes[SWNODE_SENSOR_ENDPOINT] = NODE_ENDPOINT( 535 sensor->node_names.endpoint, 536 &nodes[SWNODE_SENSOR_PORT], 537 sensor->ep_properties); 538 nodes[SWNODE_IPU_PORT] = NODE_PORT(sensor->node_names.remote_port, 539 &bridge->ipu_hid_node); 540 nodes[SWNODE_IPU_ENDPOINT] = NODE_ENDPOINT( 541 sensor->node_names.endpoint, 542 &nodes[SWNODE_IPU_PORT], 543 sensor->ipu_properties); 544 545 if (sensor->csi_dev) { 546 const char *device_hid = ""; 547 548 device_hid = acpi_device_hid(sensor->ivsc_adev); 549 550 snprintf(sensor->ivsc_name, sizeof(sensor->ivsc_name), "%s-%u", 551 device_hid, sensor->link); 552 553 nodes[SWNODE_IVSC_HID] = NODE_SENSOR(sensor->ivsc_name, 554 sensor->ivsc_properties); 555 nodes[SWNODE_IVSC_SENSOR_PORT] = 556 NODE_PORT(names->ivsc_sensor_port, 557 &nodes[SWNODE_IVSC_HID]); 558 nodes[SWNODE_IVSC_SENSOR_ENDPOINT] = 559 NODE_ENDPOINT(names->endpoint, 560 &nodes[SWNODE_IVSC_SENSOR_PORT], 561 sensor->ivsc_sensor_ep_properties); 562 nodes[SWNODE_IVSC_IPU_PORT] = 563 NODE_PORT(names->ivsc_ipu_port, 564 &nodes[SWNODE_IVSC_HID]); 565 nodes[SWNODE_IVSC_IPU_ENDPOINT] = 566 NODE_ENDPOINT(names->endpoint, 567 &nodes[SWNODE_IVSC_IPU_PORT], 568 sensor->ivsc_ipu_ep_properties); 569 } 570 571 nodes[SWNODE_VCM] = NODE_VCM(sensor->node_names.vcm); 572 573 ipu_bridge_init_swnode_group(sensor); 574 } 575 576 /* 577 * The actual instantiation must be done from a workqueue to avoid 578 * a deadlock on taking list_lock from v4l2-async twice. 579 */ 580 struct ipu_bridge_instantiate_vcm_work_data { 581 struct work_struct work; 582 struct device *sensor; 583 char name[16]; 584 struct i2c_board_info board_info; 585 }; 586 587 static void ipu_bridge_instantiate_vcm_work(struct work_struct *work) 588 { 589 struct ipu_bridge_instantiate_vcm_work_data *data = 590 container_of(work, struct ipu_bridge_instantiate_vcm_work_data, 591 work); 592 struct acpi_device *adev = ACPI_COMPANION(data->sensor); 593 struct i2c_client *vcm_client; 594 bool put_fwnode = true; 595 int ret; 596 597 /* 598 * The client may get probed before the device_link gets added below 599 * make sure the sensor is powered-up during probe. 600 */ 601 ret = pm_runtime_get_sync(data->sensor); 602 if (ret < 0) { 603 dev_err(data->sensor, "Error %d runtime-resuming sensor, cannot instantiate VCM\n", 604 ret); 605 goto out_pm_put; 606 } 607 608 /* 609 * Note the client is created only once and then kept around 610 * even after a rmmod, just like the software-nodes. 611 */ 612 vcm_client = i2c_acpi_new_device_by_fwnode(acpi_fwnode_handle(adev), 613 1, &data->board_info); 614 if (IS_ERR(vcm_client)) { 615 dev_err(data->sensor, "Error instantiating VCM client: %pe\n", 616 vcm_client); 617 goto out_pm_put; 618 } 619 620 device_link_add(&vcm_client->dev, data->sensor, DL_FLAG_PM_RUNTIME); 621 622 dev_info(data->sensor, "Instantiated %s VCM\n", data->board_info.type); 623 put_fwnode = false; /* Ownership has passed to the i2c-client */ 624 625 out_pm_put: 626 pm_runtime_put(data->sensor); 627 put_device(data->sensor); 628 if (put_fwnode) 629 fwnode_handle_put(data->board_info.fwnode); 630 kfree(data); 631 } 632 633 int ipu_bridge_instantiate_vcm(struct device *sensor) 634 { 635 struct ipu_bridge_instantiate_vcm_work_data *data; 636 struct fwnode_handle *vcm_fwnode; 637 struct i2c_client *vcm_client; 638 struct acpi_device *adev; 639 char *sep; 640 641 adev = ACPI_COMPANION(sensor); 642 if (!adev) 643 return 0; 644 645 vcm_fwnode = fwnode_find_reference(dev_fwnode(sensor), "lens-focus", 0); 646 if (IS_ERR(vcm_fwnode)) 647 return 0; 648 649 /* When reloading modules the client will already exist */ 650 vcm_client = i2c_find_device_by_fwnode(vcm_fwnode); 651 if (vcm_client) { 652 fwnode_handle_put(vcm_fwnode); 653 put_device(&vcm_client->dev); 654 return 0; 655 } 656 657 data = kzalloc_obj(*data); 658 if (!data) { 659 fwnode_handle_put(vcm_fwnode); 660 return -ENOMEM; 661 } 662 663 INIT_WORK(&data->work, ipu_bridge_instantiate_vcm_work); 664 data->sensor = get_device(sensor); 665 snprintf(data->name, sizeof(data->name), "%s-VCM", 666 acpi_dev_name(adev)); 667 data->board_info.dev_name = data->name; 668 data->board_info.fwnode = vcm_fwnode; 669 snprintf(data->board_info.type, sizeof(data->board_info.type), 670 "%pfwP", vcm_fwnode); 671 /* Strip "-<link>" postfix */ 672 sep = strchrnul(data->board_info.type, '-'); 673 *sep = 0; 674 675 queue_work(system_long_wq, &data->work); 676 677 return 0; 678 } 679 EXPORT_SYMBOL_NS_GPL(ipu_bridge_instantiate_vcm, "INTEL_IPU_BRIDGE"); 680 681 static int ipu_bridge_instantiate_ivsc(struct ipu_sensor *sensor) 682 { 683 struct fwnode_handle *fwnode; 684 685 if (!sensor->csi_dev) 686 return 0; 687 688 fwnode = software_node_fwnode(&sensor->swnodes[SWNODE_IVSC_HID]); 689 if (!fwnode) 690 return -ENODEV; 691 692 set_secondary_fwnode(sensor->csi_dev, fwnode); 693 694 return 0; 695 } 696 697 static void ipu_bridge_unregister_sensors(struct ipu_bridge *bridge) 698 { 699 struct ipu_sensor *sensor; 700 unsigned int i; 701 702 for (i = 0; i < bridge->n_sensors; i++) { 703 sensor = &bridge->sensors[i]; 704 software_node_unregister_node_group(sensor->group); 705 acpi_dev_put(sensor->adev); 706 put_device(sensor->csi_dev); 707 acpi_dev_put(sensor->ivsc_adev); 708 } 709 } 710 711 static int ipu_bridge_connect_sensor(const struct ipu_sensor_config *cfg, 712 struct ipu_bridge *bridge) 713 { 714 struct fwnode_handle *fwnode, *primary; 715 struct ipu_sensor *sensor; 716 struct acpi_device *adev = NULL; 717 int ret; 718 719 for_each_acpi_dev_match(adev, cfg->hid, NULL, -1) { 720 if (!ACPI_PTR(adev->status.enabled)) 721 continue; 722 723 if (bridge->n_sensors >= IPU_MAX_PORTS) { 724 acpi_dev_put(adev); 725 dev_err(bridge->dev, "Exceeded available IPU ports\n"); 726 return -EINVAL; 727 } 728 729 sensor = &bridge->sensors[bridge->n_sensors]; 730 731 ret = bridge->parse_sensor_fwnode(adev, sensor); 732 if (ret) 733 goto err_put_adev; 734 735 snprintf(sensor->name, sizeof(sensor->name), "%s-%u", 736 cfg->hid, sensor->link); 737 738 ret = ipu_bridge_check_ivsc_dev(sensor, adev); 739 if (ret) 740 goto err_put_adev; 741 742 ipu_bridge_create_fwnode_properties(sensor, bridge, cfg); 743 ipu_bridge_create_connection_swnodes(bridge, sensor); 744 745 ret = software_node_register_node_group(sensor->group); 746 if (ret) 747 goto err_put_ivsc; 748 749 fwnode = software_node_fwnode(&sensor->swnodes[ 750 SWNODE_SENSOR_HID]); 751 if (!fwnode) { 752 ret = -ENODEV; 753 goto err_free_swnodes; 754 } 755 756 sensor->adev = ACPI_PTR(acpi_dev_get(adev)); 757 758 primary = acpi_fwnode_handle(adev); 759 primary->secondary = fwnode; 760 761 ret = ipu_bridge_instantiate_ivsc(sensor); 762 if (ret) 763 goto err_free_swnodes; 764 765 dev_info(bridge->dev, "Found supported sensor %s\n", 766 acpi_dev_name(adev)); 767 768 bridge->n_sensors++; 769 } 770 771 return 0; 772 773 err_free_swnodes: 774 software_node_unregister_node_group(sensor->group); 775 err_put_ivsc: 776 put_device(sensor->csi_dev); 777 acpi_dev_put(sensor->ivsc_adev); 778 err_put_adev: 779 acpi_dev_put(adev); 780 return ret; 781 } 782 783 static int ipu_bridge_connect_sensors(struct ipu_bridge *bridge) 784 { 785 unsigned int i; 786 int ret; 787 788 for (i = 0; i < ARRAY_SIZE(ipu_supported_sensors); i++) { 789 const struct ipu_sensor_config *cfg = 790 &ipu_supported_sensors[i]; 791 792 ret = ipu_bridge_connect_sensor(cfg, bridge); 793 if (ret) 794 goto err_unregister_sensors; 795 } 796 797 return 0; 798 799 err_unregister_sensors: 800 ipu_bridge_unregister_sensors(bridge); 801 return ret; 802 } 803 804 static int ipu_bridge_ivsc_is_ready(void) 805 { 806 struct acpi_device *sensor_adev, *adev; 807 struct device *csi_dev; 808 bool ready = true; 809 unsigned int i; 810 811 for (i = 0; i < ARRAY_SIZE(ipu_supported_sensors); i++) { 812 const struct ipu_sensor_config *cfg = 813 &ipu_supported_sensors[i]; 814 815 for_each_acpi_dev_match(sensor_adev, cfg->hid, NULL, -1) { 816 if (!ACPI_PTR(sensor_adev->status.enabled)) 817 continue; 818 819 adev = ipu_bridge_get_ivsc_acpi_dev(sensor_adev); 820 if (!adev) 821 continue; 822 823 csi_dev = ipu_bridge_get_ivsc_csi_dev(adev); 824 if (!csi_dev) 825 ready = false; 826 827 put_device(csi_dev); 828 acpi_dev_put(adev); 829 } 830 } 831 832 return ready; 833 } 834 835 static int ipu_bridge_check_fwnode_graph(struct fwnode_handle *fwnode) 836 { 837 struct fwnode_handle *endpoint; 838 839 if (IS_ERR_OR_NULL(fwnode)) 840 return -EINVAL; 841 842 endpoint = fwnode_graph_get_next_endpoint(fwnode, NULL); 843 if (endpoint) { 844 fwnode_handle_put(endpoint); 845 return 0; 846 } 847 848 return ipu_bridge_check_fwnode_graph(fwnode->secondary); 849 } 850 851 static DEFINE_MUTEX(ipu_bridge_mutex); 852 853 int ipu_bridge_init(struct device *dev, 854 ipu_parse_sensor_fwnode_t parse_sensor_fwnode) 855 { 856 struct fwnode_handle *fwnode; 857 struct ipu_bridge *bridge; 858 unsigned int i; 859 int ret; 860 861 guard(mutex)(&ipu_bridge_mutex); 862 863 if (!ipu_bridge_check_fwnode_graph(dev_fwnode(dev))) 864 return 0; 865 866 if (!ipu_bridge_ivsc_is_ready()) 867 return dev_err_probe(dev, -EPROBE_DEFER, 868 "waiting for IVSC to become ready\n"); 869 870 bridge = kzalloc_obj(*bridge); 871 if (!bridge) 872 return -ENOMEM; 873 874 strscpy(bridge->ipu_node_name, IPU_HID, 875 sizeof(bridge->ipu_node_name)); 876 bridge->ipu_hid_node.name = bridge->ipu_node_name; 877 bridge->dev = dev; 878 bridge->parse_sensor_fwnode = parse_sensor_fwnode; 879 880 ret = software_node_register(&bridge->ipu_hid_node); 881 if (ret < 0) { 882 dev_err(dev, "Failed to register the IPU HID node\n"); 883 goto err_free_bridge; 884 } 885 886 /* 887 * Map the lane arrangement, which is fixed for the IPU3 (meaning we 888 * only need one, rather than one per sensor). We include it as a 889 * member of the struct ipu_bridge rather than a global variable so 890 * that it survives if the module is unloaded along with the rest of 891 * the struct. 892 */ 893 for (i = 0; i < IPU_MAX_LANES; i++) 894 bridge->data_lanes[i] = i + 1; 895 896 ret = ipu_bridge_connect_sensors(bridge); 897 if (ret || bridge->n_sensors == 0) 898 goto err_unregister_ipu; 899 900 dev_info(dev, "Connected %d cameras\n", bridge->n_sensors); 901 902 fwnode = software_node_fwnode(&bridge->ipu_hid_node); 903 if (!fwnode) { 904 dev_err(dev, "Error getting fwnode from ipu software_node\n"); 905 ret = -ENODEV; 906 goto err_unregister_sensors; 907 } 908 909 set_secondary_fwnode(dev, fwnode); 910 911 return 0; 912 913 err_unregister_sensors: 914 ipu_bridge_unregister_sensors(bridge); 915 err_unregister_ipu: 916 software_node_unregister(&bridge->ipu_hid_node); 917 err_free_bridge: 918 kfree(bridge); 919 920 return ret; 921 } 922 EXPORT_SYMBOL_NS_GPL(ipu_bridge_init, "INTEL_IPU_BRIDGE"); 923 924 MODULE_LICENSE("GPL"); 925 MODULE_DESCRIPTION("Intel IPU Sensors Bridge driver"); 926