2 em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB
5 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
6 Markus Rechberger <mrechberger@gmail.com>
7 Mauro Carvalho Chehab <mchehab@infradead.org>
8 Sascha Sommer <saschasommer@freenet.de>
9 Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
11 Some parts based on SN9C10x PC Camera Controllers GPL driver made
12 by Luca Risolia <luca.risolia@studio.unibo.it>
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 #include <linux/init.h>
30 #include <linux/list.h>
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/bitmap.h>
34 #include <linux/usb.h>
35 #include <linux/i2c.h>
37 #include <linux/mutex.h>
38 #include <linux/slab.h>
41 #include <media/v4l2-common.h>
42 #include <media/v4l2-ioctl.h>
43 #include <media/v4l2-event.h>
44 #include <media/v4l2-chip-ident.h>
45 #include <media/msp3400.h>
46 #include <media/tuner.h>
48 #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
49 "Markus Rechberger <mrechberger@gmail.com>, " \
50 "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
51 "Sascha Sommer <saschasommer@freenet.de>"
53 #define DRIVER_DESC "Empia em28xx based USB video device driver"
55 #define EM28XX_VERSION "0.2.0"
57 #define em28xx_videodbg(fmt, arg...) do {\
59 printk(KERN_INFO "%s %s :"fmt, \
60 dev->name, __func__ , ##arg); } while (0)
62 static unsigned int isoc_debug
;
63 module_param(isoc_debug
, int, 0644);
64 MODULE_PARM_DESC(isoc_debug
, "enable debug messages [isoc transfers]");
66 #define em28xx_isocdbg(fmt, arg...) \
69 printk(KERN_INFO "%s %s :"fmt, \
70 dev->name, __func__ , ##arg); \
74 MODULE_AUTHOR(DRIVER_AUTHOR
);
75 MODULE_DESCRIPTION(DRIVER_DESC
);
76 MODULE_LICENSE("GPL");
77 MODULE_VERSION(EM28XX_VERSION
);
79 static unsigned int video_nr
[] = {[0 ... (EM28XX_MAXBOARDS
- 1)] = -1U };
80 static unsigned int vbi_nr
[] = {[0 ... (EM28XX_MAXBOARDS
- 1)] = -1U };
81 static unsigned int radio_nr
[] = {[0 ... (EM28XX_MAXBOARDS
- 1)] = -1U };
83 module_param_array(video_nr
, int, NULL
, 0444);
84 module_param_array(vbi_nr
, int, NULL
, 0444);
85 module_param_array(radio_nr
, int, NULL
, 0444);
86 MODULE_PARM_DESC(video_nr
, "video device numbers");
87 MODULE_PARM_DESC(vbi_nr
, "vbi device numbers");
88 MODULE_PARM_DESC(radio_nr
, "radio device numbers");
90 static unsigned int video_debug
;
91 module_param(video_debug
, int, 0644);
92 MODULE_PARM_DESC(video_debug
, "enable debug messages [video]");
94 /* supported video standards */
95 static struct em28xx_fmt format
[] = {
97 .name
= "16 bpp YUY2, 4:2:2, packed",
98 .fourcc
= V4L2_PIX_FMT_YUYV
,
100 .reg
= EM28XX_OUTFMT_YUV422_Y0UY1V
,
102 .name
= "16 bpp RGB 565, LE",
103 .fourcc
= V4L2_PIX_FMT_RGB565
,
105 .reg
= EM28XX_OUTFMT_RGB_16_656
,
107 .name
= "8 bpp Bayer BGBG..GRGR",
108 .fourcc
= V4L2_PIX_FMT_SBGGR8
,
110 .reg
= EM28XX_OUTFMT_RGB_8_BGBG
,
112 .name
= "8 bpp Bayer GRGR..BGBG",
113 .fourcc
= V4L2_PIX_FMT_SGRBG8
,
115 .reg
= EM28XX_OUTFMT_RGB_8_GRGR
,
117 .name
= "8 bpp Bayer GBGB..RGRG",
118 .fourcc
= V4L2_PIX_FMT_SGBRG8
,
120 .reg
= EM28XX_OUTFMT_RGB_8_GBGB
,
122 .name
= "12 bpp YUV411",
123 .fourcc
= V4L2_PIX_FMT_YUV411P
,
125 .reg
= EM28XX_OUTFMT_YUV411
,
129 /* ------------------------------------------------------------------
130 DMA and thread functions
131 ------------------------------------------------------------------*/
134 * Finish the current buffer
136 static inline void finish_buffer(struct em28xx
*dev
,
137 struct em28xx_buffer
*buf
)
139 em28xx_isocdbg("[%p/%d] wakeup\n", buf
, buf
->top_field
);
141 buf
->vb
.v4l2_buf
.sequence
= dev
->field_count
++;
142 buf
->vb
.v4l2_buf
.field
= V4L2_FIELD_INTERLACED
;
143 v4l2_get_timestamp(&buf
->vb
.v4l2_buf
.timestamp
);
145 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_DONE
);
149 * Copy picture data from USB buffer to videobuf buffer
151 static void em28xx_copy_video(struct em28xx
*dev
,
152 struct em28xx_buffer
*buf
,
153 unsigned char *usb_buf
,
156 void *fieldstart
, *startwrite
, *startread
;
157 int linesdone
, currlinedone
, offset
, lencopy
, remain
;
158 int bytesperline
= dev
->width
<< 1;
160 if (buf
->pos
+ len
> buf
->length
)
161 len
= buf
->length
- buf
->pos
;
166 if (dev
->progressive
|| buf
->top_field
)
167 fieldstart
= buf
->vb_buf
;
168 else /* interlaced mode, even nr. of lines */
169 fieldstart
= buf
->vb_buf
+ bytesperline
;
171 linesdone
= buf
->pos
/ bytesperline
;
172 currlinedone
= buf
->pos
% bytesperline
;
174 if (dev
->progressive
)
175 offset
= linesdone
* bytesperline
+ currlinedone
;
177 offset
= linesdone
* bytesperline
* 2 + currlinedone
;
179 startwrite
= fieldstart
+ offset
;
180 lencopy
= bytesperline
- currlinedone
;
181 lencopy
= lencopy
> remain
? remain
: lencopy
;
183 if ((char *)startwrite
+ lencopy
> (char *)buf
->vb_buf
+ buf
->length
) {
184 em28xx_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
185 ((char *)startwrite
+ lencopy
) -
186 ((char *)buf
->vb_buf
+ buf
->length
));
187 remain
= (char *)buf
->vb_buf
+ buf
->length
-
193 memcpy(startwrite
, startread
, lencopy
);
198 if (dev
->progressive
)
199 startwrite
+= lencopy
;
201 startwrite
+= lencopy
+ bytesperline
;
202 startread
+= lencopy
;
203 if (bytesperline
> remain
)
206 lencopy
= bytesperline
;
208 if ((char *)startwrite
+ lencopy
> (char *)buf
->vb_buf
+
210 em28xx_isocdbg("Overflow of %zi bytes past buffer end"
212 ((char *)startwrite
+ lencopy
) -
213 ((char *)buf
->vb_buf
+ buf
->length
));
214 lencopy
= remain
= (char *)buf
->vb_buf
+ buf
->length
-
220 memcpy(startwrite
, startread
, lencopy
);
229 * Copy VBI data from USB buffer to videobuf buffer
231 static void em28xx_copy_vbi(struct em28xx
*dev
,
232 struct em28xx_buffer
*buf
,
233 unsigned char *usb_buf
,
238 if (buf
->pos
+ len
> buf
->length
)
239 len
= buf
->length
- buf
->pos
;
242 /* Make sure the bottom field populates the second half of the frame */
243 if (buf
->top_field
== 0)
244 offset
+= dev
->vbi_width
* dev
->vbi_height
;
246 memcpy(buf
->vb_buf
+ offset
, usb_buf
, len
);
250 static inline void print_err_status(struct em28xx
*dev
,
251 int packet
, int status
)
253 char *errmsg
= "Unknown";
257 errmsg
= "unlinked synchronuously";
260 errmsg
= "unlinked asynchronuously";
263 errmsg
= "Buffer error (overrun)";
266 errmsg
= "Stalled (device not responding)";
269 errmsg
= "Babble (bad cable?)";
272 errmsg
= "Bit-stuff error (bad cable?)";
275 errmsg
= "CRC/Timeout (could be anything)";
278 errmsg
= "Device does not respond";
282 em28xx_isocdbg("URB status %d [%s].\n", status
, errmsg
);
284 em28xx_isocdbg("URB packet %d, status %d [%s].\n",
285 packet
, status
, errmsg
);
290 * get the next available buffer from dma queue
292 static inline struct em28xx_buffer
*get_next_buf(struct em28xx
*dev
,
293 struct em28xx_dmaqueue
*dma_q
)
295 struct em28xx_buffer
*buf
;
297 if (list_empty(&dma_q
->active
)) {
298 em28xx_isocdbg("No active queue to serve\n");
302 /* Get the next buffer */
303 buf
= list_entry(dma_q
->active
.next
, struct em28xx_buffer
, list
);
304 /* Cleans up buffer - Useful for testing for frame/URB loss */
305 list_del(&buf
->list
);
307 buf
->vb_buf
= buf
->mem
;
313 * Finish the current buffer if completed and prepare for the next field
315 static struct em28xx_buffer
*
316 finish_field_prepare_next(struct em28xx
*dev
,
317 struct em28xx_buffer
*buf
,
318 struct em28xx_dmaqueue
*dma_q
)
320 if (dev
->progressive
|| dev
->top_field
) { /* Brand new frame */
322 finish_buffer(dev
, buf
);
323 buf
= get_next_buf(dev
, dma_q
);
326 buf
->top_field
= dev
->top_field
;
334 * Process data packet according to the em2710/em2750/em28xx frame data format
336 static inline void process_frame_data_em28xx(struct em28xx
*dev
,
337 unsigned char *data_pkt
,
338 unsigned int data_len
)
340 struct em28xx_buffer
*buf
= dev
->usb_ctl
.vid_buf
;
341 struct em28xx_buffer
*vbi_buf
= dev
->usb_ctl
.vbi_buf
;
342 struct em28xx_dmaqueue
*dma_q
= &dev
->vidq
;
343 struct em28xx_dmaqueue
*vbi_dma_q
= &dev
->vbiq
;
345 /* capture type 0 = vbi start
346 capture type 1 = vbi in progress
347 capture type 2 = video start
348 capture type 3 = video in progress */
350 /* NOTE: Headers are always 4 bytes and
351 * never split across packets */
352 if (data_pkt
[0] == 0x88 && data_pkt
[1] == 0x88 &&
353 data_pkt
[2] == 0x88 && data_pkt
[3] == 0x88) {
357 } else if (data_pkt
[0] == 0x33 && data_pkt
[1] == 0x95) {
358 /* Field start (VBI mode) */
359 dev
->capture_type
= 0;
361 em28xx_isocdbg("VBI START HEADER !!!\n");
362 dev
->top_field
= !(data_pkt
[2] & 1);
365 } else if (data_pkt
[0] == 0x22 && data_pkt
[1] == 0x5a) {
366 /* Field start (VBI disabled) */
367 dev
->capture_type
= 2;
368 em28xx_isocdbg("VIDEO START HEADER !!!\n");
369 dev
->top_field
= !(data_pkt
[2] & 1);
374 /* NOTE: With bulk transfers, intermediate data packets
375 * have no continuation header */
377 if (dev
->capture_type
== 0) {
378 vbi_buf
= finish_field_prepare_next(dev
, vbi_buf
, vbi_dma_q
);
379 dev
->usb_ctl
.vbi_buf
= vbi_buf
;
380 dev
->capture_type
= 1;
383 if (dev
->capture_type
== 1) {
384 int vbi_size
= dev
->vbi_width
* dev
->vbi_height
;
385 int vbi_data_len
= ((dev
->vbi_read
+ data_len
) > vbi_size
) ?
386 (vbi_size
- dev
->vbi_read
) : data_len
;
390 em28xx_copy_vbi(dev
, vbi_buf
, data_pkt
, vbi_data_len
);
391 dev
->vbi_read
+= vbi_data_len
;
393 if (vbi_data_len
< data_len
) {
394 /* Continue with copying video data */
395 dev
->capture_type
= 2;
396 data_pkt
+= vbi_data_len
;
397 data_len
-= vbi_data_len
;
401 if (dev
->capture_type
== 2) {
402 buf
= finish_field_prepare_next(dev
, buf
, dma_q
);
403 dev
->usb_ctl
.vid_buf
= buf
;
404 dev
->capture_type
= 3;
407 if (dev
->capture_type
== 3 && buf
!= NULL
&& data_len
> 0)
408 em28xx_copy_video(dev
, buf
, data_pkt
, data_len
);
411 /* Processes and copies the URB data content (video and VBI data) */
412 static inline int em28xx_urb_data_copy(struct em28xx
*dev
, struct urb
*urb
)
414 int xfer_bulk
, num_packets
, i
;
415 unsigned char *usb_data_pkt
;
416 unsigned int usb_data_len
;
421 if (dev
->disconnected
)
425 print_err_status(dev
, -1, urb
->status
);
427 xfer_bulk
= usb_pipebulk(urb
->pipe
);
429 if (xfer_bulk
) /* bulk */
432 num_packets
= urb
->number_of_packets
;
434 for (i
= 0; i
< num_packets
; i
++) {
435 if (xfer_bulk
) { /* bulk */
436 usb_data_len
= urb
->actual_length
;
438 usb_data_pkt
= urb
->transfer_buffer
;
440 if (urb
->iso_frame_desc
[i
].status
< 0) {
441 print_err_status(dev
, i
,
442 urb
->iso_frame_desc
[i
].status
);
443 if (urb
->iso_frame_desc
[i
].status
!= -EPROTO
)
447 usb_data_len
= urb
->iso_frame_desc
[i
].actual_length
;
448 if (usb_data_len
> dev
->max_pkt_size
) {
449 em28xx_isocdbg("packet bigger than packet size");
453 usb_data_pkt
= urb
->transfer_buffer
+
454 urb
->iso_frame_desc
[i
].offset
;
457 if (usb_data_len
== 0) {
458 /* NOTE: happens very often with isoc transfers */
459 /* em28xx_usbdbg("packet %d is empty",i); - spammy */
463 process_frame_data_em28xx(dev
, usb_data_pkt
, usb_data_len
);
469 static int get_ressource(enum v4l2_buf_type f_type
)
472 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
473 return EM28XX_RESOURCE_VIDEO
;
474 case V4L2_BUF_TYPE_VBI_CAPTURE
:
475 return EM28XX_RESOURCE_VBI
;
482 /* Usage lock check functions */
483 static int res_get(struct em28xx
*dev
, enum v4l2_buf_type f_type
)
485 int res_type
= get_ressource(f_type
);
488 if (dev
->resources
& res_type
) {
489 /* no, someone else uses it */
493 /* it's free, grab it */
494 dev
->resources
|= res_type
;
495 em28xx_videodbg("res: get %d\n", res_type
);
499 static void res_free(struct em28xx
*dev
, enum v4l2_buf_type f_type
)
501 int res_type
= get_ressource(f_type
);
503 dev
->resources
&= ~res_type
;
504 em28xx_videodbg("res: put %d\n", res_type
);
507 /* ------------------------------------------------------------------
509 ------------------------------------------------------------------*/
511 static int queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*fmt
,
512 unsigned int *nbuffers
, unsigned int *nplanes
,
513 unsigned int sizes
[], void *alloc_ctxs
[])
515 struct em28xx
*dev
= vb2_get_drv_priv(vq
);
519 size
= fmt
->fmt
.pix
.sizeimage
;
521 size
= (dev
->width
* dev
->height
* dev
->format
->depth
+ 7) >> 3;
536 buffer_prepare(struct vb2_buffer
*vb
)
538 struct em28xx
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
539 struct em28xx_buffer
*buf
= container_of(vb
, struct em28xx_buffer
, vb
);
542 em28xx_videodbg("%s, field=%d\n", __func__
, vb
->v4l2_buf
.field
);
544 size
= (dev
->width
* dev
->height
* dev
->format
->depth
+ 7) >> 3;
546 if (vb2_plane_size(vb
, 0) < size
) {
547 em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n",
548 __func__
, vb2_plane_size(vb
, 0), size
);
551 vb2_set_plane_payload(&buf
->vb
, 0, size
);
556 int em28xx_start_analog_streaming(struct vb2_queue
*vq
, unsigned int count
)
558 struct em28xx
*dev
= vb2_get_drv_priv(vq
);
559 struct v4l2_frequency f
;
562 em28xx_videodbg("%s\n", __func__
);
564 /* Make sure streaming is not already in progress for this type
565 of filehandle (e.g. video, vbi) */
566 rc
= res_get(dev
, vq
->type
);
570 if (dev
->streaming_users
++ == 0) {
571 /* First active streaming user, so allocate all the URBs */
573 /* Allocate the USB bandwidth */
574 em28xx_set_alternate(dev
);
576 /* Needed, since GPIO might have disabled power of
579 em28xx_wake_i2c(dev
);
581 dev
->capture_type
= -1;
582 rc
= em28xx_init_usb_xfer(dev
, EM28XX_ANALOG_MODE
,
583 dev
->analog_xfer_bulk
,
586 dev
->packet_multiplier
,
587 em28xx_urb_data_copy
);
592 * djh: it's not clear whether this code is still needed. I'm
593 * leaving it in here for now entirely out of concern for
594 * backward compatibility (the old code did it)
597 /* Ask tuner to go to analog or radio mode */
598 memset(&f
, 0, sizeof(f
));
599 f
.frequency
= dev
->ctl_freq
;
600 if (vq
->owner
&& vq
->owner
->vdev
->vfl_type
== VFL_TYPE_RADIO
)
601 f
.type
= V4L2_TUNER_RADIO
;
603 f
.type
= V4L2_TUNER_ANALOG_TV
;
604 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_frequency
, &f
);
611 static int em28xx_stop_streaming(struct vb2_queue
*vq
)
613 struct em28xx
*dev
= vb2_get_drv_priv(vq
);
614 struct em28xx_dmaqueue
*vidq
= &dev
->vidq
;
615 unsigned long flags
= 0;
617 em28xx_videodbg("%s\n", __func__
);
619 res_free(dev
, vq
->type
);
621 if (dev
->streaming_users
-- == 1) {
622 /* Last active user, so shutdown all the URBS */
623 em28xx_uninit_usb_xfer(dev
, EM28XX_ANALOG_MODE
);
626 spin_lock_irqsave(&dev
->slock
, flags
);
627 while (!list_empty(&vidq
->active
)) {
628 struct em28xx_buffer
*buf
;
629 buf
= list_entry(vidq
->active
.next
, struct em28xx_buffer
, list
);
630 list_del(&buf
->list
);
631 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
633 dev
->usb_ctl
.vid_buf
= NULL
;
634 spin_unlock_irqrestore(&dev
->slock
, flags
);
639 int em28xx_stop_vbi_streaming(struct vb2_queue
*vq
)
641 struct em28xx
*dev
= vb2_get_drv_priv(vq
);
642 struct em28xx_dmaqueue
*vbiq
= &dev
->vbiq
;
643 unsigned long flags
= 0;
645 em28xx_videodbg("%s\n", __func__
);
647 res_free(dev
, vq
->type
);
649 if (dev
->streaming_users
-- == 1) {
650 /* Last active user, so shutdown all the URBS */
651 em28xx_uninit_usb_xfer(dev
, EM28XX_ANALOG_MODE
);
654 spin_lock_irqsave(&dev
->slock
, flags
);
655 while (!list_empty(&vbiq
->active
)) {
656 struct em28xx_buffer
*buf
;
657 buf
= list_entry(vbiq
->active
.next
, struct em28xx_buffer
, list
);
658 list_del(&buf
->list
);
659 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
661 dev
->usb_ctl
.vbi_buf
= NULL
;
662 spin_unlock_irqrestore(&dev
->slock
, flags
);
668 buffer_queue(struct vb2_buffer
*vb
)
670 struct em28xx
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
671 struct em28xx_buffer
*buf
= container_of(vb
, struct em28xx_buffer
, vb
);
672 struct em28xx_dmaqueue
*vidq
= &dev
->vidq
;
673 unsigned long flags
= 0;
675 em28xx_videodbg("%s\n", __func__
);
676 buf
->mem
= vb2_plane_vaddr(vb
, 0);
677 buf
->length
= vb2_plane_size(vb
, 0);
679 spin_lock_irqsave(&dev
->slock
, flags
);
680 list_add_tail(&buf
->list
, &vidq
->active
);
681 spin_unlock_irqrestore(&dev
->slock
, flags
);
684 static struct vb2_ops em28xx_video_qops
= {
685 .queue_setup
= queue_setup
,
686 .buf_prepare
= buffer_prepare
,
687 .buf_queue
= buffer_queue
,
688 .start_streaming
= em28xx_start_analog_streaming
,
689 .stop_streaming
= em28xx_stop_streaming
,
690 .wait_prepare
= vb2_ops_wait_prepare
,
691 .wait_finish
= vb2_ops_wait_finish
,
694 int em28xx_vb2_setup(struct em28xx
*dev
)
699 /* Setup Videobuf2 for Video capture */
701 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
702 q
->io_modes
= VB2_READ
| VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
;
703 q
->timestamp_type
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
705 q
->buf_struct_size
= sizeof(struct em28xx_buffer
);
706 q
->ops
= &em28xx_video_qops
;
707 q
->mem_ops
= &vb2_vmalloc_memops
;
709 rc
= vb2_queue_init(q
);
713 /* Setup Videobuf2 for VBI capture */
715 q
->type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
716 q
->io_modes
= VB2_READ
| VB2_MMAP
| VB2_USERPTR
;
717 q
->timestamp_type
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
719 q
->buf_struct_size
= sizeof(struct em28xx_buffer
);
720 q
->ops
= &em28xx_vbi_qops
;
721 q
->mem_ops
= &vb2_vmalloc_memops
;
723 rc
= vb2_queue_init(q
);
730 /********************* v4l2 interface **************************************/
732 static void video_mux(struct em28xx
*dev
, int index
)
734 dev
->ctl_input
= index
;
735 dev
->ctl_ainput
= INPUT(index
)->amux
;
736 dev
->ctl_aoutput
= INPUT(index
)->aout
;
738 if (!dev
->ctl_aoutput
)
739 dev
->ctl_aoutput
= EM28XX_AOUT_MASTER
;
741 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, s_routing
,
742 INPUT(index
)->vmux
, 0, 0);
744 if (dev
->board
.has_msp34xx
) {
745 if (dev
->i2s_speed
) {
746 v4l2_device_call_all(&dev
->v4l2_dev
, 0, audio
,
747 s_i2s_clock_freq
, dev
->i2s_speed
);
749 /* Note: this is msp3400 specific */
750 v4l2_device_call_all(&dev
->v4l2_dev
, 0, audio
, s_routing
,
751 dev
->ctl_ainput
, MSP_OUTPUT(MSP_SC_IN_DSP_SCART1
), 0);
754 if (dev
->board
.adecoder
!= EM28XX_NOADECODER
) {
755 v4l2_device_call_all(&dev
->v4l2_dev
, 0, audio
, s_routing
,
756 dev
->ctl_ainput
, dev
->ctl_aoutput
, 0);
759 em28xx_audio_analog_set(dev
);
762 void em28xx_ctrl_notify(struct v4l2_ctrl
*ctrl
, void *priv
)
764 struct em28xx
*dev
= priv
;
767 * In the case of non-AC97 volume controls, we still need
768 * to do some setups at em28xx, in order to mute/unmute
769 * and to adjust audio volume. However, the value ranges
770 * should be checked by the corresponding V4L subdriver.
773 case V4L2_CID_AUDIO_MUTE
:
774 dev
->mute
= ctrl
->val
;
775 em28xx_audio_analog_set(dev
);
777 case V4L2_CID_AUDIO_VOLUME
:
778 dev
->volume
= ctrl
->val
;
779 em28xx_audio_analog_set(dev
);
784 static int em28xx_s_ctrl(struct v4l2_ctrl
*ctrl
)
786 struct em28xx
*dev
= container_of(ctrl
->handler
, struct em28xx
, ctrl_handler
);
790 case V4L2_CID_AUDIO_MUTE
:
791 dev
->mute
= ctrl
->val
;
792 ret
= em28xx_audio_analog_set(dev
);
794 case V4L2_CID_AUDIO_VOLUME
:
795 dev
->volume
= ctrl
->val
;
796 ret
= em28xx_audio_analog_set(dev
);
798 case V4L2_CID_CONTRAST
:
799 ret
= em28xx_write_reg(dev
, EM28XX_R20_YGAIN
, ctrl
->val
);
801 case V4L2_CID_BRIGHTNESS
:
802 ret
= em28xx_write_reg(dev
, EM28XX_R21_YOFFSET
, ctrl
->val
);
804 case V4L2_CID_SATURATION
:
805 ret
= em28xx_write_reg(dev
, EM28XX_R22_UVGAIN
, ctrl
->val
);
807 case V4L2_CID_BLUE_BALANCE
:
808 ret
= em28xx_write_reg(dev
, EM28XX_R23_UOFFSET
, ctrl
->val
);
810 case V4L2_CID_RED_BALANCE
:
811 ret
= em28xx_write_reg(dev
, EM28XX_R24_VOFFSET
, ctrl
->val
);
813 case V4L2_CID_SHARPNESS
:
814 ret
= em28xx_write_reg(dev
, EM28XX_R25_SHARPNESS
, ctrl
->val
);
818 return (ret
< 0) ? ret
: 0;
821 const struct v4l2_ctrl_ops em28xx_ctrl_ops
= {
822 .s_ctrl
= em28xx_s_ctrl
,
825 static void size_to_scale(struct em28xx
*dev
,
826 unsigned int width
, unsigned int height
,
827 unsigned int *hscale
, unsigned int *vscale
)
829 unsigned int maxw
= norm_maxw(dev
);
830 unsigned int maxh
= norm_maxh(dev
);
832 *hscale
= (((unsigned long)maxw
) << 12) / width
- 4096L;
833 if (*hscale
> EM28XX_HVSCALE_MAX
)
834 *hscale
= EM28XX_HVSCALE_MAX
;
836 *vscale
= (((unsigned long)maxh
) << 12) / height
- 4096L;
837 if (*vscale
> EM28XX_HVSCALE_MAX
)
838 *vscale
= EM28XX_HVSCALE_MAX
;
841 static void scale_to_size(struct em28xx
*dev
,
842 unsigned int hscale
, unsigned int vscale
,
843 unsigned int *width
, unsigned int *height
)
845 unsigned int maxw
= norm_maxw(dev
);
846 unsigned int maxh
= norm_maxh(dev
);
848 *width
= (((unsigned long)maxw
) << 12) / (hscale
+ 4096L);
849 *height
= (((unsigned long)maxh
) << 12) / (vscale
+ 4096L);
852 /* ------------------------------------------------------------------
853 IOCTL vidioc handling
854 ------------------------------------------------------------------*/
856 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
857 struct v4l2_format
*f
)
859 struct em28xx_fh
*fh
= priv
;
860 struct em28xx
*dev
= fh
->dev
;
862 f
->fmt
.pix
.width
= dev
->width
;
863 f
->fmt
.pix
.height
= dev
->height
;
864 f
->fmt
.pix
.pixelformat
= dev
->format
->fourcc
;
865 f
->fmt
.pix
.bytesperline
= (dev
->width
* dev
->format
->depth
+ 7) >> 3;
866 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
* dev
->height
;
867 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
869 /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
870 if (dev
->progressive
)
871 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
873 f
->fmt
.pix
.field
= dev
->interlaced
?
874 V4L2_FIELD_INTERLACED
: V4L2_FIELD_TOP
;
878 static struct em28xx_fmt
*format_by_fourcc(unsigned int fourcc
)
882 for (i
= 0; i
< ARRAY_SIZE(format
); i
++)
883 if (format
[i
].fourcc
== fourcc
)
889 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
890 struct v4l2_format
*f
)
892 struct em28xx_fh
*fh
= priv
;
893 struct em28xx
*dev
= fh
->dev
;
894 unsigned int width
= f
->fmt
.pix
.width
;
895 unsigned int height
= f
->fmt
.pix
.height
;
896 unsigned int maxw
= norm_maxw(dev
);
897 unsigned int maxh
= norm_maxh(dev
);
898 unsigned int hscale
, vscale
;
899 struct em28xx_fmt
*fmt
;
901 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
903 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
904 f
->fmt
.pix
.pixelformat
);
908 if (dev
->board
.is_em2800
) {
909 /* the em2800 can only scale down to 50% */
910 height
= height
> (3 * maxh
/ 4) ? maxh
: maxh
/ 2;
911 width
= width
> (3 * maxw
/ 4) ? maxw
: maxw
/ 2;
913 * MaxPacketSize for em2800 is too small to capture at full
914 * resolution use half of maxw as the scaler can only scale
917 if (width
== maxw
&& height
== maxh
)
920 /* width must even because of the YUYV format
921 height must be even because of interlacing */
922 v4l_bound_align_image(&width
, 48, maxw
, 1, &height
, 32, maxh
,
926 size_to_scale(dev
, width
, height
, &hscale
, &vscale
);
927 scale_to_size(dev
, hscale
, hscale
, &width
, &height
);
929 f
->fmt
.pix
.width
= width
;
930 f
->fmt
.pix
.height
= height
;
931 f
->fmt
.pix
.pixelformat
= fmt
->fourcc
;
932 f
->fmt
.pix
.bytesperline
= (width
* fmt
->depth
+ 7) >> 3;
933 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
* height
;
934 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
935 if (dev
->progressive
)
936 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
938 f
->fmt
.pix
.field
= dev
->interlaced
?
939 V4L2_FIELD_INTERLACED
: V4L2_FIELD_TOP
;
944 static int em28xx_set_video_format(struct em28xx
*dev
, unsigned int fourcc
,
945 unsigned width
, unsigned height
)
947 struct em28xx_fmt
*fmt
;
949 fmt
= format_by_fourcc(fourcc
);
955 dev
->height
= height
;
957 /* set new image size */
958 size_to_scale(dev
, dev
->width
, dev
->height
, &dev
->hscale
, &dev
->vscale
);
960 em28xx_resolution_set(dev
);
965 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
966 struct v4l2_format
*f
)
968 struct em28xx
*dev
= video_drvdata(file
);
970 if (dev
->streaming_users
> 0)
973 vidioc_try_fmt_vid_cap(file
, priv
, f
);
975 return em28xx_set_video_format(dev
, f
->fmt
.pix
.pixelformat
,
976 f
->fmt
.pix
.width
, f
->fmt
.pix
.height
);
979 static int vidioc_g_std(struct file
*file
, void *priv
, v4l2_std_id
*norm
)
981 struct em28xx_fh
*fh
= priv
;
982 struct em28xx
*dev
= fh
->dev
;
989 static int vidioc_querystd(struct file
*file
, void *priv
, v4l2_std_id
*norm
)
991 struct em28xx_fh
*fh
= priv
;
992 struct em28xx
*dev
= fh
->dev
;
994 v4l2_device_call_all(&dev
->v4l2_dev
, 0, video
, querystd
, norm
);
999 static int vidioc_s_std(struct file
*file
, void *priv
, v4l2_std_id
*norm
)
1001 struct em28xx_fh
*fh
= priv
;
1002 struct em28xx
*dev
= fh
->dev
;
1003 struct v4l2_format f
;
1005 if (*norm
== dev
->norm
)
1008 if (dev
->streaming_users
> 0)
1013 /* Adjusts width/height, if needed */
1014 f
.fmt
.pix
.width
= 720;
1015 f
.fmt
.pix
.height
= (*norm
& V4L2_STD_525_60
) ? 480 : 576;
1016 vidioc_try_fmt_vid_cap(file
, priv
, &f
);
1018 /* set new image size */
1019 dev
->width
= f
.fmt
.pix
.width
;
1020 dev
->height
= f
.fmt
.pix
.height
;
1021 size_to_scale(dev
, dev
->width
, dev
->height
, &dev
->hscale
, &dev
->vscale
);
1023 em28xx_resolution_set(dev
);
1024 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, s_std
, dev
->norm
);
1029 static int vidioc_g_parm(struct file
*file
, void *priv
,
1030 struct v4l2_streamparm
*p
)
1032 struct em28xx_fh
*fh
= priv
;
1033 struct em28xx
*dev
= fh
->dev
;
1036 p
->parm
.capture
.readbuffers
= EM28XX_MIN_BUF
;
1037 if (dev
->board
.is_webcam
)
1038 rc
= v4l2_device_call_until_err(&dev
->v4l2_dev
, 0,
1041 v4l2_video_std_frame_period(dev
->norm
,
1042 &p
->parm
.capture
.timeperframe
);
1047 static int vidioc_s_parm(struct file
*file
, void *priv
,
1048 struct v4l2_streamparm
*p
)
1050 struct em28xx_fh
*fh
= priv
;
1051 struct em28xx
*dev
= fh
->dev
;
1053 p
->parm
.capture
.readbuffers
= EM28XX_MIN_BUF
;
1054 return v4l2_device_call_until_err(&dev
->v4l2_dev
, 0, video
, s_parm
, p
);
1057 static const char *iname
[] = {
1058 [EM28XX_VMUX_COMPOSITE1
] = "Composite1",
1059 [EM28XX_VMUX_COMPOSITE2
] = "Composite2",
1060 [EM28XX_VMUX_COMPOSITE3
] = "Composite3",
1061 [EM28XX_VMUX_COMPOSITE4
] = "Composite4",
1062 [EM28XX_VMUX_SVIDEO
] = "S-Video",
1063 [EM28XX_VMUX_TELEVISION
] = "Television",
1064 [EM28XX_VMUX_CABLE
] = "Cable TV",
1065 [EM28XX_VMUX_DVB
] = "DVB",
1066 [EM28XX_VMUX_DEBUG
] = "for debug only",
1069 static int vidioc_enum_input(struct file
*file
, void *priv
,
1070 struct v4l2_input
*i
)
1072 struct em28xx_fh
*fh
= priv
;
1073 struct em28xx
*dev
= fh
->dev
;
1077 if (n
>= MAX_EM28XX_INPUT
)
1079 if (0 == INPUT(n
)->type
)
1083 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1085 strcpy(i
->name
, iname
[INPUT(n
)->type
]);
1087 if ((EM28XX_VMUX_TELEVISION
== INPUT(n
)->type
) ||
1088 (EM28XX_VMUX_CABLE
== INPUT(n
)->type
))
1089 i
->type
= V4L2_INPUT_TYPE_TUNER
;
1091 i
->std
= dev
->vdev
->tvnorms
;
1092 /* webcams do not have the STD API */
1093 if (dev
->board
.is_webcam
)
1094 i
->capabilities
= 0;
1099 static int vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1101 struct em28xx_fh
*fh
= priv
;
1102 struct em28xx
*dev
= fh
->dev
;
1104 *i
= dev
->ctl_input
;
1109 static int vidioc_s_input(struct file
*file
, void *priv
, unsigned int i
)
1111 struct em28xx_fh
*fh
= priv
;
1112 struct em28xx
*dev
= fh
->dev
;
1114 if (i
>= MAX_EM28XX_INPUT
)
1116 if (0 == INPUT(i
)->type
)
1123 static int vidioc_g_audio(struct file
*file
, void *priv
, struct v4l2_audio
*a
)
1125 struct em28xx_fh
*fh
= priv
;
1126 struct em28xx
*dev
= fh
->dev
;
1129 case EM28XX_AMUX_VIDEO
:
1130 strcpy(a
->name
, "Television");
1132 case EM28XX_AMUX_LINE_IN
:
1133 strcpy(a
->name
, "Line In");
1135 case EM28XX_AMUX_VIDEO2
:
1136 strcpy(a
->name
, "Television alt");
1138 case EM28XX_AMUX_PHONE
:
1139 strcpy(a
->name
, "Phone");
1141 case EM28XX_AMUX_MIC
:
1142 strcpy(a
->name
, "Mic");
1144 case EM28XX_AMUX_CD
:
1145 strcpy(a
->name
, "CD");
1147 case EM28XX_AMUX_AUX
:
1148 strcpy(a
->name
, "Aux");
1150 case EM28XX_AMUX_PCM_OUT
:
1151 strcpy(a
->name
, "PCM");
1157 a
->index
= dev
->ctl_ainput
;
1158 a
->capability
= V4L2_AUDCAP_STEREO
;
1163 static int vidioc_s_audio(struct file
*file
, void *priv
, const struct v4l2_audio
*a
)
1165 struct em28xx_fh
*fh
= priv
;
1166 struct em28xx
*dev
= fh
->dev
;
1168 if (a
->index
>= MAX_EM28XX_INPUT
)
1170 if (0 == INPUT(a
->index
)->type
)
1173 dev
->ctl_ainput
= INPUT(a
->index
)->amux
;
1174 dev
->ctl_aoutput
= INPUT(a
->index
)->aout
;
1176 if (!dev
->ctl_aoutput
)
1177 dev
->ctl_aoutput
= EM28XX_AOUT_MASTER
;
1182 static int vidioc_g_tuner(struct file
*file
, void *priv
,
1183 struct v4l2_tuner
*t
)
1185 struct em28xx_fh
*fh
= priv
;
1186 struct em28xx
*dev
= fh
->dev
;
1191 strcpy(t
->name
, "Tuner");
1193 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, g_tuner
, t
);
1197 static int vidioc_s_tuner(struct file
*file
, void *priv
,
1198 struct v4l2_tuner
*t
)
1200 struct em28xx_fh
*fh
= priv
;
1201 struct em28xx
*dev
= fh
->dev
;
1206 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_tuner
, t
);
1210 static int vidioc_g_frequency(struct file
*file
, void *priv
,
1211 struct v4l2_frequency
*f
)
1213 struct em28xx_fh
*fh
= priv
;
1214 struct em28xx
*dev
= fh
->dev
;
1219 f
->frequency
= dev
->ctl_freq
;
1223 static int vidioc_s_frequency(struct file
*file
, void *priv
,
1224 const struct v4l2_frequency
*f
)
1226 struct v4l2_frequency new_freq
= *f
;
1227 struct em28xx_fh
*fh
= priv
;
1228 struct em28xx
*dev
= fh
->dev
;
1233 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_frequency
, f
);
1234 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, g_frequency
, &new_freq
);
1235 dev
->ctl_freq
= new_freq
.frequency
;
1240 static int vidioc_g_chip_ident(struct file
*file
, void *priv
,
1241 struct v4l2_dbg_chip_ident
*chip
)
1243 struct em28xx_fh
*fh
= priv
;
1244 struct em28xx
*dev
= fh
->dev
;
1246 chip
->ident
= V4L2_IDENT_NONE
;
1248 if (chip
->match
.type
== V4L2_CHIP_MATCH_HOST
) {
1249 if (v4l2_chip_match_host(&chip
->match
))
1250 chip
->ident
= V4L2_IDENT_NONE
;
1253 if (chip
->match
.type
!= V4L2_CHIP_MATCH_I2C_DRIVER
&&
1254 chip
->match
.type
!= V4L2_CHIP_MATCH_I2C_ADDR
)
1257 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, g_chip_ident
, chip
);
1262 #ifdef CONFIG_VIDEO_ADV_DEBUG
1263 static int em28xx_reg_len(int reg
)
1266 case EM28XX_R40_AC97LSB
:
1267 case EM28XX_R30_HSCALELOW
:
1268 case EM28XX_R32_VSCALELOW
:
1275 static int vidioc_g_register(struct file
*file
, void *priv
,
1276 struct v4l2_dbg_register
*reg
)
1278 struct em28xx_fh
*fh
= priv
;
1279 struct em28xx
*dev
= fh
->dev
;
1282 switch (reg
->match
.type
) {
1283 case V4L2_CHIP_MATCH_AC97
:
1284 ret
= em28xx_read_ac97(dev
, reg
->reg
);
1291 case V4L2_CHIP_MATCH_I2C_DRIVER
:
1292 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, g_register
, reg
);
1294 case V4L2_CHIP_MATCH_I2C_ADDR
:
1295 /* TODO: is this correct? */
1296 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, g_register
, reg
);
1299 if (!v4l2_chip_match_host(®
->match
))
1304 reg
->size
= em28xx_reg_len(reg
->reg
);
1305 if (reg
->size
== 1) {
1306 ret
= em28xx_read_reg(dev
, reg
->reg
);
1314 ret
= em28xx_read_reg_req_len(dev
, USB_REQ_GET_STATUS
,
1315 reg
->reg
, (char *)&val
, 2);
1319 reg
->val
= le16_to_cpu(val
);
1325 static int vidioc_s_register(struct file
*file
, void *priv
,
1326 struct v4l2_dbg_register
*reg
)
1328 struct em28xx_fh
*fh
= priv
;
1329 struct em28xx
*dev
= fh
->dev
;
1332 switch (reg
->match
.type
) {
1333 case V4L2_CHIP_MATCH_AC97
:
1334 return em28xx_write_ac97(dev
, reg
->reg
, reg
->val
);
1335 case V4L2_CHIP_MATCH_I2C_DRIVER
:
1336 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, s_register
, reg
);
1338 case V4L2_CHIP_MATCH_I2C_ADDR
:
1339 /* TODO: is this correct? */
1340 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, s_register
, reg
);
1343 if (!v4l2_chip_match_host(®
->match
))
1348 buf
= cpu_to_le16(reg
->val
);
1350 return em28xx_write_regs(dev
, reg
->reg
, (char *)&buf
,
1351 em28xx_reg_len(reg
->reg
));
1356 static int vidioc_querycap(struct file
*file
, void *priv
,
1357 struct v4l2_capability
*cap
)
1359 struct video_device
*vdev
= video_devdata(file
);
1360 struct em28xx_fh
*fh
= priv
;
1361 struct em28xx
*dev
= fh
->dev
;
1363 strlcpy(cap
->driver
, "em28xx", sizeof(cap
->driver
));
1364 strlcpy(cap
->card
, em28xx_boards
[dev
->model
].name
, sizeof(cap
->card
));
1365 usb_make_path(dev
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
1367 if (vdev
->vfl_type
== VFL_TYPE_GRABBER
)
1368 cap
->device_caps
= V4L2_CAP_READWRITE
|
1369 V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_STREAMING
;
1370 else if (vdev
->vfl_type
== VFL_TYPE_RADIO
)
1371 cap
->device_caps
= V4L2_CAP_RADIO
;
1373 cap
->device_caps
= V4L2_CAP_READWRITE
| V4L2_CAP_VBI_CAPTURE
;
1375 if (dev
->audio_mode
.has_audio
)
1376 cap
->device_caps
|= V4L2_CAP_AUDIO
;
1378 if (dev
->tuner_type
!= TUNER_ABSENT
)
1379 cap
->device_caps
|= V4L2_CAP_TUNER
;
1381 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
|
1382 V4L2_CAP_READWRITE
| V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_STREAMING
;
1384 cap
->capabilities
|= V4L2_CAP_VBI_CAPTURE
;
1386 cap
->capabilities
|= V4L2_CAP_RADIO
;
1390 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
1391 struct v4l2_fmtdesc
*f
)
1393 if (unlikely(f
->index
>= ARRAY_SIZE(format
)))
1396 strlcpy(f
->description
, format
[f
->index
].name
, sizeof(f
->description
));
1397 f
->pixelformat
= format
[f
->index
].fourcc
;
1402 static int vidioc_enum_framesizes(struct file
*file
, void *priv
,
1403 struct v4l2_frmsizeenum
*fsize
)
1405 struct em28xx_fh
*fh
= priv
;
1406 struct em28xx
*dev
= fh
->dev
;
1407 struct em28xx_fmt
*fmt
;
1408 unsigned int maxw
= norm_maxw(dev
);
1409 unsigned int maxh
= norm_maxh(dev
);
1411 fmt
= format_by_fourcc(fsize
->pixel_format
);
1413 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1414 fsize
->pixel_format
);
1418 if (dev
->board
.is_em2800
) {
1419 if (fsize
->index
> 1)
1421 fsize
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1422 fsize
->discrete
.width
= maxw
/ (1 + fsize
->index
);
1423 fsize
->discrete
.height
= maxh
/ (1 + fsize
->index
);
1427 if (fsize
->index
!= 0)
1430 /* Report a continuous range */
1431 fsize
->type
= V4L2_FRMSIZE_TYPE_STEPWISE
;
1432 scale_to_size(dev
, EM28XX_HVSCALE_MAX
, EM28XX_HVSCALE_MAX
,
1433 &fsize
->stepwise
.min_width
, &fsize
->stepwise
.min_height
);
1434 if (fsize
->stepwise
.min_width
< 48)
1435 fsize
->stepwise
.min_width
= 48;
1436 if (fsize
->stepwise
.min_height
< 38)
1437 fsize
->stepwise
.min_height
= 38;
1438 fsize
->stepwise
.max_width
= maxw
;
1439 fsize
->stepwise
.max_height
= maxh
;
1440 fsize
->stepwise
.step_width
= 1;
1441 fsize
->stepwise
.step_height
= 1;
1445 /* RAW VBI ioctls */
1447 static int vidioc_g_fmt_vbi_cap(struct file
*file
, void *priv
,
1448 struct v4l2_format
*format
)
1450 struct em28xx_fh
*fh
= priv
;
1451 struct em28xx
*dev
= fh
->dev
;
1453 format
->fmt
.vbi
.samples_per_line
= dev
->vbi_width
;
1454 format
->fmt
.vbi
.sample_format
= V4L2_PIX_FMT_GREY
;
1455 format
->fmt
.vbi
.offset
= 0;
1456 format
->fmt
.vbi
.flags
= 0;
1457 format
->fmt
.vbi
.sampling_rate
= 6750000 * 4 / 2;
1458 format
->fmt
.vbi
.count
[0] = dev
->vbi_height
;
1459 format
->fmt
.vbi
.count
[1] = dev
->vbi_height
;
1460 memset(format
->fmt
.vbi
.reserved
, 0, sizeof(format
->fmt
.vbi
.reserved
));
1462 /* Varies by video standard (NTSC, PAL, etc.) */
1463 if (dev
->norm
& V4L2_STD_525_60
) {
1465 format
->fmt
.vbi
.start
[0] = 10;
1466 format
->fmt
.vbi
.start
[1] = 273;
1467 } else if (dev
->norm
& V4L2_STD_625_50
) {
1469 format
->fmt
.vbi
.start
[0] = 6;
1470 format
->fmt
.vbi
.start
[1] = 318;
1476 /* ----------------------------------------------------------- */
1477 /* RADIO ESPECIFIC IOCTLS */
1478 /* ----------------------------------------------------------- */
1480 static int radio_g_tuner(struct file
*file
, void *priv
,
1481 struct v4l2_tuner
*t
)
1483 struct em28xx
*dev
= ((struct em28xx_fh
*)priv
)->dev
;
1485 if (unlikely(t
->index
> 0))
1488 strcpy(t
->name
, "Radio");
1490 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, g_tuner
, t
);
1495 static int radio_s_tuner(struct file
*file
, void *priv
,
1496 struct v4l2_tuner
*t
)
1498 struct em28xx
*dev
= ((struct em28xx_fh
*)priv
)->dev
;
1503 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_tuner
, t
);
1509 * em28xx_v4l2_open()
1510 * inits the device and starts isoc transfer
1512 static int em28xx_v4l2_open(struct file
*filp
)
1514 struct video_device
*vdev
= video_devdata(filp
);
1515 struct em28xx
*dev
= video_drvdata(filp
);
1516 enum v4l2_buf_type fh_type
= 0;
1517 struct em28xx_fh
*fh
;
1519 switch (vdev
->vfl_type
) {
1520 case VFL_TYPE_GRABBER
:
1521 fh_type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1524 fh_type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
1528 em28xx_videodbg("open dev=%s type=%s users=%d\n",
1529 video_device_node_name(vdev
), v4l2_type_names
[fh_type
],
1533 if (mutex_lock_interruptible(&dev
->lock
))
1534 return -ERESTARTSYS
;
1535 fh
= kzalloc(sizeof(struct em28xx_fh
), GFP_KERNEL
);
1537 em28xx_errdev("em28xx-video.c: Out of memory?!\n");
1538 mutex_unlock(&dev
->lock
);
1541 v4l2_fh_init(&fh
->fh
, vdev
);
1544 filp
->private_data
= fh
;
1546 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
&& dev
->users
== 0) {
1547 em28xx_set_mode(dev
, EM28XX_ANALOG_MODE
);
1548 em28xx_resolution_set(dev
);
1550 /* Needed, since GPIO might have disabled power of
1553 em28xx_wake_i2c(dev
);
1557 if (vdev
->vfl_type
== VFL_TYPE_RADIO
) {
1558 em28xx_videodbg("video_open: setting radio device\n");
1559 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_radio
);
1564 mutex_unlock(&dev
->lock
);
1565 v4l2_fh_add(&fh
->fh
);
1571 * em28xx_realease_resources()
1572 * unregisters the v4l2,i2c and usb devices
1573 * called when the device gets disconected or at module unload
1575 void em28xx_release_analog_resources(struct em28xx
*dev
)
1578 /*FIXME: I2C IR should be disconnected */
1580 if (dev
->radio_dev
) {
1581 if (video_is_registered(dev
->radio_dev
))
1582 video_unregister_device(dev
->radio_dev
);
1584 video_device_release(dev
->radio_dev
);
1585 dev
->radio_dev
= NULL
;
1588 em28xx_info("V4L2 device %s deregistered\n",
1589 video_device_node_name(dev
->vbi_dev
));
1590 if (video_is_registered(dev
->vbi_dev
))
1591 video_unregister_device(dev
->vbi_dev
);
1593 video_device_release(dev
->vbi_dev
);
1594 dev
->vbi_dev
= NULL
;
1597 em28xx_info("V4L2 device %s deregistered\n",
1598 video_device_node_name(dev
->vdev
));
1599 if (video_is_registered(dev
->vdev
))
1600 video_unregister_device(dev
->vdev
);
1602 video_device_release(dev
->vdev
);
1608 * em28xx_v4l2_close()
1609 * stops streaming and deallocates all resources allocated by the v4l2
1612 static int em28xx_v4l2_close(struct file
*filp
)
1614 struct em28xx_fh
*fh
= filp
->private_data
;
1615 struct em28xx
*dev
= fh
->dev
;
1618 em28xx_videodbg("users=%d\n", dev
->users
);
1620 mutex_lock(&dev
->lock
);
1621 vb2_fop_release(filp
);
1623 if (dev
->users
== 1) {
1624 /* the device is already disconnect,
1625 free the remaining resources */
1626 if (dev
->disconnected
) {
1627 em28xx_release_resources(dev
);
1628 kfree(dev
->alt_max_pkt_size_isoc
);
1629 mutex_unlock(&dev
->lock
);
1634 /* Save some power by putting tuner to sleep */
1635 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, s_power
, 0);
1637 /* do this before setting alternate! */
1638 em28xx_set_mode(dev
, EM28XX_SUSPEND
);
1640 /* set alternate 0 */
1642 em28xx_videodbg("setting alternate 0\n");
1643 errCode
= usb_set_interface(dev
->udev
, 0, 0);
1645 em28xx_errdev("cannot change alternate number to "
1646 "0 (error=%i)\n", errCode
);
1651 mutex_unlock(&dev
->lock
);
1655 static const struct v4l2_file_operations em28xx_v4l_fops
= {
1656 .owner
= THIS_MODULE
,
1657 .open
= em28xx_v4l2_open
,
1658 .release
= em28xx_v4l2_close
,
1659 .read
= vb2_fop_read
,
1660 .poll
= vb2_fop_poll
,
1661 .mmap
= vb2_fop_mmap
,
1662 .unlocked_ioctl
= video_ioctl2
,
1665 static const struct v4l2_ioctl_ops video_ioctl_ops
= {
1666 .vidioc_querycap
= vidioc_querycap
,
1667 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1668 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1669 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1670 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1671 .vidioc_g_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1672 .vidioc_try_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1673 .vidioc_s_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1674 .vidioc_enum_framesizes
= vidioc_enum_framesizes
,
1675 .vidioc_g_audio
= vidioc_g_audio
,
1676 .vidioc_s_audio
= vidioc_s_audio
,
1678 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
1679 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
1680 .vidioc_prepare_buf
= vb2_ioctl_prepare_buf
,
1681 .vidioc_querybuf
= vb2_ioctl_querybuf
,
1682 .vidioc_qbuf
= vb2_ioctl_qbuf
,
1683 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
1685 .vidioc_g_std
= vidioc_g_std
,
1686 .vidioc_querystd
= vidioc_querystd
,
1687 .vidioc_s_std
= vidioc_s_std
,
1688 .vidioc_g_parm
= vidioc_g_parm
,
1689 .vidioc_s_parm
= vidioc_s_parm
,
1690 .vidioc_enum_input
= vidioc_enum_input
,
1691 .vidioc_g_input
= vidioc_g_input
,
1692 .vidioc_s_input
= vidioc_s_input
,
1693 .vidioc_streamon
= vb2_ioctl_streamon
,
1694 .vidioc_streamoff
= vb2_ioctl_streamoff
,
1695 .vidioc_g_tuner
= vidioc_g_tuner
,
1696 .vidioc_s_tuner
= vidioc_s_tuner
,
1697 .vidioc_g_frequency
= vidioc_g_frequency
,
1698 .vidioc_s_frequency
= vidioc_s_frequency
,
1699 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1700 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1701 .vidioc_g_chip_ident
= vidioc_g_chip_ident
,
1702 #ifdef CONFIG_VIDEO_ADV_DEBUG
1703 .vidioc_g_register
= vidioc_g_register
,
1704 .vidioc_s_register
= vidioc_s_register
,
1708 static const struct video_device em28xx_video_template
= {
1709 .fops
= &em28xx_v4l_fops
,
1710 .release
= video_device_release_empty
,
1711 .ioctl_ops
= &video_ioctl_ops
,
1713 .tvnorms
= V4L2_STD_ALL
,
1716 static const struct v4l2_file_operations radio_fops
= {
1717 .owner
= THIS_MODULE
,
1718 .open
= em28xx_v4l2_open
,
1719 .release
= em28xx_v4l2_close
,
1720 .unlocked_ioctl
= video_ioctl2
,
1723 static const struct v4l2_ioctl_ops radio_ioctl_ops
= {
1724 .vidioc_querycap
= vidioc_querycap
,
1725 .vidioc_g_tuner
= radio_g_tuner
,
1726 .vidioc_s_tuner
= radio_s_tuner
,
1727 .vidioc_g_frequency
= vidioc_g_frequency
,
1728 .vidioc_s_frequency
= vidioc_s_frequency
,
1729 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1730 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1731 .vidioc_g_chip_ident
= vidioc_g_chip_ident
,
1732 #ifdef CONFIG_VIDEO_ADV_DEBUG
1733 .vidioc_g_register
= vidioc_g_register
,
1734 .vidioc_s_register
= vidioc_s_register
,
1738 static struct video_device em28xx_radio_template
= {
1739 .name
= "em28xx-radio",
1740 .fops
= &radio_fops
,
1741 .ioctl_ops
= &radio_ioctl_ops
,
1744 /******************************** usb interface ******************************/
1748 static struct video_device
*em28xx_vdev_init(struct em28xx
*dev
,
1749 const struct video_device
*template,
1750 const char *type_name
)
1752 struct video_device
*vfd
;
1754 vfd
= video_device_alloc();
1759 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
1760 vfd
->debug
= video_debug
;
1761 vfd
->lock
= &dev
->lock
;
1762 set_bit(V4L2_FL_USE_FH_PRIO
, &vfd
->flags
);
1763 if (dev
->board
.is_webcam
)
1766 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s %s",
1767 dev
->name
, type_name
);
1769 video_set_drvdata(vfd
, dev
);
1773 int em28xx_register_analog_devices(struct em28xx
*dev
)
1779 printk(KERN_INFO
"%s: v4l2 driver version %s\n",
1780 dev
->name
, EM28XX_VERSION
);
1782 /* set default norm */
1783 dev
->norm
= V4L2_STD_PAL
;
1784 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, s_std
, dev
->norm
);
1785 dev
->interlaced
= EM28XX_INTERLACED_DEFAULT
;
1787 /* Analog specific initialization */
1788 dev
->format
= &format
[0];
1790 maxw
= norm_maxw(dev
);
1791 /* MaxPacketSize for em2800 is too small to capture at full resolution
1792 * use half of maxw as the scaler can only scale to 50% */
1793 if (dev
->board
.is_em2800
)
1796 em28xx_set_video_format(dev
, format
[0].fourcc
,
1797 maxw
, norm_maxh(dev
));
1801 /* Audio defaults */
1805 /* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */
1806 val
= (u8
)em28xx_read_reg(dev
, EM28XX_R0F_XCLK
);
1807 em28xx_write_reg(dev
, EM28XX_R0F_XCLK
,
1808 (EM28XX_XCLK_AUDIO_UNMUTE
| val
));
1810 em28xx_set_outfmt(dev
);
1811 em28xx_compression_disable(dev
);
1813 /* Add image controls */
1814 /* NOTE: at this point, the subdevices are already registered, so bridge
1815 * controls are only added/enabled when no subdevice provides them */
1816 if (NULL
== v4l2_ctrl_find(&dev
->ctrl_handler
, V4L2_CID_CONTRAST
))
1817 v4l2_ctrl_new_std(&dev
->ctrl_handler
, &em28xx_ctrl_ops
,
1819 0, 0x1f, 1, CONTRAST_DEFAULT
);
1820 if (NULL
== v4l2_ctrl_find(&dev
->ctrl_handler
, V4L2_CID_BRIGHTNESS
))
1821 v4l2_ctrl_new_std(&dev
->ctrl_handler
, &em28xx_ctrl_ops
,
1822 V4L2_CID_BRIGHTNESS
,
1823 -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT
);
1824 if (NULL
== v4l2_ctrl_find(&dev
->ctrl_handler
, V4L2_CID_SATURATION
))
1825 v4l2_ctrl_new_std(&dev
->ctrl_handler
, &em28xx_ctrl_ops
,
1826 V4L2_CID_SATURATION
,
1827 0, 0x1f, 1, SATURATION_DEFAULT
);
1828 if (NULL
== v4l2_ctrl_find(&dev
->ctrl_handler
, V4L2_CID_BLUE_BALANCE
))
1829 v4l2_ctrl_new_std(&dev
->ctrl_handler
, &em28xx_ctrl_ops
,
1830 V4L2_CID_BLUE_BALANCE
,
1831 -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT
);
1832 if (NULL
== v4l2_ctrl_find(&dev
->ctrl_handler
, V4L2_CID_RED_BALANCE
))
1833 v4l2_ctrl_new_std(&dev
->ctrl_handler
, &em28xx_ctrl_ops
,
1834 V4L2_CID_RED_BALANCE
,
1835 -0x30, 0x30, 1, RED_BALANCE_DEFAULT
);
1836 if (NULL
== v4l2_ctrl_find(&dev
->ctrl_handler
, V4L2_CID_SHARPNESS
))
1837 v4l2_ctrl_new_std(&dev
->ctrl_handler
, &em28xx_ctrl_ops
,
1839 0, 0x0f, 1, SHARPNESS_DEFAULT
);
1841 /* Reset image controls */
1842 em28xx_colorlevels_set_default(dev
);
1843 v4l2_ctrl_handler_setup(&dev
->ctrl_handler
);
1844 if (dev
->ctrl_handler
.error
)
1845 return dev
->ctrl_handler
.error
;
1847 /* allocate and fill video video_device struct */
1848 dev
->vdev
= em28xx_vdev_init(dev
, &em28xx_video_template
, "video");
1850 em28xx_errdev("cannot allocate video_device.\n");
1853 dev
->vdev
->queue
= &dev
->vb_vidq
;
1854 dev
->vdev
->queue
->lock
= &dev
->vb_queue_lock
;
1856 /* disable inapplicable ioctls */
1857 if (dev
->board
.is_webcam
) {
1858 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_QUERYSTD
);
1859 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_G_STD
);
1860 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_S_STD
);
1862 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_S_PARM
);
1864 if (dev
->tuner_type
== TUNER_ABSENT
) {
1865 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_G_TUNER
);
1866 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_S_TUNER
);
1867 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_G_FREQUENCY
);
1868 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_S_FREQUENCY
);
1870 if (!dev
->audio_mode
.has_audio
) {
1871 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_G_AUDIO
);
1872 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_S_AUDIO
);
1875 /* register v4l2 video video_device */
1876 ret
= video_register_device(dev
->vdev
, VFL_TYPE_GRABBER
,
1877 video_nr
[dev
->devno
]);
1879 em28xx_errdev("unable to register video device (error=%i).\n",
1884 /* Allocate and fill vbi video_device struct */
1885 if (em28xx_vbi_supported(dev
) == 1) {
1886 dev
->vbi_dev
= em28xx_vdev_init(dev
, &em28xx_video_template
,
1889 dev
->vbi_dev
->queue
= &dev
->vb_vbiq
;
1890 dev
->vbi_dev
->queue
->lock
= &dev
->vb_vbi_queue_lock
;
1892 /* disable inapplicable ioctls */
1893 v4l2_disable_ioctl(dev
->vdev
, VIDIOC_S_PARM
);
1894 if (dev
->tuner_type
== TUNER_ABSENT
) {
1895 v4l2_disable_ioctl(dev
->vbi_dev
, VIDIOC_G_TUNER
);
1896 v4l2_disable_ioctl(dev
->vbi_dev
, VIDIOC_S_TUNER
);
1897 v4l2_disable_ioctl(dev
->vbi_dev
, VIDIOC_G_FREQUENCY
);
1898 v4l2_disable_ioctl(dev
->vbi_dev
, VIDIOC_S_FREQUENCY
);
1900 if (!dev
->audio_mode
.has_audio
) {
1901 v4l2_disable_ioctl(dev
->vbi_dev
, VIDIOC_G_AUDIO
);
1902 v4l2_disable_ioctl(dev
->vbi_dev
, VIDIOC_S_AUDIO
);
1905 /* register v4l2 vbi video_device */
1906 ret
= video_register_device(dev
->vbi_dev
, VFL_TYPE_VBI
,
1907 vbi_nr
[dev
->devno
]);
1909 em28xx_errdev("unable to register vbi device\n");
1914 if (em28xx_boards
[dev
->model
].radio
.type
== EM28XX_RADIO
) {
1915 dev
->radio_dev
= em28xx_vdev_init(dev
, &em28xx_radio_template
,
1917 if (!dev
->radio_dev
) {
1918 em28xx_errdev("cannot allocate video_device.\n");
1921 ret
= video_register_device(dev
->radio_dev
, VFL_TYPE_RADIO
,
1922 radio_nr
[dev
->devno
]);
1924 em28xx_errdev("can't register radio device\n");
1927 em28xx_info("Registered radio device as %s\n",
1928 video_device_node_name(dev
->radio_dev
));
1931 em28xx_info("V4L2 video device registered as %s\n",
1932 video_device_node_name(dev
->vdev
));
1935 em28xx_info("V4L2 VBI device registered as %s\n",
1936 video_device_node_name(dev
->vbi_dev
));