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

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

[media] media: imx: Add IC subdev drivers 



This is a set of three media entity subdevice drivers for the i.MX
Image Converter:

- Pre-process Router: Takes input frames from CSI0, CSI1, or VDIC.
  Two output pads enable either or both of the preprocess tasks
  below. If the input is from one of the CSIs, both proprocess task
  links can be enabled to process frames from that CSI simultaneously.
  If the input is the VDIC, only the Pre-processing Viewfinder task
  link can be enabled.

- Pre-processing Encode task: video frames are routed directly from
  the CSI and can be scaled, color-space converted, and rotated.
  Scaled output is limited to 1024x1024 resolution. Output frames
  are routed to the prpenc capture device.

- Pre-processing Viewfinder task: this task can perform the same
  conversions as the pre-process encode task, but in addition can
  be used for hardware motion compensated deinterlacing. Frames can
  come either directly from the CSI or from the VDIC. Scaled output
  is limited to 1024x1024 resolution. Output frames are routed to
  the prpvf capture device.

Signed-off-by: default avatarSteve Longerbeam <steve_longerbeam@mentor.com>
Signed-off-by: default avatarHans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@s-opensource.com>
parent 93dae311

drivers/staging/media/imx/Makefile

+2 −0
Original line number Diff line number Diff line 
imx-media-objs := imx-media-dev.o imx-media-internal-sd.o imx-media-of.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

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

0 → 100644
+113 −0
Original line number Diff line number Diff line 
/*

 * V4L2 Image Converter Subdev for Freescale i.MX5/6 SOC

 *

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

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 */

#include <linux/module.h>

#include <linux/platform_device.h>

#include <media/v4l2-device.h>

#include <media/v4l2-subdev.h>

#include "imx-media.h"

#include "imx-ic.h"



#define IC_TASK_PRP IC_NUM_TASKS

#define IC_NUM_OPS  (IC_NUM_TASKS + 1)



static struct imx_ic_ops *ic_ops[IC_NUM_OPS] = {

	[IC_TASK_PRP]            = &imx_ic_prp_ops,

	[IC_TASK_ENCODER]        = &imx_ic_prpencvf_ops,

	[IC_TASK_VIEWFINDER]     = &imx_ic_prpencvf_ops,

};



static int imx_ic_probe(struct platform_device *pdev)

{

	struct imx_media_internal_sd_platformdata *pdata;

	struct imx_ic_priv *priv;

	int ret;



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

	if (!priv)

		return -ENOMEM;



	platform_set_drvdata(pdev, &priv->sd);

	priv->dev = &pdev->dev;



	/* 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) {

	case IMX_MEDIA_GRP_ID_IC_PRP:

		priv->task_id = IC_TASK_PRP;

		break;

	case IMX_MEDIA_GRP_ID_IC_PRPENC:

		priv->task_id = IC_TASK_ENCODER;

		break;

	case IMX_MEDIA_GRP_ID_IC_PRPVF:

		priv->task_id = IC_TASK_VIEWFINDER;

		break;

	default:

		return -EINVAL;

	}



	v4l2_subdev_init(&priv->sd, ic_ops[priv->task_id]->subdev_ops);

	v4l2_set_subdevdata(&priv->sd, priv);

	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.flags = V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS;

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

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



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

	if (ret)

		return ret;



	ret = v4l2_async_register_subdev(&priv->sd);

	if (ret)

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



	return ret;

}



static int imx_ic_remove(struct platform_device *pdev)

{

	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);

	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

0 → 100644
+513 −0
Original line number Diff line number Diff line 
/*

 * V4L2 Capture IC Preprocess Subdev for Freescale i.MX5/6 SOC

 *

 * This subdevice handles capture of video frames from the CSI or VDIC,

 * which are routed directly to the Image Converter preprocess tasks,

 * for resizing, colorspace conversion, and rotation.

 *

 * Copyright (c) 2012-2017 Mentor Graphics Inc.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 */

#include <linux/delay.h>

#include <linux/interrupt.h>

#include <linux/module.h>

#include <linux/sched.h>

#include <linux/slab.h>

#include <linux/spinlock.h>

#include <linux/timer.h>

#include <media/v4l2-ctrls.h>

#include <media/v4l2-device.h>

#include <media/v4l2-ioctl.h>

#include <media/v4l2-subdev.h>

#include <media/imx.h>

#include "imx-media.h"

#include "imx-ic.h"



/*

 * Min/Max supported width and heights.

 */

#define MIN_W       176

#define MIN_H       144

#define MAX_W      4096

#define MAX_H      4096

#define W_ALIGN    4 /* multiple of 16 pixels */

#define H_ALIGN    1 /* multiple of 2 lines */

#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;



	/* the CSI id at link validate */

	int csi_id;



	struct v4l2_mbus_framefmt format_mbus;

	struct v4l2_fract frame_interval;



	int stream_count;

};



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;

}



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_VDIC);



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



	return 0;

}



