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 MODULE_DESCRIPTION("Virtual device for mem2mem framework testing");
35 MODULE_AUTHOR("Pawel Osciak, <pawel@osciak.com>");
36 MODULE_LICENSE("GPL");
37 MODULE_VERSION("0.1.1");
38 MODULE_ALIAS("mem2mem_testdev");
40 static unsigned debug
;
41 module_param(debug
, uint
, 0644);
42 MODULE_PARM_DESC(debug
, "activates debug info");
48 #define DIM_ALIGN_MASK 7 /* 8-byte alignment for line length */
50 /* Flags that indicate a format can be used for capture/output */
51 #define MEM2MEM_CAPTURE (1 << 0)
52 #define MEM2MEM_OUTPUT (1 << 1)
54 #define MEM2MEM_NAME "vim2m"
57 #define MEM2MEM_DEF_NUM_BUFS VIDEO_MAX_FRAME
58 /* In bytes, per queue */
59 #define MEM2MEM_VID_MEM_LIMIT (16 * 1024 * 1024)
61 /* Default transaction time in msec */
62 #define MEM2MEM_DEF_TRANSTIME 40
63 #define MEM2MEM_COLOR_STEP (0xff >> 4)
64 #define MEM2MEM_NUM_TILES 8
66 /* Flags that indicate processing mode */
67 #define MEM2MEM_HFLIP (1 << 0)
68 #define MEM2MEM_VFLIP (1 << 1)
70 #define dprintk(dev, fmt, arg...) \
71 v4l2_dbg(1, debug, &dev->v4l2_dev, "%s: " fmt, __func__, ## arg)
74 static void vim2m_dev_release(struct device
*dev
)
77 static struct platform_device vim2m_pdev
= {
79 .dev
.release
= vim2m_dev_release
,
86 /* Types the format can be used for */
90 static struct vim2m_fmt formats
[] = {
92 .name
= "RGB565 (BE)",
93 .fourcc
= V4L2_PIX_FMT_RGB565X
, /* rrrrrggg gggbbbbb */
95 /* Both capture and output format */
96 .types
= MEM2MEM_CAPTURE
| MEM2MEM_OUTPUT
,
99 .name
= "4:2:2, packed, YUYV",
100 .fourcc
= V4L2_PIX_FMT_YUYV
,
102 /* Output-only format */
103 .types
= MEM2MEM_OUTPUT
,
107 #define NUM_FORMATS ARRAY_SIZE(formats)
109 /* Per-queue, driver-specific private data */
110 struct vim2m_q_data
{
113 unsigned int sizeimage
;
114 unsigned int sequence
;
115 struct vim2m_fmt
*fmt
;
123 #define V4L2_CID_TRANS_TIME_MSEC (V4L2_CID_USER_BASE + 0x1000)
124 #define V4L2_CID_TRANS_NUM_BUFS (V4L2_CID_USER_BASE + 0x1001)
126 static struct vim2m_fmt
*find_format(struct v4l2_format
*f
)
128 struct vim2m_fmt
*fmt
;
131 for (k
= 0; k
< NUM_FORMATS
; k
++) {
133 if (fmt
->fourcc
== f
->fmt
.pix
.pixelformat
)
137 if (k
== NUM_FORMATS
)
144 struct v4l2_device v4l2_dev
;
145 struct video_device
*vfd
;
148 struct mutex dev_mutex
;
151 struct timer_list timer
;
153 struct v4l2_m2m_dev
*m2m_dev
;
158 struct vim2m_dev
*dev
;
160 struct v4l2_ctrl_handler hdl
;
162 /* Processed buffers in this transaction */
165 /* Transaction length (i.e. how many buffers per transaction) */
167 /* Transaction time (i.e. simulated processing time) in milliseconds */
170 /* Abort requested by m2m */
173 /* Processing mode */
176 enum v4l2_colorspace colorspace
;
178 /* Source and destination queue data */
179 struct vim2m_q_data q_data
[2];
182 static inline struct vim2m_ctx
*file2ctx(struct file
*file
)
184 return container_of(file
->private_data
, struct vim2m_ctx
, fh
);
187 static struct vim2m_q_data
*get_q_data(struct vim2m_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 vim2m_ctx
*ctx
,
203 struct vb2_buffer
*in_vb
,
204 struct vb2_buffer
*out_vb
)
206 struct vim2m_dev
*dev
= ctx
->dev
;
207 struct vim2m_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
;
237 out_vb
->v4l2_buf
.sequence
= get_q_data(ctx
, V4L2_BUF_TYPE_VIDEO_CAPTURE
)->sequence
++;
238 in_vb
->v4l2_buf
.sequence
= q_data
->sequence
++;
239 memcpy(&out_vb
->v4l2_buf
.timestamp
,
240 &in_vb
->v4l2_buf
.timestamp
,
241 sizeof(struct timeval
));
242 if (in_vb
->v4l2_buf
.flags
& V4L2_BUF_FLAG_TIMECODE
)
243 memcpy(&out_vb
->v4l2_buf
.timecode
, &in_vb
->v4l2_buf
.timecode
,
244 sizeof(struct v4l2_timecode
));
245 out_vb
->v4l2_buf
.field
= in_vb
->v4l2_buf
.field
;
246 out_vb
->v4l2_buf
.flags
= in_vb
->v4l2_buf
.flags
&
247 (V4L2_BUF_FLAG_TIMECODE
|
248 V4L2_BUF_FLAG_KEYFRAME
|
249 V4L2_BUF_FLAG_PFRAME
|
250 V4L2_BUF_FLAG_BFRAME
|
251 V4L2_BUF_FLAG_TSTAMP_SRC_MASK
);
254 case MEM2MEM_HFLIP
| MEM2MEM_VFLIP
:
255 p_out
+= bytesperline
* height
- bytes_left
;
256 for (y
= 0; y
< height
; ++y
) {
257 for (t
= 0; t
< MEM2MEM_NUM_TILES
; ++t
) {
259 for (x
= 0; x
< tile_w
; ++x
)
263 for (x
= 0; x
< tile_w
; ++x
)
275 for (y
= 0; y
< height
; ++y
) {
276 p_out
+= MEM2MEM_NUM_TILES
* tile_w
;
277 for (t
= 0; t
< MEM2MEM_NUM_TILES
; ++t
) {
279 for (x
= 0; x
< tile_w
; ++x
)
283 for (x
= 0; x
< tile_w
; ++x
)
290 p_out
+= bytesperline
;
295 p_out
+= bytesperline
* (height
- 1);
296 for (y
= 0; y
< height
; ++y
) {
297 for (t
= 0; t
< MEM2MEM_NUM_TILES
; ++t
) {
299 for (x
= 0; x
< tile_w
; ++x
)
303 for (x
= 0; x
< tile_w
; ++x
)
310 p_out
+= bytes_left
- 2 * bytesperline
;
315 for (y
= 0; y
< height
; ++y
) {
316 for (t
= 0; t
< MEM2MEM_NUM_TILES
; ++t
) {
318 for (x
= 0; x
< tile_w
; ++x
)
322 for (x
= 0; x
< tile_w
; ++x
)
336 static void schedule_irq(struct vim2m_dev
*dev
, int msec_timeout
)
338 dprintk(dev
, "Scheduling a simulated irq\n");
339 mod_timer(&dev
->timer
, jiffies
+ msecs_to_jiffies(msec_timeout
));
347 * job_ready() - check whether an instance is ready to be scheduled to run
349 static int job_ready(void *priv
)
351 struct vim2m_ctx
*ctx
= priv
;
353 if (v4l2_m2m_num_src_bufs_ready(ctx
->fh
.m2m_ctx
) < ctx
->translen
354 || v4l2_m2m_num_dst_bufs_ready(ctx
->fh
.m2m_ctx
) < ctx
->translen
) {
355 dprintk(ctx
->dev
, "Not enough buffers available\n");
362 static void job_abort(void *priv
)
364 struct vim2m_ctx
*ctx
= priv
;
366 /* Will cancel the transaction in the next interrupt handler */
370 /* device_run() - prepares and starts the device
372 * This simulates all the immediate preparations required before starting
373 * a device. This will be called by the framework when it decides to schedule
374 * a particular instance.
376 static void device_run(void *priv
)
378 struct vim2m_ctx
*ctx
= priv
;
379 struct vim2m_dev
*dev
= ctx
->dev
;
380 struct vb2_buffer
*src_buf
, *dst_buf
;
382 src_buf
= v4l2_m2m_next_src_buf(ctx
->fh
.m2m_ctx
);
383 dst_buf
= v4l2_m2m_next_dst_buf(ctx
->fh
.m2m_ctx
);
385 device_process(ctx
, src_buf
, dst_buf
);
387 /* Run a timer, which simulates a hardware irq */
388 schedule_irq(dev
, ctx
->transtime
);
391 static void device_isr(unsigned long priv
)
393 struct vim2m_dev
*vim2m_dev
= (struct vim2m_dev
*)priv
;
394 struct vim2m_ctx
*curr_ctx
;
395 struct vb2_buffer
*src_vb
, *dst_vb
;
398 curr_ctx
= v4l2_m2m_get_curr_priv(vim2m_dev
->m2m_dev
);
400 if (NULL
== curr_ctx
) {
401 pr_err("Instance released before the end of transaction\n");
405 src_vb
= v4l2_m2m_src_buf_remove(curr_ctx
->fh
.m2m_ctx
);
406 dst_vb
= v4l2_m2m_dst_buf_remove(curr_ctx
->fh
.m2m_ctx
);
408 curr_ctx
->num_processed
++;
410 spin_lock_irqsave(&vim2m_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(&vim2m_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(vim2m_dev
->m2m_dev
, curr_ctx
->fh
.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 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
),
434 "platform:%s", MEM2MEM_NAME
);
435 cap
->device_caps
= V4L2_CAP_VIDEO_M2M
| V4L2_CAP_STREAMING
;
436 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
440 static int enum_fmt(struct v4l2_fmtdesc
*f
, u32 type
)
443 struct vim2m_fmt
*fmt
;
447 for (i
= 0; i
< NUM_FORMATS
; ++i
) {
448 if (formats
[i
].types
& type
) {
449 /* index-th format of type type found ? */
452 /* Correct type but haven't reached our index yet,
453 * just increment per-type index */
458 if (i
< NUM_FORMATS
) {
461 strncpy(f
->description
, fmt
->name
, sizeof(f
->description
) - 1);
462 f
->pixelformat
= fmt
->fourcc
;
466 /* Format not found */
470 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
471 struct v4l2_fmtdesc
*f
)
473 return enum_fmt(f
, MEM2MEM_CAPTURE
);
476 static int vidioc_enum_fmt_vid_out(struct file
*file
, void *priv
,
477 struct v4l2_fmtdesc
*f
)
479 return enum_fmt(f
, MEM2MEM_OUTPUT
);
482 static int vidioc_g_fmt(struct vim2m_ctx
*ctx
, struct v4l2_format
*f
)
484 struct vb2_queue
*vq
;
485 struct vim2m_q_data
*q_data
;
487 vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, f
->type
);
491 q_data
= get_q_data(ctx
, f
->type
);
493 f
->fmt
.pix
.width
= q_data
->width
;
494 f
->fmt
.pix
.height
= q_data
->height
;
495 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
496 f
->fmt
.pix
.pixelformat
= q_data
->fmt
->fourcc
;
497 f
->fmt
.pix
.bytesperline
= (q_data
->width
* q_data
->fmt
->depth
) >> 3;
498 f
->fmt
.pix
.sizeimage
= q_data
->sizeimage
;
499 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
504 static int vidioc_g_fmt_vid_out(struct file
*file
, void *priv
,
505 struct v4l2_format
*f
)
507 return vidioc_g_fmt(file2ctx(file
), f
);
510 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
511 struct v4l2_format
*f
)
513 return vidioc_g_fmt(file2ctx(file
), f
);
516 static int vidioc_try_fmt(struct v4l2_format
*f
, struct vim2m_fmt
*fmt
)
518 /* V4L2 specification suggests the driver corrects the format struct
519 * if any of the dimensions is unsupported */
520 if (f
->fmt
.pix
.height
< MIN_H
)
521 f
->fmt
.pix
.height
= MIN_H
;
522 else if (f
->fmt
.pix
.height
> MAX_H
)
523 f
->fmt
.pix
.height
= MAX_H
;
525 if (f
->fmt
.pix
.width
< MIN_W
)
526 f
->fmt
.pix
.width
= MIN_W
;
527 else if (f
->fmt
.pix
.width
> MAX_W
)
528 f
->fmt
.pix
.width
= MAX_W
;
530 f
->fmt
.pix
.width
&= ~DIM_ALIGN_MASK
;
531 f
->fmt
.pix
.bytesperline
= (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
532 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
533 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
538 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
539 struct v4l2_format
*f
)
541 struct vim2m_fmt
*fmt
;
542 struct vim2m_ctx
*ctx
= file2ctx(file
);
544 fmt
= find_format(f
);
546 f
->fmt
.pix
.pixelformat
= formats
[0].fourcc
;
547 fmt
= find_format(f
);
549 if (!(fmt
->types
& MEM2MEM_CAPTURE
)) {
550 v4l2_err(&ctx
->dev
->v4l2_dev
,
551 "Fourcc format (0x%08x) invalid.\n",
552 f
->fmt
.pix
.pixelformat
);
555 f
->fmt
.pix
.colorspace
= ctx
->colorspace
;
557 return vidioc_try_fmt(f
, fmt
);
560 static int vidioc_try_fmt_vid_out(struct file
*file
, void *priv
,
561 struct v4l2_format
*f
)
563 struct vim2m_fmt
*fmt
;
564 struct vim2m_ctx
*ctx
= file2ctx(file
);
566 fmt
= find_format(f
);
568 f
->fmt
.pix
.pixelformat
= formats
[0].fourcc
;
569 fmt
= find_format(f
);
571 if (!(fmt
->types
& MEM2MEM_OUTPUT
)) {
572 v4l2_err(&ctx
->dev
->v4l2_dev
,
573 "Fourcc format (0x%08x) invalid.\n",
574 f
->fmt
.pix
.pixelformat
);
577 if (!f
->fmt
.pix
.colorspace
)
578 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_REC709
;
580 return vidioc_try_fmt(f
, fmt
);
583 static int vidioc_s_fmt(struct vim2m_ctx
*ctx
, struct v4l2_format
*f
)
585 struct vim2m_q_data
*q_data
;
586 struct vb2_queue
*vq
;
588 vq
= v4l2_m2m_get_vq(ctx
->fh
.m2m_ctx
, f
->type
);
592 q_data
= get_q_data(ctx
, f
->type
);
596 if (vb2_is_busy(vq
)) {
597 v4l2_err(&ctx
->dev
->v4l2_dev
, "%s queue busy\n", __func__
);
601 q_data
->fmt
= find_format(f
);
602 q_data
->width
= f
->fmt
.pix
.width
;
603 q_data
->height
= f
->fmt
.pix
.height
;
604 q_data
->sizeimage
= q_data
->width
* q_data
->height
605 * q_data
->fmt
->depth
>> 3;
608 "Setting format for type %d, wxh: %dx%d, fmt: %d\n",
609 f
->type
, q_data
->width
, q_data
->height
, q_data
->fmt
->fourcc
);
614 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
615 struct v4l2_format
*f
)
619 ret
= vidioc_try_fmt_vid_cap(file
, priv
, f
);
623 return vidioc_s_fmt(file2ctx(file
), f
);
626 static int vidioc_s_fmt_vid_out(struct file
*file
, void *priv
,
627 struct v4l2_format
*f
)
629 struct vim2m_ctx
*ctx
= file2ctx(file
);
632 ret
= vidioc_try_fmt_vid_out(file
, priv
, f
);
636 ret
= vidioc_s_fmt(file2ctx(file
), f
);
638 ctx
->colorspace
= f
->fmt
.pix
.colorspace
;
642 static int vim2m_s_ctrl(struct v4l2_ctrl
*ctrl
)
644 struct vim2m_ctx
*ctx
=
645 container_of(ctrl
->handler
, struct vim2m_ctx
, hdl
);
650 ctx
->mode
|= MEM2MEM_HFLIP
;
652 ctx
->mode
&= ~MEM2MEM_HFLIP
;
657 ctx
->mode
|= MEM2MEM_VFLIP
;
659 ctx
->mode
&= ~MEM2MEM_VFLIP
;
662 case V4L2_CID_TRANS_TIME_MSEC
:
663 ctx
->transtime
= ctrl
->val
;
666 case V4L2_CID_TRANS_NUM_BUFS
:
667 ctx
->translen
= ctrl
->val
;
671 v4l2_err(&ctx
->dev
->v4l2_dev
, "Invalid control\n");
678 static const struct v4l2_ctrl_ops vim2m_ctrl_ops
= {
679 .s_ctrl
= vim2m_s_ctrl
,
683 static const struct v4l2_ioctl_ops vim2m_ioctl_ops
= {
684 .vidioc_querycap
= vidioc_querycap
,
686 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
687 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
688 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
689 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
691 .vidioc_enum_fmt_vid_out
= vidioc_enum_fmt_vid_out
,
692 .vidioc_g_fmt_vid_out
= vidioc_g_fmt_vid_out
,
693 .vidioc_try_fmt_vid_out
= vidioc_try_fmt_vid_out
,
694 .vidioc_s_fmt_vid_out
= vidioc_s_fmt_vid_out
,
696 .vidioc_reqbufs
= v4l2_m2m_ioctl_reqbufs
,
697 .vidioc_querybuf
= v4l2_m2m_ioctl_querybuf
,
698 .vidioc_qbuf
= v4l2_m2m_ioctl_qbuf
,
699 .vidioc_dqbuf
= v4l2_m2m_ioctl_dqbuf
,
700 .vidioc_expbuf
= v4l2_m2m_ioctl_expbuf
,
702 .vidioc_streamon
= v4l2_m2m_ioctl_streamon
,
703 .vidioc_streamoff
= v4l2_m2m_ioctl_streamoff
,
705 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
706 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
714 static int vim2m_queue_setup(struct vb2_queue
*vq
,
715 const struct v4l2_format
*fmt
,
716 unsigned int *nbuffers
, unsigned int *nplanes
,
717 unsigned int sizes
[], void *alloc_ctxs
[])
719 struct vim2m_ctx
*ctx
= vb2_get_drv_priv(vq
);
720 struct vim2m_q_data
*q_data
;
721 unsigned int size
, count
= *nbuffers
;
723 q_data
= get_q_data(ctx
, vq
->type
);
725 size
= q_data
->width
* q_data
->height
* q_data
->fmt
->depth
>> 3;
727 while (size
* count
> MEM2MEM_VID_MEM_LIMIT
)
735 * videobuf2-vmalloc allocator is context-less so no need to set
739 dprintk(ctx
->dev
, "get %d buffer(s) of size %d each.\n", count
, size
);
744 static int vim2m_buf_prepare(struct vb2_buffer
*vb
)
746 struct vim2m_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
747 struct vim2m_q_data
*q_data
;
749 dprintk(ctx
->dev
, "type: %d\n", vb
->vb2_queue
->type
);
751 q_data
= get_q_data(ctx
, vb
->vb2_queue
->type
);
752 if (V4L2_TYPE_IS_OUTPUT(vb
->vb2_queue
->type
)) {
753 if (vb
->v4l2_buf
.field
== V4L2_FIELD_ANY
)
754 vb
->v4l2_buf
.field
= V4L2_FIELD_NONE
;
755 if (vb
->v4l2_buf
.field
!= V4L2_FIELD_NONE
) {
756 dprintk(ctx
->dev
, "%s field isn't supported\n",
762 if (vb2_plane_size(vb
, 0) < q_data
->sizeimage
) {
763 dprintk(ctx
->dev
, "%s data will not fit into plane (%lu < %lu)\n",
764 __func__
, vb2_plane_size(vb
, 0), (long)q_data
->sizeimage
);
768 vb2_set_plane_payload(vb
, 0, q_data
->sizeimage
);
773 static void vim2m_buf_queue(struct vb2_buffer
*vb
)
775 struct vim2m_ctx
*ctx
= vb2_get_drv_priv(vb
->vb2_queue
);
777 v4l2_m2m_buf_queue(ctx
->fh
.m2m_ctx
, vb
);
780 static int vim2m_start_streaming(struct vb2_queue
*q
, unsigned count
)
782 struct vim2m_ctx
*ctx
= vb2_get_drv_priv(q
);
783 struct vim2m_q_data
*q_data
= get_q_data(ctx
, q
->type
);
785 q_data
->sequence
= 0;
789 static void vim2m_stop_streaming(struct vb2_queue
*q
)
791 struct vim2m_ctx
*ctx
= vb2_get_drv_priv(q
);
792 struct vb2_buffer
*vb
;
796 if (V4L2_TYPE_IS_OUTPUT(q
->type
))
797 vb
= v4l2_m2m_src_buf_remove(ctx
->fh
.m2m_ctx
);
799 vb
= v4l2_m2m_dst_buf_remove(ctx
->fh
.m2m_ctx
);
802 spin_lock_irqsave(&ctx
->dev
->irqlock
, flags
);
803 v4l2_m2m_buf_done(vb
, VB2_BUF_STATE_ERROR
);
804 spin_unlock_irqrestore(&ctx
->dev
->irqlock
, flags
);
808 static struct vb2_ops vim2m_qops
= {
809 .queue_setup
= vim2m_queue_setup
,
810 .buf_prepare
= vim2m_buf_prepare
,
811 .buf_queue
= vim2m_buf_queue
,
812 .start_streaming
= vim2m_start_streaming
,
813 .stop_streaming
= vim2m_stop_streaming
,
814 .wait_prepare
= vb2_ops_wait_prepare
,
815 .wait_finish
= vb2_ops_wait_finish
,
818 static int queue_init(void *priv
, struct vb2_queue
*src_vq
, struct vb2_queue
*dst_vq
)
820 struct vim2m_ctx
*ctx
= priv
;
823 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
824 src_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
825 src_vq
->drv_priv
= ctx
;
826 src_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
827 src_vq
->ops
= &vim2m_qops
;
828 src_vq
->mem_ops
= &vb2_vmalloc_memops
;
829 src_vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
830 src_vq
->lock
= &ctx
->dev
->dev_mutex
;
832 ret
= vb2_queue_init(src_vq
);
836 dst_vq
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
837 dst_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
838 dst_vq
->drv_priv
= ctx
;
839 dst_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
840 dst_vq
->ops
= &vim2m_qops
;
841 dst_vq
->mem_ops
= &vb2_vmalloc_memops
;
842 dst_vq
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_COPY
;
843 dst_vq
->lock
= &ctx
->dev
->dev_mutex
;
845 return vb2_queue_init(dst_vq
);
848 static const struct v4l2_ctrl_config vim2m_ctrl_trans_time_msec
= {
849 .ops
= &vim2m_ctrl_ops
,
850 .id
= V4L2_CID_TRANS_TIME_MSEC
,
851 .name
= "Transaction Time (msec)",
852 .type
= V4L2_CTRL_TYPE_INTEGER
,
853 .def
= MEM2MEM_DEF_TRANSTIME
,
859 static const struct v4l2_ctrl_config vim2m_ctrl_trans_num_bufs
= {
860 .ops
= &vim2m_ctrl_ops
,
861 .id
= V4L2_CID_TRANS_NUM_BUFS
,
862 .name
= "Buffers Per Transaction",
863 .type
= V4L2_CTRL_TYPE_INTEGER
,
866 .max
= MEM2MEM_DEF_NUM_BUFS
,
873 static int vim2m_open(struct file
*file
)
875 struct vim2m_dev
*dev
= video_drvdata(file
);
876 struct vim2m_ctx
*ctx
= NULL
;
877 struct v4l2_ctrl_handler
*hdl
;
880 if (mutex_lock_interruptible(&dev
->dev_mutex
))
882 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
);
888 v4l2_fh_init(&ctx
->fh
, video_devdata(file
));
889 file
->private_data
= &ctx
->fh
;
892 v4l2_ctrl_handler_init(hdl
, 4);
893 v4l2_ctrl_new_std(hdl
, &vim2m_ctrl_ops
, V4L2_CID_HFLIP
, 0, 1, 1, 0);
894 v4l2_ctrl_new_std(hdl
, &vim2m_ctrl_ops
, V4L2_CID_VFLIP
, 0, 1, 1, 0);
895 v4l2_ctrl_new_custom(hdl
, &vim2m_ctrl_trans_time_msec
, NULL
);
896 v4l2_ctrl_new_custom(hdl
, &vim2m_ctrl_trans_num_bufs
, NULL
);
899 v4l2_ctrl_handler_free(hdl
);
902 ctx
->fh
.ctrl_handler
= hdl
;
903 v4l2_ctrl_handler_setup(hdl
);
905 ctx
->q_data
[V4L2_M2M_SRC
].fmt
= &formats
[0];
906 ctx
->q_data
[V4L2_M2M_SRC
].width
= 640;
907 ctx
->q_data
[V4L2_M2M_SRC
].height
= 480;
908 ctx
->q_data
[V4L2_M2M_SRC
].sizeimage
=
909 ctx
->q_data
[V4L2_M2M_SRC
].width
*
910 ctx
->q_data
[V4L2_M2M_SRC
].height
*
911 (ctx
->q_data
[V4L2_M2M_SRC
].fmt
->depth
>> 3);
912 ctx
->q_data
[V4L2_M2M_DST
] = ctx
->q_data
[V4L2_M2M_SRC
];
913 ctx
->colorspace
= V4L2_COLORSPACE_REC709
;
915 ctx
->fh
.m2m_ctx
= v4l2_m2m_ctx_init(dev
->m2m_dev
, ctx
, &queue_init
);
917 if (IS_ERR(ctx
->fh
.m2m_ctx
)) {
918 rc
= PTR_ERR(ctx
->fh
.m2m_ctx
);
920 v4l2_ctrl_handler_free(hdl
);
925 v4l2_fh_add(&ctx
->fh
);
926 atomic_inc(&dev
->num_inst
);
928 dprintk(dev
, "Created instance: %p, m2m_ctx: %p\n",
929 ctx
, ctx
->fh
.m2m_ctx
);
932 mutex_unlock(&dev
->dev_mutex
);
936 static int vim2m_release(struct file
*file
)
938 struct vim2m_dev
*dev
= video_drvdata(file
);
939 struct vim2m_ctx
*ctx
= file2ctx(file
);
941 dprintk(dev
, "Releasing instance %p\n", ctx
);
943 v4l2_fh_del(&ctx
->fh
);
944 v4l2_fh_exit(&ctx
->fh
);
945 v4l2_ctrl_handler_free(&ctx
->hdl
);
946 mutex_lock(&dev
->dev_mutex
);
947 v4l2_m2m_ctx_release(ctx
->fh
.m2m_ctx
);
948 mutex_unlock(&dev
->dev_mutex
);
951 atomic_dec(&dev
->num_inst
);
956 static const struct v4l2_file_operations vim2m_fops
= {
957 .owner
= THIS_MODULE
,
959 .release
= vim2m_release
,
960 .poll
= v4l2_m2m_fop_poll
,
961 .unlocked_ioctl
= video_ioctl2
,
962 .mmap
= v4l2_m2m_fop_mmap
,
965 static struct video_device vim2m_videodev
= {
966 .name
= MEM2MEM_NAME
,
967 .vfl_dir
= VFL_DIR_M2M
,
969 .ioctl_ops
= &vim2m_ioctl_ops
,
971 .release
= video_device_release
,
974 static struct v4l2_m2m_ops m2m_ops
= {
975 .device_run
= device_run
,
976 .job_ready
= job_ready
,
977 .job_abort
= job_abort
,
980 static int vim2m_probe(struct platform_device
*pdev
)
982 struct vim2m_dev
*dev
;
983 struct video_device
*vfd
;
986 dev
= devm_kzalloc(&pdev
->dev
, sizeof(*dev
), GFP_KERNEL
);
990 spin_lock_init(&dev
->irqlock
);
992 ret
= v4l2_device_register(&pdev
->dev
, &dev
->v4l2_dev
);
996 atomic_set(&dev
->num_inst
, 0);
997 mutex_init(&dev
->dev_mutex
);
999 vfd
= video_device_alloc();
1001 v4l2_err(&dev
->v4l2_dev
, "Failed to allocate video device\n");
1006 *vfd
= vim2m_videodev
;
1007 vfd
->lock
= &dev
->dev_mutex
;
1008 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
1010 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, 0);
1012 v4l2_err(&dev
->v4l2_dev
, "Failed to register video device\n");
1016 video_set_drvdata(vfd
, dev
);
1017 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s", vim2m_videodev
.name
);
1019 v4l2_info(&dev
->v4l2_dev
,
1020 "Device registered as /dev/video%d\n", vfd
->num
);
1022 setup_timer(&dev
->timer
, device_isr
, (long)dev
);
1023 platform_set_drvdata(pdev
, dev
);
1025 dev
->m2m_dev
= v4l2_m2m_init(&m2m_ops
);
1026 if (IS_ERR(dev
->m2m_dev
)) {
1027 v4l2_err(&dev
->v4l2_dev
, "Failed to init mem2mem device\n");
1028 ret
= PTR_ERR(dev
->m2m_dev
);
1035 v4l2_m2m_release(dev
->m2m_dev
);
1036 video_unregister_device(dev
->vfd
);
1038 video_device_release(vfd
);
1040 v4l2_device_unregister(&dev
->v4l2_dev
);
1045 static int vim2m_remove(struct platform_device
*pdev
)
1047 struct vim2m_dev
*dev
= platform_get_drvdata(pdev
);
1049 v4l2_info(&dev
->v4l2_dev
, "Removing " MEM2MEM_NAME
);
1050 v4l2_m2m_release(dev
->m2m_dev
);
1051 del_timer_sync(&dev
->timer
);
1052 video_unregister_device(dev
->vfd
);
1053 v4l2_device_unregister(&dev
->v4l2_dev
);
1058 static struct platform_driver vim2m_pdrv
= {
1059 .probe
= vim2m_probe
,
1060 .remove
= vim2m_remove
,
1062 .name
= MEM2MEM_NAME
,
1066 static void __exit
vim2m_exit(void)
1068 platform_driver_unregister(&vim2m_pdrv
);
1069 platform_device_unregister(&vim2m_pdev
);
1072 static int __init
vim2m_init(void)
1076 ret
= platform_device_register(&vim2m_pdev
);
1080 ret
= platform_driver_register(&vim2m_pdrv
);
1082 platform_device_unregister(&vim2m_pdev
);
1087 module_init(vim2m_init
);
1088 module_exit(vim2m_exit
);