1 // SPDX-License-Identifier: GPL-2.0
2 /* Author: Dan Scally <djrscally@gmail.com> */
4 #include <linux/acpi.h>
5 #include <linux/device.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>
14 #include <media/ipu-bridge.h>
15 #include <media/v4l2-fwnode.h>
18 * 92335fcf-3203-4472-af93-7b4453ac29da
20 * Used to build MEI CSI device name to lookup MEI CSI device by
21 * device_find_child_by_name().
23 #define MEI_CSI_UUID \
24 UUID_LE(0x92335FCF, 0x3203, 0x4472, \
25 0xAF, 0x93, 0x7B, 0x44, 0x53, 0xAC, 0x29, 0xDA)
30 * Used to match IVSC device by ipu_bridge_match_ivsc_dev()
32 #define IVSC_DEV_NAME "intel_vsc"
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.
42 * Do not add an entry for a sensor that is not actually supported.
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, 360000000),
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),
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",
75 static const char * const ipu_vcm_types[] = {
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.
91 static const struct acpi_device_id ivsc_acpi_ids[] = {
98 static struct acpi_device *ipu_bridge_get_ivsc_acpi_dev(struct acpi_device *adev)
100 acpi_handle handle = acpi_device_handle(adev);
101 struct acpi_device *consumer, *ivsc_adev;
104 for (i = 0; i < ARRAY_SIZE(ivsc_acpi_ids); i++) {
105 const struct acpi_device_id *acpi_id = &ivsc_acpi_ids[i];
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)
117 static int ipu_bridge_match_ivsc_dev(struct device *dev, const void *adev)
119 if (ACPI_COMPANION(dev) != adev)
122 if (!sysfs_streq(dev_name(dev), IVSC_DEV_NAME))
128 static struct device *ipu_bridge_get_ivsc_csi_dev(struct acpi_device *adev)
130 struct device *dev, *csi_dev;
131 uuid_le uuid = MEI_CSI_UUID;
134 /* IVSC device on platform bus */
135 dev = bus_find_device(&platform_bus_type, NULL, adev,
136 ipu_bridge_match_ivsc_dev);
138 snprintf(name, sizeof(name), "%s-%pUl", dev_name(dev), &uuid);
140 csi_dev = device_find_child_by_name(dev, name);
150 static int ipu_bridge_check_ivsc_dev(struct ipu_sensor *sensor,
151 struct acpi_device *sensor_adev)
153 struct acpi_device *adev;
154 struct device *csi_dev;
156 adev = ipu_bridge_get_ivsc_acpi_dev(sensor_adev);
158 csi_dev = ipu_bridge_get_ivsc_csi_dev(adev);
161 dev_err(&adev->dev, "Failed to find MEI CSI dev\n");
165 sensor->csi_dev = csi_dev;
166 sensor->ivsc_adev = adev;
172 static int ipu_bridge_read_acpi_buffer(struct acpi_device *adev, char *id,
173 void *data, u32 size)
175 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
176 union acpi_object *obj;
180 status = acpi_evaluate_object(adev->handle, id, NULL, &buffer);
181 if (ACPI_FAILURE(status))
184 obj = buffer.pointer;
186 dev_err(&adev->dev, "Couldn't locate ACPI buffer\n");
190 if (obj->type != ACPI_TYPE_BUFFER) {
191 dev_err(&adev->dev, "Not an ACPI buffer\n");
196 if (obj->buffer.length > size) {
197 dev_err(&adev->dev, "Given buffer is too small\n");
202 memcpy(data, obj->buffer.pointer, obj->buffer.length);
205 kfree(buffer.pointer);
209 static u32 ipu_bridge_parse_rotation(struct acpi_device *adev,
210 struct ipu_sensor_ssdb *ssdb)
212 switch (ssdb->degree) {
213 case IPU_SENSOR_ROTATION_NORMAL:
215 case IPU_SENSOR_ROTATION_INVERTED:
219 "Unknown rotation %d. Assume 0 degree rotation\n",
225 static enum v4l2_fwnode_orientation ipu_bridge_parse_orientation(struct acpi_device *adev)
227 enum v4l2_fwnode_orientation orientation;
228 struct acpi_pld_info *pld;
231 status = acpi_get_physical_device_location(adev->handle, &pld);
232 if (ACPI_FAILURE(status)) {
233 dev_warn(&adev->dev, "_PLD call failed, using default orientation\n");
234 return V4L2_FWNODE_ORIENTATION_EXTERNAL;
237 switch (pld->panel) {
238 case ACPI_PLD_PANEL_FRONT:
239 orientation = V4L2_FWNODE_ORIENTATION_FRONT;
241 case ACPI_PLD_PANEL_BACK:
242 orientation = V4L2_FWNODE_ORIENTATION_BACK;
244 case ACPI_PLD_PANEL_TOP:
245 case ACPI_PLD_PANEL_LEFT:
246 case ACPI_PLD_PANEL_RIGHT:
247 case ACPI_PLD_PANEL_UNKNOWN:
248 orientation = V4L2_FWNODE_ORIENTATION_EXTERNAL;
251 dev_warn(&adev->dev, "Unknown _PLD panel val %d\n", pld->panel);
252 orientation = V4L2_FWNODE_ORIENTATION_EXTERNAL;
260 int ipu_bridge_parse_ssdb(struct acpi_device *adev, struct ipu_sensor *sensor)
262 struct ipu_sensor_ssdb ssdb = {};
265 ret = ipu_bridge_read_acpi_buffer(adev, "SSDB", &ssdb, sizeof(ssdb));
269 if (ssdb.vcmtype > ARRAY_SIZE(ipu_vcm_types)) {
270 dev_warn(&adev->dev, "Unknown VCM type %d\n", ssdb.vcmtype);
274 if (ssdb.lanes > IPU_MAX_LANES) {
275 dev_err(&adev->dev, "Number of lanes in SSDB is invalid\n");
279 sensor->link = ssdb.link;
280 sensor->lanes = ssdb.lanes;
281 sensor->mclkspeed = ssdb.mclkspeed;
282 sensor->rotation = ipu_bridge_parse_rotation(adev, &ssdb);
283 sensor->orientation = ipu_bridge_parse_orientation(adev);
286 sensor->vcm_type = ipu_vcm_types[ssdb.vcmtype - 1];
290 EXPORT_SYMBOL_NS_GPL(ipu_bridge_parse_ssdb, INTEL_IPU_BRIDGE);
292 static void ipu_bridge_create_fwnode_properties(
293 struct ipu_sensor *sensor,
294 struct ipu_bridge *bridge,
295 const struct ipu_sensor_config *cfg)
297 struct ipu_property_names *names = &sensor->prop_names;
298 struct software_node *nodes = sensor->swnodes;
300 sensor->prop_names = prop_names;
302 if (sensor->csi_dev) {
303 sensor->local_ref[0] =
304 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IVSC_SENSOR_ENDPOINT]);
305 sensor->remote_ref[0] =
306 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IVSC_IPU_ENDPOINT]);
307 sensor->ivsc_sensor_ref[0] =
308 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_SENSOR_ENDPOINT]);
309 sensor->ivsc_ipu_ref[0] =
310 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IPU_ENDPOINT]);
312 sensor->ivsc_sensor_ep_properties[0] =
313 PROPERTY_ENTRY_U32(names->bus_type,
314 V4L2_FWNODE_BUS_TYPE_CSI2_DPHY);
315 sensor->ivsc_sensor_ep_properties[1] =
316 PROPERTY_ENTRY_U32_ARRAY_LEN(names->data_lanes,
319 sensor->ivsc_sensor_ep_properties[2] =
320 PROPERTY_ENTRY_REF_ARRAY(names->remote_endpoint,
321 sensor->ivsc_sensor_ref);
323 sensor->ivsc_ipu_ep_properties[0] =
324 PROPERTY_ENTRY_U32(names->bus_type,
325 V4L2_FWNODE_BUS_TYPE_CSI2_DPHY);
326 sensor->ivsc_ipu_ep_properties[1] =
327 PROPERTY_ENTRY_U32_ARRAY_LEN(names->data_lanes,
330 sensor->ivsc_ipu_ep_properties[2] =
331 PROPERTY_ENTRY_REF_ARRAY(names->remote_endpoint,
332 sensor->ivsc_ipu_ref);
334 sensor->local_ref[0] =
335 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IPU_ENDPOINT]);
336 sensor->remote_ref[0] =
337 SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_SENSOR_ENDPOINT]);
340 sensor->dev_properties[0] = PROPERTY_ENTRY_U32(
341 sensor->prop_names.clock_frequency,
343 sensor->dev_properties[1] = PROPERTY_ENTRY_U32(
344 sensor->prop_names.rotation,
346 sensor->dev_properties[2] = PROPERTY_ENTRY_U32(
347 sensor->prop_names.orientation,
348 sensor->orientation);
349 if (sensor->vcm_type) {
351 SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_VCM]);
352 sensor->dev_properties[3] =
353 PROPERTY_ENTRY_REF_ARRAY("lens-focus", sensor->vcm_ref);
356 sensor->ep_properties[0] = PROPERTY_ENTRY_U32(
357 sensor->prop_names.bus_type,
358 V4L2_FWNODE_BUS_TYPE_CSI2_DPHY);
359 sensor->ep_properties[1] = PROPERTY_ENTRY_U32_ARRAY_LEN(
360 sensor->prop_names.data_lanes,
361 bridge->data_lanes, sensor->lanes);
362 sensor->ep_properties[2] = PROPERTY_ENTRY_REF_ARRAY(
363 sensor->prop_names.remote_endpoint,
366 if (cfg->nr_link_freqs > 0)
367 sensor->ep_properties[3] = PROPERTY_ENTRY_U64_ARRAY_LEN(
368 sensor->prop_names.link_frequencies,
372 sensor->ipu_properties[0] = PROPERTY_ENTRY_U32_ARRAY_LEN(
373 sensor->prop_names.data_lanes,
374 bridge->data_lanes, sensor->lanes);
375 sensor->ipu_properties[1] = PROPERTY_ENTRY_REF_ARRAY(
376 sensor->prop_names.remote_endpoint,
380 static void ipu_bridge_init_swnode_names(struct ipu_sensor *sensor)
382 snprintf(sensor->node_names.remote_port,
383 sizeof(sensor->node_names.remote_port),
384 SWNODE_GRAPH_PORT_NAME_FMT, sensor->link);
385 snprintf(sensor->node_names.port,
386 sizeof(sensor->node_names.port),
387 SWNODE_GRAPH_PORT_NAME_FMT, 0); /* Always port 0 */
388 snprintf(sensor->node_names.endpoint,
389 sizeof(sensor->node_names.endpoint),
390 SWNODE_GRAPH_ENDPOINT_NAME_FMT, 0); /* And endpoint 0 */
391 if (sensor->vcm_type) {
392 /* append link to distinguish nodes with same model VCM */
393 snprintf(sensor->node_names.vcm, sizeof(sensor->node_names.vcm),
394 "%s-%u", sensor->vcm_type, sensor->link);
397 if (sensor->csi_dev) {
398 snprintf(sensor->node_names.ivsc_sensor_port,
399 sizeof(sensor->node_names.ivsc_sensor_port),
400 SWNODE_GRAPH_PORT_NAME_FMT, 0);
401 snprintf(sensor->node_names.ivsc_ipu_port,
402 sizeof(sensor->node_names.ivsc_ipu_port),
403 SWNODE_GRAPH_PORT_NAME_FMT, 1);
407 static void ipu_bridge_init_swnode_group(struct ipu_sensor *sensor)
409 struct software_node *nodes = sensor->swnodes;
411 sensor->group[SWNODE_SENSOR_HID] = &nodes[SWNODE_SENSOR_HID];
412 sensor->group[SWNODE_SENSOR_PORT] = &nodes[SWNODE_SENSOR_PORT];
413 sensor->group[SWNODE_SENSOR_ENDPOINT] = &nodes[SWNODE_SENSOR_ENDPOINT];
414 sensor->group[SWNODE_IPU_PORT] = &nodes[SWNODE_IPU_PORT];
415 sensor->group[SWNODE_IPU_ENDPOINT] = &nodes[SWNODE_IPU_ENDPOINT];
416 if (sensor->vcm_type)
417 sensor->group[SWNODE_VCM] = &nodes[SWNODE_VCM];
419 if (sensor->csi_dev) {
420 sensor->group[SWNODE_IVSC_HID] =
421 &nodes[SWNODE_IVSC_HID];
422 sensor->group[SWNODE_IVSC_SENSOR_PORT] =
423 &nodes[SWNODE_IVSC_SENSOR_PORT];
424 sensor->group[SWNODE_IVSC_SENSOR_ENDPOINT] =
425 &nodes[SWNODE_IVSC_SENSOR_ENDPOINT];
426 sensor->group[SWNODE_IVSC_IPU_PORT] =
427 &nodes[SWNODE_IVSC_IPU_PORT];
428 sensor->group[SWNODE_IVSC_IPU_ENDPOINT] =
429 &nodes[SWNODE_IVSC_IPU_ENDPOINT];
431 if (sensor->vcm_type)
432 sensor->group[SWNODE_VCM] = &nodes[SWNODE_VCM];
434 if (sensor->vcm_type)
435 sensor->group[SWNODE_IVSC_HID] = &nodes[SWNODE_VCM];
439 static void ipu_bridge_create_connection_swnodes(struct ipu_bridge *bridge,
440 struct ipu_sensor *sensor)
442 struct ipu_node_names *names = &sensor->node_names;
443 struct software_node *nodes = sensor->swnodes;
445 ipu_bridge_init_swnode_names(sensor);
447 nodes[SWNODE_SENSOR_HID] = NODE_SENSOR(sensor->name,
448 sensor->dev_properties);
449 nodes[SWNODE_SENSOR_PORT] = NODE_PORT(sensor->node_names.port,
450 &nodes[SWNODE_SENSOR_HID]);
451 nodes[SWNODE_SENSOR_ENDPOINT] = NODE_ENDPOINT(
452 sensor->node_names.endpoint,
453 &nodes[SWNODE_SENSOR_PORT],
454 sensor->ep_properties);
455 nodes[SWNODE_IPU_PORT] = NODE_PORT(sensor->node_names.remote_port,
456 &bridge->ipu_hid_node);
457 nodes[SWNODE_IPU_ENDPOINT] = NODE_ENDPOINT(
458 sensor->node_names.endpoint,
459 &nodes[SWNODE_IPU_PORT],
460 sensor->ipu_properties);
462 if (sensor->csi_dev) {
463 snprintf(sensor->ivsc_name, sizeof(sensor->ivsc_name), "%s-%u",
464 acpi_device_hid(sensor->ivsc_adev), sensor->link);
466 nodes[SWNODE_IVSC_HID] = NODE_SENSOR(sensor->ivsc_name,
467 sensor->ivsc_properties);
468 nodes[SWNODE_IVSC_SENSOR_PORT] =
469 NODE_PORT(names->ivsc_sensor_port,
470 &nodes[SWNODE_IVSC_HID]);
471 nodes[SWNODE_IVSC_SENSOR_ENDPOINT] =
472 NODE_ENDPOINT(names->endpoint,
473 &nodes[SWNODE_IVSC_SENSOR_PORT],
474 sensor->ivsc_sensor_ep_properties);
475 nodes[SWNODE_IVSC_IPU_PORT] =
476 NODE_PORT(names->ivsc_ipu_port,
477 &nodes[SWNODE_IVSC_HID]);
478 nodes[SWNODE_IVSC_IPU_ENDPOINT] =
479 NODE_ENDPOINT(names->endpoint,
480 &nodes[SWNODE_IVSC_IPU_PORT],
481 sensor->ivsc_ipu_ep_properties);
484 nodes[SWNODE_VCM] = NODE_VCM(sensor->node_names.vcm);
486 ipu_bridge_init_swnode_group(sensor);
490 * The actual instantiation must be done from a workqueue to avoid
491 * a deadlock on taking list_lock from v4l2-async twice.
493 struct ipu_bridge_instantiate_vcm_work_data {
494 struct work_struct work;
495 struct device *sensor;
497 struct i2c_board_info board_info;
500 static void ipu_bridge_instantiate_vcm_work(struct work_struct *work)
502 struct ipu_bridge_instantiate_vcm_work_data *data =
503 container_of(work, struct ipu_bridge_instantiate_vcm_work_data,
505 struct acpi_device *adev = ACPI_COMPANION(data->sensor);
506 struct i2c_client *vcm_client;
507 bool put_fwnode = true;
511 * The client may get probed before the device_link gets added below
512 * make sure the sensor is powered-up during probe.
514 ret = pm_runtime_get_sync(data->sensor);
516 dev_err(data->sensor, "Error %d runtime-resuming sensor, cannot instantiate VCM\n",
522 * Note the client is created only once and then kept around
523 * even after a rmmod, just like the software-nodes.
525 vcm_client = i2c_acpi_new_device_by_fwnode(acpi_fwnode_handle(adev),
526 1, &data->board_info);
527 if (IS_ERR(vcm_client)) {
528 dev_err(data->sensor, "Error instantiating VCM client: %ld\n",
529 PTR_ERR(vcm_client));
533 device_link_add(&vcm_client->dev, data->sensor, DL_FLAG_PM_RUNTIME);
535 dev_info(data->sensor, "Instantiated %s VCM\n", data->board_info.type);
536 put_fwnode = false; /* Ownership has passed to the i2c-client */
539 pm_runtime_put(data->sensor);
540 put_device(data->sensor);
542 fwnode_handle_put(data->board_info.fwnode);
546 int ipu_bridge_instantiate_vcm(struct device *sensor)
548 struct ipu_bridge_instantiate_vcm_work_data *data;
549 struct fwnode_handle *vcm_fwnode;
550 struct i2c_client *vcm_client;
551 struct acpi_device *adev;
554 adev = ACPI_COMPANION(sensor);
558 vcm_fwnode = fwnode_find_reference(dev_fwnode(sensor), "lens-focus", 0);
559 if (IS_ERR(vcm_fwnode))
562 /* When reloading modules the client will already exist */
563 vcm_client = i2c_find_device_by_fwnode(vcm_fwnode);
565 fwnode_handle_put(vcm_fwnode);
566 put_device(&vcm_client->dev);
570 data = kzalloc(sizeof(*data), GFP_KERNEL);
572 fwnode_handle_put(vcm_fwnode);
576 INIT_WORK(&data->work, ipu_bridge_instantiate_vcm_work);
577 data->sensor = get_device(sensor);
578 snprintf(data->name, sizeof(data->name), "%s-VCM",
579 acpi_dev_name(adev));
580 data->board_info.dev_name = data->name;
581 data->board_info.fwnode = vcm_fwnode;
582 snprintf(data->board_info.type, sizeof(data->board_info.type),
583 "%pfwP", vcm_fwnode);
584 /* Strip "-<link>" postfix */
585 sep = strchrnul(data->board_info.type, '-');
588 queue_work(system_long_wq, &data->work);
592 EXPORT_SYMBOL_NS_GPL(ipu_bridge_instantiate_vcm, INTEL_IPU_BRIDGE);
594 static int ipu_bridge_instantiate_ivsc(struct ipu_sensor *sensor)
596 struct fwnode_handle *fwnode;
598 if (!sensor->csi_dev)
601 fwnode = software_node_fwnode(&sensor->swnodes[SWNODE_IVSC_HID]);
605 set_secondary_fwnode(sensor->csi_dev, fwnode);
610 static void ipu_bridge_unregister_sensors(struct ipu_bridge *bridge)
612 struct ipu_sensor *sensor;
615 for (i = 0; i < bridge->n_sensors; i++) {
616 sensor = &bridge->sensors[i];
617 software_node_unregister_node_group(sensor->group);
618 acpi_dev_put(sensor->adev);
619 put_device(sensor->csi_dev);
620 acpi_dev_put(sensor->ivsc_adev);
624 static int ipu_bridge_connect_sensor(const struct ipu_sensor_config *cfg,
625 struct ipu_bridge *bridge)
627 struct fwnode_handle *fwnode, *primary;
628 struct ipu_sensor *sensor;
629 struct acpi_device *adev;
632 for_each_acpi_dev_match(adev, cfg->hid, NULL, -1) {
633 if (!adev->status.enabled)
636 if (bridge->n_sensors >= IPU_MAX_PORTS) {
638 dev_err(bridge->dev, "Exceeded available IPU ports\n");
642 sensor = &bridge->sensors[bridge->n_sensors];
644 ret = bridge->parse_sensor_fwnode(adev, sensor);
648 snprintf(sensor->name, sizeof(sensor->name), "%s-%u",
649 cfg->hid, sensor->link);
651 ret = ipu_bridge_check_ivsc_dev(sensor, adev);
655 ipu_bridge_create_fwnode_properties(sensor, bridge, cfg);
656 ipu_bridge_create_connection_swnodes(bridge, sensor);
658 ret = software_node_register_node_group(sensor->group);
662 fwnode = software_node_fwnode(&sensor->swnodes[
666 goto err_free_swnodes;
669 sensor->adev = acpi_dev_get(adev);
671 primary = acpi_fwnode_handle(adev);
672 primary->secondary = fwnode;
674 ret = ipu_bridge_instantiate_ivsc(sensor);
676 goto err_free_swnodes;
678 dev_info(bridge->dev, "Found supported sensor %s\n",
679 acpi_dev_name(adev));
687 software_node_unregister_node_group(sensor->group);
689 put_device(sensor->csi_dev);
690 acpi_dev_put(sensor->ivsc_adev);
696 static int ipu_bridge_connect_sensors(struct ipu_bridge *bridge)
701 for (i = 0; i < ARRAY_SIZE(ipu_supported_sensors); i++) {
702 const struct ipu_sensor_config *cfg =
703 &ipu_supported_sensors[i];
705 ret = ipu_bridge_connect_sensor(cfg, bridge);
707 goto err_unregister_sensors;
712 err_unregister_sensors:
713 ipu_bridge_unregister_sensors(bridge);
717 static int ipu_bridge_ivsc_is_ready(void)
719 struct acpi_device *sensor_adev, *adev;
720 struct device *csi_dev;
724 for (i = 0; i < ARRAY_SIZE(ipu_supported_sensors); i++) {
725 const struct ipu_sensor_config *cfg =
726 &ipu_supported_sensors[i];
728 for_each_acpi_dev_match(sensor_adev, cfg->hid, NULL, -1) {
729 if (!sensor_adev->status.enabled)
732 adev = ipu_bridge_get_ivsc_acpi_dev(sensor_adev);
736 csi_dev = ipu_bridge_get_ivsc_csi_dev(adev);
748 int ipu_bridge_init(struct device *dev,
749 ipu_parse_sensor_fwnode_t parse_sensor_fwnode)
751 struct fwnode_handle *fwnode;
752 struct ipu_bridge *bridge;
756 if (!ipu_bridge_ivsc_is_ready())
757 return -EPROBE_DEFER;
759 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
763 strscpy(bridge->ipu_node_name, IPU_HID,
764 sizeof(bridge->ipu_node_name));
765 bridge->ipu_hid_node.name = bridge->ipu_node_name;
767 bridge->parse_sensor_fwnode = parse_sensor_fwnode;
769 ret = software_node_register(&bridge->ipu_hid_node);
771 dev_err(dev, "Failed to register the IPU HID node\n");
772 goto err_free_bridge;
776 * Map the lane arrangement, which is fixed for the IPU3 (meaning we
777 * only need one, rather than one per sensor). We include it as a
778 * member of the struct ipu_bridge rather than a global variable so
779 * that it survives if the module is unloaded along with the rest of
782 for (i = 0; i < IPU_MAX_LANES; i++)
783 bridge->data_lanes[i] = i + 1;
785 ret = ipu_bridge_connect_sensors(bridge);
786 if (ret || bridge->n_sensors == 0)
787 goto err_unregister_ipu;
789 dev_info(dev, "Connected %d cameras\n", bridge->n_sensors);
791 fwnode = software_node_fwnode(&bridge->ipu_hid_node);
793 dev_err(dev, "Error getting fwnode from ipu software_node\n");
795 goto err_unregister_sensors;
798 set_secondary_fwnode(dev, fwnode);
802 err_unregister_sensors:
803 ipu_bridge_unregister_sensors(bridge);
805 software_node_unregister(&bridge->ipu_hid_node);
811 EXPORT_SYMBOL_NS_GPL(ipu_bridge_init, INTEL_IPU_BRIDGE);
813 MODULE_LICENSE("GPL");
814 MODULE_DESCRIPTION("Intel IPU Sensors Bridge driver");