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