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