Re: [PATCH 9/9] media: atomisp: Add support for v4l2-async sensor registration

[Hans de Goede <hdegoede@redhat.com>]

Hi,

On 5/18/23 17:37, Hans de Goede wrote:
> WIP
> 
> Signed-off-by: Hans de Goede <hdegoede@redhat.com>

My bad I forgot to update the commit message after finishing my work on this.

Here is the new commit msg now in my local tree:

"""
media: atomisp: Add support for v4l2-async sensor registration

Add support for using v4l2-async sensor registration.

This has been tested with both the gc0310 and the ov2680 sensor drivers.

Drivers should add the ACPI HIDs they match on to the supported_sensors[]
array in the same commit as that they are convered to
v4l2_async_register_subdev_sensor().

For now it also is still possible to use the old atomisp_gmin_platform
based sensor drivers. This is mainly intended for testing while moving
"""

I have also made the supported_sensors[] array empty in my tree and
moved the addition of the INT0310 and OVTI2680 HIDs to the commits
converting the 2 sensor drivers to v4l2_async_register_subdev_sensor(),
so that there is no intermittend state where the sensors will not work.

Regards,

Hans



> ---
>  drivers/staging/media/atomisp/Makefile        |   1 +
>  .../staging/media/atomisp/pci/atomisp_csi2.c  |   4 +
>  .../staging/media/atomisp/pci/atomisp_csi2.h  |  64 ++
>  .../media/atomisp/pci/atomisp_csi2_bridge.c   | 592 ++++++++++++++++++
>  .../media/atomisp/pci/atomisp_internal.h      |   2 +
>  .../staging/media/atomisp/pci/atomisp_v4l2.c  |  38 +-
>  .../staging/media/atomisp/pci/atomisp_v4l2.h  |   1 +
>  7 files changed, 681 insertions(+), 21 deletions(-)
>  create mode 100644 drivers/staging/media/atomisp/pci/atomisp_csi2_bridge.c
> 
> diff --git a/drivers/staging/media/atomisp/Makefile b/drivers/staging/media/atomisp/Makefile
> index 532e12ed72e6..38b370124109 100644
> --- a/drivers/staging/media/atomisp/Makefile
> +++ b/drivers/staging/media/atomisp/Makefile
> @@ -16,6 +16,7 @@ atomisp-objs += \
>  	pci/atomisp_cmd.o \
>  	pci/atomisp_compat_css20.o \
>  	pci/atomisp_csi2.o \
> +	pci/atomisp_csi2_bridge.o \
>  	pci/atomisp_drvfs.o \
>  	pci/atomisp_fops.o \
>  	pci/atomisp_ioctl.o \
> diff --git a/drivers/staging/media/atomisp/pci/atomisp_csi2.c b/drivers/staging/media/atomisp/pci/atomisp_csi2.c
> index 0045c4d3a7f6..abf55a86f795 100644
> --- a/drivers/staging/media/atomisp/pci/atomisp_csi2.c
> +++ b/drivers/staging/media/atomisp/pci/atomisp_csi2.c
> @@ -371,6 +371,10 @@ int atomisp_mipi_csi2_init(struct atomisp_device *isp)
>  	unsigned int i;
>  	int ret;
>  
> +	ret = atomisp_csi2_bridge_init(isp);
> +	if (ret < 0)
> +		return ret;
> +
>  	for (i = 0; i < ATOMISP_CAMERA_NR_PORTS; i++) {
>  		csi2_port = &isp->csi2_port[i];
>  		csi2_port->isp = isp;
> diff --git a/drivers/staging/media/atomisp/pci/atomisp_csi2.h b/drivers/staging/media/atomisp/pci/atomisp_csi2.h
> index b245b2f5ce99..c714202db52a 100644
> --- a/drivers/staging/media/atomisp/pci/atomisp_csi2.h
> +++ b/drivers/staging/media/atomisp/pci/atomisp_csi2.h
> @@ -21,14 +21,76 @@
>  #include <media/v4l2-subdev.h>
>  #include <media/v4l2-ctrls.h>
>  
> +#include "../../include/linux/atomisp.h"
> +
>  #define CSI2_PAD_SINK		0
>  #define CSI2_PAD_SOURCE		1
>  #define CSI2_PADS_NUM		2
>  
> +#define CSI2_MAX_LANES		4
> +
>  struct atomisp_device;
>  struct v4l2_device;
>  struct atomisp_sub_device;
>  
> +enum atomisp_csi2_sensor_swnodes {
> +	SWNODE_SENSOR,
> +	SWNODE_SENSOR_PORT,
> +	SWNODE_SENSOR_ENDPOINT,
> +	SWNODE_CSI2_PORT,
> +	SWNODE_CSI2_ENDPOINT,
> +	SWNODE_COUNT
> +};
> +
> +struct atomisp_csi2_property_names {
> +	char rotation[9];
> +	char bus_type[9];
> +	char data_lanes[11];
> +	char remote_endpoint[16];
> +};
> +
> +struct atomisp_csi2_node_names {
> +	char port[7];
> +	char endpoint[11];
> +	char remote_port[7];
> +};
> +
> +struct atomisp_csi2_sensor_config {
> +	const char *hid;
> +	int lanes;
> +};
> +
> +struct atomisp_csi2_sensor {
> +	/* Append port in "-%u" format as suffix of HID */
> +	char name[ACPI_ID_LEN + 4];
> +	struct acpi_device *adev;
> +	int port;
> +	int lanes;
> +
> +	/* SWNODE_COUNT + 1 for terminating NULL */
> +	const struct software_node *group[SWNODE_COUNT + 1];
> +	struct software_node swnodes[SWNODE_COUNT];
> +	struct atomisp_csi2_node_names node_names;
> +	struct atomisp_csi2_property_names prop_names;
> +	/* "rotation" + terminating entry */
> +	struct property_entry dev_properties[2];
> +	/* "bus-type", "data-lanes", "remote-endpoint" + terminating entry */
> +	struct property_entry ep_properties[4];
> +	/* "data-lanes", "remote-endpoint" + terminating entry */
> +	struct property_entry csi2_properties[3];
> +	struct software_node_ref_args local_ref[1];
> +	struct software_node_ref_args remote_ref[1];
> +	struct software_node_ref_args vcm_ref[1];
> +};
> +
> +struct atomisp_csi2_bridge {
> +	char csi2_node_name[14];
> +	struct software_node csi2_node;
> +	u32 data_lanes[CSI2_MAX_LANES];
> +	unsigned int n_sensors;
> +	struct atomisp_csi2_sensor sensors[ATOMISP_CAMERA_NR_PORTS];
> +};
> +
>  struct atomisp_mipi_csi2_device {
>  	struct v4l2_subdev subdev;
>  	struct media_pad pads[CSI2_PADS_NUM];
> @@ -48,6 +110,8 @@ void atomisp_mipi_csi2_unregister_entities(
>      struct atomisp_mipi_csi2_device *csi2);
>  int atomisp_mipi_csi2_register_entities(struct atomisp_mipi_csi2_device *csi2,
>  					struct v4l2_device *vdev);
> +int atomisp_csi2_bridge_init(struct atomisp_device *isp);
> +int atomisp_csi2_bridge_parse_firmware(struct atomisp_device *isp);
>  
>  void atomisp_csi2_configure(struct atomisp_sub_device *asd);
>  
> diff --git a/drivers/staging/media/atomisp/pci/atomisp_csi2_bridge.c b/drivers/staging/media/atomisp/pci/atomisp_csi2_bridge.c
> new file mode 100644
> index 000000000000..8539d7f354ae
> --- /dev/null
> +++ b/drivers/staging/media/atomisp/pci/atomisp_csi2_bridge.c
> @@ -0,0 +1,592 @@
> +// 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 <hdegoede@redhat.com>
> + *
> + * Based on drivers/media/pci/intel/ipu3/cio2-bridge.c written by:
> + * Dan Scally <djrscally@gmail.com>
> + */
> +
> +#include <linux/acpi.h>
> +#include <linux/device.h>
> +#include <linux/dmi.h>
> +#include <linux/property.h>
> +#include <media/v4l2-fwnode.h>
> +
> +#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,		\
> +	})
> +
> +/*
> + * Extend this array with ACPI Hardware IDs of sensors known to be working
> + * plus the number of links expected by their drivers.
> + *
> + * 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 const guid_t atomisp_dsm_guid = GUID_INIT(0xdc2f6c4f, 0x045b, 0x4f1d,
> +						 0x97, 0xb9, 0x88, 0x2a,
> +						 0x68, 0x60, 0xa4, 0xbe);
> +
> +static char *gmin_cfg_get_dsm(struct acpi_device *adev, const char *key)
> +{
> +	union acpi_object *obj;
> +	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) {
> +		/* The package should only contain strings */
> +		if (obj->package.elements[i].type != ACPI_TYPE_STRING ||
> +		    obj->package.elements[i + 1].type != ACPI_TYPE_STRING)
> +			break;
> +
> +		if (!strcmp(obj->package.elements[i].string.pointer, key)) {
> +			val = kstrdup(obj->package.elements[i + 1].string.pointer, GFP_KERNEL);
> +			dev_info(&adev->dev, "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;
> +
> +		dev_info(&adev->dev, "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 use_default;
> +
> +	ret = kstrtoul(str_val, 0, &int_val);
> +	kfree(str_val);
> +	if (ret)
> +		goto use_default;
> +
> +	return int_val;
> +
> +use_default:
> +	dev_info(&adev->dev, "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)
> +{
> +	char name[5];
> +	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
> +	struct acpi_buffer b_name = { sizeof(name), name };
> +	union acpi_object *package, *element;
> +	int clock_num = -ENOENT;
> +	acpi_handle rhandle;
> +	acpi_status status;
> +	int i;
> +
> +	status = acpi_evaluate_object(adev->handle, "_PR0", NULL, &buffer);
> +	if (!ACPI_SUCCESS(status))
> +		return -ENOENT;
> +
> +	package = buffer.pointer;
> +
> +	if (!buffer.length || !package || package->type != ACPI_TYPE_PACKAGE)
> +		goto fail;
> +
> +	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 (strlen(name) == 4 && !strncmp(name, "CLK", 3) &&
> +		    name[3] >= '0' && name[3] <= '4') {
> +			clock_num = name[3] - '0';
> +			break;
> +		}
> +	}
> +fail:
> +	ACPI_FREE(buffer.pointer);
> +
> +	return clock_num;
> +}
> +
> +static int atomisp_csi2_get_port(struct acpi_device *adev)
> +{
> +	int clock_num, port;
> +
> +	/*
> +	 * Get pmc-clock number from ACPI _PR0 method and compare this to
> +	 * the CsiPort 1 pmc-clock used in the CHT/BYT reference designs.
> +	 */
> +	clock_num = atomisp_csi2_get_pmc_clk_nr_from_acpi_pr0(adev);
> +	if (IS_ISP2401)
> +		port = clock_num == 4 ? 1 : 0;
> +	else
> +		port = clock_num == 0 ? 1 : 0;
> +
> +	/* Intel DSM or DMI quirk overrides PR0 derived default */
> +	port = gmin_cfg_get_int(adev, "CsiPort", port);
> +
> +	return port;
> +}
> +
> +static const struct atomisp_csi2_property_names prop_names = {
> +	.rotation = "rotation",
> +	.bus_type = "bus-type",
> +	.data_lanes = "data-lanes",
> +	.remote_endpoint = "remote-endpoint",
> +};
> +
> +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.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);
> +
> +	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_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;
> +
> +	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 = -EINVAL;
> +			goto err_put_adev;
> +		}
> +
> +		sensor = &bridge->sensors[bridge->n_sensors];
> +
> +		sensor->port = atomisp_csi2_get_port(adev);
> +		if (sensor->port >= ATOMISP_CAMERA_NR_PORTS) {
> +			dev_err(&adev->dev, "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) {
> +			dev_err(&adev->dev, "Invalid number of lanes: %d\n", sensor->lanes);
> +			ret = -EINVAL;
> +			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_put_adev;
> +
> +		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;
> +
> +		dev_info(isp->dev, "Found supported sensor %s\n", acpi_dev_name(adev));
> +
> +		bridge->n_sensors++;
> +	}
> +
> +	return 0;
> +
> +err_free_swnodes:
> +	software_node_unregister_node_group(sensor->group);
> +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, therefor:
> +	 * 1. The bridge memory is leaked deliberately on success
> +	 * 2. If a secondary fwnode is already set exit early.
> +	 */
> +	if (dev->fwnode && dev->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;
> +}
> diff --git a/drivers/staging/media/atomisp/pci/atomisp_internal.h b/drivers/staging/media/atomisp/pci/atomisp_internal.h
> index 514c360d4d03..e59c0f1e7f53 100644
> --- a/drivers/staging/media/atomisp/pci/atomisp_internal.h
> +++ b/drivers/staging/media/atomisp/pci/atomisp_internal.h
> @@ -27,6 +27,7 @@
>  #include <linux/idr.h>
>  
>  #include <media/media-device.h>
> +#include <media/v4l2-async.h>
>  #include <media/v4l2-subdev.h>
>  
>  /* ISP2400*/
> @@ -173,6 +174,7 @@ struct atomisp_device {
>  	struct v4l2_device v4l2_dev;
>  	struct media_device media_dev;
>  	struct atomisp_sub_device asd;
> +	struct v4l2_async_notifier notifier;
>  	struct atomisp_platform_data *pdata;
>  	void *mmu_l1_base;
>  	void __iomem *base;
> diff --git a/drivers/staging/media/atomisp/pci/atomisp_v4l2.c b/drivers/staging/media/atomisp/pci/atomisp_v4l2.c
> index ef04effc66bf..802c16697ca6 100644
> --- a/drivers/staging/media/atomisp/pci/atomisp_v4l2.c
> +++ b/drivers/staging/media/atomisp/pci/atomisp_v4l2.c
> @@ -27,6 +27,7 @@
>  #include <linux/dmi.h>
>  #include <linux/interrupt.h>
>  #include <linux/bits.h>
> +#include <media/v4l2-fwnode.h>
>  
>  #include <asm/iosf_mbi.h>
>  
> @@ -782,7 +783,11 @@ static int atomisp_subdev_probe(struct atomisp_device *isp)
>  {
>  	const struct atomisp_platform_data *pdata;
>  	struct intel_v4l2_subdev_table *subdevs;
> -	int ret, mipi_port, count;
> +	int ret, mipi_port;
> +
> +	ret = atomisp_csi2_bridge_parse_firmware(isp);
> +	if (ret)
> +		return ret;
>  
>  	pdata = atomisp_get_platform_data();
>  	if (!pdata) {
> @@ -790,23 +795,12 @@ static int atomisp_subdev_probe(struct atomisp_device *isp)
>  		return 0;
>  	}
>  
> -	/* FIXME: should return -EPROBE_DEFER if not all subdevs were probed */
> -	for (count = 0; count < SUBDEV_WAIT_TIMEOUT_MAX_COUNT; count++) {
> -		int camera_count = 0;
> -
> -		for (subdevs = pdata->subdevs; subdevs->type; ++subdevs) {
> -			if (subdevs->type == RAW_CAMERA)
> -				camera_count++;
> -		}
> -		if (camera_count)
> -			break;
> -		msleep(SUBDEV_WAIT_TIMEOUT);
> -	}
> -	/* Wait more time to give more time for subdev init code to finish */
> -	msleep(5 * SUBDEV_WAIT_TIMEOUT);
> -
> -	/* FIXME: should, instead, use I2C probe */
> -
> +	/*
> +	 * TODO: this is left here for now to allow testing atomisp-sensor
> +	 * drivers which are still using the atomisp_gmin_platform infra before
> +	 * converting them to standard v4l2 sensor drivers using runtime-pm +
> +	 * ACPI for pm and v4l2_async_register_subdev_sensor() registration.
> +	 */
>  	for (subdevs = pdata->subdevs; subdevs->type; ++subdevs) {
>  		ret = v4l2_device_register_subdev(&isp->v4l2_dev, subdevs->subdev);
>  		if (ret)
> @@ -937,7 +931,7 @@ static int atomisp_register_entities(struct atomisp_device *isp)
>  	return ret;
>  }
>  
> -static int atomisp_register_device_nodes(struct atomisp_device *isp)
> +int atomisp_register_device_nodes(struct atomisp_device *isp)
>  {
>  	struct atomisp_input_subdev *input;
>  	int i, err;
> @@ -1429,9 +1423,11 @@ static int atomisp_pci_probe(struct pci_dev *pdev, const struct pci_device_id *i
>  	isp->firmware = NULL;
>  	isp->css_env.isp_css_fw.data = NULL;
>  
> -	err = atomisp_register_device_nodes(isp);
> -	if (err)
> +	err = v4l2_async_nf_register(&isp->v4l2_dev, &isp->notifier);
> +	if (err) {
> +		dev_err(isp->dev, "failed to register async notifier : %d\n", err);
>  		goto css_init_fail;
> +	}
>  
>  	atomisp_drvfs_init(isp);
>  
> diff --git a/drivers/staging/media/atomisp/pci/atomisp_v4l2.h b/drivers/staging/media/atomisp/pci/atomisp_v4l2.h
> index c8ee3ad83320..fad9573374b3 100644
> --- a/drivers/staging/media/atomisp/pci/atomisp_v4l2.h
> +++ b/drivers/staging/media/atomisp/pci/atomisp_v4l2.h
> @@ -30,5 +30,6 @@ int atomisp_video_init(struct atomisp_video_pipe *video);
>  void atomisp_video_unregister(struct atomisp_video_pipe *video);
>  const struct firmware *atomisp_load_firmware(struct atomisp_device *isp);
>  int atomisp_csi_lane_config(struct atomisp_device *isp);
> +int atomisp_register_device_nodes(struct atomisp_device *isp);
>  
>  #endif /* __ATOMISP_V4L2_H__ */