static void prp_stop(struct prp_priv *priv)

{

}



static struct v4l2_mbus_framefmt *

__prp_get_fmt(struct prp_priv *priv, struct v4l2_subdev_pad_config *cfg,

	      unsigned int pad, enum v4l2_subdev_format_whence which)

{

	struct imx_ic_priv *ic_priv = priv->ic_priv;



	if (which == V4L2_SUBDEV_FORMAT_TRY)

		return v4l2_subdev_get_try_format(&ic_priv->sd, cfg, pad);

	else

		return &priv->format_mbus;

}



/*

 * V4L2 subdev operations.

 */



static int prp_enum_mbus_code(struct v4l2_subdev *sd,

			      struct v4l2_subdev_pad_config *cfg,

			      struct v4l2_subdev_mbus_code_enum *code)

{

	struct prp_priv *priv = sd_to_priv(sd);

	struct v4l2_mbus_framefmt *infmt;

	int ret = 0;



	mutex_lock(&priv->lock);



	switch (code->pad) {

	case PRP_SINK_PAD:

		ret = imx_media_enum_ipu_format(&code->code, code->index,

						CS_SEL_ANY);

		break;

	case PRP_SRC_PAD_PRPENC:

	case PRP_SRC_PAD_PRPVF:

		if (code->index != 0) {

			ret = -EINVAL;

			goto out;

		}

		infmt = __prp_get_fmt(priv, cfg, PRP_SINK_PAD, code->which);

		code->code = infmt->code;

		break;

	default:

		ret = -EINVAL;

	}

out:

	mutex_unlock(&priv->lock);

	return ret;

}



static int prp_get_fmt(struct v4l2_subdev *sd,

		       struct v4l2_subdev_pad_config *cfg,

		       struct v4l2_subdev_format *sdformat)

{

	struct prp_priv *priv = sd_to_priv(sd);

	struct v4l2_mbus_framefmt *fmt;

	int ret = 0;



	if (sdformat->pad >= PRP_NUM_PADS)

		return -EINVAL;



	mutex_lock(&priv->lock);



	fmt = __prp_get_fmt(priv, cfg, sdformat->pad, sdformat->which);

	if (!fmt) {

		ret = -EINVAL;

		goto out;

	}



	sdformat->format = *fmt;

out:

	mutex_unlock(&priv->lock);

	return ret;

}



static int prp_set_fmt(struct v4l2_subdev *sd,

		       struct v4l2_subdev_pad_config *cfg,

		       struct v4l2_subdev_format *sdformat)

{

	struct prp_priv *priv = sd_to_priv(sd);

	const struct imx_media_pixfmt *cc;

	struct v4l2_mbus_framefmt *fmt;

	int ret = 0;

	u32 code;



	if (sdformat->pad >= PRP_NUM_PADS)

		return -EINVAL;



	mutex_lock(&priv->lock);



	if (priv->stream_count > 0) {

		ret = -EBUSY;

		goto out;

	}



	switch (sdformat->pad) {

	case PRP_SINK_PAD:

		v4l_bound_align_image(&sdformat->format.width, MIN_W, MAX_W,

				      W_ALIGN, &sdformat->format.height,

				      MIN_H, MAX_H, H_ALIGN, S_ALIGN);



		cc = imx_media_find_ipu_format(sdformat->format.code,

					       CS_SEL_ANY);

		if (!cc) {

			imx_media_enum_ipu_format(&code, 0, CS_SEL_ANY);

			cc = imx_media_find_ipu_format(code, CS_SEL_ANY);

			sdformat->format.code = cc->codes[0];

		}

		break;

	case PRP_SRC_PAD_PRPENC:

	case PRP_SRC_PAD_PRPVF:

		/* Output pads mirror input pad */

		fmt = __prp_get_fmt(priv, cfg, PRP_SINK_PAD, sdformat->which);

		sdformat->format = *fmt;

		break;

	}



