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