Merge tag 'media/v4.20-2' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[muen/linux.git] / drivers / staging / media / davinci_vpfe / vpfe_video.c
1 /*
2  * Copyright (C) 2012 Texas Instruments Inc
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation version 2.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16  *
17  * Contributors:
18  *      Manjunath Hadli <manjunath.hadli@ti.com>
19  *      Prabhakar Lad <prabhakar.lad@ti.com>
20  */
21
22 #include <linux/module.h>
23 #include <linux/slab.h>
24
25 #include <media/v4l2-ioctl.h>
26
27 #include "vpfe.h"
28 #include "vpfe_mc_capture.h"
29
30 static int debug;
31
32 /* get v4l2 subdev pointer to external subdev which is active */
33 static struct media_entity *vpfe_get_input_entity
34                         (struct vpfe_video_device *video)
35 {
36         struct vpfe_device *vpfe_dev = video->vpfe_dev;
37         struct media_pad *remote;
38
39         remote = media_entity_remote_pad(&vpfe_dev->vpfe_isif.pads[0]);
40         if (!remote) {
41                 pr_err("Invalid media connection to isif/ccdc\n");
42                 return NULL;
43         }
44         return remote->entity;
45 }
46
47 /* updates external subdev(sensor/decoder) which is active */
48 static int vpfe_update_current_ext_subdev(struct vpfe_video_device *video)
49 {
50         struct vpfe_device *vpfe_dev = video->vpfe_dev;
51         struct vpfe_config *vpfe_cfg;
52         struct v4l2_subdev *subdev;
53         struct media_pad *remote;
54         int i;
55
56         remote = media_entity_remote_pad(&vpfe_dev->vpfe_isif.pads[0]);
57         if (!remote) {
58                 pr_err("Invalid media connection to isif/ccdc\n");
59                 return -EINVAL;
60         }
61
62         subdev = media_entity_to_v4l2_subdev(remote->entity);
63         vpfe_cfg = vpfe_dev->pdev->platform_data;
64         for (i = 0; i < vpfe_cfg->num_subdevs; i++) {
65                 if (!strcmp(vpfe_cfg->sub_devs[i].module_name, subdev->name)) {
66                         video->current_ext_subdev = &vpfe_cfg->sub_devs[i];
67                         break;
68                 }
69         }
70
71         /* if user not linked decoder/sensor to isif/ccdc */
72         if (i == vpfe_cfg->num_subdevs) {
73                 pr_err("Invalid media chain connection to isif/ccdc\n");
74                 return -EINVAL;
75         }
76         /* find the v4l2 subdev pointer */
77         for (i = 0; i < vpfe_dev->num_ext_subdevs; i++) {
78                 if (!strcmp(video->current_ext_subdev->module_name,
79                         vpfe_dev->sd[i]->name))
80                         video->current_ext_subdev->subdev = vpfe_dev->sd[i];
81         }
82         return 0;
83 }
84
85 /* get the subdev which is connected to the output video node */
86 static struct v4l2_subdev *
87 vpfe_video_remote_subdev(struct vpfe_video_device *video, u32 *pad)
88 {
89         struct media_pad *remote = media_entity_remote_pad(&video->pad);
90
91         if (!remote || !is_media_entity_v4l2_subdev(remote->entity))
92                 return NULL;
93         if (pad)
94                 *pad = remote->index;
95         return media_entity_to_v4l2_subdev(remote->entity);
96 }
97
98 /* get the format set at output pad of the adjacent subdev */
99 static int
100 __vpfe_video_get_format(struct vpfe_video_device *video,
101                         struct v4l2_format *format)
102 {
103         struct v4l2_subdev_format fmt;
104         struct v4l2_subdev *subdev;
105         struct media_pad *remote;
106         u32 pad;
107         int ret;
108
109         subdev = vpfe_video_remote_subdev(video, &pad);
110         if (!subdev)
111                 return -EINVAL;
112
113         fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
114         remote = media_entity_remote_pad(&video->pad);
115         fmt.pad = remote->index;
116
117         ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt);
118         if (ret == -ENOIOCTLCMD)
119                 return -EINVAL;
120
121         format->type = video->type;
122         /* convert mbus_format to v4l2_format */
123         v4l2_fill_pix_format(&format->fmt.pix, &fmt.format);
124         mbus_to_pix(&fmt.format, &format->fmt.pix);
125
126         return 0;
127 }
128
129 /* make a note of pipeline details */
130 static int vpfe_prepare_pipeline(struct vpfe_video_device *video)
131 {
132         struct media_graph graph;
133         struct media_entity *entity = &video->video_dev.entity;
134         struct media_device *mdev = entity->graph_obj.mdev;
135         struct vpfe_pipeline *pipe = &video->pipe;
136         struct vpfe_video_device *far_end = NULL;
137         int ret;
138
139         pipe->input_num = 0;
140         pipe->output_num = 0;
141
142         if (video->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
143                 pipe->inputs[pipe->input_num++] = video;
144         else
145                 pipe->outputs[pipe->output_num++] = video;
146
147         mutex_lock(&mdev->graph_mutex);
148         ret = media_graph_walk_init(&graph, mdev);
149         if (ret) {
150                 mutex_unlock(&mdev->graph_mutex);
151                 return -ENOMEM;
152         }
153         media_graph_walk_start(&graph, entity);
154         while ((entity = media_graph_walk_next(&graph))) {
155                 if (entity == &video->video_dev.entity)
156                         continue;
157                 if (!is_media_entity_v4l2_video_device(entity))
158                         continue;
159                 far_end = to_vpfe_video(media_entity_to_video_device(entity));
160                 if (far_end->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
161                         pipe->inputs[pipe->input_num++] = far_end;
162                 else
163                         pipe->outputs[pipe->output_num++] = far_end;
164         }
165         media_graph_walk_cleanup(&graph);
166         mutex_unlock(&mdev->graph_mutex);
167
168         return 0;
169 }
170
171 /* update pipe state selected by user */
172 static int vpfe_update_pipe_state(struct vpfe_video_device *video)
173 {
174         struct vpfe_pipeline *pipe = &video->pipe;
175         int ret;
176
177         ret = vpfe_prepare_pipeline(video);
178         if (ret)
179                 return ret;
180
181         /*
182          * Find out if there is any input video
183          * if yes, it is single shot.
184          */
185         if (pipe->input_num == 0) {
186                 pipe->state = VPFE_PIPELINE_STREAM_CONTINUOUS;
187                 ret = vpfe_update_current_ext_subdev(video);
188                 if (ret) {
189                         pr_err("Invalid external subdev\n");
190                         return ret;
191                 }
192         } else {
193                 pipe->state = VPFE_PIPELINE_STREAM_SINGLESHOT;
194         }
195         video->initialized = 1;
196         video->skip_frame_count = 1;
197         video->skip_frame_count_init = 1;
198         return 0;
199 }
200
201 /* checks whether pipeline is ready for enabling */
202 int vpfe_video_is_pipe_ready(struct vpfe_pipeline *pipe)
203 {
204         int i;
205
206         for (i = 0; i < pipe->input_num; i++)
207                 if (!pipe->inputs[i]->started ||
208                         pipe->inputs[i]->state != VPFE_VIDEO_BUFFER_QUEUED)
209                         return 0;
210         for (i = 0; i < pipe->output_num; i++)
211                 if (!pipe->outputs[i]->started ||
212                         pipe->outputs[i]->state != VPFE_VIDEO_BUFFER_QUEUED)
213                         return 0;
214         return 1;
215 }
216
217 /*
218  * Validate a pipeline by checking both ends of all links for format
219  * discrepancies.
220  *
221  * Return 0 if all formats match, or -EPIPE if at least one link is found with
222  * different formats on its two ends.
223  */
224 static int vpfe_video_validate_pipeline(struct vpfe_pipeline *pipe)
225 {
226         struct v4l2_subdev_format fmt_source;
227         struct v4l2_subdev_format fmt_sink;
228         struct v4l2_subdev *subdev;
229         struct media_pad *pad;
230         int ret;
231
232         /*
233          * Should not matter if it is output[0] or 1 as
234          * the general ideas is to traverse backwards and
235          * the fact that the out video node always has the
236          * format of the connected pad.
237          */
238         subdev = vpfe_video_remote_subdev(pipe->outputs[0], NULL);
239         if (!subdev)
240                 return -EPIPE;
241
242         while (1) {
243                 /* Retrieve the sink format */
244                 pad = &subdev->entity.pads[0];
245                 if (!(pad->flags & MEDIA_PAD_FL_SINK))
246                         break;
247
248                 fmt_sink.which = V4L2_SUBDEV_FORMAT_ACTIVE;
249                 fmt_sink.pad = pad->index;
250                 ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL,
251                                        &fmt_sink);
252
253                 if (ret < 0 && ret != -ENOIOCTLCMD)
254                         return -EPIPE;
255
256                 /* Retrieve the source format */
257                 pad = media_entity_remote_pad(pad);
258                 if (!pad || !is_media_entity_v4l2_subdev(pad->entity))
259                         break;
260
261                 subdev = media_entity_to_v4l2_subdev(pad->entity);
262
263                 fmt_source.which = V4L2_SUBDEV_FORMAT_ACTIVE;
264                 fmt_source.pad = pad->index;
265                 ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt_source);
266                 if (ret < 0 && ret != -ENOIOCTLCMD)
267                         return -EPIPE;
268
269                 /* Check if the two ends match */
270                 if (fmt_source.format.code != fmt_sink.format.code ||
271                     fmt_source.format.width != fmt_sink.format.width ||
272                     fmt_source.format.height != fmt_sink.format.height)
273                         return -EPIPE;
274         }
275         return 0;
276 }
277
278 /*
279  * vpfe_pipeline_enable() - Enable streaming on a pipeline
280  * @vpfe_dev: vpfe device
281  * @pipe: vpfe pipeline
282  *
283  * Walk the entities chain starting at the pipeline output video node and start
284  * all modules in the chain in the given mode.
285  *
286  * Return 0 if successful, or the return value of the failed video::s_stream
287  * operation otherwise.
288  */
289 static int vpfe_pipeline_enable(struct vpfe_pipeline *pipe)
290 {
291         struct media_entity *entity;
292         struct v4l2_subdev *subdev;
293         struct media_device *mdev;
294         int ret;
295
296         if (pipe->state == VPFE_PIPELINE_STREAM_CONTINUOUS)
297                 entity = vpfe_get_input_entity(pipe->outputs[0]);
298         else
299                 entity = &pipe->inputs[0]->video_dev.entity;
300
301         mdev = entity->graph_obj.mdev;
302         mutex_lock(&mdev->graph_mutex);
303         ret = media_graph_walk_init(&pipe->graph, mdev);
304         if (ret)
305                 goto out;
306         media_graph_walk_start(&pipe->graph, entity);
307         while ((entity = media_graph_walk_next(&pipe->graph))) {
308
309                 if (!is_media_entity_v4l2_subdev(entity))
310                         continue;
311                 subdev = media_entity_to_v4l2_subdev(entity);
312                 ret = v4l2_subdev_call(subdev, video, s_stream, 1);
313                 if (ret < 0 && ret != -ENOIOCTLCMD)
314                         break;
315         }
316 out:
317         if (ret)
318                 media_graph_walk_cleanup(&pipe->graph);
319         mutex_unlock(&mdev->graph_mutex);
320         return ret;
321 }
322
323 /*
324  * vpfe_pipeline_disable() - Disable streaming on a pipeline
325  * @vpfe_dev: vpfe device
326  * @pipe: VPFE pipeline
327  *
328  * Walk the entities chain starting at the pipeline output video node and stop
329  * all modules in the chain.
330  *
331  * Return 0 if all modules have been properly stopped, or -ETIMEDOUT if a module
332  * can't be stopped.
333  */
334 static int vpfe_pipeline_disable(struct vpfe_pipeline *pipe)
335 {
336         struct media_entity *entity;
337         struct v4l2_subdev *subdev;
338         struct media_device *mdev;
339         int ret = 0;
340
341         if (pipe->state == VPFE_PIPELINE_STREAM_CONTINUOUS)
342                 entity = vpfe_get_input_entity(pipe->outputs[0]);
343         else
344                 entity = &pipe->inputs[0]->video_dev.entity;
345
346         mdev = entity->graph_obj.mdev;
347         mutex_lock(&mdev->graph_mutex);
348         media_graph_walk_start(&pipe->graph, entity);
349
350         while ((entity = media_graph_walk_next(&pipe->graph))) {
351
352                 if (!is_media_entity_v4l2_subdev(entity))
353                         continue;
354                 subdev = media_entity_to_v4l2_subdev(entity);
355                 ret = v4l2_subdev_call(subdev, video, s_stream, 0);
356                 if (ret < 0 && ret != -ENOIOCTLCMD)
357                         break;
358         }
359         mutex_unlock(&mdev->graph_mutex);
360
361         media_graph_walk_cleanup(&pipe->graph);
362         return ret ? -ETIMEDOUT : 0;
363 }
364
365 /*
366  * vpfe_pipeline_set_stream() - Enable/disable streaming on a pipeline
367  * @vpfe_dev: VPFE device
368  * @pipe: VPFE pipeline
369  * @state: Stream state (stopped or active)
370  *
371  * Set the pipeline to the given stream state.
372  *
373  * Return 0 if successful, or the return value of the failed video::s_stream
374  * operation otherwise.
375  */
376 static int vpfe_pipeline_set_stream(struct vpfe_pipeline *pipe,
377                             enum vpfe_pipeline_stream_state state)
378 {
379         if (state == VPFE_PIPELINE_STREAM_STOPPED)
380                 return vpfe_pipeline_disable(pipe);
381
382         return vpfe_pipeline_enable(pipe);
383 }
384
385 static int all_videos_stopped(struct vpfe_video_device *video)
386 {
387         struct vpfe_pipeline *pipe = &video->pipe;
388         int i;
389
390         for (i = 0; i < pipe->input_num; i++)
391                 if (pipe->inputs[i]->started)
392                         return 0;
393         for (i = 0; i < pipe->output_num; i++)
394                 if (pipe->outputs[i]->started)
395                         return 0;
396         return 1;
397 }
398
399 /*
400  * vpfe_open() - open video device
401  * @file: file pointer
402  *
403  * initialize media pipeline state, allocate memory for file handle
404  *
405  * Return 0 if successful, or the return -ENODEV otherwise.
406  */
407 static int vpfe_open(struct file *file)
408 {
409         struct vpfe_video_device *video = video_drvdata(file);
410         struct vpfe_fh *handle;
411
412         /* Allocate memory for the file handle object */
413         handle = kzalloc(sizeof(struct vpfe_fh), GFP_KERNEL);
414
415         if (!handle)
416                 return -ENOMEM;
417
418         v4l2_fh_init(&handle->vfh, &video->video_dev);
419         v4l2_fh_add(&handle->vfh);
420
421         mutex_lock(&video->lock);
422         /* If decoder is not initialized. initialize it */
423         if (!video->initialized && vpfe_update_pipe_state(video)) {
424                 mutex_unlock(&video->lock);
425                 return -ENODEV;
426         }
427         /* Increment device users counter */
428         video->usrs++;
429         /* Set io_allowed member to false */
430         handle->io_allowed = 0;
431         handle->video = video;
432         file->private_data = &handle->vfh;
433         mutex_unlock(&video->lock);
434
435         return 0;
436 }
437
438 /* get the next buffer available from dma queue */
439 static unsigned long
440 vpfe_video_get_next_buffer(struct vpfe_video_device *video)
441 {
442         video->cur_frm = video->next_frm =
443                 list_entry(video->dma_queue.next,
444                            struct vpfe_cap_buffer, list);
445
446         list_del(&video->next_frm->list);
447         video->next_frm->vb.vb2_buf.state = VB2_BUF_STATE_ACTIVE;
448         return vb2_dma_contig_plane_dma_addr(&video->next_frm->vb.vb2_buf, 0);
449 }
450
451 /* schedule the next buffer which is available on dma queue */
452 void vpfe_video_schedule_next_buffer(struct vpfe_video_device *video)
453 {
454         struct vpfe_device *vpfe_dev = video->vpfe_dev;
455         unsigned long addr;
456
457         if (list_empty(&video->dma_queue))
458                 return;
459
460         video->next_frm = list_entry(video->dma_queue.next,
461                                         struct vpfe_cap_buffer, list);
462
463         if (video->pipe.state == VPFE_PIPELINE_STREAM_SINGLESHOT)
464                 video->cur_frm = video->next_frm;
465
466         list_del(&video->next_frm->list);
467         video->next_frm->vb.vb2_buf.state = VB2_BUF_STATE_ACTIVE;
468         addr = vb2_dma_contig_plane_dma_addr(&video->next_frm->vb.vb2_buf, 0);
469         video->ops->queue(vpfe_dev, addr);
470         video->state = VPFE_VIDEO_BUFFER_QUEUED;
471 }
472
473 /* schedule the buffer for capturing bottom field */
474 void vpfe_video_schedule_bottom_field(struct vpfe_video_device *video)
475 {
476         struct vpfe_device *vpfe_dev = video->vpfe_dev;
477         unsigned long addr;
478
479         addr = vb2_dma_contig_plane_dma_addr(&video->cur_frm->vb.vb2_buf, 0);
480         addr += video->field_off;
481         video->ops->queue(vpfe_dev, addr);
482 }
483
484 /* make buffer available for dequeue */
485 void vpfe_video_process_buffer_complete(struct vpfe_video_device *video)
486 {
487         struct vpfe_pipeline *pipe = &video->pipe;
488
489         video->cur_frm->vb.vb2_buf.timestamp = ktime_get_ns();
490         vb2_buffer_done(&video->cur_frm->vb.vb2_buf, VB2_BUF_STATE_DONE);
491         if (pipe->state == VPFE_PIPELINE_STREAM_CONTINUOUS)
492                 video->cur_frm = video->next_frm;
493 }
494
495 /* vpfe_stop_capture() - stop streaming */
496 static void vpfe_stop_capture(struct vpfe_video_device *video)
497 {
498         struct vpfe_pipeline *pipe = &video->pipe;
499
500         video->started = 0;
501
502         if (video->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
503                 return;
504         if (all_videos_stopped(video))
505                 vpfe_pipeline_set_stream(pipe,
506                                          VPFE_PIPELINE_STREAM_STOPPED);
507 }
508
509 /*
510  * vpfe_release() - release video device
511  * @file: file pointer
512  *
513  * deletes buffer queue, frees the buffers and the vpfe file handle
514  *
515  * Return 0
516  */
517 static int vpfe_release(struct file *file)
518 {
519         struct vpfe_video_device *video = video_drvdata(file);
520         struct v4l2_fh *vfh = file->private_data;
521         struct vpfe_device *vpfe_dev = video->vpfe_dev;
522         struct vpfe_fh *fh = container_of(vfh, struct vpfe_fh, vfh);
523
524         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_release\n");
525
526         /* Get the device lock */
527         mutex_lock(&video->lock);
528         /* if this instance is doing IO */
529         if (fh->io_allowed) {
530                 if (video->started) {
531                         vpfe_stop_capture(video);
532                         /*
533                          * mark pipe state as stopped in vpfe_release(),
534                          * as app might call streamon() after streamoff()
535                          * in which case driver has to start streaming.
536                          */
537                         video->pipe.state = VPFE_PIPELINE_STREAM_STOPPED;
538                         vb2_streamoff(&video->buffer_queue,
539                                       video->buffer_queue.type);
540                 }
541                 video->io_usrs = 0;
542                 /* Free buffers allocated */
543                 vb2_queue_release(&video->buffer_queue);
544         }
545         /* Decrement device users counter */
546         video->usrs--;
547         v4l2_fh_del(&fh->vfh);
548         v4l2_fh_exit(&fh->vfh);
549         /* If this is the last file handle */
550         if (!video->usrs)
551                 video->initialized = 0;
552         mutex_unlock(&video->lock);
553         file->private_data = NULL;
554         /* Free memory allocated to file handle object */
555         v4l2_fh_del(vfh);
556         kzfree(fh);
557         return 0;
558 }
559
560 /*
561  * vpfe_mmap() - It is used to map kernel space buffers
562  * into user spaces
563  */
564 static int vpfe_mmap(struct file *file, struct vm_area_struct *vma)
565 {
566         struct vpfe_video_device *video = video_drvdata(file);
567         struct vpfe_device *vpfe_dev = video->vpfe_dev;
568
569         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_mmap\n");
570         return vb2_mmap(&video->buffer_queue, vma);
571 }
572
573 /*
574  * vpfe_poll() - It is used for select/poll system call
575  */
576 static __poll_t vpfe_poll(struct file *file, poll_table *wait)
577 {
578         struct vpfe_video_device *video = video_drvdata(file);
579         struct vpfe_device *vpfe_dev = video->vpfe_dev;
580
581         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_poll\n");
582         if (video->started)
583                 return vb2_poll(&video->buffer_queue, file, wait);
584         return 0;
585 }
586
587 /* vpfe capture driver file operations */
588 static const struct v4l2_file_operations vpfe_fops = {
589         .owner = THIS_MODULE,
590         .open = vpfe_open,
591         .release = vpfe_release,
592         .unlocked_ioctl = video_ioctl2,
593         .mmap = vpfe_mmap,
594         .poll = vpfe_poll
595 };
596
597 /*
598  * vpfe_querycap() - query capabilities of video device
599  * @file: file pointer
600  * @priv: void pointer
601  * @cap: pointer to v4l2_capability structure
602  *
603  * fills v4l2 capabilities structure
604  *
605  * Return 0
606  */
607 static int vpfe_querycap(struct file *file, void  *priv,
608                                struct v4l2_capability *cap)
609 {
610         struct vpfe_video_device *video = video_drvdata(file);
611         struct vpfe_device *vpfe_dev = video->vpfe_dev;
612
613         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querycap\n");
614
615         if (video->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
616                 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
617         else
618                 cap->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
619         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT |
620                             V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
621         strscpy(cap->driver, CAPTURE_DRV_NAME, sizeof(cap->driver));
622         strscpy(cap->bus_info, "VPFE", sizeof(cap->bus_info));
623         strscpy(cap->card, vpfe_dev->cfg->card_name, sizeof(cap->card));
624
625         return 0;
626 }
627
628 /*
629  * vpfe_g_fmt() - get the format which is active on video device
630  * @file: file pointer
631  * @priv: void pointer
632  * @fmt: pointer to v4l2_format structure
633  *
634  * fills v4l2 format structure with active format
635  *
636  * Return 0
637  */
638 static int vpfe_g_fmt(struct file *file, void *priv,
639                                 struct v4l2_format *fmt)
640 {
641         struct vpfe_video_device *video = video_drvdata(file);
642         struct vpfe_device *vpfe_dev = video->vpfe_dev;
643
644         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_fmt\n");
645         /* Fill in the information about format */
646         *fmt = video->fmt;
647         return 0;
648 }
649
650 /*
651  * vpfe_enum_fmt() - enum formats supported on media chain
652  * @file: file pointer
653  * @priv: void pointer
654  * @fmt: pointer to v4l2_fmtdesc structure
655  *
656  * fills v4l2_fmtdesc structure with output format set on adjacent subdev,
657  * only one format is enumearted as subdevs are already configured
658  *
659  * Return 0 if successful, error code otherwise
660  */
661 static int vpfe_enum_fmt(struct file *file, void  *priv,
662                                    struct v4l2_fmtdesc *fmt)
663 {
664         struct vpfe_video_device *video = video_drvdata(file);
665         struct vpfe_device *vpfe_dev = video->vpfe_dev;
666         struct v4l2_subdev_format sd_fmt;
667         struct v4l2_mbus_framefmt mbus;
668         struct v4l2_subdev *subdev;
669         struct v4l2_format format;
670         struct media_pad *remote;
671         int ret;
672
673         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_fmt\n");
674
675         /*
676          * since already subdev pad format is set,
677          * only one pixel format is available
678          */
679         if (fmt->index > 0) {
680                 v4l2_err(&vpfe_dev->v4l2_dev, "Invalid index\n");
681                 return -EINVAL;
682         }
683         /* get the remote pad */
684         remote = media_entity_remote_pad(&video->pad);
685         if (!remote) {
686                 v4l2_err(&vpfe_dev->v4l2_dev,
687                          "invalid remote pad for video node\n");
688                 return -EINVAL;
689         }
690         /* get the remote subdev */
691         subdev = vpfe_video_remote_subdev(video, NULL);
692         if (!subdev) {
693                 v4l2_err(&vpfe_dev->v4l2_dev,
694                          "invalid remote subdev for video node\n");
695                 return -EINVAL;
696         }
697         sd_fmt.pad = remote->index;
698         sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
699         /* get output format of remote subdev */
700         ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &sd_fmt);
701         if (ret) {
702                 v4l2_err(&vpfe_dev->v4l2_dev,
703                          "invalid remote subdev for video node\n");
704                 return ret;
705         }
706         /* convert to pix format */
707         mbus.code = sd_fmt.format.code;
708         mbus_to_pix(&mbus, &format.fmt.pix);
709         /* copy the result */
710         fmt->pixelformat = format.fmt.pix.pixelformat;
711
712         return 0;
713 }
714
715 /*
716  * vpfe_s_fmt() - set the format on video device
717  * @file: file pointer
718  * @priv: void pointer
719  * @fmt: pointer to v4l2_format structure
720  *
721  * validate and set the format on video device
722  *
723  * Return 0 on success, error code otherwise
724  */
725 static int vpfe_s_fmt(struct file *file, void *priv,
726                                 struct v4l2_format *fmt)
727 {
728         struct vpfe_video_device *video = video_drvdata(file);
729         struct vpfe_device *vpfe_dev = video->vpfe_dev;
730         struct v4l2_format format;
731         int ret;
732
733         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_fmt\n");
734         /* If streaming is started, return error */
735         if (video->started) {
736                 v4l2_err(&vpfe_dev->v4l2_dev, "Streaming is started\n");
737                 return -EBUSY;
738         }
739         /* get adjacent subdev's output pad format */
740         ret = __vpfe_video_get_format(video, &format);
741         if (ret)
742                 return ret;
743         *fmt = format;
744         video->fmt = *fmt;
745         return 0;
746 }
747
748 /*
749  * vpfe_try_fmt() - try the format on video device
750  * @file: file pointer
751  * @priv: void pointer
752  * @fmt: pointer to v4l2_format structure
753  *
754  * validate the format, update with correct format
755  * based on output format set on adjacent subdev
756  *
757  * Return 0 on success, error code otherwise
758  */
759 static int vpfe_try_fmt(struct file *file, void *priv,
760                                   struct v4l2_format *fmt)
761 {
762         struct vpfe_video_device *video = video_drvdata(file);
763         struct vpfe_device *vpfe_dev = video->vpfe_dev;
764         struct v4l2_format format;
765         int ret;
766
767         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_try_fmt\n");
768         /* get adjacent subdev's output pad format */
769         ret = __vpfe_video_get_format(video, &format);
770         if (ret)
771                 return ret;
772
773         *fmt = format;
774         return 0;
775 }
776
777 /*
778  * vpfe_enum_input() - enum inputs supported on media chain
779  * @file: file pointer
780  * @priv: void pointer
781  * @fmt: pointer to v4l2_fmtdesc structure
782  *
783  * fills v4l2_input structure with input available on media chain,
784  * only one input is enumearted as media chain is setup by this time
785  *
786  * Return 0 if successful, -EINVAL is media chain is invalid
787  */
788 static int vpfe_enum_input(struct file *file, void *priv,
789                                  struct v4l2_input *inp)
790 {
791         struct vpfe_video_device *video = video_drvdata(file);
792         struct vpfe_ext_subdev_info *sdinfo = video->current_ext_subdev;
793         struct vpfe_device *vpfe_dev = video->vpfe_dev;
794
795         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_input\n");
796         /* enumerate from the subdev user has chosen through mc */
797         if (inp->index < sdinfo->num_inputs) {
798                 memcpy(inp, &sdinfo->inputs[inp->index],
799                        sizeof(struct v4l2_input));
800                 return 0;
801         }
802         return -EINVAL;
803 }
804
805 /*
806  * vpfe_g_input() - get index of the input which is active
807  * @file: file pointer
808  * @priv: void pointer
809  * @index: pointer to unsigned int
810  *
811  * set index with input index which is active
812  */
813 static int vpfe_g_input(struct file *file, void *priv, unsigned int *index)
814 {
815         struct vpfe_video_device *video = video_drvdata(file);
816         struct vpfe_device *vpfe_dev = video->vpfe_dev;
817
818         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_input\n");
819
820         *index = video->current_input;
821         return 0;
822 }
823
824 /*
825  * vpfe_s_input() - set input which is pointed by input index
826  * @file: file pointer
827  * @priv: void pointer
828  * @index: pointer to unsigned int
829  *
830  * set input on external subdev
831  *
832  * Return 0 on success, error code otherwise
833  */
834 static int vpfe_s_input(struct file *file, void *priv, unsigned int index)
835 {
836         struct vpfe_video_device *video = video_drvdata(file);
837         struct vpfe_device *vpfe_dev = video->vpfe_dev;
838         struct vpfe_ext_subdev_info *sdinfo;
839         struct vpfe_route *route;
840         struct v4l2_input *inps;
841         u32 output;
842         u32 input;
843         int ret;
844         int i;
845
846         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_input\n");
847
848         ret = mutex_lock_interruptible(&video->lock);
849         if (ret)
850                 return ret;
851         /*
852          * If streaming is started return device busy
853          * error
854          */
855         if (video->started) {
856                 v4l2_err(&vpfe_dev->v4l2_dev, "Streaming is on\n");
857                 ret = -EBUSY;
858                 goto unlock_out;
859         }
860
861         sdinfo = video->current_ext_subdev;
862         if (!sdinfo->registered) {
863                 ret = -EINVAL;
864                 goto unlock_out;
865         }
866         if (vpfe_dev->cfg->setup_input &&
867                 vpfe_dev->cfg->setup_input(sdinfo->grp_id) < 0) {
868                 ret = -EFAULT;
869                 v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
870                           "couldn't setup input for %s\n",
871                           sdinfo->module_name);
872                 goto unlock_out;
873         }
874         route = &sdinfo->routes[index];
875         if (route && sdinfo->can_route) {
876                 input = route->input;
877                 output = route->output;
878                 ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev,
879                                                  sdinfo->grp_id, video,
880                                                  s_routing, input, output, 0);
881                 if (ret) {
882                         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
883                                 "s_input:error in setting input in decoder\n");
884                         ret = -EINVAL;
885                         goto unlock_out;
886                 }
887         }
888         /* set standards set by subdev in video device */
889         for (i = 0; i < sdinfo->num_inputs; i++) {
890                 inps = &sdinfo->inputs[i];
891                 video->video_dev.tvnorms |= inps->std;
892         }
893         video->current_input = index;
894 unlock_out:
895         mutex_unlock(&video->lock);
896         return ret;
897 }
898
899 /*
900  * vpfe_querystd() - query std which is being input on external subdev
901  * @file: file pointer
902  * @priv: void pointer
903  * @std_id: pointer to v4l2_std_id structure
904  *
905  * call external subdev through v4l2_device_call_until_err to
906  * get the std that is being active.
907  *
908  * Return 0 on success, error code otherwise
909  */
910 static int vpfe_querystd(struct file *file, void *priv, v4l2_std_id *std_id)
911 {
912         struct vpfe_video_device *video = video_drvdata(file);
913         struct vpfe_device *vpfe_dev = video->vpfe_dev;
914         struct vpfe_ext_subdev_info *sdinfo;
915         int ret;
916
917         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querystd\n");
918
919         ret = mutex_lock_interruptible(&video->lock);
920         sdinfo = video->current_ext_subdev;
921         if (ret)
922                 return ret;
923         /* Call querystd function of decoder device */
924         ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
925                                          video, querystd, std_id);
926         mutex_unlock(&video->lock);
927         return ret;
928 }
929
930 /*
931  * vpfe_s_std() - set std on external subdev
932  * @file: file pointer
933  * @priv: void pointer
934  * @std_id: pointer to v4l2_std_id structure
935  *
936  * set std pointed by std_id on external subdev by calling it using
937  * v4l2_device_call_until_err
938  *
939  * Return 0 on success, error code otherwise
940  */
941 static int vpfe_s_std(struct file *file, void *priv, v4l2_std_id std_id)
942 {
943         struct vpfe_video_device *video = video_drvdata(file);
944         struct vpfe_device *vpfe_dev = video->vpfe_dev;
945         struct vpfe_ext_subdev_info *sdinfo;
946         int ret;
947
948         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_std\n");
949
950         /* Call decoder driver function to set the standard */
951         ret = mutex_lock_interruptible(&video->lock);
952         if (ret)
953                 return ret;
954         sdinfo = video->current_ext_subdev;
955         /* If streaming is started, return device busy error */
956         if (video->started) {
957                 v4l2_err(&vpfe_dev->v4l2_dev, "streaming is started\n");
958                 ret = -EBUSY;
959                 goto unlock_out;
960         }
961         ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
962                                          video, s_std, std_id);
963         if (ret < 0) {
964                 v4l2_err(&vpfe_dev->v4l2_dev, "Failed to set standard\n");
965                 video->stdid = V4L2_STD_UNKNOWN;
966                 goto unlock_out;
967         }
968         video->stdid = std_id;
969 unlock_out:
970         mutex_unlock(&video->lock);
971         return ret;
972 }
973
974 static int vpfe_g_std(struct file *file, void *priv, v4l2_std_id *tvnorm)
975 {
976         struct vpfe_video_device *video = video_drvdata(file);
977         struct vpfe_device *vpfe_dev = video->vpfe_dev;
978
979         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_std\n");
980         *tvnorm = video->stdid;
981         return 0;
982 }
983
984 /*
985  * vpfe_enum_dv_timings() - enumerate dv_timings which are supported by
986  *                      to external subdev
987  * @file: file pointer
988  * @priv: void pointer
989  * @timings: pointer to v4l2_enum_dv_timings structure
990  *
991  * enum dv_timings's which are supported by external subdev through
992  * v4l2_subdev_call
993  *
994  * Return 0 on success, error code otherwise
995  */
996 static int
997 vpfe_enum_dv_timings(struct file *file, void *fh,
998                   struct v4l2_enum_dv_timings *timings)
999 {
1000         struct vpfe_video_device *video = video_drvdata(file);
1001         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1002         struct v4l2_subdev *subdev = video->current_ext_subdev->subdev;
1003
1004         timings->pad = 0;
1005
1006         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_dv_timings\n");
1007         return v4l2_subdev_call(subdev, pad, enum_dv_timings, timings);
1008 }
1009
1010 /*
1011  * vpfe_query_dv_timings() - query the dv_timings which is being input
1012  *                      to external subdev
1013  * @file: file pointer
1014  * @priv: void pointer
1015  * @timings: pointer to v4l2_dv_timings structure
1016  *
1017  * get dv_timings which is being input on external subdev through
1018  * v4l2_subdev_call
1019  *
1020  * Return 0 on success, error code otherwise
1021  */
1022 static int
1023 vpfe_query_dv_timings(struct file *file, void *fh,
1024                    struct v4l2_dv_timings *timings)
1025 {
1026         struct vpfe_video_device *video = video_drvdata(file);
1027         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1028         struct v4l2_subdev *subdev = video->current_ext_subdev->subdev;
1029
1030         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_query_dv_timings\n");
1031         return v4l2_subdev_call(subdev, video, query_dv_timings, timings);
1032 }
1033
1034 /*
1035  * vpfe_s_dv_timings() - set dv_timings on external subdev
1036  * @file: file pointer
1037  * @priv: void pointer
1038  * @timings: pointer to v4l2_dv_timings structure
1039  *
1040  * set dv_timings pointed by timings on external subdev through
1041  * v4l2_device_call_until_err, this configures amplifier also
1042  *
1043  * Return 0 on success, error code otherwise
1044  */
1045 static int
1046 vpfe_s_dv_timings(struct file *file, void *fh,
1047                   struct v4l2_dv_timings *timings)
1048 {
1049         struct vpfe_video_device *video = video_drvdata(file);
1050         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1051
1052         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_dv_timings\n");
1053
1054         video->stdid = V4L2_STD_UNKNOWN;
1055         return v4l2_device_call_until_err(&vpfe_dev->v4l2_dev,
1056                                           video->current_ext_subdev->grp_id,
1057                                           video, s_dv_timings, timings);
1058 }
1059
1060 /*
1061  * vpfe_g_dv_timings() - get dv_timings which is set on external subdev
1062  * @file: file pointer
1063  * @priv: void pointer
1064  * @timings: pointer to v4l2_dv_timings structure
1065  *
1066  * get dv_timings which is set on external subdev through
1067  * v4l2_subdev_call
1068  *
1069  * Return 0 on success, error code otherwise
1070  */
1071 static int
1072 vpfe_g_dv_timings(struct file *file, void *fh,
1073               struct v4l2_dv_timings *timings)
1074 {
1075         struct vpfe_video_device *video = video_drvdata(file);
1076         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1077         struct v4l2_subdev *subdev = video->current_ext_subdev->subdev;
1078
1079         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_dv_timings\n");
1080         return v4l2_subdev_call(subdev, video, g_dv_timings, timings);
1081 }
1082
1083 /*
1084  *  Videobuf operations
1085  */
1086 /*
1087  * vpfe_buffer_queue_setup : Callback function for buffer setup.
1088  * @vq: vb2_queue ptr
1089  * @fmt: v4l2 format
1090  * @nbuffers: ptr to number of buffers requested by application
1091  * @nplanes:: contains number of distinct video planes needed to hold a frame
1092  * @sizes[]: contains the size (in bytes) of each plane.
1093  * @alloc_devs: ptr to allocation context
1094  *
1095  * This callback function is called when reqbuf() is called to adjust
1096  * the buffer nbuffers and buffer size
1097  */
1098 static int
1099 vpfe_buffer_queue_setup(struct vb2_queue *vq,
1100                         unsigned int *nbuffers, unsigned int *nplanes,
1101                         unsigned int sizes[], struct device *alloc_devs[])
1102 {
1103         struct vpfe_fh *fh = vb2_get_drv_priv(vq);
1104         struct vpfe_video_device *video = fh->video;
1105         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1106         unsigned long size;
1107
1108         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_buffer_queue_setup\n");
1109         size = video->fmt.fmt.pix.sizeimage;
1110
1111         if (vq->num_buffers + *nbuffers < 3)
1112                 *nbuffers = 3 - vq->num_buffers;
1113
1114         *nplanes = 1;
1115         sizes[0] = size;
1116         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
1117                  "nbuffers=%d, size=%lu\n", *nbuffers, size);
1118         return 0;
1119 }
1120
1121 /*
1122  * vpfe_buffer_prepare : callback function for buffer prepare
1123  * @vb: ptr to vb2_buffer
1124  *
1125  * This is the callback function for buffer prepare when vb2_qbuf()
1126  * function is called. The buffer is prepared and user space virtual address
1127  * or user address is converted into  physical address
1128  */
1129 static int vpfe_buffer_prepare(struct vb2_buffer *vb)
1130 {
1131         struct vpfe_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
1132         struct vpfe_video_device *video = fh->video;
1133         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1134         unsigned long addr;
1135
1136         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_buffer_prepare\n");
1137
1138         /* Initialize buffer */
1139         vb2_set_plane_payload(vb, 0, video->fmt.fmt.pix.sizeimage);
1140         if (vb2_plane_vaddr(vb, 0) &&
1141             vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0))
1142                 return -EINVAL;
1143
1144         addr = vb2_dma_contig_plane_dma_addr(vb, 0);
1145         /* Make sure user addresses are aligned to 32 bytes */
1146         if (!ALIGN(addr, 32))
1147                 return -EINVAL;
1148
1149         return 0;
1150 }
1151
1152 static void vpfe_buffer_queue(struct vb2_buffer *vb)
1153 {
1154         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1155         /* Get the file handle object and device object */
1156         struct vpfe_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
1157         struct vpfe_video_device *video = fh->video;
1158         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1159         struct vpfe_pipeline *pipe = &video->pipe;
1160         struct vpfe_cap_buffer *buf = container_of(vbuf,
1161                                 struct vpfe_cap_buffer, vb);
1162         unsigned long flags;
1163         unsigned long empty;
1164         unsigned long addr;
1165
1166         spin_lock_irqsave(&video->dma_queue_lock, flags);
1167         empty = list_empty(&video->dma_queue);
1168         /* add the buffer to the DMA queue */
1169         list_add_tail(&buf->list, &video->dma_queue);
1170         spin_unlock_irqrestore(&video->dma_queue_lock, flags);
1171         /* this case happens in case of single shot */
1172         if (empty && video->started && pipe->state ==
1173                 VPFE_PIPELINE_STREAM_SINGLESHOT &&
1174                 video->state == VPFE_VIDEO_BUFFER_NOT_QUEUED) {
1175                 spin_lock(&video->dma_queue_lock);
1176                 addr = vpfe_video_get_next_buffer(video);
1177                 video->ops->queue(vpfe_dev, addr);
1178
1179                 video->state = VPFE_VIDEO_BUFFER_QUEUED;
1180                 spin_unlock(&video->dma_queue_lock);
1181
1182                 /* enable h/w each time in single shot */
1183                 if (vpfe_video_is_pipe_ready(pipe))
1184                         vpfe_pipeline_set_stream(pipe,
1185                                         VPFE_PIPELINE_STREAM_SINGLESHOT);
1186         }
1187 }
1188
1189 /* vpfe_start_capture() - start streaming on all the subdevs */
1190 static int vpfe_start_capture(struct vpfe_video_device *video)
1191 {
1192         struct vpfe_pipeline *pipe = &video->pipe;
1193         int ret = 0;
1194
1195         video->started = 1;
1196         if (vpfe_video_is_pipe_ready(pipe))
1197                 ret = vpfe_pipeline_set_stream(pipe, pipe->state);
1198
1199         return ret;
1200 }
1201
1202 static int vpfe_start_streaming(struct vb2_queue *vq, unsigned int count)
1203 {
1204         struct vpfe_fh *fh = vb2_get_drv_priv(vq);
1205         struct vpfe_video_device *video = fh->video;
1206         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1207         unsigned long addr;
1208         int ret;
1209
1210         ret = mutex_lock_interruptible(&video->lock);
1211         if (ret)
1212                 goto streamoff;
1213
1214         /* Get the next frame from the buffer queue */
1215         video->cur_frm = video->next_frm =
1216                 list_entry(video->dma_queue.next, struct vpfe_cap_buffer, list);
1217         /* Remove buffer from the buffer queue */
1218         list_del(&video->cur_frm->list);
1219         /* Mark state of the current frame to active */
1220         video->cur_frm->vb.vb2_buf.state = VB2_BUF_STATE_ACTIVE;
1221         /* Initialize field_id and started member */
1222         video->field_id = 0;
1223         addr = vb2_dma_contig_plane_dma_addr(&video->cur_frm->vb.vb2_buf, 0);
1224         video->ops->queue(vpfe_dev, addr);
1225         video->state = VPFE_VIDEO_BUFFER_QUEUED;
1226
1227         ret = vpfe_start_capture(video);
1228         if (ret) {
1229                 struct vpfe_cap_buffer *buf, *tmp;
1230
1231                 vb2_buffer_done(&video->cur_frm->vb.vb2_buf,
1232                                 VB2_BUF_STATE_QUEUED);
1233                 list_for_each_entry_safe(buf, tmp, &video->dma_queue, list) {
1234                         list_del(&buf->list);
1235                         vb2_buffer_done(&buf->vb.vb2_buf,
1236                                         VB2_BUF_STATE_QUEUED);
1237                 }
1238                 goto unlock_out;
1239         }
1240
1241         mutex_unlock(&video->lock);
1242
1243         return ret;
1244 unlock_out:
1245         mutex_unlock(&video->lock);
1246 streamoff:
1247         ret = vb2_streamoff(&video->buffer_queue, video->buffer_queue.type);
1248         return 0;
1249 }
1250
1251 static int vpfe_buffer_init(struct vb2_buffer *vb)
1252 {
1253         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1254         struct vpfe_cap_buffer *buf = container_of(vbuf,
1255                                                    struct vpfe_cap_buffer, vb);
1256
1257         INIT_LIST_HEAD(&buf->list);
1258         return 0;
1259 }
1260
1261 /* abort streaming and wait for last buffer */
1262 static void vpfe_stop_streaming(struct vb2_queue *vq)
1263 {
1264         struct vpfe_fh *fh = vb2_get_drv_priv(vq);
1265         struct vpfe_video_device *video = fh->video;
1266
1267         /* release all active buffers */
1268         if (video->cur_frm == video->next_frm) {
1269                 vb2_buffer_done(&video->cur_frm->vb.vb2_buf,
1270                                 VB2_BUF_STATE_ERROR);
1271         } else {
1272                 if (video->cur_frm != NULL)
1273                         vb2_buffer_done(&video->cur_frm->vb.vb2_buf,
1274                                         VB2_BUF_STATE_ERROR);
1275                 if (video->next_frm != NULL)
1276                         vb2_buffer_done(&video->next_frm->vb.vb2_buf,
1277                                         VB2_BUF_STATE_ERROR);
1278         }
1279
1280         while (!list_empty(&video->dma_queue)) {
1281                 video->next_frm = list_entry(video->dma_queue.next,
1282                                                 struct vpfe_cap_buffer, list);
1283                 list_del(&video->next_frm->list);
1284                 vb2_buffer_done(&video->next_frm->vb.vb2_buf,
1285                                 VB2_BUF_STATE_ERROR);
1286         }
1287 }
1288
1289 static void vpfe_buf_cleanup(struct vb2_buffer *vb)
1290 {
1291         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1292         struct vpfe_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
1293         struct vpfe_video_device *video = fh->video;
1294         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1295         struct vpfe_cap_buffer *buf = container_of(vbuf,
1296                                         struct vpfe_cap_buffer, vb);
1297
1298         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_buf_cleanup\n");
1299         if (vb->state == VB2_BUF_STATE_ACTIVE)
1300                 list_del_init(&buf->list);
1301 }
1302
1303 static const struct vb2_ops video_qops = {
1304         .queue_setup            = vpfe_buffer_queue_setup,
1305         .buf_init               = vpfe_buffer_init,
1306         .buf_prepare            = vpfe_buffer_prepare,
1307         .start_streaming        = vpfe_start_streaming,
1308         .stop_streaming         = vpfe_stop_streaming,
1309         .buf_cleanup            = vpfe_buf_cleanup,
1310         .buf_queue              = vpfe_buffer_queue,
1311         .wait_prepare           = vb2_ops_wait_prepare,
1312         .wait_finish            = vb2_ops_wait_finish,
1313 };
1314
1315 /*
1316  * vpfe_reqbufs() - supported REQBUF only once opening
1317  * the device.
1318  */
1319 static int vpfe_reqbufs(struct file *file, void *priv,
1320                         struct v4l2_requestbuffers *req_buf)
1321 {
1322         struct vpfe_video_device *video = video_drvdata(file);
1323         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1324         struct vpfe_fh *fh = file->private_data;
1325         struct vb2_queue *q;
1326         int ret;
1327
1328         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_reqbufs\n");
1329
1330         if (req_buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1331             req_buf->type != V4L2_BUF_TYPE_VIDEO_OUTPUT){
1332                 v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buffer type\n");
1333                 return -EINVAL;
1334         }
1335
1336         ret = mutex_lock_interruptible(&video->lock);
1337         if (ret)
1338                 return ret;
1339
1340         if (video->io_usrs != 0) {
1341                 v4l2_err(&vpfe_dev->v4l2_dev, "Only one IO user allowed\n");
1342                 ret = -EBUSY;
1343                 goto unlock_out;
1344         }
1345         video->memory = req_buf->memory;
1346
1347         /* Initialize videobuf2 queue as per the buffer type */
1348         q = &video->buffer_queue;
1349         q->type = req_buf->type;
1350         q->io_modes = VB2_MMAP | VB2_USERPTR;
1351         q->drv_priv = fh;
1352         q->min_buffers_needed = 1;
1353         q->ops = &video_qops;
1354         q->mem_ops = &vb2_dma_contig_memops;
1355         q->buf_struct_size = sizeof(struct vpfe_cap_buffer);
1356         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1357         q->dev = vpfe_dev->pdev;
1358         q->lock = &video->lock;
1359
1360         ret = vb2_queue_init(q);
1361         if (ret) {
1362                 v4l2_err(&vpfe_dev->v4l2_dev, "vb2_queue_init() failed\n");
1363                 goto unlock_out;
1364         }
1365
1366         fh->io_allowed = 1;
1367         video->io_usrs = 1;
1368         INIT_LIST_HEAD(&video->dma_queue);
1369         ret = vb2_reqbufs(&video->buffer_queue, req_buf);
1370
1371 unlock_out:
1372         mutex_unlock(&video->lock);
1373         return ret;
1374 }
1375
1376 /*
1377  * vpfe_querybuf() - query buffers for exchange
1378  */
1379 static int vpfe_querybuf(struct file *file, void *priv,
1380                          struct v4l2_buffer *buf)
1381 {
1382         struct vpfe_video_device *video = video_drvdata(file);
1383         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1384
1385         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querybuf\n");
1386
1387         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1388             buf->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1389                 v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
1390                 return  -EINVAL;
1391         }
1392
1393         if (video->memory != V4L2_MEMORY_MMAP) {
1394                 v4l2_err(&vpfe_dev->v4l2_dev, "Invalid memory\n");
1395                 return -EINVAL;
1396         }
1397
1398         /* Call vb2_querybuf to get information */
1399         return vb2_querybuf(&video->buffer_queue, buf);
1400 }
1401
1402 /*
1403  * vpfe_qbuf() - queue buffers for capture or processing
1404  */
1405 static int vpfe_qbuf(struct file *file, void *priv,
1406                      struct v4l2_buffer *p)
1407 {
1408         struct vpfe_video_device *video = video_drvdata(file);
1409         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1410         struct vpfe_fh *fh = file->private_data;
1411
1412         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_qbuf\n");
1413
1414         if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1415             p->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1416                 v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
1417                 return -EINVAL;
1418         }
1419         /*
1420          * If this file handle is not allowed to do IO,
1421          * return error
1422          */
1423         if (!fh->io_allowed) {
1424                 v4l2_err(&vpfe_dev->v4l2_dev, "fh->io_allowed\n");
1425                 return -EACCES;
1426         }
1427
1428         return vb2_qbuf(&video->buffer_queue,
1429                         video->video_dev.v4l2_dev->mdev, p);
1430 }
1431
1432 /*
1433  * vpfe_dqbuf() - deque buffer which is done with processing
1434  */
1435 static int vpfe_dqbuf(struct file *file, void *priv,
1436                       struct v4l2_buffer *buf)
1437 {
1438         struct vpfe_video_device *video = video_drvdata(file);
1439         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1440
1441         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_dqbuf\n");
1442
1443         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1444             buf->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1445                 v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
1446                 return -EINVAL;
1447         }
1448
1449         return vb2_dqbuf(&video->buffer_queue,
1450                          buf, (file->f_flags & O_NONBLOCK));
1451 }
1452
1453 /*
1454  * vpfe_streamon() - start streaming
1455  * @file: file pointer
1456  * @priv: void pointer
1457  * @buf_type: enum v4l2_buf_type
1458  *
1459  * queue buffer onto hardware for capture/processing and
1460  * start all the subdevs which are in media chain
1461  *
1462  * Return 0 on success, error code otherwise
1463  */
1464 static int vpfe_streamon(struct file *file, void *priv,
1465                          enum v4l2_buf_type buf_type)
1466 {
1467         struct vpfe_video_device *video = video_drvdata(file);
1468         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1469         struct vpfe_pipeline *pipe = &video->pipe;
1470         struct vpfe_fh *fh = file->private_data;
1471         int ret = -EINVAL;
1472
1473         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_streamon\n");
1474
1475         if (buf_type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1476             buf_type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1477                 v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
1478                 return ret;
1479         }
1480         /* If file handle is not allowed IO, return error */
1481         if (!fh->io_allowed) {
1482                 v4l2_err(&vpfe_dev->v4l2_dev, "fh->io_allowed\n");
1483                 return -EACCES;
1484         }
1485         /* If buffer queue is empty, return error */
1486         if (list_empty(&video->buffer_queue.queued_list)) {
1487                 v4l2_err(&vpfe_dev->v4l2_dev, "buffer queue is empty\n");
1488                 return -EIO;
1489         }
1490         /* Validate the pipeline */
1491         if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1492                 ret = vpfe_video_validate_pipeline(pipe);
1493                 if (ret < 0)
1494                         return ret;
1495         }
1496         /* Call vb2_streamon to start streaming */
1497         return vb2_streamon(&video->buffer_queue, buf_type);
1498 }
1499
1500 /*
1501  * vpfe_streamoff() - stop streaming
1502  * @file: file pointer
1503  * @priv: void pointer
1504  * @buf_type: enum v4l2_buf_type
1505  *
1506  * stop all the subdevs which are in media chain
1507  *
1508  * Return 0 on success, error code otherwise
1509  */
1510 static int vpfe_streamoff(struct file *file, void *priv,
1511                           enum v4l2_buf_type buf_type)
1512 {
1513         struct vpfe_video_device *video = video_drvdata(file);
1514         struct vpfe_device *vpfe_dev = video->vpfe_dev;
1515         struct vpfe_fh *fh = file->private_data;
1516         int ret = 0;
1517
1518         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_streamoff\n");
1519
1520         if (buf_type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1521             buf_type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1522                 v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "Invalid buf type\n");
1523                 return -EINVAL;
1524         }
1525
1526         /* If io is allowed for this file handle, return error */
1527         if (!fh->io_allowed) {
1528                 v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "fh->io_allowed\n");
1529                 return -EACCES;
1530         }
1531
1532         /* If streaming is not started, return error */
1533         if (!video->started) {
1534                 v4l2_err(&vpfe_dev->v4l2_dev, "device is not started\n");
1535                 return -EINVAL;
1536         }
1537
1538         ret = mutex_lock_interruptible(&video->lock);
1539         if (ret)
1540                 return ret;
1541
1542         vpfe_stop_capture(video);
1543         ret = vb2_streamoff(&video->buffer_queue, buf_type);
1544         mutex_unlock(&video->lock);
1545
1546         return ret;
1547 }
1548
1549 /* vpfe capture ioctl operations */
1550 static const struct v4l2_ioctl_ops vpfe_ioctl_ops = {
1551         .vidioc_querycap         = vpfe_querycap,
1552         .vidioc_g_fmt_vid_cap    = vpfe_g_fmt,
1553         .vidioc_s_fmt_vid_cap    = vpfe_s_fmt,
1554         .vidioc_try_fmt_vid_cap  = vpfe_try_fmt,
1555         .vidioc_enum_fmt_vid_cap = vpfe_enum_fmt,
1556         .vidioc_g_fmt_vid_out    = vpfe_g_fmt,
1557         .vidioc_s_fmt_vid_out    = vpfe_s_fmt,
1558         .vidioc_try_fmt_vid_out  = vpfe_try_fmt,
1559         .vidioc_enum_fmt_vid_out = vpfe_enum_fmt,
1560         .vidioc_enum_input       = vpfe_enum_input,
1561         .vidioc_g_input          = vpfe_g_input,
1562         .vidioc_s_input          = vpfe_s_input,
1563         .vidioc_querystd         = vpfe_querystd,
1564         .vidioc_s_std            = vpfe_s_std,
1565         .vidioc_g_std            = vpfe_g_std,
1566         .vidioc_enum_dv_timings  = vpfe_enum_dv_timings,
1567         .vidioc_query_dv_timings = vpfe_query_dv_timings,
1568         .vidioc_s_dv_timings     = vpfe_s_dv_timings,
1569         .vidioc_g_dv_timings     = vpfe_g_dv_timings,
1570         .vidioc_reqbufs          = vpfe_reqbufs,
1571         .vidioc_querybuf         = vpfe_querybuf,
1572         .vidioc_qbuf             = vpfe_qbuf,
1573         .vidioc_dqbuf            = vpfe_dqbuf,
1574         .vidioc_streamon         = vpfe_streamon,
1575         .vidioc_streamoff        = vpfe_streamoff,
1576 };
1577
1578 /* VPFE video init function */
1579 int vpfe_video_init(struct vpfe_video_device *video, const char *name)
1580 {
1581         const char *direction;
1582         int ret;
1583
1584         switch (video->type) {
1585         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1586                 direction = "output";
1587                 video->pad.flags = MEDIA_PAD_FL_SINK;
1588                 video->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1589                 break;
1590
1591         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1592                 direction = "input";
1593                 video->pad.flags = MEDIA_PAD_FL_SOURCE;
1594                 video->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
1595                 break;
1596
1597         default:
1598                 return -EINVAL;
1599         }
1600         /* Initialize field of video device */
1601         mutex_init(&video->lock);
1602         video->video_dev.release = video_device_release;
1603         video->video_dev.fops = &vpfe_fops;
1604         video->video_dev.ioctl_ops = &vpfe_ioctl_ops;
1605         video->video_dev.minor = -1;
1606         video->video_dev.tvnorms = 0;
1607         video->video_dev.lock = &video->lock;
1608         snprintf(video->video_dev.name, sizeof(video->video_dev.name),
1609                  "DAVINCI VIDEO %s %s", name, direction);
1610
1611         spin_lock_init(&video->irqlock);
1612         spin_lock_init(&video->dma_queue_lock);
1613         ret = media_entity_pads_init(&video->video_dev.entity,
1614                                 1, &video->pad);
1615         if (ret < 0)
1616                 return ret;
1617
1618         video_set_drvdata(&video->video_dev, video);
1619
1620         return 0;
1621 }
1622
1623 /* vpfe video device register function */
1624 int vpfe_video_register(struct vpfe_video_device *video,
1625                         struct v4l2_device *vdev)
1626 {
1627         int ret;
1628
1629         video->video_dev.v4l2_dev = vdev;
1630
1631         ret = video_register_device(&video->video_dev, VFL_TYPE_GRABBER, -1);
1632         if (ret < 0)
1633                 pr_err("%s: could not register video device (%d)\n",
1634                        __func__, ret);
1635         return ret;
1636 }
1637
1638 /* vpfe video device unregister function */
1639 void vpfe_video_unregister(struct vpfe_video_device *video)
1640 {
1641         if (video_is_registered(&video->video_dev)) {
1642                 video_unregister_device(&video->video_dev);
1643                 media_entity_cleanup(&video->video_dev.entity);
1644         }
1645 }