Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

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

media: staging/imx: Switch to sync registration for IPU subdevs 



Because the IPU sub-devices VDIC and IC are not present in the
device-tree, platform devices were created for them instead. This
allowed these sub-devices to be added to the media device's async
notifier and registered asynchronously along with the other
sub-devices that do have a device-tree presence (CSI and devices
external to the IPU and SoC).

But that approach isn't really necessary. The IPU sub-devices don't
actually require a backing device (sd->dev is allowed to be NULL).
And that approach can't get around the fact that the IPU sub-devices
are not part of a device hierarchy, which makes it awkward to retrieve
the parent IPU of these devices.

By registering them synchronously, they can be registered from the CSI
async bound notifier, so the init function for them can be given the CSI
subdev, who's dev->parent is the IPU. That is a somewhat cleaner way
to retrieve the parent IPU.

So convert to synchronous registration for the VDIC and IC task
sub-devices, at the time a CSI sub-device is bound. There is no longer
a backing device for them (sd->dev is NULL), but that's ok. Also
set the VDIC/IC sub-device owner as the IPU, so that a reference can
be taken on the IPU module.

Since the VDIC and IC task drivers are no longer platform drivers,
they are now statically linked to imx-media module.

Signed-off-by: default avatarSteve Longerbeam <slongerbeam@gmail.com>
Signed-off-by: default avatarHans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab+samsung@kernel.org>
parent 411c5988

drivers/staging/media/imx/Makefile

+2 −4
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

imx-media-objs := imx-media-dev.o imx-media-internal-sd.o imx-media-of.o

imx-media-objs := imx-media-dev.o imx-media-internal-sd.o imx-media-of.o \

	imx-ic-common.o imx-ic-prp.o imx-ic-prpencvf.o imx-media-vdic.o

imx-media-objs += imx-media-dev-common.o

imx-media-common-objs := imx-media-utils.o imx-media-fim.o

imx-media-ic-objs := imx-ic-common.o imx-ic-prp.o imx-ic-prpencvf.o



obj-$(CONFIG_VIDEO_IMX_MEDIA) += imx-media.o

obj-$(CONFIG_VIDEO_IMX_MEDIA) += imx-media-common.o

obj-$(CONFIG_VIDEO_IMX_MEDIA) += imx-media-capture.o

obj-$(CONFIG_VIDEO_IMX_MEDIA) += imx-media-vdic.o

obj-$(CONFIG_VIDEO_IMX_MEDIA) += imx-media-ic.o



obj-$(CONFIG_VIDEO_IMX_CSI) += imx-media-csi.o

obj-$(CONFIG_VIDEO_IMX_CSI) += imx6-mipi-csi2.o

drivers/staging/media/imx/imx-ic-common.c

+25 −45
Original line number Diff line number Diff line
@@ -4,8 +4,6 @@ 
 *

 * Copyright (c) 2014-2016 Mentor Graphics Inc.

 */

#include <linux/module.h>

#include <linux/platform_device.h>

#include <media/v4l2-device.h>

#include <media/v4l2-subdev.h>

#include "imx-media.h"
@@ -20,23 +18,25 @@ static struct imx_ic_ops *ic_ops[IC_NUM_OPS] = { 
	[IC_TASK_VIEWFINDER]     = &imx_ic_prpencvf_ops,

};



static int imx_ic_probe(struct platform_device *pdev)

struct v4l2_subdev *imx_media_ic_register(struct imx_media_dev *imxmd,

					  struct device *ipu_dev,

					  struct ipu_soc *ipu,

					  u32 grp_id)

