2 * V4L2 deinterlacing support.
4 * Copyright (c) 2012 Vista Silicon S.L.
5 * Javier Martin <javier.martin@vista-silicon.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the
10 * License, or (at your option) any later version
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <linux/interrupt.h>
16 #include <linux/dmaengine.h>
17 #include <linux/platform_device.h>
19 #include <media/v4l2-mem2mem.h>
20 #include <media/v4l2-device.h>
21 #include <media/v4l2-ioctl.h>
22 #include <media/videobuf2-dma-contig.h>
24 #define MEM2MEM_TEST_MODULE_NAME "mem2mem-deinterlace"
26 MODULE_DESCRIPTION("mem2mem device which supports deinterlacing using dmaengine");
27 MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com");
28 MODULE_LICENSE("GPL");
29 MODULE_VERSION("0.0.1");
32 module_param(debug
, bool, 0644);
34 /* Flags that indicate a format can be used for capture/output */
35 #define MEM2MEM_CAPTURE (1 << 0)
36 #define MEM2MEM_OUTPUT (1 << 1)
38 #define MEM2MEM_NAME "m2m-deinterlace"
40 #define dprintk(dev, fmt, arg...) \
41 v4l2_dbg(1, debug, &dev->v4l2_dev, "%s: " fmt, __func__, ## arg)
43 struct deinterlace_fmt
{
46 /* Types the format can be used for */
50 static struct deinterlace_fmt formats
[] = {
52 .name
= "YUV 4:2:0 Planar",
53 .fourcc
= V4L2_PIX_FMT_YUV420
,
54 .types
= MEM2MEM_CAPTURE
| MEM2MEM_OUTPUT
,
58 .fourcc
= V4L2_PIX_FMT_YUYV
,
59 .types
= MEM2MEM_CAPTURE
| MEM2MEM_OUTPUT
,
63 #define NUM_FORMATS ARRAY_SIZE(formats)
65 /* Per-queue, driver-specific private data */
66 struct deinterlace_q_data
{
69 unsigned int sizeimage
;
70 struct deinterlace_fmt
*fmt
;
71 enum v4l2_field field
;
86 YUV420_DMA_Y_ODD_DOUBLING
,
87 YUV420_DMA_U_ODD_DOUBLING
,
88 YUV420_DMA_V_ODD_DOUBLING
,
91 YUYV_DMA_EVEN_DOUBLING
,
94 /* Source and destination queue data */
95 static struct deinterlace_q_data q_data
[2];
97 static struct deinterlace_q_data
*get_q_data(enum v4l2_buf_type type
)
100 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
101 return &q_data
[V4L2_M2M_SRC
];
102 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
103 return &q_data
[V4L2_M2M_DST
];
110 static struct deinterlace_fmt
*find_format(struct v4l2_format
*f
)
112 struct deinterlace_fmt
*fmt
;
115 for (k
= 0; k
< NUM_FORMATS
; k
++) {
117 if ((fmt
->types
& f
->type
) &&
118 (fmt
->fourcc
== f
->fmt
.pix
.pixelformat
))
122 if (k
== NUM_FORMATS
)
128 struct deinterlace_dev
{
129 struct v4l2_device v4l2_dev
;
130 struct video_device vfd
;
133 struct mutex dev_mutex
;
136 struct dma_chan
*dma_chan
;
138 struct v4l2_m2m_dev
*m2m_dev
;
141 struct deinterlace_ctx
{
142 struct deinterlace_dev
*dev
;
144 /* Abort requested by m2m */
146 enum v4l2_colorspace colorspace
;
148 struct v4l2_m2m_ctx
*m2m_ctx
;
149 struct dma_interleaved_template
*xt
;
155 static int deinterlace_job_ready(void *priv
)
157 struct deinterlace_ctx
*ctx
= priv
;
158 struct deinterlace_dev
*pcdev
= ctx
->dev
;
160 if ((v4l2_m2m_num_src_bufs_ready(ctx
->m2m_ctx
) > 0)
161 && (v4l2_m2m_num_dst_bufs_ready(ctx
->m2m_ctx
) > 0)
162 && (atomic_read(&ctx
->dev
->busy
) == 0)) {
163 dprintk(pcdev
, "Task ready\n");
167 dprintk(pcdev
, "Task not ready to run\n");
172 static void deinterlace_job_abort(void *priv
)
174 struct deinterlace_ctx
*ctx
= priv
;
175 struct deinterlace_dev
*pcdev
= ctx
->dev
;
179 dprintk(pcdev
, "Aborting task\n");
181 v4l2_m2m_job_finish(pcdev
->m2m_dev
, ctx
->m2m_ctx
);
184 static void deinterlace_lock(void *priv
)
186 struct deinterlace_ctx
*ctx
= priv
;
187 struct deinterlace_dev
*pcdev
= ctx
->dev
;
188 mutex_lock(&pcdev
->dev_mutex
);
191 static void deinterlace_unlock(void *priv
)
193 struct deinterlace_ctx
*ctx
= priv
;
194 struct deinterlace_dev
*pcdev
= ctx
->dev
;
195 mutex_unlock(&pcdev
->dev_mutex
);
198 static void dma_callback(void *data
)
200 struct deinterlace_ctx
*curr_ctx
= data
;
201 struct deinterlace_dev
*pcdev
= curr_ctx
->dev
;
202 struct vb2_v4l2_buffer
*src_vb
, *dst_vb
;
204 atomic_set(&pcdev
->busy
, 0);
206 src_vb
= v4l2_m2m_src_buf_remove(curr_ctx
->m2m_ctx
);
207 dst_vb
= v4l2_m2m_dst_buf_remove(curr_ctx
->m2m_ctx
);
209 dst_vb
->vb2_buf
.timestamp
= src_vb
->vb2_buf
.timestamp
;
210 dst_vb
->flags
&= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK
;
212 src_vb
->flags
& V4L2_BUF_FLAG_TSTAMP_SRC_MASK
;
213 dst_vb
->timecode
= src_vb
->timecode
;
215 v4l2_m2m_buf_done(src_vb
, VB2_BUF_STATE_DONE
);
216 v4l2_m2m_buf_done(dst_vb
, VB2_BUF_STATE_DONE
);
218 v4l2_m2m_job_finish(pcdev
->m2m_dev
, curr_ctx
->m2m_ctx
);
220 dprintk(pcdev
, "dma transfers completed.\n");
223 static void deinterlace_issue_dma(struct deinterlace_ctx
*ctx
, int op
,
226 struct deinterlace_q_data
*s_q_data
;
227 struct vb2_v4l2_buffer
*src_buf
, *dst_buf
;
228 struct deinterlace_dev
*pcdev
= ctx
->dev
;
229 struct dma_chan
*chan
= pcdev
->dma_chan
;
230 struct dma_device
*dmadev
= chan
->device
;
231 struct dma_async_tx_descriptor
*tx
;
232 unsigned int s_width
, s_height
;
234 dma_addr_t p_in
, p_out
;
235 enum dma_ctrl_flags flags
;
237 src_buf
= v4l2_m2m_next_src_buf(ctx
->m2m_ctx
);
238 dst_buf
= v4l2_m2m_next_dst_buf(ctx
->m2m_ctx
);
240 s_q_data
= get_q_data(V4L2_BUF_TYPE_VIDEO_OUTPUT
);
241 s_width
= s_q_data
->width
;
242 s_height
= s_q_data
->height
;
243 s_size
= s_width
* s_height
;
245 p_in
= (dma_addr_t
)vb2_dma_contig_plane_dma_addr(&src_buf
->vb2_buf
, 0);
246 p_out
= (dma_addr_t
)vb2_dma_contig_plane_dma_addr(&dst_buf
->vb2_buf
,
248 if (!p_in
|| !p_out
) {
249 v4l2_err(&pcdev
->v4l2_dev
,
250 "Acquiring kernel pointers to buffers failed\n");
255 case YUV420_DMA_Y_ODD
:
256 ctx
->xt
->numf
= s_height
/ 2;
257 ctx
->xt
->sgl
[0].size
= s_width
;
258 ctx
->xt
->sgl
[0].icg
= s_width
;
259 ctx
->xt
->src_start
= p_in
;
260 ctx
->xt
->dst_start
= p_out
;
262 case YUV420_DMA_Y_EVEN
:
263 ctx
->xt
->numf
= s_height
/ 2;
264 ctx
->xt
->sgl
[0].size
= s_width
;
265 ctx
->xt
->sgl
[0].icg
= s_width
;
266 ctx
->xt
->src_start
= p_in
+ s_size
/ 2;
267 ctx
->xt
->dst_start
= p_out
+ s_width
;
269 case YUV420_DMA_U_ODD
:
270 ctx
->xt
->numf
= s_height
/ 4;
271 ctx
->xt
->sgl
[0].size
= s_width
/ 2;
272 ctx
->xt
->sgl
[0].icg
= s_width
/ 2;
273 ctx
->xt
->src_start
= p_in
+ s_size
;
274 ctx
->xt
->dst_start
= p_out
+ s_size
;
276 case YUV420_DMA_U_EVEN
:
277 ctx
->xt
->numf
= s_height
/ 4;
278 ctx
->xt
->sgl
[0].size
= s_width
/ 2;
279 ctx
->xt
->sgl
[0].icg
= s_width
/ 2;
280 ctx
->xt
->src_start
= p_in
+ (9 * s_size
) / 8;
281 ctx
->xt
->dst_start
= p_out
+ s_size
+ s_width
/ 2;
283 case YUV420_DMA_V_ODD
:
284 ctx
->xt
->numf
= s_height
/ 4;
285 ctx
->xt
->sgl
[0].size
= s_width
/ 2;
286 ctx
->xt
->sgl
[0].icg
= s_width
/ 2;
287 ctx
->xt
->src_start
= p_in
+ (5 * s_size
) / 4;
288 ctx
->xt
->dst_start
= p_out
+ (5 * s_size
) / 4;
290 case YUV420_DMA_V_EVEN
:
291 ctx
->xt
->numf
= s_height
/ 4;
292 ctx
->xt
->sgl
[0].size
= s_width
/ 2;
293 ctx
->xt
->sgl
[0].icg
= s_width
/ 2;
294 ctx
->xt
->src_start
= p_in
+ (11 * s_size
) / 8;
295 ctx
->xt
->dst_start
= p_out
+ (5 * s_size
) / 4 + s_width
/ 2;
297 case YUV420_DMA_Y_ODD_DOUBLING
:
298 ctx
->xt
->numf
= s_height
/ 2;
299 ctx
->xt
->sgl
[0].size
= s_width
;
300 ctx
->xt
->sgl
[0].icg
= s_width
;
301 ctx
->xt
->src_start
= p_in
;
302 ctx
->xt
->dst_start
= p_out
+ s_width
;
304 case YUV420_DMA_U_ODD_DOUBLING
:
305 ctx
->xt
->numf
= s_height
/ 4;
306 ctx
->xt
->sgl
[0].size
= s_width
/ 2;
307 ctx
->xt
->sgl
[0].icg
= s_width
/ 2;
308 ctx
->xt
->src_start
= p_in
+ s_size
;
309 ctx
->xt
->dst_start
= p_out
+ s_size
+ s_width
/ 2;
311 case YUV420_DMA_V_ODD_DOUBLING
:
312 ctx
->xt
->numf
= s_height
/ 4;
313 ctx
->xt
->sgl
[0].size
= s_width
/ 2;
314 ctx
->xt
->sgl
[0].icg
= s_width
/ 2;
315 ctx
->xt
->src_start
= p_in
+ (5 * s_size
) / 4;
316 ctx
->xt
->dst_start
= p_out
+ (5 * s_size
) / 4 + s_width
/ 2;
319 ctx
->xt
->numf
= s_height
/ 2;
320 ctx
->xt
->sgl
[0].size
= s_width
* 2;
321 ctx
->xt
->sgl
[0].icg
= s_width
* 2;
322 ctx
->xt
->src_start
= p_in
;
323 ctx
->xt
->dst_start
= p_out
;
326 ctx
->xt
->numf
= s_height
/ 2;
327 ctx
->xt
->sgl
[0].size
= s_width
* 2;
328 ctx
->xt
->sgl
[0].icg
= s_width
* 2;
329 ctx
->xt
->src_start
= p_in
+ s_size
;
330 ctx
->xt
->dst_start
= p_out
+ s_width
* 2;
332 case YUYV_DMA_EVEN_DOUBLING
:
334 ctx
->xt
->numf
= s_height
/ 2;
335 ctx
->xt
->sgl
[0].size
= s_width
* 2;
336 ctx
->xt
->sgl
[0].icg
= s_width
* 2;
337 ctx
->xt
->src_start
= p_in
;
338 ctx
->xt
->dst_start
= p_out
+ s_width
* 2;
342 /* Common parameters for al transfers */
343 ctx
->xt
->frame_size
= 1;
344 ctx
->xt
->dir
= DMA_MEM_TO_MEM
;
345 ctx
->xt
->src_sgl
= false;
346 ctx
->xt
->dst_sgl
= true;
347 flags
= DMA_CTRL_ACK
| DMA_PREP_INTERRUPT
;
349 tx
= dmadev
->device_prep_interleaved_dma(chan
, ctx
->xt
, flags
);
351 v4l2_warn(&pcdev
->v4l2_dev
, "DMA interleaved prep error\n");
356 tx
->callback
= dma_callback
;
357 tx
->callback_param
= ctx
;
360 ctx
->cookie
= dmaengine_submit(tx
);
361 if (dma_submit_error(ctx
->cookie
)) {
362 v4l2_warn(&pcdev
->v4l2_dev
,
363 "DMA submit error %d with src=0x%x dst=0x%x len=0x%x\n",
364 ctx
->cookie
, (unsigned)p_in
, (unsigned)p_out
,
369 dma_async_issue_pending(chan
);
372 static void deinterlace_device_run(void *priv
)
374 struct deinterlace_ctx
*ctx
= priv
;
375 struct deinterlace_q_data
*dst_q_data
;
377 atomic_set(&ctx
->dev
->busy
, 1);
379 dprintk(ctx
->dev
, "%s: DMA try issue.\n", __func__
);
381 dst_q_data
= get_q_data(V4L2_BUF_TYPE_VIDEO_CAPTURE
);
384 * 4 possible field conversions are possible at the moment:
385 * V4L2_FIELD_SEQ_TB --> V4L2_FIELD_INTERLACED_TB:
386 * two separate fields in the same input buffer are interlaced
387 * in the output buffer using weaving. Top field comes first.
388 * V4L2_FIELD_SEQ_TB --> V4L2_FIELD_NONE:
389 * top field from the input buffer is copied to the output buffer
390 * using line doubling. Bottom field from the input buffer is discarded.
391 * V4L2_FIELD_SEQ_BT --> V4L2_FIELD_INTERLACED_BT:
392 * two separate fields in the same input buffer are interlaced
393 * in the output buffer using weaving. Bottom field comes first.
394 * V4L2_FIELD_SEQ_BT --> V4L2_FIELD_NONE:
395 * bottom field from the input buffer is copied to the output buffer
396 * using line doubling. Top field from the input buffer is discarded.
398 switch (dst_q_data
->fmt
->fourcc
) {
399 case V4L2_PIX_FMT_YUV420
:
400 switch (dst_q_data
->field
) {
401 case V4L2_FIELD_INTERLACED_TB
:
402 case V4L2_FIELD_INTERLACED_BT
:
403 dprintk(ctx
->dev
, "%s: yuv420 interlaced tb.\n",
405 deinterlace_issue_dma(ctx
, YUV420_DMA_Y_ODD
, 0);
406 deinterlace_issue_dma(ctx
, YUV420_DMA_Y_EVEN
, 0);
407 deinterlace_issue_dma(ctx
, YUV420_DMA_U_ODD
, 0);
408 deinterlace_issue_dma(ctx
, YUV420_DMA_U_EVEN
, 0);
409 deinterlace_issue_dma(ctx
, YUV420_DMA_V_ODD
, 0);
410 deinterlace_issue_dma(ctx
, YUV420_DMA_V_EVEN
, 1);
412 case V4L2_FIELD_NONE
:
414 dprintk(ctx
->dev
, "%s: yuv420 interlaced line doubling.\n",
416 deinterlace_issue_dma(ctx
, YUV420_DMA_Y_ODD
, 0);
417 deinterlace_issue_dma(ctx
, YUV420_DMA_Y_ODD_DOUBLING
, 0);
418 deinterlace_issue_dma(ctx
, YUV420_DMA_U_ODD
, 0);
419 deinterlace_issue_dma(ctx
, YUV420_DMA_U_ODD_DOUBLING
, 0);
420 deinterlace_issue_dma(ctx
, YUV420_DMA_V_ODD
, 0);
421 deinterlace_issue_dma(ctx
, YUV420_DMA_V_ODD_DOUBLING
, 1);
425 case V4L2_PIX_FMT_YUYV
:
427 switch (dst_q_data
->field
) {
428 case V4L2_FIELD_INTERLACED_TB
:
429 case V4L2_FIELD_INTERLACED_BT
:
430 dprintk(ctx
->dev
, "%s: yuyv interlaced_tb.\n",
432 deinterlace_issue_dma(ctx
, YUYV_DMA_ODD
, 0);
433 deinterlace_issue_dma(ctx
, YUYV_DMA_EVEN
, 1);
435 case V4L2_FIELD_NONE
:
437 dprintk(ctx
->dev
, "%s: yuyv interlaced line doubling.\n",
439 deinterlace_issue_dma(ctx
, YUYV_DMA_ODD
, 0);
440 deinterlace_issue_dma(ctx
, YUYV_DMA_EVEN_DOUBLING
, 1);
446 dprintk(ctx
->dev
, "%s: DMA issue done.\n", __func__
);
452 static int vidioc_querycap(struct file
*file
, void *priv
,
453 struct v4l2_capability
*cap
)
455 strlcpy(cap
->driver
, MEM2MEM_NAME
, sizeof(cap
->driver
));
456 strlcpy(cap
->card
, MEM2MEM_NAME
, sizeof(cap
->card
));
457 strlcpy(cap
->bus_info
, MEM2MEM_NAME
, sizeof(cap
->card
));
459 * This is only a mem-to-mem video device. The capture and output
460 * device capability flags are left only for backward compatibility
461 * and are scheduled for removal.
463 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_VIDEO_OUTPUT
|
464 V4L2_CAP_VIDEO_M2M
| V4L2_CAP_STREAMING
;
465 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
470 static int enum_fmt(struct v4l2_fmtdesc
*f
, u32 type
)
473 struct deinterlace_fmt
*fmt
;
477 for (i
= 0; i
< NUM_FORMATS
; ++i
) {
478 if (formats
[i
].types
& type
) {
479 /* index-th format of type type found ? */
482 /* Correct type but haven't reached our index yet,
483 * just increment per-type index */
488 if (i
< NUM_FORMATS
) {
491 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
492 f
->pixelformat
= fmt
->fourcc
;
496 /* Format not found */
500 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
501 struct v4l2_fmtdesc
*f
)
503 return enum_fmt(f
, MEM2MEM_CAPTURE
);
506 static int vidioc_enum_fmt_vid_out(struct file
*file
, void *priv
,
507 struct v4l2_fmtdesc
*f
)
509 return enum_fmt(f
, MEM2MEM_OUTPUT
);
512 static int vidioc_g_fmt(struct deinterlace_ctx
*ctx
, struct v4l2_format
*f
)
514 struct vb2_queue
*vq
;
515 struct deinterlace_q_data
*q_data
;
517 vq
= v4l2_m2m_get_vq(ctx
->m2m_ctx
, f
->type
);
521 q_data
= get_q_data(f
->type
);
523 f
->fmt
.pix
.width
= q_data
->width
;
524 f
->fmt
.pix
.height
= q_data
->height
;
525 f
->fmt
.pix
.field
= q_data
->field
;
526 f
->fmt
.pix
.pixelformat
= q_data
->fmt
->fourcc
;
528 switch (q_data
->fmt
->fourcc
) {
529 case V4L2_PIX_FMT_YUV420
:
530 f
->fmt
.pix
.bytesperline
= q_data
->width
* 3 / 2;
532 case V4L2_PIX_FMT_YUYV
:
534 f
->fmt
.pix
.bytesperline
= q_data
->width
* 2;
537 f
->fmt
.pix
.sizeimage
= q_data
->sizeimage
;
538 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
543 static int vidioc_g_fmt_vid_out(struct file
*file
, void *priv
,
544 struct v4l2_format
*f
)
546 return vidioc_g_fmt(priv
, f
);
549 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
550 struct v4l2_format
*f
)
552 return vidioc_g_fmt(priv
, f
);
555 static int vidioc_try_fmt(struct v4l2_format
*f
, struct deinterlace_fmt
*fmt
)
557 switch (f
->fmt
.pix
.pixelformat
) {
558 case V4L2_PIX_FMT_YUV420
:
559 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 3 / 2;
561 case V4L2_PIX_FMT_YUYV
:
563 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
565 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
570 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
571 struct v4l2_format
*f
)
573 struct deinterlace_fmt
*fmt
;
574 struct deinterlace_ctx
*ctx
= priv
;
576 fmt
= find_format(f
);
577 if (!fmt
|| !(fmt
->types
& MEM2MEM_CAPTURE
))
578 f
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_YUV420
;
580 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
582 if (f
->fmt
.pix
.field
!= V4L2_FIELD_INTERLACED_TB
&&
583 f
->fmt
.pix
.field
!= V4L2_FIELD_INTERLACED_BT
&&
584 f
->fmt
.pix
.field
!= V4L2_FIELD_NONE
)
585 f
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED_TB
;
587 return vidioc_try_fmt(f
, fmt
);
590 static int vidioc_try_fmt_vid_out(struct file
*file
, void *priv
,
591 struct v4l2_format
*f
)
593 struct deinterlace_fmt
*fmt
;
595 fmt
= find_format(f
);
596 if (!fmt
|| !(fmt
->types
& MEM2MEM_OUTPUT
))
597 f
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_YUV420
;
599 if (!f
->fmt
.pix
.colorspace
)
600 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_REC709
;
602 if (f
->fmt
.pix
.field
!= V4L2_FIELD_SEQ_TB
&&
603 f
->fmt
.pix
.field
!= V4L2_FIELD_SEQ_BT
)
604 f
->fmt
.pix
.field
= V4L2_FIELD_SEQ_TB
;
606 return vidioc_try_fmt(f
, fmt
);
609 static int vidioc_s_fmt(struct deinterlace_ctx
*ctx
, struct v4l2_format
*f
)
611 struct deinterlace_q_data
*q_data
;
612 struct vb2_queue
*vq
;
614 vq
= v4l2_m2m_get_vq(ctx
->m2m_ctx
, f
->type
);
618 q_data
= get_q_data(f
->type
);
622 if (vb2_is_busy(vq
)) {
623 v4l2_err(&ctx
->dev
->v4l2_dev
, "%s queue busy\n", __func__
);
627 q_data
->fmt
= find_format(f
);
629 v4l2_err(&ctx
->dev
->v4l2_dev
,
630 "Couldn't set format type %d, wxh: %dx%d. fmt: %d, field: %d\n",
631 f
->type
, f
->fmt
.pix
.width
, f
->fmt
.pix
.height
,
632 f
->fmt
.pix
.pixelformat
, f
->fmt
.pix
.field
);
636 q_data
->width
= f
->fmt
.pix
.width
;
637 q_data
->height
= f
->fmt
.pix
.height
;
638 q_data
->field
= f
->fmt
.pix
.field
;
640 switch (f
->fmt
.pix
.pixelformat
) {
641 case V4L2_PIX_FMT_YUV420
:
642 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 3 / 2;
643 q_data
->sizeimage
= (q_data
->width
* q_data
->height
* 3) / 2;
645 case V4L2_PIX_FMT_YUYV
:
647 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* 2;
648 q_data
->sizeimage
= q_data
->width
* q_data
->height
* 2;
652 "Setting format for type %d, wxh: %dx%d, fmt: %d, field: %d\n",
653 f
->type
, q_data
->width
, q_data
->height
, q_data
->fmt
->fourcc
,
659 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
660 struct v4l2_format
*f
)
664 ret
= vidioc_try_fmt_vid_cap(file
, priv
, f
);
667 return vidioc_s_fmt(priv
, f
);
670 static int vidioc_s_fmt_vid_out(struct file
*file
, void *priv
,
671 struct v4l2_format
*f
)
673 struct deinterlace_ctx
*ctx
= priv
;
676 ret
= vidioc_try_fmt_vid_out(file
, priv
, f
);
680 ret
= vidioc_s_fmt(priv
, f
);
682 ctx
->colorspace
= f
->fmt
.pix
.colorspace
;
687 static int vidioc_reqbufs(struct file
*file
, void *priv
,
688 struct v4l2_requestbuffers
*reqbufs
)
690 struct deinterlace_ctx
*ctx
= priv
;
692 return v4l2_m2m_reqbufs(file
, ctx
->m2m_ctx
, reqbufs
);
695 static int vidioc_querybuf(struct file
*file
, void *priv
,
696 struct v4l2_buffer
*buf
)
698 struct deinterlace_ctx
*ctx
= priv
;
700 return v4l2_m2m_querybuf(file
, ctx
->m2m_ctx
, buf
);
703 static int vidioc_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
705 struct deinterlace_ctx
*ctx
= priv
;
707 return v4l2_m2m_qbuf(file
, ctx
->m2m_ctx
, buf
);
710 static int vidioc_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
712 struct deinterlace_ctx
*ctx
= priv
;
714 return v4l2_m2m_dqbuf(file
, ctx
->m2m_ctx
, buf
);
717 static int vidioc_streamon(struct file
*file
, void *priv
,
718 enum v4l2_buf_type type
)
720 struct deinterlace_q_data
*s_q_data
, *d_q_data
;
721 struct deinterlace_ctx
*ctx
= priv
;
723 s_q_data
= get_q_data(V4L2_BUF_TYPE_VIDEO_OUTPUT
);
724 d_q_data
= get_q_data(V4L2_BUF_TYPE_VIDEO_CAPTURE
);
726 /* Check that src and dst queues have the same pix format */
727 if (s_q_data
->fmt
->fourcc
!= d_q_data
->fmt
->fourcc
) {
728 v4l2_err(&ctx
->dev
->v4l2_dev
,
729 "src and dst formats don't match.\n");
733 /* Check that input and output deinterlacing types are compatible */
734 switch (s_q_data
->field
) {
735 case V4L2_FIELD_SEQ_BT
:
736 if (d_q_data
->field
!= V4L2_FIELD_NONE
&&
737 d_q_data
->field
!= V4L2_FIELD_INTERLACED_BT
) {
738 v4l2_err(&ctx
->dev
->v4l2_dev
,
739 "src and dst field conversion [(%d)->(%d)] not supported.\n",
740 s_q_data
->field
, d_q_data
->field
);
744 case V4L2_FIELD_SEQ_TB
:
745 if (d_q_data
->field
!= V4L2_FIELD_NONE
&&
746 d_q_data
->field
!= V4L2_FIELD_INTERLACED_TB
) {
747 v4l2_err(&ctx
->dev
->v4l2_dev
,
748 "src and dst field conversion [(%d)->(%d)] not supported.\n",
749 s_q_data
->field
, d_q_data
->field
);
757 return v4l2_m2m_streamon(file
, ctx
->m2m_ctx
, type
);
760 static int vidioc_streamoff(struct file
*file
, void *priv
,
761 enum v4l2_buf_type type
)
763 struct deinterlace_ctx
*ctx
= priv
;
765 return v4l2_m2m_streamoff(file
, ctx
->m2m_ctx
, type
);
768 static const struct v4l2_ioctl_ops deinterlace_ioctl_ops
= {
769 .vidioc_querycap
= vidioc_querycap
,
771 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
772 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
773 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
774 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
776 .vidioc_enum_fmt_vid_out
= vidioc_enum_fmt_vid_out
,
777 .vidioc_g_fmt_vid_out
= vidioc_g_fmt_vid_out
,
778 .vidioc_try_fmt_vid_out
= vidioc_try_fmt_vid_out
,
779 .vidioc_s_fmt_vid_out
= vidioc_s_fmt_vid_out
,
781 .vidioc_reqbufs
= vidioc_reqbufs
,
782 .vidioc_querybuf
= vidioc_querybuf
,
784 .vidioc_qbuf
= vidioc_qbuf
,
785 .vidioc_dqbuf
= vidioc_dqbuf
,
787 .vidioc_streamon
= vidioc_streamon
,
788 .vidioc_streamoff
= vidioc_streamoff
,
799 static int deinterlace_queue_setup(struct vb2_queue
*vq
,
800 unsigned int *nbuffers
, unsigned int *nplanes
,
801 unsigned int sizes
[], struct device
*alloc_devs
[])
803 struct deinterlace_ctx
*ctx
= vb2_get_drv_priv(vq
);
804 struct deinterlace_q_data
*q_data
;
805 unsigned int size
, count
= *nbuffers
;
807 q_data
= get_q_data(vq
->type
);
809 switch (q_data
->fmt
->fourcc
) {
810 case V4L2_PIX_FMT_YUV420
:
811 size
= q_data
->width
* q_data
->height
* 3 / 2;
813 case V4L2_PIX_FMT_YUYV
:
815 size
= q_data
->width
* q_data
->height
* 2;
822 dprintk(ctx
->dev
, "get %d buffer(s) of size %d each.\n", count
, size
);
827 static int deinterlace_buf_prepare(struct vb2_buffer
*vb
)
829 struct deinterlace_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
830 struct deinterlace_q_data
*q_data
;
832 dprintk(ctx
->dev
, "type: %d\n", vb
->vb2_queue
->type
);
834 q_data
= get_q_data(vb
->vb2_queue
->type
);
836 if (vb2_plane_size(vb
, 0) < q_data
->sizeimage
) {
837 dprintk(ctx
->dev
, "%s data will not fit into plane (%lu < %lu)\n",
838 __func__
, vb2_plane_size(vb
, 0), (long)q_data
->sizeimage
);
842 vb2_set_plane_payload(vb
, 0, q_data
->sizeimage
);
847 static void deinterlace_buf_queue(struct vb2_buffer
*vb
)
849 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
850 struct deinterlace_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
852 v4l2_m2m_buf_queue(ctx
->m2m_ctx
, vbuf
);
855 static const struct vb2_ops deinterlace_qops
= {
856 .queue_setup
= deinterlace_queue_setup
,
857 .buf_prepare
= deinterlace_buf_prepare
,
858 .buf_queue
= deinterlace_buf_queue
,
861 static int queue_init(void *priv
, struct vb2_queue
*src_vq
,
862 struct vb2_queue
*dst_vq
)
864 struct deinterlace_ctx
*ctx
= priv
;
867 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
868 src_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
869 src_vq
->drv_priv
= ctx
;
870 src_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
871 src_vq
->ops
= &deinterlace_qops
;
872 src_vq
->mem_ops
= &vb2_dma_contig_memops
;
873 src_vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
874 src_vq
->dev
= ctx
->dev
->v4l2_dev
.dev
;
875 q_data
[V4L2_M2M_SRC
].fmt
= &formats
[0];
876 q_data
[V4L2_M2M_SRC
].width
= 640;
877 q_data
[V4L2_M2M_SRC
].height
= 480;
878 q_data
[V4L2_M2M_SRC
].sizeimage
= (640 * 480 * 3) / 2;
879 q_data
[V4L2_M2M_SRC
].field
= V4L2_FIELD_SEQ_TB
;
881 ret
= vb2_queue_init(src_vq
);
885 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
886 dst_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
887 dst_vq
->drv_priv
= ctx
;
888 dst_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
889 dst_vq
->ops
= &deinterlace_qops
;
890 dst_vq
->mem_ops
= &vb2_dma_contig_memops
;
891 dst_vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
892 dst_vq
->dev
= ctx
->dev
->v4l2_dev
.dev
;
893 q_data
[V4L2_M2M_DST
].fmt
= &formats
[0];
894 q_data
[V4L2_M2M_DST
].width
= 640;
895 q_data
[V4L2_M2M_DST
].height
= 480;
896 q_data
[V4L2_M2M_DST
].sizeimage
= (640 * 480 * 3) / 2;
897 q_data
[V4L2_M2M_SRC
].field
= V4L2_FIELD_INTERLACED_TB
;
899 return vb2_queue_init(dst_vq
);
905 static int deinterlace_open(struct file
*file
)
907 struct deinterlace_dev
*pcdev
= video_drvdata(file
);
908 struct deinterlace_ctx
*ctx
= NULL
;
910 ctx
= kzalloc(sizeof *ctx
, GFP_KERNEL
);
914 file
->private_data
= ctx
;
917 ctx
->m2m_ctx
= v4l2_m2m_ctx_init(pcdev
->m2m_dev
, ctx
, &queue_init
);
918 if (IS_ERR(ctx
->m2m_ctx
)) {
919 int ret
= PTR_ERR(ctx
->m2m_ctx
);
925 ctx
->xt
= kzalloc(sizeof(struct dma_interleaved_template
) +
926 sizeof(struct data_chunk
), GFP_KERNEL
);
932 ctx
->colorspace
= V4L2_COLORSPACE_REC709
;
934 dprintk(pcdev
, "Created instance %p, m2m_ctx: %p\n", ctx
, ctx
->m2m_ctx
);
939 static int deinterlace_release(struct file
*file
)
941 struct deinterlace_dev
*pcdev
= video_drvdata(file
);
942 struct deinterlace_ctx
*ctx
= file
->private_data
;
944 dprintk(pcdev
, "Releasing instance %p\n", ctx
);
946 v4l2_m2m_ctx_release(ctx
->m2m_ctx
);
953 static unsigned int deinterlace_poll(struct file
*file
,
954 struct poll_table_struct
*wait
)
956 struct deinterlace_ctx
*ctx
= file
->private_data
;
959 deinterlace_lock(ctx
);
960 ret
= v4l2_m2m_poll(file
, ctx
->m2m_ctx
, wait
);
961 deinterlace_unlock(ctx
);
966 static int deinterlace_mmap(struct file
*file
, struct vm_area_struct
*vma
)
968 struct deinterlace_ctx
*ctx
= file
->private_data
;
970 return v4l2_m2m_mmap(file
, ctx
->m2m_ctx
, vma
);
973 static const struct v4l2_file_operations deinterlace_fops
= {
974 .owner
= THIS_MODULE
,
975 .open
= deinterlace_open
,
976 .release
= deinterlace_release
,
977 .poll
= deinterlace_poll
,
978 .unlocked_ioctl
= video_ioctl2
,
979 .mmap
= deinterlace_mmap
,
982 static struct video_device deinterlace_videodev
= {
983 .name
= MEM2MEM_NAME
,
984 .fops
= &deinterlace_fops
,
985 .ioctl_ops
= &deinterlace_ioctl_ops
,
987 .release
= video_device_release_empty
,
988 .vfl_dir
= VFL_DIR_M2M
,
991 static struct v4l2_m2m_ops m2m_ops
= {
992 .device_run
= deinterlace_device_run
,
993 .job_ready
= deinterlace_job_ready
,
994 .job_abort
= deinterlace_job_abort
,
995 .lock
= deinterlace_lock
,
996 .unlock
= deinterlace_unlock
,
999 static int deinterlace_probe(struct platform_device
*pdev
)
1001 struct deinterlace_dev
*pcdev
;
1002 struct video_device
*vfd
;
1003 dma_cap_mask_t mask
;
1006 pcdev
= devm_kzalloc(&pdev
->dev
, sizeof(*pcdev
), GFP_KERNEL
);
1010 spin_lock_init(&pcdev
->irqlock
);
1013 dma_cap_set(DMA_INTERLEAVE
, mask
);
1014 pcdev
->dma_chan
= dma_request_channel(mask
, NULL
, pcdev
);
1015 if (!pcdev
->dma_chan
)
1018 if (!dma_has_cap(DMA_INTERLEAVE
, pcdev
->dma_chan
->device
->cap_mask
)) {
1019 dev_err(&pdev
->dev
, "DMA does not support INTERLEAVE\n");
1023 ret
= v4l2_device_register(&pdev
->dev
, &pcdev
->v4l2_dev
);
1027 atomic_set(&pcdev
->busy
, 0);
1028 mutex_init(&pcdev
->dev_mutex
);
1031 *vfd
= deinterlace_videodev
;
1032 vfd
->lock
= &pcdev
->dev_mutex
;
1033 vfd
->v4l2_dev
= &pcdev
->v4l2_dev
;
1035 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, 0);
1037 v4l2_err(&pcdev
->v4l2_dev
, "Failed to register video device\n");
1041 video_set_drvdata(vfd
, pcdev
);
1042 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s", deinterlace_videodev
.name
);
1043 v4l2_info(&pcdev
->v4l2_dev
, MEM2MEM_TEST_MODULE_NAME
1044 " Device registered as /dev/video%d\n", vfd
->num
);
1046 platform_set_drvdata(pdev
, pcdev
);
1048 pcdev
->m2m_dev
= v4l2_m2m_init(&m2m_ops
);
1049 if (IS_ERR(pcdev
->m2m_dev
)) {
1050 v4l2_err(&pcdev
->v4l2_dev
, "Failed to init mem2mem device\n");
1051 ret
= PTR_ERR(pcdev
->m2m_dev
);
1058 video_unregister_device(&pcdev
->vfd
);
1060 v4l2_device_unregister(&pcdev
->v4l2_dev
);
1062 dma_release_channel(pcdev
->dma_chan
);
1067 static int deinterlace_remove(struct platform_device
*pdev
)
1069 struct deinterlace_dev
*pcdev
= platform_get_drvdata(pdev
);
1071 v4l2_info(&pcdev
->v4l2_dev
, "Removing " MEM2MEM_TEST_MODULE_NAME
);
1072 v4l2_m2m_release(pcdev
->m2m_dev
);
1073 video_unregister_device(&pcdev
->vfd
);
1074 v4l2_device_unregister(&pcdev
->v4l2_dev
);
1075 dma_release_channel(pcdev
->dma_chan
);
1080 static struct platform_driver deinterlace_pdrv
= {
1081 .probe
= deinterlace_probe
,
1082 .remove
= deinterlace_remove
,
1084 .name
= MEM2MEM_NAME
,
1087 module_platform_driver(deinterlace_pdrv
);