Commit eae2aed1 authored by Steve Longerbeam's avatar Steve Longerbeam Committed by Mauro Carvalho Chehab
Browse files

media: v4l2-fwnode: Switch to v4l2_async_notifier_add_subdev 



The fwnode endpoint and reference parsing functions in v4l2-fwnode.c
are modified to make use of v4l2_async_notifier_add_subdev().
As a result the notifier->subdevs array is no longer allocated or
re-allocated, and by extension the max_subdevs value is also no
longer needed.

Callers of the fwnode endpoint and reference parsing functions must now
first initialize the notifier with a call to v4l2_async_notifier_init().
This includes the function v4l2_async_register_subdev_sensor_common(),
and the intel-ipu3, omap3isp, and rcar-vin drivers.

Since the notifier->subdevs array is no longer allocated in the
fwnode endpoint and reference parsing functions, the callers of
those functions must never reference that array, since it is now
NULL. Of the drivers that make use of the fwnode/ref parsing,
only the intel-ipu3 driver references the ->subdevs[] array,
(in the notifier completion callback), so that driver has been
modified to iterate through the notifier->asd_list instead.

Signed-off-by: default avatarSteve Longerbeam <slongerbeam@gmail.com>
Signed-off-by: default avatarSakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab+samsung@kernel.org>
parent 23989b43

drivers/media/pci/intel/ipu3/ipu3-cio2.c

+7 −5
Original line number Diff line number Diff line
@@ -1433,13 +1433,13 @@ static int cio2_notifier_complete(struct v4l2_async_notifier *notifier) 
	struct cio2_device *cio2 = container_of(notifier, struct cio2_device,

						notifier);

	struct sensor_async_subdev *s_asd;

	struct v4l2_async_subdev *asd;

	struct cio2_queue *q;

	unsigned int i, pad;

	unsigned int pad;

	int ret;



	for (i = 0; i < notifier->num_subdevs; i++) {

		s_asd = container_of(cio2->notifier.subdevs[i],

				     struct sensor_async_subdev, asd);

	list_for_each_entry(asd, &cio2->notifier.asd_list, asd_list) {

		s_asd = container_of(asd, struct sensor_async_subdev, asd);

		q = &cio2->queue[s_asd->csi2.port];



		for (pad = 0; pad < q->sensor->entity.num_pads; pad++)
@@ -1461,7 +1461,7 @@ static int cio2_notifier_complete(struct v4l2_async_notifier *notifier) 
		if (ret) {

			dev_err(&cio2->pci_dev->dev,

				"failed to create link for %s\n",

				cio2->queue[i].sensor->name);

				q->sensor->name);

			return ret;

		}

	}
