2 * TI OMAP4 ISS V4L2 Driver - Generic video node
4 * Copyright (C) 2012 Texas Instruments, Inc.
6 * Author: Sergio Aguirre <sergio.a.aguirre@gmail.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
14 #include <asm/cacheflush.h>
15 #include <linux/clk.h>
17 #include <linux/pagemap.h>
18 #include <linux/sched.h>
19 #include <linux/slab.h>
20 #include <linux/vmalloc.h>
21 #include <linux/module.h>
22 #include <media/v4l2-dev.h>
23 #include <media/v4l2-ioctl.h>
25 #include "iss_video.h"
28 /* -----------------------------------------------------------------------------
32 static struct iss_format_info formats
[] = {
33 { MEDIA_BUS_FMT_Y8_1X8
, MEDIA_BUS_FMT_Y8_1X8
,
34 MEDIA_BUS_FMT_Y8_1X8
, MEDIA_BUS_FMT_Y8_1X8
,
35 V4L2_PIX_FMT_GREY
, 8, "Greyscale 8 bpp", },
36 { MEDIA_BUS_FMT_Y10_1X10
, MEDIA_BUS_FMT_Y10_1X10
,
37 MEDIA_BUS_FMT_Y10_1X10
, MEDIA_BUS_FMT_Y8_1X8
,
38 V4L2_PIX_FMT_Y10
, 10, "Greyscale 10 bpp", },
39 { MEDIA_BUS_FMT_Y12_1X12
, MEDIA_BUS_FMT_Y10_1X10
,
40 MEDIA_BUS_FMT_Y12_1X12
, MEDIA_BUS_FMT_Y8_1X8
,
41 V4L2_PIX_FMT_Y12
, 12, "Greyscale 12 bpp", },
42 { MEDIA_BUS_FMT_SBGGR8_1X8
, MEDIA_BUS_FMT_SBGGR8_1X8
,
43 MEDIA_BUS_FMT_SBGGR8_1X8
, MEDIA_BUS_FMT_SBGGR8_1X8
,
44 V4L2_PIX_FMT_SBGGR8
, 8, "BGGR Bayer 8 bpp", },
45 { MEDIA_BUS_FMT_SGBRG8_1X8
, MEDIA_BUS_FMT_SGBRG8_1X8
,
46 MEDIA_BUS_FMT_SGBRG8_1X8
, MEDIA_BUS_FMT_SGBRG8_1X8
,
47 V4L2_PIX_FMT_SGBRG8
, 8, "GBRG Bayer 8 bpp", },
48 { MEDIA_BUS_FMT_SGRBG8_1X8
, MEDIA_BUS_FMT_SGRBG8_1X8
,
49 MEDIA_BUS_FMT_SGRBG8_1X8
, MEDIA_BUS_FMT_SGRBG8_1X8
,
50 V4L2_PIX_FMT_SGRBG8
, 8, "GRBG Bayer 8 bpp", },
51 { MEDIA_BUS_FMT_SRGGB8_1X8
, MEDIA_BUS_FMT_SRGGB8_1X8
,
52 MEDIA_BUS_FMT_SRGGB8_1X8
, MEDIA_BUS_FMT_SRGGB8_1X8
,
53 V4L2_PIX_FMT_SRGGB8
, 8, "RGGB Bayer 8 bpp", },
54 { MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8
, MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8
,
55 MEDIA_BUS_FMT_SGRBG10_1X10
, 0,
56 V4L2_PIX_FMT_SGRBG10DPCM8
, 8, "GRBG Bayer 10 bpp DPCM8", },
57 { MEDIA_BUS_FMT_SBGGR10_1X10
, MEDIA_BUS_FMT_SBGGR10_1X10
,
58 MEDIA_BUS_FMT_SBGGR10_1X10
, MEDIA_BUS_FMT_SBGGR8_1X8
,
59 V4L2_PIX_FMT_SBGGR10
, 10, "BGGR Bayer 10 bpp", },
60 { MEDIA_BUS_FMT_SGBRG10_1X10
, MEDIA_BUS_FMT_SGBRG10_1X10
,
61 MEDIA_BUS_FMT_SGBRG10_1X10
, MEDIA_BUS_FMT_SGBRG8_1X8
,
62 V4L2_PIX_FMT_SGBRG10
, 10, "GBRG Bayer 10 bpp", },
63 { MEDIA_BUS_FMT_SGRBG10_1X10
, MEDIA_BUS_FMT_SGRBG10_1X10
,
64 MEDIA_BUS_FMT_SGRBG10_1X10
, MEDIA_BUS_FMT_SGRBG8_1X8
,
65 V4L2_PIX_FMT_SGRBG10
, 10, "GRBG Bayer 10 bpp", },
66 { MEDIA_BUS_FMT_SRGGB10_1X10
, MEDIA_BUS_FMT_SRGGB10_1X10
,
67 MEDIA_BUS_FMT_SRGGB10_1X10
, MEDIA_BUS_FMT_SRGGB8_1X8
,
68 V4L2_PIX_FMT_SRGGB10
, 10, "RGGB Bayer 10 bpp", },
69 { MEDIA_BUS_FMT_SBGGR12_1X12
, MEDIA_BUS_FMT_SBGGR10_1X10
,
70 MEDIA_BUS_FMT_SBGGR12_1X12
, MEDIA_BUS_FMT_SBGGR8_1X8
,
71 V4L2_PIX_FMT_SBGGR12
, 12, "BGGR Bayer 12 bpp", },
72 { MEDIA_BUS_FMT_SGBRG12_1X12
, MEDIA_BUS_FMT_SGBRG10_1X10
,
73 MEDIA_BUS_FMT_SGBRG12_1X12
, MEDIA_BUS_FMT_SGBRG8_1X8
,
74 V4L2_PIX_FMT_SGBRG12
, 12, "GBRG Bayer 12 bpp", },
75 { MEDIA_BUS_FMT_SGRBG12_1X12
, MEDIA_BUS_FMT_SGRBG10_1X10
,
76 MEDIA_BUS_FMT_SGRBG12_1X12
, MEDIA_BUS_FMT_SGRBG8_1X8
,
77 V4L2_PIX_FMT_SGRBG12
, 12, "GRBG Bayer 12 bpp", },
78 { MEDIA_BUS_FMT_SRGGB12_1X12
, MEDIA_BUS_FMT_SRGGB10_1X10
,
79 MEDIA_BUS_FMT_SRGGB12_1X12
, MEDIA_BUS_FMT_SRGGB8_1X8
,
80 V4L2_PIX_FMT_SRGGB12
, 12, "RGGB Bayer 12 bpp", },
81 { MEDIA_BUS_FMT_UYVY8_1X16
, MEDIA_BUS_FMT_UYVY8_1X16
,
82 MEDIA_BUS_FMT_UYVY8_1X16
, 0,
83 V4L2_PIX_FMT_UYVY
, 16, "YUV 4:2:2 (UYVY)", },
84 { MEDIA_BUS_FMT_YUYV8_1X16
, MEDIA_BUS_FMT_YUYV8_1X16
,
85 MEDIA_BUS_FMT_YUYV8_1X16
, 0,
86 V4L2_PIX_FMT_YUYV
, 16, "YUV 4:2:2 (YUYV)", },
87 { MEDIA_BUS_FMT_YUYV8_1_5X8
, MEDIA_BUS_FMT_YUYV8_1_5X8
,
88 MEDIA_BUS_FMT_YUYV8_1_5X8
, 0,
89 V4L2_PIX_FMT_NV12
, 8, "YUV 4:2:0 (NV12)", },
92 const struct iss_format_info
*
93 omap4iss_video_format_info(u32 code
)
97 for (i
= 0; i
< ARRAY_SIZE(formats
); ++i
) {
98 if (formats
[i
].code
== code
)
106 * iss_video_mbus_to_pix - Convert v4l2_mbus_framefmt to v4l2_pix_format
107 * @video: ISS video instance
108 * @mbus: v4l2_mbus_framefmt format (input)
109 * @pix: v4l2_pix_format format (output)
111 * Fill the output pix structure with information from the input mbus format.
112 * The bytesperline and sizeimage fields are computed from the requested bytes
113 * per line value in the pix format and information from the video instance.
115 * Return the number of padding bytes at end of line.
117 static unsigned int iss_video_mbus_to_pix(const struct iss_video
*video
,
118 const struct v4l2_mbus_framefmt
*mbus
,
119 struct v4l2_pix_format
*pix
)
121 unsigned int bpl
= pix
->bytesperline
;
122 unsigned int min_bpl
;
125 memset(pix
, 0, sizeof(*pix
));
126 pix
->width
= mbus
->width
;
127 pix
->height
= mbus
->height
;
129 /* Skip the last format in the loop so that it will be selected if no
132 for (i
= 0; i
< ARRAY_SIZE(formats
) - 1; ++i
) {
133 if (formats
[i
].code
== mbus
->code
)
137 min_bpl
= pix
->width
* ALIGN(formats
[i
].bpp
, 8) / 8;
139 /* Clamp the requested bytes per line value. If the maximum bytes per
140 * line value is zero, the module doesn't support user configurable line
141 * sizes. Override the requested value with the minimum in that case.
144 bpl
= clamp(bpl
, min_bpl
, video
->bpl_max
);
148 if (!video
->bpl_zero_padding
|| bpl
!= min_bpl
)
149 bpl
= ALIGN(bpl
, video
->bpl_alignment
);
151 pix
->pixelformat
= formats
[i
].pixelformat
;
152 pix
->bytesperline
= bpl
;
153 pix
->sizeimage
= pix
->bytesperline
* pix
->height
;
154 pix
->colorspace
= mbus
->colorspace
;
155 pix
->field
= mbus
->field
;
157 /* FIXME: Special case for NV12! We should make this nicer... */
158 if (pix
->pixelformat
== V4L2_PIX_FMT_NV12
)
159 pix
->sizeimage
+= (pix
->bytesperline
* pix
->height
) / 2;
161 return bpl
- min_bpl
;
164 static void iss_video_pix_to_mbus(const struct v4l2_pix_format
*pix
,
165 struct v4l2_mbus_framefmt
*mbus
)
169 memset(mbus
, 0, sizeof(*mbus
));
170 mbus
->width
= pix
->width
;
171 mbus
->height
= pix
->height
;
173 /* Skip the last format in the loop so that it will be selected if no
176 for (i
= 0; i
< ARRAY_SIZE(formats
) - 1; ++i
) {
177 if (formats
[i
].pixelformat
== pix
->pixelformat
)
181 mbus
->code
= formats
[i
].code
;
182 mbus
->colorspace
= pix
->colorspace
;
183 mbus
->field
= pix
->field
;
186 static struct v4l2_subdev
*
187 iss_video_remote_subdev(struct iss_video
*video
, u32
*pad
)
189 struct media_pad
*remote
;
191 remote
= media_entity_remote_pad(&video
->pad
);
193 if (!remote
|| !is_media_entity_v4l2_subdev(remote
->entity
))
197 *pad
= remote
->index
;
199 return media_entity_to_v4l2_subdev(remote
->entity
);
202 /* Return a pointer to the ISS video instance at the far end of the pipeline. */
203 static struct iss_video
*
204 iss_video_far_end(struct iss_video
*video
)
206 struct media_entity_graph graph
;
207 struct media_entity
*entity
= &video
->video
.entity
;
208 struct media_device
*mdev
= entity
->graph_obj
.mdev
;
209 struct iss_video
*far_end
= NULL
;
211 mutex_lock(&mdev
->graph_mutex
);
212 media_entity_graph_walk_start(&graph
, entity
);
214 while ((entity
= media_entity_graph_walk_next(&graph
))) {
215 if (entity
== &video
->video
.entity
)
218 if (!is_media_entity_v4l2_io(entity
))
221 far_end
= to_iss_video(media_entity_to_video_device(entity
));
222 if (far_end
->type
!= video
->type
)
228 mutex_unlock(&mdev
->graph_mutex
);
233 __iss_video_get_format(struct iss_video
*video
,
234 struct v4l2_mbus_framefmt
*format
)
236 struct v4l2_subdev_format fmt
;
237 struct v4l2_subdev
*subdev
;
241 subdev
= iss_video_remote_subdev(video
, &pad
);
245 memset(&fmt
, 0, sizeof(fmt
));
247 fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
249 mutex_lock(&video
->mutex
);
250 ret
= v4l2_subdev_call(subdev
, pad
, get_fmt
, NULL
, &fmt
);
251 mutex_unlock(&video
->mutex
);
256 *format
= fmt
.format
;
261 iss_video_check_format(struct iss_video
*video
, struct iss_video_fh
*vfh
)
263 struct v4l2_mbus_framefmt format
;
264 struct v4l2_pix_format pixfmt
;
267 ret
= __iss_video_get_format(video
, &format
);
271 pixfmt
.bytesperline
= 0;
272 ret
= iss_video_mbus_to_pix(video
, &format
, &pixfmt
);
274 if (vfh
->format
.fmt
.pix
.pixelformat
!= pixfmt
.pixelformat
||
275 vfh
->format
.fmt
.pix
.height
!= pixfmt
.height
||
276 vfh
->format
.fmt
.pix
.width
!= pixfmt
.width
||
277 vfh
->format
.fmt
.pix
.bytesperline
!= pixfmt
.bytesperline
||
278 vfh
->format
.fmt
.pix
.sizeimage
!= pixfmt
.sizeimage
)
284 /* -----------------------------------------------------------------------------
285 * Video queue operations
288 static int iss_video_queue_setup(struct vb2_queue
*vq
,
289 unsigned int *count
, unsigned int *num_planes
,
290 unsigned int sizes
[], void *alloc_ctxs
[])
292 struct iss_video_fh
*vfh
= vb2_get_drv_priv(vq
);
293 struct iss_video
*video
= vfh
->video
;
295 /* Revisit multi-planar support for NV12 */
298 sizes
[0] = vfh
->format
.fmt
.pix
.sizeimage
;
302 alloc_ctxs
[0] = video
->alloc_ctx
;
304 *count
= min(*count
, video
->capture_mem
/ PAGE_ALIGN(sizes
[0]));
309 static void iss_video_buf_cleanup(struct vb2_buffer
*vb
)
311 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
312 struct iss_buffer
*buffer
= container_of(vbuf
, struct iss_buffer
, vb
);
314 if (buffer
->iss_addr
)
315 buffer
->iss_addr
= 0;
318 static int iss_video_buf_prepare(struct vb2_buffer
*vb
)
320 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
321 struct iss_video_fh
*vfh
= vb2_get_drv_priv(vb
->vb2_queue
);
322 struct iss_buffer
*buffer
= container_of(vbuf
, struct iss_buffer
, vb
);
323 struct iss_video
*video
= vfh
->video
;
324 unsigned long size
= vfh
->format
.fmt
.pix
.sizeimage
;
327 if (vb2_plane_size(vb
, 0) < size
)
330 addr
= vb2_dma_contig_plane_dma_addr(vb
, 0);
331 if (!IS_ALIGNED(addr
, 32)) {
332 dev_dbg(video
->iss
->dev
,
333 "Buffer address must be aligned to 32 bytes boundary.\n");
337 vb2_set_plane_payload(vb
, 0, size
);
338 buffer
->iss_addr
= addr
;
342 static void iss_video_buf_queue(struct vb2_buffer
*vb
)
344 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
345 struct iss_video_fh
*vfh
= vb2_get_drv_priv(vb
->vb2_queue
);
346 struct iss_video
*video
= vfh
->video
;
347 struct iss_buffer
*buffer
= container_of(vbuf
, struct iss_buffer
, vb
);
348 struct iss_pipeline
*pipe
= to_iss_pipeline(&video
->video
.entity
);
352 spin_lock_irqsave(&video
->qlock
, flags
);
354 /* Mark the buffer is faulty and give it back to the queue immediately
355 * if the video node has registered an error. vb2 will perform the same
356 * check when preparing the buffer, but that is inherently racy, so we
357 * need to handle the race condition with an authoritative check here.
359 if (unlikely(video
->error
)) {
360 vb2_buffer_done(vb
, VB2_BUF_STATE_ERROR
);
361 spin_unlock_irqrestore(&video
->qlock
, flags
);
365 empty
= list_empty(&video
->dmaqueue
);
366 list_add_tail(&buffer
->list
, &video
->dmaqueue
);
368 spin_unlock_irqrestore(&video
->qlock
, flags
);
371 enum iss_pipeline_state state
;
374 if (video
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
375 state
= ISS_PIPELINE_QUEUE_OUTPUT
;
377 state
= ISS_PIPELINE_QUEUE_INPUT
;
379 spin_lock_irqsave(&pipe
->lock
, flags
);
380 pipe
->state
|= state
;
381 video
->ops
->queue(video
, buffer
);
382 video
->dmaqueue_flags
|= ISS_VIDEO_DMAQUEUE_QUEUED
;
384 start
= iss_pipeline_ready(pipe
);
386 pipe
->state
|= ISS_PIPELINE_STREAM
;
387 spin_unlock_irqrestore(&pipe
->lock
, flags
);
390 omap4iss_pipeline_set_stream(pipe
,
391 ISS_PIPELINE_STREAM_SINGLESHOT
);
395 static const struct vb2_ops iss_video_vb2ops
= {
396 .queue_setup
= iss_video_queue_setup
,
397 .buf_prepare
= iss_video_buf_prepare
,
398 .buf_queue
= iss_video_buf_queue
,
399 .buf_cleanup
= iss_video_buf_cleanup
,
403 * omap4iss_video_buffer_next - Complete the current buffer and return the next
404 * @video: ISS video object
406 * Remove the current video buffer from the DMA queue and fill its timestamp,
407 * field count and state fields before waking up its completion handler.
409 * For capture video nodes, the buffer state is set to VB2_BUF_STATE_DONE if no
410 * error has been flagged in the pipeline, or to VB2_BUF_STATE_ERROR otherwise.
412 * The DMA queue is expected to contain at least one buffer.
414 * Return a pointer to the next buffer in the DMA queue, or NULL if the queue is
417 struct iss_buffer
*omap4iss_video_buffer_next(struct iss_video
*video
)
419 struct iss_pipeline
*pipe
= to_iss_pipeline(&video
->video
.entity
);
420 enum iss_pipeline_state state
;
421 struct iss_buffer
*buf
;
424 spin_lock_irqsave(&video
->qlock
, flags
);
425 if (WARN_ON(list_empty(&video
->dmaqueue
))) {
426 spin_unlock_irqrestore(&video
->qlock
, flags
);
430 buf
= list_first_entry(&video
->dmaqueue
, struct iss_buffer
,
432 list_del(&buf
->list
);
433 spin_unlock_irqrestore(&video
->qlock
, flags
);
435 buf
->vb
.vb2_buf
.timestamp
= ktime_get_ns();
437 /* Do frame number propagation only if this is the output video node.
438 * Frame number either comes from the CSI receivers or it gets
439 * incremented here if H3A is not active.
440 * Note: There is no guarantee that the output buffer will finish
441 * first, so the input number might lag behind by 1 in some cases.
443 if (video
== pipe
->output
&& !pipe
->do_propagation
)
445 atomic_inc_return(&pipe
->frame_number
);
447 buf
->vb
.sequence
= atomic_read(&pipe
->frame_number
);
449 vb2_buffer_done(&buf
->vb
.vb2_buf
, pipe
->error
?
450 VB2_BUF_STATE_ERROR
: VB2_BUF_STATE_DONE
);
453 spin_lock_irqsave(&video
->qlock
, flags
);
454 if (list_empty(&video
->dmaqueue
)) {
455 spin_unlock_irqrestore(&video
->qlock
, flags
);
456 if (video
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
457 state
= ISS_PIPELINE_QUEUE_OUTPUT
458 | ISS_PIPELINE_STREAM
;
460 state
= ISS_PIPELINE_QUEUE_INPUT
461 | ISS_PIPELINE_STREAM
;
463 spin_lock_irqsave(&pipe
->lock
, flags
);
464 pipe
->state
&= ~state
;
465 if (video
->pipe
.stream_state
== ISS_PIPELINE_STREAM_CONTINUOUS
)
466 video
->dmaqueue_flags
|= ISS_VIDEO_DMAQUEUE_UNDERRUN
;
467 spin_unlock_irqrestore(&pipe
->lock
, flags
);
471 if (video
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
&& pipe
->input
) {
472 spin_lock(&pipe
->lock
);
473 pipe
->state
&= ~ISS_PIPELINE_STREAM
;
474 spin_unlock(&pipe
->lock
);
477 buf
= list_first_entry(&video
->dmaqueue
, struct iss_buffer
,
479 spin_unlock_irqrestore(&video
->qlock
, flags
);
480 buf
->vb
.vb2_buf
.state
= VB2_BUF_STATE_ACTIVE
;
485 * omap4iss_video_cancel_stream - Cancel stream on a video node
486 * @video: ISS video object
488 * Cancelling a stream mark all buffers on the video node as erroneous and makes
489 * sure no new buffer can be queued.
491 void omap4iss_video_cancel_stream(struct iss_video
*video
)
495 spin_lock_irqsave(&video
->qlock
, flags
);
497 while (!list_empty(&video
->dmaqueue
)) {
498 struct iss_buffer
*buf
;
500 buf
= list_first_entry(&video
->dmaqueue
, struct iss_buffer
,
502 list_del(&buf
->list
);
503 vb2_buffer_done(&buf
->vb
.vb2_buf
, VB2_BUF_STATE_ERROR
);
506 vb2_queue_error(video
->queue
);
509 spin_unlock_irqrestore(&video
->qlock
, flags
);
512 /* -----------------------------------------------------------------------------
517 iss_video_querycap(struct file
*file
, void *fh
, struct v4l2_capability
*cap
)
519 struct iss_video
*video
= video_drvdata(file
);
521 strlcpy(cap
->driver
, ISS_VIDEO_DRIVER_NAME
, sizeof(cap
->driver
));
522 strlcpy(cap
->card
, video
->video
.name
, sizeof(cap
->card
));
523 strlcpy(cap
->bus_info
, "media", sizeof(cap
->bus_info
));
525 if (video
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
526 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_STREAMING
;
528 cap
->device_caps
= V4L2_CAP_VIDEO_OUTPUT
| V4L2_CAP_STREAMING
;
530 cap
->capabilities
= V4L2_CAP_DEVICE_CAPS
| V4L2_CAP_STREAMING
531 | V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_VIDEO_OUTPUT
;
537 iss_video_enum_format(struct file
*file
, void *fh
, struct v4l2_fmtdesc
*f
)
539 struct iss_video
*video
= video_drvdata(file
);
540 struct v4l2_mbus_framefmt format
;
541 unsigned int index
= f
->index
;
545 if (f
->type
!= video
->type
)
548 ret
= __iss_video_get_format(video
, &format
);
552 for (i
= 0; i
< ARRAY_SIZE(formats
); ++i
) {
553 const struct iss_format_info
*info
= &formats
[i
];
555 if (format
.code
!= info
->code
)
559 f
->pixelformat
= info
->pixelformat
;
560 strlcpy(f
->description
, info
->description
,
561 sizeof(f
->description
));
572 iss_video_get_format(struct file
*file
, void *fh
, struct v4l2_format
*format
)
574 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
575 struct iss_video
*video
= video_drvdata(file
);
577 if (format
->type
!= video
->type
)
580 mutex_lock(&video
->mutex
);
581 *format
= vfh
->format
;
582 mutex_unlock(&video
->mutex
);
588 iss_video_set_format(struct file
*file
, void *fh
, struct v4l2_format
*format
)
590 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
591 struct iss_video
*video
= video_drvdata(file
);
592 struct v4l2_mbus_framefmt fmt
;
594 if (format
->type
!= video
->type
)
597 mutex_lock(&video
->mutex
);
599 /* Fill the bytesperline and sizeimage fields by converting to media bus
600 * format and back to pixel format.
602 iss_video_pix_to_mbus(&format
->fmt
.pix
, &fmt
);
603 iss_video_mbus_to_pix(video
, &fmt
, &format
->fmt
.pix
);
605 vfh
->format
= *format
;
607 mutex_unlock(&video
->mutex
);
612 iss_video_try_format(struct file
*file
, void *fh
, struct v4l2_format
*format
)
614 struct iss_video
*video
= video_drvdata(file
);
615 struct v4l2_subdev_format fmt
;
616 struct v4l2_subdev
*subdev
;
620 if (format
->type
!= video
->type
)
623 subdev
= iss_video_remote_subdev(video
, &pad
);
627 iss_video_pix_to_mbus(&format
->fmt
.pix
, &fmt
.format
);
630 fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
631 ret
= v4l2_subdev_call(subdev
, pad
, get_fmt
, NULL
, &fmt
);
635 iss_video_mbus_to_pix(video
, &fmt
.format
, &format
->fmt
.pix
);
640 iss_video_get_param(struct file
*file
, void *fh
, struct v4l2_streamparm
*a
)
642 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
643 struct iss_video
*video
= video_drvdata(file
);
645 if (video
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
||
646 video
->type
!= a
->type
)
649 memset(a
, 0, sizeof(*a
));
650 a
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
651 a
->parm
.output
.capability
= V4L2_CAP_TIMEPERFRAME
;
652 a
->parm
.output
.timeperframe
= vfh
->timeperframe
;
658 iss_video_set_param(struct file
*file
, void *fh
, struct v4l2_streamparm
*a
)
660 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
661 struct iss_video
*video
= video_drvdata(file
);
663 if (video
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
||
664 video
->type
!= a
->type
)
667 if (a
->parm
.output
.timeperframe
.denominator
== 0)
668 a
->parm
.output
.timeperframe
.denominator
= 1;
670 vfh
->timeperframe
= a
->parm
.output
.timeperframe
;
676 iss_video_reqbufs(struct file
*file
, void *fh
, struct v4l2_requestbuffers
*rb
)
678 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
680 return vb2_reqbufs(&vfh
->queue
, rb
);
684 iss_video_querybuf(struct file
*file
, void *fh
, struct v4l2_buffer
*b
)
686 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
688 return vb2_querybuf(&vfh
->queue
, b
);
692 iss_video_qbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*b
)
694 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
696 return vb2_qbuf(&vfh
->queue
, b
);
700 iss_video_expbuf(struct file
*file
, void *fh
, struct v4l2_exportbuffer
*e
)
702 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
704 return vb2_expbuf(&vfh
->queue
, e
);
708 iss_video_dqbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*b
)
710 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
712 return vb2_dqbuf(&vfh
->queue
, b
, file
->f_flags
& O_NONBLOCK
);
718 * Every ISS pipeline has a single input and a single output. The input can be
719 * either a sensor or a video node. The output is always a video node.
721 * As every pipeline has an output video node, the ISS video objects at the
722 * pipeline output stores the pipeline state. It tracks the streaming state of
723 * both the input and output, as well as the availability of buffers.
725 * In sensor-to-memory mode, frames are always available at the pipeline input.
726 * Starting the sensor usually requires I2C transfers and must be done in
727 * interruptible context. The pipeline is started and stopped synchronously
728 * to the stream on/off commands. All modules in the pipeline will get their
729 * subdev set stream handler called. The module at the end of the pipeline must
730 * delay starting the hardware until buffers are available at its output.
732 * In memory-to-memory mode, starting/stopping the stream requires
733 * synchronization between the input and output. ISS modules can't be stopped
734 * in the middle of a frame, and at least some of the modules seem to become
735 * busy as soon as they're started, even if they don't receive a frame start
736 * event. For that reason frames need to be processed in single-shot mode. The
737 * driver needs to wait until a frame is completely processed and written to
738 * memory before restarting the pipeline for the next frame. Pipelined
739 * processing might be possible but requires more testing.
741 * Stream start must be delayed until buffers are available at both the input
742 * and output. The pipeline must be started in the videobuf queue callback with
743 * the buffers queue spinlock held. The modules subdev set stream operation must
747 iss_video_streamon(struct file
*file
, void *fh
, enum v4l2_buf_type type
)
749 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
750 struct iss_video
*video
= video_drvdata(file
);
751 struct media_entity_graph graph
;
752 struct media_entity
*entity
;
753 enum iss_pipeline_state state
;
754 struct iss_pipeline
*pipe
;
755 struct iss_video
*far_end
;
759 if (type
!= video
->type
)
762 mutex_lock(&video
->stream_lock
);
764 /* Start streaming on the pipeline. No link touching an entity in the
765 * pipeline can be activated or deactivated once streaming is started.
767 pipe
= video
->video
.entity
.pipe
768 ? to_iss_pipeline(&video
->video
.entity
) : &video
->pipe
;
769 pipe
->external
= NULL
;
770 pipe
->external_rate
= 0;
771 pipe
->external_bpp
= 0;
774 if (video
->iss
->pdata
->set_constraints
)
775 video
->iss
->pdata
->set_constraints(video
->iss
, true);
777 ret
= media_entity_pipeline_start(&video
->video
.entity
, &pipe
->pipe
);
779 goto err_media_entity_pipeline_start
;
781 entity
= &video
->video
.entity
;
782 media_entity_graph_walk_start(&graph
, entity
);
783 while ((entity
= media_entity_graph_walk_next(&graph
)))
784 pipe
->entities
|= 1 << media_entity_id(entity
);
786 /* Verify that the currently configured format matches the output of
787 * the connected subdev.
789 ret
= iss_video_check_format(video
, vfh
);
791 goto err_iss_video_check_format
;
793 video
->bpl_padding
= ret
;
794 video
->bpl_value
= vfh
->format
.fmt
.pix
.bytesperline
;
796 /* Find the ISS video node connected at the far end of the pipeline and
797 * update the pipeline.
799 far_end
= iss_video_far_end(video
);
801 if (video
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
802 state
= ISS_PIPELINE_STREAM_OUTPUT
| ISS_PIPELINE_IDLE_OUTPUT
;
803 pipe
->input
= far_end
;
804 pipe
->output
= video
;
808 goto err_iss_video_check_format
;
811 state
= ISS_PIPELINE_STREAM_INPUT
| ISS_PIPELINE_IDLE_INPUT
;
813 pipe
->output
= far_end
;
816 spin_lock_irqsave(&pipe
->lock
, flags
);
817 pipe
->state
&= ~ISS_PIPELINE_STREAM
;
818 pipe
->state
|= state
;
819 spin_unlock_irqrestore(&pipe
->lock
, flags
);
821 /* Set the maximum time per frame as the value requested by userspace.
822 * This is a soft limit that can be overridden if the hardware doesn't
823 * support the request limit.
825 if (video
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
826 pipe
->max_timeperframe
= vfh
->timeperframe
;
828 video
->queue
= &vfh
->queue
;
829 INIT_LIST_HEAD(&video
->dmaqueue
);
830 video
->error
= false;
831 atomic_set(&pipe
->frame_number
, -1);
833 ret
= vb2_streamon(&vfh
->queue
, type
);
835 goto err_iss_video_check_format
;
837 /* In sensor-to-memory mode, the stream can be started synchronously
838 * to the stream on command. In memory-to-memory mode, it will be
839 * started when buffers are queued on both the input and output.
844 ret
= omap4iss_pipeline_set_stream(pipe
,
845 ISS_PIPELINE_STREAM_CONTINUOUS
);
847 goto err_omap4iss_set_stream
;
848 spin_lock_irqsave(&video
->qlock
, flags
);
849 if (list_empty(&video
->dmaqueue
))
850 video
->dmaqueue_flags
|= ISS_VIDEO_DMAQUEUE_UNDERRUN
;
851 spin_unlock_irqrestore(&video
->qlock
, flags
);
854 mutex_unlock(&video
->stream_lock
);
857 err_omap4iss_set_stream
:
858 vb2_streamoff(&vfh
->queue
, type
);
859 err_iss_video_check_format
:
860 media_entity_pipeline_stop(&video
->video
.entity
);
861 err_media_entity_pipeline_start
:
862 if (video
->iss
->pdata
->set_constraints
)
863 video
->iss
->pdata
->set_constraints(video
->iss
, false);
866 mutex_unlock(&video
->stream_lock
);
871 iss_video_streamoff(struct file
*file
, void *fh
, enum v4l2_buf_type type
)
873 struct iss_video_fh
*vfh
= to_iss_video_fh(fh
);
874 struct iss_video
*video
= video_drvdata(file
);
875 struct iss_pipeline
*pipe
= to_iss_pipeline(&video
->video
.entity
);
876 enum iss_pipeline_state state
;
879 if (type
!= video
->type
)
882 mutex_lock(&video
->stream_lock
);
884 if (!vb2_is_streaming(&vfh
->queue
))
887 /* Update the pipeline state. */
888 if (video
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
889 state
= ISS_PIPELINE_STREAM_OUTPUT
890 | ISS_PIPELINE_QUEUE_OUTPUT
;
892 state
= ISS_PIPELINE_STREAM_INPUT
893 | ISS_PIPELINE_QUEUE_INPUT
;
895 spin_lock_irqsave(&pipe
->lock
, flags
);
896 pipe
->state
&= ~state
;
897 spin_unlock_irqrestore(&pipe
->lock
, flags
);
899 /* Stop the stream. */
900 omap4iss_pipeline_set_stream(pipe
, ISS_PIPELINE_STREAM_STOPPED
);
901 vb2_streamoff(&vfh
->queue
, type
);
904 if (video
->iss
->pdata
->set_constraints
)
905 video
->iss
->pdata
->set_constraints(video
->iss
, false);
906 media_entity_pipeline_stop(&video
->video
.entity
);
909 mutex_unlock(&video
->stream_lock
);
914 iss_video_enum_input(struct file
*file
, void *fh
, struct v4l2_input
*input
)
916 if (input
->index
> 0)
919 strlcpy(input
->name
, "camera", sizeof(input
->name
));
920 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
926 iss_video_g_input(struct file
*file
, void *fh
, unsigned int *input
)
934 iss_video_s_input(struct file
*file
, void *fh
, unsigned int input
)
936 return input
== 0 ? 0 : -EINVAL
;
939 static const struct v4l2_ioctl_ops iss_video_ioctl_ops
= {
940 .vidioc_querycap
= iss_video_querycap
,
941 .vidioc_enum_fmt_vid_cap
= iss_video_enum_format
,
942 .vidioc_g_fmt_vid_cap
= iss_video_get_format
,
943 .vidioc_s_fmt_vid_cap
= iss_video_set_format
,
944 .vidioc_try_fmt_vid_cap
= iss_video_try_format
,
945 .vidioc_g_fmt_vid_out
= iss_video_get_format
,
946 .vidioc_s_fmt_vid_out
= iss_video_set_format
,
947 .vidioc_try_fmt_vid_out
= iss_video_try_format
,
948 .vidioc_g_parm
= iss_video_get_param
,
949 .vidioc_s_parm
= iss_video_set_param
,
950 .vidioc_reqbufs
= iss_video_reqbufs
,
951 .vidioc_querybuf
= iss_video_querybuf
,
952 .vidioc_qbuf
= iss_video_qbuf
,
953 .vidioc_expbuf
= iss_video_expbuf
,
954 .vidioc_dqbuf
= iss_video_dqbuf
,
955 .vidioc_streamon
= iss_video_streamon
,
956 .vidioc_streamoff
= iss_video_streamoff
,
957 .vidioc_enum_input
= iss_video_enum_input
,
958 .vidioc_g_input
= iss_video_g_input
,
959 .vidioc_s_input
= iss_video_s_input
,
962 /* -----------------------------------------------------------------------------
963 * V4L2 file operations
966 static int iss_video_open(struct file
*file
)
968 struct iss_video
*video
= video_drvdata(file
);
969 struct iss_video_fh
*handle
;
973 handle
= kzalloc(sizeof(*handle
), GFP_KERNEL
);
977 v4l2_fh_init(&handle
->vfh
, &video
->video
);
978 v4l2_fh_add(&handle
->vfh
);
980 /* If this is the first user, initialise the pipeline. */
981 if (!omap4iss_get(video
->iss
)) {
986 ret
= omap4iss_pipeline_pm_use(&video
->video
.entity
, 1);
988 omap4iss_put(video
->iss
);
992 video
->alloc_ctx
= vb2_dma_contig_init_ctx(video
->iss
->dev
);
993 if (IS_ERR(video
->alloc_ctx
)) {
994 ret
= PTR_ERR(video
->alloc_ctx
);
995 omap4iss_put(video
->iss
);
1001 q
->type
= video
->type
;
1002 q
->io_modes
= VB2_MMAP
| VB2_DMABUF
;
1003 q
->drv_priv
= handle
;
1004 q
->ops
= &iss_video_vb2ops
;
1005 q
->mem_ops
= &vb2_dma_contig_memops
;
1006 q
->buf_struct_size
= sizeof(struct iss_buffer
);
1007 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1009 ret
= vb2_queue_init(q
);
1011 omap4iss_put(video
->iss
);
1015 memset(&handle
->format
, 0, sizeof(handle
->format
));
1016 handle
->format
.type
= video
->type
;
1017 handle
->timeperframe
.denominator
= 1;
1019 handle
->video
= video
;
1020 file
->private_data
= &handle
->vfh
;
1024 v4l2_fh_del(&handle
->vfh
);
1031 static int iss_video_release(struct file
*file
)
1033 struct iss_video
*video
= video_drvdata(file
);
1034 struct v4l2_fh
*vfh
= file
->private_data
;
1035 struct iss_video_fh
*handle
= to_iss_video_fh(vfh
);
1037 /* Disable streaming and free the buffers queue resources. */
1038 iss_video_streamoff(file
, vfh
, video
->type
);
1040 omap4iss_pipeline_pm_use(&video
->video
.entity
, 0);
1042 /* Release the videobuf2 queue */
1043 vb2_queue_release(&handle
->queue
);
1045 /* Release the file handle. */
1048 file
->private_data
= NULL
;
1050 omap4iss_put(video
->iss
);
1055 static unsigned int iss_video_poll(struct file
*file
, poll_table
*wait
)
1057 struct iss_video_fh
*vfh
= to_iss_video_fh(file
->private_data
);
1059 return vb2_poll(&vfh
->queue
, file
, wait
);
1062 static int iss_video_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1064 struct iss_video_fh
*vfh
= to_iss_video_fh(file
->private_data
);
1066 return vb2_mmap(&vfh
->queue
, vma
);
1069 static struct v4l2_file_operations iss_video_fops
= {
1070 .owner
= THIS_MODULE
,
1071 .unlocked_ioctl
= video_ioctl2
,
1072 .open
= iss_video_open
,
1073 .release
= iss_video_release
,
1074 .poll
= iss_video_poll
,
1075 .mmap
= iss_video_mmap
,
1078 /* -----------------------------------------------------------------------------
1082 static const struct iss_video_operations iss_video_dummy_ops
= {
1085 int omap4iss_video_init(struct iss_video
*video
, const char *name
)
1087 const char *direction
;
1090 switch (video
->type
) {
1091 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1092 direction
= "output";
1093 video
->pad
.flags
= MEDIA_PAD_FL_SINK
;
1095 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
1096 direction
= "input";
1097 video
->pad
.flags
= MEDIA_PAD_FL_SOURCE
;
1104 ret
= media_entity_init(&video
->video
.entity
, 1, &video
->pad
);
1108 spin_lock_init(&video
->qlock
);
1109 mutex_init(&video
->mutex
);
1110 atomic_set(&video
->active
, 0);
1112 spin_lock_init(&video
->pipe
.lock
);
1113 mutex_init(&video
->stream_lock
);
1115 /* Initialize the video device. */
1117 video
->ops
= &iss_video_dummy_ops
;
1119 video
->video
.fops
= &iss_video_fops
;
1120 snprintf(video
->video
.name
, sizeof(video
->video
.name
),
1121 "OMAP4 ISS %s %s", name
, direction
);
1122 video
->video
.vfl_type
= VFL_TYPE_GRABBER
;
1123 video
->video
.release
= video_device_release_empty
;
1124 video
->video
.ioctl_ops
= &iss_video_ioctl_ops
;
1125 video
->pipe
.stream_state
= ISS_PIPELINE_STREAM_STOPPED
;
1127 video_set_drvdata(&video
->video
, video
);
1132 void omap4iss_video_cleanup(struct iss_video
*video
)
1134 media_entity_cleanup(&video
->video
.entity
);
1135 mutex_destroy(&video
->stream_lock
);
1136 mutex_destroy(&video
->mutex
);
1139 int omap4iss_video_register(struct iss_video
*video
, struct v4l2_device
*vdev
)
1143 video
->video
.v4l2_dev
= vdev
;
1145 ret
= video_register_device(&video
->video
, VFL_TYPE_GRABBER
, -1);
1147 dev_err(video
->iss
->dev
,
1148 "could not register video device (%d)\n", ret
);
1153 void omap4iss_video_unregister(struct iss_video
*video
)
1155 video_unregister_device(&video
->video
);