delta-v4l2.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (C) STMicroelectronics SA 2015
   4 * Authors: Hugues Fruchet <hugues.fruchet@st.com>
   5 *          Jean-Christophe Trotin <jean-christophe.trotin@st.com>
   6 *          for STMicroelectronics.
   7 */
   8
   9#include <linux/clk.h>
  10#include <linux/module.h>
  11#include <linux/platform_device.h>
  12#include <linux/pm_runtime.h>
  13#include <linux/slab.h>
  14
  15#include <media/v4l2-ioctl.h>
  16#include <media/v4l2-event.h>
  17#include <media/videobuf2-dma-contig.h>
  18
  19#include "delta.h"
  20#include "delta-debug.h"
  21#include "delta-ipc.h"
  22
  23#define DELTA_NAME	"st-delta"
  24
  25#define DELTA_PREFIX "[---:----]"
  26
  27static inline struct delta_ctx *file_to_ctx(struct file *filp)
  28{
  29	return container_of(file_to_v4l2_fh(filp), struct delta_ctx, fh);
  30}
  31
  32#define to_au(__vbuf) container_of(__vbuf, struct delta_au, vbuf)
  33#define to_frame(__vbuf) container_of(__vbuf, struct delta_frame, vbuf)
  34
  35#define call_dec_op(dec, op, args...)\
  36		((dec && (dec)->op) ? (dec)->op(args) : 0)
  37
  38/* registry of available decoders */
  39static const struct delta_dec *delta_decoders[] = {
  40#ifdef CONFIG_VIDEO_STI_DELTA_MJPEG
  41	&mjpegdec,
  42#endif
  43};
  44
  45static inline int frame_size(u32 w, u32 h, u32 fmt)
  46{
  47	switch (fmt) {
  48	case V4L2_PIX_FMT_NV12:
  49		return (w * h * 3) / 2;
  50	default:
  51		return 0;
  52	}
  53}
  54
  55static inline int frame_stride(u32 w, u32 fmt)
  56{
  57	switch (fmt) {
  58	case V4L2_PIX_FMT_NV12:
  59		return w;
  60	default:
  61		return 0;
  62	}
  63}
  64
  65static void dump_au(struct delta_ctx *ctx, struct delta_au *au)
  66{
  67	struct delta_dev *delta = ctx->dev;
  68	u32 size = 10;	/* dump first & last 10 bytes */
  69	u8 *data = (u8 *)(au->vaddr);
  70
  71	if (au->size <= (size * 2))
  72		dev_dbg(delta->dev, "%s dump au[%d] dts=%lld size=%d data=%*ph\n",
  73			ctx->name, au->vbuf.vb2_buf.index, au->dts, au->size,
  74			au->size, data);
  75	else
  76		dev_dbg(delta->dev, "%s dump au[%d] dts=%lld size=%d data=%*ph..%*ph\n",
  77			ctx->name, au->vbuf.vb2_buf.index, au->dts, au->size,
  78			size, data, size, data + au->size - size);
  79}
  80
  81static void dump_frame(struct delta_ctx *ctx, struct delta_frame *frame)
  82{
  83	struct delta_dev *delta = ctx->dev;
  84	u32 size = 10;	/* dump first 10 bytes */
  85	u8 *data = (u8 *)(frame->vaddr);
  86
  87	dev_dbg(delta->dev, "%s dump frame[%d] dts=%lld type=%s field=%s data=%*ph\n",
  88		ctx->name, frame->index, frame->dts,
  89		frame_type_str(frame->flags),
  90		frame_field_str(frame->field),
  91		size, data);
  92}
  93
  94static void delta_au_done(struct delta_ctx *ctx, struct delta_au *au, int err)
  95{
  96	struct vb2_v4l2_buffer *vbuf;
  97
  98	vbuf = &au->vbuf;
  99	vbuf->sequence = ctx->au_num++;
 100	v4l2_m2m_buf_done(vbuf, err ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
 101}
 102
 103static void delta_frame_done(struct delta_ctx *ctx, struct delta_frame *frame,
 104			     int err)
 105{
 106	struct vb2_v4l2_buffer *vbuf;
 107
 108	dump_frame(ctx, frame);
 109
 110	/* decoded frame is now output to user */
 111	frame->state |= DELTA_FRAME_OUT;
 112
 113	vbuf = &frame->vbuf;
 114	vbuf->sequence = ctx->frame_num++;
 115	v4l2_m2m_buf_done(vbuf, err ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
 116
 117	if (frame->info.size) /* ignore EOS */
 118		ctx->output_frames++;
 119}
 120
 121static void requeue_free_frames(struct delta_ctx *ctx)
 122{
 123	struct vb2_v4l2_buffer *vbuf;
 124	struct delta_frame *frame;
 125	unsigned int i;
 126
 127	/* requeue all free frames */
 128	for (i = 0; i < ctx->nb_of_frames; i++) {
 129		frame = ctx->frames[i];
 130		if (frame->state == DELTA_FRAME_FREE) {
 131			vbuf = &frame->vbuf;
 132			v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
 133			frame->state = DELTA_FRAME_M2M;
 134		}
 135	}
 136}
 137
 138static int delta_recycle(struct delta_ctx *ctx, struct delta_frame *frame)
 139{
 140	const struct delta_dec *dec = ctx->dec;
 141
 142	/* recycle frame on decoder side */
 143	call_dec_op(dec, recycle, ctx, frame);
 144
 145	/* this frame is no more output */
 146	frame->state &= ~DELTA_FRAME_OUT;
 147
 148	/* requeue free frame */
 149	if (frame->state == DELTA_FRAME_FREE) {
 150		struct vb2_v4l2_buffer *vbuf = &frame->vbuf;
 151
 152		v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
 153		frame->state = DELTA_FRAME_M2M;
 154	}
 155
 156	/* reset other frame fields */
 157	frame->flags = 0;
 158	frame->dts = 0;
 159
 160	return 0;
 161}
 162
 163static void delta_push_dts(struct delta_ctx *ctx, u64 val)
 164{
 165	struct delta_dts *dts;
 166
 167	dts = kzalloc(sizeof(*dts), GFP_KERNEL);
 168	if (!dts)
 169		return;
 170
 171	INIT_LIST_HEAD(&dts->list);
 172
 173	/*
 174	 * protected by global lock acquired
 175	 * by V4L2 when calling delta_vb2_au_queue
 176	 */
 177	dts->val = val;
 178	list_add_tail(&dts->list, &ctx->dts);
 179}
 180
 181static void delta_pop_dts(struct delta_ctx *ctx, u64 *val)
 182{
 183	struct delta_dev *delta = ctx->dev;
 184	struct delta_dts *dts;
 185
 186	/*
 187	 * protected by global lock acquired
 188	 * by V4L2 when calling delta_vb2_au_queue
 189	 */
 190	if (list_empty(&ctx->dts)) {
 191		dev_warn(delta->dev, "%s no dts to pop ... output dts = 0\n",
 192			 ctx->name);
 193		*val = 0;
 194		return;
 195	}
 196
 197	dts = list_first_entry(&ctx->dts, struct delta_dts, list);
 198	list_del(&dts->list);
 199
 200	*val = dts->val;
 201
 202	kfree(dts);
 203}
 204
 205static void delta_flush_dts(struct delta_ctx *ctx)
 206{
 207	struct delta_dts *dts;
 208	struct delta_dts *next;
 209
 210	/*
 211	 * protected by global lock acquired
 212	 * by V4L2 when calling delta_vb2_au_queue
 213	 */
 214
 215	/* free all pending dts */
 216	list_for_each_entry_safe(dts, next, &ctx->dts, list)
 217		kfree(dts);
 218
 219	/* reset list */
 220	INIT_LIST_HEAD(&ctx->dts);
 221}
 222
 223static inline int frame_alignment(u32 fmt)
 224{
 225	switch (fmt) {
 226	case V4L2_PIX_FMT_NV12:
 227	case V4L2_PIX_FMT_NV21:
 228		/* multiple of 2 */
 229		return 2;
 230	default:
 231		return 1;
 232	}
 233}
 234
 235static inline int estimated_au_size(u32 w, u32 h)
 236{
 237	/*
 238	 * for a MJPEG stream encoded from YUV422 pixel format,
 239	 * assuming a compression ratio of 2, the maximum size
 240	 * of an access unit is (width x height x 2) / 2,
 241	 * so (width x height)
 242	 */
 243	return (w * h);
 244}
 245
 246static void set_default_params(struct delta_ctx *ctx)
 247{
 248	struct delta_frameinfo *frameinfo = &ctx->frameinfo;
 249	struct delta_streaminfo *streaminfo = &ctx->streaminfo;
 250
 251	memset(frameinfo, 0, sizeof(*frameinfo));
 252	frameinfo->pixelformat = V4L2_PIX_FMT_NV12;
 253	frameinfo->width = DELTA_DEFAULT_WIDTH;
 254	frameinfo->height = DELTA_DEFAULT_HEIGHT;
 255	frameinfo->aligned_width = ALIGN(frameinfo->width,
 256					 DELTA_WIDTH_ALIGNMENT);
 257	frameinfo->aligned_height = ALIGN(frameinfo->height,
 258					  DELTA_HEIGHT_ALIGNMENT);
 259	frameinfo->size = frame_size(frameinfo->aligned_width,
 260				     frameinfo->aligned_height,
 261				     frameinfo->pixelformat);
 262	frameinfo->field = V4L2_FIELD_NONE;
 263	frameinfo->colorspace = V4L2_COLORSPACE_REC709;
 264	frameinfo->xfer_func = V4L2_XFER_FUNC_DEFAULT;
 265	frameinfo->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
 266	frameinfo->quantization = V4L2_QUANTIZATION_DEFAULT;
 267
 268	memset(streaminfo, 0, sizeof(*streaminfo));
 269	streaminfo->streamformat = DELTA_DEFAULT_STREAMFORMAT;
 270	streaminfo->width = DELTA_DEFAULT_WIDTH;
 271	streaminfo->height = DELTA_DEFAULT_HEIGHT;
 272	streaminfo->field = V4L2_FIELD_NONE;
 273	streaminfo->colorspace = V4L2_COLORSPACE_REC709;
 274	streaminfo->xfer_func = V4L2_XFER_FUNC_DEFAULT;
 275	streaminfo->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
 276	streaminfo->quantization = V4L2_QUANTIZATION_DEFAULT;
 277
 278	ctx->max_au_size = estimated_au_size(streaminfo->width,
 279					     streaminfo->height);
 280}
 281
 282static const struct delta_dec *delta_find_decoder(struct delta_ctx *ctx,
 283						  u32 streamformat,
 284						  u32 pixelformat)
 285{
 286	struct delta_dev *delta = ctx->dev;
 287	const struct delta_dec *dec;
 288	unsigned int i;
 289
 290	for (i = 0; i < delta->nb_of_decoders; i++) {
 291		dec = delta->decoders[i];
 292		if ((dec->pixelformat == pixelformat) &&
 293		    (dec->streamformat == streamformat))
 294			return dec;
 295	}
 296
 297	return NULL;
 298}
 299
 300static void register_format(u32 format, u32 formats[], u32 *nb_of_formats)
 301{
 302	u32 i;
 303
 304	for (i = 0; i < *nb_of_formats; i++) {
 305		if (format == formats[i])
 306			return;
 307	}
 308
 309	formats[(*nb_of_formats)++] = format;
 310}
 311
 312static void register_formats(struct delta_dev *delta)
 313{
 314	unsigned int i;
 315
 316	for (i = 0; i < delta->nb_of_decoders; i++) {
 317		register_format(delta->decoders[i]->pixelformat,
 318				delta->pixelformats,
 319				&delta->nb_of_pixelformats);
 320
 321		register_format(delta->decoders[i]->streamformat,
 322				delta->streamformats,
 323				&delta->nb_of_streamformats);
 324	}
 325}
 326
 327static void register_decoders(struct delta_dev *delta)
 328{
 329	unsigned int i;
 330
 331	for (i = 0; i < ARRAY_SIZE(delta_decoders); i++) {
 332		if (delta->nb_of_decoders >= DELTA_MAX_DECODERS) {
 333			dev_dbg(delta->dev,
 334				"%s failed to register %s decoder (%d maximum reached)\n",
 335				DELTA_PREFIX, delta_decoders[i]->name,
 336				DELTA_MAX_DECODERS);
 337			return;
 338		}
 339
 340		delta->decoders[delta->nb_of_decoders++] = delta_decoders[i];
 341		dev_info(delta->dev, "%s %s decoder registered\n",
 342			 DELTA_PREFIX, delta_decoders[i]->name);
 343	}
 344}
 345
 346static int delta_open_decoder(struct delta_ctx *ctx, u32 streamformat,
 347			      u32 pixelformat, const struct delta_dec **pdec)
 348{
 349	struct delta_dev *delta = ctx->dev;
 350	const struct delta_dec *dec;
 351	int ret;
 352
 353	dec = delta_find_decoder(ctx, streamformat, ctx->frameinfo.pixelformat);
 354	if (!dec) {
 355		dev_err(delta->dev, "%s no decoder found matching %4.4s => %4.4s\n",
 356			ctx->name, (char *)&streamformat, (char *)&pixelformat);
 357		return -EINVAL;
 358	}
 359
 360	dev_dbg(delta->dev, "%s one decoder matching %4.4s => %4.4s\n",
 361		ctx->name, (char *)&streamformat, (char *)&pixelformat);
 362
 363	/* update instance name */
 364	snprintf(ctx->name, sizeof(ctx->name), "[%3d:%4.4s]",
 365		 delta->instance_id, (char *)&streamformat);
 366
 367	/* open decoder instance */
 368	ret = call_dec_op(dec, open, ctx);
 369	if (ret) {
 370		dev_err(delta->dev, "%s failed to open decoder instance (%d)\n",
 371			ctx->name, ret);
 372		return ret;
 373	}
 374
 375	dev_dbg(delta->dev, "%s %s decoder opened\n", ctx->name, dec->name);
 376
 377	*pdec = dec;
 378
 379	return ret;
 380}
 381
 382/*
 383 * V4L2 ioctl operations
 384 */
 385
 386static int delta_querycap(struct file *file, void *priv,
 387			  struct v4l2_capability *cap)
 388{
 389	struct delta_ctx *ctx = file_to_ctx(file);
 390	struct delta_dev *delta = ctx->dev;
 391
 392	strscpy(cap->driver, DELTA_NAME, sizeof(cap->driver));
 393	strscpy(cap->card, delta->vdev->name, sizeof(cap->card));
 394	snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
 395		 delta->pdev->name);
 396
 397	return 0;
 398}
 399
 400static int delta_enum_fmt_stream(struct file *file, void *priv,
 401				 struct v4l2_fmtdesc *f)
 402{
 403	struct delta_ctx *ctx = file_to_ctx(file);
 404	struct delta_dev *delta = ctx->dev;
 405
 406	if (unlikely(f->index >= delta->nb_of_streamformats))
 407		return -EINVAL;
 408
 409	f->pixelformat = delta->streamformats[f->index];
 410
 411	return 0;
 412}
 413
 414static int delta_enum_fmt_frame(struct file *file, void *priv,
 415				struct v4l2_fmtdesc *f)
 416{
 417	struct delta_ctx *ctx = file_to_ctx(file);
 418	struct delta_dev *delta = ctx->dev;
 419
 420	if (unlikely(f->index >= delta->nb_of_pixelformats))
 421		return -EINVAL;
 422
 423	f->pixelformat = delta->pixelformats[f->index];
 424
 425	return 0;
 426}
 427
 428static int delta_g_fmt_stream(struct file *file, void *fh,
 429			      struct v4l2_format *f)
 430{
 431	struct delta_ctx *ctx = file_to_ctx(file);
 432	struct delta_dev *delta = ctx->dev;
 433	struct v4l2_pix_format *pix = &f->fmt.pix;
 434	struct delta_streaminfo *streaminfo = &ctx->streaminfo;
 435	unsigned char str[100] = "";
 436
 437	if (!(ctx->flags & DELTA_FLAG_STREAMINFO))
 438		dev_dbg(delta->dev,
 439			"%s V4L2 GET_FMT (OUTPUT): no stream information available, default to %s\n",
 440			ctx->name,
 441			delta_streaminfo_str(streaminfo, str, sizeof(str)));
 442
 443	pix->pixelformat = streaminfo->streamformat;
 444	pix->width = streaminfo->width;
 445	pix->height = streaminfo->height;
 446	pix->field = streaminfo->field;
 447	pix->bytesperline = 0;
 448	pix->sizeimage = ctx->max_au_size;
 449	pix->colorspace = streaminfo->colorspace;
 450	pix->xfer_func = streaminfo->xfer_func;
 451	pix->ycbcr_enc = streaminfo->ycbcr_enc;
 452	pix->quantization = streaminfo->quantization;
 453
 454	return 0;
 455}
 456
 457static int delta_g_fmt_frame(struct file *file, void *fh, struct v4l2_format *f)
 458{
 459	struct delta_ctx *ctx = file_to_ctx(file);
 460	struct delta_dev *delta = ctx->dev;
 461	struct v4l2_pix_format *pix = &f->fmt.pix;
 462	struct delta_frameinfo *frameinfo = &ctx->frameinfo;
 463	struct delta_streaminfo *streaminfo = &ctx->streaminfo;
 464	unsigned char str[100] = "";
 465
 466	if (!(ctx->flags & DELTA_FLAG_FRAMEINFO))
 467		dev_dbg(delta->dev,
 468			"%s V4L2 GET_FMT (CAPTURE): no frame information available, default to %s\n",
 469			ctx->name,
 470			delta_frameinfo_str(frameinfo, str, sizeof(str)));
 471
 472	pix->pixelformat = frameinfo->pixelformat;
 473	pix->width = frameinfo->aligned_width;
 474	pix->height = frameinfo->aligned_height;
 475	pix->field = frameinfo->field;
 476	pix->bytesperline = frame_stride(frameinfo->aligned_width,
 477					       frameinfo->pixelformat);
 478	pix->sizeimage = frameinfo->size;
 479
 480	if (ctx->flags & DELTA_FLAG_STREAMINFO) {
 481		/* align colorspace & friends on stream ones if any set */
 482		frameinfo->colorspace = streaminfo->colorspace;
 483		frameinfo->xfer_func = streaminfo->xfer_func;
 484		frameinfo->ycbcr_enc = streaminfo->ycbcr_enc;
 485		frameinfo->quantization = streaminfo->quantization;
 486	}
 487	pix->colorspace = frameinfo->colorspace;
 488	pix->xfer_func = frameinfo->xfer_func;
 489	pix->ycbcr_enc = frameinfo->ycbcr_enc;
 490	pix->quantization = frameinfo->quantization;
 491
 492	return 0;
 493}
 494
 495static int delta_try_fmt_stream(struct file *file, void *priv,
 496				struct v4l2_format *f)
 497{
 498	struct delta_ctx *ctx = file_to_ctx(file);
 499	struct delta_dev *delta = ctx->dev;
 500	struct v4l2_pix_format *pix = &f->fmt.pix;
 501	u32 streamformat = pix->pixelformat;
 502	const struct delta_dec *dec;
 503	u32 width, height;
 504	u32 au_size;
 505
 506	dec = delta_find_decoder(ctx, streamformat, ctx->frameinfo.pixelformat);
 507	if (!dec) {
 508		dev_dbg(delta->dev,
 509			"%s V4L2 TRY_FMT (OUTPUT): unsupported format %4.4s\n",
 510			ctx->name, (char *)&pix->pixelformat);
 511		return -EINVAL;
 512	}
 513
 514	/* adjust width & height */
 515	width = pix->width;
 516	height = pix->height;
 517	v4l_bound_align_image
 518		(&pix->width,
 519		 DELTA_MIN_WIDTH,
 520		 dec->max_width ? dec->max_width : DELTA_MAX_WIDTH,
 521		 0,
 522		 &pix->height,
 523		 DELTA_MIN_HEIGHT,
 524		 dec->max_height ? dec->max_height : DELTA_MAX_HEIGHT,
 525		 0, 0);
 526
 527	if ((pix->width != width) || (pix->height != height))
 528		dev_dbg(delta->dev,
 529			"%s V4L2 TRY_FMT (OUTPUT): resolution updated %dx%d -> %dx%d to fit min/max/alignment\n",
 530			ctx->name, width, height,
 531			pix->width, pix->height);
 532
 533	au_size = estimated_au_size(pix->width, pix->height);
 534	if (pix->sizeimage < au_size) {
 535		dev_dbg(delta->dev,
 536			"%s V4L2 TRY_FMT (OUTPUT): size updated %d -> %d to fit estimated size\n",
 537			ctx->name, pix->sizeimage, au_size);
 538		pix->sizeimage = au_size;
 539	}
 540
 541	pix->bytesperline = 0;
 542
 543	if (pix->field == V4L2_FIELD_ANY)
 544		pix->field = V4L2_FIELD_NONE;
 545
 546	return 0;
 547}
 548
 549static int delta_try_fmt_frame(struct file *file, void *priv,
 550			       struct v4l2_format *f)
 551{
 552	struct delta_ctx *ctx = file_to_ctx(file);
 553	struct delta_dev *delta = ctx->dev;
 554	struct v4l2_pix_format *pix = &f->fmt.pix;
 555	u32 pixelformat = pix->pixelformat;
 556	const struct delta_dec *dec;
 557	u32 width, height;
 558
 559	dec = delta_find_decoder(ctx, ctx->streaminfo.streamformat,
 560				 pixelformat);
 561	if (!dec) {
 562		dev_dbg(delta->dev,
 563			"%s V4L2 TRY_FMT (CAPTURE): unsupported format %4.4s\n",
 564			ctx->name, (char *)&pixelformat);
 565		return -EINVAL;
 566	}
 567
 568	/* adjust width & height */
 569	width = pix->width;
 570	height = pix->height;
 571	v4l_bound_align_image(&pix->width,
 572			      DELTA_MIN_WIDTH, DELTA_MAX_WIDTH,
 573			      frame_alignment(pixelformat) - 1,
 574			      &pix->height,
 575			      DELTA_MIN_HEIGHT, DELTA_MAX_HEIGHT,
 576			      frame_alignment(pixelformat) - 1, 0);
 577
 578	if ((pix->width != width) || (pix->height != height))
 579		dev_dbg(delta->dev,
 580			"%s V4L2 TRY_FMT (CAPTURE): resolution updated %dx%d -> %dx%d to fit min/max/alignment\n",
 581			ctx->name, width, height, pix->width, pix->height);
 582
 583	/* default decoder alignment constraint */
 584	width = ALIGN(pix->width, DELTA_WIDTH_ALIGNMENT);
 585	height = ALIGN(pix->height, DELTA_HEIGHT_ALIGNMENT);
 586	if ((pix->width != width) || (pix->height != height))
 587		dev_dbg(delta->dev,
 588			"%s V4L2 TRY_FMT (CAPTURE): resolution updated %dx%d -> %dx%d to fit decoder alignment\n",
 589			ctx->name, width, height, pix->width, pix->height);
 590
 591	if (!pix->colorspace) {
 592		pix->colorspace = V4L2_COLORSPACE_REC709;
 593		pix->xfer_func = V4L2_XFER_FUNC_DEFAULT;
 594		pix->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
 595		pix->quantization = V4L2_QUANTIZATION_DEFAULT;
 596	}
 597
 598	pix->width = width;
 599	pix->height = height;
 600	pix->bytesperline = frame_stride(pix->width, pixelformat);
 601	pix->sizeimage = frame_size(pix->width, pix->height, pixelformat);
 602
 603	if (pix->field == V4L2_FIELD_ANY)
 604		pix->field = V4L2_FIELD_NONE;
 605
 606	return 0;
 607}
 608
 609static int delta_s_fmt_stream(struct file *file, void *fh,
 610			      struct v4l2_format *f)
 611{
 612	struct delta_ctx *ctx = file_to_ctx(file);
 613	struct delta_dev *delta = ctx->dev;
 614	struct vb2_queue *vq;
 615	struct v4l2_pix_format *pix = &f->fmt.pix;
 616	int ret;
 617
 618	ret = delta_try_fmt_stream(file, fh, f);
 619	if (ret) {
 620		dev_dbg(delta->dev,
 621			"%s V4L2 S_FMT (OUTPUT): unsupported format %4.4s\n",
 622			ctx->name, (char *)&pix->pixelformat);
 623		return ret;
 624	}
 625
 626	vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
 627	if (vb2_is_streaming(vq)) {
 628		dev_dbg(delta->dev, "%s V4L2 S_FMT (OUTPUT): queue busy\n",
 629			ctx->name);
 630		return -EBUSY;
 631	}
 632
 633	ctx->max_au_size = pix->sizeimage;
 634	ctx->streaminfo.width = pix->width;
 635	ctx->streaminfo.height = pix->height;
 636	ctx->streaminfo.streamformat = pix->pixelformat;
 637	ctx->streaminfo.colorspace = pix->colorspace;
 638	ctx->streaminfo.xfer_func = pix->xfer_func;
 639	ctx->streaminfo.ycbcr_enc = pix->ycbcr_enc;
 640	ctx->streaminfo.quantization = pix->quantization;
 641	ctx->flags |= DELTA_FLAG_STREAMINFO;
 642
 643	return 0;
 644}
 645
 646static int delta_s_fmt_frame(struct file *file, void *fh, struct v4l2_format *f)
 647{
 648	struct delta_ctx *ctx = file_to_ctx(file);
 649	struct delta_dev *delta = ctx->dev;
 650	const struct delta_dec *dec = ctx->dec;
 651	struct v4l2_pix_format *pix = &f->fmt.pix;
 652	struct delta_frameinfo frameinfo;
 653	unsigned char str[100] = "";
 654	struct vb2_queue *vq;
 655	int ret;
 656
 657	vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
 658	if (vb2_is_streaming(vq)) {
 659		dev_dbg(delta->dev, "%s V4L2 S_FMT (CAPTURE): queue busy\n",
 660			ctx->name);
 661		return -EBUSY;
 662	}
 663
 664	if (ctx->state < DELTA_STATE_READY) {
 665		/*
 666		 * decoder not yet opened and valid stream header not found,
 667		 * could not negotiate format with decoder, check at least
 668		 * pixel format & negotiate resolution boundaries
 669		 * and alignment...
 670		 */
 671		ret = delta_try_fmt_frame(file, fh, f);
 672		if (ret) {
 673			dev_dbg(delta->dev,
 674				"%s V4L2 S_FMT (CAPTURE): unsupported format %4.4s\n",
 675				ctx->name, (char *)&pix->pixelformat);
 676			return ret;
 677		}
 678
 679		return 0;
 680	}
 681
 682	/* set frame information to decoder */
 683	memset(&frameinfo, 0, sizeof(frameinfo));
 684	frameinfo.pixelformat = pix->pixelformat;
 685	frameinfo.width = pix->width;
 686	frameinfo.height = pix->height;
 687	frameinfo.aligned_width = pix->width;
 688	frameinfo.aligned_height = pix->height;
 689	frameinfo.size = pix->sizeimage;
 690	frameinfo.field = pix->field;
 691	frameinfo.colorspace = pix->colorspace;
 692	frameinfo.xfer_func = pix->xfer_func;
 693	frameinfo.ycbcr_enc = pix->ycbcr_enc;
 694	frameinfo.quantization = pix->quantization;
 695	ret = call_dec_op(dec, set_frameinfo, ctx, &frameinfo);
 696	if (ret)
 697		return ret;
 698
 699	/* then get what decoder can really do */
 700	ret = call_dec_op(dec, get_frameinfo, ctx, &frameinfo);
 701	if (ret)
 702		return ret;
 703
 704	ctx->flags |= DELTA_FLAG_FRAMEINFO;
 705	ctx->frameinfo = frameinfo;
 706	dev_dbg(delta->dev,
 707		"%s V4L2 SET_FMT (CAPTURE): frameinfo updated to %s\n",
 708		ctx->name,
 709		delta_frameinfo_str(&frameinfo, str, sizeof(str)));
 710
 711	pix->pixelformat = frameinfo.pixelformat;
 712	pix->width = frameinfo.aligned_width;
 713	pix->height = frameinfo.aligned_height;
 714	pix->bytesperline = frame_stride(pix->width, pix->pixelformat);
 715	pix->sizeimage = frameinfo.size;
 716	pix->field = frameinfo.field;
 717	pix->colorspace = frameinfo.colorspace;
 718	pix->xfer_func = frameinfo.xfer_func;
 719	pix->ycbcr_enc = frameinfo.ycbcr_enc;
 720	pix->quantization = frameinfo.quantization;
 721
 722	return 0;
 723}
 724
 725static int delta_g_selection(struct file *file, void *fh,
 726			     struct v4l2_selection *s)
 727{
 728	struct delta_ctx *ctx = file_to_ctx(file);
 729	struct delta_frameinfo *frameinfo = &ctx->frameinfo;
 730	struct v4l2_rect crop;
 731
 732	if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 733		return -EINVAL;
 734
 735	if ((ctx->flags & DELTA_FLAG_FRAMEINFO) &&
 736	    (frameinfo->flags & DELTA_FRAMEINFO_FLAG_CROP)) {
 737		crop = frameinfo->crop;
 738	} else {
 739		/* default to video dimensions */
 740		crop.left = 0;
 741		crop.top = 0;
 742		crop.width = frameinfo->width;
 743		crop.height = frameinfo->height;
 744	}
 745
 746	switch (s->target) {
 747	case V4L2_SEL_TGT_COMPOSE:
 748	case V4L2_SEL_TGT_COMPOSE_DEFAULT:
 749		/* visible area inside video */
 750		s->r = crop;
 751		break;
 752	case V4L2_SEL_TGT_COMPOSE_PADDED:
 753	case V4L2_SEL_TGT_COMPOSE_BOUNDS:
 754		/* up to aligned dimensions */
 755		s->r.left = 0;
 756		s->r.top = 0;
 757		s->r.width = frameinfo->aligned_width;
 758		s->r.height = frameinfo->aligned_height;
 759		break;
 760	default:
 761		return -EINVAL;
 762	}
 763
 764	return 0;
 765}
 766
 767static void delta_complete_eos(struct delta_ctx *ctx,
 768			       struct delta_frame *frame)
 769{
 770	struct delta_dev *delta = ctx->dev;
 771	const struct v4l2_event ev = {.type = V4L2_EVENT_EOS};
 772
 773	/*
 774	 * Send EOS to user:
 775	 * - by returning an empty frame flagged to V4L2_BUF_FLAG_LAST
 776	 * - and then send EOS event
 777	 */
 778
 779	/* empty frame */
 780	frame->info.size = 0;
 781
 782	/* set the last buffer flag */
 783	frame->flags |= V4L2_BUF_FLAG_LAST;
 784
 785	/* release frame to user */
 786	delta_frame_done(ctx, frame, 0);
 787
 788	/* send EOS event */
 789	v4l2_event_queue_fh(&ctx->fh, &ev);
 790
 791	dev_dbg(delta->dev, "%s EOS completed\n", ctx->name);
 792}
 793
 794static int delta_try_decoder_cmd(struct file *file, void *fh,
 795				 struct v4l2_decoder_cmd *cmd)
 796{
 797	if (cmd->cmd != V4L2_DEC_CMD_STOP)
 798		return -EINVAL;
 799
 800	if (cmd->flags & V4L2_DEC_CMD_STOP_TO_BLACK)
 801		return -EINVAL;
 802
 803	if (!(cmd->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) &&
 804	    (cmd->stop.pts != 0))
 805		return -EINVAL;
 806
 807	return 0;
 808}
 809
 810static int delta_decoder_stop_cmd(struct delta_ctx *ctx)
 811{
 812	const struct delta_dec *dec = ctx->dec;
 813	struct delta_dev *delta = ctx->dev;
 814	struct delta_frame *frame = NULL;
 815	int ret = 0;
 816
 817	dev_dbg(delta->dev, "%s EOS received\n", ctx->name);
 818
 819	if (ctx->state != DELTA_STATE_READY)
 820		return 0;
 821
 822	/* drain the decoder */
 823	call_dec_op(dec, drain, ctx);
 824
 825	/* release to user drained frames */
 826	while (1) {
 827		frame = NULL;
 828		ret = call_dec_op(dec, get_frame, ctx, &frame);
 829		if (ret == -ENODATA) {
 830			/* no more decoded frames */
 831			break;
 832		}
 833		if (frame) {
 834			dev_dbg(delta->dev, "%s drain frame[%d]\n",
 835				ctx->name, frame->index);
 836
 837			/* pop timestamp and mark frame with it */
 838			delta_pop_dts(ctx, &frame->dts);
 839
 840			/* release decoded frame to user */
 841			delta_frame_done(ctx, frame, 0);
 842		}
 843	}
 844
 845	/* try to complete EOS */
 846	ret = delta_get_free_frame(ctx, &frame);
 847	if (ret)
 848		goto delay_eos;
 849
 850	/* new frame available, EOS can now be completed */
 851	delta_complete_eos(ctx, frame);
 852
 853	ctx->state = DELTA_STATE_EOS;
 854
 855	return 0;
 856
 857delay_eos:
 858	/*
 859	 * EOS completion from driver is delayed because
 860	 * we don't have a free empty frame available.
 861	 * EOS completion is so delayed till next frame_queue() call
 862	 * to be sure to have a free empty frame available.
 863	 */
 864	ctx->state = DELTA_STATE_WF_EOS;
 865	dev_dbg(delta->dev, "%s EOS delayed\n", ctx->name);
 866
 867	return 0;
 868}
 869
 870static int delta_decoder_cmd(struct file *file, void *fh,
 871			     struct v4l2_decoder_cmd *cmd)
 872{
 873	struct delta_ctx *ctx = file_to_ctx(file);
 874	int ret = 0;
 875
 876	ret = delta_try_decoder_cmd(file, fh, cmd);
 877	if (ret)
 878		return ret;
 879
 880	return delta_decoder_stop_cmd(ctx);
 881}
 882
 883static int delta_subscribe_event(struct v4l2_fh *fh,
 884				 const struct v4l2_event_subscription *sub)
 885{
 886	switch (sub->type) {
 887	case V4L2_EVENT_EOS:
 888		return v4l2_event_subscribe(fh, sub, 2, NULL);
 889	default:
 890		return -EINVAL;
 891	}
 892
 893	return 0;
 894}
 895
 896/* v4l2 ioctl ops */
 897static const struct v4l2_ioctl_ops delta_ioctl_ops = {
 898	.vidioc_querycap = delta_querycap,
 899	.vidioc_enum_fmt_vid_cap = delta_enum_fmt_frame,
 900	.vidioc_g_fmt_vid_cap = delta_g_fmt_frame,
 901	.vidioc_try_fmt_vid_cap = delta_try_fmt_frame,
 902	.vidioc_s_fmt_vid_cap = delta_s_fmt_frame,
 903	.vidioc_enum_fmt_vid_out = delta_enum_fmt_stream,
 904	.vidioc_g_fmt_vid_out = delta_g_fmt_stream,
 905	.vidioc_try_fmt_vid_out = delta_try_fmt_stream,
 906	.vidioc_s_fmt_vid_out = delta_s_fmt_stream,
 907	.vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
 908	.vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
 909	.vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
 910	.vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
 911	.vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
 912	.vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
 913	.vidioc_streamon = v4l2_m2m_ioctl_streamon,
 914	.vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
 915	.vidioc_g_selection = delta_g_selection,
 916	.vidioc_try_decoder_cmd = delta_try_decoder_cmd,
 917	.vidioc_decoder_cmd = delta_decoder_cmd,
 918	.vidioc_subscribe_event = delta_subscribe_event,
 919	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 920};
 921
 922/*
 923 * mem-to-mem operations
 924 */
 925
 926static void delta_run_work(struct work_struct *work)
 927{
 928	struct delta_ctx *ctx = container_of(work, struct delta_ctx, run_work);
 929	struct delta_dev *delta = ctx->dev;
 930	const struct delta_dec *dec = ctx->dec;
 931	struct delta_au *au;
 932	struct delta_frame *frame = NULL;
 933	int ret = 0;
 934	bool discard = false;
 935	struct vb2_v4l2_buffer *vbuf;
 936
 937	if (!dec) {
 938		dev_err(delta->dev, "%s no decoder opened yet\n", ctx->name);
 939		return;
 940	}
 941
 942	/* protect instance against reentrancy */
 943	mutex_lock(&ctx->lock);
 944
 945	vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
 946	if (!vbuf) {
 947		dev_err(delta->dev, "%s no buffer to decode\n", ctx->name);
 948		mutex_unlock(&ctx->lock);
 949		return;
 950	}
 951	au = to_au(vbuf);
 952	au->size = vb2_get_plane_payload(&vbuf->vb2_buf, 0);
 953	au->dts = vbuf->vb2_buf.timestamp;
 954
 955	/* dump access unit */
 956	dump_au(ctx, au);
 957
 958	/* enable the hardware */
 959	if (!dec->pm) {
 960		ret = delta_get_sync(ctx);
 961		if (ret)
 962			goto err;
 963	}
 964
 965	/* decode this access unit */
 966	ret = call_dec_op(dec, decode, ctx, au);
 967
 968	/*
 969	 * if the (-ENODATA) value is returned, it refers to the interlaced
 970	 * stream case for which 2 access units are needed to get 1 frame.
 971	 * So, this returned value doesn't mean that the decoding fails, but
 972	 * indicates that the timestamp information of the access unit shall
 973	 * not be taken into account, and that the V4L2 buffer associated with
 974	 * the access unit shall be flagged with V4L2_BUF_FLAG_ERROR to inform
 975	 * the user of this situation
 976	 */
 977	if (ret == -ENODATA) {
 978		discard = true;
 979	} else if (ret) {
 980		dev_err(delta->dev, "%s decoding failed (%d)\n",
 981			ctx->name, ret);
 982
 983		/* disable the hardware */
 984		if (!dec->pm)
 985			delta_put_autosuspend(ctx);
 986
 987		goto err;
 988	}
 989
 990	/* disable the hardware */
 991	if (!dec->pm)
 992		delta_put_autosuspend(ctx);
 993
 994	/* push au timestamp in FIFO */
 995	if (!discard)
 996		delta_push_dts(ctx, au->dts);
 997
 998	/* get available decoded frames */
 999	while (1) {
1000		ret = call_dec_op(dec, get_frame, ctx, &frame);
1001		if (ret == -ENODATA) {
1002			/* no more decoded frames */
1003			goto out;
1004		}
1005		if (ret) {
1006			dev_err(delta->dev, "%s  cannot get decoded frame (%d)\n",
1007				ctx->name, ret);
1008			goto out;
1009		}
1010		if (!frame) {
1011			dev_err(delta->dev,
1012				"%s  NULL decoded frame\n",
1013				ctx->name);
1014			goto out;
1015		}
1016
1017		/* pop timestamp and mark frame with it */
1018		delta_pop_dts(ctx, &frame->dts);
1019
1020		/* release decoded frame to user */
1021		delta_frame_done(ctx, frame, 0);
1022	}
1023
1024out:
1025	requeue_free_frames(ctx);
1026	delta_au_done(ctx, au, (discard ? -ENODATA : 0));
1027	mutex_unlock(&ctx->lock);
1028	v4l2_m2m_job_finish(delta->m2m_dev, ctx->fh.m2m_ctx);
1029	return;
1030
1031err:
1032	requeue_free_frames(ctx);
1033	delta_au_done(ctx, au, ret);
1034	mutex_unlock(&ctx->lock);
1035	v4l2_m2m_job_finish(delta->m2m_dev, ctx->fh.m2m_ctx);
1036}
1037
1038static void delta_device_run(void *priv)
1039{
1040	struct delta_ctx *ctx = priv;
1041	struct delta_dev *delta = ctx->dev;
1042
1043	queue_work(delta->work_queue, &ctx->run_work);
1044}
1045
1046static void delta_job_abort(void *priv)
1047{
1048	struct delta_ctx *ctx = priv;
1049	struct delta_dev *delta = ctx->dev;
1050
1051	dev_dbg(delta->dev, "%s aborting job\n", ctx->name);
1052
1053	ctx->aborting = true;
1054}
1055
1056static int delta_job_ready(void *priv)
1057{
1058	struct delta_ctx *ctx = priv;
1059	struct delta_dev *delta = ctx->dev;
1060	int src_bufs = v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx);
1061
1062	if (!src_bufs) {
1063		dev_dbg(delta->dev, "%s not ready: not enough video buffers.\n",
1064			ctx->name);
1065		return 0;
1066	}
1067
1068	if (!v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx)) {
1069		dev_dbg(delta->dev, "%s not ready: not enough video capture buffers.\n",
1070			ctx->name);
1071		return 0;
1072	}
1073
1074	if (ctx->aborting) {
1075		dev_dbg(delta->dev, "%s job not ready: aborting\n", ctx->name);
1076		return 0;
1077	}
1078
1079	dev_dbg(delta->dev, "%s job ready\n", ctx->name);
1080
1081	return 1;
1082}
1083
1084/* mem-to-mem ops */
1085static const struct v4l2_m2m_ops delta_m2m_ops = {
1086	.device_run     = delta_device_run,
1087	.job_ready	= delta_job_ready,
1088	.job_abort      = delta_job_abort,
1089};
1090
1091/*
1092 * VB2 queue operations
1093 */
1094
1095static int delta_vb2_au_queue_setup(struct vb2_queue *vq,
1096				    unsigned int *num_buffers,
1097				    unsigned int *num_planes,
1098				    unsigned int sizes[],
1099				    struct device *alloc_devs[])
1100{
1101	struct delta_ctx *ctx = vb2_get_drv_priv(vq);
1102	unsigned int size = ctx->max_au_size;
1103
1104	if (*num_planes)
1105		return sizes[0] < size ? -EINVAL : 0;
1106
1107	*num_planes = 1;
1108	if (*num_buffers < 1)
1109		*num_buffers = 1;
1110	if (*num_buffers > DELTA_MAX_AUS)
1111		*num_buffers = DELTA_MAX_AUS;
1112
1113	sizes[0] = size;
1114
1115	return 0;
1116}
1117
1118static int delta_vb2_au_prepare(struct vb2_buffer *vb)
1119{
1120	struct vb2_queue *q = vb->vb2_queue;
1121	struct delta_ctx *ctx = vb2_get_drv_priv(q);
1122	struct delta_dev *delta = ctx->dev;
1123	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1124	struct delta_au *au = to_au(vbuf);
1125
1126	if (!au->prepared) {
1127		/* get memory addresses */
1128		au->vaddr = vb2_plane_vaddr(&au->vbuf.vb2_buf, 0);
1129		au->paddr = vb2_dma_contig_plane_dma_addr
1130				(&au->vbuf.vb2_buf, 0);
1131		au->prepared = true;
1132		dev_dbg(delta->dev, "%s au[%d] prepared; virt=0x%p, phy=0x%pad\n",
1133			ctx->name, vb->index, au->vaddr, &au->paddr);
1134	}
1135
1136	if (vbuf->field == V4L2_FIELD_ANY)
1137		vbuf->field = V4L2_FIELD_NONE;
1138
1139	return 0;
1140}
1141
1142static int delta_setup_frame(struct delta_ctx *ctx,
1143			     struct delta_frame *frame)
1144{
1145	struct delta_dev *delta = ctx->dev;
1146	const struct delta_dec *dec = ctx->dec;
1147
1148	if (frame->index >= DELTA_MAX_FRAMES) {
1149		dev_err(delta->dev,
1150			"%s frame index=%d exceeds output frame count (%d)\n",
1151			ctx->name, frame->index, DELTA_MAX_FRAMES);
1152		return -EINVAL;
1153	}
1154
1155	if (ctx->nb_of_frames >= DELTA_MAX_FRAMES) {
1156		dev_err(delta->dev,
1157			"%s number of frames exceeds output frame count (%d > %d)\n",
1158			ctx->name, ctx->nb_of_frames, DELTA_MAX_FRAMES);
1159		return -EINVAL;
1160	}
1161
1162	if (frame->index != ctx->nb_of_frames) {
1163		dev_warn(delta->dev,
1164			 "%s frame index discontinuity detected, expected %d, got %d\n",
1165			 ctx->name, ctx->nb_of_frames, frame->index);
1166	}
1167
1168	frame->state = DELTA_FRAME_FREE;
1169	ctx->frames[ctx->nb_of_frames] = frame;
1170	ctx->nb_of_frames++;
1171
1172	/* setup frame on decoder side */
1173	return call_dec_op(dec, setup_frame, ctx, frame);
1174}
1175
1176/*
1177 * default implementation of get_frameinfo decoder ops
1178 * matching frame information from stream information
1179 * & with default pixel format & default alignment.
1180 */
1181int delta_get_frameinfo_default(struct delta_ctx *ctx,
1182				struct delta_frameinfo *frameinfo)
1183{
1184	struct delta_streaminfo *streaminfo = &ctx->streaminfo;
1185
1186	memset(frameinfo, 0, sizeof(*frameinfo));
1187	frameinfo->pixelformat = V4L2_PIX_FMT_NV12;
1188	frameinfo->width = streaminfo->width;
1189	frameinfo->height = streaminfo->height;
1190	frameinfo->aligned_width = ALIGN(streaminfo->width,
1191					 DELTA_WIDTH_ALIGNMENT);
1192	frameinfo->aligned_height = ALIGN(streaminfo->height,
1193					  DELTA_HEIGHT_ALIGNMENT);
1194	frameinfo->size = frame_size(frameinfo->aligned_width,
1195				     frameinfo->aligned_height,
1196				     frameinfo->pixelformat);
1197	if (streaminfo->flags & DELTA_STREAMINFO_FLAG_CROP) {
1198		frameinfo->flags |= DELTA_FRAMEINFO_FLAG_CROP;
1199		frameinfo->crop = streaminfo->crop;
1200	}
1201	if (streaminfo->flags & DELTA_STREAMINFO_FLAG_PIXELASPECT) {
1202		frameinfo->flags |= DELTA_FRAMEINFO_FLAG_PIXELASPECT;
1203		frameinfo->pixelaspect = streaminfo->pixelaspect;
1204	}
1205	frameinfo->field = streaminfo->field;
1206
1207	return 0;
1208}
1209
1210/*
1211 * default implementation of recycle decoder ops
1212 * consisting to relax the "decoded" frame state
1213 */
1214int delta_recycle_default(struct delta_ctx *pctx,
1215			  struct delta_frame *frame)
1216{
1217	frame->state &= ~DELTA_FRAME_DEC;
1218
1219	return 0;
1220}
1221
1222static void dump_frames_status(struct delta_ctx *ctx)
1223{
1224	struct delta_dev *delta = ctx->dev;
1225	unsigned int i;
1226	struct delta_frame *frame;
1227	unsigned char str[100] = "";
1228
1229	dev_info(delta->dev,
1230		 "%s dumping frames status...\n", ctx->name);
1231
1232	for (i = 0; i < ctx->nb_of_frames; i++) {
1233		frame = ctx->frames[i];
1234		dev_info(delta->dev,
1235			 "%s frame[%d] %s\n",
1236			 ctx->name, frame->index,
1237			 frame_state_str(frame->state,
1238					 str, sizeof(str)));
1239	}
1240}
1241
1242int delta_get_free_frame(struct delta_ctx *ctx,
1243			 struct delta_frame **pframe)
1244{
1245	struct delta_dev *delta = ctx->dev;
1246	struct vb2_v4l2_buffer *vbuf;
1247	struct delta_frame *frame;
1248
1249	*pframe = NULL;
1250
1251	vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1252	if (!vbuf) {
1253		dev_err(delta->dev, "%s no frame available",
1254			ctx->name);
1255		return -EIO;
1256	}
1257
1258	frame = to_frame(vbuf);
1259	frame->state &= ~DELTA_FRAME_M2M;
1260	if (frame->state != DELTA_FRAME_FREE) {
1261		dev_err(delta->dev,
1262			"%s frame[%d] is not free\n",
1263			ctx->name, frame->index);
1264		dump_frames_status(ctx);
1265		return -ENODATA;
1266	}
1267
1268	dev_dbg(delta->dev,
1269		"%s get free frame[%d]\n", ctx->name, frame->index);
1270
1271	*pframe = frame;
1272	return 0;
1273}
1274
1275int delta_get_sync(struct delta_ctx *ctx)
1276{
1277	struct delta_dev *delta = ctx->dev;
1278	int ret = 0;
1279
1280	/* enable the hardware */
1281	ret = pm_runtime_resume_and_get(delta->dev);
1282	if (ret < 0) {
1283		dev_err(delta->dev, "%s pm_runtime_resume_and_get failed (%d)\n",
1284			__func__, ret);
1285		return ret;
1286	}
1287
1288	return 0;
1289}
1290
1291void delta_put_autosuspend(struct delta_ctx *ctx)
1292{
1293	struct delta_dev *delta = ctx->dev;
1294
1295	pm_runtime_put_autosuspend(delta->dev);
1296}
1297
1298static void delta_vb2_au_queue(struct vb2_buffer *vb)
1299{
1300	struct vb2_queue *q = vb->vb2_queue;
1301	struct delta_ctx *ctx = vb2_get_drv_priv(q);
1302	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1303
1304	v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
1305}
1306
1307static int delta_vb2_au_start_streaming(struct vb2_queue *q,
1308					unsigned int count)
1309{
1310	struct delta_ctx *ctx = vb2_get_drv_priv(q);
1311	struct delta_dev *delta = ctx->dev;
1312	const struct delta_dec *dec = ctx->dec;
1313	struct delta_au *au;
1314	int ret = 0;
1315	struct vb2_v4l2_buffer *vbuf = NULL;
1316	struct delta_streaminfo *streaminfo = &ctx->streaminfo;
1317	struct delta_frameinfo *frameinfo = &ctx->frameinfo;
1318	unsigned char str1[100] = "";
1319	unsigned char str2[100] = "";
1320
1321	if ((ctx->state != DELTA_STATE_WF_FORMAT) &&
1322	    (ctx->state != DELTA_STATE_WF_STREAMINFO))
1323		return 0;
1324
1325	if (ctx->state == DELTA_STATE_WF_FORMAT) {
1326		/* open decoder if not yet done */
1327		ret = delta_open_decoder(ctx,
1328					 ctx->streaminfo.streamformat,
1329					 ctx->frameinfo.pixelformat, &dec);
1330		if (ret)
1331			goto err;
1332		ctx->dec = dec;
1333		ctx->state = DELTA_STATE_WF_STREAMINFO;
1334	}
1335
1336	/*
1337	 * first buffer should contain stream header,
1338	 * decode it to get the infos related to stream
1339	 * such as width, height, dpb, ...
1340	 */
1341	vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1342	if (!vbuf) {
1343		dev_err(delta->dev, "%s failed to start streaming, no stream header buffer enqueued\n",
1344			ctx->name);
1345		ret = -EINVAL;
1346		goto err;
1347	}
1348	au = to_au(vbuf);
1349	au->size = vb2_get_plane_payload(&vbuf->vb2_buf, 0);
1350	au->dts = vbuf->vb2_buf.timestamp;
1351
1352	delta_push_dts(ctx, au->dts);
1353
1354	/* dump access unit */
1355	dump_au(ctx, au);
1356
1357	/* decode this access unit */
1358	ret = call_dec_op(dec, decode, ctx, au);
1359	if (ret) {
1360		dev_err(delta->dev, "%s failed to start streaming, header decoding failed (%d)\n",
1361			ctx->name, ret);
1362		goto err;
1363	}
1364
1365	ret = call_dec_op(dec, get_streaminfo, ctx, streaminfo);
1366	if (ret) {
1367		dev_dbg_ratelimited(delta->dev,
1368				    "%s failed to start streaming, valid stream header not yet decoded\n",
1369				    ctx->name);
1370		goto err;
1371	}
1372	ctx->flags |= DELTA_FLAG_STREAMINFO;
1373
1374	ret = call_dec_op(dec, get_frameinfo, ctx, frameinfo);
1375	if (ret)
1376		goto err;
1377	ctx->flags |= DELTA_FLAG_FRAMEINFO;
1378
1379	ctx->state = DELTA_STATE_READY;
1380
1381	dev_dbg(delta->dev, "%s %s => %s\n", ctx->name,
1382		delta_streaminfo_str(streaminfo, str1, sizeof(str1)),
1383		delta_frameinfo_str(frameinfo, str2, sizeof(str2)));
1384
1385	delta_au_done(ctx, au, ret);
1386	return 0;
1387
1388err:
1389	/*
1390	 * return all buffers to vb2 in QUEUED state.
1391	 * This will give ownership back to userspace
1392	 */
1393	if (vbuf)
1394		v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_QUEUED);
1395
1396	while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))
1397		v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_QUEUED);
1398	return ret;
1399}
1400
1401static void delta_vb2_au_stop_streaming(struct vb2_queue *q)
1402{
1403	struct delta_ctx *ctx = vb2_get_drv_priv(q);
1404	struct vb2_v4l2_buffer *vbuf;
1405
1406	delta_flush_dts(ctx);
1407
1408	/* return all buffers to vb2 in ERROR state */
1409	while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))
1410		v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
1411
1412	ctx->au_num = 0;
1413
1414	ctx->aborting = false;
1415}
1416
1417static int delta_vb2_frame_queue_setup(struct vb2_queue *vq,
1418				       unsigned int *num_buffers,
1419				       unsigned int *num_planes,
1420				       unsigned int sizes[],
1421				       struct device *alloc_devs[])
1422{
1423	struct delta_ctx *ctx = vb2_get_drv_priv(vq);
1424	struct delta_dev *delta = ctx->dev;
1425	struct delta_streaminfo *streaminfo = &ctx->streaminfo;
1426	struct delta_frameinfo *frameinfo = &ctx->frameinfo;
1427	unsigned int size = frameinfo->size;
1428
1429	/*
1430	 * the number of output buffers needed for decoding =
1431	 * user need (*num_buffers given, usually for display pipeline) +
1432	 * stream need (streaminfo->dpb) +
1433	 * decoding peak smoothing (depends on DELTA IP perf)
1434	 */
1435	if (*num_buffers < DELTA_MIN_FRAME_USER) {
1436		dev_dbg(delta->dev,
1437			"%s num_buffers too low (%d), increasing to %d\n",
1438			ctx->name, *num_buffers, DELTA_MIN_FRAME_USER);
1439		*num_buffers = DELTA_MIN_FRAME_USER;
1440	}
1441
1442	*num_buffers += streaminfo->dpb + DELTA_PEAK_FRAME_SMOOTHING;
1443
1444	if (*num_buffers > DELTA_MAX_FRAMES) {
1445		dev_dbg(delta->dev,
1446			"%s output frame count too high (%d), cut to %d\n",
1447			ctx->name, *num_buffers, DELTA_MAX_FRAMES);
1448		*num_buffers = DELTA_MAX_FRAMES;
1449	}
1450
1451	if (*num_planes)
1452		return sizes[0] < size ? -EINVAL : 0;
1453
1454	/* single plane for Y and CbCr */
1455	*num_planes = 1;
1456
1457	sizes[0] = size;
1458
1459	ctx->nb_of_frames = 0;
1460
1461	return 0;
1462}
1463
1464static int delta_vb2_frame_prepare(struct vb2_buffer *vb)
1465{
1466	struct vb2_queue *q = vb->vb2_queue;
1467	struct delta_ctx *ctx = vb2_get_drv_priv(q);
1468	struct delta_dev *delta = ctx->dev;
1469	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1470	struct delta_frame *frame = to_frame(vbuf);
1471	int ret = 0;
1472
1473	if (!frame->prepared) {
1474		frame->index = vbuf->vb2_buf.index;
1475		frame->vaddr = vb2_plane_vaddr(&vbuf->vb2_buf, 0);
1476		frame->paddr = vb2_dma_contig_plane_dma_addr(&vbuf->vb2_buf, 0);
1477		frame->info = ctx->frameinfo;
1478
1479		ret = delta_setup_frame(ctx, frame);
1480		if (ret) {
1481			dev_err(delta->dev,
1482				"%s setup_frame() failed (%d)\n",
1483				ctx->name, ret);
1484			return ret;
1485		}
1486		frame->prepared = true;
1487		dev_dbg(delta->dev,
1488			"%s frame[%d] prepared; virt=0x%p, phy=0x%pad\n",
1489			ctx->name, vb->index, frame->vaddr,
1490			&frame->paddr);
1491	}
1492
1493	frame->flags = vbuf->flags;
1494
1495	return 0;
1496}
1497
1498static void delta_vb2_frame_finish(struct vb2_buffer *vb)
1499{
1500	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1501	struct delta_frame *frame = to_frame(vbuf);
1502
1503	/* update V4L2 fields for user */
1504	vb2_set_plane_payload(&vbuf->vb2_buf, 0, frame->info.size);
1505	vb->timestamp = frame->dts;
1506	vbuf->field = frame->field;
1507	vbuf->flags = frame->flags;
1508}
1509
1510static void delta_vb2_frame_queue(struct vb2_buffer *vb)
1511{
1512	struct vb2_queue *q = vb->vb2_queue;
1513	struct delta_ctx *ctx = vb2_get_drv_priv(q);
1514	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1515	struct delta_frame *frame = to_frame(vbuf);
1516
1517	if (ctx->state == DELTA_STATE_WF_EOS) {
1518		/* new frame available, EOS can now be completed */
1519		delta_complete_eos(ctx, frame);
1520
1521		ctx->state = DELTA_STATE_EOS;
1522
1523		/* return, no need to recycle this buffer to decoder */
1524		return;
1525	}
1526
1527	/* recycle this frame */
1528	delta_recycle(ctx, frame);
1529}
1530
1531static void delta_vb2_frame_stop_streaming(struct vb2_queue *q)
1532{
1533	struct delta_ctx *ctx = vb2_get_drv_priv(q);
1534	struct vb2_v4l2_buffer *vbuf;
1535	struct delta_frame *frame;
1536	const struct delta_dec *dec = ctx->dec;
1537	unsigned int i;
1538
1539	delta_flush_dts(ctx);
1540
1541	call_dec_op(dec, flush, ctx);
1542
1543	/*
1544	 * return all buffers to vb2 in ERROR state
1545	 * & reset each frame state to OUT
1546	 */
1547	for (i = 0; i < ctx->nb_of_frames; i++) {
1548		frame = ctx->frames[i];
1549		if (!(frame->state & DELTA_FRAME_OUT)) {
1550			vbuf = &frame->vbuf;
1551			v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
1552		}
1553		frame->state = DELTA_FRAME_OUT;
1554	}
1555
1556	ctx->frame_num = 0;
1557
1558	ctx->aborting = false;
1559}
1560
1561/* VB2 queue ops */
1562static const struct vb2_ops delta_vb2_au_ops = {
1563	.queue_setup = delta_vb2_au_queue_setup,
1564	.buf_prepare = delta_vb2_au_prepare,
1565	.buf_queue = delta_vb2_au_queue,
1566	.start_streaming = delta_vb2_au_start_streaming,
1567	.stop_streaming = delta_vb2_au_stop_streaming,
1568};
1569
1570static const struct vb2_ops delta_vb2_frame_ops = {
1571	.queue_setup = delta_vb2_frame_queue_setup,
1572	.buf_prepare = delta_vb2_frame_prepare,
1573	.buf_finish = delta_vb2_frame_finish,
1574	.buf_queue = delta_vb2_frame_queue,
1575	.stop_streaming = delta_vb2_frame_stop_streaming,
1576};
1577
1578/*
1579 * V4L2 file operations
1580 */
1581
1582static int queue_init(void *priv,
1583		      struct vb2_queue *src_vq, struct vb2_queue *dst_vq)
1584{
1585	struct vb2_queue *q;
1586	struct delta_ctx *ctx = priv;
1587	struct delta_dev *delta = ctx->dev;
1588	int ret;
1589
1590	/* setup vb2 queue for stream input */
1591	q = src_vq;
1592	q->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
1593	q->io_modes = VB2_MMAP | VB2_DMABUF;
1594	q->drv_priv = ctx;
1595	/* overload vb2 buf with private au struct */
1596	q->buf_struct_size = sizeof(struct delta_au);
1597	q->ops = &delta_vb2_au_ops;
1598	q->mem_ops = &vb2_dma_contig_memops;
1599	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1600	q->lock = &delta->lock;
1601	q->dev = delta->dev;
1602
1603	ret = vb2_queue_init(q);
1604	if (ret)
1605		return ret;
1606
1607	/* setup vb2 queue for frame output */
1608	q = dst_vq;
1609	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1610	q->io_modes = VB2_MMAP | VB2_DMABUF;
1611	q->drv_priv = ctx;
1612	/* overload vb2 buf with private frame struct */
1613	q->buf_struct_size = sizeof(struct delta_frame)
1614			     + DELTA_MAX_FRAME_PRIV_SIZE;
1615	q->ops = &delta_vb2_frame_ops;
1616	q->mem_ops = &vb2_dma_contig_memops;
1617	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1618	q->lock = &delta->lock;
1619	q->dev = delta->dev;
1620
1621	return vb2_queue_init(q);
1622}
1623
1624static int delta_open(struct file *file)
1625{
1626	struct delta_dev *delta = video_drvdata(file);
1627	struct delta_ctx *ctx = NULL;
1628	int ret = 0;
1629
1630	mutex_lock(&delta->lock);
1631
1632	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
1633	if (!ctx) {
1634		ret = -ENOMEM;
1635		goto err;
1636	}
1637	ctx->dev = delta;
1638
1639	v4l2_fh_init(&ctx->fh, video_devdata(file));
1640	v4l2_fh_add(&ctx->fh, file);
1641
1642	INIT_WORK(&ctx->run_work, delta_run_work);
1643	mutex_init(&ctx->lock);
1644
1645	ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(delta->m2m_dev, ctx,
1646					    queue_init);
1647	if (IS_ERR(ctx->fh.m2m_ctx)) {
1648		ret = PTR_ERR(ctx->fh.m2m_ctx);
1649		dev_err(delta->dev, "%s failed to initialize m2m context (%d)\n",
1650			DELTA_PREFIX, ret);
1651		goto err_fh_del;
1652	}
1653
1654	/*
1655	 * wait stream format to determine which
1656	 * decoder to open
1657	 */
1658	ctx->state = DELTA_STATE_WF_FORMAT;
1659
1660	INIT_LIST_HEAD(&ctx->dts);
1661
1662	/* set the instance name */
1663	delta->instance_id++;
1664	snprintf(ctx->name, sizeof(ctx->name), "[%3d:----]",
1665		 delta->instance_id);
1666
1667	/* default parameters for frame and stream */
1668	set_default_params(ctx);
1669
1670	/* enable ST231 clocks */
1671	if (clk_prepare_enable(delta->clk_st231))
1672		dev_warn(delta->dev, "failed to enable st231 clk\n");
1673
1674	/* enable FLASH_PROMIP clock */
1675	if (clk_prepare_enable(delta->clk_flash_promip))
1676		dev_warn(delta->dev, "failed to enable delta promip clk\n");
1677
1678	mutex_unlock(&delta->lock);
1679
1680	dev_dbg(delta->dev, "%s decoder instance created\n", ctx->name);
1681
1682	return 0;
1683
1684err_fh_del:
1685	v4l2_fh_del(&ctx->fh, file);
1686	v4l2_fh_exit(&ctx->fh);
1687	kfree(ctx);
1688err:
1689	mutex_unlock(&delta->lock);
1690
1691	return ret;
1692}
1693
1694static int delta_release(struct file *file)
1695{
1696	struct delta_ctx *ctx = file_to_ctx(file);
1697	struct delta_dev *delta = ctx->dev;
1698	const struct delta_dec *dec = ctx->dec;
1699
1700	mutex_lock(&delta->lock);
1701
1702	/* close decoder */
1703	call_dec_op(dec, close, ctx);
1704
1705	/*
1706	 * trace a summary of instance
1707	 * before closing (debug purpose)
1708	 */
1709	delta_trace_summary(ctx);
1710
1711	v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
1712
1713	v4l2_fh_del(&ctx->fh, file);
1714	v4l2_fh_exit(&ctx->fh);
1715
1716	/* disable ST231 clocks */
1717	clk_disable_unprepare(delta->clk_st231);
1718
1719	/* disable FLASH_PROMIP clock */
1720	clk_disable_unprepare(delta->clk_flash_promip);
1721
1722	dev_dbg(delta->dev, "%s decoder instance released\n", ctx->name);
1723
1724	kfree(ctx);
1725
1726	mutex_unlock(&delta->lock);
1727	return 0;
1728}
1729
1730/* V4L2 file ops */
1731static const struct v4l2_file_operations delta_fops = {
1732	.owner = THIS_MODULE,
1733	.open = delta_open,
1734	.release = delta_release,
1735	.unlocked_ioctl = video_ioctl2,
1736	.mmap = v4l2_m2m_fop_mmap,
1737	.poll = v4l2_m2m_fop_poll,
1738};
1739
1740/*
1741 * Platform device operations
1742 */
1743
1744static int delta_register_device(struct delta_dev *delta)
1745{
1746	int ret;
1747	struct video_device *vdev;
1748
1749	if (!delta)
1750		return -ENODEV;
1751
1752	delta->m2m_dev = v4l2_m2m_init(&delta_m2m_ops);
1753	if (IS_ERR(delta->m2m_dev)) {
1754		dev_err(delta->dev, "%s failed to initialize v4l2-m2m device\n",
1755			DELTA_PREFIX);
1756		ret = PTR_ERR(delta->m2m_dev);
1757		goto err;
1758	}
1759
1760	vdev = video_device_alloc();
1761	if (!vdev) {
1762		dev_err(delta->dev, "%s failed to allocate video device\n",
1763			DELTA_PREFIX);
1764		ret = -ENOMEM;
1765		goto err_m2m_release;
1766	}
1767
1768	vdev->fops = &delta_fops;
1769	vdev->ioctl_ops = &delta_ioctl_ops;
1770	vdev->release = video_device_release;
1771	vdev->lock = &delta->lock;
1772	vdev->vfl_dir = VFL_DIR_M2M;
1773	vdev->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
1774	vdev->v4l2_dev = &delta->v4l2_dev;
1775	snprintf(vdev->name, sizeof(vdev->name), "%s-%s",
1776		 DELTA_NAME, DELTA_FW_VERSION);
1777
1778	ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
1779	if (ret) {
1780		dev_err(delta->dev, "%s failed to register video device\n",
1781			DELTA_PREFIX);
1782		goto err_vdev_release;
1783	}
1784
1785	delta->vdev = vdev;
1786	video_set_drvdata(vdev, delta);
1787	return 0;
1788
1789err_vdev_release:
1790	video_device_release(vdev);
1791err_m2m_release:
1792	v4l2_m2m_release(delta->m2m_dev);
1793err:
1794	return ret;
1795}
1796
1797static void delta_unregister_device(struct delta_dev *delta)
1798{
1799	if (!delta)
1800		return;
1801
1802	if (delta->m2m_dev)
1803		v4l2_m2m_release(delta->m2m_dev);
1804
1805	video_unregister_device(delta->vdev);
1806}
1807
1808static int delta_probe(struct platform_device *pdev)
1809{
1810	struct delta_dev *delta;
1811	struct device *dev = &pdev->dev;
1812	int ret;
1813
1814	delta = devm_kzalloc(dev, sizeof(*delta), GFP_KERNEL);
1815	if (!delta) {
1816		ret = -ENOMEM;
1817		goto err;
1818	}
1819
1820	delta->dev = dev;
1821	delta->pdev = pdev;
1822	platform_set_drvdata(pdev, delta);
1823
1824	mutex_init(&delta->lock);
1825
1826	/* get clock resources */
1827	delta->clk_delta = devm_clk_get(dev, "delta");
1828	if (IS_ERR(delta->clk_delta)) {
1829		dev_dbg(dev, "%s can't get delta clock\n", DELTA_PREFIX);
1830		delta->clk_delta = NULL;
1831	}
1832
1833	delta->clk_st231 = devm_clk_get(dev, "delta-st231");
1834	if (IS_ERR(delta->clk_st231)) {
1835		dev_dbg(dev, "%s can't get delta-st231 clock\n", DELTA_PREFIX);
1836		delta->clk_st231 = NULL;
1837	}
1838
1839	delta->clk_flash_promip = devm_clk_get(dev, "delta-flash-promip");
1840	if (IS_ERR(delta->clk_flash_promip)) {
1841		dev_dbg(dev, "%s can't get delta-flash-promip clock\n",
1842			DELTA_PREFIX);
1843		delta->clk_flash_promip = NULL;
1844	}
1845
1846	/* init pm_runtime used for power management */
1847	pm_runtime_set_autosuspend_delay(dev, DELTA_HW_AUTOSUSPEND_DELAY_MS);
1848	pm_runtime_use_autosuspend(dev);
1849	pm_runtime_set_suspended(dev);
1850	pm_runtime_enable(dev);
1851
1852	/* init firmware ipc channel */
1853	ret = delta_ipc_init(delta);
1854	if (ret) {
1855		dev_err(delta->dev, "%s failed to initialize firmware ipc channel\n",
1856			DELTA_PREFIX);
1857		goto err_pm_disable;
1858	}
1859
1860	/* register all available decoders */
1861	register_decoders(delta);
1862
1863	/* register all supported formats */
1864	register_formats(delta);
1865
1866	/* register on V4L2 */
1867	ret = v4l2_device_register(dev, &delta->v4l2_dev);
1868	if (ret) {
1869		dev_err(delta->dev, "%s failed to register V4L2 device\n",
1870			DELTA_PREFIX);
1871		goto err_pm_disable;
1872	}
1873
1874	delta->work_queue = create_workqueue(DELTA_NAME);
1875	if (!delta->work_queue) {
1876		dev_err(delta->dev, "%s failed to allocate work queue\n",
1877			DELTA_PREFIX);
1878		ret = -ENOMEM;
1879		goto err_v4l2;
1880	}
1881
1882	/* register device */
1883	ret = delta_register_device(delta);
1884	if (ret)
1885		goto err_work_queue;
1886
1887	dev_info(dev, "%s %s registered as /dev/video%d\n",
1888		 DELTA_PREFIX, delta->vdev->name, delta->vdev->num);
1889
1890	return 0;
1891
1892err_work_queue:
1893	destroy_workqueue(delta->work_queue);
1894err_v4l2:
1895	v4l2_device_unregister(&delta->v4l2_dev);
1896err_pm_disable:
1897	pm_runtime_disable(dev);
1898err:
1899	return ret;
1900}
1901
1902static void delta_remove(struct platform_device *pdev)
1903{
1904	struct delta_dev *delta = platform_get_drvdata(pdev);
1905
1906	delta_ipc_exit(delta);
1907
1908	delta_unregister_device(delta);
1909
1910	destroy_workqueue(delta->work_queue);
1911
1912	pm_runtime_put_autosuspend(delta->dev);
1913	pm_runtime_disable(delta->dev);
1914
1915	v4l2_device_unregister(&delta->v4l2_dev);
1916}
1917
1918static int delta_runtime_suspend(struct device *dev)
1919{
1920	struct delta_dev *delta = dev_get_drvdata(dev);
1921
1922	clk_disable_unprepare(delta->clk_delta);
1923
1924	return 0;
1925}
1926
1927static int delta_runtime_resume(struct device *dev)
1928{
1929	struct delta_dev *delta = dev_get_drvdata(dev);
1930
1931	if (clk_prepare_enable(delta->clk_delta))
1932		dev_warn(dev, "failed to prepare/enable delta clk\n");
1933
1934	return 0;
1935}
1936
1937/* PM ops */
1938static const struct dev_pm_ops delta_pm_ops = {
1939	.runtime_suspend = delta_runtime_suspend,
1940	.runtime_resume = delta_runtime_resume,
1941};
1942
1943static const struct of_device_id delta_match_types[] = {
1944	{
1945	 .compatible = "st,st-delta",
1946	},
1947	{
1948	 /* end node */
1949	}
1950};
1951
1952MODULE_DEVICE_TABLE(of, delta_match_types);
1953
1954static struct platform_driver delta_driver = {
1955	.probe = delta_probe,
1956	.remove = delta_remove,
1957	.driver = {
1958		   .name = DELTA_NAME,
1959		   .of_match_table = delta_match_types,
1960		   .pm = &delta_pm_ops},
1961};
1962
1963module_platform_driver(delta_driver);
1964
1965MODULE_LICENSE("GPL");
1966MODULE_AUTHOR("Hugues Fruchet <hugues.fruchet@st.com>");
1967MODULE_DESCRIPTION("STMicroelectronics DELTA video decoder V4L2 driver");