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