	fmt = __prp_get_fmt(priv, cfg, sdformat->pad, sdformat->which);

	*fmt = sdformat->format;

out:

	mutex_unlock(&priv->lock);

	return ret;

}



static int prp_link_setup(struct media_entity *entity,

			  const struct media_pad *local,

			  const struct media_pad *remote, u32 flags)

{

	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 v4l2_subdev *remote_sd;

	int ret = 0;



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

		local->entity->name);



	remote_sd = media_entity_to_v4l2_subdev(remote->entity);



	mutex_lock(&priv->lock);



	if (local->flags & MEDIA_PAD_FL_SINK) {

		if (flags & MEDIA_LNK_FL_ENABLED) {

			if (priv->src_sd) {

				ret = -EBUSY;

				goto out;

			}

			if (priv->sink_sd_prpenc && (remote_sd->grp_id &

						     IMX_MEDIA_GRP_ID_VDIC)) {

				ret = -EINVAL;

				goto out;

			}

			priv->src_sd = remote_sd;

		} else {

			priv->src_sd = NULL;

		}



		goto out;

	}



	/* this is a source pad */

	if (flags & MEDIA_LNK_FL_ENABLED) {

		switch (local->index) {

		case PRP_SRC_PAD_PRPENC:

			if (priv->sink_sd_prpenc) {

				ret = -EBUSY;

				goto out;

			}

			if (priv->src_sd && (priv->src_sd->grp_id &

					     IMX_MEDIA_GRP_ID_VDIC)) {

				ret = -EINVAL;

				goto out;

			}

			priv->sink_sd_prpenc = remote_sd;

			break;

		case PRP_SRC_PAD_PRPVF:

			if (priv->sink_sd_prpvf) {

				ret = -EBUSY;

				goto out;

			}

			priv->sink_sd_prpvf = remote_sd;

			break;

		default:

			ret = -EINVAL;

		}

	} else {

		switch (local->index) {

		case PRP_SRC_PAD_PRPENC:

			priv->sink_sd_prpenc = NULL;

			break;

		case PRP_SRC_PAD_PRPVF:

			priv->sink_sd_prpvf = NULL;

			break;

		default:

			ret = -EINVAL;

		}

	}



out:

	mutex_unlock(&priv->lock);

	return ret;

}



static int prp_link_validate(struct v4l2_subdev *sd,

			     struct media_link *link,

			     struct v4l2_subdev_format *source_fmt,

			     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 imx_media_subdev *csi;

	int ret;



	ret = v4l2_subdev_link_validate_default(sd, link,

						source_fmt, sink_fmt);

	if (ret)

		return ret;



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

					     IMX_MEDIA_GRP_ID_CSI);

	if (IS_ERR(csi))

		csi = NULL;



	mutex_lock(&priv->lock);



	if (priv->src_sd->grp_id & IMX_MEDIA_GRP_ID_VDIC) {

		/*

		 * the ->PRPENC link cannot be enabled if the source

		 * is the VDIC

		 */

		if (priv->sink_sd_prpenc)

			ret = -EINVAL;

		goto out;

	} else {

		/* the source is a CSI */

		if (!csi) {

			ret = -EINVAL;

			goto out;

		}

	}



	if (csi) {

		switch (csi->sd->grp_id) {

		case IMX_MEDIA_GRP_ID_CSI0:

			priv->csi_id = 0;

			break;

		case IMX_MEDIA_GRP_ID_CSI1:

			priv->csi_id = 1;

			break;

		default:

			ret = -EINVAL;

		}

	} else {

		priv->csi_id = 0;

	}



out:

	mutex_unlock(&priv->lock);

	return ret;

}



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;

	int ret = 0;



	mutex_lock(&priv->lock);



	if (!priv->src_sd || (!priv->sink_sd_prpenc && !priv->sink_sd_prpvf)) {

		ret = -EPIPE;

		goto out;

	}



	/*

	 * enable/disable streaming only if stream_count is

	 * going from 0 to 1 / 1 to 0.

	 */

	if (priv->stream_count != !enable)

		goto update_count;



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



	if (enable)

		ret = prp_start(priv);

	else

		prp_stop(priv);

	if (ret)

		goto out;



	/* start/stop upstream */

	ret = v4l2_subdev_call(priv->src_sd, video, s_stream, enable);

	ret = (ret && ret != -ENOIOCTLCMD) ? ret : 0;

	if (ret) {

		if (enable)

			prp_stop(priv);

		goto out;

	}



