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