imx-media-capture.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Video Capture Subdev for Freescale i.MX5/6 SOC
   4 *
   5 * Copyright (c) 2012-2016 Mentor Graphics Inc.
   6 */
   7#include <linux/delay.h>
   8#include <linux/fs.h>
   9#include <linux/module.h>
  10#include <linux/pinctrl/consumer.h>
  11#include <linux/platform_device.h>
  12#include <linux/sched.h>
  13#include <linux/slab.h>
  14#include <linux/spinlock.h>
  15#include <linux/timer.h>
  16#include <media/v4l2-ctrls.h>
  17#include <media/v4l2-device.h>
  18#include <media/v4l2-event.h>
  19#include <media/v4l2-fwnode.h>
  20#include <media/v4l2-ioctl.h>
  21#include <media/v4l2-mc.h>
  22#include <media/v4l2-subdev.h>
  23#include <media/videobuf2-dma-contig.h>
  24#include <video/imx-ipu-v3.h>
  25#include <media/imx.h>
  26#include "imx-media.h"
  27
  28#define IMX_CAPTURE_NAME "imx-capture"
  29
  30struct capture_priv {
  31	struct imx_media_dev *md;		/* Media device */
  32	struct device *dev;			/* Physical device */
  33
  34	struct imx_media_video_dev vdev;	/* Video device */
  35	struct media_pad vdev_pad;		/* Video device pad */
  36
  37	struct v4l2_subdev *src_sd;		/* Source subdev */
  38	int src_sd_pad;				/* Source subdev pad */
  39
  40	struct mutex mutex;			/* Protect vdev operations */
  41
  42	struct vb2_queue q;			/* The videobuf2 queue */
  43	struct list_head ready_q;		/* List of queued buffers */
  44	spinlock_t q_lock;			/* Protect ready_q */
  45
  46	struct v4l2_ctrl_handler ctrl_hdlr;	/* Controls inherited from subdevs */
  47
  48	bool legacy_api;			/* Use the legacy (pre-MC) API */
  49};
  50
  51#define to_capture_priv(v) container_of(v, struct capture_priv, vdev)
  52
  53/* In bytes, per queue */
  54#define VID_MEM_LIMIT	SZ_64M
  55
  56/* -----------------------------------------------------------------------------
  57 * MC-Centric Video IOCTLs
  58 */
  59
  60static const struct imx_media_pixfmt *capture_find_format(u32 code, u32 fourcc)
  61{
  62	const struct imx_media_pixfmt *cc;
  63
  64	cc = imx_media_find_ipu_format(code, PIXFMT_SEL_YUV_RGB);
  65	if (cc) {
  66		enum imx_pixfmt_sel fmt_sel = cc->cs == IPUV3_COLORSPACE_YUV
  67					    ? PIXFMT_SEL_YUV : PIXFMT_SEL_RGB;
  68
  69		cc = imx_media_find_pixel_format(fourcc, fmt_sel);
  70		if (!cc) {
  71			imx_media_enum_pixel_formats(&fourcc, 0, fmt_sel, 0);
  72			cc = imx_media_find_pixel_format(fourcc, fmt_sel);
  73		}
  74
  75		return cc;
  76	}
  77
  78	return imx_media_find_mbus_format(code, PIXFMT_SEL_ANY);
  79}
  80
  81static int capture_querycap(struct file *file, void *fh,
  82			    struct v4l2_capability *cap)
  83{
  84	struct capture_priv *priv = video_drvdata(file);
  85
  86	strscpy(cap->driver, IMX_CAPTURE_NAME, sizeof(cap->driver));
  87	strscpy(cap->card, IMX_CAPTURE_NAME, sizeof(cap->card));
  88	snprintf(cap->bus_info, sizeof(cap->bus_info),
  89		 "platform:%s", dev_name(priv->dev));
  90
  91	return 0;
  92}
  93
  94static int capture_enum_fmt_vid_cap(struct file *file, void *fh,
  95				    struct v4l2_fmtdesc *f)
  96{
  97	return imx_media_enum_pixel_formats(&f->pixelformat, f->index,
  98					    PIXFMT_SEL_ANY, f->mbus_code);
  99}
 100
 101static int capture_enum_framesizes(struct file *file, void *fh,
 102				   struct v4l2_frmsizeenum *fsize)
 103{
 104	const struct imx_media_pixfmt *cc;
 105
 106	if (fsize->index > 0)
 107		return -EINVAL;
 108
 109	cc = imx_media_find_pixel_format(fsize->pixel_format, PIXFMT_SEL_ANY);
 110	if (!cc)
 111		return -EINVAL;
 112
 113	/*
 114	 * TODO: The constraints are hardware-specific and may depend on the
 115	 * pixel format. This should come from the driver using
 116	 * imx_media_capture.
 117	 */
 118	fsize->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
 119	fsize->stepwise.min_width = 1;
 120	fsize->stepwise.max_width = 65535;
 121	fsize->stepwise.min_height = 1;
 122	fsize->stepwise.max_height = 65535;
 123	fsize->stepwise.step_width = 1;
 124	fsize->stepwise.step_height = 1;
 125
 126	return 0;
 127}
 128
 129static int capture_g_fmt_vid_cap(struct file *file, void *fh,
 130				 struct v4l2_format *f)
 131{
 132	struct capture_priv *priv = video_drvdata(file);
 133
 134	f->fmt.pix = priv->vdev.fmt;
 135
 136	return 0;
 137}
 138
 139static const struct imx_media_pixfmt *
 140__capture_try_fmt(struct v4l2_pix_format *pixfmt, struct v4l2_rect *compose)
 141{
 142	struct v4l2_mbus_framefmt fmt_src;
 143	const struct imx_media_pixfmt *cc;
 144
 145	/*
 146	 * Find the pixel format, default to the first supported format if not
 147	 * found.
 148	 */
 149	cc = imx_media_find_pixel_format(pixfmt->pixelformat, PIXFMT_SEL_ANY);
 150	if (!cc) {
 151		imx_media_enum_pixel_formats(&pixfmt->pixelformat, 0,
 152					     PIXFMT_SEL_ANY, 0);
 153		cc = imx_media_find_pixel_format(pixfmt->pixelformat,
 154						 PIXFMT_SEL_ANY);
 155	}
 156
 157	/* Allow IDMAC interweave but enforce field order from source. */
 158	if (V4L2_FIELD_IS_INTERLACED(pixfmt->field)) {
 159		switch (pixfmt->field) {
 160		case V4L2_FIELD_SEQ_TB:
 161			pixfmt->field = V4L2_FIELD_INTERLACED_TB;
 162			break;
 163		case V4L2_FIELD_SEQ_BT:
 164			pixfmt->field = V4L2_FIELD_INTERLACED_BT;
 165			break;
 166		default:
 167			break;
 168		}
 169	}
 170
 171	v4l2_fill_mbus_format(&fmt_src, pixfmt, 0);
 172	imx_media_mbus_fmt_to_pix_fmt(pixfmt, &fmt_src, cc);
 173
 174	if (compose) {
 175		compose->width = fmt_src.width;
 176		compose->height = fmt_src.height;
 177	}
 178
 179	return cc;
 180}
 181
 182static int capture_try_fmt_vid_cap(struct file *file, void *fh,
 183				   struct v4l2_format *f)
 184{
 185	__capture_try_fmt(&f->fmt.pix, NULL);
 186	return 0;
 187}
 188
 189static int capture_s_fmt_vid_cap(struct file *file, void *fh,
 190				 struct v4l2_format *f)
 191{
 192	struct capture_priv *priv = video_drvdata(file);
 193	const struct imx_media_pixfmt *cc;
 194
 195	if (vb2_is_busy(&priv->q)) {
 196		dev_err(priv->dev, "%s queue busy\n", __func__);
 197		return -EBUSY;
 198	}
 199
 200	cc = __capture_try_fmt(&f->fmt.pix, &priv->vdev.compose);
 201
 202	priv->vdev.cc = cc;
 203	priv->vdev.fmt = f->fmt.pix;
 204
 205	return 0;
 206}
 207
 208static int capture_g_selection(struct file *file, void *fh,
 209			       struct v4l2_selection *s)
 210{
 211	struct capture_priv *priv = video_drvdata(file);
 212
 213	switch (s->target) {
 214	case V4L2_SEL_TGT_COMPOSE:
 215	case V4L2_SEL_TGT_COMPOSE_DEFAULT:
 216	case V4L2_SEL_TGT_COMPOSE_BOUNDS:
 217		/* The compose rectangle is fixed to the source format. */
 218		s->r = priv->vdev.compose;
 219		break;
 220	case V4L2_SEL_TGT_COMPOSE_PADDED:
 221		/*
 222		 * The hardware writes with a configurable but fixed DMA burst
 223		 * size. If the source format width is not burst size aligned,
 224		 * the written frame contains padding to the right.
 225		 */
 226		s->r.left = 0;
 227		s->r.top = 0;
 228		s->r.width = priv->vdev.fmt.width;
 229		s->r.height = priv->vdev.fmt.height;
 230		break;
 231	default:
 232		return -EINVAL;
 233	}
 234
 235	return 0;
 236}
 237
 238static int capture_subscribe_event(struct v4l2_fh *fh,
 239				   const struct v4l2_event_subscription *sub)
 240{
 241	switch (sub->type) {
 242	case V4L2_EVENT_IMX_FRAME_INTERVAL_ERROR:
 243		return v4l2_event_subscribe(fh, sub, 0, NULL);
 244	default:
 245		return -EINVAL;
 246	}
 247}
 248
 249static const struct v4l2_ioctl_ops capture_ioctl_ops = {
 250	.vidioc_querycap		= capture_querycap,
 251
 252	.vidioc_enum_fmt_vid_cap	= capture_enum_fmt_vid_cap,
 253	.vidioc_enum_framesizes		= capture_enum_framesizes,
 254
 255	.vidioc_g_fmt_vid_cap		= capture_g_fmt_vid_cap,
 256	.vidioc_try_fmt_vid_cap		= capture_try_fmt_vid_cap,
 257	.vidioc_s_fmt_vid_cap		= capture_s_fmt_vid_cap,
 258
 259	.vidioc_g_selection		= capture_g_selection,
 260
 261	.vidioc_reqbufs			= vb2_ioctl_reqbufs,
 262	.vidioc_create_bufs		= vb2_ioctl_create_bufs,
 263	.vidioc_prepare_buf		= vb2_ioctl_prepare_buf,
 264	.vidioc_querybuf		= vb2_ioctl_querybuf,
 265	.vidioc_qbuf			= vb2_ioctl_qbuf,
 266	.vidioc_dqbuf			= vb2_ioctl_dqbuf,
 267	.vidioc_expbuf			= vb2_ioctl_expbuf,
 268	.vidioc_streamon		= vb2_ioctl_streamon,
 269	.vidioc_streamoff		= vb2_ioctl_streamoff,
 270
 271	.vidioc_subscribe_event		= capture_subscribe_event,
 272	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
 273};
 274
 275/* -----------------------------------------------------------------------------
 276 * Legacy Video IOCTLs
 277 */
 278
 279static int capture_legacy_enum_framesizes(struct file *file, void *fh,
 280					  struct v4l2_frmsizeenum *fsize)
 281{
 282	struct capture_priv *priv = video_drvdata(file);
 283	const struct imx_media_pixfmt *cc;
 284	struct v4l2_subdev_frame_size_enum fse = {
 285		.index = fsize->index,
 286		.pad = priv->src_sd_pad,
 287		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
 288	};
 289	int ret;
 290
 291	cc = imx_media_find_pixel_format(fsize->pixel_format, PIXFMT_SEL_ANY);
 292	if (!cc)
 293		return -EINVAL;
 294
 295	fse.code = cc->codes ? cc->codes[0] : 0;
 296
 297	ret = v4l2_subdev_call(priv->src_sd, pad, enum_frame_size, NULL, &fse);
 298	if (ret)
 299		return ret;
 300
 301	if (fse.min_width == fse.max_width &&
 302	    fse.min_height == fse.max_height) {
 303		fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
 304		fsize->discrete.width = fse.min_width;
 305		fsize->discrete.height = fse.min_height;
 306	} else {
 307		fsize->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
 308		fsize->stepwise.min_width = fse.min_width;
 309		fsize->stepwise.max_width = fse.max_width;
 310		fsize->stepwise.min_height = fse.min_height;
 311		fsize->stepwise.max_height = fse.max_height;
 312		fsize->stepwise.step_width = 1;
 313		fsize->stepwise.step_height = 1;
 314	}
 315
 316	return 0;
 317}
 318
 319static int capture_legacy_enum_frameintervals(struct file *file, void *fh,
 320					      struct v4l2_frmivalenum *fival)
 321{
 322	struct capture_priv *priv = video_drvdata(file);
 323	const struct imx_media_pixfmt *cc;
 324	struct v4l2_subdev_frame_interval_enum fie = {
 325		.index = fival->index,
 326		.pad = priv->src_sd_pad,
 327		.width = fival->width,
 328		.height = fival->height,
 329		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
 330	};
 331	int ret;
 332
 333	cc = imx_media_find_pixel_format(fival->pixel_format, PIXFMT_SEL_ANY);
 334	if (!cc)
 335		return -EINVAL;
 336
 337	fie.code = cc->codes ? cc->codes[0] : 0;
 338
 339	ret = v4l2_subdev_call(priv->src_sd, pad, enum_frame_interval,
 340			       NULL, &fie);
 341	if (ret)
 342		return ret;
 343
 344	fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
 345	fival->discrete = fie.interval;
 346
 347	return 0;
 348}
 349
 350static int capture_legacy_enum_fmt_vid_cap(struct file *file, void *fh,
 351					   struct v4l2_fmtdesc *f)
 352{
 353	struct capture_priv *priv = video_drvdata(file);
 354	const struct imx_media_pixfmt *cc_src;
 355	struct v4l2_subdev_format fmt_src = {
 356		.pad = priv->src_sd_pad,
 357		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
 358	};
 359	u32 fourcc;
 360	int ret;
 361
 362	ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
 363	if (ret) {
 364		dev_err(priv->dev, "failed to get src_sd format\n");
 365		return ret;
 366	}
 367
 368	cc_src = imx_media_find_ipu_format(fmt_src.format.code,
 369					   PIXFMT_SEL_YUV_RGB);
 370	if (cc_src) {
 371		enum imx_pixfmt_sel fmt_sel =
 372			(cc_src->cs == IPUV3_COLORSPACE_YUV) ?
 373			PIXFMT_SEL_YUV : PIXFMT_SEL_RGB;
 374
 375		ret = imx_media_enum_pixel_formats(&fourcc, f->index, fmt_sel,
 376						   0);
 377		if (ret)
 378			return ret;
 379	} else {
 380		cc_src = imx_media_find_mbus_format(fmt_src.format.code,
 381						    PIXFMT_SEL_ANY);
 382		if (WARN_ON(!cc_src))
 383			return -EINVAL;
 384
 385		if (f->index != 0)
 386			return -EINVAL;
 387		fourcc = cc_src->fourcc;
 388	}
 389
 390	f->pixelformat = fourcc;
 391
 392	return 0;
 393}
 394
 395static const struct imx_media_pixfmt *
 396__capture_legacy_try_fmt(struct capture_priv *priv,
 397			 struct v4l2_subdev_format *fmt_src,
 398			 struct v4l2_pix_format *pixfmt)
 399{
 400	const struct imx_media_pixfmt *cc;
 401
 402	cc = capture_find_format(fmt_src->format.code, pixfmt->pixelformat);
 403	if (WARN_ON(!cc))
 404		return NULL;
 405
 406	/* allow IDMAC interweave but enforce field order from source */
 407	if (V4L2_FIELD_IS_INTERLACED(pixfmt->field)) {
 408		switch (fmt_src->format.field) {
 409		case V4L2_FIELD_SEQ_TB:
 410			fmt_src->format.field = V4L2_FIELD_INTERLACED_TB;
 411			break;
 412		case V4L2_FIELD_SEQ_BT:
 413			fmt_src->format.field = V4L2_FIELD_INTERLACED_BT;
 414			break;
 415		default:
 416			break;
 417		}
 418	}
 419
 420	imx_media_mbus_fmt_to_pix_fmt(pixfmt, &fmt_src->format, cc);
 421
 422	return cc;
 423}
 424
 425static int capture_legacy_try_fmt_vid_cap(struct file *file, void *fh,
 426					  struct v4l2_format *f)
 427{
 428	struct capture_priv *priv = video_drvdata(file);
 429	struct v4l2_subdev_format fmt_src = {
 430		.pad = priv->src_sd_pad,
 431		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
 432	};
 433	int ret;
 434
 435	ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
 436	if (ret)
 437		return ret;
 438
 439	if (!__capture_legacy_try_fmt(priv, &fmt_src, &f->fmt.pix))
 440		return -EINVAL;
 441
 442	return 0;
 443}
 444
 445static int capture_legacy_s_fmt_vid_cap(struct file *file, void *fh,
 446					struct v4l2_format *f)
 447{
 448	struct capture_priv *priv = video_drvdata(file);
 449	struct v4l2_subdev_format fmt_src = {
 450		.pad = priv->src_sd_pad,
 451		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
 452	};
 453	const struct imx_media_pixfmt *cc;
 454	int ret;
 455
 456	if (vb2_is_busy(&priv->q)) {
 457		dev_err(priv->dev, "%s queue busy\n", __func__);
 458		return -EBUSY;
 459	}
 460
 461	ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
 462	if (ret)
 463		return ret;
 464
 465	cc = __capture_legacy_try_fmt(priv, &fmt_src, &f->fmt.pix);
 466	if (!cc)
 467		return -EINVAL;
 468
 469	priv->vdev.cc = cc;
 470	priv->vdev.fmt = f->fmt.pix;
 471	priv->vdev.compose.width = fmt_src.format.width;
 472	priv->vdev.compose.height = fmt_src.format.height;
 473
 474	return 0;
 475}
 476
 477static int capture_legacy_querystd(struct file *file, void *fh,
 478				   v4l2_std_id *std)
 479{
 480	struct capture_priv *priv = video_drvdata(file);
 481
 482	return v4l2_subdev_call(priv->src_sd, video, querystd, std);
 483}
 484
 485static int capture_legacy_g_std(struct file *file, void *fh, v4l2_std_id *std)
 486{
 487	struct capture_priv *priv = video_drvdata(file);
 488
 489	return v4l2_subdev_call(priv->src_sd, video, g_std, std);
 490}
 491
 492static int capture_legacy_s_std(struct file *file, void *fh, v4l2_std_id std)
 493{
 494	struct capture_priv *priv = video_drvdata(file);
 495
 496	if (vb2_is_busy(&priv->q))
 497		return -EBUSY;
 498
 499	return v4l2_subdev_call(priv->src_sd, video, s_std, std);
 500}
 501
 502static int capture_legacy_g_parm(struct file *file, void *fh,
 503				 struct v4l2_streamparm *a)
 504{
 505	struct capture_priv *priv = video_drvdata(file);
 506	struct v4l2_subdev_frame_interval fi = {
 507		.pad = priv->src_sd_pad,
 508	};
 509	int ret;
 510
 511	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 512		return -EINVAL;
 513
 514	ret = v4l2_subdev_call_state_active(priv->src_sd, pad,
 515					    get_frame_interval, &fi);
 516	if (ret < 0)
 517		return ret;
 518
 519	a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
 520	a->parm.capture.timeperframe = fi.interval;
 521
 522	return 0;
 523}
 524
 525static int capture_legacy_s_parm(struct file *file, void *fh,
 526				 struct v4l2_streamparm *a)
 527{
 528	struct capture_priv *priv = video_drvdata(file);
 529	struct v4l2_subdev_frame_interval fi = {
 530		.pad = priv->src_sd_pad,
 531	};
 532	int ret;
 533
 534	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 535		return -EINVAL;
 536
 537	fi.interval = a->parm.capture.timeperframe;
 538	ret = v4l2_subdev_call_state_active(priv->src_sd, pad,
 539					    set_frame_interval, &fi);
 540	if (ret < 0)
 541		return ret;
 542
 543	a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
 544	a->parm.capture.timeperframe = fi.interval;
 545
 546	return 0;
 547}
 548
 549static int capture_legacy_subscribe_event(struct v4l2_fh *fh,
 550					  const struct v4l2_event_subscription *sub)
 551{
 552	switch (sub->type) {
 553	case V4L2_EVENT_IMX_FRAME_INTERVAL_ERROR:
 554		return v4l2_event_subscribe(fh, sub, 0, NULL);
 555	case V4L2_EVENT_SOURCE_CHANGE:
 556		return v4l2_src_change_event_subscribe(fh, sub);
 557	case V4L2_EVENT_CTRL:
 558		return v4l2_ctrl_subscribe_event(fh, sub);
 559	default:
 560		return -EINVAL;
 561	}
 562}
 563
 564static const struct v4l2_ioctl_ops capture_legacy_ioctl_ops = {
 565	.vidioc_querycap		= capture_querycap,
 566
 567	.vidioc_enum_framesizes		= capture_legacy_enum_framesizes,
 568	.vidioc_enum_frameintervals	= capture_legacy_enum_frameintervals,
 569
 570	.vidioc_enum_fmt_vid_cap	= capture_legacy_enum_fmt_vid_cap,
 571	.vidioc_g_fmt_vid_cap		= capture_g_fmt_vid_cap,
 572	.vidioc_try_fmt_vid_cap		= capture_legacy_try_fmt_vid_cap,
 573	.vidioc_s_fmt_vid_cap		= capture_legacy_s_fmt_vid_cap,
 574
 575	.vidioc_querystd		= capture_legacy_querystd,
 576	.vidioc_g_std			= capture_legacy_g_std,
 577	.vidioc_s_std			= capture_legacy_s_std,
 578
 579	.vidioc_g_selection		= capture_g_selection,
 580
 581	.vidioc_g_parm			= capture_legacy_g_parm,
 582	.vidioc_s_parm			= capture_legacy_s_parm,
 583
 584	.vidioc_reqbufs			= vb2_ioctl_reqbufs,
 585	.vidioc_create_bufs		= vb2_ioctl_create_bufs,
 586	.vidioc_prepare_buf		= vb2_ioctl_prepare_buf,
 587	.vidioc_querybuf		= vb2_ioctl_querybuf,
 588	.vidioc_qbuf			= vb2_ioctl_qbuf,
 589	.vidioc_dqbuf			= vb2_ioctl_dqbuf,
 590	.vidioc_expbuf			= vb2_ioctl_expbuf,
 591	.vidioc_streamon		= vb2_ioctl_streamon,
 592	.vidioc_streamoff		= vb2_ioctl_streamoff,
 593
 594	.vidioc_subscribe_event		= capture_legacy_subscribe_event,
 595	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
 596};
 597
 598/* -----------------------------------------------------------------------------
 599 * Queue Operations
 600 */
 601
 602static int capture_queue_setup(struct vb2_queue *vq,
 603			       unsigned int *nbuffers,
 604			       unsigned int *nplanes,
 605			       unsigned int sizes[],
 606			       struct device *alloc_devs[])
 607{
 608	struct capture_priv *priv = vb2_get_drv_priv(vq);
 609	struct v4l2_pix_format *pix = &priv->vdev.fmt;
 610	unsigned int q_num_bufs = vb2_get_num_buffers(vq);
 611	unsigned int count = *nbuffers;
 612
 613	if (vq->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 614		return -EINVAL;
 615
 616	if (*nplanes) {
 617		if (*nplanes != 1 || sizes[0] < pix->sizeimage)
 618			return -EINVAL;
 619		count += q_num_bufs;
 620	}
 621
 622	count = min_t(__u32, VID_MEM_LIMIT / pix->sizeimage, count);
 623
 624	if (*nplanes)
 625		*nbuffers = (count < q_num_bufs) ? 0 :
 626			count - q_num_bufs;
 627	else
 628		*nbuffers = count;
 629
 630	*nplanes = 1;
 631	sizes[0] = pix->sizeimage;
 632
 633	return 0;
 634}
 635
 636static int capture_buf_init(struct vb2_buffer *vb)
 637{
 638	struct imx_media_buffer *buf = to_imx_media_vb(vb);
 639
 640	INIT_LIST_HEAD(&buf->list);
 641
 642	return 0;
 643}
 644
 645static int capture_buf_prepare(struct vb2_buffer *vb)
 646{
 647	struct vb2_queue *vq = vb->vb2_queue;
 648	struct capture_priv *priv = vb2_get_drv_priv(vq);
 649	struct v4l2_pix_format *pix = &priv->vdev.fmt;
 650
 651	if (vb2_plane_size(vb, 0) < pix->sizeimage) {
 652		dev_err(priv->dev,
 653			"data will not fit into plane (%lu < %lu)\n",
 654			vb2_plane_size(vb, 0), (long)pix->sizeimage);
 655		return -EINVAL;
 656	}
 657
 658	vb2_set_plane_payload(vb, 0, pix->sizeimage);
 659
 660	return 0;
 661}
 662
 663static void capture_buf_queue(struct vb2_buffer *vb)
 664{
 665	struct capture_priv *priv = vb2_get_drv_priv(vb->vb2_queue);
 666	struct imx_media_buffer *buf = to_imx_media_vb(vb);
 667	unsigned long flags;
 668
 669	spin_lock_irqsave(&priv->q_lock, flags);
 670
 671	list_add_tail(&buf->list, &priv->ready_q);
 672
 673	spin_unlock_irqrestore(&priv->q_lock, flags);
 674}
 675
 676static int capture_validate_fmt(struct capture_priv *priv)
 677{
 678	struct v4l2_subdev_format fmt_src = {
 679		.pad = priv->src_sd_pad,
 680		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
 681	};
 682	const struct imx_media_pixfmt *cc;
 683	int ret;
 684
 685	/* Retrieve the media bus format on the source subdev. */
 686	ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL, &fmt_src);
 687	if (ret)
 688		return ret;
 689
 690	/*
 691	 * Verify that the media bus size matches the size set on the video
 692	 * node. It is sufficient to check the compose rectangle size without
 693	 * checking the rounded size from vdev.fmt, as the rounded size is
 694	 * derived directly from the compose rectangle size, and will thus
 695	 * always match if the compose rectangle matches.
 696	 */
 697	if (priv->vdev.compose.width != fmt_src.format.width ||
 698	    priv->vdev.compose.height != fmt_src.format.height)
 699		return -EPIPE;
 700
 701	/*
 702	 * Verify that the media bus code is compatible with the pixel format
 703	 * set on the video node.
 704	 */
 705	cc = capture_find_format(fmt_src.format.code, 0);
 706	if (!cc || priv->vdev.cc->cs != cc->cs)
 707		return -EPIPE;
 708
 709	return 0;
 710}
 711
 712static int capture_start_streaming(struct vb2_queue *vq, unsigned int count)
 713{
 714	struct capture_priv *priv = vb2_get_drv_priv(vq);
 715	struct imx_media_buffer *buf, *tmp;
 716	unsigned long flags;
 717	int ret;
 718
 719	ret = capture_validate_fmt(priv);
 720	if (ret) {
 721		dev_err(priv->dev, "capture format not valid\n");
 722		goto return_bufs;
 723	}
 724
 725	ret = imx_media_pipeline_set_stream(priv->md, &priv->src_sd->entity,
 726					    true);
 727	if (ret) {
 728		dev_err(priv->dev, "pipeline start failed with %d\n", ret);
 729		goto return_bufs;
 730	}
 731
 732	return 0;
 733
 734return_bufs:
 735	spin_lock_irqsave(&priv->q_lock, flags);
 736	list_for_each_entry_safe(buf, tmp, &priv->ready_q, list) {
 737		list_del(&buf->list);
 738		vb2_buffer_done(&buf->vbuf.vb2_buf, VB2_BUF_STATE_QUEUED);
 739	}
 740	spin_unlock_irqrestore(&priv->q_lock, flags);
 741	return ret;
 742}
 743
 744static void capture_stop_streaming(struct vb2_queue *vq)
 745{
 746	struct capture_priv *priv = vb2_get_drv_priv(vq);
 747	struct imx_media_buffer *frame;
 748	struct imx_media_buffer *tmp;
 749	unsigned long flags;
 750	int ret;
 751
 752	ret = imx_media_pipeline_set_stream(priv->md, &priv->src_sd->entity,
 753					    false);
 754	if (ret)
 755		dev_warn(priv->dev, "pipeline stop failed with %d\n", ret);
 756
 757	/* release all active buffers */
 758	spin_lock_irqsave(&priv->q_lock, flags);
 759	list_for_each_entry_safe(frame, tmp, &priv->ready_q, list) {
 760		list_del(&frame->list);
 761		vb2_buffer_done(&frame->vbuf.vb2_buf, VB2_BUF_STATE_ERROR);
 762	}
 763	spin_unlock_irqrestore(&priv->q_lock, flags);
 764}
 765
 766static const struct vb2_ops capture_qops = {
 767	.queue_setup	 = capture_queue_setup,
 768	.buf_init        = capture_buf_init,
 769	.buf_prepare	 = capture_buf_prepare,
 770	.buf_queue	 = capture_buf_queue,
 771	.start_streaming = capture_start_streaming,
 772	.stop_streaming  = capture_stop_streaming,
 773};
 774
 775/* -----------------------------------------------------------------------------
 776 * File Operations
 777 */
 778
 779static int capture_open(struct file *file)
 780{
 781	struct capture_priv *priv = video_drvdata(file);
 782	struct video_device *vfd = priv->vdev.vfd;
 783	int ret;
 784
 785	if (mutex_lock_interruptible(&priv->mutex))
 786		return -ERESTARTSYS;
 787
 788	ret = v4l2_fh_open(file);
 789	if (ret) {
 790		dev_err(priv->dev, "v4l2_fh_open failed\n");
 791		goto out;
 792	}
 793
 794	ret = v4l2_pipeline_pm_get(&vfd->entity);
 795	if (ret)
 796		v4l2_fh_release(file);
 797
 798out:
 799	mutex_unlock(&priv->mutex);
 800	return ret;
 801}
 802
 803static int capture_release(struct file *file)
 804{
 805	struct capture_priv *priv = video_drvdata(file);
 806	struct video_device *vfd = priv->vdev.vfd;
 807	struct vb2_queue *vq = &priv->q;
 808
 809	mutex_lock(&priv->mutex);
 810
 811	if (file->private_data == vq->owner) {
 812		vb2_queue_release(vq);
 813		vq->owner = NULL;
 814	}
 815
 816	v4l2_pipeline_pm_put(&vfd->entity);
 817
 818	v4l2_fh_release(file);
 819	mutex_unlock(&priv->mutex);
 820	return 0;
 821}
 822
 823static const struct v4l2_file_operations capture_fops = {
 824	.owner		= THIS_MODULE,
 825	.open		= capture_open,
 826	.release	= capture_release,
 827	.poll		= vb2_fop_poll,
 828	.unlocked_ioctl	= video_ioctl2,
 829	.mmap		= vb2_fop_mmap,
 830};
 831
 832/* -----------------------------------------------------------------------------
 833 * Public API
 834 */
 835
 836struct imx_media_buffer *
 837imx_media_capture_device_next_buf(struct imx_media_video_dev *vdev)
 838{
 839	struct capture_priv *priv = to_capture_priv(vdev);
 840	struct imx_media_buffer *buf = NULL;
 841	unsigned long flags;
 842
 843	spin_lock_irqsave(&priv->q_lock, flags);
 844
 845	/* get next queued buffer */
 846	if (!list_empty(&priv->ready_q)) {
 847		buf = list_entry(priv->ready_q.next, struct imx_media_buffer,
 848				 list);
 849		list_del(&buf->list);
 850	}
 851
 852	spin_unlock_irqrestore(&priv->q_lock, flags);
 853
 854	return buf;
 855}
 856EXPORT_SYMBOL_GPL(imx_media_capture_device_next_buf);
 857
 858void imx_media_capture_device_error(struct imx_media_video_dev *vdev)
 859{
 860	struct capture_priv *priv = to_capture_priv(vdev);
 861	struct vb2_queue *vq = &priv->q;
 862	unsigned long flags;
 863
 864	if (!vb2_is_streaming(vq))
 865		return;
 866
 867	spin_lock_irqsave(&priv->q_lock, flags);
 868	vb2_queue_error(vq);
 869	spin_unlock_irqrestore(&priv->q_lock, flags);
 870}
 871EXPORT_SYMBOL_GPL(imx_media_capture_device_error);
 872
 873static int capture_init_format(struct capture_priv *priv)
 874{
 875	struct v4l2_subdev_format fmt_src = {
 876		.pad = priv->src_sd_pad,
 877		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
 878	};
 879	struct imx_media_video_dev *vdev = &priv->vdev;
 880	int ret;
 881
 882	if (priv->legacy_api) {
 883		ret = v4l2_subdev_call(priv->src_sd, pad, get_fmt, NULL,
 884				       &fmt_src);
 885		if (ret) {
 886			dev_err(priv->dev, "failed to get source format\n");
 887			return ret;
 888		}
 889	} else {
 890		fmt_src.format.code = MEDIA_BUS_FMT_UYVY8_2X8;
 891		fmt_src.format.width = IMX_MEDIA_DEF_PIX_WIDTH;
 892		fmt_src.format.height = IMX_MEDIA_DEF_PIX_HEIGHT;
 893	}
 894
 895	imx_media_mbus_fmt_to_pix_fmt(&vdev->fmt, &fmt_src.format, NULL);
 896	vdev->compose.width = fmt_src.format.width;
 897	vdev->compose.height = fmt_src.format.height;
 898
 899	vdev->cc = imx_media_find_pixel_format(vdev->fmt.pixelformat,
 900					       PIXFMT_SEL_ANY);
 901
 902	return 0;
 903}
 904
 905int imx_media_capture_device_register(struct imx_media_video_dev *vdev,
 906				      u32 link_flags)
 907{
 908	struct capture_priv *priv = to_capture_priv(vdev);
 909	struct v4l2_subdev *sd = priv->src_sd;
 910	struct v4l2_device *v4l2_dev = sd->v4l2_dev;
 911	struct video_device *vfd = vdev->vfd;
 912	int ret;
 913
 914	/* get media device */
 915	priv->md = container_of(v4l2_dev->mdev, struct imx_media_dev, md);
 916
 917	vfd->v4l2_dev = v4l2_dev;
 918
 919	/* Initialize the default format and compose rectangle. */
 920	ret = capture_init_format(priv);
 921	if (ret < 0)
 922		return ret;
 923
 924	/* Register the video device. */
 925	ret = video_register_device(vfd, VFL_TYPE_VIDEO, -1);
 926	if (ret) {
 927		dev_err(priv->dev, "Failed to register video device\n");
 928		return ret;
 929	}
 930
 931	dev_info(priv->dev, "Registered %s as /dev/%s\n", vfd->name,
 932		 video_device_node_name(vfd));
 933
 934	/* Create the link from the src_sd devnode pad to device node. */
 935	if (link_flags & MEDIA_LNK_FL_IMMUTABLE)
 936		link_flags |= MEDIA_LNK_FL_ENABLED;
 937	ret = media_create_pad_link(&sd->entity, priv->src_sd_pad,
 938				    &vfd->entity, 0, link_flags);
 939	if (ret) {
 940		dev_err(priv->dev, "failed to create link to device node\n");
 941		video_unregister_device(vfd);
 942		return ret;
 943	}
 944
 945	/* Add vdev to the video devices list. */
 946	imx_media_add_video_device(priv->md, vdev);
 947
 948	return 0;
 949}
 950EXPORT_SYMBOL_GPL(imx_media_capture_device_register);
 951
 952void imx_media_capture_device_unregister(struct imx_media_video_dev *vdev)
 953{
 954	struct capture_priv *priv = to_capture_priv(vdev);
 955	struct video_device *vfd = priv->vdev.vfd;
 956
 957	media_entity_cleanup(&vfd->entity);
 958	video_unregister_device(vfd);
 959}
 960EXPORT_SYMBOL_GPL(imx_media_capture_device_unregister);
 961
 962struct imx_media_video_dev *
 963imx_media_capture_device_init(struct device *dev, struct v4l2_subdev *src_sd,
 964			      int pad, bool legacy_api)
 965{
 966	struct capture_priv *priv;
 967	struct video_device *vfd;
 968	struct vb2_queue *vq;
 969	int ret;
 970
 971	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 972	if (!priv)
 973		return ERR_PTR(-ENOMEM);
 974
 975	priv->src_sd = src_sd;
 976	priv->src_sd_pad = pad;
 977	priv->dev = dev;
 978	priv->legacy_api = legacy_api;
 979
 980	mutex_init(&priv->mutex);
 981	INIT_LIST_HEAD(&priv->ready_q);
 982	spin_lock_init(&priv->q_lock);
 983
 984	/* Allocate and initialize the video device. */
 985	vfd = video_device_alloc();
 986	if (!vfd)
 987		return ERR_PTR(-ENOMEM);
 988
 989	vfd->fops = &capture_fops;
 990	vfd->ioctl_ops = legacy_api ? &capture_legacy_ioctl_ops
 991		       : &capture_ioctl_ops;
 992	vfd->minor = -1;
 993	vfd->release = video_device_release;
 994	vfd->vfl_dir = VFL_DIR_RX;
 995	vfd->tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM;
 996	vfd->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING
 997			 | (!legacy_api ? V4L2_CAP_IO_MC : 0);
 998	vfd->lock = &priv->mutex;
 999	vfd->queue = &priv->q;
1000
1001	snprintf(vfd->name, sizeof(vfd->name), "%s capture", src_sd->name);
1002
1003	video_set_drvdata(vfd, priv);
1004	priv->vdev.vfd = vfd;
1005	INIT_LIST_HEAD(&priv->vdev.list);
1006
1007	/* Initialize the video device pad. */
1008	priv->vdev_pad.flags = MEDIA_PAD_FL_SINK;
1009	ret = media_entity_pads_init(&vfd->entity, 1, &priv->vdev_pad);
1010	if (ret) {
1011		video_device_release(vfd);
1012		return ERR_PTR(ret);
1013	}
1014
1015	/* Initialize the vb2 queue. */
1016	vq = &priv->q;
1017	vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1018	vq->io_modes = VB2_MMAP | VB2_DMABUF;
1019	vq->drv_priv = priv;
1020	vq->buf_struct_size = sizeof(struct imx_media_buffer);
1021	vq->ops = &capture_qops;
1022	vq->mem_ops = &vb2_dma_contig_memops;
1023	vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1024	vq->lock = &priv->mutex;
1025	vq->min_queued_buffers = 2;
1026	vq->dev = priv->dev;
1027
1028	ret = vb2_queue_init(vq);
1029	if (ret) {
1030		dev_err(priv->dev, "vb2_queue_init failed\n");
1031		video_device_release(vfd);
1032		return ERR_PTR(ret);
1033	}
1034
1035	if (legacy_api) {
1036		/* Initialize the control handler. */
1037		v4l2_ctrl_handler_init(&priv->ctrl_hdlr, 0);
1038		vfd->ctrl_handler = &priv->ctrl_hdlr;
1039	}
1040
1041	return &priv->vdev;
1042}
1043EXPORT_SYMBOL_GPL(imx_media_capture_device_init);
1044
1045void imx_media_capture_device_remove(struct imx_media_video_dev *vdev)
1046{
1047	struct capture_priv *priv = to_capture_priv(vdev);
1048
1049	v4l2_ctrl_handler_free(&priv->ctrl_hdlr);
1050}
1051EXPORT_SYMBOL_GPL(imx_media_capture_device_remove);
1052
1053MODULE_DESCRIPTION("i.MX5/6 v4l2 video capture interface driver");
1054MODULE_AUTHOR("Steve Longerbeam <steve_longerbeam@mentor.com>");
1055MODULE_LICENSE("GPL");