update_count:

	priv->stream_count += enable ? 1 : -1;

	WARN_ON(priv->stream_count < 0);

out:

	mutex_unlock(&priv->lock);

	return ret;

}



static int prp_g_frame_interval(struct v4l2_subdev *sd,

				struct v4l2_subdev_frame_interval *fi)

{

	struct prp_priv *priv = sd_to_priv(sd);



	if (fi->pad >= PRP_NUM_PADS)

		return -EINVAL;



	mutex_lock(&priv->lock);

	fi->interval = priv->frame_interval;

	mutex_unlock(&priv->lock);



	return 0;

}



static int prp_s_frame_interval(struct v4l2_subdev *sd,

				struct v4l2_subdev_frame_interval *fi)

{

	struct prp_priv *priv = sd_to_priv(sd);



	if (fi->pad >= PRP_NUM_PADS)

		return -EINVAL;



	/* No limits on frame interval */

	mutex_lock(&priv->lock);

	priv->frame_interval = fi->interval;

	mutex_unlock(&priv->lock);



	return 0;

}



/*

 * retrieve our pads parsed from the OF graph by the media device

 */

static int prp_registered(struct v4l2_subdev *sd)

{

	struct prp_priv *priv = sd_to_priv(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;

	}



	/* init default frame interval */

	priv->frame_interval.numerator = 1;

	priv->frame_interval.denominator = 30;



	/* set a default mbus format  */

	imx_media_enum_ipu_format(&code, 0, CS_SEL_YUV);

	ret = imx_media_init_mbus_fmt(&priv->format_mbus, 640, 480, code,

				      V4L2_FIELD_NONE, NULL);

	if (ret)

		return ret;



	return media_entity_pads_init(&sd->entity, PRP_NUM_PADS, priv->pad);

}



static const struct v4l2_subdev_pad_ops prp_pad_ops = {

	.enum_mbus_code = prp_enum_mbus_code,

	.get_fmt = prp_get_fmt,

	.set_fmt = prp_set_fmt,

	.link_validate = prp_link_validate,

};



static const struct v4l2_subdev_video_ops prp_video_ops = {

	.g_frame_interval = prp_g_frame_interval,

	.s_frame_interval = prp_s_frame_interval,

	.s_stream = prp_s_stream,

};



static const struct media_entity_operations prp_entity_ops = {

	.link_setup = prp_link_setup,

	.link_validate = v4l2_subdev_link_validate,

};



static const struct v4l2_subdev_ops prp_subdev_ops = {

	.video = &prp_video_ops,

	.pad = &prp_pad_ops,

};



static const struct v4l2_subdev_internal_ops prp_internal_ops = {

	.registered = prp_registered,

};



static int prp_init(struct imx_ic_priv *ic_priv)

{

	struct prp_priv *priv;



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

	if (!priv)

		return -ENOMEM;



	mutex_init(&priv->lock);

	ic_priv->prp_priv = priv;

	priv->ic_priv = ic_priv;



	return 0;

}



static void prp_remove(struct imx_ic_priv *ic_priv)

{

	struct prp_priv *priv = ic_priv->prp_priv;



	mutex_destroy(&priv->lock);

}



struct imx_ic_ops imx_ic_prp_ops = {

	.subdev_ops = &prp_subdev_ops,

	.internal_ops = &prp_internal_ops,

	.entity_ops = &prp_entity_ops,

	.init = prp_init,

	.remove = prp_remove,

};

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

0 → 100644
+1299 −0

File added.

Preview size limit exceeded, changes collapsed.

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

0 → 100644
+38 −0
Original line number Diff line number Diff line 
/*

 * V4L2 Image Converter Subdev for Freescale i.MX5/6 SOC

 *

 * Copyright (c) 2016 Mentor Graphics Inc.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 */

#ifndef _IMX_IC_H

#define _IMX_IC_H



#include <media/v4l2-subdev.h>



struct imx_ic_priv {

	struct device *dev;

	struct v4l2_subdev sd;

	int    ipu_id;

	int    task_id;

	void   *prp_priv;

	void   *task_priv;

};



struct imx_ic_ops {

	const struct v4l2_subdev_ops *subdev_ops;

	const struct v4l2_subdev_internal_ops *internal_ops;

	const struct media_entity_operations *entity_ops;



	int (*init)(struct imx_ic_priv *ic_priv);

	void (*remove)(struct imx_ic_priv *ic_priv);

};



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