{

	struct imx_media_ipu_internal_sd_pdata *pdata;

	struct v4l2_device *v4l2_dev = &imxmd->v4l2_dev;

	struct imx_ic_priv *priv;

	int ret;



	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);

	priv = devm_kzalloc(ipu_dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;

		return ERR_PTR(-ENOMEM);



	platform_set_drvdata(pdev, &priv->sd);

	priv->dev = &pdev->dev;

	priv->ipu_dev = ipu_dev;

	priv->ipu = ipu;

	priv->md = imxmd;



	/* get our ipu_id, grp_id and IC task id */

	pdata = priv->dev->platform_data;

	priv->ipu_id = pdata->ipu_id;

	switch (pdata->grp_id) {

	/* get our IC task id */

	switch (grp_id) {

	case IMX_MEDIA_GRP_ID_IPU_IC_PRP:

		priv->task_id = IC_TASK_PRP;

		break;
@@ -47,7 +47,7 @@ static int imx_ic_probe(struct platform_device *pdev) 
		priv->task_id = IC_TASK_VIEWFINDER;

		break;

	default:

		return -EINVAL;

		return ERR_PTR(-EINVAL);

	}



	v4l2_subdev_init(&priv->sd, ic_ops[priv->task_id]->subdev_ops);
@@ -55,55 +55,35 @@ static int imx_ic_probe(struct platform_device *pdev) 
	priv->sd.internal_ops = ic_ops[priv->task_id]->internal_ops;

	priv->sd.entity.ops = ic_ops[priv->task_id]->entity_ops;

	priv->sd.entity.function = MEDIA_ENT_F_PROC_VIDEO_SCALER;

	priv->sd.dev = &pdev->dev;

	priv->sd.owner = THIS_MODULE;

	priv->sd.owner = ipu_dev->driver->owner;

	priv->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS;

	priv->sd.grp_id = pdata->grp_id;

	strscpy(priv->sd.name, pdata->sd_name, sizeof(priv->sd.name));

	priv->sd.grp_id = grp_id;

	imx_media_grp_id_to_sd_name(priv->sd.name, sizeof(priv->sd.name),

				    priv->sd.grp_id, ipu_get_num(ipu));



	ret = ic_ops[priv->task_id]->init(priv);

	if (ret)

		return ret;

		return ERR_PTR(ret);



	ret = v4l2_async_register_subdev(&priv->sd);

	if (ret)

	ret = v4l2_device_register_subdev(v4l2_dev, &priv->sd);

	if (ret) {

		ic_ops[priv->task_id]->remove(priv);

		return ERR_PTR(ret);

	}



	return ret;

	return &priv->sd;

}



static int imx_ic_remove(struct platform_device *pdev)

int imx_media_ic_unregister(struct v4l2_subdev *sd)

{

	struct v4l2_subdev *sd = platform_get_drvdata(pdev);

	struct imx_ic_priv *priv = container_of(sd, struct imx_ic_priv, sd);



	v4l2_info(sd, "Removing\n");



	ic_ops[priv->task_id]->remove(priv);



	v4l2_async_unregister_subdev(sd);

	v4l2_device_unregister_subdev(sd);

	media_entity_cleanup(&sd->entity);



	return 0;

}
 


static const struct platform_device_id imx_ic_ids[] = {

	{ .name = "imx-ipuv3-ic" },

	{ },

};

MODULE_DEVICE_TABLE(platform, imx_ic_ids);



static struct platform_driver imx_ic_driver = {

	.probe = imx_ic_probe,

	.remove = imx_ic_remove,

	.id_table = imx_ic_ids,

	.driver = {

		.name = "imx-ipuv3-ic",

	},

};

module_platform_driver(imx_ic_driver);



MODULE_DESCRIPTION("i.MX IC subdev driver");

MODULE_AUTHOR("Steve Longerbeam <steve_longerbeam@mentor.com>");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:imx-ipuv3-ic");

drivers/staging/media/imx/imx-ic-prp.c

+13 −21
Original line number Diff line number Diff line
@@ -35,16 +35,12 @@ 
#define S_ALIGN    1 /* multiple of 2 */



struct prp_priv {

	struct imx_media_dev *md;

	struct imx_ic_priv *ic_priv;

	struct media_pad pad[PRP_NUM_PADS];



	/* lock to protect all members below */

	struct mutex lock;



	/* IPU units we require */

	struct ipu_soc *ipu;



	struct v4l2_subdev *src_sd;

	struct v4l2_subdev *sink_sd_prpenc;

	struct v4l2_subdev *sink_sd_prpvf;
@@ -62,7 +58,7 @@ static inline struct prp_priv *sd_to_priv(struct v4l2_subdev *sd) 
{

	struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd);



	return ic_priv->prp_priv;

	return ic_priv->task_priv;

}



static int prp_start(struct prp_priv *priv)
@@ -70,12 +66,10 @@ static int prp_start(struct prp_priv *priv) 
	struct imx_ic_priv *ic_priv = priv->ic_priv;

	bool src_is_vdic;



	priv->ipu = priv->md->ipu[ic_priv->ipu_id];



	/* set IC to receive from CSI or VDI depending on source */

	src_is_vdic = !!(priv->src_sd->grp_id & IMX_MEDIA_GRP_ID_IPU_VDIC);



	ipu_set_ic_src_mux(priv->ipu, priv->csi_id, src_is_vdic);

	ipu_set_ic_src_mux(ic_priv->ipu, priv->csi_id, src_is_vdic);



	return 0;

}
@@ -216,12 +210,12 @@ static int prp_link_setup(struct media_entity *entity, 
{

	struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);

	struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd);

	struct prp_priv *priv = ic_priv->prp_priv;

	struct prp_priv *priv = ic_priv->task_priv;

	struct v4l2_subdev *remote_sd;

	int ret = 0;



	dev_dbg(ic_priv->dev, "link setup %s -> %s", remote->entity->name,

		local->entity->name);

	dev_dbg(ic_priv->ipu_dev, "%s: link setup %s -> %s",

		ic_priv->sd.name, remote->entity->name, local->entity->name);



	remote_sd = media_entity_to_v4l2_subdev(remote->entity);