@@ -1497,6 +1497,8 @@ static int cio2_notifier_init(struct cio2_device *cio2) 
{

	int ret;



	v4l2_async_notifier_init(&cio2->notifier);



	ret = v4l2_async_notifier_parse_fwnode_endpoints(

		&cio2->pci_dev->dev, &cio2->notifier,

		sizeof(struct sensor_async_subdev),

drivers/media/platform/omap3isp/isp.c

+1 −0
Original line number Diff line number Diff line
@@ -2220,6 +2220,7 @@ static int isp_probe(struct platform_device *pdev) 


	mutex_init(&isp->isp_mutex);

	spin_lock_init(&isp->stat_lock);

	v4l2_async_notifier_init(&isp->notifier);



	ret = v4l2_async_notifier_parse_fwnode_endpoints(

		&pdev->dev, &isp->notifier, sizeof(struct isp_async_subdev),

drivers/media/platform/rcar-vin/rcar-core.c

+4 −0
Original line number Diff line number Diff line
@@ -610,6 +610,8 @@ static int rvin_parallel_init(struct rvin_dev *vin) 
{

	int ret;



	v4l2_async_notifier_init(&vin->notifier);



	ret = v4l2_async_notifier_parse_fwnode_endpoints_by_port(

		vin->dev, &vin->notifier, sizeof(struct rvin_parallel_entity),

		0, rvin_parallel_parse_v4l2);
@@ -802,6 +804,8 @@ static int rvin_mc_parse_of_graph(struct rvin_dev *vin) 
		return 0;

	}



	v4l2_async_notifier_init(&vin->group->notifier);



	/*

	 * Have all VIN's look for CSI-2 subdevices. Some subdevices will

	 * overlap but the parser function can handle it, so each subdevice

drivers/media/v4l2-core/v4l2-async.c

+0 −4
Original line number Diff line number Diff line
@@ -566,9 +566,6 @@ static void __v4l2_async_notifier_cleanup(struct v4l2_async_notifier *notifier) 
		return;



	if (notifier->subdevs) {

		if (!notifier->max_subdevs)

			return;



		for (i = 0; i < notifier->num_subdevs; i++) {

			asd = notifier->subdevs[i];
@@ -583,7 +580,6 @@ static void __v4l2_async_notifier_cleanup(struct v4l2_async_notifier *notifier) 
			kfree(asd);

		}



		notifier->max_subdevs = 0;

		kvfree(notifier->subdevs);

		notifier->subdevs = NULL;

	} else {

drivers/media/v4l2-core/v4l2-fwnode.c

+28 −104
Original line number Diff line number Diff line
@@ -320,33 +320,6 @@ void v4l2_fwnode_put_link(struct v4l2_fwnode_link *link) 
}

EXPORT_SYMBOL_GPL(v4l2_fwnode_put_link);



static int v4l2_async_notifier_realloc(struct v4l2_async_notifier *notifier,

				       unsigned int max_subdevs)

{

	struct v4l2_async_subdev **subdevs;



	if (max_subdevs <= notifier->max_subdevs)

		return 0;



	subdevs = kvmalloc_array(

		max_subdevs, sizeof(*notifier->subdevs),

		GFP_KERNEL | __GFP_ZERO);

	if (!subdevs)

		return -ENOMEM;



	if (notifier->subdevs) {

		memcpy(subdevs, notifier->subdevs,

		       sizeof(*subdevs) * notifier->num_subdevs);



		kvfree(notifier->subdevs);

	}



	notifier->subdevs = subdevs;

	notifier->max_subdevs = max_subdevs;



	return 0;

}



static int v4l2_async_notifier_fwnode_parse_endpoint(

	struct device *dev, struct v4l2_async_notifier *notifier,

	struct fwnode_handle *endpoint, unsigned int asd_struct_size,
@@ -391,8 +364,13 @@ static int v4l2_async_notifier_fwnode_parse_endpoint( 
	if (ret < 0)

		goto out_err;



	notifier->subdevs[notifier->num_subdevs] = asd;

	notifier->num_subdevs++;

	ret = v4l2_async_notifier_add_subdev(notifier, asd);

	if (ret < 0) {

		/* not an error if asd already exists */

		if (ret == -EEXIST)

			ret = 0;

		goto out_err;

	}



	return 0;
@@ -411,46 +389,11 @@ static int __v4l2_async_notifier_parse_fwnode_endpoints( 
			    struct v4l2_async_subdev *asd))

{

	struct fwnode_handle *fwnode;

	unsigned int max_subdevs = notifier->max_subdevs;

	int ret;

	int ret = 0;



	if (WARN_ON(asd_struct_size < sizeof(struct v4l2_async_subdev)))

		return -EINVAL;



	for (fwnode = NULL; (fwnode = fwnode_graph_get_next_endpoint(

				     dev_fwnode(dev), fwnode)); ) {

		struct fwnode_handle *dev_fwnode;

		bool is_available;



		dev_fwnode = fwnode_graph_get_port_parent(fwnode);

		is_available = fwnode_device_is_available(dev_fwnode);

		fwnode_handle_put(dev_fwnode);

		if (!is_available)

			continue;



		if (has_port) {

			struct fwnode_endpoint ep;



			ret = fwnode_graph_parse_endpoint(fwnode, &ep);

			if (ret) {

				fwnode_handle_put(fwnode);

				return ret;

			}



			if (ep.port != port)

				continue;

		}

		max_subdevs++;

	}



	/* No subdevs to add? Return here. */

	if (max_subdevs == notifier->max_subdevs)

		return 0;



	ret = v4l2_async_notifier_realloc(notifier, max_subdevs);

	if (ret)

		return ret;



	for (fwnode = NULL; (fwnode = fwnode_graph_get_next_endpoint(

				     dev_fwnode(dev), fwnode)); ) {

		struct fwnode_handle *dev_fwnode;
@@ -473,11 +416,6 @@ static int __v4l2_async_notifier_parse_fwnode_endpoints( 
				continue;

		}



		if (WARN_ON(notifier->num_subdevs >= notifier->max_subdevs)) {

			ret = -EINVAL;

			break;

		}



		ret = v4l2_async_notifier_fwnode_parse_endpoint(

			dev, notifier, fwnode, asd_struct_size, parse_endpoint);

		if (ret < 0)
@@ -548,31 +486,23 @@ static int v4l2_fwnode_reference_parse( 
	if (ret != -ENOENT && ret != -ENODATA)

		return ret;



	ret = v4l2_async_notifier_realloc(notifier,

					  notifier->num_subdevs + index);

	if (ret)

		return ret;



	for (index = 0; !fwnode_property_get_reference_args(

		     dev_fwnode(dev), prop, NULL, 0, index, &args);

	     index++) {

		struct v4l2_async_subdev *asd;



		if (WARN_ON(notifier->num_subdevs >= notifier->max_subdevs)) {

			ret = -EINVAL;

			goto error;

		asd = v4l2_async_notifier_add_fwnode_subdev(

			notifier, args.fwnode, sizeof(*asd));

		if (IS_ERR(asd)) {

			ret = PTR_ERR(asd);

			/* not an error if asd already exists */

			if (ret == -EEXIST) {

				fwnode_handle_put(args.fwnode);

				continue;

			}



		asd = kzalloc(sizeof(*asd), GFP_KERNEL);

		if (!asd) {

			ret = -ENOMEM;

			goto error;

		}



		notifier->subdevs[notifier->num_subdevs] = asd;

		asd->match.fwnode = args.fwnode;

		asd->match_type = V4L2_ASYNC_MATCH_FWNODE;

		notifier->num_subdevs++;

	}



	return 0;
@@ -843,31 +773,23 @@ static int v4l2_fwnode_reference_parse_int_props( 
		index++;

	} while (1);



	ret = v4l2_async_notifier_realloc(notifier,

					  notifier->num_subdevs + index);

	if (ret)

		return -ENOMEM;



	for (index = 0; !IS_ERR((fwnode = v4l2_fwnode_reference_get_int_prop(

					 dev_fwnode(dev), prop, index, props,

					 nprops))); index++) {

		struct v4l2_async_subdev *asd;



		if (WARN_ON(notifier->num_subdevs >= notifier->max_subdevs)) {

			ret = -EINVAL;

			goto error;

		asd = v4l2_async_notifier_add_fwnode_subdev(notifier, fwnode,

							    sizeof(*asd));

		if (IS_ERR(asd)) {

			ret = PTR_ERR(asd);

			/* not an error if asd already exists */

			if (ret == -EEXIST) {

				fwnode_handle_put(fwnode);

				continue;

			}



		asd = kzalloc(sizeof(struct v4l2_async_subdev), GFP_KERNEL);

		if (!asd) {

			ret = -ENOMEM;

			goto error;

		}



		notifier->subdevs[notifier->num_subdevs] = asd;

		asd->match.fwnode = fwnode;

		asd->match_type = V4L2_ASYNC_MATCH_FWNODE;

		notifier->num_subdevs++;

	}



	return PTR_ERR(fwnode) == -ENOENT ? 0 : PTR_ERR(fwnode);
@@ -924,6 +846,8 @@ int v4l2_async_register_subdev_sensor_common(struct v4l2_subdev *sd) 
	if (!notifier)

		return -ENOMEM;



	v4l2_async_notifier_init(notifier);



	ret = v4l2_async_notifier_parse_fwnode_sensor_common(sd->dev,

							     notifier);

	if (ret < 0)

CRA Git | Maintained and supported by SUSTech CRA and CCSE