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