@@ -295,7 +289,7 @@ static int prp_link_validate(struct v4l2_subdev *sd, 
			     struct v4l2_subdev_format *sink_fmt)

{

	struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd);

	struct prp_priv *priv = ic_priv->prp_priv;

	struct prp_priv *priv = ic_priv->task_priv;

	struct v4l2_subdev *csi;

	int ret;
@@ -304,7 +298,7 @@ static int prp_link_validate(struct v4l2_subdev *sd, 
	if (ret)

		return ret;



	csi = imx_media_find_upstream_subdev(priv->md, &ic_priv->sd.entity,

	csi = imx_media_find_upstream_subdev(ic_priv->md, &ic_priv->sd.entity,

					     IMX_MEDIA_GRP_ID_IPU_CSI);

	if (IS_ERR(csi))

		csi = NULL;
@@ -351,7 +345,7 @@ static int prp_link_validate(struct v4l2_subdev *sd, 
static int prp_s_stream(struct v4l2_subdev *sd, int enable)

{

	struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd);

	struct prp_priv *priv = ic_priv->prp_priv;

	struct prp_priv *priv = ic_priv->task_priv;

	int ret = 0;



	mutex_lock(&priv->lock);
@@ -368,7 +362,8 @@ static int prp_s_stream(struct v4l2_subdev *sd, int enable) 
	if (priv->stream_count != !enable)

		goto update_count;



	dev_dbg(ic_priv->dev, "stream %s\n", enable ? "ON" : "OFF");

	dev_dbg(ic_priv->ipu_dev, "%s: stream %s\n", sd->name,

		enable ? "ON" : "OFF");



	if (enable)

		ret = prp_start(priv);
@@ -440,9 +435,6 @@ static int prp_registered(struct v4l2_subdev *sd) 
	int i, ret;

	u32 code;



	/* get media device */

	priv->md = dev_get_drvdata(sd->v4l2_dev->dev);



	for (i = 0; i < PRP_NUM_PADS; i++) {

		priv->pad[i].flags = (i == PRP_SINK_PAD) ?

			MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE;
@@ -494,12 +486,12 @@ static int prp_init(struct imx_ic_priv *ic_priv) 
{

	struct prp_priv *priv;



	priv = devm_kzalloc(ic_priv->dev, sizeof(*priv), GFP_KERNEL);

	priv = devm_kzalloc(ic_priv->ipu_dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;



	mutex_init(&priv->lock);

	ic_priv->prp_priv = priv;

	ic_priv->task_priv = priv;

	priv->ic_priv = ic_priv;



	return 0;
@@ -507,7 +499,7 @@ static int prp_init(struct imx_ic_priv *ic_priv) 


static void prp_remove(struct imx_ic_priv *ic_priv)

{

	struct prp_priv *priv = ic_priv->prp_priv;

	struct prp_priv *priv = ic_priv->task_priv;



	mutex_destroy(&priv->lock);

}

drivers/staging/media/imx/imx-ic-prpencvf.c

+34 −36
Original line number Diff line number Diff line
@@ -50,7 +50,6 @@ 
#define S_ALIGN       1 /* multiple of 2 */



struct prp_priv {

	struct imx_media_dev *md;

	struct imx_ic_priv *ic_priv;

	struct media_pad pad[PRPENCVF_NUM_PADS];

	/* the video device at output pad */
@@ -60,7 +59,6 @@ struct prp_priv { 
	struct mutex lock;



	/* IPU units we require */

	struct ipu_soc *ipu;

	struct ipu_ic *ic;

	struct ipuv3_channel *out_ch;

	struct ipuv3_channel *rot_in_ch;
@@ -156,9 +154,7 @@ static int prp_get_ipu_resources(struct prp_priv *priv) 
	struct ipuv3_channel *out_ch, *rot_in_ch, *rot_out_ch;

	int ret, task = ic_priv->task_id;



	priv->ipu = priv->md->ipu[ic_priv->ipu_id];



	ic = ipu_ic_get(priv->ipu, task);

	ic = ipu_ic_get(ic_priv->ipu, task);

	if (IS_ERR(ic)) {

		v4l2_err(&ic_priv->sd, "failed to get IC\n");

		ret = PTR_ERR(ic);
@@ -166,7 +162,7 @@ static int prp_get_ipu_resources(struct prp_priv *priv) 
	}

	priv->ic = ic;



	out_ch = ipu_idmac_get(priv->ipu, prp_channel[task].out_ch);

	out_ch = ipu_idmac_get(ic_priv->ipu, prp_channel[task].out_ch);

	if (IS_ERR(out_ch)) {

		v4l2_err(&ic_priv->sd, "could not get IDMAC channel %u\n",

			 prp_channel[task].out_ch);
@@ -175,7 +171,7 @@ static int prp_get_ipu_resources(struct prp_priv *priv) 
	}

	priv->out_ch = out_ch;



	rot_in_ch = ipu_idmac_get(priv->ipu, prp_channel[task].rot_in_ch);

	rot_in_ch = ipu_idmac_get(ic_priv->ipu, prp_channel[task].rot_in_ch);

	if (IS_ERR(rot_in_ch)) {

		v4l2_err(&ic_priv->sd, "could not get IDMAC channel %u\n",

			 prp_channel[task].rot_in_ch);
@@ -184,7 +180,7 @@ static int prp_get_ipu_resources(struct prp_priv *priv) 
	}

	priv->rot_in_ch = rot_in_ch;



	rot_out_ch = ipu_idmac_get(priv->ipu, prp_channel[task].rot_out_ch);

	rot_out_ch = ipu_idmac_get(ic_priv->ipu, prp_channel[task].rot_out_ch);

	if (IS_ERR(rot_out_ch)) {

		v4l2_err(&ic_priv->sd, "could not get IDMAC channel %u\n",

			 prp_channel[task].rot_out_ch);
@@ -464,13 +460,13 @@ static int prp_setup_rotation(struct prp_priv *priv) 
	incc = priv->cc[PRPENCVF_SINK_PAD];

	outcc = vdev->cc;



	ret = imx_media_alloc_dma_buf(priv->md, &priv->rot_buf[0],

	ret = imx_media_alloc_dma_buf(ic_priv->md, &priv->rot_buf[0],

				      outfmt->sizeimage);

	if (ret) {

		v4l2_err(&ic_priv->sd, "failed to alloc rot_buf[0], %d\n", ret);

		return ret;

	}

	ret = imx_media_alloc_dma_buf(priv->md, &priv->rot_buf[1],

	ret = imx_media_alloc_dma_buf(ic_priv->md, &priv->rot_buf[1],

				      outfmt->sizeimage);

	if (ret) {

		v4l2_err(&ic_priv->sd, "failed to alloc rot_buf[1], %d\n", ret);
@@ -543,14 +539,16 @@ static int prp_setup_rotation(struct prp_priv *priv) 
unsetup_vb2:

	prp_unsetup_vb2_buf(priv, VB2_BUF_STATE_QUEUED);

free_rot1:

	imx_media_free_dma_buf(priv->md, &priv->rot_buf[1]);

	imx_media_free_dma_buf(ic_priv->md, &priv->rot_buf[1]);

free_rot0:

	imx_media_free_dma_buf(priv->md, &priv->rot_buf[0]);

	imx_media_free_dma_buf(ic_priv->md, &priv->rot_buf[0]);

	return ret;

}



static void prp_unsetup_rotation(struct prp_priv *priv)

{

	struct imx_ic_priv *ic_priv = priv->ic_priv;



	ipu_ic_task_disable(priv->ic);



	ipu_idmac_disable_channel(priv->out_ch);
@@ -561,8 +559,8 @@ static void prp_unsetup_rotation(struct prp_priv *priv) 


	ipu_ic_disable(priv->ic);



	imx_media_free_dma_buf(priv->md, &priv->rot_buf[0]);

	imx_media_free_dma_buf(priv->md, &priv->rot_buf[1]);

	imx_media_free_dma_buf(ic_priv->md, &priv->rot_buf[0]);

	imx_media_free_dma_buf(ic_priv->md, &priv->rot_buf[1]);

}



static int prp_setup_norotation(struct prp_priv *priv)
@@ -602,7 +600,7 @@ static int prp_setup_norotation(struct prp_priv *priv) 


	ipu_cpmem_dump(priv->out_ch);

	ipu_ic_dump(priv->ic);

	ipu_dump(priv->ipu);

	ipu_dump(ic_priv->ipu);



	ipu_ic_enable(priv->ic);
@@ -654,7 +652,7 @@ static int prp_start(struct prp_priv *priv) 


	outfmt = &vdev->fmt.fmt.pix;



	ret = imx_media_alloc_dma_buf(priv->md, &priv->underrun_buf,

	ret = imx_media_alloc_dma_buf(ic_priv->md, &priv->underrun_buf,

				      outfmt->sizeimage);

	if (ret)

		goto out_put_ipu;
@@ -674,10 +672,10 @@ static int prp_start(struct prp_priv *priv) 
	if (ret)

		goto out_free_underrun;



	priv->nfb4eof_irq = ipu_idmac_channel_irq(priv->ipu,

	priv->nfb4eof_irq = ipu_idmac_channel_irq(ic_priv->ipu,

						  priv->out_ch,

						  IPU_IRQ_NFB4EOF);

	ret = devm_request_irq(ic_priv->dev, priv->nfb4eof_irq,

	ret = devm_request_irq(ic_priv->ipu_dev, priv->nfb4eof_irq,

			       prp_nfb4eof_interrupt, 0,

			       "imx-ic-prp-nfb4eof", priv);

	if (ret) {
@@ -688,12 +686,12 @@ static int prp_start(struct prp_priv *priv) 


	if (ipu_rot_mode_is_irt(priv->rot_mode))

		priv->eof_irq = ipu_idmac_channel_irq(

			priv->ipu, priv->rot_out_ch, IPU_IRQ_EOF);

			ic_priv->ipu, priv->rot_out_ch, IPU_IRQ_EOF);

	else

		priv->eof_irq = ipu_idmac_channel_irq(

			priv->ipu, priv->out_ch, IPU_IRQ_EOF);

			ic_priv->ipu, priv->out_ch, IPU_IRQ_EOF);



	ret = devm_request_irq(ic_priv->dev, priv->eof_irq,

	ret = devm_request_irq(ic_priv->ipu_dev, priv->eof_irq,

			       prp_eof_interrupt, 0,

			       "imx-ic-prp-eof", priv);

	if (ret) {
@@ -718,13 +716,13 @@ static int prp_start(struct prp_priv *priv) 
	return 0;



out_free_eof_irq:

	devm_free_irq(ic_priv->dev, priv->eof_irq, priv);

	devm_free_irq(ic_priv->ipu_dev, priv->eof_irq, priv);

out_free_nfb4eof_irq:

	devm_free_irq(ic_priv->dev, priv->nfb4eof_irq, priv);

	devm_free_irq(ic_priv->ipu_dev, priv->nfb4eof_irq, priv);

out_unsetup:

	prp_unsetup(priv, VB2_BUF_STATE_QUEUED);

out_free_underrun:

	imx_media_free_dma_buf(priv->md, &priv->underrun_buf);

	imx_media_free_dma_buf(ic_priv->md, &priv->underrun_buf);

out_put_ipu:

	prp_put_ipu_resources(priv);

	return ret;
@@ -756,12 +754,12 @@ static void prp_stop(struct prp_priv *priv) 
		v4l2_warn(&ic_priv->sd,

			  "upstream stream off failed: %d\n", ret);



	devm_free_irq(ic_priv->dev, priv->eof_irq, priv);

	devm_free_irq(ic_priv->dev, priv->nfb4eof_irq, priv);

	devm_free_irq(ic_priv->ipu_dev, priv->eof_irq, priv);

	devm_free_irq(ic_priv->ipu_dev, priv->nfb4eof_irq, priv);



	prp_unsetup(priv, VB2_BUF_STATE_ERROR);



	imx_media_free_dma_buf(priv->md, &priv->underrun_buf);

	imx_media_free_dma_buf(ic_priv->md, &priv->underrun_buf);



	/* cancel the EOF timeout timer */

	del_timer_sync(&priv->eof_timeout_timer);
@@ -1011,8 +1009,8 @@ static int prp_link_setup(struct media_entity *entity, 
	struct v4l2_subdev *remote_sd;

	int ret = 0;



	dev_dbg(ic_priv->dev, "link setup %s -> %s", remote->entity->name,

		local->entity->name);

	dev_dbg(ic_priv->ipu_dev, "%s: link setup %s -> %s",

		ic_priv->sd.name, remote->entity->name, local->entity->name);



	mutex_lock(&priv->lock);
@@ -1178,7 +1176,8 @@ static int prp_s_stream(struct v4l2_subdev *sd, int enable) 
	if (priv->stream_count != !enable)

		goto update_count;



	dev_dbg(ic_priv->dev, "stream %s\n", enable ? "ON" : "OFF");

	dev_dbg(ic_priv->ipu_dev, "%s: stream %s\n", sd->name,

		enable ? "ON" : "OFF");



	if (enable)

		ret = prp_start(priv);
@@ -1238,12 +1237,10 @@ static int prp_s_frame_interval(struct v4l2_subdev *sd, 
static int prp_registered(struct v4l2_subdev *sd)

{

	struct prp_priv *priv = sd_to_priv(sd);

	struct imx_ic_priv *ic_priv = priv->ic_priv;

	int i, ret;

	u32 code;



	/* get media device */

	priv->md = dev_get_drvdata(sd->v4l2_dev->dev);



	for (i = 0; i < PRPENCVF_NUM_PADS; i++) {

		priv->pad[i].flags = (i == PRPENCVF_SINK_PAD) ?

			MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE;
@@ -1270,7 +1267,7 @@ static int prp_registered(struct v4l2_subdev *sd) 
	if (ret)

		return ret;



	ret = imx_media_add_video_device(priv->md, priv->vdev);

	ret = imx_media_add_video_device(ic_priv->md, priv->vdev);

	if (ret)

		goto unreg;
@@ -1325,7 +1322,7 @@ static int prp_init(struct imx_ic_priv *ic_priv) 
{

	struct prp_priv *priv;



	priv = devm_kzalloc(ic_priv->dev, sizeof(*priv), GFP_KERNEL);

	priv = devm_kzalloc(ic_priv->ipu_dev, sizeof(*priv), GFP_KERNEL);

	if (!priv)

		return -ENOMEM;
@@ -1335,7 +1332,8 @@ static int prp_init(struct imx_ic_priv *ic_priv) 
	spin_lock_init(&priv->irqlock);

	timer_setup(&priv->eof_timeout_timer, prp_eof_timeout, 0);



	priv->vdev = imx_media_capture_device_init(&ic_priv->sd,

	priv->vdev = imx_media_capture_device_init(ic_priv->ipu_dev,

						   &ic_priv->sd,

						   PRPENCVF_SRC_PAD);

	if (IS_ERR(priv->vdev))

		return PTR_ERR(priv->vdev);

drivers/staging/media/imx/imx-ic.h

+3 −4
Original line number Diff line number Diff line
@@ -10,11 +10,11 @@ 
#include <media/v4l2-subdev.h>



struct imx_ic_priv {

	struct device *dev;

	struct device *ipu_dev;

	struct ipu_soc *ipu;

	struct imx_media_dev *md;

	struct v4l2_subdev sd;

	int    ipu_id;

	int    task_id;

	void   *prp_priv;

	void   *task_priv;

};
@@ -29,6 +29,5 @@ struct imx_ic_ops { 


extern struct imx_ic_ops imx_ic_prp_ops;

extern struct imx_ic_ops imx_ic_prpencvf_ops;

extern struct imx_ic_ops imx_ic_pp_ops;



#endif