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 void bcap_lock(struct vb2_queue
*vq
)
354 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vq
);
355 mutex_lock(&bcap_dev
->mutex
);
358 static void bcap_unlock(struct vb2_queue
*vq
)
360 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vq
);
361 mutex_unlock(&bcap_dev
->mutex
);
364 static int bcap_start_streaming(struct vb2_queue
*vq
, unsigned int count
)
366 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vq
);
367 struct ppi_if
*ppi
= bcap_dev
->ppi
;
368 struct ppi_params params
;
371 /* enable streamon on the sub device */
372 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_stream
, 1);
373 if (ret
&& (ret
!= -ENOIOCTLCMD
)) {
374 v4l2_err(&bcap_dev
->v4l2_dev
, "stream on failed in subdev\n");
379 params
.width
= bcap_dev
->fmt
.width
;
380 params
.height
= bcap_dev
->fmt
.height
;
381 params
.bpp
= bcap_dev
->bpp
;
382 params
.dlen
= bcap_dev
->dlen
;
383 params
.ppi_control
= bcap_dev
->cfg
->ppi_control
;
384 params
.int_mask
= bcap_dev
->cfg
->int_mask
;
385 if (bcap_dev
->cfg
->inputs
[bcap_dev
->cur_input
].capabilities
386 & V4L2_IN_CAP_DV_TIMINGS
) {
387 struct v4l2_bt_timings
*bt
= &bcap_dev
->dv_timings
.bt
;
389 params
.hdelay
= bt
->hsync
+ bt
->hbackporch
;
390 params
.vdelay
= bt
->vsync
+ bt
->vbackporch
;
391 params
.line
= V4L2_DV_BT_FRAME_WIDTH(bt
);
392 params
.frame
= V4L2_DV_BT_FRAME_HEIGHT(bt
);
393 } else if (bcap_dev
->cfg
->inputs
[bcap_dev
->cur_input
].capabilities
397 if (bcap_dev
->std
& V4L2_STD_525_60
) {
407 params
.line
= params
.width
+ bcap_dev
->cfg
->blank_pixels
;
408 params
.frame
= params
.height
;
410 ret
= ppi
->ops
->set_params(ppi
, ¶ms
);
412 v4l2_err(&bcap_dev
->v4l2_dev
,
413 "Error in setting ppi params\n");
417 /* attach ppi DMA irq handler */
418 ret
= ppi
->ops
->attach_irq(ppi
, bcap_isr
);
420 v4l2_err(&bcap_dev
->v4l2_dev
,
421 "Error in attaching interrupt handler\n");
425 reinit_completion(&bcap_dev
->comp
);
426 bcap_dev
->stop
= false;
430 static void bcap_stop_streaming(struct vb2_queue
*vq
)
432 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vq
);
433 struct ppi_if
*ppi
= bcap_dev
->ppi
;
436 bcap_dev
->stop
= true;
437 wait_for_completion(&bcap_dev
->comp
);
439 ppi
->ops
->detach_irq(ppi
);
440 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_stream
, 0);
441 if (ret
&& (ret
!= -ENOIOCTLCMD
))
442 v4l2_err(&bcap_dev
->v4l2_dev
,
443 "stream off failed in subdev\n");
445 /* release all active buffers */
446 while (!list_empty(&bcap_dev
->dma_queue
)) {
447 bcap_dev
->cur_frm
= list_entry(bcap_dev
->dma_queue
.next
,
448 struct bcap_buffer
, list
);
449 list_del_init(&bcap_dev
->cur_frm
->list
);
450 vb2_buffer_done(&bcap_dev
->cur_frm
->vb
, VB2_BUF_STATE_ERROR
);
454 static struct vb2_ops bcap_video_qops
= {
455 .queue_setup
= bcap_queue_setup
,
456 .buf_init
= bcap_buffer_init
,
457 .buf_prepare
= bcap_buffer_prepare
,
458 .buf_cleanup
= bcap_buffer_cleanup
,
459 .buf_queue
= bcap_buffer_queue
,
460 .wait_prepare
= bcap_unlock
,
461 .wait_finish
= bcap_lock
,
462 .start_streaming
= bcap_start_streaming
,
463 .stop_streaming
= bcap_stop_streaming
,
466 static int bcap_reqbufs(struct file
*file
, void *priv
,
467 struct v4l2_requestbuffers
*req_buf
)
469 struct bcap_device
*bcap_dev
= video_drvdata(file
);
470 struct vb2_queue
*vq
= &bcap_dev
->buffer_queue
;
471 struct v4l2_fh
*fh
= file
->private_data
;
472 struct bcap_fh
*bcap_fh
= container_of(fh
, struct bcap_fh
, fh
);
477 bcap_fh
->io_allowed
= true;
479 return vb2_reqbufs(vq
, req_buf
);
482 static int bcap_querybuf(struct file
*file
, void *priv
,
483 struct v4l2_buffer
*buf
)
485 struct bcap_device
*bcap_dev
= video_drvdata(file
);
487 return vb2_querybuf(&bcap_dev
->buffer_queue
, buf
);
490 static int bcap_qbuf(struct file
*file
, void *priv
,
491 struct v4l2_buffer
*buf
)
493 struct bcap_device
*bcap_dev
= video_drvdata(file
);
494 struct v4l2_fh
*fh
= file
->private_data
;
495 struct bcap_fh
*bcap_fh
= container_of(fh
, struct bcap_fh
, fh
);
497 if (!bcap_fh
->io_allowed
)
500 return vb2_qbuf(&bcap_dev
->buffer_queue
, buf
);
503 static int bcap_dqbuf(struct file
*file
, void *priv
,
504 struct v4l2_buffer
*buf
)
506 struct bcap_device
*bcap_dev
= video_drvdata(file
);
507 struct v4l2_fh
*fh
= file
->private_data
;
508 struct bcap_fh
*bcap_fh
= container_of(fh
, struct bcap_fh
, fh
);
510 if (!bcap_fh
->io_allowed
)
513 return vb2_dqbuf(&bcap_dev
->buffer_queue
,
514 buf
, file
->f_flags
& O_NONBLOCK
);
517 static irqreturn_t
bcap_isr(int irq
, void *dev_id
)
519 struct ppi_if
*ppi
= dev_id
;
520 struct bcap_device
*bcap_dev
= ppi
->priv
;
521 struct vb2_buffer
*vb
= &bcap_dev
->cur_frm
->vb
;
524 spin_lock(&bcap_dev
->lock
);
526 if (!list_empty(&bcap_dev
->dma_queue
)) {
527 v4l2_get_timestamp(&vb
->v4l2_buf
.timestamp
);
529 vb2_buffer_done(vb
, VB2_BUF_STATE_ERROR
);
532 vb2_buffer_done(vb
, VB2_BUF_STATE_DONE
);
534 bcap_dev
->cur_frm
= list_entry(bcap_dev
->dma_queue
.next
,
535 struct bcap_buffer
, list
);
536 list_del_init(&bcap_dev
->cur_frm
->list
);
538 /* clear error flag, we will get a new frame */
545 if (bcap_dev
->stop
) {
546 complete(&bcap_dev
->comp
);
548 addr
= vb2_dma_contig_plane_dma_addr(&bcap_dev
->cur_frm
->vb
, 0);
549 ppi
->ops
->update_addr(ppi
, (unsigned long)addr
);
550 ppi
->ops
->start(ppi
);
553 spin_unlock(&bcap_dev
->lock
);
558 static int bcap_streamon(struct file
*file
, void *priv
,
559 enum v4l2_buf_type buf_type
)
561 struct bcap_device
*bcap_dev
= video_drvdata(file
);
562 struct bcap_fh
*fh
= file
->private_data
;
563 struct ppi_if
*ppi
= bcap_dev
->ppi
;
570 /* call streamon to start streaming in videobuf */
571 ret
= vb2_streamon(&bcap_dev
->buffer_queue
, buf_type
);
575 /* if dma queue is empty, return error */
576 if (list_empty(&bcap_dev
->dma_queue
)) {
577 v4l2_err(&bcap_dev
->v4l2_dev
, "dma queue is empty\n");
582 /* get the next frame from the dma queue */
583 bcap_dev
->cur_frm
= list_entry(bcap_dev
->dma_queue
.next
,
584 struct bcap_buffer
, list
);
585 /* remove buffer from the dma queue */
586 list_del_init(&bcap_dev
->cur_frm
->list
);
587 addr
= vb2_dma_contig_plane_dma_addr(&bcap_dev
->cur_frm
->vb
, 0);
588 /* update DMA address */
589 ppi
->ops
->update_addr(ppi
, (unsigned long)addr
);
591 ppi
->ops
->start(ppi
);
595 vb2_streamoff(&bcap_dev
->buffer_queue
, buf_type
);
599 static int bcap_streamoff(struct file
*file
, void *priv
,
600 enum v4l2_buf_type buf_type
)
602 struct bcap_device
*bcap_dev
= video_drvdata(file
);
603 struct bcap_fh
*fh
= file
->private_data
;
608 return vb2_streamoff(&bcap_dev
->buffer_queue
, buf_type
);
611 static int bcap_querystd(struct file
*file
, void *priv
, v4l2_std_id
*std
)
613 struct bcap_device
*bcap_dev
= video_drvdata(file
);
615 return v4l2_subdev_call(bcap_dev
->sd
, video
, querystd
, std
);
618 static int bcap_g_std(struct file
*file
, void *priv
, v4l2_std_id
*std
)
620 struct bcap_device
*bcap_dev
= video_drvdata(file
);
622 *std
= bcap_dev
->std
;
626 static int bcap_s_std(struct file
*file
, void *priv
, v4l2_std_id std
)
628 struct bcap_device
*bcap_dev
= video_drvdata(file
);
631 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
634 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_std
, std
);
642 static int bcap_enum_dv_timings(struct file
*file
, void *priv
,
643 struct v4l2_enum_dv_timings
*timings
)
645 struct bcap_device
*bcap_dev
= video_drvdata(file
);
649 return v4l2_subdev_call(bcap_dev
->sd
, pad
,
650 enum_dv_timings
, timings
);
653 static int bcap_query_dv_timings(struct file
*file
, void *priv
,
654 struct v4l2_dv_timings
*timings
)
656 struct bcap_device
*bcap_dev
= video_drvdata(file
);
658 return v4l2_subdev_call(bcap_dev
->sd
, video
,
659 query_dv_timings
, timings
);
662 static int bcap_g_dv_timings(struct file
*file
, void *priv
,
663 struct v4l2_dv_timings
*timings
)
665 struct bcap_device
*bcap_dev
= video_drvdata(file
);
667 *timings
= bcap_dev
->dv_timings
;
671 static int bcap_s_dv_timings(struct file
*file
, void *priv
,
672 struct v4l2_dv_timings
*timings
)
674 struct bcap_device
*bcap_dev
= video_drvdata(file
);
676 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
679 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_dv_timings
, timings
);
683 bcap_dev
->dv_timings
= *timings
;
687 static int bcap_enum_input(struct file
*file
, void *priv
,
688 struct v4l2_input
*input
)
690 struct bcap_device
*bcap_dev
= video_drvdata(file
);
691 struct bfin_capture_config
*config
= bcap_dev
->cfg
;
695 if (input
->index
>= config
->num_inputs
)
698 *input
= config
->inputs
[input
->index
];
699 /* get input status */
700 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, g_input_status
, &status
);
702 input
->status
= status
;
706 static int bcap_g_input(struct file
*file
, void *priv
, unsigned int *index
)
708 struct bcap_device
*bcap_dev
= video_drvdata(file
);
710 *index
= bcap_dev
->cur_input
;
714 static int bcap_s_input(struct file
*file
, void *priv
, unsigned int index
)
716 struct bcap_device
*bcap_dev
= video_drvdata(file
);
717 struct bfin_capture_config
*config
= bcap_dev
->cfg
;
718 struct bcap_route
*route
;
721 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
724 if (index
>= config
->num_inputs
)
727 route
= &config
->routes
[index
];
728 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_routing
,
729 route
->input
, route
->output
, 0);
730 if ((ret
< 0) && (ret
!= -ENOIOCTLCMD
)) {
731 v4l2_err(&bcap_dev
->v4l2_dev
, "Failed to set input\n");
734 bcap_dev
->cur_input
= index
;
735 /* if this route has specific config, update ppi control */
736 if (route
->ppi_control
)
737 config
->ppi_control
= route
->ppi_control
;
741 static int bcap_try_format(struct bcap_device
*bcap
,
742 struct v4l2_pix_format
*pixfmt
,
743 struct bcap_format
*bcap_fmt
)
745 struct bcap_format
*sf
= bcap
->sensor_formats
;
746 struct bcap_format
*fmt
= NULL
;
747 struct v4l2_mbus_framefmt mbus_fmt
;
750 for (i
= 0; i
< bcap
->num_sensor_formats
; i
++) {
752 if (pixfmt
->pixelformat
== fmt
->pixelformat
)
755 if (i
== bcap
->num_sensor_formats
)
758 v4l2_fill_mbus_format(&mbus_fmt
, pixfmt
, fmt
->mbus_code
);
759 ret
= v4l2_subdev_call(bcap
->sd
, video
,
760 try_mbus_fmt
, &mbus_fmt
);
763 v4l2_fill_pix_format(pixfmt
, &mbus_fmt
);
765 for (i
= 0; i
< bcap
->num_sensor_formats
; i
++) {
767 if (mbus_fmt
.code
== fmt
->mbus_code
)
772 pixfmt
->bytesperline
= pixfmt
->width
* fmt
->bpp
/ 8;
773 pixfmt
->sizeimage
= pixfmt
->bytesperline
* pixfmt
->height
;
777 static int bcap_enum_fmt_vid_cap(struct file
*file
, void *priv
,
778 struct v4l2_fmtdesc
*fmt
)
780 struct bcap_device
*bcap_dev
= video_drvdata(file
);
781 struct bcap_format
*sf
= bcap_dev
->sensor_formats
;
783 if (fmt
->index
>= bcap_dev
->num_sensor_formats
)
786 fmt
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
787 strlcpy(fmt
->description
,
789 sizeof(fmt
->description
));
790 fmt
->pixelformat
= sf
[fmt
->index
].pixelformat
;
794 static int bcap_try_fmt_vid_cap(struct file
*file
, void *priv
,
795 struct v4l2_format
*fmt
)
797 struct bcap_device
*bcap_dev
= video_drvdata(file
);
798 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
800 return bcap_try_format(bcap_dev
, pixfmt
, NULL
);
803 static int bcap_g_fmt_vid_cap(struct file
*file
, void *priv
,
804 struct v4l2_format
*fmt
)
806 struct bcap_device
*bcap_dev
= video_drvdata(file
);
808 fmt
->fmt
.pix
= bcap_dev
->fmt
;
812 static int bcap_s_fmt_vid_cap(struct file
*file
, void *priv
,
813 struct v4l2_format
*fmt
)
815 struct bcap_device
*bcap_dev
= video_drvdata(file
);
816 struct v4l2_mbus_framefmt mbus_fmt
;
817 struct bcap_format bcap_fmt
;
818 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
821 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
824 /* see if format works */
825 ret
= bcap_try_format(bcap_dev
, pixfmt
, &bcap_fmt
);
829 v4l2_fill_mbus_format(&mbus_fmt
, pixfmt
, bcap_fmt
.mbus_code
);
830 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_mbus_fmt
, &mbus_fmt
);
833 bcap_dev
->fmt
= *pixfmt
;
834 bcap_dev
->bpp
= bcap_fmt
.bpp
;
835 bcap_dev
->dlen
= bcap_fmt
.dlen
;
839 static int bcap_querycap(struct file
*file
, void *priv
,
840 struct v4l2_capability
*cap
)
842 struct bcap_device
*bcap_dev
= video_drvdata(file
);
844 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_STREAMING
;
845 strlcpy(cap
->driver
, CAPTURE_DRV_NAME
, sizeof(cap
->driver
));
846 strlcpy(cap
->bus_info
, "Blackfin Platform", sizeof(cap
->bus_info
));
847 strlcpy(cap
->card
, bcap_dev
->cfg
->card_name
, sizeof(cap
->card
));
851 static int bcap_g_parm(struct file
*file
, void *fh
,
852 struct v4l2_streamparm
*a
)
854 struct bcap_device
*bcap_dev
= video_drvdata(file
);
856 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
858 return v4l2_subdev_call(bcap_dev
->sd
, video
, g_parm
, a
);
861 static int bcap_s_parm(struct file
*file
, void *fh
,
862 struct v4l2_streamparm
*a
)
864 struct bcap_device
*bcap_dev
= video_drvdata(file
);
866 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
868 return v4l2_subdev_call(bcap_dev
->sd
, video
, s_parm
, a
);
871 static int bcap_log_status(struct file
*file
, void *priv
)
873 struct bcap_device
*bcap_dev
= video_drvdata(file
);
874 /* status for sub devices */
875 v4l2_device_call_all(&bcap_dev
->v4l2_dev
, 0, core
, log_status
);
879 static const struct v4l2_ioctl_ops bcap_ioctl_ops
= {
880 .vidioc_querycap
= bcap_querycap
,
881 .vidioc_g_fmt_vid_cap
= bcap_g_fmt_vid_cap
,
882 .vidioc_enum_fmt_vid_cap
= bcap_enum_fmt_vid_cap
,
883 .vidioc_s_fmt_vid_cap
= bcap_s_fmt_vid_cap
,
884 .vidioc_try_fmt_vid_cap
= bcap_try_fmt_vid_cap
,
885 .vidioc_enum_input
= bcap_enum_input
,
886 .vidioc_g_input
= bcap_g_input
,
887 .vidioc_s_input
= bcap_s_input
,
888 .vidioc_querystd
= bcap_querystd
,
889 .vidioc_s_std
= bcap_s_std
,
890 .vidioc_g_std
= bcap_g_std
,
891 .vidioc_s_dv_timings
= bcap_s_dv_timings
,
892 .vidioc_g_dv_timings
= bcap_g_dv_timings
,
893 .vidioc_query_dv_timings
= bcap_query_dv_timings
,
894 .vidioc_enum_dv_timings
= bcap_enum_dv_timings
,
895 .vidioc_reqbufs
= bcap_reqbufs
,
896 .vidioc_querybuf
= bcap_querybuf
,
897 .vidioc_qbuf
= bcap_qbuf
,
898 .vidioc_dqbuf
= bcap_dqbuf
,
899 .vidioc_streamon
= bcap_streamon
,
900 .vidioc_streamoff
= bcap_streamoff
,
901 .vidioc_g_parm
= bcap_g_parm
,
902 .vidioc_s_parm
= bcap_s_parm
,
903 .vidioc_log_status
= bcap_log_status
,
906 static struct v4l2_file_operations bcap_fops
= {
907 .owner
= THIS_MODULE
,
909 .release
= bcap_release
,
910 .unlocked_ioctl
= video_ioctl2
,
913 .get_unmapped_area
= bcap_get_unmapped_area
,
918 static int bcap_probe(struct platform_device
*pdev
)
920 struct bcap_device
*bcap_dev
;
921 struct video_device
*vfd
;
922 struct i2c_adapter
*i2c_adap
;
923 struct bfin_capture_config
*config
;
925 struct bcap_route
*route
;
928 config
= pdev
->dev
.platform_data
;
929 if (!config
|| !config
->num_inputs
) {
930 v4l2_err(pdev
->dev
.driver
, "Unable to get board config\n");
934 bcap_dev
= kzalloc(sizeof(*bcap_dev
), GFP_KERNEL
);
936 v4l2_err(pdev
->dev
.driver
, "Unable to alloc bcap_dev\n");
940 bcap_dev
->cfg
= config
;
942 bcap_dev
->ppi
= ppi_create_instance(pdev
, config
->ppi_info
);
943 if (!bcap_dev
->ppi
) {
944 v4l2_err(pdev
->dev
.driver
, "Unable to create ppi\n");
948 bcap_dev
->ppi
->priv
= bcap_dev
;
950 bcap_dev
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
951 if (IS_ERR(bcap_dev
->alloc_ctx
)) {
952 ret
= PTR_ERR(bcap_dev
->alloc_ctx
);
956 vfd
= video_device_alloc();
959 v4l2_err(pdev
->dev
.driver
, "Unable to alloc video device\n");
960 goto err_cleanup_ctx
;
963 /* initialize field of video device */
964 vfd
->release
= video_device_release
;
965 vfd
->fops
= &bcap_fops
;
966 vfd
->ioctl_ops
= &bcap_ioctl_ops
;
968 vfd
->v4l2_dev
= &bcap_dev
->v4l2_dev
;
969 strncpy(vfd
->name
, CAPTURE_DRV_NAME
, sizeof(vfd
->name
));
970 bcap_dev
->video_dev
= vfd
;
972 ret
= v4l2_device_register(&pdev
->dev
, &bcap_dev
->v4l2_dev
);
974 v4l2_err(pdev
->dev
.driver
,
975 "Unable to register v4l2 device\n");
976 goto err_release_vdev
;
978 v4l2_info(&bcap_dev
->v4l2_dev
, "v4l2 device registered\n");
980 bcap_dev
->v4l2_dev
.ctrl_handler
= &bcap_dev
->ctrl_handler
;
981 ret
= v4l2_ctrl_handler_init(&bcap_dev
->ctrl_handler
, 0);
983 v4l2_err(&bcap_dev
->v4l2_dev
,
984 "Unable to init control handler\n");
988 spin_lock_init(&bcap_dev
->lock
);
989 /* initialize queue */
990 q
= &bcap_dev
->buffer_queue
;
991 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
992 q
->io_modes
= VB2_MMAP
;
993 q
->drv_priv
= bcap_dev
;
994 q
->buf_struct_size
= sizeof(struct bcap_buffer
);
995 q
->ops
= &bcap_video_qops
;
996 q
->mem_ops
= &vb2_dma_contig_memops
;
997 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
999 ret
= vb2_queue_init(q
);
1001 goto err_free_handler
;
1003 mutex_init(&bcap_dev
->mutex
);
1004 init_completion(&bcap_dev
->comp
);
1006 /* init video dma queues */
1007 INIT_LIST_HEAD(&bcap_dev
->dma_queue
);
1009 vfd
->lock
= &bcap_dev
->mutex
;
1011 /* register video device */
1012 ret
= video_register_device(bcap_dev
->video_dev
, VFL_TYPE_GRABBER
, -1);
1014 v4l2_err(&bcap_dev
->v4l2_dev
,
1015 "Unable to register video device\n");
1016 goto err_free_handler
;
1018 video_set_drvdata(bcap_dev
->video_dev
, bcap_dev
);
1019 v4l2_info(&bcap_dev
->v4l2_dev
, "video device registered as: %s\n",
1020 video_device_node_name(vfd
));
1022 /* load up the subdevice */
1023 i2c_adap
= i2c_get_adapter(config
->i2c_adapter_id
);
1025 v4l2_err(&bcap_dev
->v4l2_dev
,
1026 "Unable to find i2c adapter\n");
1028 goto err_unreg_vdev
;
1031 bcap_dev
->sd
= v4l2_i2c_new_subdev_board(&bcap_dev
->v4l2_dev
,
1033 &config
->board_info
,
1038 /* update tvnorms from the sub devices */
1039 for (i
= 0; i
< config
->num_inputs
; i
++)
1040 vfd
->tvnorms
|= config
->inputs
[i
].std
;
1042 v4l2_err(&bcap_dev
->v4l2_dev
,
1043 "Unable to register sub device\n");
1045 goto err_unreg_vdev
;
1048 v4l2_info(&bcap_dev
->v4l2_dev
, "v4l2 sub device registered\n");
1051 * explicitly set input, otherwise some boards
1052 * may not work at the state as we expected
1054 route
= &config
->routes
[0];
1055 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_routing
,
1056 route
->input
, route
->output
, 0);
1057 if ((ret
< 0) && (ret
!= -ENOIOCTLCMD
)) {
1058 v4l2_err(&bcap_dev
->v4l2_dev
, "Failed to set input\n");
1059 goto err_unreg_vdev
;
1061 bcap_dev
->cur_input
= 0;
1062 /* if this route has specific config, update ppi control */
1063 if (route
->ppi_control
)
1064 config
->ppi_control
= route
->ppi_control
;
1066 /* now we can probe the default state */
1067 if (config
->inputs
[0].capabilities
& V4L2_IN_CAP_STD
) {
1069 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, g_std
, &std
);
1071 v4l2_err(&bcap_dev
->v4l2_dev
,
1072 "Unable to get std\n");
1073 goto err_unreg_vdev
;
1075 bcap_dev
->std
= std
;
1077 if (config
->inputs
[0].capabilities
& V4L2_IN_CAP_DV_TIMINGS
) {
1078 struct v4l2_dv_timings dv_timings
;
1079 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
,
1080 g_dv_timings
, &dv_timings
);
1082 v4l2_err(&bcap_dev
->v4l2_dev
,
1083 "Unable to get dv timings\n");
1084 goto err_unreg_vdev
;
1086 bcap_dev
->dv_timings
= dv_timings
;
1088 ret
= bcap_init_sensor_formats(bcap_dev
);
1090 v4l2_err(&bcap_dev
->v4l2_dev
,
1091 "Unable to create sensor formats table\n");
1092 goto err_unreg_vdev
;
1096 video_unregister_device(bcap_dev
->video_dev
);
1097 bcap_dev
->video_dev
= NULL
;
1099 v4l2_ctrl_handler_free(&bcap_dev
->ctrl_handler
);
1101 v4l2_device_unregister(&bcap_dev
->v4l2_dev
);
1103 if (bcap_dev
->video_dev
)
1104 video_device_release(bcap_dev
->video_dev
);
1106 vb2_dma_contig_cleanup_ctx(bcap_dev
->alloc_ctx
);
1108 ppi_delete_instance(bcap_dev
->ppi
);
1114 static int bcap_remove(struct platform_device
*pdev
)
1116 struct v4l2_device
*v4l2_dev
= platform_get_drvdata(pdev
);
1117 struct bcap_device
*bcap_dev
= container_of(v4l2_dev
,
1118 struct bcap_device
, v4l2_dev
);
1120 bcap_free_sensor_formats(bcap_dev
);
1121 video_unregister_device(bcap_dev
->video_dev
);
1122 v4l2_ctrl_handler_free(&bcap_dev
->ctrl_handler
);
1123 v4l2_device_unregister(v4l2_dev
);
1124 vb2_dma_contig_cleanup_ctx(bcap_dev
->alloc_ctx
);
1125 ppi_delete_instance(bcap_dev
->ppi
);
1130 static struct platform_driver bcap_driver
= {
1132 .name
= CAPTURE_DRV_NAME
,
1133 .owner
= THIS_MODULE
,
1135 .probe
= bcap_probe
,
1136 .remove
= bcap_remove
,
1138 module_platform_driver(bcap_driver
);
1140 MODULE_DESCRIPTION("Analog Devices blackfin video capture driver");
1141 MODULE_AUTHOR("Scott Jiang <Scott.Jiang.Linux@gmail.com>");
1142 MODULE_LICENSE("GPL v2");