omap4iss: clear error when pipeline propagation is done
[omap4-v4l2-camera:omap4-v4l2-camera.git] / drivers / media / video / omap4iss / iss_video.c
1 /*
2  * TI OMAP4 ISS V4L2 Driver - Generic video node
3  *
4  * Copyright (C) 2012 Texas Instruments, Inc.
5  *
6  * Author: Sergio Aguirre <saaguirre@ti.com>
7  *
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.
12  */
13
14 #include <asm/cacheflush.h>
15 #include <linux/clk.h>
16 #include <linux/mm.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>
24 #include <plat/omap-pm.h>
25
26 #include "iss_video.h"
27 #include "iss.h"
28
29
30 /* -----------------------------------------------------------------------------
31  * Helper functions
32  */
33
34 static struct iss_format_info formats[] = {
35         { V4L2_MBUS_FMT_Y8_1X8, V4L2_MBUS_FMT_Y8_1X8,
36           V4L2_MBUS_FMT_Y8_1X8, V4L2_MBUS_FMT_Y8_1X8,
37           V4L2_PIX_FMT_GREY, 8, },
38         { V4L2_MBUS_FMT_Y10_1X10, V4L2_MBUS_FMT_Y10_1X10,
39           V4L2_MBUS_FMT_Y10_1X10, V4L2_MBUS_FMT_Y8_1X8,
40           V4L2_PIX_FMT_Y10, 10, },
41         { V4L2_MBUS_FMT_Y12_1X12, V4L2_MBUS_FMT_Y10_1X10,
42           V4L2_MBUS_FMT_Y12_1X12, V4L2_MBUS_FMT_Y8_1X8,
43           V4L2_PIX_FMT_Y12, 12, },
44         { V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_MBUS_FMT_SBGGR8_1X8,
45           V4L2_MBUS_FMT_SBGGR8_1X8, V4L2_MBUS_FMT_SBGGR8_1X8,
46           V4L2_PIX_FMT_SBGGR8, 8, },
47         { V4L2_MBUS_FMT_SGBRG8_1X8, V4L2_MBUS_FMT_SGBRG8_1X8,
48           V4L2_MBUS_FMT_SGBRG8_1X8, V4L2_MBUS_FMT_SGBRG8_1X8,
49           V4L2_PIX_FMT_SGBRG8, 8, },
50         { V4L2_MBUS_FMT_SGRBG8_1X8, V4L2_MBUS_FMT_SGRBG8_1X8,
51           V4L2_MBUS_FMT_SGRBG8_1X8, V4L2_MBUS_FMT_SGRBG8_1X8,
52           V4L2_PIX_FMT_SGRBG8, 8, },
53         { V4L2_MBUS_FMT_SRGGB8_1X8, V4L2_MBUS_FMT_SRGGB8_1X8,
54           V4L2_MBUS_FMT_SRGGB8_1X8, V4L2_MBUS_FMT_SRGGB8_1X8,
55           V4L2_PIX_FMT_SRGGB8, 8, },
56         { V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8, V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8,
57           V4L2_MBUS_FMT_SGRBG10_1X10, 0,
58           V4L2_PIX_FMT_SGRBG10DPCM8, 8, },
59         { V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_MBUS_FMT_SBGGR10_1X10,
60           V4L2_MBUS_FMT_SBGGR10_1X10, V4L2_MBUS_FMT_SBGGR8_1X8,
61           V4L2_PIX_FMT_SBGGR10, 10, },
62         { V4L2_MBUS_FMT_SGBRG10_1X10, V4L2_MBUS_FMT_SGBRG10_1X10,
63           V4L2_MBUS_FMT_SGBRG10_1X10, V4L2_MBUS_FMT_SGBRG8_1X8,
64           V4L2_PIX_FMT_SGBRG10, 10, },
65         { V4L2_MBUS_FMT_SGRBG10_1X10, V4L2_MBUS_FMT_SGRBG10_1X10,
66           V4L2_MBUS_FMT_SGRBG10_1X10, V4L2_MBUS_FMT_SGRBG8_1X8,
67           V4L2_PIX_FMT_SGRBG10, 10, },
68         { V4L2_MBUS_FMT_SRGGB10_1X10, V4L2_MBUS_FMT_SRGGB10_1X10,
69           V4L2_MBUS_FMT_SRGGB10_1X10, V4L2_MBUS_FMT_SRGGB8_1X8,
70           V4L2_PIX_FMT_SRGGB10, 10, },
71         { V4L2_MBUS_FMT_SBGGR12_1X12, V4L2_MBUS_FMT_SBGGR10_1X10,
72           V4L2_MBUS_FMT_SBGGR12_1X12, V4L2_MBUS_FMT_SBGGR8_1X8,
73           V4L2_PIX_FMT_SBGGR12, 12, },
74         { V4L2_MBUS_FMT_SGBRG12_1X12, V4L2_MBUS_FMT_SGBRG10_1X10,
75           V4L2_MBUS_FMT_SGBRG12_1X12, V4L2_MBUS_FMT_SGBRG8_1X8,
76           V4L2_PIX_FMT_SGBRG12, 12, },
77         { V4L2_MBUS_FMT_SGRBG12_1X12, V4L2_MBUS_FMT_SGRBG10_1X10,
78           V4L2_MBUS_FMT_SGRBG12_1X12, V4L2_MBUS_FMT_SGRBG8_1X8,
79           V4L2_PIX_FMT_SGRBG12, 12, },
80         { V4L2_MBUS_FMT_SRGGB12_1X12, V4L2_MBUS_FMT_SRGGB10_1X10,
81           V4L2_MBUS_FMT_SRGGB12_1X12, V4L2_MBUS_FMT_SRGGB8_1X8,
82           V4L2_PIX_FMT_SRGGB12, 12, },
83         { V4L2_MBUS_FMT_UYVY8_1X16, V4L2_MBUS_FMT_UYVY8_1X16,
84           V4L2_MBUS_FMT_UYVY8_1X16, 0,
85           V4L2_PIX_FMT_UYVY, 16, },
86         { V4L2_MBUS_FMT_YUYV8_1X16, V4L2_MBUS_FMT_YUYV8_1X16,
87           V4L2_MBUS_FMT_YUYV8_1X16, 0,
88           V4L2_PIX_FMT_YUYV, 16, },
89 };
90
91 const struct iss_format_info *
92 omap4iss_video_format_info(enum v4l2_mbus_pixelcode code)
93 {
94         unsigned int i;
95
96         for (i = 0; i < ARRAY_SIZE(formats); ++i) {
97                 if (formats[i].code == code)
98                         return &formats[i];
99         }
100
101         return NULL;
102 }
103
104 /*
105  * iss_video_mbus_to_pix - Convert v4l2_mbus_framefmt to v4l2_pix_format
106  * @video: ISS video instance
107  * @mbus: v4l2_mbus_framefmt format (input)
108  * @pix: v4l2_pix_format format (output)
109  *
110  * Fill the output pix structure with information from the input mbus format.
111  * The bytesperline and sizeimage fields are computed from the requested bytes
112  * per line value in the pix format and information from the video instance.
113  *
114  * Return the number of padding bytes at end of line.
115  */
116 static unsigned int iss_video_mbus_to_pix(const struct iss_video *video,
117                                           const struct v4l2_mbus_framefmt *mbus,
118                                           struct v4l2_pix_format *pix)
119 {
120         unsigned int bpl = pix->bytesperline;
121         unsigned int min_bpl;
122         unsigned int i;
123
124         memset(pix, 0, sizeof(*pix));
125         pix->width = mbus->width;
126         pix->height = mbus->height;
127
128         /* Skip the last format in the loop so that it will be selected if no
129          * match is found.
130          */
131         for (i = 0; i < ARRAY_SIZE(formats) - 1; ++i) {
132                 if (formats[i].code == mbus->code)
133                         break;
134         }
135
136         min_bpl = pix->width * ALIGN(formats[i].bpp, 8) / 8;
137
138         /* Clamp the requested bytes per line value. If the maximum bytes per
139          * line value is zero, the module doesn't support user configurable line
140          * sizes. Override the requested value with the minimum in that case.
141          */
142         if (video->bpl_max)
143                 bpl = clamp(bpl, min_bpl, video->bpl_max);
144         else
145                 bpl = min_bpl;
146
147         if (!video->bpl_zero_padding || bpl != min_bpl)
148                 bpl = ALIGN(bpl, video->bpl_alignment);
149
150         pix->pixelformat = formats[i].pixelformat;
151         pix->bytesperline = bpl;
152         pix->sizeimage = pix->bytesperline * pix->height;
153         pix->colorspace = mbus->colorspace;
154         pix->field = mbus->field;
155
156         return bpl - min_bpl;
157 }
158
159 static void iss_video_pix_to_mbus(const struct v4l2_pix_format *pix,
160                                   struct v4l2_mbus_framefmt *mbus)
161 {
162         unsigned int i;
163
164         memset(mbus, 0, sizeof(*mbus));
165         mbus->width = pix->width;
166         mbus->height = pix->height;
167
168         for (i = 0; i < ARRAY_SIZE(formats); ++i) {
169                 if (formats[i].pixelformat == pix->pixelformat)
170                         break;
171         }
172
173         if (WARN_ON(i == ARRAY_SIZE(formats)))
174                 return;
175
176         mbus->code = formats[i].code;
177         mbus->colorspace = pix->colorspace;
178         mbus->field = pix->field;
179 }
180
181 static struct v4l2_subdev *
182 iss_video_remote_subdev(struct iss_video *video, u32 *pad)
183 {
184         struct media_pad *remote;
185
186         remote = media_entity_remote_source(&video->pad);
187
188         if (remote == NULL ||
189             media_entity_type(remote->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
190                 return NULL;
191
192         if (pad)
193                 *pad = remote->index;
194
195         return media_entity_to_v4l2_subdev(remote->entity);
196 }
197
198 /* Return a pointer to the ISS video instance at the far end of the pipeline. */
199 static struct iss_video *
200 iss_video_far_end(struct iss_video *video)
201 {
202         struct media_entity_graph graph;
203         struct media_entity *entity = &video->video.entity;
204         struct media_device *mdev = entity->parent;
205         struct iss_video *far_end = NULL;
206
207         mutex_lock(&mdev->graph_mutex);
208         media_entity_graph_walk_start(&graph, entity);
209
210         while ((entity = media_entity_graph_walk_next(&graph))) {
211                 if (entity == &video->video.entity)
212                         continue;
213
214                 if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE)
215                         continue;
216
217                 far_end = to_iss_video(media_entity_to_video_device(entity));
218                 if (far_end->type != video->type)
219                         break;
220
221                 far_end = NULL;
222         }
223
224         mutex_unlock(&mdev->graph_mutex);
225         return far_end;
226 }
227
228 static int
229 __iss_video_get_format(struct iss_video *video, struct v4l2_format *format)
230 {
231         struct v4l2_subdev_format fmt;
232         struct v4l2_subdev *subdev;
233         u32 pad;
234         int ret;
235
236         subdev = iss_video_remote_subdev(video, &pad);
237         if (subdev == NULL)
238                 return -EINVAL;
239
240         mutex_lock(&video->mutex);
241
242         fmt.pad = pad;
243         fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
244         ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt);
245         if (ret == -ENOIOCTLCMD)
246                 ret = -EINVAL;
247
248         mutex_unlock(&video->mutex);
249
250         if (ret)
251                 return ret;
252
253         format->type = video->type;
254         return iss_video_mbus_to_pix(video, &fmt.format, &format->fmt.pix);
255 }
256
257 static int
258 iss_video_check_format(struct iss_video *video, struct iss_video_fh *vfh)
259 {
260         struct v4l2_format format;
261         int ret;
262
263         memcpy(&format, &vfh->format, sizeof(format));
264         ret = __iss_video_get_format(video, &format);
265         if (ret < 0)
266                 return ret;
267
268         if (vfh->format.fmt.pix.pixelformat != format.fmt.pix.pixelformat ||
269             vfh->format.fmt.pix.height != format.fmt.pix.height ||
270             vfh->format.fmt.pix.width != format.fmt.pix.width ||
271             vfh->format.fmt.pix.bytesperline != format.fmt.pix.bytesperline ||
272             vfh->format.fmt.pix.sizeimage != format.fmt.pix.sizeimage)
273                 return -EINVAL;
274
275         return ret;
276 }
277
278 /* -----------------------------------------------------------------------------
279  * Video queue operations
280  */
281
282 static int iss_video_queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
283                                  unsigned int *count, unsigned int *num_planes,
284                                  unsigned int sizes[], void *alloc_ctxs[])
285 {
286         struct iss_video_fh *vfh = vb2_get_drv_priv(vq);
287         struct iss_video *video = vfh->video;
288
289         /* Revisit multi-planar support for NV12 */
290         *num_planes = 1;
291
292         sizes[0] = vfh->format.fmt.pix.sizeimage;
293         if (sizes[0] == 0)
294                 return -EINVAL;
295
296         alloc_ctxs[0] = video->alloc_ctx;
297
298         *count = min(*count, (unsigned int)(video->capture_mem / PAGE_ALIGN(sizes[0])));
299
300         return 0;
301 }
302
303 static void iss_video_buf_cleanup(struct vb2_buffer *vb)
304 {
305         struct iss_buffer *buffer = container_of(vb, struct iss_buffer, vb);
306
307         if (buffer->iss_addr)
308                 buffer->iss_addr = 0;
309 }
310
311 static int iss_video_buf_prepare(struct vb2_buffer *vb)
312 {
313         struct iss_video_fh *vfh = vb2_get_drv_priv(vb->vb2_queue);
314         struct iss_buffer *buffer = container_of(vb, struct iss_buffer, vb);
315         struct iss_video *video = vfh->video;
316         unsigned long size = vfh->format.fmt.pix.sizeimage;
317         dma_addr_t addr;
318
319         if (vb2_plane_size(vb, 0) < size)
320                 return -ENOBUFS;
321
322         addr = vb2_dma_contig_plane_dma_addr(vb, 0);
323         if (!IS_ALIGNED(addr, 32)) {
324                 dev_dbg(video->iss->dev, "Buffer address must be "
325                         "aligned to 32 bytes boundary.\n");
326                 return -EINVAL;
327         }
328
329         vb2_set_plane_payload(vb, 0, size);
330         buffer->iss_addr = addr;
331         return 0;
332 }
333
334 static void iss_video_buf_queue(struct vb2_buffer *vb)
335 {
336         struct iss_video_fh *vfh = vb2_get_drv_priv(vb->vb2_queue);
337         struct iss_video *video = vfh->video;
338         struct iss_buffer *buffer = container_of(vb, struct iss_buffer, vb);
339         struct iss_pipeline *pipe = to_iss_pipeline(&video->video.entity);
340         unsigned int empty;
341         unsigned long flags;
342
343         spin_lock_irqsave(&video->qlock, flags);
344         empty = list_empty(&video->dmaqueue);
345         list_add_tail(&buffer->list, &video->dmaqueue);
346         spin_unlock_irqrestore(&video->qlock, flags);
347
348         if (empty) {
349                 enum iss_pipeline_state state;
350                 unsigned int start;
351
352                 if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
353                         state = ISS_PIPELINE_QUEUE_OUTPUT;
354                 else
355                         state = ISS_PIPELINE_QUEUE_INPUT;
356
357                 spin_lock_irqsave(&pipe->lock, flags);
358                 pipe->state |= state;
359                 video->ops->queue(video, buffer);
360                 video->dmaqueue_flags |= ISS_VIDEO_DMAQUEUE_QUEUED;
361
362                 start = iss_pipeline_ready(pipe);
363                 if (start)
364                         pipe->state |= ISS_PIPELINE_STREAM;
365                 spin_unlock_irqrestore(&pipe->lock, flags);
366
367                 if (start)
368                         omap4iss_pipeline_set_stream(pipe,
369                                                 ISS_PIPELINE_STREAM_SINGLESHOT);
370         }
371 }
372
373 static struct vb2_ops iss_video_vb2ops = {
374         .queue_setup    = iss_video_queue_setup,
375         .buf_prepare    = iss_video_buf_prepare,
376         .buf_queue      = iss_video_buf_queue,
377         .buf_cleanup    = iss_video_buf_cleanup,
378 };
379
380 /*
381  * omap4iss_video_buffer_next - Complete the current buffer and return the next
382  * @video: ISS video object
383  *
384  * Remove the current video buffer from the DMA queue and fill its timestamp,
385  * field count and state fields before waking up its completion handler.
386  *
387  * For capture video nodes, the buffer state is set to VB2_BUF_STATE_DONE if no
388  * error has been flagged in the pipeline, or to VB2_BUF_STATE_ERROR otherwise.
389  *
390  * The DMA queue is expected to contain at least one buffer.
391  *
392  * Return a pointer to the next buffer in the DMA queue, or NULL if the queue is
393  * empty.
394  */
395 struct iss_buffer *omap4iss_video_buffer_next(struct iss_video *video)
396 {
397         struct iss_pipeline *pipe = to_iss_pipeline(&video->video.entity);
398         enum iss_pipeline_state state;
399         struct iss_buffer *buf;
400         unsigned long flags;
401         struct timespec ts;
402
403         spin_lock_irqsave(&video->qlock, flags);
404         if (WARN_ON(list_empty(&video->dmaqueue))) {
405                 spin_unlock_irqrestore(&video->qlock, flags);
406                 return NULL;
407         }
408
409         buf = list_first_entry(&video->dmaqueue, struct iss_buffer,
410                                list);
411         list_del(&buf->list);
412         spin_unlock_irqrestore(&video->qlock, flags);
413
414         ktime_get_ts(&ts);
415         buf->vb.v4l2_buf.timestamp.tv_sec = ts.tv_sec;
416         buf->vb.v4l2_buf.timestamp.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
417
418         /* Do frame number propagation only if this is the output video node.
419          * Frame number either comes from the CSI receivers or it gets
420          * incremented here if H3A is not active.
421          * Note: There is no guarantee that the output buffer will finish
422          * first, so the input number might lag behind by 1 in some cases.
423          */
424         if (video == pipe->output && !pipe->do_propagation)
425                 buf->vb.v4l2_buf.sequence = atomic_inc_return(&pipe->frame_number);
426         else
427                 buf->vb.v4l2_buf.sequence = atomic_read(&pipe->frame_number);
428
429         vb2_buffer_done(&buf->vb, pipe->error ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
430         pipe->error = false;
431
432         spin_lock_irqsave(&video->qlock, flags);
433         if (list_empty(&video->dmaqueue)) {
434                 spin_unlock_irqrestore(&video->qlock, flags);
435                 if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
436                         state = ISS_PIPELINE_QUEUE_OUTPUT
437                               | ISS_PIPELINE_STREAM;
438                 else
439                         state = ISS_PIPELINE_QUEUE_INPUT
440                               | ISS_PIPELINE_STREAM;
441
442                 spin_lock_irqsave(&pipe->lock, flags);
443                 pipe->state &= ~state;
444                 if (video->pipe.stream_state == ISS_PIPELINE_STREAM_CONTINUOUS)
445                         video->dmaqueue_flags |= ISS_VIDEO_DMAQUEUE_UNDERRUN;
446                 spin_unlock_irqrestore(&pipe->lock, flags);
447                 return NULL;
448         }
449
450         if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && pipe->input != NULL) {
451                 spin_lock_irqsave(&pipe->lock, flags);
452                 pipe->state &= ~ISS_PIPELINE_STREAM;
453                 spin_unlock_irqrestore(&pipe->lock, flags);
454         }
455
456         buf = list_first_entry(&video->dmaqueue, struct iss_buffer,
457                                list);
458         spin_unlock_irqrestore(&video->qlock, flags);
459         buf->vb.state = VB2_BUF_STATE_ACTIVE;
460         return buf;
461 }
462
463 /* -----------------------------------------------------------------------------
464  * V4L2 ioctls
465  */
466
467 static int
468 iss_video_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
469 {
470         struct iss_video *video = video_drvdata(file);
471
472         strlcpy(cap->driver, ISS_VIDEO_DRIVER_NAME, sizeof(cap->driver));
473         strlcpy(cap->card, video->video.name, sizeof(cap->card));
474         strlcpy(cap->bus_info, "media", sizeof(cap->bus_info));
475
476         if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
477                 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
478         else
479                 cap->capabilities = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
480
481         return 0;
482 }
483
484 static int
485 iss_video_get_format(struct file *file, void *fh, struct v4l2_format *format)
486 {
487         struct iss_video_fh *vfh = to_iss_video_fh(fh);
488         struct iss_video *video = video_drvdata(file);
489
490         if (format->type != video->type)
491                 return -EINVAL;
492
493         mutex_lock(&video->mutex);
494         *format = vfh->format;
495         mutex_unlock(&video->mutex);
496
497         return 0;
498 }
499
500 static int
501 iss_video_set_format(struct file *file, void *fh, struct v4l2_format *format)
502 {
503         struct iss_video_fh *vfh = to_iss_video_fh(fh);
504         struct iss_video *video = video_drvdata(file);
505         struct v4l2_mbus_framefmt fmt;
506
507         if (format->type != video->type)
508                 return -EINVAL;
509
510         mutex_lock(&video->mutex);
511
512         /* Fill the bytesperline and sizeimage fields by converting to media bus
513          * format and back to pixel format.
514          */
515         iss_video_pix_to_mbus(&format->fmt.pix, &fmt);
516         iss_video_mbus_to_pix(video, &fmt, &format->fmt.pix);
517
518         vfh->format = *format;
519
520         mutex_unlock(&video->mutex);
521         return 0;
522 }
523
524 static int
525 iss_video_try_format(struct file *file, void *fh, struct v4l2_format *format)
526 {
527         struct iss_video *video = video_drvdata(file);
528         struct v4l2_subdev_format fmt;
529         struct v4l2_subdev *subdev;
530         u32 pad;
531         int ret;
532
533         if (format->type != video->type)
534                 return -EINVAL;
535
536         subdev = iss_video_remote_subdev(video, &pad);
537         if (subdev == NULL)
538                 return -EINVAL;
539
540         iss_video_pix_to_mbus(&format->fmt.pix, &fmt.format);
541
542         fmt.pad = pad;
543         fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
544         ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt);
545         if (ret)
546                 return ret == -ENOIOCTLCMD ? -EINVAL : ret;
547
548         iss_video_mbus_to_pix(video, &fmt.format, &format->fmt.pix);
549         return 0;
550 }
551
552 static int
553 iss_video_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cropcap)
554 {
555         struct iss_video *video = video_drvdata(file);
556         struct v4l2_subdev *subdev;
557         int ret;
558
559         subdev = iss_video_remote_subdev(video, NULL);
560         if (subdev == NULL)
561                 return -EINVAL;
562
563         mutex_lock(&video->mutex);
564         ret = v4l2_subdev_call(subdev, video, cropcap, cropcap);
565         mutex_unlock(&video->mutex);
566
567         return ret == -ENOIOCTLCMD ? -EINVAL : ret;
568 }
569
570 static int
571 iss_video_get_crop(struct file *file, void *fh, struct v4l2_crop *crop)
572 {
573         struct iss_video *video = video_drvdata(file);
574         struct v4l2_subdev_format format;
575         struct v4l2_subdev *subdev;
576         u32 pad;
577         int ret;
578
579         subdev = iss_video_remote_subdev(video, &pad);
580         if (subdev == NULL)
581                 return -EINVAL;
582
583         /* Try the get crop operation first and fallback to get format if not
584          * implemented.
585          */
586         ret = v4l2_subdev_call(subdev, video, g_crop, crop);
587         if (ret != -ENOIOCTLCMD)
588                 return ret;
589
590         format.pad = pad;
591         format.which = V4L2_SUBDEV_FORMAT_ACTIVE;
592         ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &format);
593         if (ret < 0)
594                 return ret == -ENOIOCTLCMD ? -EINVAL : ret;
595
596         crop->c.left = 0;
597         crop->c.top = 0;
598         crop->c.width = format.format.width;
599         crop->c.height = format.format.height;
600
601         return 0;
602 }
603
604 static int
605 iss_video_set_crop(struct file *file, void *fh, struct v4l2_crop *crop)
606 {
607         struct iss_video *video = video_drvdata(file);
608         struct v4l2_subdev *subdev;
609         int ret;
610
611         subdev = iss_video_remote_subdev(video, NULL);
612         if (subdev == NULL)
613                 return -EINVAL;
614
615         mutex_lock(&video->mutex);
616         ret = v4l2_subdev_call(subdev, video, s_crop, crop);
617         mutex_unlock(&video->mutex);
618
619         return ret == -ENOIOCTLCMD ? -EINVAL : ret;
620 }
621
622 static int
623 iss_video_get_param(struct file *file, void *fh, struct v4l2_streamparm *a)
624 {
625         struct iss_video_fh *vfh = to_iss_video_fh(fh);
626         struct iss_video *video = video_drvdata(file);
627
628         if (video->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
629             video->type != a->type)
630                 return -EINVAL;
631
632         memset(a, 0, sizeof(*a));
633         a->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
634         a->parm.output.capability = V4L2_CAP_TIMEPERFRAME;
635         a->parm.output.timeperframe = vfh->timeperframe;
636
637         return 0;
638 }
639
640 static int
641 iss_video_set_param(struct file *file, void *fh, struct v4l2_streamparm *a)
642 {
643         struct iss_video_fh *vfh = to_iss_video_fh(fh);
644         struct iss_video *video = video_drvdata(file);
645
646         if (video->type != V4L2_BUF_TYPE_VIDEO_OUTPUT ||
647             video->type != a->type)
648                 return -EINVAL;
649
650         if (a->parm.output.timeperframe.denominator == 0)
651                 a->parm.output.timeperframe.denominator = 1;
652
653         vfh->timeperframe = a->parm.output.timeperframe;
654
655         return 0;
656 }
657
658 static int
659 iss_video_reqbufs(struct file *file, void *fh, struct v4l2_requestbuffers *rb)
660 {
661         struct iss_video_fh *vfh = to_iss_video_fh(fh);
662
663         return vb2_reqbufs(&vfh->queue, rb);
664 }
665
666 static int
667 iss_video_querybuf(struct file *file, void *fh, struct v4l2_buffer *b)
668 {
669         struct iss_video_fh *vfh = to_iss_video_fh(fh);
670
671         return vb2_querybuf(&vfh->queue, b);
672 }
673
674 static int
675 iss_video_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
676 {
677         struct iss_video_fh *vfh = to_iss_video_fh(fh);
678
679         return vb2_qbuf(&vfh->queue, b);
680 }
681
682 static int
683 iss_video_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
684 {
685         struct iss_video_fh *vfh = to_iss_video_fh(fh);
686
687         return vb2_dqbuf(&vfh->queue, b, file->f_flags & O_NONBLOCK);
688 }
689
690 /*
691  * Stream management
692  *
693  * Every ISS pipeline has a single input and a single output. The input can be
694  * either a sensor or a video node. The output is always a video node.
695  *
696  * As every pipeline has an output video node, the ISS video objects at the
697  * pipeline output stores the pipeline state. It tracks the streaming state of
698  * both the input and output, as well as the availability of buffers.
699  *
700  * In sensor-to-memory mode, frames are always available at the pipeline input.
701  * Starting the sensor usually requires I2C transfers and must be done in
702  * interruptible context. The pipeline is started and stopped synchronously
703  * to the stream on/off commands. All modules in the pipeline will get their
704  * subdev set stream handler called. The module at the end of the pipeline must
705  * delay starting the hardware until buffers are available at its output.
706  *
707  * In memory-to-memory mode, starting/stopping the stream requires
708  * synchronization between the input and output. ISS modules can't be stopped
709  * in the middle of a frame, and at least some of the modules seem to become
710  * busy as soon as they're started, even if they don't receive a frame start
711  * event. For that reason frames need to be processed in single-shot mode. The
712  * driver needs to wait until a frame is completely processed and written to
713  * memory before restarting the pipeline for the next frame. Pipelined
714  * processing might be possible but requires more testing.
715  *
716  * Stream start must be delayed until buffers are available at both the input
717  * and output. The pipeline must be started in the videobuf queue callback with
718  * the buffers queue spinlock held. The modules subdev set stream operation must
719  * not sleep.
720  */
721 static int
722 iss_video_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
723 {
724         struct iss_video_fh *vfh = to_iss_video_fh(fh);
725         struct iss_video *video = video_drvdata(file);
726         enum iss_pipeline_state state;
727         struct iss_pipeline *pipe;
728         struct iss_video *far_end;
729         unsigned long flags;
730         int ret;
731
732         if (type != video->type)
733                 return -EINVAL;
734
735         mutex_lock(&video->stream_lock);
736
737         if (video->streaming) {
738                 mutex_unlock(&video->stream_lock);
739                 return -EBUSY;
740         }
741
742         /* Start streaming on the pipeline. No link touching an entity in the
743          * pipeline can be activated or deactivated once streaming is started.
744          */
745         pipe = video->video.entity.pipe
746              ? to_iss_pipeline(&video->video.entity) : &video->pipe;
747         pipe->external = NULL;
748         pipe->external_rate = 0;
749         pipe->external_bpp = 0;
750
751         if (video->iss->pdata->set_constraints)
752                 video->iss->pdata->set_constraints(video->iss, true);
753
754         ret = media_entity_pipeline_start(&video->video.entity, &pipe->pipe);
755         if (ret < 0)
756                 goto err_media_entity_pipeline_start;
757
758         /* Verify that the currently configured format matches the output of
759          * the connected subdev.
760          */
761         ret = iss_video_check_format(video, vfh);
762         if (ret < 0)
763                 goto err_iss_video_check_format;
764
765         video->bpl_padding = ret;
766         video->bpl_value = vfh->format.fmt.pix.bytesperline;
767
768         /* Find the ISS video node connected at the far end of the pipeline and
769          * update the pipeline.
770          */
771         far_end = iss_video_far_end(video);
772
773         if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
774                 state = ISS_PIPELINE_STREAM_OUTPUT | ISS_PIPELINE_IDLE_OUTPUT;
775                 pipe->input = far_end;
776                 pipe->output = video;
777         } else {
778                 if (far_end == NULL) {
779                         ret = -EPIPE;
780                         goto err_iss_video_check_format;
781                 }
782
783                 state = ISS_PIPELINE_STREAM_INPUT | ISS_PIPELINE_IDLE_INPUT;
784                 pipe->input = video;
785                 pipe->output = far_end;
786         }
787
788         spin_lock_irqsave(&pipe->lock, flags);
789         pipe->state &= ~ISS_PIPELINE_STREAM;
790         pipe->state |= state;
791         spin_unlock_irqrestore(&pipe->lock, flags);
792
793         /* Set the maximum time per frame as the value requested by userspace.
794          * This is a soft limit that can be overridden if the hardware doesn't
795          * support the request limit.
796          */
797         if (video->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
798                 pipe->max_timeperframe = vfh->timeperframe;
799
800         video->queue = &vfh->queue;
801         INIT_LIST_HEAD(&video->dmaqueue);
802         spin_lock_init(&video->qlock);
803         atomic_set(&pipe->frame_number, -1);
804
805         ret = vb2_streamon(&vfh->queue, type);
806         if (ret < 0)
807                 goto err_iss_video_check_format;
808
809         /* In sensor-to-memory mode, the stream can be started synchronously
810          * to the stream on command. In memory-to-memory mode, it will be
811          * started when buffers are queued on both the input and output.
812          */
813         if (pipe->input == NULL) {
814                 unsigned long flags;
815                 ret = omap4iss_pipeline_set_stream(pipe,
816                                               ISS_PIPELINE_STREAM_CONTINUOUS);
817                 if (ret < 0)
818                         goto err_omap4iss_set_stream;
819                 spin_lock_irqsave(&video->qlock, flags);
820                 if (list_empty(&video->dmaqueue))
821                         video->dmaqueue_flags |= ISS_VIDEO_DMAQUEUE_UNDERRUN;
822                 spin_unlock_irqrestore(&video->qlock, flags);
823         }
824
825         if (ret < 0) {
826 err_omap4iss_set_stream:
827                 vb2_streamoff(&vfh->queue, type);
828 err_iss_video_check_format:
829                 media_entity_pipeline_stop(&video->video.entity);
830 err_media_entity_pipeline_start:
831                 if (video->iss->pdata->set_constraints)
832                         video->iss->pdata->set_constraints(video->iss, false);
833                 video->queue = NULL;
834         }
835
836         if (!ret)
837                 video->streaming = 1;
838
839         mutex_unlock(&video->stream_lock);
840         return ret;
841 }
842
843 static int
844 iss_video_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
845 {
846         struct iss_video_fh *vfh = to_iss_video_fh(fh);
847         struct iss_video *video = video_drvdata(file);
848         struct iss_pipeline *pipe = to_iss_pipeline(&video->video.entity);
849         enum iss_pipeline_state state;
850         unsigned long flags;
851
852         if (type != video->type)
853                 return -EINVAL;
854
855         mutex_lock(&video->stream_lock);
856
857         if (!vb2_is_streaming(&vfh->queue))
858                 goto done;
859
860         /* Update the pipeline state. */
861         if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
862                 state = ISS_PIPELINE_STREAM_OUTPUT
863                       | ISS_PIPELINE_QUEUE_OUTPUT;
864         else
865                 state = ISS_PIPELINE_STREAM_INPUT
866                       | ISS_PIPELINE_QUEUE_INPUT;
867
868         spin_lock_irqsave(&pipe->lock, flags);
869         pipe->state &= ~state;
870         spin_unlock_irqrestore(&pipe->lock, flags);
871
872         /* Stop the stream. */
873         omap4iss_pipeline_set_stream(pipe, ISS_PIPELINE_STREAM_STOPPED);
874         vb2_streamoff(&vfh->queue, type);
875         video->queue = NULL;
876         video->streaming = 0;
877
878         if (video->iss->pdata->set_constraints)
879                 video->iss->pdata->set_constraints(video->iss, false);
880         media_entity_pipeline_stop(&video->video.entity);
881
882 done:
883         mutex_unlock(&video->stream_lock);
884         return 0;
885 }
886
887 static int
888 iss_video_enum_input(struct file *file, void *fh, struct v4l2_input *input)
889 {
890         if (input->index > 0)
891                 return -EINVAL;
892
893         strlcpy(input->name, "camera", sizeof(input->name));
894         input->type = V4L2_INPUT_TYPE_CAMERA;
895
896         return 0;
897 }
898
899 static int
900 iss_video_g_input(struct file *file, void *fh, unsigned int *input)
901 {
902         *input = 0;
903
904         return 0;
905 }
906
907 static const struct v4l2_ioctl_ops iss_video_ioctl_ops = {
908         .vidioc_querycap                = iss_video_querycap,
909         .vidioc_g_fmt_vid_cap           = iss_video_get_format,
910         .vidioc_s_fmt_vid_cap           = iss_video_set_format,
911         .vidioc_try_fmt_vid_cap         = iss_video_try_format,
912         .vidioc_g_fmt_vid_out           = iss_video_get_format,
913         .vidioc_s_fmt_vid_out           = iss_video_set_format,
914         .vidioc_try_fmt_vid_out         = iss_video_try_format,
915         .vidioc_cropcap                 = iss_video_cropcap,
916         .vidioc_g_crop                  = iss_video_get_crop,
917         .vidioc_s_crop                  = iss_video_set_crop,
918         .vidioc_g_parm                  = iss_video_get_param,
919         .vidioc_s_parm                  = iss_video_set_param,
920         .vidioc_reqbufs                 = iss_video_reqbufs,
921         .vidioc_querybuf                = iss_video_querybuf,
922         .vidioc_qbuf                    = iss_video_qbuf,
923         .vidioc_dqbuf                   = iss_video_dqbuf,
924         .vidioc_streamon                = iss_video_streamon,
925         .vidioc_streamoff               = iss_video_streamoff,
926         .vidioc_enum_input              = iss_video_enum_input,
927         .vidioc_g_input                 = iss_video_g_input,
928 };
929
930 /* -----------------------------------------------------------------------------
931  * V4L2 file operations
932  */
933
934 static int iss_video_open(struct file *file)
935 {
936         struct iss_video *video = video_drvdata(file);
937         struct iss_video_fh *handle;
938         struct vb2_queue *q;
939         int ret = 0;
940
941         handle = kzalloc(sizeof(*handle), GFP_KERNEL);
942         if (handle == NULL)
943                 return -ENOMEM;
944
945         v4l2_fh_init(&handle->vfh, &video->video);
946         v4l2_fh_add(&handle->vfh);
947
948         /* If this is the first user, initialise the pipeline. */
949         if (omap4iss_get(video->iss) == NULL) {
950                 ret = -EBUSY;
951                 goto done;
952         }
953
954         ret = omap4iss_pipeline_pm_use(&video->video.entity, 1);
955         if (ret < 0) {
956                 omap4iss_put(video->iss);
957                 goto done;
958         }
959
960         video->alloc_ctx = vb2_dma_contig_init_ctx(video->iss->dev);
961         if (IS_ERR(video->alloc_ctx)) {
962                 ret = PTR_ERR(video->alloc_ctx);
963                 omap4iss_put(video->iss);
964                 goto done;
965         }
966
967         q = &handle->queue;
968
969         q->type = video->type;
970         q->io_modes = VB2_MMAP;
971         q->drv_priv = handle;
972         q->ops = &iss_video_vb2ops;
973         q->mem_ops = &vb2_dma_contig_memops;
974         q->buf_struct_size = sizeof(struct iss_buffer);
975
976         ret = vb2_queue_init(q);
977         if (ret) {
978                 omap4iss_put(video->iss);
979                 goto done;
980         }
981
982         memset(&handle->format, 0, sizeof(handle->format));
983         handle->format.type = video->type;
984         handle->timeperframe.denominator = 1;
985
986         handle->video = video;
987         file->private_data = &handle->vfh;
988
989 done:
990         if (ret < 0) {
991                 v4l2_fh_del(&handle->vfh);
992                 kfree(handle);
993         }
994
995         return ret;
996 }
997
998 static int iss_video_release(struct file *file)
999 {
1000         struct iss_video *video = video_drvdata(file);
1001         struct v4l2_fh *vfh = file->private_data;
1002         struct iss_video_fh *handle = to_iss_video_fh(vfh);
1003
1004         /* Disable streaming and free the buffers queue resources. */
1005         iss_video_streamoff(file, vfh, video->type);
1006
1007         omap4iss_pipeline_pm_use(&video->video.entity, 0);
1008
1009         /* Release the videobuf2 queue */
1010         vb2_queue_release(&handle->queue);
1011
1012         /* Release the file handle. */
1013         v4l2_fh_del(vfh);
1014         kfree(handle);
1015         file->private_data = NULL;
1016
1017         omap4iss_put(video->iss);
1018
1019         return 0;
1020 }
1021
1022 static unsigned int iss_video_poll(struct file *file, poll_table *wait)
1023 {
1024         struct iss_video_fh *vfh = to_iss_video_fh(file->private_data);
1025
1026         return vb2_poll(&vfh->queue, file, wait);
1027 }
1028
1029 static int iss_video_mmap(struct file *file, struct vm_area_struct *vma)
1030 {
1031         struct iss_video_fh *vfh = to_iss_video_fh(file->private_data);
1032
1033         return vb2_mmap(&vfh->queue, vma);;
1034 }
1035
1036 static struct v4l2_file_operations iss_video_fops = {
1037         .owner = THIS_MODULE,
1038         .unlocked_ioctl = video_ioctl2,
1039         .open = iss_video_open,
1040         .release = iss_video_release,
1041         .poll = iss_video_poll,
1042         .mmap = iss_video_mmap,
1043 };
1044
1045 /* -----------------------------------------------------------------------------
1046  * ISS video core
1047  */
1048
1049 static const struct iss_video_operations iss_video_dummy_ops = {
1050 };
1051
1052 int omap4iss_video_init(struct iss_video *video, const char *name)
1053 {
1054         const char *direction;
1055         int ret;
1056
1057         switch (video->type) {
1058         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1059                 direction = "output";
1060                 video->pad.flags = MEDIA_PAD_FL_SINK;
1061                 break;
1062         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1063                 direction = "input";
1064                 video->pad.flags = MEDIA_PAD_FL_SOURCE;
1065                 break;
1066
1067         default:
1068                 return -EINVAL;
1069         }
1070
1071         ret = media_entity_init(&video->video.entity, 1, &video->pad, 0);
1072         if (ret < 0)
1073                 return ret;
1074
1075         mutex_init(&video->mutex);
1076         atomic_set(&video->active, 0);
1077
1078         spin_lock_init(&video->pipe.lock);
1079         mutex_init(&video->stream_lock);
1080
1081         /* Initialize the video device. */
1082         if (video->ops == NULL)
1083                 video->ops = &iss_video_dummy_ops;
1084
1085         video->video.fops = &iss_video_fops;
1086         snprintf(video->video.name, sizeof(video->video.name),
1087                  "OMAP4 ISS %s %s", name, direction);
1088         video->video.vfl_type = VFL_TYPE_GRABBER;
1089         video->video.release = video_device_release_empty;
1090         video->video.ioctl_ops = &iss_video_ioctl_ops;
1091         video->pipe.stream_state = ISS_PIPELINE_STREAM_STOPPED;
1092
1093         video_set_drvdata(&video->video, video);
1094
1095         return 0;
1096 }
1097
1098 void omap4iss_video_cleanup(struct iss_video *video)
1099 {
1100         media_entity_cleanup(&video->video.entity);
1101         mutex_destroy(&video->stream_lock);
1102         mutex_destroy(&video->mutex);
1103 }
1104
1105 int omap4iss_video_register(struct iss_video *video, struct v4l2_device *vdev)
1106 {
1107         int ret;
1108
1109         video->video.v4l2_dev = vdev;
1110
1111         ret = video_register_device(&video->video, VFL_TYPE_GRABBER, -1);
1112         if (ret < 0)
1113                 printk(KERN_ERR "%s: could not register video device (%d)\n",
1114                         __func__, ret);
1115
1116         return ret;
1117 }
1118
1119 void omap4iss_video_unregister(struct iss_video *video)
1120 {
1121         if (video_is_registered(&video->video))
1122                 video_unregister_device(&video->video);
1123 }