2 * Analog Devices video capture driver
4 * Copyright (c) 2011 Analog Devices Inc.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 #include <linux/completion.h>
21 #include <linux/delay.h>
22 #include <linux/errno.h>
24 #include <linux/i2c.h>
25 #include <linux/init.h>
26 #include <linux/interrupt.h>
29 #include <linux/module.h>
30 #include <linux/platform_device.h>
31 #include <linux/slab.h>
32 #include <linux/time.h>
33 #include <linux/types.h>
35 #include <media/v4l2-common.h>
36 #include <media/v4l2-ctrls.h>
37 #include <media/v4l2-device.h>
38 #include <media/v4l2-ioctl.h>
39 #include <media/videobuf2-dma-contig.h>
43 #include <media/blackfin/bfin_capture.h>
44 #include <media/blackfin/ppi.h>
46 #define CAPTURE_DRV_NAME "bfin_capture"
47 #define BCAP_MIN_NUM_BUF 2
53 int bpp
; /* bits per pixel */
54 int dlen
; /* data length for ppi in bits */
59 struct list_head list
;
63 /* capture device instance */
64 struct v4l2_device v4l2_dev
;
65 /* v4l2 control handler */
66 struct v4l2_ctrl_handler ctrl_handler
;
67 /* device node data */
68 struct video_device
*video_dev
;
69 /* sub device instance */
70 struct v4l2_subdev
*sd
;
72 struct bfin_capture_config
*cfg
;
76 unsigned int cur_input
;
77 /* current selected standard */
79 /* current selected dv_timings */
80 struct v4l2_dv_timings dv_timings
;
81 /* used to store pixel format */
82 struct v4l2_pix_format fmt
;
85 /* data length for ppi in bits */
87 /* used to store sensor supported format */
88 struct bcap_format
*sensor_formats
;
89 /* number of sensor formats array */
90 int num_sensor_formats
;
91 /* pointing to current video buffer */
92 struct bcap_buffer
*cur_frm
;
93 /* buffer queue used in videobuf2 */
94 struct vb2_queue buffer_queue
;
95 /* allocator-specific contexts for each plane */
96 struct vb2_alloc_ctx
*alloc_ctx
;
97 /* queue of filled frames */
98 struct list_head dma_queue
;
99 /* used in videobuf2 callback */
101 /* used to access capture device */
103 /* used to wait ppi to complete one transfer */
104 struct completion comp
;
105 /* prepare to stop */
111 /* indicates whether this file handle is doing IO */
115 static const struct bcap_format bcap_formats
[] = {
117 .desc
= "YCbCr 4:2:2 Interleaved UYVY",
118 .pixelformat
= V4L2_PIX_FMT_UYVY
,
119 .mbus_code
= MEDIA_BUS_FMT_UYVY8_2X8
,
124 .desc
= "YCbCr 4:2:2 Interleaved YUYV",
125 .pixelformat
= V4L2_PIX_FMT_YUYV
,
126 .mbus_code
= MEDIA_BUS_FMT_YUYV8_2X8
,
131 .desc
= "YCbCr 4:2:2 Interleaved UYVY",
132 .pixelformat
= V4L2_PIX_FMT_UYVY
,
133 .mbus_code
= MEDIA_BUS_FMT_UYVY8_1X16
,
139 .pixelformat
= V4L2_PIX_FMT_RGB565
,
140 .mbus_code
= MEDIA_BUS_FMT_RGB565_2X8_LE
,
146 .pixelformat
= V4L2_PIX_FMT_RGB444
,
147 .mbus_code
= MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE
,
153 #define BCAP_MAX_FMTS ARRAY_SIZE(bcap_formats)
155 static irqreturn_t
bcap_isr(int irq
, void *dev_id
);
157 static struct bcap_buffer
*to_bcap_vb(struct vb2_buffer
*vb
)
159 return container_of(vb
, struct bcap_buffer
, vb
);
162 static int bcap_init_sensor_formats(struct bcap_device
*bcap_dev
)
165 struct bcap_format
*sf
;
166 unsigned int num_formats
= 0;
169 while (!v4l2_subdev_call(bcap_dev
->sd
, video
,
170 enum_mbus_fmt
, num_formats
, &code
))
175 sf
= kzalloc(num_formats
* sizeof(*sf
), GFP_KERNEL
);
179 for (i
= 0; i
< num_formats
; i
++) {
180 v4l2_subdev_call(bcap_dev
->sd
, video
,
181 enum_mbus_fmt
, i
, &code
);
182 for (j
= 0; j
< BCAP_MAX_FMTS
; j
++)
183 if (code
== bcap_formats
[j
].mbus_code
)
185 if (j
== BCAP_MAX_FMTS
) {
186 /* we don't allow this sensor working with our bridge */
190 sf
[i
] = bcap_formats
[j
];
192 bcap_dev
->sensor_formats
= sf
;
193 bcap_dev
->num_sensor_formats
= num_formats
;
197 static void bcap_free_sensor_formats(struct bcap_device
*bcap_dev
)
199 bcap_dev
->num_sensor_formats
= 0;
200 kfree(bcap_dev
->sensor_formats
);
201 bcap_dev
->sensor_formats
= NULL
;
204 static int bcap_open(struct file
*file
)
206 struct bcap_device
*bcap_dev
= video_drvdata(file
);
207 struct video_device
*vfd
= bcap_dev
->video_dev
;
208 struct bcap_fh
*bcap_fh
;
211 v4l2_err(&bcap_dev
->v4l2_dev
, "No sub device registered\n");
215 bcap_fh
= kzalloc(sizeof(*bcap_fh
), GFP_KERNEL
);
217 v4l2_err(&bcap_dev
->v4l2_dev
,
218 "unable to allocate memory for file handle object\n");
222 v4l2_fh_init(&bcap_fh
->fh
, vfd
);
224 /* store pointer to v4l2_fh in private_data member of file */
225 file
->private_data
= &bcap_fh
->fh
;
226 v4l2_fh_add(&bcap_fh
->fh
);
227 bcap_fh
->io_allowed
= false;
231 static int bcap_release(struct file
*file
)
233 struct bcap_device
*bcap_dev
= video_drvdata(file
);
234 struct v4l2_fh
*fh
= file
->private_data
;
235 struct bcap_fh
*bcap_fh
= container_of(fh
, struct bcap_fh
, fh
);
237 /* if this instance is doing IO */
238 if (bcap_fh
->io_allowed
)
239 vb2_queue_release(&bcap_dev
->buffer_queue
);
241 file
->private_data
= NULL
;
242 v4l2_fh_del(&bcap_fh
->fh
);
243 v4l2_fh_exit(&bcap_fh
->fh
);
248 static int bcap_mmap(struct file
*file
, struct vm_area_struct
*vma
)
250 struct bcap_device
*bcap_dev
= video_drvdata(file
);
253 if (mutex_lock_interruptible(&bcap_dev
->mutex
))
255 ret
= vb2_mmap(&bcap_dev
->buffer_queue
, vma
);
256 mutex_unlock(&bcap_dev
->mutex
);
261 static unsigned long bcap_get_unmapped_area(struct file
*file
,
267 struct bcap_device
*bcap_dev
= video_drvdata(file
);
269 return vb2_get_unmapped_area(&bcap_dev
->buffer_queue
,
277 static unsigned int bcap_poll(struct file
*file
, poll_table
*wait
)
279 struct bcap_device
*bcap_dev
= video_drvdata(file
);
282 mutex_lock(&bcap_dev
->mutex
);
283 res
= vb2_poll(&bcap_dev
->buffer_queue
, file
, wait
);
284 mutex_unlock(&bcap_dev
->mutex
);
288 static int bcap_queue_setup(struct vb2_queue
*vq
,
289 const struct v4l2_format
*fmt
,
290 unsigned int *nbuffers
, unsigned int *nplanes
,
291 unsigned int sizes
[], void *alloc_ctxs
[])
293 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vq
);
295 if (*nbuffers
< BCAP_MIN_NUM_BUF
)
296 *nbuffers
= BCAP_MIN_NUM_BUF
;
299 sizes
[0] = bcap_dev
->fmt
.sizeimage
;
300 alloc_ctxs
[0] = bcap_dev
->alloc_ctx
;
305 static int bcap_buffer_init(struct vb2_buffer
*vb
)
307 struct bcap_buffer
*buf
= to_bcap_vb(vb
);
309 INIT_LIST_HEAD(&buf
->list
);
313 static int bcap_buffer_prepare(struct vb2_buffer
*vb
)
315 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vb
->vb2_queue
);
316 struct bcap_buffer
*buf
= to_bcap_vb(vb
);
319 size
= bcap_dev
->fmt
.sizeimage
;
320 if (vb2_plane_size(vb
, 0) < size
) {
321 v4l2_err(&bcap_dev
->v4l2_dev
, "buffer too small (%lu < %lu)\n",
322 vb2_plane_size(vb
, 0), size
);
325 vb2_set_plane_payload(&buf
->vb
, 0, size
);
330 static void bcap_buffer_queue(struct vb2_buffer
*vb
)
332 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vb
->vb2_queue
);
333 struct bcap_buffer
*buf
= to_bcap_vb(vb
);
336 spin_lock_irqsave(&bcap_dev
->lock
, flags
);
337 list_add_tail(&buf
->list
, &bcap_dev
->dma_queue
);
338 spin_unlock_irqrestore(&bcap_dev
->lock
, flags
);
341 static void bcap_buffer_cleanup(struct vb2_buffer
*vb
)
343 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vb
->vb2_queue
);
344 struct bcap_buffer
*buf
= to_bcap_vb(vb
);
347 spin_lock_irqsave(&bcap_dev
->lock
, flags
);
348 list_del_init(&buf
->list
);
349 spin_unlock_irqrestore(&bcap_dev
->lock
, flags
);
352 static int bcap_start_streaming(struct vb2_queue
*vq
, unsigned int count
)
354 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vq
);
355 struct ppi_if
*ppi
= bcap_dev
->ppi
;
356 struct ppi_params params
;
359 /* enable streamon on the sub device */
360 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_stream
, 1);
361 if (ret
&& (ret
!= -ENOIOCTLCMD
)) {
362 v4l2_err(&bcap_dev
->v4l2_dev
, "stream on failed in subdev\n");
367 params
.width
= bcap_dev
->fmt
.width
;
368 params
.height
= bcap_dev
->fmt
.height
;
369 params
.bpp
= bcap_dev
->bpp
;
370 params
.dlen
= bcap_dev
->dlen
;
371 params
.ppi_control
= bcap_dev
->cfg
->ppi_control
;
372 params
.int_mask
= bcap_dev
->cfg
->int_mask
;
373 if (bcap_dev
->cfg
->inputs
[bcap_dev
->cur_input
].capabilities
374 & V4L2_IN_CAP_DV_TIMINGS
) {
375 struct v4l2_bt_timings
*bt
= &bcap_dev
->dv_timings
.bt
;
377 params
.hdelay
= bt
->hsync
+ bt
->hbackporch
;
378 params
.vdelay
= bt
->vsync
+ bt
->vbackporch
;
379 params
.line
= V4L2_DV_BT_FRAME_WIDTH(bt
);
380 params
.frame
= V4L2_DV_BT_FRAME_HEIGHT(bt
);
381 } else if (bcap_dev
->cfg
->inputs
[bcap_dev
->cur_input
].capabilities
385 if (bcap_dev
->std
& V4L2_STD_525_60
) {
395 params
.line
= params
.width
+ bcap_dev
->cfg
->blank_pixels
;
396 params
.frame
= params
.height
;
398 ret
= ppi
->ops
->set_params(ppi
, ¶ms
);
400 v4l2_err(&bcap_dev
->v4l2_dev
,
401 "Error in setting ppi params\n");
405 /* attach ppi DMA irq handler */
406 ret
= ppi
->ops
->attach_irq(ppi
, bcap_isr
);
408 v4l2_err(&bcap_dev
->v4l2_dev
,
409 "Error in attaching interrupt handler\n");
413 reinit_completion(&bcap_dev
->comp
);
414 bcap_dev
->stop
= false;
418 static void bcap_stop_streaming(struct vb2_queue
*vq
)
420 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vq
);
421 struct ppi_if
*ppi
= bcap_dev
->ppi
;
424 bcap_dev
->stop
= true;
425 wait_for_completion(&bcap_dev
->comp
);
427 ppi
->ops
->detach_irq(ppi
);
428 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_stream
, 0);
429 if (ret
&& (ret
!= -ENOIOCTLCMD
))
430 v4l2_err(&bcap_dev
->v4l2_dev
,
431 "stream off failed in subdev\n");
433 /* release all active buffers */
434 while (!list_empty(&bcap_dev
->dma_queue
)) {
435 bcap_dev
->cur_frm
= list_entry(bcap_dev
->dma_queue
.next
,
436 struct bcap_buffer
, list
);
437 list_del_init(&bcap_dev
->cur_frm
->list
);
438 vb2_buffer_done(&bcap_dev
->cur_frm
->vb
, VB2_BUF_STATE_ERROR
);
442 static struct vb2_ops bcap_video_qops
= {
443 .queue_setup
= bcap_queue_setup
,
444 .buf_init
= bcap_buffer_init
,
445 .buf_prepare
= bcap_buffer_prepare
,
446 .buf_cleanup
= bcap_buffer_cleanup
,
447 .buf_queue
= bcap_buffer_queue
,
448 .wait_prepare
= vb2_ops_wait_prepare
,
449 .wait_finish
= vb2_ops_wait_finish
,
450 .start_streaming
= bcap_start_streaming
,
451 .stop_streaming
= bcap_stop_streaming
,
454 static int bcap_reqbufs(struct file
*file
, void *priv
,
455 struct v4l2_requestbuffers
*req_buf
)
457 struct bcap_device
*bcap_dev
= video_drvdata(file
);
458 struct vb2_queue
*vq
= &bcap_dev
->buffer_queue
;
459 struct v4l2_fh
*fh
= file
->private_data
;
460 struct bcap_fh
*bcap_fh
= container_of(fh
, struct bcap_fh
, fh
);
465 bcap_fh
->io_allowed
= true;
467 return vb2_reqbufs(vq
, req_buf
);
470 static int bcap_querybuf(struct file
*file
, void *priv
,
471 struct v4l2_buffer
*buf
)
473 struct bcap_device
*bcap_dev
= video_drvdata(file
);
475 return vb2_querybuf(&bcap_dev
->buffer_queue
, buf
);
478 static int bcap_qbuf(struct file
*file
, void *priv
,
479 struct v4l2_buffer
*buf
)
481 struct bcap_device
*bcap_dev
= video_drvdata(file
);
482 struct v4l2_fh
*fh
= file
->private_data
;
483 struct bcap_fh
*bcap_fh
= container_of(fh
, struct bcap_fh
, fh
);
485 if (!bcap_fh
->io_allowed
)
488 return vb2_qbuf(&bcap_dev
->buffer_queue
, buf
);
491 static int bcap_dqbuf(struct file
*file
, void *priv
,
492 struct v4l2_buffer
*buf
)
494 struct bcap_device
*bcap_dev
= video_drvdata(file
);
495 struct v4l2_fh
*fh
= file
->private_data
;
496 struct bcap_fh
*bcap_fh
= container_of(fh
, struct bcap_fh
, fh
);
498 if (!bcap_fh
->io_allowed
)
501 return vb2_dqbuf(&bcap_dev
->buffer_queue
,
502 buf
, file
->f_flags
& O_NONBLOCK
);
505 static irqreturn_t
bcap_isr(int irq
, void *dev_id
)
507 struct ppi_if
*ppi
= dev_id
;
508 struct bcap_device
*bcap_dev
= ppi
->priv
;
509 struct vb2_buffer
*vb
= &bcap_dev
->cur_frm
->vb
;
512 spin_lock(&bcap_dev
->lock
);
514 if (!list_empty(&bcap_dev
->dma_queue
)) {
515 v4l2_get_timestamp(&vb
->v4l2_buf
.timestamp
);
517 vb2_buffer_done(vb
, VB2_BUF_STATE_ERROR
);
520 vb2_buffer_done(vb
, VB2_BUF_STATE_DONE
);
522 bcap_dev
->cur_frm
= list_entry(bcap_dev
->dma_queue
.next
,
523 struct bcap_buffer
, list
);
524 list_del_init(&bcap_dev
->cur_frm
->list
);
526 /* clear error flag, we will get a new frame */
533 if (bcap_dev
->stop
) {
534 complete(&bcap_dev
->comp
);
536 addr
= vb2_dma_contig_plane_dma_addr(&bcap_dev
->cur_frm
->vb
, 0);
537 ppi
->ops
->update_addr(ppi
, (unsigned long)addr
);
538 ppi
->ops
->start(ppi
);
541 spin_unlock(&bcap_dev
->lock
);
546 static int bcap_streamon(struct file
*file
, void *priv
,
547 enum v4l2_buf_type buf_type
)
549 struct bcap_device
*bcap_dev
= video_drvdata(file
);
550 struct bcap_fh
*fh
= file
->private_data
;
551 struct ppi_if
*ppi
= bcap_dev
->ppi
;
558 /* call streamon to start streaming in videobuf */
559 ret
= vb2_streamon(&bcap_dev
->buffer_queue
, buf_type
);
563 /* if dma queue is empty, return error */
564 if (list_empty(&bcap_dev
->dma_queue
)) {
565 v4l2_err(&bcap_dev
->v4l2_dev
, "dma queue is empty\n");
570 /* get the next frame from the dma queue */
571 bcap_dev
->cur_frm
= list_entry(bcap_dev
->dma_queue
.next
,
572 struct bcap_buffer
, list
);
573 /* remove buffer from the dma queue */
574 list_del_init(&bcap_dev
->cur_frm
->list
);
575 addr
= vb2_dma_contig_plane_dma_addr(&bcap_dev
->cur_frm
->vb
, 0);
576 /* update DMA address */
577 ppi
->ops
->update_addr(ppi
, (unsigned long)addr
);
579 ppi
->ops
->start(ppi
);
583 vb2_streamoff(&bcap_dev
->buffer_queue
, buf_type
);
587 static int bcap_streamoff(struct file
*file
, void *priv
,
588 enum v4l2_buf_type buf_type
)
590 struct bcap_device
*bcap_dev
= video_drvdata(file
);
591 struct bcap_fh
*fh
= file
->private_data
;
596 return vb2_streamoff(&bcap_dev
->buffer_queue
, buf_type
);
599 static int bcap_querystd(struct file
*file
, void *priv
, v4l2_std_id
*std
)
601 struct bcap_device
*bcap_dev
= video_drvdata(file
);
603 return v4l2_subdev_call(bcap_dev
->sd
, video
, querystd
, std
);
606 static int bcap_g_std(struct file
*file
, void *priv
, v4l2_std_id
*std
)
608 struct bcap_device
*bcap_dev
= video_drvdata(file
);
610 *std
= bcap_dev
->std
;
614 static int bcap_s_std(struct file
*file
, void *priv
, v4l2_std_id std
)
616 struct bcap_device
*bcap_dev
= video_drvdata(file
);
619 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
622 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_std
, std
);
630 static int bcap_enum_dv_timings(struct file
*file
, void *priv
,
631 struct v4l2_enum_dv_timings
*timings
)
633 struct bcap_device
*bcap_dev
= video_drvdata(file
);
637 return v4l2_subdev_call(bcap_dev
->sd
, pad
,
638 enum_dv_timings
, timings
);
641 static int bcap_query_dv_timings(struct file
*file
, void *priv
,
642 struct v4l2_dv_timings
*timings
)
644 struct bcap_device
*bcap_dev
= video_drvdata(file
);
646 return v4l2_subdev_call(bcap_dev
->sd
, video
,
647 query_dv_timings
, timings
);
650 static int bcap_g_dv_timings(struct file
*file
, void *priv
,
651 struct v4l2_dv_timings
*timings
)
653 struct bcap_device
*bcap_dev
= video_drvdata(file
);
655 *timings
= bcap_dev
->dv_timings
;
659 static int bcap_s_dv_timings(struct file
*file
, void *priv
,
660 struct v4l2_dv_timings
*timings
)
662 struct bcap_device
*bcap_dev
= video_drvdata(file
);
664 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
667 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_dv_timings
, timings
);
671 bcap_dev
->dv_timings
= *timings
;
675 static int bcap_enum_input(struct file
*file
, void *priv
,
676 struct v4l2_input
*input
)
678 struct bcap_device
*bcap_dev
= video_drvdata(file
);
679 struct bfin_capture_config
*config
= bcap_dev
->cfg
;
683 if (input
->index
>= config
->num_inputs
)
686 *input
= config
->inputs
[input
->index
];
687 /* get input status */
688 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, g_input_status
, &status
);
690 input
->status
= status
;
694 static int bcap_g_input(struct file
*file
, void *priv
, unsigned int *index
)
696 struct bcap_device
*bcap_dev
= video_drvdata(file
);
698 *index
= bcap_dev
->cur_input
;
702 static int bcap_s_input(struct file
*file
, void *priv
, unsigned int index
)
704 struct bcap_device
*bcap_dev
= video_drvdata(file
);
705 struct bfin_capture_config
*config
= bcap_dev
->cfg
;
706 struct bcap_route
*route
;
709 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
712 if (index
>= config
->num_inputs
)
715 route
= &config
->routes
[index
];
716 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_routing
,
717 route
->input
, route
->output
, 0);
718 if ((ret
< 0) && (ret
!= -ENOIOCTLCMD
)) {
719 v4l2_err(&bcap_dev
->v4l2_dev
, "Failed to set input\n");
722 bcap_dev
->cur_input
= index
;
723 /* if this route has specific config, update ppi control */
724 if (route
->ppi_control
)
725 config
->ppi_control
= route
->ppi_control
;
729 static int bcap_try_format(struct bcap_device
*bcap
,
730 struct v4l2_pix_format
*pixfmt
,
731 struct bcap_format
*bcap_fmt
)
733 struct bcap_format
*sf
= bcap
->sensor_formats
;
734 struct bcap_format
*fmt
= NULL
;
735 struct v4l2_mbus_framefmt mbus_fmt
;
738 for (i
= 0; i
< bcap
->num_sensor_formats
; i
++) {
740 if (pixfmt
->pixelformat
== fmt
->pixelformat
)
743 if (i
== bcap
->num_sensor_formats
)
746 v4l2_fill_mbus_format(&mbus_fmt
, pixfmt
, fmt
->mbus_code
);
747 ret
= v4l2_subdev_call(bcap
->sd
, video
,
748 try_mbus_fmt
, &mbus_fmt
);
751 v4l2_fill_pix_format(pixfmt
, &mbus_fmt
);
753 for (i
= 0; i
< bcap
->num_sensor_formats
; i
++) {
755 if (mbus_fmt
.code
== fmt
->mbus_code
)
760 pixfmt
->bytesperline
= pixfmt
->width
* fmt
->bpp
/ 8;
761 pixfmt
->sizeimage
= pixfmt
->bytesperline
* pixfmt
->height
;
765 static int bcap_enum_fmt_vid_cap(struct file
*file
, void *priv
,
766 struct v4l2_fmtdesc
*fmt
)
768 struct bcap_device
*bcap_dev
= video_drvdata(file
);
769 struct bcap_format
*sf
= bcap_dev
->sensor_formats
;
771 if (fmt
->index
>= bcap_dev
->num_sensor_formats
)
774 fmt
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
775 strlcpy(fmt
->description
,
777 sizeof(fmt
->description
));
778 fmt
->pixelformat
= sf
[fmt
->index
].pixelformat
;
782 static int bcap_try_fmt_vid_cap(struct file
*file
, void *priv
,
783 struct v4l2_format
*fmt
)
785 struct bcap_device
*bcap_dev
= video_drvdata(file
);
786 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
788 return bcap_try_format(bcap_dev
, pixfmt
, NULL
);
791 static int bcap_g_fmt_vid_cap(struct file
*file
, void *priv
,
792 struct v4l2_format
*fmt
)
794 struct bcap_device
*bcap_dev
= video_drvdata(file
);
796 fmt
->fmt
.pix
= bcap_dev
->fmt
;
800 static int bcap_s_fmt_vid_cap(struct file
*file
, void *priv
,
801 struct v4l2_format
*fmt
)
803 struct bcap_device
*bcap_dev
= video_drvdata(file
);
804 struct v4l2_mbus_framefmt mbus_fmt
;
805 struct bcap_format bcap_fmt
;
806 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
809 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
812 /* see if format works */
813 ret
= bcap_try_format(bcap_dev
, pixfmt
, &bcap_fmt
);
817 v4l2_fill_mbus_format(&mbus_fmt
, pixfmt
, bcap_fmt
.mbus_code
);
818 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_mbus_fmt
, &mbus_fmt
);
821 bcap_dev
->fmt
= *pixfmt
;
822 bcap_dev
->bpp
= bcap_fmt
.bpp
;
823 bcap_dev
->dlen
= bcap_fmt
.dlen
;
827 static int bcap_querycap(struct file
*file
, void *priv
,
828 struct v4l2_capability
*cap
)
830 struct bcap_device
*bcap_dev
= video_drvdata(file
);
832 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_STREAMING
;
833 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
834 strlcpy(cap
->driver
, CAPTURE_DRV_NAME
, sizeof(cap
->driver
));
835 strlcpy(cap
->bus_info
, "Blackfin Platform", sizeof(cap
->bus_info
));
836 strlcpy(cap
->card
, bcap_dev
->cfg
->card_name
, sizeof(cap
->card
));
840 static int bcap_g_parm(struct file
*file
, void *fh
,
841 struct v4l2_streamparm
*a
)
843 struct bcap_device
*bcap_dev
= video_drvdata(file
);
845 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
847 return v4l2_subdev_call(bcap_dev
->sd
, video
, g_parm
, a
);
850 static int bcap_s_parm(struct file
*file
, void *fh
,
851 struct v4l2_streamparm
*a
)
853 struct bcap_device
*bcap_dev
= video_drvdata(file
);
855 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
857 return v4l2_subdev_call(bcap_dev
->sd
, video
, s_parm
, a
);
860 static int bcap_log_status(struct file
*file
, void *priv
)
862 struct bcap_device
*bcap_dev
= video_drvdata(file
);
863 /* status for sub devices */
864 v4l2_device_call_all(&bcap_dev
->v4l2_dev
, 0, core
, log_status
);
868 static const struct v4l2_ioctl_ops bcap_ioctl_ops
= {
869 .vidioc_querycap
= bcap_querycap
,
870 .vidioc_g_fmt_vid_cap
= bcap_g_fmt_vid_cap
,
871 .vidioc_enum_fmt_vid_cap
= bcap_enum_fmt_vid_cap
,
872 .vidioc_s_fmt_vid_cap
= bcap_s_fmt_vid_cap
,
873 .vidioc_try_fmt_vid_cap
= bcap_try_fmt_vid_cap
,
874 .vidioc_enum_input
= bcap_enum_input
,
875 .vidioc_g_input
= bcap_g_input
,
876 .vidioc_s_input
= bcap_s_input
,
877 .vidioc_querystd
= bcap_querystd
,
878 .vidioc_s_std
= bcap_s_std
,
879 .vidioc_g_std
= bcap_g_std
,
880 .vidioc_s_dv_timings
= bcap_s_dv_timings
,
881 .vidioc_g_dv_timings
= bcap_g_dv_timings
,
882 .vidioc_query_dv_timings
= bcap_query_dv_timings
,
883 .vidioc_enum_dv_timings
= bcap_enum_dv_timings
,
884 .vidioc_reqbufs
= bcap_reqbufs
,
885 .vidioc_querybuf
= bcap_querybuf
,
886 .vidioc_qbuf
= bcap_qbuf
,
887 .vidioc_dqbuf
= bcap_dqbuf
,
888 .vidioc_streamon
= bcap_streamon
,
889 .vidioc_streamoff
= bcap_streamoff
,
890 .vidioc_g_parm
= bcap_g_parm
,
891 .vidioc_s_parm
= bcap_s_parm
,
892 .vidioc_log_status
= bcap_log_status
,
895 static struct v4l2_file_operations bcap_fops
= {
896 .owner
= THIS_MODULE
,
898 .release
= bcap_release
,
899 .unlocked_ioctl
= video_ioctl2
,
902 .get_unmapped_area
= bcap_get_unmapped_area
,
907 static int bcap_probe(struct platform_device
*pdev
)
909 struct bcap_device
*bcap_dev
;
910 struct video_device
*vfd
;
911 struct i2c_adapter
*i2c_adap
;
912 struct bfin_capture_config
*config
;
914 struct bcap_route
*route
;
917 config
= pdev
->dev
.platform_data
;
918 if (!config
|| !config
->num_inputs
) {
919 v4l2_err(pdev
->dev
.driver
, "Unable to get board config\n");
923 bcap_dev
= kzalloc(sizeof(*bcap_dev
), GFP_KERNEL
);
925 v4l2_err(pdev
->dev
.driver
, "Unable to alloc bcap_dev\n");
929 bcap_dev
->cfg
= config
;
931 bcap_dev
->ppi
= ppi_create_instance(pdev
, config
->ppi_info
);
932 if (!bcap_dev
->ppi
) {
933 v4l2_err(pdev
->dev
.driver
, "Unable to create ppi\n");
937 bcap_dev
->ppi
->priv
= bcap_dev
;
939 bcap_dev
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
940 if (IS_ERR(bcap_dev
->alloc_ctx
)) {
941 ret
= PTR_ERR(bcap_dev
->alloc_ctx
);
945 vfd
= video_device_alloc();
948 v4l2_err(pdev
->dev
.driver
, "Unable to alloc video device\n");
949 goto err_cleanup_ctx
;
952 /* initialize field of video device */
953 vfd
->release
= video_device_release
;
954 vfd
->fops
= &bcap_fops
;
955 vfd
->ioctl_ops
= &bcap_ioctl_ops
;
957 vfd
->v4l2_dev
= &bcap_dev
->v4l2_dev
;
958 strncpy(vfd
->name
, CAPTURE_DRV_NAME
, sizeof(vfd
->name
));
959 bcap_dev
->video_dev
= vfd
;
961 ret
= v4l2_device_register(&pdev
->dev
, &bcap_dev
->v4l2_dev
);
963 v4l2_err(pdev
->dev
.driver
,
964 "Unable to register v4l2 device\n");
965 goto err_release_vdev
;
967 v4l2_info(&bcap_dev
->v4l2_dev
, "v4l2 device registered\n");
969 bcap_dev
->v4l2_dev
.ctrl_handler
= &bcap_dev
->ctrl_handler
;
970 ret
= v4l2_ctrl_handler_init(&bcap_dev
->ctrl_handler
, 0);
972 v4l2_err(&bcap_dev
->v4l2_dev
,
973 "Unable to init control handler\n");
977 spin_lock_init(&bcap_dev
->lock
);
978 /* initialize queue */
979 q
= &bcap_dev
->buffer_queue
;
980 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
981 q
->io_modes
= VB2_MMAP
;
982 q
->drv_priv
= bcap_dev
;
983 q
->buf_struct_size
= sizeof(struct bcap_buffer
);
984 q
->ops
= &bcap_video_qops
;
985 q
->mem_ops
= &vb2_dma_contig_memops
;
986 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
987 q
->lock
= &bcap_dev
->mutex
;
989 ret
= vb2_queue_init(q
);
991 goto err_free_handler
;
993 mutex_init(&bcap_dev
->mutex
);
994 init_completion(&bcap_dev
->comp
);
996 /* init video dma queues */
997 INIT_LIST_HEAD(&bcap_dev
->dma_queue
);
999 vfd
->lock
= &bcap_dev
->mutex
;
1001 /* register video device */
1002 ret
= video_register_device(bcap_dev
->video_dev
, VFL_TYPE_GRABBER
, -1);
1004 v4l2_err(&bcap_dev
->v4l2_dev
,
1005 "Unable to register video device\n");
1006 goto err_free_handler
;
1008 video_set_drvdata(bcap_dev
->video_dev
, bcap_dev
);
1009 v4l2_info(&bcap_dev
->v4l2_dev
, "video device registered as: %s\n",
1010 video_device_node_name(vfd
));
1012 /* load up the subdevice */
1013 i2c_adap
= i2c_get_adapter(config
->i2c_adapter_id
);
1015 v4l2_err(&bcap_dev
->v4l2_dev
,
1016 "Unable to find i2c adapter\n");
1018 goto err_unreg_vdev
;
1021 bcap_dev
->sd
= v4l2_i2c_new_subdev_board(&bcap_dev
->v4l2_dev
,
1023 &config
->board_info
,
1028 /* update tvnorms from the sub devices */
1029 for (i
= 0; i
< config
->num_inputs
; i
++)
1030 vfd
->tvnorms
|= config
->inputs
[i
].std
;
1032 v4l2_err(&bcap_dev
->v4l2_dev
,
1033 "Unable to register sub device\n");
1035 goto err_unreg_vdev
;
1038 v4l2_info(&bcap_dev
->v4l2_dev
, "v4l2 sub device registered\n");
1041 * explicitly set input, otherwise some boards
1042 * may not work at the state as we expected
1044 route
= &config
->routes
[0];
1045 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_routing
,
1046 route
->input
, route
->output
, 0);
1047 if ((ret
< 0) && (ret
!= -ENOIOCTLCMD
)) {
1048 v4l2_err(&bcap_dev
->v4l2_dev
, "Failed to set input\n");
1049 goto err_unreg_vdev
;
1051 bcap_dev
->cur_input
= 0;
1052 /* if this route has specific config, update ppi control */
1053 if (route
->ppi_control
)
1054 config
->ppi_control
= route
->ppi_control
;
1056 /* now we can probe the default state */
1057 if (config
->inputs
[0].capabilities
& V4L2_IN_CAP_STD
) {
1059 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, g_std
, &std
);
1061 v4l2_err(&bcap_dev
->v4l2_dev
,
1062 "Unable to get std\n");
1063 goto err_unreg_vdev
;
1065 bcap_dev
->std
= std
;
1067 if (config
->inputs
[0].capabilities
& V4L2_IN_CAP_DV_TIMINGS
) {
1068 struct v4l2_dv_timings dv_timings
;
1069 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
,
1070 g_dv_timings
, &dv_timings
);
1072 v4l2_err(&bcap_dev
->v4l2_dev
,
1073 "Unable to get dv timings\n");
1074 goto err_unreg_vdev
;
1076 bcap_dev
->dv_timings
= dv_timings
;
1078 ret
= bcap_init_sensor_formats(bcap_dev
);
1080 v4l2_err(&bcap_dev
->v4l2_dev
,
1081 "Unable to create sensor formats table\n");
1082 goto err_unreg_vdev
;
1086 video_unregister_device(bcap_dev
->video_dev
);
1087 bcap_dev
->video_dev
= NULL
;
1089 v4l2_ctrl_handler_free(&bcap_dev
->ctrl_handler
);
1091 v4l2_device_unregister(&bcap_dev
->v4l2_dev
);
1093 if (bcap_dev
->video_dev
)
1094 video_device_release(bcap_dev
->video_dev
);
1096 vb2_dma_contig_cleanup_ctx(bcap_dev
->alloc_ctx
);
1098 ppi_delete_instance(bcap_dev
->ppi
);
1104 static int bcap_remove(struct platform_device
*pdev
)
1106 struct v4l2_device
*v4l2_dev
= platform_get_drvdata(pdev
);
1107 struct bcap_device
*bcap_dev
= container_of(v4l2_dev
,
1108 struct bcap_device
, v4l2_dev
);
1110 bcap_free_sensor_formats(bcap_dev
);
1111 video_unregister_device(bcap_dev
->video_dev
);
1112 v4l2_ctrl_handler_free(&bcap_dev
->ctrl_handler
);
1113 v4l2_device_unregister(v4l2_dev
);
1114 vb2_dma_contig_cleanup_ctx(bcap_dev
->alloc_ctx
);
1115 ppi_delete_instance(bcap_dev
->ppi
);
1120 static struct platform_driver bcap_driver
= {
1122 .name
= CAPTURE_DRV_NAME
,
1124 .probe
= bcap_probe
,
1125 .remove
= bcap_remove
,
1127 module_platform_driver(bcap_driver
);
1129 MODULE_DESCRIPTION("Analog Devices blackfin video capture driver");
1130 MODULE_AUTHOR("Scott Jiang <Scott.Jiang.Linux@gmail.com>");
1131 MODULE_LICENSE("GPL v2");