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