// SPDX-License-Identifier: GPL-2.0 /* * Code to build software firmware node graph for atomisp2 connected sensors * from ACPI tables. * * Copyright (C) 2023 Hans de Goede * * Based on drivers/media/pci/intel/ipu3/cio2-bridge.c written by: * Dan Scally */ #include #include #include #include #include #include #include "atomisp_cmd.h" #include "atomisp_csi2.h" #include "atomisp_internal.h" #define NODE_SENSOR(_HID, _PROPS) \ ((const struct software_node) { \ .name = _HID, \ .properties = _PROPS, \ }) #define NODE_PORT(_PORT, _SENSOR_NODE) \ ((const struct software_node) { \ .name = _PORT, \ .parent = _SENSOR_NODE, \ }) #define NODE_ENDPOINT(_EP, _PORT, _PROPS) \ ((const struct software_node) { \ .name = _EP, \ .parent = _PORT, \ .properties = _PROPS, \ }) #define PMC_CLK_RATE_19_2MHZ 19200000 /* * 79234640-9e10-4fea-a5c1-b5aa8b19756f * This _DSM GUID returns information about the GPIO lines mapped to a sensor. * Function number 1 returns a count of the GPIO lines that are mapped. * Subsequent functions return 32 bit ints encoding information about the GPIO. */ static const guid_t intel_sensor_gpio_info_guid = GUID_INIT(0x79234640, 0x9e10, 0x4fea, 0xa5, 0xc1, 0xb5, 0xaa, 0x8b, 0x19, 0x75, 0x6f); #define INTEL_GPIO_DSM_TYPE_SHIFT 0 #define INTEL_GPIO_DSM_TYPE_MASK GENMASK(7, 0) #define INTEL_GPIO_DSM_PIN_SHIFT 8 #define INTEL_GPIO_DSM_PIN_MASK GENMASK(15, 8) #define INTEL_GPIO_DSM_SENSOR_ON_VAL_SHIFT 24 #define INTEL_GPIO_DSM_SENSOR_ON_VAL_MASK GENMASK(31, 24) #define INTEL_GPIO_DSM_TYPE(x) \ (((x) & INTEL_GPIO_DSM_TYPE_MASK) >> INTEL_GPIO_DSM_TYPE_SHIFT) #define INTEL_GPIO_DSM_PIN(x) \ (((x) & INTEL_GPIO_DSM_PIN_MASK) >> INTEL_GPIO_DSM_PIN_SHIFT) #define INTEL_GPIO_DSM_SENSOR_ON_VAL(x) \ (((x) & INTEL_GPIO_DSM_SENSOR_ON_VAL_MASK) >> INTEL_GPIO_DSM_SENSOR_ON_VAL_SHIFT) /* * 822ace8f-2814-4174-a56b-5f029fe079ee * This _DSM GUID returns a string from the sensor device, which acts as a * module identifier. */ static const guid_t intel_sensor_module_guid = GUID_INIT(0x822ace8f, 0x2814, 0x4174, 0xa5, 0x6b, 0x5f, 0x02, 0x9f, 0xe0, 0x79, 0xee); /* * dc2f6c4f-045b-4f1d-97b9-882a6860a4be * This _DSM GUID returns a package with n*2 strings, with each set of 2 strings * forming a key, value pair for settings like e.g. "CsiLanes" = "1". */ static const guid_t atomisp_dsm_guid = GUID_INIT(0xdc2f6c4f, 0x045b, 0x4f1d, 0x97, 0xb9, 0x88, 0x2a, 0x68, 0x60, 0xa4, 0xbe); /* * Extend this array with ACPI Hardware IDs of sensors known to be working * plus the default number of links + link-frequencies. * * Do not add an entry for a sensor that is not actually supported, * or which have not yet been converted to work without atomisp_gmin * power-management and with v4l2-async probing. */ static const struct atomisp_csi2_sensor_config supported_sensors[] = { /* GalaxyCore GC0310 */ { "INT0310", 1 }, /* Omnivision OV2680 */ { "OVTI2680", 1 }, }; /* * gmin_cfg parsing code. This is a cleaned up version of the gmin_cfg parsing * code from atomisp_gmin_platform.c. * Once all sensors are moved to v4l2-async probing atomisp_gmin_platform.c can * be removed and the duplication of this code goes away. */ struct gmin_cfg_var { const char *acpi_dev_name; const char *key; const char *val; }; static struct gmin_cfg_var lenovo_ideapad_miix_310_vars[] = { /* _DSM contains the wrong CsiPort! */ { "OVTI2680:01", "CsiPort", "0" }, {} }; static const struct dmi_system_id gmin_cfg_dmi_overrides[] = { { /* Lenovo Ideapad Miix 310 */ .matches = { DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), DMI_MATCH(DMI_PRODUCT_VERSION, "MIIX 310-10"), }, .driver_data = lenovo_ideapad_miix_310_vars, }, {} }; static char *gmin_cfg_get_dsm(struct acpi_device *adev, const char *key) { union acpi_object *obj, *key_el, *val_el; char *val = NULL; int i; obj = acpi_evaluate_dsm_typed(adev->handle, &atomisp_dsm_guid, 0, 0, NULL, ACPI_TYPE_PACKAGE); if (!obj) return NULL; for (i = 0; i < obj->package.count - 1; i += 2) { key_el = &obj->package.elements[i + 0]; val_el = &obj->package.elements[i + 1]; if (key_el->type != ACPI_TYPE_STRING || val_el->type != ACPI_TYPE_STRING) break; if (!strcmp(key_el->string.pointer, key)) { val = kstrdup(val_el->string.pointer, GFP_KERNEL); if (!val) break; acpi_handle_info(adev->handle, "Using DSM entry %s=%s\n", key, val); break; } } ACPI_FREE(obj); return val; } static char *gmin_cfg_get_dmi_override(struct acpi_device *adev, const char *key) { const struct dmi_system_id *id; struct gmin_cfg_var *gv; id = dmi_first_match(gmin_cfg_dmi_overrides); if (!id) return NULL; for (gv = id->driver_data; gv->acpi_dev_name; gv++) { if (strcmp(gv->acpi_dev_name, acpi_dev_name(adev))) continue; if (strcmp(key, gv->key)) continue; acpi_handle_info(adev->handle, "Using DMI entry %s=%s\n", key, gv->val); return kstrdup(gv->val, GFP_KERNEL); } return NULL; } static char *gmin_cfg_get(struct acpi_device *adev, const char *key) { char *val; val = gmin_cfg_get_dmi_override(adev, key); if (val) return val; return gmin_cfg_get_dsm(adev, key); } static int gmin_cfg_get_int(struct acpi_device *adev, const char *key, int default_val) { char *str_val; long int_val; int ret; str_val = gmin_cfg_get(adev, key); if (!str_val) goto out_use_default; ret = kstrtoul(str_val, 0, &int_val); kfree(str_val); if (ret) goto out_use_default; return int_val; out_use_default: acpi_handle_info(adev->handle, "Using default %s=%d\n", key, default_val); return default_val; } static int atomisp_csi2_get_pmc_clk_nr_from_acpi_pr0(struct acpi_device *adev) { /* ACPI_PATH_SEGMENT_LENGTH is guaranteed to be big enough for name + 0 term. */ char name[ACPI_PATH_SEGMENT_LENGTH]; struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; struct acpi_buffer b_name = { sizeof(name), name }; union acpi_object *package, *element; int i, ret = -ENOENT; acpi_handle rhandle; acpi_status status; u8 clock_num; status = acpi_evaluate_object_typed(adev->handle, "_PR0", NULL, &buffer, ACPI_TYPE_PACKAGE); if (ACPI_FAILURE(status)) return -ENOENT; package = buffer.pointer; for (i = 0; i < package->package.count; i++) { element = &package->package.elements[i]; if (element->type != ACPI_TYPE_LOCAL_REFERENCE) continue; rhandle = element->reference.handle; if (!rhandle) continue; acpi_get_name(rhandle, ACPI_SINGLE_NAME, &b_name); if (str_has_prefix(name, "CLK") && !kstrtou8(&name[3], 10, &clock_num) && clock_num <= 4) { ret = clock_num; break; } } ACPI_FREE(buffer.pointer); if (ret < 0) acpi_handle_warn(adev->handle, "Could not find PMC clk in _PR0\n"); return ret; } static int atomisp_csi2_set_pmc_clk_freq(struct acpi_device *adev, int clock_num) { struct clk *clk; char name[14]; int ret; if (clock_num < 0) return 0; snprintf(name, sizeof(name), "pmc_plt_clk_%d", clock_num); clk = clk_get(NULL, name); if (IS_ERR(clk)) { ret = PTR_ERR(clk); acpi_handle_err(adev->handle, "Error getting clk %s:%d\n", name, ret); return ret; } /* * The firmware might enable the clock at boot, to change * the rate we must ensure the clock is disabled. */ ret = clk_prepare_enable(clk); if (!ret) clk_disable_unprepare(clk); if (!ret) ret = clk_set_rate(clk, PMC_CLK_RATE_19_2MHZ); if (ret) acpi_handle_err(adev->handle, "Error setting clk-rate for %s:%d\n", name, ret); clk_put(clk); return ret; } static int atomisp_csi2_get_port(struct acpi_device *adev, int clock_num) { int port; /* * Compare clock-number to the PMC-clock used for CsiPort 1 * in the CHT/BYT reference designs. */ if (IS_ISP2401) port = clock_num == 4 ? 1 : 0; else port = clock_num == 0 ? 1 : 0; /* Intel DSM or DMI quirk overrides _PR0 CLK derived default */ return gmin_cfg_get_int(adev, "CsiPort", port); } /* Note this always returns 1 to continue looping so that res_count is accurate */ static int atomisp_csi2_handle_acpi_gpio_res(struct acpi_resource *ares, void *_data) { struct atomisp_csi2_acpi_gpio_parsing_data *data = _data; struct acpi_resource_gpio *agpio; const char *name; bool active_low; unsigned int i; u32 settings = 0; u16 pin; if (!acpi_gpio_get_io_resource(ares, &agpio)) return 1; /* Not a GPIO, continue the loop */ data->res_count++; pin = agpio->pin_table[0]; for (i = 0; i < data->settings_count; i++) { if (INTEL_GPIO_DSM_PIN(data->settings[i]) == pin) { settings = data->settings[i]; break; } } if (i == data->settings_count) { acpi_handle_warn(data->adev->handle, "Could not find DSM GPIO settings for pin %u\n", pin); return 1; } switch (INTEL_GPIO_DSM_TYPE(settings)) { case 0: name = "reset-gpios"; break; case 1: name = "powerdown-gpios"; break; default: acpi_handle_warn(data->adev->handle, "Unknown GPIO type 0x%02lx for pin %u\n", INTEL_GPIO_DSM_TYPE(settings), pin); return 1; } /* * Both reset and power-down need to be logical false when the sensor * is on (sensor should not be in reset and not be powered-down). So * when the sensor-on-value (which is the physical pin value) is high, * then the signal is active-low. */ active_low = INTEL_GPIO_DSM_SENSOR_ON_VAL(settings); i = data->map_count; if (i == CSI2_MAX_ACPI_GPIOS) return 1; /* res_count is already incremented */ data->map->params[i].crs_entry_index = data->res_count - 1; data->map->params[i].active_low = active_low; data->map->mapping[i].name = name; data->map->mapping[i].data = &data->map->params[i]; data->map->mapping[i].size = 1; data->map_count++; acpi_handle_info(data->adev->handle, "%s crs %d %s pin %u active-%s\n", name, data->res_count - 1, agpio->resource_source.string_ptr, pin, active_low ? "low" : "high"); return 1; } /* * Helper function to create an ACPI GPIO lookup table for sensor reset and * powerdown signals on Intel Bay Trail (BYT) and Cherry Trail (CHT) devices, * including setting the correct polarity for the GPIO. * * This uses the "79234640-9e10-4fea-a5c1-b5aa8b19756f" DSM method directly * on the sensor device's ACPI node. This is different from later Intel * hardware which has a separate INT3472 acpi_device with this info. * * This function must be called before creating the sw-noded describing * the fwnode graph endpoint. And sensor drivers used on these devices * must return -EPROBE_DEFER when there is no endpoint description yet. * Together this guarantees that the GPIO lookups are in place before * the sensor driver tries to get GPIOs with gpiod_get(). * * Note this code uses the same DSM GUID as the int3472_gpio_guid in * the INT3472 discrete.c code and there is some overlap, but there are * enough differences that it is difficult to share the code. */ static int atomisp_csi2_add_gpio_mappings(struct atomisp_csi2_sensor *sensor, struct acpi_device *adev) { struct atomisp_csi2_acpi_gpio_parsing_data data = { }; LIST_HEAD(resource_list); union acpi_object *obj; unsigned int i, j; int ret; obj = acpi_evaluate_dsm_typed(adev->handle, &intel_sensor_module_guid, 0x00, 1, NULL, ACPI_TYPE_STRING); if (obj) { acpi_handle_info(adev->handle, "Sensor module id: '%s'\n", obj->string.pointer); ACPI_FREE(obj); } /* * First get the GPIO-settings count and then get count GPIO-settings * values. Note the order of these may differ from the order in which * the GPIOs are listed on the ACPI resources! So we first store them all * and then enumerate the ACPI resources and match them up by pin number. */ obj = acpi_evaluate_dsm_typed(adev->handle, &intel_sensor_gpio_info_guid, 0x00, 1, NULL, ACPI_TYPE_INTEGER); if (!obj) { acpi_handle_err(adev->handle, "No _DSM entry for GPIO pin count\n"); return -EIO; } data.settings_count = obj->integer.value; ACPI_FREE(obj); if (data.settings_count > CSI2_MAX_ACPI_GPIOS) { acpi_handle_err(adev->handle, "Too many GPIOs %u > %u\n", data.settings_count, CSI2_MAX_ACPI_GPIOS); return -EOVERFLOW; } for (i = 0; i < data.settings_count; i++) { /* * i + 2 because the index of this _DSM function is 1-based * and the first function is just a count. */ obj = acpi_evaluate_dsm_typed(adev->handle, &intel_sensor_gpio_info_guid, 0x00, i + 2, NULL, ACPI_TYPE_INTEGER); if (!obj) { acpi_handle_err(adev->handle, "No _DSM entry for pin %u\n", i); return -EIO; } data.settings[i] = obj->integer.value; ACPI_FREE(obj); } /* Since we match up by pin-number the pin-numbers must be unique */ for (i = 0; i < data.settings_count; i++) { for (j = i + 1; j < data.settings_count; j++) { if (INTEL_GPIO_DSM_PIN(data.settings[i]) != INTEL_GPIO_DSM_PIN(data.settings[j])) continue; acpi_handle_err(adev->handle, "Duplicate pin number %lu\n", INTEL_GPIO_DSM_PIN(data.settings[i])); return -EIO; } } /* Now parse the ACPI resources and build the lookup table */ data.adev = adev; data.map = &sensor->gpio_map; ret = acpi_dev_get_resources(adev, &resource_list, atomisp_csi2_handle_acpi_gpio_res, &data); if (ret < 0) return ret; acpi_dev_free_resource_list(&resource_list); if (data.map_count != data.settings_count || data.res_count != data.settings_count) acpi_handle_warn(adev->handle, "ACPI GPIO resources vs DSM GPIO-info count mismatch (dsm: %d res: %d map %d\n", data.settings_count, data.res_count, data.map_count); ret = acpi_dev_add_driver_gpios(adev, data.map->mapping); if (ret) acpi_handle_err(adev->handle, "Error adding driver GPIOs: %d\n", ret); return ret; } static const struct atomisp_csi2_property_names prop_names = { .clock_frequency = "clock-frequency", .rotation = "rotation", .bus_type = "bus-type", .data_lanes = "data-lanes", .remote_endpoint = "remote-endpoint", .link_frequencies = "link-frequencies", }; static void atomisp_csi2_create_fwnode_properties(struct atomisp_csi2_sensor *sensor, struct atomisp_csi2_bridge *bridge, const struct atomisp_csi2_sensor_config *cfg) { sensor->prop_names = prop_names; sensor->local_ref[0] = SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_CSI2_ENDPOINT]); sensor->remote_ref[0] = SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_SENSOR_ENDPOINT]); sensor->dev_properties[0] = PROPERTY_ENTRY_U32(sensor->prop_names.clock_frequency, PMC_CLK_RATE_19_2MHZ); sensor->dev_properties[1] = PROPERTY_ENTRY_U32(sensor->prop_names.rotation, 0); sensor->ep_properties[0] = PROPERTY_ENTRY_U32(sensor->prop_names.bus_type, V4L2_FWNODE_BUS_TYPE_CSI2_DPHY); sensor->ep_properties[1] = PROPERTY_ENTRY_U32_ARRAY_LEN(sensor->prop_names.data_lanes, bridge->data_lanes, sensor->lanes); sensor->ep_properties[2] = PROPERTY_ENTRY_REF_ARRAY(sensor->prop_names.remote_endpoint, sensor->local_ref); if (cfg->nr_link_freqs > 0) sensor->ep_properties[3] = PROPERTY_ENTRY_U64_ARRAY_LEN(sensor->prop_names.link_frequencies, cfg->link_freqs, cfg->nr_link_freqs); sensor->csi2_properties[0] = PROPERTY_ENTRY_U32_ARRAY_LEN(sensor->prop_names.data_lanes, bridge->data_lanes, sensor->lanes); sensor->csi2_properties[1] = PROPERTY_ENTRY_REF_ARRAY(sensor->prop_names.remote_endpoint, sensor->remote_ref); } static void atomisp_csi2_init_swnode_names(struct atomisp_csi2_sensor *sensor) { snprintf(sensor->node_names.remote_port, sizeof(sensor->node_names.remote_port), SWNODE_GRAPH_PORT_NAME_FMT, sensor->port); snprintf(sensor->node_names.port, sizeof(sensor->node_names.port), SWNODE_GRAPH_PORT_NAME_FMT, 0); /* Always port 0 */ snprintf(sensor->node_names.endpoint, sizeof(sensor->node_names.endpoint), SWNODE_GRAPH_ENDPOINT_NAME_FMT, 0); /* And endpoint 0 */ } static void atomisp_csi2_init_swnode_group(struct atomisp_csi2_sensor *sensor) { struct software_node *nodes = sensor->swnodes; sensor->group[SWNODE_SENSOR] = &nodes[SWNODE_SENSOR]; sensor->group[SWNODE_SENSOR_PORT] = &nodes[SWNODE_SENSOR_PORT]; sensor->group[SWNODE_SENSOR_ENDPOINT] = &nodes[SWNODE_SENSOR_ENDPOINT]; sensor->group[SWNODE_CSI2_PORT] = &nodes[SWNODE_CSI2_PORT]; sensor->group[SWNODE_CSI2_ENDPOINT] = &nodes[SWNODE_CSI2_ENDPOINT]; } static void atomisp_csi2_create_connection_swnodes(struct atomisp_csi2_bridge *bridge, struct atomisp_csi2_sensor *sensor) { struct software_node *nodes = sensor->swnodes; atomisp_csi2_init_swnode_names(sensor); nodes[SWNODE_SENSOR] = NODE_SENSOR(sensor->name, sensor->dev_properties); nodes[SWNODE_SENSOR_PORT] = NODE_PORT(sensor->node_names.port, &nodes[SWNODE_SENSOR]); nodes[SWNODE_SENSOR_ENDPOINT] = NODE_ENDPOINT(sensor->node_names.endpoint, &nodes[SWNODE_SENSOR_PORT], sensor->ep_properties); nodes[SWNODE_CSI2_PORT] = NODE_PORT(sensor->node_names.remote_port, &bridge->csi2_node); nodes[SWNODE_CSI2_ENDPOINT] = NODE_ENDPOINT(sensor->node_names.endpoint, &nodes[SWNODE_CSI2_PORT], sensor->csi2_properties); atomisp_csi2_init_swnode_group(sensor); } static void atomisp_csi2_unregister_sensors(struct atomisp_csi2_bridge *bridge) { struct atomisp_csi2_sensor *sensor; unsigned int i; for (i = 0; i < bridge->n_sensors; i++) { sensor = &bridge->sensors[i]; software_node_unregister_node_group(sensor->group); acpi_dev_remove_driver_gpios(sensor->adev); acpi_dev_put(sensor->adev); } } static int atomisp_csi2_connect_sensor(const struct atomisp_csi2_sensor_config *cfg, struct atomisp_csi2_bridge *bridge, struct atomisp_device *isp) { struct fwnode_handle *fwnode, *primary; struct atomisp_csi2_sensor *sensor; struct acpi_device *adev; int ret, clock_num; for_each_acpi_dev_match(adev, cfg->hid, NULL, -1) { if (!adev->status.enabled) continue; if (bridge->n_sensors >= ATOMISP_CAMERA_NR_PORTS) { dev_err(isp->dev, "Exceeded available CSI2 ports\n"); ret = -EOVERFLOW; goto err_put_adev; } sensor = &bridge->sensors[bridge->n_sensors]; /* * ACPI takes care of turning the PMC clock on and off, but on BYT * the clock defaults to 25 MHz instead of the expected 19.2 MHz. * Get the PMC-clock number from ACPI _PR0 method and set it to 19.2 MHz. * The PMC-clock number is also used to determine the default CSI port. */ clock_num = atomisp_csi2_get_pmc_clk_nr_from_acpi_pr0(adev); ret = atomisp_csi2_set_pmc_clk_freq(adev, clock_num); if (ret) goto err_put_adev; sensor->port = atomisp_csi2_get_port(adev, clock_num); if (sensor->port >= ATOMISP_CAMERA_NR_PORTS) { acpi_handle_err(adev->handle, "Invalid port: %d\n", sensor->port); ret = -EINVAL; goto err_put_adev; } sensor->lanes = gmin_cfg_get_int(adev, "CsiLanes", cfg->lanes); if (sensor->lanes > CSI2_MAX_LANES) { acpi_handle_err(adev->handle, "Invalid number of lanes: %d\n", sensor->lanes); ret = -EINVAL; goto err_put_adev; } ret = atomisp_csi2_add_gpio_mappings(sensor, adev); if (ret) goto err_put_adev; snprintf(sensor->name, sizeof(sensor->name), "%s-%u", cfg->hid, sensor->port); atomisp_csi2_create_fwnode_properties(sensor, bridge, cfg); atomisp_csi2_create_connection_swnodes(bridge, sensor); ret = software_node_register_node_group(sensor->group); if (ret) goto err_remove_mappings; fwnode = software_node_fwnode(&sensor->swnodes[SWNODE_SENSOR]); if (!fwnode) { ret = -ENODEV; goto err_free_swnodes; } sensor->adev = acpi_dev_get(adev); primary = acpi_fwnode_handle(adev); primary->secondary = fwnode; bridge->n_sensors++; } return 0; err_free_swnodes: software_node_unregister_node_group(sensor->group); err_remove_mappings: acpi_dev_remove_driver_gpios(adev); err_put_adev: acpi_dev_put(adev); return ret; } static int atomisp_csi2_connect_sensors(struct atomisp_csi2_bridge *bridge, struct atomisp_device *isp) { unsigned int i; int ret; for (i = 0; i < ARRAY_SIZE(supported_sensors); i++) { const struct atomisp_csi2_sensor_config *cfg = &supported_sensors[i]; ret = atomisp_csi2_connect_sensor(cfg, bridge, isp); if (ret) goto err_unregister_sensors; } return 0; err_unregister_sensors: atomisp_csi2_unregister_sensors(bridge); return ret; } int atomisp_csi2_bridge_init(struct atomisp_device *isp) { struct atomisp_csi2_bridge *bridge; struct device *dev = isp->dev; struct fwnode_handle *fwnode; int i, ret; /* * This function is intended to run only once and then leave * the created nodes attached even after a rmmod, therefore: * 1. The bridge memory is leaked deliberately on success * 2. If a secondary fwnode is already set exit early. */ fwnode = dev_fwnode(dev); if (fwnode && fwnode->secondary) return 0; bridge = kzalloc(sizeof(*bridge), GFP_KERNEL); if (!bridge) return -ENOMEM; strscpy(bridge->csi2_node_name, "atomisp-csi2", sizeof(bridge->csi2_node_name)); bridge->csi2_node.name = bridge->csi2_node_name; ret = software_node_register(&bridge->csi2_node); if (ret < 0) { dev_err(dev, "Failed to register the CSI2 HID node\n"); goto err_free_bridge; } /* * Map the lane arrangement, which is fixed for the ISP2 (meaning we * only need one, rather than one per sensor). We include it as a * member of the bridge struct rather than a global variable so * that it survives if the module is unloaded along with the rest of * the struct. */ for (i = 0; i < CSI2_MAX_LANES; i++) bridge->data_lanes[i] = i + 1; ret = atomisp_csi2_connect_sensors(bridge, isp); if (ret || bridge->n_sensors == 0) goto err_unregister_csi2; fwnode = software_node_fwnode(&bridge->csi2_node); if (!fwnode) { dev_err(dev, "Error getting fwnode from csi2 software_node\n"); ret = -ENODEV; goto err_unregister_sensors; } set_secondary_fwnode(dev, fwnode); return 0; err_unregister_sensors: atomisp_csi2_unregister_sensors(bridge); err_unregister_csi2: software_node_unregister(&bridge->csi2_node); err_free_bridge: kfree(bridge); return ret; } /******* V4L2 sub-device asynchronous registration callbacks***********/ struct sensor_async_subdev { struct v4l2_async_subdev asd; int port; }; #define to_sensor_asd(a) container_of(a, struct sensor_async_subdev, asd) #define notifier_to_atomisp(n) container_of(n, struct atomisp_device, notifier) /* .bound() notifier callback when a match is found */ static int atomisp_notifier_bound(struct v4l2_async_notifier *notifier, struct v4l2_subdev *sd, struct v4l2_async_subdev *asd) { struct atomisp_device *isp = notifier_to_atomisp(notifier); struct sensor_async_subdev *s_asd = to_sensor_asd(asd); if (s_asd->port >= ATOMISP_CAMERA_NR_PORTS) { dev_err(isp->dev, "port %d not supported\n", s_asd->port); return -EINVAL; } if (isp->sensor_subdevs[s_asd->port]) { dev_err(isp->dev, "port %d already has a sensor attached\n", s_asd->port); return -EBUSY; } isp->sensor_subdevs[s_asd->port] = sd; return 0; } /* The .unbind callback */ static void atomisp_notifier_unbind(struct v4l2_async_notifier *notifier, struct v4l2_subdev *sd, struct v4l2_async_subdev *asd) { struct atomisp_device *isp = notifier_to_atomisp(notifier); struct sensor_async_subdev *s_asd = to_sensor_asd(asd); isp->sensor_subdevs[s_asd->port] = NULL; } /* .complete() is called after all subdevices have been located */ static int atomisp_notifier_complete(struct v4l2_async_notifier *notifier) { struct atomisp_device *isp = notifier_to_atomisp(notifier); return atomisp_register_device_nodes(isp); } static const struct v4l2_async_notifier_operations atomisp_async_ops = { .bound = atomisp_notifier_bound, .unbind = atomisp_notifier_unbind, .complete = atomisp_notifier_complete, }; int atomisp_csi2_bridge_parse_firmware(struct atomisp_device *isp) { int i, mipi_port, ret; v4l2_async_nf_init(&isp->notifier); isp->notifier.ops = &atomisp_async_ops; for (i = 0; i < ATOMISP_CAMERA_NR_PORTS; i++) { struct v4l2_fwnode_endpoint vep = { .bus_type = V4L2_MBUS_CSI2_DPHY, }; struct sensor_async_subdev *s_asd; struct fwnode_handle *ep; ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(isp->dev), i, 0, FWNODE_GRAPH_ENDPOINT_NEXT); if (!ep) continue; ret = v4l2_fwnode_endpoint_parse(ep, &vep); if (ret) goto err_parse; if (vep.base.port >= ATOMISP_CAMERA_NR_PORTS) { dev_err(isp->dev, "port %d not supported\n", vep.base.port); ret = -EINVAL; goto err_parse; } mipi_port = atomisp_port_to_mipi_port(isp, vep.base.port); isp->sensor_lanes[mipi_port] = vep.bus.mipi_csi2.num_data_lanes; s_asd = v4l2_async_nf_add_fwnode_remote(&isp->notifier, ep, struct sensor_async_subdev); if (IS_ERR(s_asd)) { ret = PTR_ERR(s_asd); goto err_parse; } s_asd->port = vep.base.port; fwnode_handle_put(ep); continue; err_parse: fwnode_handle_put(ep); return ret; } return 0; }