2 * A virtual v4l2-mem2mem example device.
4 * This is a virtual device driver for testing mem-to-mem videobuf framework.
5 * It simulates a device that uses memory buffers for both source and
6 * destination, processes the data and issues an "irq" (simulated by a timer).
7 * The device is capable of multi-instance, multi-buffer-per-transaction
8 * operation (via the mem2mem framework).
10 * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd.
11 * Pawel Osciak, <pawel@osciak.com>
12 * Marek Szyprowski, <m.szyprowski@samsung.com>
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by the
16 * Free Software Foundation; either version 2 of the
17 * License, or (at your option) any later version
19 #include <linux/module.h>
20 #include <linux/delay.h>
22 #include <linux/timer.h>
23 #include <linux/sched.h>
24 #include <linux/slab.h>
26 #include <linux/platform_device.h>
27 #include <media/v4l2-mem2mem.h>
28 #include <media/v4l2-device.h>
29 #include <media/v4l2-ioctl.h>
30 #include <media/v4l2-ctrls.h>
31 #include <media/v4l2-event.h>
32 #include <media/videobuf2-vmalloc.h>
34 #define MEM2MEM_TEST_MODULE_NAME "mem2mem-testdev"
36 MODULE_DESCRIPTION("Virtual device for mem2mem framework testing");
37 MODULE_AUTHOR("Pawel Osciak, <pawel@osciak.com>");
38 MODULE_LICENSE("GPL");
39 MODULE_VERSION("0.1.1");
45 #define DIM_ALIGN_MASK 7 /* 8-byte alignment for line length */
47 /* Flags that indicate a format can be used for capture/output */
48 #define MEM2MEM_CAPTURE (1 << 0)
49 #define MEM2MEM_OUTPUT (1 << 1)
51 #define MEM2MEM_NAME "m2m-testdev"
54 #define MEM2MEM_DEF_NUM_BUFS VIDEO_MAX_FRAME
55 /* In bytes, per queue */
56 #define MEM2MEM_VID_MEM_LIMIT (16 * 1024 * 1024)
58 /* Default transaction time in msec */
59 #define MEM2MEM_DEF_TRANSTIME 1000
60 /* Default number of buffers per transaction */
61 #define MEM2MEM_DEF_TRANSLEN 1
62 #define MEM2MEM_COLOR_STEP (0xff >> 4)
63 #define MEM2MEM_NUM_TILES 8
65 /* Flags that indicate processing mode */
66 #define MEM2MEM_HFLIP (1 << 0)
67 #define MEM2MEM_VFLIP (1 << 1)
69 #define dprintk(dev, fmt, arg...) \
70 v4l2_dbg(1, 1, &dev->v4l2_dev, "%s: " fmt, __func__, ## arg)
73 void m2mtest_dev_release(struct device
*dev
)
76 static struct platform_device m2mtest_pdev
= {
78 .dev
.release
= m2mtest_dev_release
,
85 /* Types the format can be used for */
89 static struct m2mtest_fmt formats
[] = {
91 .name
= "RGB565 (BE)",
92 .fourcc
= V4L2_PIX_FMT_RGB565X
, /* rrrrrggg gggbbbbb */
94 /* Both capture and output format */
95 .types
= MEM2MEM_CAPTURE
| MEM2MEM_OUTPUT
,
98 .name
= "4:2:2, packed, YUYV",
99 .fourcc
= V4L2_PIX_FMT_YUYV
,
101 /* Output-only format */
102 .types
= MEM2MEM_OUTPUT
,
106 #define NUM_FORMATS ARRAY_SIZE(formats)
108 /* Per-queue, driver-specific private data */
109 struct m2mtest_q_data
{
112 unsigned int sizeimage
;
113 struct m2mtest_fmt
*fmt
;
121 #define V4L2_CID_TRANS_TIME_MSEC (V4L2_CID_USER_BASE + 0x1000)
122 #define V4L2_CID_TRANS_NUM_BUFS (V4L2_CID_USER_BASE + 0x1001)
124 static struct m2mtest_fmt
*find_format(struct v4l2_format
*f
)
126 struct m2mtest_fmt
*fmt
;
129 for (k
= 0; k
< NUM_FORMATS
; k
++) {
131 if (fmt
->fourcc
== f
->fmt
.pix
.pixelformat
)
135 if (k
== NUM_FORMATS
)
142 struct v4l2_device v4l2_dev
;
143 struct video_device
*vfd
;
146 struct mutex dev_mutex
;
149 struct timer_list timer
;
151 struct v4l2_m2m_dev
*m2m_dev
;
156 struct m2mtest_dev
*dev
;
158 struct v4l2_ctrl_handler hdl
;
160 /* Processed buffers in this transaction */
163 /* Transaction length (i.e. how many buffers per transaction) */
165 /* Transaction time (i.e. simulated processing time) in milliseconds */
168 /* Abort requested by m2m */
171 /* Processing mode */
174 enum v4l2_colorspace colorspace
;
176 struct v4l2_m2m_ctx
*m2m_ctx
;
178 /* Source and destination queue data */
179 struct m2mtest_q_data q_data
[2];
182 static inline struct m2mtest_ctx
*file2ctx(struct file
*file
)
184 return container_of(file
->private_data
, struct m2mtest_ctx
, fh
);
187 static struct m2mtest_q_data
*get_q_data(struct m2mtest_ctx
*ctx
,
188 enum v4l2_buf_type type
)
191 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
192 return &ctx
->q_data
[V4L2_M2M_SRC
];
193 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
194 return &ctx
->q_data
[V4L2_M2M_DST
];
202 static int device_process(struct m2mtest_ctx
*ctx
,
203 struct vb2_buffer
*in_vb
,
204 struct vb2_buffer
*out_vb
)
206 struct m2mtest_dev
*dev
= ctx
->dev
;
207 struct m2mtest_q_data
*q_data
;
210 int tile_w
, bytes_left
;
211 int width
, height
, bytesperline
;
213 q_data
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_OUTPUT
);
215 width
= q_data
->width
;
216 height
= q_data
->height
;
217 bytesperline
= (q_data
->width
* q_data
->fmt
->depth
) >> 3;
219 p_in
= vb2_plane_vaddr(in_vb
, 0);
220 p_out
= vb2_plane_vaddr(out_vb
, 0);
221 if (!p_in
|| !p_out
) {
222 v4l2_err(&dev
->v4l2_dev
,
223 "Acquiring kernel pointers to buffers failed\n");
227 if (vb2_plane_size(in_vb
, 0) > vb2_plane_size(out_vb
, 0)) {
228 v4l2_err(&dev
->v4l2_dev
, "Output buffer is too small\n");
232 tile_w
= (width
* (q_data
[V4L2_M2M_DST
].fmt
->depth
>> 3))
234 bytes_left
= bytesperline
- tile_w
* MEM2MEM_NUM_TILES
;
238 case MEM2MEM_HFLIP
| MEM2MEM_VFLIP
:
239 p_out
+= bytesperline
* height
- bytes_left
;
240 for (y
= 0; y
< height
; ++y
) {
241 for (t
= 0; t
< MEM2MEM_NUM_TILES
; ++t
) {
243 for (x
= 0; x
< tile_w
; ++x
)
247 for (x
= 0; x
< tile_w
; ++x
)
259 for (y
= 0; y
< height
; ++y
) {
260 p_out
+= MEM2MEM_NUM_TILES
* tile_w
;
261 for (t
= 0; t
< MEM2MEM_NUM_TILES
; ++t
) {
263 for (x
= 0; x
< tile_w
; ++x
)
267 for (x
= 0; x
< tile_w
; ++x
)
274 p_out
+= bytesperline
;
279 p_out
+= bytesperline
* (height
- 1);
280 for (y
= 0; y
< height
; ++y
) {
281 for (t
= 0; t
< MEM2MEM_NUM_TILES
; ++t
) {
283 for (x
= 0; x
< tile_w
; ++x
)
287 for (x
= 0; x
< tile_w
; ++x
)
294 p_out
+= bytes_left
- 2 * bytesperline
;
299 for (y
= 0; y
< height
; ++y
) {
300 for (t
= 0; t
< MEM2MEM_NUM_TILES
; ++t
) {
302 for (x
= 0; x
< tile_w
; ++x
)
306 for (x
= 0; x
< tile_w
; ++x
)
320 static void schedule_irq(struct m2mtest_dev
*dev
, int msec_timeout
)
322 dprintk(dev
, "Scheduling a simulated irq\n");
323 mod_timer(&dev
->timer
, jiffies
+ msecs_to_jiffies(msec_timeout
));
331 * job_ready() - check whether an instance is ready to be scheduled to run
333 static int job_ready(void *priv
)
335 struct m2mtest_ctx
*ctx
= priv
;
337 if (v4l2_m2m_num_src_bufs_ready(ctx
->m2m_ctx
) < ctx
->translen
338 || v4l2_m2m_num_dst_bufs_ready(ctx
->m2m_ctx
) < ctx
->translen
) {
339 dprintk(ctx
->dev
, "Not enough buffers available\n");
346 static void job_abort(void *priv
)
348 struct m2mtest_ctx
*ctx
= priv
;
350 /* Will cancel the transaction in the next interrupt handler */
354 static void m2mtest_lock(void *priv
)
356 struct m2mtest_ctx
*ctx
= priv
;
357 struct m2mtest_dev
*dev
= ctx
->dev
;
358 mutex_lock(&dev
->dev_mutex
);
361 static void m2mtest_unlock(void *priv
)
363 struct m2mtest_ctx
*ctx
= priv
;
364 struct m2mtest_dev
*dev
= ctx
->dev
;
365 mutex_unlock(&dev
->dev_mutex
);
369 /* device_run() - prepares and starts the device
371 * This simulates all the immediate preparations required before starting
372 * a device. This will be called by the framework when it decides to schedule
373 * a particular instance.
375 static void device_run(void *priv
)
377 struct m2mtest_ctx
*ctx
= priv
;
378 struct m2mtest_dev
*dev
= ctx
->dev
;
379 struct vb2_buffer
*src_buf
, *dst_buf
;
381 src_buf
= v4l2_m2m_next_src_buf(ctx
->m2m_ctx
);
382 dst_buf
= v4l2_m2m_next_dst_buf(ctx
->m2m_ctx
);
384 device_process(ctx
, src_buf
, dst_buf
);
386 /* Run a timer, which simulates a hardware irq */
387 schedule_irq(dev
, ctx
->transtime
);
390 static void device_isr(unsigned long priv
)
392 struct m2mtest_dev
*m2mtest_dev
= (struct m2mtest_dev
*)priv
;
393 struct m2mtest_ctx
*curr_ctx
;
394 struct vb2_buffer
*src_vb
, *dst_vb
;
397 curr_ctx
= v4l2_m2m_get_curr_priv(m2mtest_dev
->m2m_dev
);
399 if (NULL
== curr_ctx
) {
401 "Instance released before the end of transaction\n");
405 src_vb
= v4l2_m2m_src_buf_remove(curr_ctx
->m2m_ctx
);
406 dst_vb
= v4l2_m2m_dst_buf_remove(curr_ctx
->m2m_ctx
);
408 curr_ctx
->num_processed
++;
410 spin_lock_irqsave(&m2mtest_dev
->irqlock
, flags
);
411 v4l2_m2m_buf_done(src_vb
, VB2_BUF_STATE_DONE
);
412 v4l2_m2m_buf_done(dst_vb
, VB2_BUF_STATE_DONE
);
413 spin_unlock_irqrestore(&m2mtest_dev
->irqlock
, flags
);
415 if (curr_ctx
->num_processed
== curr_ctx
->translen
416 || curr_ctx
->aborting
) {
417 dprintk(curr_ctx
->dev
, "Finishing transaction\n");
418 curr_ctx
->num_processed
= 0;
419 v4l2_m2m_job_finish(m2mtest_dev
->m2m_dev
, curr_ctx
->m2m_ctx
);
421 device_run(curr_ctx
);
428 static int vidioc_querycap(struct file
*file
, void *priv
,
429 struct v4l2_capability
*cap
)
431 strncpy(cap
->driver
, MEM2MEM_NAME
, sizeof(cap
->driver
) - 1);
432 strncpy(cap
->card
, MEM2MEM_NAME
, sizeof(cap
->card
) - 1);
433 strlcpy(cap
->bus_info
, MEM2MEM_NAME
, sizeof(cap
->bus_info
));
434 cap
->capabilities
= V4L2_CAP_VIDEO_M2M
| V4L2_CAP_STREAMING
;
435 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
439 static int enum_fmt(struct v4l2_fmtdesc
*f
, u32 type
)
442 struct m2mtest_fmt
*fmt
;
446 for (i
= 0; i
< NUM_FORMATS
; ++i
) {
447 if (formats
[i
].types
& type
) {
448 /* index-th format of type type found ? */
451 /* Correct type but haven't reached our index yet,
452 * just increment per-type index */
457 if (i
< NUM_FORMATS
) {
460 strncpy(f
->description
, fmt
->name
, sizeof(f
->description
) - 1);
461 f
->pixelformat
= fmt
->fourcc
;
465 /* Format not found */
469 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
470 struct v4l2_fmtdesc
*f
)
472 return enum_fmt(f
, MEM2MEM_CAPTURE
);
475 static int vidioc_enum_fmt_vid_out(struct file
*file
, void *priv
,
476 struct v4l2_fmtdesc
*f
)
478 return enum_fmt(f
, MEM2MEM_OUTPUT
);
481 static int vidioc_g_fmt(struct m2mtest_ctx
*ctx
, struct v4l2_format
*f
)
483 struct vb2_queue
*vq
;
484 struct m2mtest_q_data
*q_data
;
486 vq
= v4l2_m2m_get_vq(ctx
->m2m_ctx
, f
->type
);
490 q_data
= get_q_data(ctx
, f
->type
);
492 f
->fmt
.pix
.width
= q_data
->width
;
493 f
->fmt
.pix
.height
= q_data
->height
;
494 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
495 f
->fmt
.pix
.pixelformat
= q_data
->fmt
->fourcc
;
496 f
->fmt
.pix
.bytesperline
= (q_data
->width
* q_data
->fmt
->depth
) >> 3;
497 f
->fmt
.pix
.sizeimage
= q_data
->sizeimage
;
498 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
503 static int vidioc_g_fmt_vid_out(struct file
*file
, void *priv
,
504 struct v4l2_format
*f
)
506 return vidioc_g_fmt(file2ctx(file
), f
);
509 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
510 struct v4l2_format
*f
)
512 return vidioc_g_fmt(file2ctx(file
), f
);
515 static int vidioc_try_fmt(struct v4l2_format
*f
, struct m2mtest_fmt
*fmt
)
517 enum v4l2_field field
;
519 field
= f
->fmt
.pix
.field
;
521 if (field
== V4L2_FIELD_ANY
)
522 field
= V4L2_FIELD_NONE
;
523 else if (V4L2_FIELD_NONE
!= field
)
526 /* V4L2 specification suggests the driver corrects the format struct
527 * if any of the dimensions is unsupported */
528 f
->fmt
.pix
.field
= field
;
530 if (f
->fmt
.pix
.height
< MIN_H
)
531 f
->fmt
.pix
.height
= MIN_H
;
532 else if (f
->fmt
.pix
.height
> MAX_H
)
533 f
->fmt
.pix
.height
= MAX_H
;
535 if (f
->fmt
.pix
.width
< MIN_W
)
536 f
->fmt
.pix
.width
= MIN_W
;
537 else if (f
->fmt
.pix
.width
> MAX_W
)
538 f
->fmt
.pix
.width
= MAX_W
;
540 f
->fmt
.pix
.width
&= ~DIM_ALIGN_MASK
;
541 f
->fmt
.pix
.bytesperline
= (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
542 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
547 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
548 struct v4l2_format
*f
)
550 struct m2mtest_fmt
*fmt
;
551 struct m2mtest_ctx
*ctx
= file2ctx(file
);
553 fmt
= find_format(f
);
554 if (!fmt
|| !(fmt
->types
& MEM2MEM_CAPTURE
)) {
555 v4l2_err(&ctx
->dev
->v4l2_dev
,
556 "Fourcc format (0x%08x) invalid.\n",
557 f
->fmt
.pix
.pixelformat
);
560 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
562 return vidioc_try_fmt(f
, fmt
);
565 static int vidioc_try_fmt_vid_out(struct file
*file
, void *priv
,
566 struct v4l2_format
*f
)
568 struct m2mtest_fmt
*fmt
;
569 struct m2mtest_ctx
*ctx
= file2ctx(file
);
571 fmt
= find_format(f
);
572 if (!fmt
|| !(fmt
->types
& MEM2MEM_OUTPUT
)) {
573 v4l2_err(&ctx
->dev
->v4l2_dev
,
574 "Fourcc format (0x%08x) invalid.\n",
575 f
->fmt
.pix
.pixelformat
);
578 if (!f
->fmt
.pix
.colorspace
)
579 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_REC709
;
581 return vidioc_try_fmt(f
, fmt
);
584 static int vidioc_s_fmt(struct m2mtest_ctx
*ctx
, struct v4l2_format
*f
)
586 struct m2mtest_q_data
*q_data
;
587 struct vb2_queue
*vq
;
589 vq
= v4l2_m2m_get_vq(ctx
->m2m_ctx
, f
->type
);
593 q_data
= get_q_data(ctx
, f
->type
);
597 if (vb2_is_busy(vq
)) {
598 v4l2_err(&ctx
->dev
->v4l2_dev
, "%s queue busy\n", __func__
);
602 q_data
->fmt
= find_format(f
);
603 q_data
->width
= f
->fmt
.pix
.width
;
604 q_data
->height
= f
->fmt
.pix
.height
;
605 q_data
->sizeimage
= q_data
->width
* q_data
->height
606 * q_data
->fmt
->depth
>> 3;
609 "Setting format for type %d, wxh: %dx%d, fmt: %d\n",
610 f
->type
, q_data
->width
, q_data
->height
, q_data
->fmt
->fourcc
);
615 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
616 struct v4l2_format
*f
)
620 ret
= vidioc_try_fmt_vid_cap(file
, priv
, f
);
624 return vidioc_s_fmt(file2ctx(file
), f
);
627 static int vidioc_s_fmt_vid_out(struct file
*file
, void *priv
,
628 struct v4l2_format
*f
)
630 struct m2mtest_ctx
*ctx
= file2ctx(file
);
633 ret
= vidioc_try_fmt_vid_out(file
, priv
, f
);
637 ret
= vidioc_s_fmt(file2ctx(file
), f
);
639 ctx
->colorspace
= f
->fmt
.pix
.colorspace
;
643 static int vidioc_reqbufs(struct file
*file
, void *priv
,
644 struct v4l2_requestbuffers
*reqbufs
)
646 struct m2mtest_ctx
*ctx
= file2ctx(file
);
648 return v4l2_m2m_reqbufs(file
, ctx
->m2m_ctx
, reqbufs
);
651 static int vidioc_querybuf(struct file
*file
, void *priv
,
652 struct v4l2_buffer
*buf
)
654 struct m2mtest_ctx
*ctx
= file2ctx(file
);
656 return v4l2_m2m_querybuf(file
, ctx
->m2m_ctx
, buf
);
659 static int vidioc_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
661 struct m2mtest_ctx
*ctx
= file2ctx(file
);
663 return v4l2_m2m_qbuf(file
, ctx
->m2m_ctx
, buf
);
666 static int vidioc_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
668 struct m2mtest_ctx
*ctx
= file2ctx(file
);
670 return v4l2_m2m_dqbuf(file
, ctx
->m2m_ctx
, buf
);
673 static int vidioc_streamon(struct file
*file
, void *priv
,
674 enum v4l2_buf_type type
)
676 struct m2mtest_ctx
*ctx
= file2ctx(file
);
678 return v4l2_m2m_streamon(file
, ctx
->m2m_ctx
, type
);
681 static int vidioc_streamoff(struct file
*file
, void *priv
,
682 enum v4l2_buf_type type
)
684 struct m2mtest_ctx
*ctx
= file2ctx(file
);
686 return v4l2_m2m_streamoff(file
, ctx
->m2m_ctx
, type
);
689 static int m2mtest_s_ctrl(struct v4l2_ctrl
*ctrl
)
691 struct m2mtest_ctx
*ctx
=
692 container_of(ctrl
->handler
, struct m2mtest_ctx
, hdl
);
697 ctx
->mode
|= MEM2MEM_HFLIP
;
699 ctx
->mode
&= ~MEM2MEM_HFLIP
;
704 ctx
->mode
|= MEM2MEM_VFLIP
;
706 ctx
->mode
&= ~MEM2MEM_VFLIP
;
709 case V4L2_CID_TRANS_TIME_MSEC
:
710 ctx
->transtime
= ctrl
->val
;
713 case V4L2_CID_TRANS_NUM_BUFS
:
714 ctx
->translen
= ctrl
->val
;
718 v4l2_err(&ctx
->dev
->v4l2_dev
, "Invalid control\n");
725 static const struct v4l2_ctrl_ops m2mtest_ctrl_ops
= {
726 .s_ctrl
= m2mtest_s_ctrl
,
730 static const struct v4l2_ioctl_ops m2mtest_ioctl_ops
= {
731 .vidioc_querycap
= vidioc_querycap
,
733 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
734 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
735 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
736 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
738 .vidioc_enum_fmt_vid_out
= vidioc_enum_fmt_vid_out
,
739 .vidioc_g_fmt_vid_out
= vidioc_g_fmt_vid_out
,
740 .vidioc_try_fmt_vid_out
= vidioc_try_fmt_vid_out
,
741 .vidioc_s_fmt_vid_out
= vidioc_s_fmt_vid_out
,
743 .vidioc_reqbufs
= vidioc_reqbufs
,
744 .vidioc_querybuf
= vidioc_querybuf
,
746 .vidioc_qbuf
= vidioc_qbuf
,
747 .vidioc_dqbuf
= vidioc_dqbuf
,
749 .vidioc_streamon
= vidioc_streamon
,
750 .vidioc_streamoff
= vidioc_streamoff
,
751 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
752 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
760 static int m2mtest_queue_setup(struct vb2_queue
*vq
,
761 const struct v4l2_format
*fmt
,
762 unsigned int *nbuffers
, unsigned int *nplanes
,
763 unsigned int sizes
[], void *alloc_ctxs
[])
765 struct m2mtest_ctx
*ctx
= vb2_get_drv_priv(vq
);
766 struct m2mtest_q_data
*q_data
;
767 unsigned int size
, count
= *nbuffers
;
769 q_data
= get_q_data(ctx
, vq
->type
);
771 size
= q_data
->width
* q_data
->height
* q_data
->fmt
->depth
>> 3;
773 while (size
* count
> MEM2MEM_VID_MEM_LIMIT
)
781 * videobuf2-vmalloc allocator is context-less so no need to set
785 dprintk(ctx
->dev
, "get %d buffer(s) of size %d each.\n", count
, size
);
790 static int m2mtest_buf_prepare(struct vb2_buffer
*vb
)
792 struct m2mtest_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
793 struct m2mtest_q_data
*q_data
;
795 dprintk(ctx
->dev
, "type: %d\n", vb
->vb2_queue
->type
);
797 q_data
= get_q_data(ctx
, vb
->vb2_queue
->type
);
799 if (vb2_plane_size(vb
, 0) < q_data
->sizeimage
) {
800 dprintk(ctx
->dev
, "%s data will not fit into plane (%lu < %lu)\n",
801 __func__
, vb2_plane_size(vb
, 0), (long)q_data
->sizeimage
);
805 vb2_set_plane_payload(vb
, 0, q_data
->sizeimage
);
810 static void m2mtest_buf_queue(struct vb2_buffer
*vb
)
812 struct m2mtest_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
813 v4l2_m2m_buf_queue(ctx
->m2m_ctx
, vb
);
816 static void m2mtest_wait_prepare(struct vb2_queue
*q
)
818 struct m2mtest_ctx
*ctx
= vb2_get_drv_priv(q
);
822 static void m2mtest_wait_finish(struct vb2_queue
*q
)
824 struct m2mtest_ctx
*ctx
= vb2_get_drv_priv(q
);
828 static struct vb2_ops m2mtest_qops
= {
829 .queue_setup
= m2mtest_queue_setup
,
830 .buf_prepare
= m2mtest_buf_prepare
,
831 .buf_queue
= m2mtest_buf_queue
,
832 .wait_prepare
= m2mtest_wait_prepare
,
833 .wait_finish
= m2mtest_wait_finish
,
836 static int queue_init(void *priv
, struct vb2_queue
*src_vq
, struct vb2_queue
*dst_vq
)
838 struct m2mtest_ctx
*ctx
= priv
;
841 memset(src_vq
, 0, sizeof(*src_vq
));
842 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
843 src_vq
->io_modes
= VB2_MMAP
;
844 src_vq
->drv_priv
= ctx
;
845 src_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
846 src_vq
->ops
= &m2mtest_qops
;
847 src_vq
->mem_ops
= &vb2_vmalloc_memops
;
849 ret
= vb2_queue_init(src_vq
);
853 memset(dst_vq
, 0, sizeof(*dst_vq
));
854 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
855 dst_vq
->io_modes
= VB2_MMAP
;
856 dst_vq
->drv_priv
= ctx
;
857 dst_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
858 dst_vq
->ops
= &m2mtest_qops
;
859 dst_vq
->mem_ops
= &vb2_vmalloc_memops
;
861 return vb2_queue_init(dst_vq
);
864 static const struct v4l2_ctrl_config m2mtest_ctrl_trans_time_msec
= {
865 .ops
= &m2mtest_ctrl_ops
,
866 .id
= V4L2_CID_TRANS_TIME_MSEC
,
867 .name
= "Transaction Time (msec)",
868 .type
= V4L2_CTRL_TYPE_INTEGER
,
875 static const struct v4l2_ctrl_config m2mtest_ctrl_trans_num_bufs
= {
876 .ops
= &m2mtest_ctrl_ops
,
877 .id
= V4L2_CID_TRANS_NUM_BUFS
,
878 .name
= "Buffers Per Transaction",
879 .type
= V4L2_CTRL_TYPE_INTEGER
,
882 .max
= MEM2MEM_DEF_NUM_BUFS
,
889 static int m2mtest_open(struct file
*file
)
891 struct m2mtest_dev
*dev
= video_drvdata(file
);
892 struct m2mtest_ctx
*ctx
= NULL
;
893 struct v4l2_ctrl_handler
*hdl
;
896 if (mutex_lock_interruptible(&dev
->dev_mutex
))
898 ctx
= kzalloc(sizeof *ctx
, GFP_KERNEL
);
904 v4l2_fh_init(&ctx
->fh
, video_devdata(file
));
905 file
->private_data
= &ctx
->fh
;
908 v4l2_ctrl_handler_init(hdl
, 4);
909 v4l2_ctrl_new_std(hdl
, &m2mtest_ctrl_ops
, V4L2_CID_HFLIP
, 0, 1, 1, 0);
910 v4l2_ctrl_new_std(hdl
, &m2mtest_ctrl_ops
, V4L2_CID_VFLIP
, 0, 1, 1, 0);
911 v4l2_ctrl_new_custom(hdl
, &m2mtest_ctrl_trans_time_msec
, NULL
);
912 v4l2_ctrl_new_custom(hdl
, &m2mtest_ctrl_trans_num_bufs
, NULL
);
914 int err
= hdl
->error
;
916 v4l2_ctrl_handler_free(hdl
);
919 ctx
->fh
.ctrl_handler
= hdl
;
920 v4l2_ctrl_handler_setup(hdl
);
922 ctx
->q_data
[V4L2_M2M_SRC
].fmt
= &formats
[0];
923 ctx
->q_data
[V4L2_M2M_SRC
].width
= 640;
924 ctx
->q_data
[V4L2_M2M_SRC
].height
= 480;
925 ctx
->q_data
[V4L2_M2M_SRC
].sizeimage
=
926 ctx
->q_data
[V4L2_M2M_SRC
].width
*
927 ctx
->q_data
[V4L2_M2M_SRC
].height
*
928 (ctx
->q_data
[V4L2_M2M_SRC
].fmt
->depth
>> 3);
929 ctx
->q_data
[V4L2_M2M_DST
] = ctx
->q_data
[V4L2_M2M_SRC
];
930 ctx
->colorspace
= V4L2_COLORSPACE_REC709
;
932 ctx
->m2m_ctx
= v4l2_m2m_ctx_init(dev
->m2m_dev
, ctx
, &queue_init
);
934 if (IS_ERR(ctx
->m2m_ctx
)) {
935 rc
= PTR_ERR(ctx
->m2m_ctx
);
937 v4l2_ctrl_handler_free(hdl
);
942 v4l2_fh_add(&ctx
->fh
);
943 atomic_inc(&dev
->num_inst
);
945 dprintk(dev
, "Created instance %p, m2m_ctx: %p\n", ctx
, ctx
->m2m_ctx
);
948 mutex_unlock(&dev
->dev_mutex
);
952 static int m2mtest_release(struct file
*file
)
954 struct m2mtest_dev
*dev
= video_drvdata(file
);
955 struct m2mtest_ctx
*ctx
= file2ctx(file
);
957 dprintk(dev
, "Releasing instance %p\n", ctx
);
959 v4l2_fh_del(&ctx
->fh
);
960 v4l2_fh_exit(&ctx
->fh
);
961 v4l2_ctrl_handler_free(&ctx
->hdl
);
962 mutex_lock(&dev
->dev_mutex
);
963 v4l2_m2m_ctx_release(ctx
->m2m_ctx
);
964 mutex_unlock(&dev
->dev_mutex
);
967 atomic_dec(&dev
->num_inst
);
972 static unsigned int m2mtest_poll(struct file
*file
,
973 struct poll_table_struct
*wait
)
975 struct m2mtest_ctx
*ctx
= file2ctx(file
);
977 return v4l2_m2m_poll(file
, ctx
->m2m_ctx
, wait
);
980 static int m2mtest_mmap(struct file
*file
, struct vm_area_struct
*vma
)
982 struct m2mtest_dev
*dev
= video_drvdata(file
);
983 struct m2mtest_ctx
*ctx
= file2ctx(file
);
986 if (mutex_lock_interruptible(&dev
->dev_mutex
))
988 res
= v4l2_m2m_mmap(file
, ctx
->m2m_ctx
, vma
);
989 mutex_unlock(&dev
->dev_mutex
);
993 static const struct v4l2_file_operations m2mtest_fops
= {
994 .owner
= THIS_MODULE
,
995 .open
= m2mtest_open
,
996 .release
= m2mtest_release
,
997 .poll
= m2mtest_poll
,
998 .unlocked_ioctl
= video_ioctl2
,
999 .mmap
= m2mtest_mmap
,
1002 static struct video_device m2mtest_videodev
= {
1003 .name
= MEM2MEM_NAME
,
1004 .fops
= &m2mtest_fops
,
1005 .ioctl_ops
= &m2mtest_ioctl_ops
,
1007 .release
= video_device_release
,
1010 static struct v4l2_m2m_ops m2m_ops
= {
1011 .device_run
= device_run
,
1012 .job_ready
= job_ready
,
1013 .job_abort
= job_abort
,
1014 .lock
= m2mtest_lock
,
1015 .unlock
= m2mtest_unlock
,
1018 static int m2mtest_probe(struct platform_device
*pdev
)
1020 struct m2mtest_dev
*dev
;
1021 struct video_device
*vfd
;
1024 dev
= kzalloc(sizeof *dev
, GFP_KERNEL
);
1028 spin_lock_init(&dev
->irqlock
);
1030 ret
= v4l2_device_register(&pdev
->dev
, &dev
->v4l2_dev
);
1034 atomic_set(&dev
->num_inst
, 0);
1035 mutex_init(&dev
->dev_mutex
);
1037 vfd
= video_device_alloc();
1039 v4l2_err(&dev
->v4l2_dev
, "Failed to allocate video device\n");
1044 *vfd
= m2mtest_videodev
;
1045 vfd
->lock
= &dev
->dev_mutex
;
1047 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, 0);
1049 v4l2_err(&dev
->v4l2_dev
, "Failed to register video device\n");
1053 video_set_drvdata(vfd
, dev
);
1054 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s", m2mtest_videodev
.name
);
1056 v4l2_info(&dev
->v4l2_dev
, MEM2MEM_TEST_MODULE_NAME
1057 "Device registered as /dev/video%d\n", vfd
->num
);
1059 setup_timer(&dev
->timer
, device_isr
, (long)dev
);
1060 platform_set_drvdata(pdev
, dev
);
1062 dev
->m2m_dev
= v4l2_m2m_init(&m2m_ops
);
1063 if (IS_ERR(dev
->m2m_dev
)) {
1064 v4l2_err(&dev
->v4l2_dev
, "Failed to init mem2mem device\n");
1065 ret
= PTR_ERR(dev
->m2m_dev
);
1071 v4l2_m2m_release(dev
->m2m_dev
);
1073 video_unregister_device(dev
->vfd
);
1075 video_device_release(vfd
);
1077 v4l2_device_unregister(&dev
->v4l2_dev
);
1084 static int m2mtest_remove(struct platform_device
*pdev
)
1086 struct m2mtest_dev
*dev
=
1087 (struct m2mtest_dev
*)platform_get_drvdata(pdev
);
1089 v4l2_info(&dev
->v4l2_dev
, "Removing " MEM2MEM_TEST_MODULE_NAME
);
1090 v4l2_m2m_release(dev
->m2m_dev
);
1091 del_timer_sync(&dev
->timer
);
1092 video_unregister_device(dev
->vfd
);
1093 v4l2_device_unregister(&dev
->v4l2_dev
);
1099 static struct platform_driver m2mtest_pdrv
= {
1100 .probe
= m2mtest_probe
,
1101 .remove
= m2mtest_remove
,
1103 .name
= MEM2MEM_NAME
,
1104 .owner
= THIS_MODULE
,
1108 static void __exit
m2mtest_exit(void)
1110 platform_driver_unregister(&m2mtest_pdrv
);
1111 platform_device_unregister(&m2mtest_pdev
);
1114 static int __init
m2mtest_init(void)
1118 ret
= platform_device_register(&m2mtest_pdev
);
1122 ret
= platform_driver_register(&m2mtest_pdrv
);
1124 platform_device_unregister(&m2mtest_pdev
);
1129 module_init(m2mtest_init
);
1130 module_exit(m2mtest_exit
);