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