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_prepare(struct vb2_buffer
*vb
)
307 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vb
->vb2_queue
);
308 struct bcap_buffer
*buf
= to_bcap_vb(vb
);
311 size
= bcap_dev
->fmt
.sizeimage
;
312 if (vb2_plane_size(vb
, 0) < size
) {
313 v4l2_err(&bcap_dev
->v4l2_dev
, "buffer too small (%lu < %lu)\n",
314 vb2_plane_size(vb
, 0), size
);
317 vb2_set_plane_payload(&buf
->vb
, 0, size
);
322 static void bcap_buffer_queue(struct vb2_buffer
*vb
)
324 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vb
->vb2_queue
);
325 struct bcap_buffer
*buf
= to_bcap_vb(vb
);
328 spin_lock_irqsave(&bcap_dev
->lock
, flags
);
329 list_add_tail(&buf
->list
, &bcap_dev
->dma_queue
);
330 spin_unlock_irqrestore(&bcap_dev
->lock
, flags
);
333 static void bcap_buffer_cleanup(struct vb2_buffer
*vb
)
335 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vb
->vb2_queue
);
336 struct bcap_buffer
*buf
= to_bcap_vb(vb
);
339 spin_lock_irqsave(&bcap_dev
->lock
, flags
);
340 list_del_init(&buf
->list
);
341 spin_unlock_irqrestore(&bcap_dev
->lock
, flags
);
344 static int bcap_start_streaming(struct vb2_queue
*vq
, unsigned int count
)
346 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vq
);
347 struct ppi_if
*ppi
= bcap_dev
->ppi
;
348 struct ppi_params params
;
351 /* enable streamon on the sub device */
352 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_stream
, 1);
353 if (ret
&& (ret
!= -ENOIOCTLCMD
)) {
354 v4l2_err(&bcap_dev
->v4l2_dev
, "stream on failed in subdev\n");
359 params
.width
= bcap_dev
->fmt
.width
;
360 params
.height
= bcap_dev
->fmt
.height
;
361 params
.bpp
= bcap_dev
->bpp
;
362 params
.dlen
= bcap_dev
->dlen
;
363 params
.ppi_control
= bcap_dev
->cfg
->ppi_control
;
364 params
.int_mask
= bcap_dev
->cfg
->int_mask
;
365 if (bcap_dev
->cfg
->inputs
[bcap_dev
->cur_input
].capabilities
366 & V4L2_IN_CAP_DV_TIMINGS
) {
367 struct v4l2_bt_timings
*bt
= &bcap_dev
->dv_timings
.bt
;
369 params
.hdelay
= bt
->hsync
+ bt
->hbackporch
;
370 params
.vdelay
= bt
->vsync
+ bt
->vbackporch
;
371 params
.line
= V4L2_DV_BT_FRAME_WIDTH(bt
);
372 params
.frame
= V4L2_DV_BT_FRAME_HEIGHT(bt
);
373 } else if (bcap_dev
->cfg
->inputs
[bcap_dev
->cur_input
].capabilities
377 if (bcap_dev
->std
& V4L2_STD_525_60
) {
387 params
.line
= params
.width
+ bcap_dev
->cfg
->blank_pixels
;
388 params
.frame
= params
.height
;
390 ret
= ppi
->ops
->set_params(ppi
, ¶ms
);
392 v4l2_err(&bcap_dev
->v4l2_dev
,
393 "Error in setting ppi params\n");
397 /* attach ppi DMA irq handler */
398 ret
= ppi
->ops
->attach_irq(ppi
, bcap_isr
);
400 v4l2_err(&bcap_dev
->v4l2_dev
,
401 "Error in attaching interrupt handler\n");
405 reinit_completion(&bcap_dev
->comp
);
406 bcap_dev
->stop
= false;
410 static void bcap_stop_streaming(struct vb2_queue
*vq
)
412 struct bcap_device
*bcap_dev
= vb2_get_drv_priv(vq
);
413 struct ppi_if
*ppi
= bcap_dev
->ppi
;
416 bcap_dev
->stop
= true;
417 wait_for_completion(&bcap_dev
->comp
);
419 ppi
->ops
->detach_irq(ppi
);
420 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_stream
, 0);
421 if (ret
&& (ret
!= -ENOIOCTLCMD
))
422 v4l2_err(&bcap_dev
->v4l2_dev
,
423 "stream off failed in subdev\n");
425 /* release all active buffers */
426 while (!list_empty(&bcap_dev
->dma_queue
)) {
427 bcap_dev
->cur_frm
= list_entry(bcap_dev
->dma_queue
.next
,
428 struct bcap_buffer
, list
);
429 list_del_init(&bcap_dev
->cur_frm
->list
);
430 vb2_buffer_done(&bcap_dev
->cur_frm
->vb
, VB2_BUF_STATE_ERROR
);
434 static struct vb2_ops bcap_video_qops
= {
435 .queue_setup
= bcap_queue_setup
,
436 .buf_prepare
= bcap_buffer_prepare
,
437 .buf_cleanup
= bcap_buffer_cleanup
,
438 .buf_queue
= bcap_buffer_queue
,
439 .wait_prepare
= vb2_ops_wait_prepare
,
440 .wait_finish
= vb2_ops_wait_finish
,
441 .start_streaming
= bcap_start_streaming
,
442 .stop_streaming
= bcap_stop_streaming
,
445 static int bcap_reqbufs(struct file
*file
, void *priv
,
446 struct v4l2_requestbuffers
*req_buf
)
448 struct bcap_device
*bcap_dev
= video_drvdata(file
);
449 struct vb2_queue
*vq
= &bcap_dev
->buffer_queue
;
450 struct v4l2_fh
*fh
= file
->private_data
;
451 struct bcap_fh
*bcap_fh
= container_of(fh
, struct bcap_fh
, fh
);
456 bcap_fh
->io_allowed
= true;
458 return vb2_reqbufs(vq
, req_buf
);
461 static int bcap_querybuf(struct file
*file
, void *priv
,
462 struct v4l2_buffer
*buf
)
464 struct bcap_device
*bcap_dev
= video_drvdata(file
);
466 return vb2_querybuf(&bcap_dev
->buffer_queue
, buf
);
469 static int bcap_qbuf(struct file
*file
, void *priv
,
470 struct v4l2_buffer
*buf
)
472 struct bcap_device
*bcap_dev
= video_drvdata(file
);
473 struct v4l2_fh
*fh
= file
->private_data
;
474 struct bcap_fh
*bcap_fh
= container_of(fh
, struct bcap_fh
, fh
);
476 if (!bcap_fh
->io_allowed
)
479 return vb2_qbuf(&bcap_dev
->buffer_queue
, buf
);
482 static int bcap_dqbuf(struct file
*file
, void *priv
,
483 struct v4l2_buffer
*buf
)
485 struct bcap_device
*bcap_dev
= video_drvdata(file
);
486 struct v4l2_fh
*fh
= file
->private_data
;
487 struct bcap_fh
*bcap_fh
= container_of(fh
, struct bcap_fh
, fh
);
489 if (!bcap_fh
->io_allowed
)
492 return vb2_dqbuf(&bcap_dev
->buffer_queue
,
493 buf
, file
->f_flags
& O_NONBLOCK
);
496 static irqreturn_t
bcap_isr(int irq
, void *dev_id
)
498 struct ppi_if
*ppi
= dev_id
;
499 struct bcap_device
*bcap_dev
= ppi
->priv
;
500 struct vb2_buffer
*vb
= &bcap_dev
->cur_frm
->vb
;
503 spin_lock(&bcap_dev
->lock
);
505 if (!list_empty(&bcap_dev
->dma_queue
)) {
506 v4l2_get_timestamp(&vb
->v4l2_buf
.timestamp
);
508 vb2_buffer_done(vb
, VB2_BUF_STATE_ERROR
);
511 vb2_buffer_done(vb
, VB2_BUF_STATE_DONE
);
513 bcap_dev
->cur_frm
= list_entry(bcap_dev
->dma_queue
.next
,
514 struct bcap_buffer
, list
);
515 list_del_init(&bcap_dev
->cur_frm
->list
);
517 /* clear error flag, we will get a new frame */
524 if (bcap_dev
->stop
) {
525 complete(&bcap_dev
->comp
);
527 addr
= vb2_dma_contig_plane_dma_addr(&bcap_dev
->cur_frm
->vb
, 0);
528 ppi
->ops
->update_addr(ppi
, (unsigned long)addr
);
529 ppi
->ops
->start(ppi
);
532 spin_unlock(&bcap_dev
->lock
);
537 static int bcap_streamon(struct file
*file
, void *priv
,
538 enum v4l2_buf_type buf_type
)
540 struct bcap_device
*bcap_dev
= video_drvdata(file
);
541 struct bcap_fh
*fh
= file
->private_data
;
542 struct ppi_if
*ppi
= bcap_dev
->ppi
;
549 /* call streamon to start streaming in videobuf */
550 ret
= vb2_streamon(&bcap_dev
->buffer_queue
, buf_type
);
554 /* if dma queue is empty, return error */
555 if (list_empty(&bcap_dev
->dma_queue
)) {
556 v4l2_err(&bcap_dev
->v4l2_dev
, "dma queue is empty\n");
561 /* get the next frame from the dma queue */
562 bcap_dev
->cur_frm
= list_entry(bcap_dev
->dma_queue
.next
,
563 struct bcap_buffer
, list
);
564 /* remove buffer from the dma queue */
565 list_del_init(&bcap_dev
->cur_frm
->list
);
566 addr
= vb2_dma_contig_plane_dma_addr(&bcap_dev
->cur_frm
->vb
, 0);
567 /* update DMA address */
568 ppi
->ops
->update_addr(ppi
, (unsigned long)addr
);
570 ppi
->ops
->start(ppi
);
574 vb2_streamoff(&bcap_dev
->buffer_queue
, buf_type
);
578 static int bcap_streamoff(struct file
*file
, void *priv
,
579 enum v4l2_buf_type buf_type
)
581 struct bcap_device
*bcap_dev
= video_drvdata(file
);
582 struct bcap_fh
*fh
= file
->private_data
;
587 return vb2_streamoff(&bcap_dev
->buffer_queue
, buf_type
);
590 static int bcap_querystd(struct file
*file
, void *priv
, v4l2_std_id
*std
)
592 struct bcap_device
*bcap_dev
= video_drvdata(file
);
594 return v4l2_subdev_call(bcap_dev
->sd
, video
, querystd
, std
);
597 static int bcap_g_std(struct file
*file
, void *priv
, v4l2_std_id
*std
)
599 struct bcap_device
*bcap_dev
= video_drvdata(file
);
601 *std
= bcap_dev
->std
;
605 static int bcap_s_std(struct file
*file
, void *priv
, v4l2_std_id std
)
607 struct bcap_device
*bcap_dev
= video_drvdata(file
);
610 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
613 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_std
, std
);
621 static int bcap_enum_dv_timings(struct file
*file
, void *priv
,
622 struct v4l2_enum_dv_timings
*timings
)
624 struct bcap_device
*bcap_dev
= video_drvdata(file
);
628 return v4l2_subdev_call(bcap_dev
->sd
, pad
,
629 enum_dv_timings
, timings
);
632 static int bcap_query_dv_timings(struct file
*file
, void *priv
,
633 struct v4l2_dv_timings
*timings
)
635 struct bcap_device
*bcap_dev
= video_drvdata(file
);
637 return v4l2_subdev_call(bcap_dev
->sd
, video
,
638 query_dv_timings
, timings
);
641 static int bcap_g_dv_timings(struct file
*file
, void *priv
,
642 struct v4l2_dv_timings
*timings
)
644 struct bcap_device
*bcap_dev
= video_drvdata(file
);
646 *timings
= bcap_dev
->dv_timings
;
650 static int bcap_s_dv_timings(struct file
*file
, void *priv
,
651 struct v4l2_dv_timings
*timings
)
653 struct bcap_device
*bcap_dev
= video_drvdata(file
);
655 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
658 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_dv_timings
, timings
);
662 bcap_dev
->dv_timings
= *timings
;
666 static int bcap_enum_input(struct file
*file
, void *priv
,
667 struct v4l2_input
*input
)
669 struct bcap_device
*bcap_dev
= video_drvdata(file
);
670 struct bfin_capture_config
*config
= bcap_dev
->cfg
;
674 if (input
->index
>= config
->num_inputs
)
677 *input
= config
->inputs
[input
->index
];
678 /* get input status */
679 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, g_input_status
, &status
);
681 input
->status
= status
;
685 static int bcap_g_input(struct file
*file
, void *priv
, unsigned int *index
)
687 struct bcap_device
*bcap_dev
= video_drvdata(file
);
689 *index
= bcap_dev
->cur_input
;
693 static int bcap_s_input(struct file
*file
, void *priv
, unsigned int index
)
695 struct bcap_device
*bcap_dev
= video_drvdata(file
);
696 struct bfin_capture_config
*config
= bcap_dev
->cfg
;
697 struct bcap_route
*route
;
700 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
703 if (index
>= config
->num_inputs
)
706 route
= &config
->routes
[index
];
707 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_routing
,
708 route
->input
, route
->output
, 0);
709 if ((ret
< 0) && (ret
!= -ENOIOCTLCMD
)) {
710 v4l2_err(&bcap_dev
->v4l2_dev
, "Failed to set input\n");
713 bcap_dev
->cur_input
= index
;
714 /* if this route has specific config, update ppi control */
715 if (route
->ppi_control
)
716 config
->ppi_control
= route
->ppi_control
;
720 static int bcap_try_format(struct bcap_device
*bcap
,
721 struct v4l2_pix_format
*pixfmt
,
722 struct bcap_format
*bcap_fmt
)
724 struct bcap_format
*sf
= bcap
->sensor_formats
;
725 struct bcap_format
*fmt
= NULL
;
726 struct v4l2_mbus_framefmt mbus_fmt
;
729 for (i
= 0; i
< bcap
->num_sensor_formats
; i
++) {
731 if (pixfmt
->pixelformat
== fmt
->pixelformat
)
734 if (i
== bcap
->num_sensor_formats
)
737 v4l2_fill_mbus_format(&mbus_fmt
, pixfmt
, fmt
->mbus_code
);
738 ret
= v4l2_subdev_call(bcap
->sd
, video
,
739 try_mbus_fmt
, &mbus_fmt
);
742 v4l2_fill_pix_format(pixfmt
, &mbus_fmt
);
744 for (i
= 0; i
< bcap
->num_sensor_formats
; i
++) {
746 if (mbus_fmt
.code
== fmt
->mbus_code
)
751 pixfmt
->bytesperline
= pixfmt
->width
* fmt
->bpp
/ 8;
752 pixfmt
->sizeimage
= pixfmt
->bytesperline
* pixfmt
->height
;
756 static int bcap_enum_fmt_vid_cap(struct file
*file
, void *priv
,
757 struct v4l2_fmtdesc
*fmt
)
759 struct bcap_device
*bcap_dev
= video_drvdata(file
);
760 struct bcap_format
*sf
= bcap_dev
->sensor_formats
;
762 if (fmt
->index
>= bcap_dev
->num_sensor_formats
)
765 fmt
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
766 strlcpy(fmt
->description
,
768 sizeof(fmt
->description
));
769 fmt
->pixelformat
= sf
[fmt
->index
].pixelformat
;
773 static int bcap_try_fmt_vid_cap(struct file
*file
, void *priv
,
774 struct v4l2_format
*fmt
)
776 struct bcap_device
*bcap_dev
= video_drvdata(file
);
777 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
779 return bcap_try_format(bcap_dev
, pixfmt
, NULL
);
782 static int bcap_g_fmt_vid_cap(struct file
*file
, void *priv
,
783 struct v4l2_format
*fmt
)
785 struct bcap_device
*bcap_dev
= video_drvdata(file
);
787 fmt
->fmt
.pix
= bcap_dev
->fmt
;
791 static int bcap_s_fmt_vid_cap(struct file
*file
, void *priv
,
792 struct v4l2_format
*fmt
)
794 struct bcap_device
*bcap_dev
= video_drvdata(file
);
795 struct v4l2_mbus_framefmt mbus_fmt
;
796 struct bcap_format bcap_fmt
;
797 struct v4l2_pix_format
*pixfmt
= &fmt
->fmt
.pix
;
800 if (vb2_is_busy(&bcap_dev
->buffer_queue
))
803 /* see if format works */
804 ret
= bcap_try_format(bcap_dev
, pixfmt
, &bcap_fmt
);
808 v4l2_fill_mbus_format(&mbus_fmt
, pixfmt
, bcap_fmt
.mbus_code
);
809 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_mbus_fmt
, &mbus_fmt
);
812 bcap_dev
->fmt
= *pixfmt
;
813 bcap_dev
->bpp
= bcap_fmt
.bpp
;
814 bcap_dev
->dlen
= bcap_fmt
.dlen
;
818 static int bcap_querycap(struct file
*file
, void *priv
,
819 struct v4l2_capability
*cap
)
821 struct bcap_device
*bcap_dev
= video_drvdata(file
);
823 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_STREAMING
;
824 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
825 strlcpy(cap
->driver
, CAPTURE_DRV_NAME
, sizeof(cap
->driver
));
826 strlcpy(cap
->bus_info
, "Blackfin Platform", sizeof(cap
->bus_info
));
827 strlcpy(cap
->card
, bcap_dev
->cfg
->card_name
, sizeof(cap
->card
));
831 static int bcap_g_parm(struct file
*file
, void *fh
,
832 struct v4l2_streamparm
*a
)
834 struct bcap_device
*bcap_dev
= video_drvdata(file
);
836 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
838 return v4l2_subdev_call(bcap_dev
->sd
, video
, g_parm
, a
);
841 static int bcap_s_parm(struct file
*file
, void *fh
,
842 struct v4l2_streamparm
*a
)
844 struct bcap_device
*bcap_dev
= video_drvdata(file
);
846 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
848 return v4l2_subdev_call(bcap_dev
->sd
, video
, s_parm
, a
);
851 static int bcap_log_status(struct file
*file
, void *priv
)
853 struct bcap_device
*bcap_dev
= video_drvdata(file
);
854 /* status for sub devices */
855 v4l2_device_call_all(&bcap_dev
->v4l2_dev
, 0, core
, log_status
);
859 static const struct v4l2_ioctl_ops bcap_ioctl_ops
= {
860 .vidioc_querycap
= bcap_querycap
,
861 .vidioc_g_fmt_vid_cap
= bcap_g_fmt_vid_cap
,
862 .vidioc_enum_fmt_vid_cap
= bcap_enum_fmt_vid_cap
,
863 .vidioc_s_fmt_vid_cap
= bcap_s_fmt_vid_cap
,
864 .vidioc_try_fmt_vid_cap
= bcap_try_fmt_vid_cap
,
865 .vidioc_enum_input
= bcap_enum_input
,
866 .vidioc_g_input
= bcap_g_input
,
867 .vidioc_s_input
= bcap_s_input
,
868 .vidioc_querystd
= bcap_querystd
,
869 .vidioc_s_std
= bcap_s_std
,
870 .vidioc_g_std
= bcap_g_std
,
871 .vidioc_s_dv_timings
= bcap_s_dv_timings
,
872 .vidioc_g_dv_timings
= bcap_g_dv_timings
,
873 .vidioc_query_dv_timings
= bcap_query_dv_timings
,
874 .vidioc_enum_dv_timings
= bcap_enum_dv_timings
,
875 .vidioc_reqbufs
= bcap_reqbufs
,
876 .vidioc_querybuf
= bcap_querybuf
,
877 .vidioc_qbuf
= bcap_qbuf
,
878 .vidioc_dqbuf
= bcap_dqbuf
,
879 .vidioc_streamon
= bcap_streamon
,
880 .vidioc_streamoff
= bcap_streamoff
,
881 .vidioc_g_parm
= bcap_g_parm
,
882 .vidioc_s_parm
= bcap_s_parm
,
883 .vidioc_log_status
= bcap_log_status
,
886 static struct v4l2_file_operations bcap_fops
= {
887 .owner
= THIS_MODULE
,
889 .release
= bcap_release
,
890 .unlocked_ioctl
= video_ioctl2
,
893 .get_unmapped_area
= bcap_get_unmapped_area
,
898 static int bcap_probe(struct platform_device
*pdev
)
900 struct bcap_device
*bcap_dev
;
901 struct video_device
*vfd
;
902 struct i2c_adapter
*i2c_adap
;
903 struct bfin_capture_config
*config
;
905 struct bcap_route
*route
;
908 config
= pdev
->dev
.platform_data
;
909 if (!config
|| !config
->num_inputs
) {
910 v4l2_err(pdev
->dev
.driver
, "Unable to get board config\n");
914 bcap_dev
= kzalloc(sizeof(*bcap_dev
), GFP_KERNEL
);
916 v4l2_err(pdev
->dev
.driver
, "Unable to alloc bcap_dev\n");
920 bcap_dev
->cfg
= config
;
922 bcap_dev
->ppi
= ppi_create_instance(pdev
, config
->ppi_info
);
923 if (!bcap_dev
->ppi
) {
924 v4l2_err(pdev
->dev
.driver
, "Unable to create ppi\n");
928 bcap_dev
->ppi
->priv
= bcap_dev
;
930 bcap_dev
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
931 if (IS_ERR(bcap_dev
->alloc_ctx
)) {
932 ret
= PTR_ERR(bcap_dev
->alloc_ctx
);
936 vfd
= video_device_alloc();
939 v4l2_err(pdev
->dev
.driver
, "Unable to alloc video device\n");
940 goto err_cleanup_ctx
;
943 /* initialize field of video device */
944 vfd
->release
= video_device_release
;
945 vfd
->fops
= &bcap_fops
;
946 vfd
->ioctl_ops
= &bcap_ioctl_ops
;
948 vfd
->v4l2_dev
= &bcap_dev
->v4l2_dev
;
949 strncpy(vfd
->name
, CAPTURE_DRV_NAME
, sizeof(vfd
->name
));
950 bcap_dev
->video_dev
= vfd
;
952 ret
= v4l2_device_register(&pdev
->dev
, &bcap_dev
->v4l2_dev
);
954 v4l2_err(pdev
->dev
.driver
,
955 "Unable to register v4l2 device\n");
956 goto err_release_vdev
;
958 v4l2_info(&bcap_dev
->v4l2_dev
, "v4l2 device registered\n");
960 bcap_dev
->v4l2_dev
.ctrl_handler
= &bcap_dev
->ctrl_handler
;
961 ret
= v4l2_ctrl_handler_init(&bcap_dev
->ctrl_handler
, 0);
963 v4l2_err(&bcap_dev
->v4l2_dev
,
964 "Unable to init control handler\n");
968 spin_lock_init(&bcap_dev
->lock
);
969 /* initialize queue */
970 q
= &bcap_dev
->buffer_queue
;
971 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
972 q
->io_modes
= VB2_MMAP
;
973 q
->drv_priv
= bcap_dev
;
974 q
->buf_struct_size
= sizeof(struct bcap_buffer
);
975 q
->ops
= &bcap_video_qops
;
976 q
->mem_ops
= &vb2_dma_contig_memops
;
977 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
978 q
->lock
= &bcap_dev
->mutex
;
980 ret
= vb2_queue_init(q
);
982 goto err_free_handler
;
984 mutex_init(&bcap_dev
->mutex
);
985 init_completion(&bcap_dev
->comp
);
987 /* init video dma queues */
988 INIT_LIST_HEAD(&bcap_dev
->dma_queue
);
990 vfd
->lock
= &bcap_dev
->mutex
;
992 /* register video device */
993 ret
= video_register_device(bcap_dev
->video_dev
, VFL_TYPE_GRABBER
, -1);
995 v4l2_err(&bcap_dev
->v4l2_dev
,
996 "Unable to register video device\n");
997 goto err_free_handler
;
999 video_set_drvdata(bcap_dev
->video_dev
, bcap_dev
);
1000 v4l2_info(&bcap_dev
->v4l2_dev
, "video device registered as: %s\n",
1001 video_device_node_name(vfd
));
1003 /* load up the subdevice */
1004 i2c_adap
= i2c_get_adapter(config
->i2c_adapter_id
);
1006 v4l2_err(&bcap_dev
->v4l2_dev
,
1007 "Unable to find i2c adapter\n");
1009 goto err_unreg_vdev
;
1012 bcap_dev
->sd
= v4l2_i2c_new_subdev_board(&bcap_dev
->v4l2_dev
,
1014 &config
->board_info
,
1019 /* update tvnorms from the sub devices */
1020 for (i
= 0; i
< config
->num_inputs
; i
++)
1021 vfd
->tvnorms
|= config
->inputs
[i
].std
;
1023 v4l2_err(&bcap_dev
->v4l2_dev
,
1024 "Unable to register sub device\n");
1026 goto err_unreg_vdev
;
1029 v4l2_info(&bcap_dev
->v4l2_dev
, "v4l2 sub device registered\n");
1032 * explicitly set input, otherwise some boards
1033 * may not work at the state as we expected
1035 route
= &config
->routes
[0];
1036 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, s_routing
,
1037 route
->input
, route
->output
, 0);
1038 if ((ret
< 0) && (ret
!= -ENOIOCTLCMD
)) {
1039 v4l2_err(&bcap_dev
->v4l2_dev
, "Failed to set input\n");
1040 goto err_unreg_vdev
;
1042 bcap_dev
->cur_input
= 0;
1043 /* if this route has specific config, update ppi control */
1044 if (route
->ppi_control
)
1045 config
->ppi_control
= route
->ppi_control
;
1047 /* now we can probe the default state */
1048 if (config
->inputs
[0].capabilities
& V4L2_IN_CAP_STD
) {
1050 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
, g_std
, &std
);
1052 v4l2_err(&bcap_dev
->v4l2_dev
,
1053 "Unable to get std\n");
1054 goto err_unreg_vdev
;
1056 bcap_dev
->std
= std
;
1058 if (config
->inputs
[0].capabilities
& V4L2_IN_CAP_DV_TIMINGS
) {
1059 struct v4l2_dv_timings dv_timings
;
1060 ret
= v4l2_subdev_call(bcap_dev
->sd
, video
,
1061 g_dv_timings
, &dv_timings
);
1063 v4l2_err(&bcap_dev
->v4l2_dev
,
1064 "Unable to get dv timings\n");
1065 goto err_unreg_vdev
;
1067 bcap_dev
->dv_timings
= dv_timings
;
1069 ret
= bcap_init_sensor_formats(bcap_dev
);
1071 v4l2_err(&bcap_dev
->v4l2_dev
,
1072 "Unable to create sensor formats table\n");
1073 goto err_unreg_vdev
;
1077 video_unregister_device(bcap_dev
->video_dev
);
1078 bcap_dev
->video_dev
= NULL
;
1080 v4l2_ctrl_handler_free(&bcap_dev
->ctrl_handler
);
1082 v4l2_device_unregister(&bcap_dev
->v4l2_dev
);
1084 if (bcap_dev
->video_dev
)
1085 video_device_release(bcap_dev
->video_dev
);
1087 vb2_dma_contig_cleanup_ctx(bcap_dev
->alloc_ctx
);
1089 ppi_delete_instance(bcap_dev
->ppi
);
1095 static int bcap_remove(struct platform_device
*pdev
)
1097 struct v4l2_device
*v4l2_dev
= platform_get_drvdata(pdev
);
1098 struct bcap_device
*bcap_dev
= container_of(v4l2_dev
,
1099 struct bcap_device
, v4l2_dev
);
1101 bcap_free_sensor_formats(bcap_dev
);
1102 video_unregister_device(bcap_dev
->video_dev
);
1103 v4l2_ctrl_handler_free(&bcap_dev
->ctrl_handler
);
1104 v4l2_device_unregister(v4l2_dev
);
1105 vb2_dma_contig_cleanup_ctx(bcap_dev
->alloc_ctx
);
1106 ppi_delete_instance(bcap_dev
->ppi
);
1111 static struct platform_driver bcap_driver
= {
1113 .name
= CAPTURE_DRV_NAME
,
1115 .probe
= bcap_probe
,
1116 .remove
= bcap_remove
,
1118 module_platform_driver(bcap_driver
);
1120 MODULE_DESCRIPTION("Analog Devices blackfin video capture driver");
1121 MODULE_AUTHOR("Scott Jiang <Scott.Jiang.Linux@gmail.com>");
1122 MODULE_LICENSE("GPL v2");