2 * Copyright (C) 2012 Texas Instruments Inc
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.
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.
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
18 * Manjunath Hadli <manjunath.hadli@ti.com>
19 * Prabhakar Lad <prabhakar.lad@ti.com>
22 #include <linux/module.h>
23 #include <linux/slab.h>
25 #include <media/v4l2-ioctl.h>
28 #include "vpfe_mc_capture.h"
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
)
36 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
37 struct media_pad
*remote
;
39 remote
= media_entity_remote_pad(&vpfe_dev
->vpfe_isif
.pads
[0]);
41 pr_err("Invalid media connection to isif/ccdc\n");
44 return remote
->entity
;
47 /* updates external subdev(sensor/decoder) which is active */
48 static int vpfe_update_current_ext_subdev(struct vpfe_video_device
*video
)
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
;
56 remote
= media_entity_remote_pad(&vpfe_dev
->vpfe_isif
.pads
[0]);
58 pr_err("Invalid media connection to isif/ccdc\n");
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
];
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");
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
];
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
)
89 struct media_pad
*remote
= media_entity_remote_pad(&video
->pad
);
91 if (!remote
|| !is_media_entity_v4l2_subdev(remote
->entity
))
95 return media_entity_to_v4l2_subdev(remote
->entity
);
98 /* get the format set at output pad of the adjacent subdev */
100 __vpfe_video_get_format(struct vpfe_video_device
*video
,
101 struct v4l2_format
*format
)
103 struct v4l2_subdev_format fmt
;
104 struct v4l2_subdev
*subdev
;
105 struct media_pad
*remote
;
109 subdev
= vpfe_video_remote_subdev(video
, &pad
);
113 fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
114 remote
= media_entity_remote_pad(&video
->pad
);
115 fmt
.pad
= remote
->index
;
117 ret
= v4l2_subdev_call(subdev
, pad
, get_fmt
, NULL
, &fmt
);
118 if (ret
== -ENOIOCTLCMD
)
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
);
129 /* make a note of pipeline details */
130 static int vpfe_prepare_pipeline(struct vpfe_video_device
*video
)
132 struct media_entity_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
;
140 pipe
->output_num
= 0;
142 if (video
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
143 pipe
->inputs
[pipe
->input_num
++] = video
;
145 pipe
->outputs
[pipe
->output_num
++] = video
;
147 mutex_lock(&mdev
->graph_mutex
);
148 ret
= media_entity_graph_walk_init(&graph
, entity
->graph_obj
.mdev
);
150 mutex_unlock(&video
->lock
);
153 media_entity_graph_walk_start(&graph
, entity
);
154 while ((entity
= media_entity_graph_walk_next(&graph
))) {
155 if (entity
== &video
->video_dev
.entity
)
157 if (!is_media_entity_v4l2_io(entity
))
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
;
163 pipe
->outputs
[pipe
->output_num
++] = far_end
;
165 media_entity_graph_walk_cleanup(&graph
);
166 mutex_unlock(&mdev
->graph_mutex
);
171 /* update pipe state selected by user */
172 static int vpfe_update_pipe_state(struct vpfe_video_device
*video
)
174 struct vpfe_pipeline
*pipe
= &video
->pipe
;
177 ret
= vpfe_prepare_pipeline(video
);
181 /* Find out if there is any input video
182 if yes, it is single shot.
184 if (pipe
->input_num
== 0) {
185 pipe
->state
= VPFE_PIPELINE_STREAM_CONTINUOUS
;
186 ret
= vpfe_update_current_ext_subdev(video
);
188 pr_err("Invalid external subdev\n");
192 pipe
->state
= VPFE_PIPELINE_STREAM_SINGLESHOT
;
194 video
->initialized
= 1;
195 video
->skip_frame_count
= 1;
196 video
->skip_frame_count_init
= 1;
200 /* checks wether pipeline is ready for enabling */
201 int vpfe_video_is_pipe_ready(struct vpfe_pipeline
*pipe
)
205 for (i
= 0; i
< pipe
->input_num
; i
++)
206 if (!pipe
->inputs
[i
]->started
||
207 pipe
->inputs
[i
]->state
!= VPFE_VIDEO_BUFFER_QUEUED
)
209 for (i
= 0; i
< pipe
->output_num
; i
++)
210 if (!pipe
->outputs
[i
]->started
||
211 pipe
->outputs
[i
]->state
!= VPFE_VIDEO_BUFFER_QUEUED
)
217 * Validate a pipeline by checking both ends of all links for format
220 * Return 0 if all formats match, or -EPIPE if at least one link is found with
221 * different formats on its two ends.
223 static int vpfe_video_validate_pipeline(struct vpfe_pipeline
*pipe
)
225 struct v4l2_subdev_format fmt_source
;
226 struct v4l2_subdev_format fmt_sink
;
227 struct v4l2_subdev
*subdev
;
228 struct media_pad
*pad
;
232 * Should not matter if it is output[0] or 1 as
233 * the general ideas is to traverse backwards and
234 * the fact that the out video node always has the
235 * format of the connected pad.
237 subdev
= vpfe_video_remote_subdev(pipe
->outputs
[0], NULL
);
242 /* Retrieve the sink format */
243 pad
= &subdev
->entity
.pads
[0];
244 if (!(pad
->flags
& MEDIA_PAD_FL_SINK
))
247 fmt_sink
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
248 fmt_sink
.pad
= pad
->index
;
249 ret
= v4l2_subdev_call(subdev
, pad
, get_fmt
, NULL
,
252 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
255 /* Retrieve the source format */
256 pad
= media_entity_remote_pad(pad
);
257 if (!pad
|| !is_media_entity_v4l2_subdev(pad
->entity
))
260 subdev
= media_entity_to_v4l2_subdev(pad
->entity
);
262 fmt_source
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
263 fmt_source
.pad
= pad
->index
;
264 ret
= v4l2_subdev_call(subdev
, pad
, get_fmt
, NULL
, &fmt_source
);
265 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
268 /* Check if the two ends match */
269 if (fmt_source
.format
.code
!= fmt_sink
.format
.code
||
270 fmt_source
.format
.width
!= fmt_sink
.format
.width
||
271 fmt_source
.format
.height
!= fmt_sink
.format
.height
)
278 * vpfe_pipeline_enable() - Enable streaming on a pipeline
279 * @vpfe_dev: vpfe device
280 * @pipe: vpfe pipeline
282 * Walk the entities chain starting at the pipeline output video node and start
283 * all modules in the chain in the given mode.
285 * Return 0 if successful, or the return value of the failed video::s_stream
286 * operation otherwise.
288 static int vpfe_pipeline_enable(struct vpfe_pipeline
*pipe
)
290 struct media_entity
*entity
;
291 struct v4l2_subdev
*subdev
;
292 struct media_device
*mdev
;
295 if (pipe
->state
== VPFE_PIPELINE_STREAM_CONTINUOUS
)
296 entity
= vpfe_get_input_entity(pipe
->outputs
[0]);
298 entity
= &pipe
->inputs
[0]->video_dev
.entity
;
300 mdev
= entity
->graph_obj
.mdev
;
301 mutex_lock(&mdev
->graph_mutex
);
302 ret
= media_entity_graph_walk_init(&pipe
->graph
,
303 entity
->graph_obj
.mdev
);
306 media_entity_graph_walk_start(&pipe
->graph
, entity
);
307 while ((entity
= media_entity_graph_walk_next(&pipe
->graph
))) {
309 if (!is_media_entity_v4l2_subdev(entity
))
311 subdev
= media_entity_to_v4l2_subdev(entity
);
312 ret
= v4l2_subdev_call(subdev
, video
, s_stream
, 1);
313 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
318 media_entity_graph_walk_cleanup(&pipe
->graph
);
319 mutex_unlock(&mdev
->graph_mutex
);
324 * vpfe_pipeline_disable() - Disable streaming on a pipeline
325 * @vpfe_dev: vpfe device
326 * @pipe: VPFE pipeline
328 * Walk the entities chain starting at the pipeline output video node and stop
329 * all modules in the chain.
331 * Return 0 if all modules have been properly stopped, or -ETIMEDOUT if a module
334 static int vpfe_pipeline_disable(struct vpfe_pipeline
*pipe
)
336 struct media_entity
*entity
;
337 struct v4l2_subdev
*subdev
;
338 struct media_device
*mdev
;
341 if (pipe
->state
== VPFE_PIPELINE_STREAM_CONTINUOUS
)
342 entity
= vpfe_get_input_entity(pipe
->outputs
[0]);
344 entity
= &pipe
->inputs
[0]->video_dev
.entity
;
346 mdev
= entity
->graph_obj
.mdev
;
347 mutex_lock(&mdev
->graph_mutex
);
348 media_entity_graph_walk_start(&pipe
->graph
, entity
);
350 while ((entity
= media_entity_graph_walk_next(&pipe
->graph
))) {
352 if (!is_media_entity_v4l2_subdev(entity
))
354 subdev
= media_entity_to_v4l2_subdev(entity
);
355 ret
= v4l2_subdev_call(subdev
, video
, s_stream
, 0);
356 if (ret
< 0 && ret
!= -ENOIOCTLCMD
)
359 mutex_unlock(&mdev
->graph_mutex
);
361 media_entity_graph_walk_cleanup(&pipe
->graph
);
362 return ret
? -ETIMEDOUT
: 0;
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)
371 * Set the pipeline to the given stream state.
373 * Return 0 if successful, or the return value of the failed video::s_stream
374 * operation otherwise.
376 static int vpfe_pipeline_set_stream(struct vpfe_pipeline
*pipe
,
377 enum vpfe_pipeline_stream_state state
)
379 if (state
== VPFE_PIPELINE_STREAM_STOPPED
)
380 return vpfe_pipeline_disable(pipe
);
382 return vpfe_pipeline_enable(pipe
);
385 static int all_videos_stopped(struct vpfe_video_device
*video
)
387 struct vpfe_pipeline
*pipe
= &video
->pipe
;
390 for (i
= 0; i
< pipe
->input_num
; i
++)
391 if (pipe
->inputs
[i
]->started
)
393 for (i
= 0; i
< pipe
->output_num
; i
++)
394 if (pipe
->outputs
[i
]->started
)
400 * vpfe_open() - open video device
401 * @file: file pointer
403 * initialize media pipeline state, allocate memory for file handle
405 * Return 0 if successful, or the return -ENODEV otherwise.
407 static int vpfe_open(struct file
*file
)
409 struct vpfe_video_device
*video
= video_drvdata(file
);
410 struct vpfe_fh
*handle
;
412 /* Allocate memory for the file handle object */
413 handle
= kzalloc(sizeof(struct vpfe_fh
), GFP_KERNEL
);
418 v4l2_fh_init(&handle
->vfh
, &video
->video_dev
);
419 v4l2_fh_add(&handle
->vfh
);
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
);
427 /* Increment device users counter */
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
);
438 /* get the next buffer available from dma queue */
440 vpfe_video_get_next_buffer(struct vpfe_video_device
*video
)
442 video
->cur_frm
= video
->next_frm
=
443 list_entry(video
->dma_queue
.next
,
444 struct vpfe_cap_buffer
, list
);
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);
451 /* schedule the next buffer which is available on dma queue */
452 void vpfe_video_schedule_next_buffer(struct vpfe_video_device
*video
)
454 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
457 if (list_empty(&video
->dma_queue
))
460 video
->next_frm
= list_entry(video
->dma_queue
.next
,
461 struct vpfe_cap_buffer
, list
);
463 if (VPFE_PIPELINE_STREAM_SINGLESHOT
== video
->pipe
.state
)
464 video
->cur_frm
= video
->next_frm
;
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
;
473 /* schedule the buffer for capturing bottom field */
474 void vpfe_video_schedule_bottom_field(struct vpfe_video_device
*video
)
476 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
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
);
484 /* make buffer available for dequeue */
485 void vpfe_video_process_buffer_complete(struct vpfe_video_device
*video
)
487 struct vpfe_pipeline
*pipe
= &video
->pipe
;
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
;
495 /* vpfe_stop_capture() - stop streaming */
496 static void vpfe_stop_capture(struct vpfe_video_device
*video
)
498 struct vpfe_pipeline
*pipe
= &video
->pipe
;
502 if (video
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
504 if (all_videos_stopped(video
))
505 vpfe_pipeline_set_stream(pipe
,
506 VPFE_PIPELINE_STREAM_STOPPED
);
510 * vpfe_release() - release video device
511 * @file: file pointer
513 * deletes buffer queue, frees the buffers and the vpfe file handle
517 static int vpfe_release(struct file
*file
)
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
);
524 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_release\n");
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 /* mark pipe state as stopped in vpfe_release(),
533 as app might call streamon() after streamoff()
534 in which case driver has to start streaming.
536 video
->pipe
.state
= VPFE_PIPELINE_STREAM_STOPPED
;
537 vb2_streamoff(&video
->buffer_queue
,
538 video
->buffer_queue
.type
);
541 /* Free buffers allocated */
542 vb2_queue_release(&video
->buffer_queue
);
543 vb2_dma_contig_cleanup_ctx(video
->alloc_ctx
);
545 /* Decrement device users counter */
547 v4l2_fh_del(&fh
->vfh
);
548 v4l2_fh_exit(&fh
->vfh
);
549 /* If this is the last file handle */
551 video
->initialized
= 0;
552 mutex_unlock(&video
->lock
);
553 file
->private_data
= NULL
;
554 /* Free memory allocated to file handle object */
561 * vpfe_mmap() - It is used to map kernel space buffers
564 static int vpfe_mmap(struct file
*file
, struct vm_area_struct
*vma
)
566 struct vpfe_video_device
*video
= video_drvdata(file
);
567 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
569 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_mmap\n");
570 return vb2_mmap(&video
->buffer_queue
, vma
);
574 * vpfe_poll() - It is used for select/poll system call
576 static unsigned int vpfe_poll(struct file
*file
, poll_table
*wait
)
578 struct vpfe_video_device
*video
= video_drvdata(file
);
579 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
581 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_poll\n");
583 return vb2_poll(&video
->buffer_queue
, file
, wait
);
587 /* vpfe capture driver file operations */
588 static const struct v4l2_file_operations vpfe_fops
= {
589 .owner
= THIS_MODULE
,
591 .release
= vpfe_release
,
592 .unlocked_ioctl
= video_ioctl2
,
598 * vpfe_querycap() - query capabilities of video device
599 * @file: file pointer
600 * @priv: void pointer
601 * @cap: pointer to v4l2_capability structure
603 * fills v4l2 capabilities structure
607 static int vpfe_querycap(struct file
*file
, void *priv
,
608 struct v4l2_capability
*cap
)
610 struct vpfe_video_device
*video
= video_drvdata(file
);
611 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
613 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_querycap\n");
615 if (video
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
616 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_STREAMING
;
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 strlcpy(cap
->driver
, CAPTURE_DRV_NAME
, sizeof(cap
->driver
));
622 strlcpy(cap
->bus_info
, "VPFE", sizeof(cap
->bus_info
));
623 strlcpy(cap
->card
, vpfe_dev
->cfg
->card_name
, sizeof(cap
->card
));
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
634 * fills v4l2 format structure with active format
638 static int vpfe_g_fmt(struct file
*file
, void *priv
,
639 struct v4l2_format
*fmt
)
641 struct vpfe_video_device
*video
= video_drvdata(file
);
642 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
644 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_g_fmt\n");
645 /* Fill in the information about format */
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
656 * fills v4l2_fmtdesc structure with output format set on adjacent subdev,
657 * only one format is enumearted as subdevs are already configured
659 * Return 0 if successful, error code otherwise
661 static int vpfe_enum_fmt(struct file
*file
, void *priv
,
662 struct v4l2_fmtdesc
*fmt
)
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
;
673 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_enum_fmt\n");
675 /* since already subdev pad format is set,
676 only one pixel format is available */
677 if (fmt
->index
> 0) {
678 v4l2_err(&vpfe_dev
->v4l2_dev
, "Invalid index\n");
681 /* get the remote pad */
682 remote
= media_entity_remote_pad(&video
->pad
);
683 if (remote
== NULL
) {
684 v4l2_err(&vpfe_dev
->v4l2_dev
,
685 "invalid remote pad for video node\n");
688 /* get the remote subdev */
689 subdev
= vpfe_video_remote_subdev(video
, NULL
);
690 if (subdev
== NULL
) {
691 v4l2_err(&vpfe_dev
->v4l2_dev
,
692 "invalid remote subdev for video node\n");
695 sd_fmt
.pad
= remote
->index
;
696 sd_fmt
.which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
697 /* get output format of remote subdev */
698 ret
= v4l2_subdev_call(subdev
, pad
, get_fmt
, NULL
, &sd_fmt
);
700 v4l2_err(&vpfe_dev
->v4l2_dev
,
701 "invalid remote subdev for video node\n");
704 /* convert to pix format */
705 mbus
.code
= sd_fmt
.format
.code
;
706 mbus_to_pix(&mbus
, &format
.fmt
.pix
);
707 /* copy the result */
708 fmt
->pixelformat
= format
.fmt
.pix
.pixelformat
;
714 * vpfe_s_fmt() - set the format on video device
715 * @file: file pointer
716 * @priv: void pointer
717 * @fmt: pointer to v4l2_format structure
719 * validate and set the format on video device
721 * Return 0 on success, error code otherwise
723 static int vpfe_s_fmt(struct file
*file
, void *priv
,
724 struct v4l2_format
*fmt
)
726 struct vpfe_video_device
*video
= video_drvdata(file
);
727 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
728 struct v4l2_format format
;
731 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_s_fmt\n");
732 /* If streaming is started, return error */
733 if (video
->started
) {
734 v4l2_err(&vpfe_dev
->v4l2_dev
, "Streaming is started\n");
737 /* get adjacent subdev's output pad format */
738 ret
= __vpfe_video_get_format(video
, &format
);
747 * vpfe_try_fmt() - try the format on video device
748 * @file: file pointer
749 * @priv: void pointer
750 * @fmt: pointer to v4l2_format structure
752 * validate the format, update with correct format
753 * based on output format set on adjacent subdev
755 * Return 0 on success, error code otherwise
757 static int vpfe_try_fmt(struct file
*file
, void *priv
,
758 struct v4l2_format
*fmt
)
760 struct vpfe_video_device
*video
= video_drvdata(file
);
761 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
762 struct v4l2_format format
;
765 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_try_fmt\n");
766 /* get adjacent subdev's output pad format */
767 ret
= __vpfe_video_get_format(video
, &format
);
776 * vpfe_enum_input() - enum inputs supported on media chain
777 * @file: file pointer
778 * @priv: void pointer
779 * @fmt: pointer to v4l2_fmtdesc structure
781 * fills v4l2_input structure with input available on media chain,
782 * only one input is enumearted as media chain is setup by this time
784 * Return 0 if successful, -EINVAL is media chain is invalid
786 static int vpfe_enum_input(struct file
*file
, void *priv
,
787 struct v4l2_input
*inp
)
789 struct vpfe_video_device
*video
= video_drvdata(file
);
790 struct vpfe_ext_subdev_info
*sdinfo
= video
->current_ext_subdev
;
791 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
793 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_enum_input\n");
794 /* enumerate from the subdev user has chosen through mc */
795 if (inp
->index
< sdinfo
->num_inputs
) {
796 memcpy(inp
, &sdinfo
->inputs
[inp
->index
],
797 sizeof(struct v4l2_input
));
804 * vpfe_g_input() - get index of the input which is active
805 * @file: file pointer
806 * @priv: void pointer
807 * @index: pointer to unsigned int
809 * set index with input index which is active
811 static int vpfe_g_input(struct file
*file
, void *priv
, unsigned int *index
)
813 struct vpfe_video_device
*video
= video_drvdata(file
);
814 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
816 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_g_input\n");
818 *index
= video
->current_input
;
823 * vpfe_s_input() - set input which is pointed by input index
824 * @file: file pointer
825 * @priv: void pointer
826 * @index: pointer to unsigned int
828 * set input on external subdev
830 * Return 0 on success, error code otherwise
832 static int vpfe_s_input(struct file
*file
, void *priv
, unsigned int index
)
834 struct vpfe_video_device
*video
= video_drvdata(file
);
835 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
836 struct vpfe_ext_subdev_info
*sdinfo
;
837 struct vpfe_route
*route
;
838 struct v4l2_input
*inps
;
844 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_s_input\n");
846 ret
= mutex_lock_interruptible(&video
->lock
);
850 * If streaming is started return device busy
853 if (video
->started
) {
854 v4l2_err(&vpfe_dev
->v4l2_dev
, "Streaming is on\n");
859 sdinfo
= video
->current_ext_subdev
;
860 if (!sdinfo
->registered
) {
864 if (vpfe_dev
->cfg
->setup_input
&&
865 vpfe_dev
->cfg
->setup_input(sdinfo
->grp_id
) < 0) {
867 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
,
868 "couldn't setup input for %s\n",
869 sdinfo
->module_name
);
872 route
= &sdinfo
->routes
[index
];
873 if (route
&& sdinfo
->can_route
) {
874 input
= route
->input
;
875 output
= route
->output
;
876 ret
= v4l2_device_call_until_err(&vpfe_dev
->v4l2_dev
,
877 sdinfo
->grp_id
, video
,
878 s_routing
, input
, output
, 0);
880 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
,
881 "s_input:error in setting input in decoder\n");
886 /* set standards set by subdev in video device */
887 for (i
= 0; i
< sdinfo
->num_inputs
; i
++) {
888 inps
= &sdinfo
->inputs
[i
];
889 video
->video_dev
.tvnorms
|= inps
->std
;
891 video
->current_input
= index
;
893 mutex_unlock(&video
->lock
);
898 * vpfe_querystd() - query std which is being input on external subdev
899 * @file: file pointer
900 * @priv: void pointer
901 * @std_id: pointer to v4l2_std_id structure
903 * call external subdev through v4l2_device_call_until_err to
904 * get the std that is being active.
906 * Return 0 on success, error code otherwise
908 static int vpfe_querystd(struct file
*file
, void *priv
, v4l2_std_id
*std_id
)
910 struct vpfe_video_device
*video
= video_drvdata(file
);
911 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
912 struct vpfe_ext_subdev_info
*sdinfo
;
915 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_querystd\n");
917 ret
= mutex_lock_interruptible(&video
->lock
);
918 sdinfo
= video
->current_ext_subdev
;
921 /* Call querystd function of decoder device */
922 ret
= v4l2_device_call_until_err(&vpfe_dev
->v4l2_dev
, sdinfo
->grp_id
,
923 video
, querystd
, std_id
);
924 mutex_unlock(&video
->lock
);
929 * vpfe_s_std() - set std on external subdev
930 * @file: file pointer
931 * @priv: void pointer
932 * @std_id: pointer to v4l2_std_id structure
934 * set std pointed by std_id on external subdev by calling it using
935 * v4l2_device_call_until_err
937 * Return 0 on success, error code otherwise
939 static int vpfe_s_std(struct file
*file
, void *priv
, v4l2_std_id std_id
)
941 struct vpfe_video_device
*video
= video_drvdata(file
);
942 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
943 struct vpfe_ext_subdev_info
*sdinfo
;
946 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_s_std\n");
948 /* Call decoder driver function to set the standard */
949 ret
= mutex_lock_interruptible(&video
->lock
);
952 sdinfo
= video
->current_ext_subdev
;
953 /* If streaming is started, return device busy error */
954 if (video
->started
) {
955 v4l2_err(&vpfe_dev
->v4l2_dev
, "streaming is started\n");
959 ret
= v4l2_device_call_until_err(&vpfe_dev
->v4l2_dev
, sdinfo
->grp_id
,
960 video
, s_std
, std_id
);
962 v4l2_err(&vpfe_dev
->v4l2_dev
, "Failed to set standard\n");
963 video
->stdid
= V4L2_STD_UNKNOWN
;
966 video
->stdid
= std_id
;
968 mutex_unlock(&video
->lock
);
972 static int vpfe_g_std(struct file
*file
, void *priv
, v4l2_std_id
*tvnorm
)
974 struct vpfe_video_device
*video
= video_drvdata(file
);
975 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
977 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_g_std\n");
978 *tvnorm
= video
->stdid
;
983 * vpfe_enum_dv_timings() - enumerate dv_timings which are supported by
985 * @file: file pointer
986 * @priv: void pointer
987 * @timings: pointer to v4l2_enum_dv_timings structure
989 * enum dv_timings's which are supported by external subdev through
992 * Return 0 on success, error code otherwise
995 vpfe_enum_dv_timings(struct file
*file
, void *fh
,
996 struct v4l2_enum_dv_timings
*timings
)
998 struct vpfe_video_device
*video
= video_drvdata(file
);
999 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1000 struct v4l2_subdev
*subdev
= video
->current_ext_subdev
->subdev
;
1004 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_enum_dv_timings\n");
1005 return v4l2_subdev_call(subdev
, pad
, enum_dv_timings
, timings
);
1009 * vpfe_query_dv_timings() - query the dv_timings which is being input
1010 * to external subdev
1011 * @file: file pointer
1012 * @priv: void pointer
1013 * @timings: pointer to v4l2_dv_timings structure
1015 * get dv_timings which is being input on external subdev through
1018 * Return 0 on success, error code otherwise
1021 vpfe_query_dv_timings(struct file
*file
, void *fh
,
1022 struct v4l2_dv_timings
*timings
)
1024 struct vpfe_video_device
*video
= video_drvdata(file
);
1025 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1026 struct v4l2_subdev
*subdev
= video
->current_ext_subdev
->subdev
;
1028 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_query_dv_timings\n");
1029 return v4l2_subdev_call(subdev
, video
, query_dv_timings
, timings
);
1033 * vpfe_s_dv_timings() - set dv_timings on external subdev
1034 * @file: file pointer
1035 * @priv: void pointer
1036 * @timings: pointer to v4l2_dv_timings structure
1038 * set dv_timings pointed by timings on external subdev through
1039 * v4l2_device_call_until_err, this configures amplifier also
1041 * Return 0 on success, error code otherwise
1044 vpfe_s_dv_timings(struct file
*file
, void *fh
,
1045 struct v4l2_dv_timings
*timings
)
1047 struct vpfe_video_device
*video
= video_drvdata(file
);
1048 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1050 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_s_dv_timings\n");
1052 video
->stdid
= V4L2_STD_UNKNOWN
;
1053 return v4l2_device_call_until_err(&vpfe_dev
->v4l2_dev
,
1054 video
->current_ext_subdev
->grp_id
,
1055 video
, s_dv_timings
, timings
);
1059 * vpfe_g_dv_timings() - get dv_timings which is set on external subdev
1060 * @file: file pointer
1061 * @priv: void pointer
1062 * @timings: pointer to v4l2_dv_timings structure
1064 * get dv_timings which is set on external subdev through
1067 * Return 0 on success, error code otherwise
1070 vpfe_g_dv_timings(struct file
*file
, void *fh
,
1071 struct v4l2_dv_timings
*timings
)
1073 struct vpfe_video_device
*video
= video_drvdata(file
);
1074 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1075 struct v4l2_subdev
*subdev
= video
->current_ext_subdev
->subdev
;
1077 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_g_dv_timings\n");
1078 return v4l2_subdev_call(subdev
, video
, g_dv_timings
, timings
);
1082 * Videobuf operations
1085 * vpfe_buffer_queue_setup : Callback function for buffer setup.
1086 * @vq: vb2_queue ptr
1088 * @nbuffers: ptr to number of buffers requested by application
1089 * @nplanes:: contains number of distinct video planes needed to hold a frame
1090 * @sizes[]: contains the size (in bytes) of each plane.
1091 * @alloc_ctxs: ptr to allocation context
1093 * This callback function is called when reqbuf() is called to adjust
1094 * the buffer nbuffers and buffer size
1097 vpfe_buffer_queue_setup(struct vb2_queue
*vq
,
1098 unsigned int *nbuffers
, unsigned int *nplanes
,
1099 unsigned int sizes
[], void *alloc_ctxs
[])
1101 struct vpfe_fh
*fh
= vb2_get_drv_priv(vq
);
1102 struct vpfe_video_device
*video
= fh
->video
;
1103 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1106 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_buffer_queue_setup\n");
1107 size
= video
->fmt
.fmt
.pix
.sizeimage
;
1109 if (vq
->num_buffers
+ *nbuffers
< 3)
1110 *nbuffers
= 3 - vq
->num_buffers
;
1114 alloc_ctxs
[0] = video
->alloc_ctx
;
1115 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
,
1116 "nbuffers=%d, size=%lu\n", *nbuffers
, size
);
1121 * vpfe_buffer_prepare : callback function for buffer prepare
1122 * @vb: ptr to vb2_buffer
1124 * This is the callback function for buffer prepare when vb2_qbuf()
1125 * function is called. The buffer is prepared and user space virtual address
1126 * or user address is converted into physical address
1128 static int vpfe_buffer_prepare(struct vb2_buffer
*vb
)
1130 struct vpfe_fh
*fh
= vb2_get_drv_priv(vb
->vb2_queue
);
1131 struct vpfe_video_device
*video
= fh
->video
;
1132 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1135 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_buffer_prepare\n");
1137 if (vb
->state
!= VB2_BUF_STATE_ACTIVE
&&
1138 vb
->state
!= VB2_BUF_STATE_PREPARED
)
1141 /* Initialize buffer */
1142 vb2_set_plane_payload(vb
, 0, video
->fmt
.fmt
.pix
.sizeimage
);
1143 if (vb2_plane_vaddr(vb
, 0) &&
1144 vb2_get_plane_payload(vb
, 0) > vb2_plane_size(vb
, 0))
1147 addr
= vb2_dma_contig_plane_dma_addr(vb
, 0);
1148 /* Make sure user addresses are aligned to 32 bytes */
1149 if (!ALIGN(addr
, 32))
1155 static void vpfe_buffer_queue(struct vb2_buffer
*vb
)
1157 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
1158 /* Get the file handle object and device object */
1159 struct vpfe_fh
*fh
= vb2_get_drv_priv(vb
->vb2_queue
);
1160 struct vpfe_video_device
*video
= fh
->video
;
1161 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1162 struct vpfe_pipeline
*pipe
= &video
->pipe
;
1163 struct vpfe_cap_buffer
*buf
= container_of(vbuf
,
1164 struct vpfe_cap_buffer
, vb
);
1165 unsigned long flags
;
1166 unsigned long empty
;
1169 spin_lock_irqsave(&video
->dma_queue_lock
, flags
);
1170 empty
= list_empty(&video
->dma_queue
);
1171 /* add the buffer to the DMA queue */
1172 list_add_tail(&buf
->list
, &video
->dma_queue
);
1173 spin_unlock_irqrestore(&video
->dma_queue_lock
, flags
);
1174 /* this case happens in case of single shot */
1175 if (empty
&& video
->started
&& pipe
->state
==
1176 VPFE_PIPELINE_STREAM_SINGLESHOT
&&
1177 video
->state
== VPFE_VIDEO_BUFFER_NOT_QUEUED
) {
1178 spin_lock(&video
->dma_queue_lock
);
1179 addr
= vpfe_video_get_next_buffer(video
);
1180 video
->ops
->queue(vpfe_dev
, addr
);
1182 video
->state
= VPFE_VIDEO_BUFFER_QUEUED
;
1183 spin_unlock(&video
->dma_queue_lock
);
1185 /* enable h/w each time in single shot */
1186 if (vpfe_video_is_pipe_ready(pipe
))
1187 vpfe_pipeline_set_stream(pipe
,
1188 VPFE_PIPELINE_STREAM_SINGLESHOT
);
1192 /* vpfe_start_capture() - start streaming on all the subdevs */
1193 static int vpfe_start_capture(struct vpfe_video_device
*video
)
1195 struct vpfe_pipeline
*pipe
= &video
->pipe
;
1199 if (vpfe_video_is_pipe_ready(pipe
))
1200 ret
= vpfe_pipeline_set_stream(pipe
, pipe
->state
);
1205 static int vpfe_start_streaming(struct vb2_queue
*vq
, unsigned int count
)
1207 struct vpfe_fh
*fh
= vb2_get_drv_priv(vq
);
1208 struct vpfe_video_device
*video
= fh
->video
;
1209 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1213 ret
= mutex_lock_interruptible(&video
->lock
);
1217 /* Get the next frame from the buffer queue */
1218 video
->cur_frm
= video
->next_frm
=
1219 list_entry(video
->dma_queue
.next
, struct vpfe_cap_buffer
, list
);
1220 /* Remove buffer from the buffer queue */
1221 list_del(&video
->cur_frm
->list
);
1222 /* Mark state of the current frame to active */
1223 video
->cur_frm
->vb
.vb2_buf
.state
= VB2_BUF_STATE_ACTIVE
;
1224 /* Initialize field_id and started member */
1225 video
->field_id
= 0;
1226 addr
= vb2_dma_contig_plane_dma_addr(&video
->cur_frm
->vb
.vb2_buf
, 0);
1227 video
->ops
->queue(vpfe_dev
, addr
);
1228 video
->state
= VPFE_VIDEO_BUFFER_QUEUED
;
1230 ret
= vpfe_start_capture(video
);
1232 struct vpfe_cap_buffer
*buf
, *tmp
;
1234 vb2_buffer_done(&video
->cur_frm
->vb
.vb2_buf
,
1235 VB2_BUF_STATE_QUEUED
);
1236 list_for_each_entry_safe(buf
, tmp
, &video
->dma_queue
, list
) {
1237 list_del(&buf
->list
);
1238 vb2_buffer_done(&buf
->vb
.vb2_buf
,
1239 VB2_BUF_STATE_QUEUED
);
1244 mutex_unlock(&video
->lock
);
1248 mutex_unlock(&video
->lock
);
1250 ret
= vb2_streamoff(&video
->buffer_queue
, video
->buffer_queue
.type
);
1254 static int vpfe_buffer_init(struct vb2_buffer
*vb
)
1256 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
1257 struct vpfe_cap_buffer
*buf
= container_of(vbuf
,
1258 struct vpfe_cap_buffer
, vb
);
1260 INIT_LIST_HEAD(&buf
->list
);
1264 /* abort streaming and wait for last buffer */
1265 static void vpfe_stop_streaming(struct vb2_queue
*vq
)
1267 struct vpfe_fh
*fh
= vb2_get_drv_priv(vq
);
1268 struct vpfe_video_device
*video
= fh
->video
;
1270 /* release all active buffers */
1271 if (video
->cur_frm
== video
->next_frm
) {
1272 vb2_buffer_done(&video
->cur_frm
->vb
.vb2_buf
,
1273 VB2_BUF_STATE_ERROR
);
1275 if (video
->cur_frm
!= NULL
)
1276 vb2_buffer_done(&video
->cur_frm
->vb
.vb2_buf
,
1277 VB2_BUF_STATE_ERROR
);
1278 if (video
->next_frm
!= NULL
)
1279 vb2_buffer_done(&video
->next_frm
->vb
.vb2_buf
,
1280 VB2_BUF_STATE_ERROR
);
1283 while (!list_empty(&video
->dma_queue
)) {
1284 video
->next_frm
= list_entry(video
->dma_queue
.next
,
1285 struct vpfe_cap_buffer
, list
);
1286 list_del(&video
->next_frm
->list
);
1287 vb2_buffer_done(&video
->next_frm
->vb
.vb2_buf
,
1288 VB2_BUF_STATE_ERROR
);
1292 static void vpfe_buf_cleanup(struct vb2_buffer
*vb
)
1294 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
1295 struct vpfe_fh
*fh
= vb2_get_drv_priv(vb
->vb2_queue
);
1296 struct vpfe_video_device
*video
= fh
->video
;
1297 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1298 struct vpfe_cap_buffer
*buf
= container_of(vbuf
,
1299 struct vpfe_cap_buffer
, vb
);
1301 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_buf_cleanup\n");
1302 if (vb
->state
== VB2_BUF_STATE_ACTIVE
)
1303 list_del_init(&buf
->list
);
1306 static struct vb2_ops video_qops
= {
1307 .queue_setup
= vpfe_buffer_queue_setup
,
1308 .buf_init
= vpfe_buffer_init
,
1309 .buf_prepare
= vpfe_buffer_prepare
,
1310 .start_streaming
= vpfe_start_streaming
,
1311 .stop_streaming
= vpfe_stop_streaming
,
1312 .buf_cleanup
= vpfe_buf_cleanup
,
1313 .buf_queue
= vpfe_buffer_queue
,
1317 * vpfe_reqbufs() - supported REQBUF only once opening
1320 static int vpfe_reqbufs(struct file
*file
, void *priv
,
1321 struct v4l2_requestbuffers
*req_buf
)
1323 struct vpfe_video_device
*video
= video_drvdata(file
);
1324 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1325 struct vpfe_fh
*fh
= file
->private_data
;
1326 struct vb2_queue
*q
;
1329 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_reqbufs\n");
1331 if (V4L2_BUF_TYPE_VIDEO_CAPTURE
!= req_buf
->type
&&
1332 V4L2_BUF_TYPE_VIDEO_OUTPUT
!= req_buf
->type
) {
1333 v4l2_err(&vpfe_dev
->v4l2_dev
, "Invalid buffer type\n");
1337 ret
= mutex_lock_interruptible(&video
->lock
);
1341 if (video
->io_usrs
!= 0) {
1342 v4l2_err(&vpfe_dev
->v4l2_dev
, "Only one IO user allowed\n");
1346 video
->memory
= req_buf
->memory
;
1348 /* Initialize videobuf2 queue as per the buffer type */
1349 video
->alloc_ctx
= vb2_dma_contig_init_ctx(vpfe_dev
->pdev
);
1350 if (IS_ERR(video
->alloc_ctx
)) {
1351 v4l2_err(&vpfe_dev
->v4l2_dev
, "Failed to get the context\n");
1352 return PTR_ERR(video
->alloc_ctx
);
1355 q
= &video
->buffer_queue
;
1356 q
->type
= req_buf
->type
;
1357 q
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
1359 q
->min_buffers_needed
= 1;
1360 q
->ops
= &video_qops
;
1361 q
->mem_ops
= &vb2_dma_contig_memops
;
1362 q
->buf_struct_size
= sizeof(struct vpfe_cap_buffer
);
1363 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1365 ret
= vb2_queue_init(q
);
1367 v4l2_err(&vpfe_dev
->v4l2_dev
, "vb2_queue_init() failed\n");
1368 vb2_dma_contig_cleanup_ctx(vpfe_dev
->pdev
);
1374 INIT_LIST_HEAD(&video
->dma_queue
);
1375 ret
= vb2_reqbufs(&video
->buffer_queue
, req_buf
);
1378 mutex_unlock(&video
->lock
);
1383 * vpfe_querybuf() - query buffers for exchange
1385 static int vpfe_querybuf(struct file
*file
, void *priv
,
1386 struct v4l2_buffer
*buf
)
1388 struct vpfe_video_device
*video
= video_drvdata(file
);
1389 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1391 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_querybuf\n");
1393 if (V4L2_BUF_TYPE_VIDEO_CAPTURE
!= buf
->type
&&
1394 V4L2_BUF_TYPE_VIDEO_OUTPUT
!= buf
->type
) {
1395 v4l2_err(&vpfe_dev
->v4l2_dev
, "Invalid buf type\n");
1399 if (video
->memory
!= V4L2_MEMORY_MMAP
) {
1400 v4l2_err(&vpfe_dev
->v4l2_dev
, "Invalid memory\n");
1404 /* Call vb2_querybuf to get information */
1405 return vb2_querybuf(&video
->buffer_queue
, buf
);
1409 * vpfe_qbuf() - queue buffers for capture or processing
1411 static int vpfe_qbuf(struct file
*file
, void *priv
,
1412 struct v4l2_buffer
*p
)
1414 struct vpfe_video_device
*video
= video_drvdata(file
);
1415 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1416 struct vpfe_fh
*fh
= file
->private_data
;
1418 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_qbuf\n");
1420 if (V4L2_BUF_TYPE_VIDEO_CAPTURE
!= p
->type
&&
1421 V4L2_BUF_TYPE_VIDEO_OUTPUT
!= p
->type
) {
1422 v4l2_err(&vpfe_dev
->v4l2_dev
, "Invalid buf type\n");
1426 * If this file handle is not allowed to do IO,
1429 if (!fh
->io_allowed
) {
1430 v4l2_err(&vpfe_dev
->v4l2_dev
, "fh->io_allowed\n");
1434 return vb2_qbuf(&video
->buffer_queue
, p
);
1438 * vpfe_dqbuf() - deque buffer which is done with processing
1440 static int vpfe_dqbuf(struct file
*file
, void *priv
,
1441 struct v4l2_buffer
*buf
)
1443 struct vpfe_video_device
*video
= video_drvdata(file
);
1444 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1446 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_dqbuf\n");
1448 if (V4L2_BUF_TYPE_VIDEO_CAPTURE
!= buf
->type
&&
1449 V4L2_BUF_TYPE_VIDEO_OUTPUT
!= buf
->type
) {
1450 v4l2_err(&vpfe_dev
->v4l2_dev
, "Invalid buf type\n");
1454 return vb2_dqbuf(&video
->buffer_queue
,
1455 buf
, (file
->f_flags
& O_NONBLOCK
));
1459 * vpfe_streamon() - start streaming
1460 * @file: file pointer
1461 * @priv: void pointer
1462 * @buf_type: enum v4l2_buf_type
1464 * queue buffer onto hardware for capture/processing and
1465 * start all the subdevs which are in media chain
1467 * Return 0 on success, error code otherwise
1469 static int vpfe_streamon(struct file
*file
, void *priv
,
1470 enum v4l2_buf_type buf_type
)
1472 struct vpfe_video_device
*video
= video_drvdata(file
);
1473 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1474 struct vpfe_pipeline
*pipe
= &video
->pipe
;
1475 struct vpfe_fh
*fh
= file
->private_data
;
1476 struct vpfe_ext_subdev_info
*sdinfo
;
1479 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_streamon\n");
1481 if (V4L2_BUF_TYPE_VIDEO_CAPTURE
!= buf_type
&&
1482 V4L2_BUF_TYPE_VIDEO_OUTPUT
!= buf_type
) {
1483 v4l2_err(&vpfe_dev
->v4l2_dev
, "Invalid buf type\n");
1486 /* If file handle is not allowed IO, return error */
1487 if (!fh
->io_allowed
) {
1488 v4l2_err(&vpfe_dev
->v4l2_dev
, "fh->io_allowed\n");
1491 sdinfo
= video
->current_ext_subdev
;
1492 /* If buffer queue is empty, return error */
1493 if (list_empty(&video
->buffer_queue
.queued_list
)) {
1494 v4l2_err(&vpfe_dev
->v4l2_dev
, "buffer queue is empty\n");
1497 /* Validate the pipeline */
1498 if (V4L2_BUF_TYPE_VIDEO_CAPTURE
== buf_type
) {
1499 ret
= vpfe_video_validate_pipeline(pipe
);
1503 /* Call vb2_streamon to start streaming */
1504 return vb2_streamon(&video
->buffer_queue
, buf_type
);
1508 * vpfe_streamoff() - stop streaming
1509 * @file: file pointer
1510 * @priv: void pointer
1511 * @buf_type: enum v4l2_buf_type
1513 * stop all the subdevs which are in media chain
1515 * Return 0 on success, error code otherwise
1517 static int vpfe_streamoff(struct file
*file
, void *priv
,
1518 enum v4l2_buf_type buf_type
)
1520 struct vpfe_video_device
*video
= video_drvdata(file
);
1521 struct vpfe_device
*vpfe_dev
= video
->vpfe_dev
;
1522 struct vpfe_fh
*fh
= file
->private_data
;
1525 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "vpfe_streamoff\n");
1527 if (buf_type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
&&
1528 buf_type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1529 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "Invalid buf type\n");
1533 /* If io is allowed for this file handle, return error */
1534 if (!fh
->io_allowed
) {
1535 v4l2_dbg(1, debug
, &vpfe_dev
->v4l2_dev
, "fh->io_allowed\n");
1539 /* If streaming is not started, return error */
1540 if (!video
->started
) {
1541 v4l2_err(&vpfe_dev
->v4l2_dev
, "device is not started\n");
1545 ret
= mutex_lock_interruptible(&video
->lock
);
1549 vpfe_stop_capture(video
);
1550 ret
= vb2_streamoff(&video
->buffer_queue
, buf_type
);
1551 mutex_unlock(&video
->lock
);
1556 /* vpfe capture ioctl operations */
1557 static const struct v4l2_ioctl_ops vpfe_ioctl_ops
= {
1558 .vidioc_querycap
= vpfe_querycap
,
1559 .vidioc_g_fmt_vid_cap
= vpfe_g_fmt
,
1560 .vidioc_s_fmt_vid_cap
= vpfe_s_fmt
,
1561 .vidioc_try_fmt_vid_cap
= vpfe_try_fmt
,
1562 .vidioc_enum_fmt_vid_cap
= vpfe_enum_fmt
,
1563 .vidioc_g_fmt_vid_out
= vpfe_g_fmt
,
1564 .vidioc_s_fmt_vid_out
= vpfe_s_fmt
,
1565 .vidioc_try_fmt_vid_out
= vpfe_try_fmt
,
1566 .vidioc_enum_fmt_vid_out
= vpfe_enum_fmt
,
1567 .vidioc_enum_input
= vpfe_enum_input
,
1568 .vidioc_g_input
= vpfe_g_input
,
1569 .vidioc_s_input
= vpfe_s_input
,
1570 .vidioc_querystd
= vpfe_querystd
,
1571 .vidioc_s_std
= vpfe_s_std
,
1572 .vidioc_g_std
= vpfe_g_std
,
1573 .vidioc_enum_dv_timings
= vpfe_enum_dv_timings
,
1574 .vidioc_query_dv_timings
= vpfe_query_dv_timings
,
1575 .vidioc_s_dv_timings
= vpfe_s_dv_timings
,
1576 .vidioc_g_dv_timings
= vpfe_g_dv_timings
,
1577 .vidioc_reqbufs
= vpfe_reqbufs
,
1578 .vidioc_querybuf
= vpfe_querybuf
,
1579 .vidioc_qbuf
= vpfe_qbuf
,
1580 .vidioc_dqbuf
= vpfe_dqbuf
,
1581 .vidioc_streamon
= vpfe_streamon
,
1582 .vidioc_streamoff
= vpfe_streamoff
,
1585 /* VPFE video init function */
1586 int vpfe_video_init(struct vpfe_video_device
*video
, const char *name
)
1588 const char *direction
;
1591 switch (video
->type
) {
1592 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1593 direction
= "output";
1594 video
->pad
.flags
= MEDIA_PAD_FL_SINK
;
1595 video
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1598 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
1599 direction
= "input";
1600 video
->pad
.flags
= MEDIA_PAD_FL_SOURCE
;
1601 video
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1607 /* Initialize field of video device */
1608 video
->video_dev
.release
= video_device_release
;
1609 video
->video_dev
.fops
= &vpfe_fops
;
1610 video
->video_dev
.ioctl_ops
= &vpfe_ioctl_ops
;
1611 video
->video_dev
.minor
= -1;
1612 video
->video_dev
.tvnorms
= 0;
1613 snprintf(video
->video_dev
.name
, sizeof(video
->video_dev
.name
),
1614 "DAVINCI VIDEO %s %s", name
, direction
);
1616 spin_lock_init(&video
->irqlock
);
1617 spin_lock_init(&video
->dma_queue_lock
);
1618 mutex_init(&video
->lock
);
1619 ret
= media_entity_pads_init(&video
->video_dev
.entity
,
1624 video_set_drvdata(&video
->video_dev
, video
);
1629 /* vpfe video device register function */
1630 int vpfe_video_register(struct vpfe_video_device
*video
,
1631 struct v4l2_device
*vdev
)
1635 video
->video_dev
.v4l2_dev
= vdev
;
1637 ret
= video_register_device(&video
->video_dev
, VFL_TYPE_GRABBER
, -1);
1639 pr_err("%s: could not register video device (%d)\n",
1644 /* vpfe video device unregister function */
1645 void vpfe_video_unregister(struct vpfe_video_device
*video
)
1647 if (video_is_registered(&video
->video_dev
)) {
1648 video_unregister_device(&video
->video_dev
);
1649 media_entity_cleanup(&video
->video_dev
.entity
);