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