2 em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
4 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
5 Markus Rechberger <mrechberger@gmail.com>
6 Mauro Carvalho Chehab <mchehab@brturbo.com.br>
7 Sascha Sommer <saschasommer@freenet.de>
9 Some parts based on SN9C10x PC Camera Controllers GPL driver made
10 by Luca Risolia <luca.risolia@studio.unibo.it>
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <linux/init.h>
28 #include <linux/list.h>
29 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/bitmap.h>
32 #include <linux/usb.h>
33 #include <linux/i2c.h>
34 #include <linux/version.h>
35 #include <linux/video_decoder.h>
36 #include <linux/mutex.h>
39 #include <media/tuner.h>
40 #include <media/v4l2-common.h>
42 #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
43 "Markus Rechberger <mrechberger@gmail.com>, " \
44 "Mauro Carvalho Chehab <mchehab@brturbo.com.br>, " \
45 "Sascha Sommer <saschasommer@freenet.de>"
47 #define DRIVER_NAME "em28xx"
48 #define DRIVER_DESC "Empia em28xx based USB video device driver"
49 #define EM28XX_VERSION_CODE KERNEL_VERSION(0, 0, 1)
51 #define em28xx_videodbg(fmt, arg...) do {\
53 printk(KERN_INFO "%s %s :"fmt, \
54 dev->name, __FUNCTION__ , ##arg); } while (0)
56 MODULE_AUTHOR(DRIVER_AUTHOR
);
57 MODULE_DESCRIPTION(DRIVER_DESC
);
58 MODULE_LICENSE("GPL");
60 static LIST_HEAD(em28xx_devlist
);
62 static unsigned int card
[] = {[0 ... (EM28XX_MAXBOARDS
- 1)] = UNSET
};
63 static unsigned int video_nr
[] = {[0 ... (EM28XX_MAXBOARDS
- 1)] = UNSET
};
64 static unsigned int vbi_nr
[] = {[0 ... (EM28XX_MAXBOARDS
- 1)] = UNSET
};
65 module_param_array(card
, int, NULL
, 0444);
66 module_param_array(video_nr
, int, NULL
, 0444);
67 module_param_array(vbi_nr
, int, NULL
, 0444);
68 MODULE_PARM_DESC(card
,"card type");
69 MODULE_PARM_DESC(video_nr
,"video device numbers");
70 MODULE_PARM_DESC(vbi_nr
,"vbi device numbers");
72 static int tuner
= -1;
73 module_param(tuner
, int, 0444);
74 MODULE_PARM_DESC(tuner
, "tuner type");
76 static unsigned int video_debug
= 0;
77 module_param(video_debug
,int,0644);
78 MODULE_PARM_DESC(video_debug
,"enable debug messages [video]");
80 /* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS */
81 static unsigned long em28xx_devused
;
83 /* supported tv norms */
84 static struct em28xx_tvnorm tvnorms
[] = {
88 .mode
= VIDEO_MODE_PAL
,
92 .mode
= VIDEO_MODE_NTSC
,
96 .mode
= VIDEO_MODE_SECAM
,
100 .mode
= VIDEO_MODE_PAL
,
104 static const unsigned char saa7114_i2c_init
[] = {
105 0x00,0x00,0x01,0x08,0x02,0xc4,0x03,0x30,0x04,0x90,0x05,0x90,0x06,0xeb,0x07,0xe0,
106 0x08,0x88,0x09,0x40,0x0a,0x80,0x0b,0x44,0x0c,0x40,0x0d,0x00,0x0e,0x81,0x0f,0x2a,
107 0x10,0x06,0x11,0x00,0x12,0xc8,0x13,0x80,0x14,0x00,0x15,0x11,0x16,0x01,0x17,0x42,
108 0x18,0x40,0x19,0x80,0x40,0x00,0x41,0xff,0x42,0xff,0x43,0xff,0x44,0xff,0x45,0xff,
109 0x46,0xff,0x47,0xff,0x48,0xff,0x49,0xff,0x4a,0xff,0x4b,0xff,0x4c,0xff,0x4d,0xff,
110 0x4e,0xff,0x4f,0xff,0x50,0xff,0x51,0xff,0x52,0xff,0x53,0xff,0x54,0x5f,0x55,0xff,
111 0x56,0xff,0x57,0xff,0x58,0x00,0x59,0x47,0x5a,0x03,0x5b,0x03,0x5d,0x3e,0x5e,0x00,
112 0x80,0x1c,0x83,0x01,0x84,0xa5,0x85,0x10,0x86,0x45,0x87,0x41,0x88,0xf0,0x88,0x00,
113 0x88,0xf0,0x90,0x00,0x91,0x08,0x92,0x00,0x93,0x80,0x94,0x08,0x95,0x00,0x96,0xc0,
114 0x97,0x02,0x98,0x13,0x99,0x00,0x9a,0x38,0x9b,0x01,0x9c,0x80,0x9d,0x02,0x9e,0x06,
115 0x9f,0x01,0xa0,0x01,0xa1,0x00,0xa2,0x00,0xa4,0x80,0xa5,0x36,0xa6,0x36,0xa8,0x67,
116 0xa9,0x04,0xaa,0x00,0xac,0x33,0xad,0x02,0xae,0x00,0xb0,0xcd,0xb1,0x04,0xb2,0xcd,
117 0xb3,0x04,0xb4,0x01,0xb8,0x00,0xb9,0x00,0xba,0x00,0xbb,0x00,0xbc,0x00,0xbd,0x00,
121 #define TVNORMS ARRAY_SIZE(tvnorms)
123 /* supported controls */
124 /* Common to all boards */
125 static struct v4l2_queryctrl em28xx_qctrl
[] = {
127 .id
= V4L2_CID_AUDIO_VOLUME
,
128 .type
= V4L2_CTRL_TYPE_INTEGER
,
133 .default_value
= 0x1f,
136 .id
= V4L2_CID_AUDIO_MUTE
,
137 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
147 /* FIXME: These are specific to saa711x - should be moved to its code */
148 static struct v4l2_queryctrl saa711x_qctrl
[] = {
150 .id
= V4L2_CID_BRIGHTNESS
,
151 .type
= V4L2_CTRL_TYPE_INTEGER
,
152 .name
= "Brightness",
159 .id
= V4L2_CID_CONTRAST
,
160 .type
= V4L2_CTRL_TYPE_INTEGER
,
165 .default_value
= 0x10,
168 .id
= V4L2_CID_SATURATION
,
169 .type
= V4L2_CTRL_TYPE_INTEGER
,
170 .name
= "Saturation",
174 .default_value
= 0x10,
177 .id
= V4L2_CID_RED_BALANCE
,
178 .type
= V4L2_CTRL_TYPE_INTEGER
,
179 .name
= "Red chroma balance",
186 .id
= V4L2_CID_BLUE_BALANCE
,
187 .type
= V4L2_CTRL_TYPE_INTEGER
,
188 .name
= "Blue chroma balance",
195 .id
= V4L2_CID_GAMMA
,
196 .type
= V4L2_CTRL_TYPE_INTEGER
,
201 .default_value
= 0x20,
206 static struct usb_driver em28xx_usb_driver
;
208 static DEFINE_MUTEX(em28xx_sysfs_lock
);
209 static DECLARE_RWSEM(em28xx_disconnect
);
211 /********************* v4l2 interface ******************************************/
215 * inits registers with sane defaults
217 static int em28xx_config(struct em28xx
*dev
)
220 /* Sets I2C speed to 100 KHz */
221 em28xx_write_regs_req(dev
, 0x00, 0x06, "\x40", 1);
223 /* enable vbi capturing */
225 /* em28xx_write_regs_req(dev,0x00,0x0e,"\xC0",1); audio register */
226 /* em28xx_write_regs_req(dev,0x00,0x0f,"\x80",1); clk register */
227 em28xx_write_regs_req(dev
,0x00,0x11,"\x51",1);
229 em28xx_audio_usb_mute(dev
, 1);
230 dev
->mute
= 1; /* maybe not the right place... */
232 em28xx_audio_analog_set(dev
);
233 em28xx_audio_analog_setup(dev
);
234 em28xx_outfmt_set_yuv422(dev
);
235 em28xx_colorlevels_set_default(dev
);
236 em28xx_compression_disable(dev
);
242 * em28xx_config_i2c()
243 * configure i2c attached devices
245 static void em28xx_config_i2c(struct em28xx
*dev
)
247 struct v4l2_frequency f
;
248 struct video_decoder_init em28xx_vdi
= {.data
= NULL
};
251 /* configure decoder */
252 if(dev
->model
== EM2820_BOARD_MSI_VOX_USB_2
){
253 em28xx_vdi
.data
=saa7114_i2c_init
;
254 em28xx_vdi
.len
=sizeof(saa7114_i2c_init
);
258 em28xx_i2c_call_clients(dev
, DECODER_INIT
, &em28xx_vdi
);
259 em28xx_i2c_call_clients(dev
, DECODER_SET_INPUT
, &dev
->ctl_input
);
260 /* em28xx_i2c_call_clients(dev,DECODER_SET_PICTURE, &dev->vpic); */
261 /* em28xx_i2c_call_clients(dev,DECODER_SET_NORM,&dev->tvnorm->id); */
262 /* em28xx_i2c_call_clients(dev,DECODER_ENABLE_OUTPUT,&output); */
263 /* em28xx_i2c_call_clients(dev,DECODER_DUMP, NULL); */
265 /* configure tuner */
267 f
.type
= V4L2_TUNER_ANALOG_TV
;
268 f
.frequency
= 9076; /* FIXME:remove magic number */
269 dev
->ctl_freq
= f
.frequency
;
270 em28xx_i2c_call_clients(dev
, VIDIOC_S_FREQUENCY
, &f
);
272 /* configure tda9887 */
275 /* em28xx_i2c_call_clients(dev,VIDIOC_S_STD,&dev->tvnorm->id); */
279 * em28xx_empty_framequeues()
280 * prepare queues for incoming and outgoing frames
282 static void em28xx_empty_framequeues(struct em28xx
*dev
)
286 INIT_LIST_HEAD(&dev
->inqueue
);
287 INIT_LIST_HEAD(&dev
->outqueue
);
289 for (i
= 0; i
< EM28XX_NUM_FRAMES
; i
++) {
290 dev
->frame
[i
].state
= F_UNUSED
;
291 dev
->frame
[i
].buf
.bytesused
= 0;
295 static void video_mux(struct em28xx
*dev
, int index
)
299 input
= INPUT(index
)->vmux
;
300 dev
->ctl_input
= index
;
301 dev
->ctl_ainput
= INPUT(index
)->amux
;
303 em28xx_i2c_call_clients(dev
, DECODER_SET_INPUT
, &input
);
306 em28xx_videodbg("Setting input index=%d, vmux=%d, amux=%d\n",index
,input
,dev
->ctl_ainput
);
308 if (dev
->has_msp34xx
) {
310 em28xx_i2c_call_clients(dev
, VIDIOC_INT_I2S_CLOCK_FREQ
, &dev
->i2s_speed
);
311 em28xx_i2c_call_clients(dev
, VIDIOC_S_AUDIO
, &dev
->ctl_ainput
);
312 ainput
= EM28XX_AUDIO_SRC_TUNER
;
313 em28xx_audio_source(dev
, ainput
);
315 switch (dev
->ctl_ainput
) {
317 ainput
= EM28XX_AUDIO_SRC_TUNER
;
320 ainput
= EM28XX_AUDIO_SRC_LINE
;
322 em28xx_audio_source(dev
, ainput
);
328 * inits the device and starts isoc transfer
330 static int em28xx_v4l2_open(struct inode
*inode
, struct file
*filp
)
332 int minor
= iminor(inode
);
334 struct em28xx
*h
,*dev
= NULL
;
335 struct list_head
*list
;
337 list_for_each(list
,&em28xx_devlist
) {
338 h
= list_entry(list
, struct em28xx
, devlist
);
339 if (h
->vdev
->minor
== minor
) {
341 dev
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
343 if (h
->vbi_dev
->minor
== minor
) {
345 dev
->type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
351 filp
->private_data
=dev
;
353 em28xx_videodbg("open minor=%d type=%s users=%d\n",
354 minor
,v4l2_type_names
[dev
->type
],dev
->users
);
356 if (!down_read_trylock(&em28xx_disconnect
))
360 em28xx_warn("this driver can be opened only once\n");
361 up_read(&em28xx_disconnect
);
365 mutex_init(&dev
->fileop_lock
); /* to 1 == available */
366 spin_lock_init(&dev
->queue_lock
);
367 init_waitqueue_head(&dev
->wait_frame
);
368 init_waitqueue_head(&dev
->wait_stream
);
370 mutex_lock(&dev
->lock
);
372 if (dev
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
373 em28xx_set_alternate(dev
);
375 dev
->width
= norm_maxw(dev
);
376 dev
->height
= norm_maxh(dev
);
377 dev
->frame_size
= dev
->width
* dev
->height
* 2;
378 dev
->field_size
= dev
->frame_size
>> 1; /*both_fileds ? dev->frame_size>>1 : dev->frame_size; */
379 dev
->bytesperline
= dev
->width
* 2;
383 em28xx_capture_start(dev
, 1);
384 em28xx_resolution_set(dev
);
386 /* device needs to be initialized before isoc transfer */
389 /* start the transfer */
390 errCode
= em28xx_init_isoc(dev
);
397 filp
->private_data
= dev
;
399 dev
->stream
= STREAM_OFF
;
403 em28xx_empty_framequeues(dev
);
405 dev
->state
|= DEV_INITIALIZED
;
408 mutex_unlock(&dev
->lock
);
409 up_read(&em28xx_disconnect
);
414 * em28xx_realease_resources()
415 * unregisters the v4l2,i2c and usb devices
416 * called when the device gets disconected or at module unload
418 static void em28xx_release_resources(struct em28xx
*dev
)
420 mutex_lock(&em28xx_sysfs_lock
);
422 /*FIXME: I2C IR should be disconnected */
424 em28xx_info("V4L2 devices /dev/video%d and /dev/vbi%d deregistered\n",
425 dev
->vdev
->minor
-MINOR_VFL_TYPE_GRABBER_MIN
,
426 dev
->vbi_dev
->minor
-MINOR_VFL_TYPE_VBI_MIN
);
427 list_del(&dev
->devlist
);
428 video_unregister_device(dev
->vdev
);
429 video_unregister_device(dev
->vbi_dev
);
430 em28xx_i2c_unregister(dev
);
431 usb_put_dev(dev
->udev
);
432 mutex_unlock(&em28xx_sysfs_lock
);
435 /* Mark device as unused */
436 em28xx_devused
&=~(1<<dev
->devno
);
440 * em28xx_v4l2_close()
441 * stops streaming and deallocates all resources allocated by the v4l2 calls and ioctls
443 static int em28xx_v4l2_close(struct inode
*inode
, struct file
*filp
)
446 struct em28xx
*dev
=filp
->private_data
;
448 em28xx_videodbg("users=%d\n", dev
->users
);
450 mutex_lock(&dev
->lock
);
452 em28xx_uninit_isoc(dev
);
454 em28xx_release_buffers(dev
);
456 /* the device is already disconnect, free the remaining resources */
457 if (dev
->state
& DEV_DISCONNECTED
) {
458 em28xx_release_resources(dev
);
459 mutex_unlock(&dev
->lock
);
464 /* set alternate 0 */
466 em28xx_videodbg("setting alternate 0\n");
467 errCode
= usb_set_interface(dev
->udev
, 0, 0);
469 em28xx_errdev ("cannot change alternate number to 0 (error=%i)\n",
474 wake_up_interruptible_nr(&dev
->open
, 1);
475 mutex_unlock(&dev
->lock
);
481 * will allocate buffers when called for the first time
484 em28xx_v4l2_read(struct file
*filp
, char __user
* buf
, size_t count
,
487 struct em28xx_frame_t
*f
, *i
;
488 unsigned long lock_flags
;
490 struct em28xx
*dev
= filp
->private_data
;
492 if (dev
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
493 em28xx_videodbg("V4l2_Buf_type_videocapture is set\n");
495 if (dev
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
496 em28xx_videodbg("V4L2_BUF_TYPE_VBI_CAPTURE is set\n");
497 em28xx_videodbg("not supported yet! ...\n");
498 if (copy_to_user(buf
, "", 1)) {
499 mutex_unlock(&dev
->fileop_lock
);
504 if (dev
->type
== V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
) {
505 em28xx_videodbg("V4L2_BUF_TYPE_SLICED_VBI_CAPTURE is set\n");
506 em28xx_videodbg("not supported yet! ...\n");
507 if (copy_to_user(buf
, "", 1)) {
508 mutex_unlock(&dev
->fileop_lock
);
514 if (mutex_lock_interruptible(&dev
->fileop_lock
))
517 if (dev
->state
& DEV_DISCONNECTED
) {
518 em28xx_videodbg("device not present\n");
519 mutex_unlock(&dev
->fileop_lock
);
523 if (dev
->state
& DEV_MISCONFIGURED
) {
524 em28xx_videodbg("device misconfigured; close and open it again\n");
525 mutex_unlock(&dev
->fileop_lock
);
529 if (dev
->io
== IO_MMAP
) {
530 em28xx_videodbg ("IO method is set to mmap; close and open"
531 " the device again to choose the read method\n");
532 mutex_unlock(&dev
->fileop_lock
);
536 if (dev
->io
== IO_NONE
) {
537 if (!em28xx_request_buffers(dev
, EM28XX_NUM_READ_FRAMES
)) {
538 em28xx_errdev("read failed, not enough memory\n");
539 mutex_unlock(&dev
->fileop_lock
);
543 dev
->stream
= STREAM_ON
;
544 em28xx_queue_unusedframes(dev
);
548 mutex_unlock(&dev
->fileop_lock
);
552 if (list_empty(&dev
->outqueue
)) {
553 if (filp
->f_flags
& O_NONBLOCK
) {
554 mutex_unlock(&dev
->fileop_lock
);
557 ret
= wait_event_interruptible
559 (!list_empty(&dev
->outqueue
)) ||
560 (dev
->state
& DEV_DISCONNECTED
));
562 mutex_unlock(&dev
->fileop_lock
);
565 if (dev
->state
& DEV_DISCONNECTED
) {
566 mutex_unlock(&dev
->fileop_lock
);
571 f
= list_entry(dev
->outqueue
.prev
, struct em28xx_frame_t
, frame
);
573 spin_lock_irqsave(&dev
->queue_lock
, lock_flags
);
574 list_for_each_entry(i
, &dev
->outqueue
, frame
)
576 INIT_LIST_HEAD(&dev
->outqueue
);
577 spin_unlock_irqrestore(&dev
->queue_lock
, lock_flags
);
579 em28xx_queue_unusedframes(dev
);
581 if (count
> f
->buf
.length
)
582 count
= f
->buf
.length
;
584 if (copy_to_user(buf
, f
->bufmem
, count
)) {
585 mutex_unlock(&dev
->fileop_lock
);
590 mutex_unlock(&dev
->fileop_lock
);
597 * will allocate buffers when called for the first time
599 static unsigned int em28xx_v4l2_poll(struct file
*filp
, poll_table
* wait
)
601 unsigned int mask
= 0;
602 struct em28xx
*dev
= filp
->private_data
;
604 if (mutex_lock_interruptible(&dev
->fileop_lock
))
607 if (dev
->state
& DEV_DISCONNECTED
) {
608 em28xx_videodbg("device not present\n");
609 } else if (dev
->state
& DEV_MISCONFIGURED
) {
610 em28xx_videodbg("device is misconfigured; close and open it again\n");
612 if (dev
->io
== IO_NONE
) {
613 if (!em28xx_request_buffers
614 (dev
, EM28XX_NUM_READ_FRAMES
)) {
616 ("poll() failed, not enough memory\n");
619 dev
->stream
= STREAM_ON
;
623 if (dev
->io
== IO_READ
) {
624 em28xx_queue_unusedframes(dev
);
625 poll_wait(filp
, &dev
->wait_frame
, wait
);
627 if (!list_empty(&dev
->outqueue
))
628 mask
|= POLLIN
| POLLRDNORM
;
630 mutex_unlock(&dev
->fileop_lock
);
636 mutex_unlock(&dev
->fileop_lock
);
643 static void em28xx_vm_open(struct vm_area_struct
*vma
)
645 struct em28xx_frame_t
*f
= vma
->vm_private_data
;
652 static void em28xx_vm_close(struct vm_area_struct
*vma
)
654 /* NOTE: buffers are not freed here */
655 struct em28xx_frame_t
*f
= vma
->vm_private_data
;
659 static struct vm_operations_struct em28xx_vm_ops
= {
660 .open
= em28xx_vm_open
,
661 .close
= em28xx_vm_close
,
667 static int em28xx_v4l2_mmap(struct file
*filp
, struct vm_area_struct
*vma
)
669 unsigned long size
= vma
->vm_end
- vma
->vm_start
,
670 start
= vma
->vm_start
;
674 struct em28xx
*dev
= filp
->private_data
;
676 if (mutex_lock_interruptible(&dev
->fileop_lock
))
679 if (dev
->state
& DEV_DISCONNECTED
) {
680 em28xx_videodbg("mmap: device not present\n");
681 mutex_unlock(&dev
->fileop_lock
);
685 if (dev
->state
& DEV_MISCONFIGURED
) {
686 em28xx_videodbg ("mmap: Device is misconfigured; close and "
688 mutex_unlock(&dev
->fileop_lock
);
692 if (dev
->io
!= IO_MMAP
|| !(vma
->vm_flags
& VM_WRITE
) ||
693 size
!= PAGE_ALIGN(dev
->frame
[0].buf
.length
)) {
694 mutex_unlock(&dev
->fileop_lock
);
698 for (i
= 0; i
< dev
->num_frames
; i
++) {
699 if ((dev
->frame
[i
].buf
.m
.offset
>> PAGE_SHIFT
) == vma
->vm_pgoff
)
702 if (i
== dev
->num_frames
) {
703 em28xx_videodbg("mmap: user supplied mapping address is out of range\n");
704 mutex_unlock(&dev
->fileop_lock
);
708 /* VM_IO is eventually going to replace PageReserved altogether */
709 vma
->vm_flags
|= VM_IO
;
710 vma
->vm_flags
|= VM_RESERVED
; /* avoid to swap out this VMA */
712 pos
= dev
->frame
[i
].bufmem
;
713 while (size
> 0) { /* size is page-aligned */
714 if (vm_insert_page(vma
, start
, vmalloc_to_page(pos
))) {
715 em28xx_videodbg("mmap: vm_insert_page failed\n");
716 mutex_unlock(&dev
->fileop_lock
);
724 vma
->vm_ops
= &em28xx_vm_ops
;
725 vma
->vm_private_data
= &dev
->frame
[i
];
728 mutex_unlock(&dev
->fileop_lock
);
734 * return the current saturation, brightness or contrast, mute state
736 static int em28xx_get_ctrl(struct em28xx
*dev
, struct v4l2_control
*ctrl
)
739 case V4L2_CID_AUDIO_MUTE
:
740 ctrl
->value
= dev
->mute
;
742 case V4L2_CID_AUDIO_VOLUME
:
743 ctrl
->value
= dev
->volume
;
750 /*FIXME: should be moved to saa711x */
751 static int saa711x_get_ctrl(struct em28xx
*dev
, struct v4l2_control
*ctrl
)
755 case V4L2_CID_BRIGHTNESS
:
756 if ((tmp
= em28xx_brightness_get(dev
)) < 0)
758 ctrl
->value
= (s32
) ((s8
) tmp
); /* FIXME: clenaer way to extend sign? */
760 case V4L2_CID_CONTRAST
:
761 if ((ctrl
->value
= em28xx_contrast_get(dev
)) < 0)
764 case V4L2_CID_SATURATION
:
765 if ((ctrl
->value
= em28xx_saturation_get(dev
)) < 0)
768 case V4L2_CID_RED_BALANCE
:
769 if ((tmp
= em28xx_v_balance_get(dev
)) < 0)
771 ctrl
->value
= (s32
) ((s8
) tmp
); /* FIXME: clenaer way to extend sign? */
773 case V4L2_CID_BLUE_BALANCE
:
774 if ((tmp
= em28xx_u_balance_get(dev
)) < 0)
776 ctrl
->value
= (s32
) ((s8
) tmp
); /* FIXME: clenaer way to extend sign? */
779 if ((ctrl
->value
= em28xx_gamma_get(dev
)) < 0)
789 * mute or set new saturation, brightness or contrast
791 static int em28xx_set_ctrl(struct em28xx
*dev
, const struct v4l2_control
*ctrl
)
794 case V4L2_CID_AUDIO_MUTE
:
795 if (ctrl
->value
!= dev
->mute
) {
796 dev
->mute
= ctrl
->value
;
797 em28xx_audio_usb_mute(dev
, ctrl
->value
);
798 return em28xx_audio_analog_set(dev
);
801 case V4L2_CID_AUDIO_VOLUME
:
802 dev
->volume
= ctrl
->value
;
803 return em28xx_audio_analog_set(dev
);
809 /*FIXME: should be moved to saa711x */
810 static int saa711x_set_ctrl(struct em28xx
*dev
, const struct v4l2_control
*ctrl
)
813 case V4L2_CID_BRIGHTNESS
:
814 return em28xx_brightness_set(dev
, ctrl
->value
);
815 case V4L2_CID_CONTRAST
:
816 return em28xx_contrast_set(dev
, ctrl
->value
);
817 case V4L2_CID_SATURATION
:
818 return em28xx_saturation_set(dev
, ctrl
->value
);
819 case V4L2_CID_RED_BALANCE
:
820 return em28xx_v_balance_set(dev
, ctrl
->value
);
821 case V4L2_CID_BLUE_BALANCE
:
822 return em28xx_u_balance_set(dev
, ctrl
->value
);
824 return em28xx_gamma_set(dev
, ctrl
->value
);
831 * em28xx_stream_interrupt()
834 static int em28xx_stream_interrupt(struct em28xx
*dev
)
838 /* stop reading from the device */
840 dev
->stream
= STREAM_INTERRUPT
;
841 ret
= wait_event_timeout(dev
->wait_stream
,
842 (dev
->stream
== STREAM_OFF
) ||
843 (dev
->state
& DEV_DISCONNECTED
),
845 if (dev
->state
& DEV_DISCONNECTED
)
848 dev
->state
|= DEV_MISCONFIGURED
;
849 em28xx_videodbg("device is misconfigured; close and "
850 "open /dev/video%d again\n",
851 dev
->vdev
->minor
-MINOR_VFL_TYPE_GRABBER_MIN
);
858 static int em28xx_set_norm(struct em28xx
*dev
, int width
, int height
)
860 unsigned int hscale
, vscale
;
861 unsigned int maxh
, maxw
;
863 maxw
= norm_maxw(dev
);
864 maxh
= norm_maxh(dev
);
866 /* width must even because of the YUYV format */
867 /* height must be even because of interlacing */
880 if ((hscale
= (((unsigned long)maxw
) << 12) / width
- 4096L) >= 0x4000)
882 width
= (((unsigned long)maxw
) << 12) / (hscale
+ 4096L);
884 if ((vscale
= (((unsigned long)maxh
) << 12) / height
- 4096L) >= 0x4000)
886 height
= (((unsigned long)maxh
) << 12) / (vscale
+ 4096L);
888 /* set new image size */
890 dev
->height
= height
;
891 dev
->frame_size
= dev
->width
* dev
->height
* 2;
892 dev
->field_size
= dev
->frame_size
>> 1; /*both_fileds ? dev->frame_size>>1 : dev->frame_size; */
893 dev
->bytesperline
= dev
->width
* 2;
894 dev
->hscale
= hscale
;
895 dev
->vscale
= vscale
;
897 em28xx_resolution_set(dev
);
902 static int em28xx_get_fmt(struct em28xx
*dev
, struct v4l2_format
*format
)
904 em28xx_videodbg("VIDIOC_G_FMT: type=%s\n",
905 (format
->type
==V4L2_BUF_TYPE_VIDEO_CAPTURE
) ?
906 "V4L2_BUF_TYPE_VIDEO_CAPTURE" :
907 (format
->type
==V4L2_BUF_TYPE_VBI_CAPTURE
) ?
908 "V4L2_BUF_TYPE_VBI_CAPTURE" :
909 (format
->type
==V4L2_CAP_SLICED_VBI_CAPTURE
) ?
910 "V4L2_BUF_TYPE_SLICED_VBI_CAPTURE " :
913 switch (format
->type
) {
914 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
916 format
->fmt
.pix
.width
= dev
->width
;
917 format
->fmt
.pix
.height
= dev
->height
;
918 format
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_YUYV
;
919 format
->fmt
.pix
.bytesperline
= dev
->bytesperline
;
920 format
->fmt
.pix
.sizeimage
= dev
->frame_size
;
921 format
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
922 format
->fmt
.pix
.field
= dev
->interlaced
? V4L2_FIELD_INTERLACED
: V4L2_FIELD_TOP
; /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
924 em28xx_videodbg("VIDIOC_G_FMT: %dx%d\n", dev
->width
,
929 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
931 format
->fmt
.sliced
.service_set
=0;
933 em28xx_i2c_call_clients(dev
,VIDIOC_G_FMT
,format
);
935 if (format
->fmt
.sliced
.service_set
==0)
947 static int em28xx_set_fmt(struct em28xx
*dev
, unsigned int cmd
, struct v4l2_format
*format
)
951 int width
= format
->fmt
.pix
.width
;
952 int height
= format
->fmt
.pix
.height
;
953 unsigned int hscale
, vscale
;
954 unsigned int maxh
, maxw
;
956 maxw
= norm_maxw(dev
);
957 maxh
= norm_maxh(dev
);
959 em28xx_videodbg("%s: type=%s\n",
960 cmd
== VIDIOC_TRY_FMT
?
961 "VIDIOC_TRY_FMT" : "VIDIOC_S_FMT",
962 format
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
?
963 "V4L2_BUF_TYPE_VIDEO_CAPTURE" :
964 format
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
?
965 "V4L2_BUF_TYPE_VBI_CAPTURE " :
968 if (format
->type
== V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
) {
969 em28xx_i2c_call_clients(dev
,VIDIOC_G_FMT
,format
);
971 if (format
->fmt
.sliced
.service_set
==0)
978 if (format
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
981 em28xx_videodbg("%s: requested %dx%d\n",
982 cmd
== VIDIOC_TRY_FMT
?
983 "VIDIOC_TRY_FMT" : "VIDIOC_S_FMT",
984 format
->fmt
.pix
.width
, format
->fmt
.pix
.height
);
986 /* FIXME: Move some code away from here */
987 /* width must even because of the YUYV format */
988 /* height must be even because of interlacing */
1002 /* the em2800 can only scale down to 50% */
1003 if(height
% (maxh
/ 2))
1005 if(width
% (maxw
/ 2))
1007 /* according to empiatech support */
1008 /* the MaxPacketSize is to small to support */
1009 /* framesizes larger than 640x480 @ 30 fps */
1010 /* or 640x576 @ 25 fps. As this would cut */
1011 /* of a part of the image we prefer */
1012 /* 360x576 or 360x480 for now */
1013 if(width
== maxw
&& height
== maxh
)
1017 if ((hscale
= (((unsigned long)maxw
) << 12) / width
- 4096L) >= 0x4000)
1020 width
= (((unsigned long)maxw
) << 12) / (hscale
+ 4096L);
1022 if ((vscale
= (((unsigned long)maxh
) << 12) / height
- 4096L) >= 0x4000)
1025 height
= (((unsigned long)maxh
) << 12) / (vscale
+ 4096L);
1027 format
->fmt
.pix
.width
= width
;
1028 format
->fmt
.pix
.height
= height
;
1029 format
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_YUYV
;
1030 format
->fmt
.pix
.bytesperline
= width
* 2;
1031 format
->fmt
.pix
.sizeimage
= width
* 2 * height
;
1032 format
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1033 format
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1035 em28xx_videodbg("%s: returned %dx%d (%d, %d)\n",
1036 cmd
== VIDIOC_TRY_FMT
?
1037 "VIDIOC_TRY_FMT" :"VIDIOC_S_FMT",
1038 format
->fmt
.pix
.width
, format
->fmt
.pix
.height
, hscale
, vscale
);
1040 if (cmd
== VIDIOC_TRY_FMT
)
1043 for (i
= 0; i
< dev
->num_frames
; i
++)
1044 if (dev
->frame
[i
].vma_use_count
) {
1045 em28xx_videodbg("VIDIOC_S_FMT failed. "
1046 "Unmap the buffers first.\n");
1050 /* stop io in case it is already in progress */
1051 if (dev
->stream
== STREAM_ON
) {
1052 em28xx_videodbg("VIDIOC_SET_FMT: interupting stream\n");
1053 if ((ret
= em28xx_stream_interrupt(dev
)))
1057 em28xx_release_buffers(dev
);
1060 /* set new image size */
1062 dev
->height
= height
;
1063 dev
->frame_size
= dev
->width
* dev
->height
* 2;
1064 dev
->field_size
= dev
->frame_size
>> 1;
1065 dev
->bytesperline
= dev
->width
* 2;
1066 dev
->hscale
= hscale
;
1067 dev
->vscale
= vscale
;
1068 em28xx_uninit_isoc(dev
);
1069 em28xx_set_alternate(dev
);
1070 em28xx_capture_start(dev
, 1);
1071 em28xx_resolution_set(dev
);
1072 em28xx_init_isoc(dev
);
1078 * em28xx_v4l2_do_ioctl()
1079 * This function is _not_ called directly, but from
1080 * em28xx_v4l2_ioctl. Userspace
1081 * copying is done already, arg is a kernel pointer.
1083 static int em28xx_do_ioctl(struct inode
*inode
, struct file
*filp
,
1084 struct em28xx
*dev
, unsigned int cmd
, void *arg
,
1085 v4l2_kioctl driver_ioctl
)
1090 /* ---------- tv norms ---------- */
1091 case VIDIOC_ENUMSTD
:
1093 struct v4l2_standard
*e
= arg
;
1099 ret
= v4l2_video_std_construct(e
, tvnorms
[e
->index
].id
,
1100 tvnorms
[e
->index
].name
);
1108 v4l2_std_id
*id
= arg
;
1110 *id
= dev
->tvnorm
->id
;
1115 v4l2_std_id
*id
= arg
;
1118 for (i
= 0; i
< TVNORMS
; i
++)
1119 if (*id
== tvnorms
[i
].id
)
1122 for (i
= 0; i
< TVNORMS
; i
++)
1123 if (*id
& tvnorms
[i
].id
)
1128 mutex_lock(&dev
->lock
);
1129 dev
->tvnorm
= &tvnorms
[i
];
1131 em28xx_set_norm(dev
, dev
->width
, dev
->height
);
1133 em28xx_i2c_call_clients(dev
, DECODER_SET_NORM
,
1135 em28xx_i2c_call_clients(dev
, VIDIOC_S_STD
,
1138 mutex_unlock(&dev
->lock
);
1143 /* ------ input switching ---------- */
1144 case VIDIOC_ENUMINPUT
:
1146 struct v4l2_input
*i
= arg
;
1148 static const char *iname
[] = {
1149 [EM28XX_VMUX_COMPOSITE1
] = "Composite1",
1150 [EM28XX_VMUX_COMPOSITE2
] = "Composite2",
1151 [EM28XX_VMUX_COMPOSITE3
] = "Composite3",
1152 [EM28XX_VMUX_COMPOSITE4
] = "Composite4",
1153 [EM28XX_VMUX_SVIDEO
] = "S-Video",
1154 [EM28XX_VMUX_TELEVISION
] = "Television",
1155 [EM28XX_VMUX_CABLE
] = "Cable TV",
1156 [EM28XX_VMUX_DVB
] = "DVB",
1157 [EM28XX_VMUX_DEBUG
] = "for debug only",
1161 if (n
>= MAX_EM28XX_INPUT
)
1163 if (0 == INPUT(n
)->type
)
1165 memset(i
, 0, sizeof(*i
));
1167 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1168 strcpy(i
->name
, iname
[INPUT(n
)->type
]);
1169 if ((EM28XX_VMUX_TELEVISION
== INPUT(n
)->type
) ||
1170 (EM28XX_VMUX_CABLE
== INPUT(n
)->type
))
1171 i
->type
= V4L2_INPUT_TYPE_TUNER
;
1172 for (n
= 0; n
< ARRAY_SIZE(tvnorms
); n
++)
1173 i
->std
|= tvnorms
[n
].id
;
1176 case VIDIOC_G_INPUT
:
1179 *i
= dev
->ctl_input
;
1183 case VIDIOC_S_INPUT
:
1187 if (*index
>= MAX_EM28XX_INPUT
)
1189 if (0 == INPUT(*index
)->type
)
1192 mutex_lock(&dev
->lock
);
1193 video_mux(dev
, *index
);
1194 mutex_unlock(&dev
->lock
);
1198 case VIDIOC_G_AUDIO
:
1200 struct v4l2_audio
*a
= arg
;
1201 unsigned int index
= a
->index
;
1205 memset(a
, 0, sizeof(*a
));
1206 index
= dev
->ctl_ainput
;
1209 strcpy(a
->name
, "Television");
1211 strcpy(a
->name
, "Line In");
1213 a
->capability
= V4L2_AUDCAP_STEREO
;
1217 case VIDIOC_S_AUDIO
:
1219 struct v4l2_audio
*a
= arg
;
1221 if (a
->index
!= dev
->ctl_ainput
)
1227 /* --- controls ---------------------------------------------- */
1228 case VIDIOC_QUERYCTRL
:
1230 struct v4l2_queryctrl
*qc
= arg
;
1233 memset(qc
,0,sizeof(*qc
));
1236 if (!dev
->has_msp34xx
) {
1237 for (i
= 0; i
< ARRAY_SIZE(em28xx_qctrl
); i
++) {
1238 if (qc
->id
&& qc
->id
== em28xx_qctrl
[i
].id
) {
1239 memcpy(qc
, &(em28xx_qctrl
[i
]),
1245 if (dev
->decoder
== EM28XX_TVP5150
) {
1246 em28xx_i2c_call_clients(dev
,cmd
,qc
);
1252 for (i
= 0; i
< ARRAY_SIZE(saa711x_qctrl
); i
++) {
1253 if (qc
->id
&& qc
->id
== saa711x_qctrl
[i
].id
) {
1254 memcpy(qc
, &(saa711x_qctrl
[i
]),
1264 struct v4l2_control
*ctrl
= arg
;
1267 if (!dev
->has_msp34xx
)
1268 retval
=em28xx_get_ctrl(dev
, ctrl
);
1269 if (retval
==-EINVAL
) {
1270 if (dev
->decoder
== EM28XX_TVP5150
) {
1271 em28xx_i2c_call_clients(dev
,cmd
,arg
);
1275 return saa711x_get_ctrl(dev
, ctrl
);
1276 } else return retval
;
1280 struct v4l2_control
*ctrl
= arg
;
1283 if (!dev
->has_msp34xx
){
1284 for (i
= 0; i
< ARRAY_SIZE(em28xx_qctrl
); i
++) {
1285 if (ctrl
->id
== em28xx_qctrl
[i
].id
) {
1287 em28xx_qctrl
[i
].minimum
1289 em28xx_qctrl
[i
].maximum
)
1291 return em28xx_set_ctrl(dev
, ctrl
);
1296 if (dev
->decoder
== EM28XX_TVP5150
) {
1297 em28xx_i2c_call_clients(dev
,cmd
,arg
);
1299 } else if (!dev
->has_msp34xx
) {
1300 for (i
= 0; i
< ARRAY_SIZE(em28xx_qctrl
); i
++) {
1301 if (ctrl
->id
== em28xx_qctrl
[i
].id
) {
1303 em28xx_qctrl
[i
].minimum
1305 em28xx_qctrl
[i
].maximum
)
1307 return em28xx_set_ctrl(dev
, ctrl
);
1310 for (i
= 0; i
< ARRAY_SIZE(saa711x_qctrl
); i
++) {
1311 if (ctrl
->id
== saa711x_qctrl
[i
].id
) {
1313 saa711x_qctrl
[i
].minimum
1315 saa711x_qctrl
[i
].maximum
)
1317 return saa711x_set_ctrl(dev
, ctrl
);
1324 /* --- tuner ioctls ------------------------------------------ */
1325 case VIDIOC_G_TUNER
:
1327 struct v4l2_tuner
*t
= arg
;
1333 memset(t
, 0, sizeof(*t
));
1334 strcpy(t
->name
, "Tuner");
1335 t
->type
= V4L2_TUNER_ANALOG_TV
;
1336 t
->capability
= V4L2_TUNER_CAP_NORM
;
1337 t
->rangehigh
= 0xffffffffUL
; /* FIXME: set correct range */
1338 /* t->signal = 0xffff;*/
1339 /* em28xx_i2c_call_clients(dev,VIDIOC_G_TUNER,t);*/
1340 /* No way to get signal strength? */
1341 mutex_lock(&dev
->lock
);
1342 em28xx_i2c_call_clients(dev
, DECODER_GET_STATUS
,
1344 mutex_unlock(&dev
->lock
);
1346 (status
& DECODER_STATUS_GOOD
) != 0 ? 0xffff : 0;
1348 em28xx_videodbg("VIDIO_G_TUNER: signal=%x, afc=%x\n", t
->signal
,
1352 case VIDIOC_S_TUNER
:
1354 struct v4l2_tuner
*t
= arg
;
1359 memset(t
, 0, sizeof(*t
));
1360 strcpy(t
->name
, "Tuner");
1361 t
->type
= V4L2_TUNER_ANALOG_TV
;
1362 t
->capability
= V4L2_TUNER_CAP_NORM
;
1363 t
->rangehigh
= 0xffffffffUL
; /* FIXME: set correct range */
1364 /* t->signal = 0xffff; */
1365 /* No way to get signal strength? */
1366 mutex_lock(&dev
->lock
);
1367 em28xx_i2c_call_clients(dev
, DECODER_GET_STATUS
,
1369 mutex_unlock(&dev
->lock
);
1371 (status
& DECODER_STATUS_GOOD
) != 0 ? 0xffff : 0;
1373 em28xx_videodbg("VIDIO_S_TUNER: signal=%x, afc=%x\n",
1377 case VIDIOC_G_FREQUENCY
:
1379 struct v4l2_frequency
*f
= arg
;
1381 memset(f
, 0, sizeof(*f
));
1382 f
->type
= V4L2_TUNER_ANALOG_TV
;
1383 f
->frequency
= dev
->ctl_freq
;
1387 case VIDIOC_S_FREQUENCY
:
1389 struct v4l2_frequency
*f
= arg
;
1394 if (V4L2_TUNER_ANALOG_TV
!= f
->type
)
1397 mutex_lock(&dev
->lock
);
1398 dev
->ctl_freq
= f
->frequency
;
1399 em28xx_i2c_call_clients(dev
, VIDIOC_S_FREQUENCY
, f
);
1400 mutex_unlock(&dev
->lock
);
1403 case VIDIOC_CROPCAP
:
1405 struct v4l2_cropcap
*cc
= arg
;
1407 if (cc
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1409 cc
->bounds
.left
= 0;
1411 cc
->bounds
.width
= dev
->width
;
1412 cc
->bounds
.height
= dev
->height
;
1413 cc
->defrect
= cc
->bounds
;
1414 cc
->pixelaspect
.numerator
= 54; /* 4:3 FIXME: remove magic numbers */
1415 cc
->pixelaspect
.denominator
= 59;
1418 case VIDIOC_STREAMON
:
1422 if (*type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
1423 || dev
->io
!= IO_MMAP
)
1426 if (list_empty(&dev
->inqueue
))
1429 dev
->stream
= STREAM_ON
; /* FIXME: Start video capture here? */
1431 em28xx_videodbg("VIDIOC_STREAMON: starting stream\n");
1435 case VIDIOC_STREAMOFF
:
1440 if (*type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
1441 || dev
->io
!= IO_MMAP
)
1444 if (dev
->stream
== STREAM_ON
) {
1445 em28xx_videodbg ("VIDIOC_STREAMOFF: interrupting stream\n");
1446 if ((ret
= em28xx_stream_interrupt(dev
)))
1449 em28xx_empty_framequeues(dev
);
1454 return v4l_compat_translate_ioctl(inode
, filp
, cmd
, arg
,
1461 * em28xx_v4l2_do_ioctl()
1462 * This function is _not_ called directly, but from
1463 * em28xx_v4l2_ioctl. Userspace
1464 * copying is done already, arg is a kernel pointer.
1466 static int em28xx_video_do_ioctl(struct inode
*inode
, struct file
*filp
,
1467 unsigned int cmd
, void *arg
)
1469 struct em28xx
*dev
= filp
->private_data
;
1474 if (video_debug
> 1)
1475 v4l_print_ioctl(dev
->name
,cmd
);
1479 /* --- capabilities ------------------------------------------ */
1480 case VIDIOC_QUERYCAP
:
1482 struct v4l2_capability
*cap
= arg
;
1484 memset(cap
, 0, sizeof(*cap
));
1485 strlcpy(cap
->driver
, "em28xx", sizeof(cap
->driver
));
1486 strlcpy(cap
->card
, em28xx_boards
[dev
->model
].name
,
1488 strlcpy(cap
->bus_info
, dev
->udev
->dev
.bus_id
,
1489 sizeof(cap
->bus_info
));
1490 cap
->version
= EM28XX_VERSION_CODE
;
1492 V4L2_CAP_SLICED_VBI_CAPTURE
|
1493 V4L2_CAP_VIDEO_CAPTURE
|
1495 V4L2_CAP_READWRITE
| V4L2_CAP_STREAMING
;
1497 cap
->capabilities
|= V4L2_CAP_TUNER
;
1500 /* --- capture ioctls ---------------------------------------- */
1501 case VIDIOC_ENUM_FMT
:
1503 struct v4l2_fmtdesc
*fmtd
= arg
;
1505 if (fmtd
->index
!= 0)
1507 memset(fmtd
, 0, sizeof(*fmtd
));
1508 fmtd
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1509 strcpy(fmtd
->description
, "Packed YUY2");
1510 fmtd
->pixelformat
= V4L2_PIX_FMT_YUYV
;
1511 memset(fmtd
->reserved
, 0, sizeof(fmtd
->reserved
));
1515 return em28xx_get_fmt(dev
, (struct v4l2_format
*) arg
);
1517 case VIDIOC_TRY_FMT
:
1519 return em28xx_set_fmt(dev
, cmd
, (struct v4l2_format
*)arg
);
1521 case VIDIOC_REQBUFS
:
1523 struct v4l2_requestbuffers
*rb
= arg
;
1527 if (rb
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1528 rb
->memory
!= V4L2_MEMORY_MMAP
)
1531 if (dev
->io
== IO_READ
) {
1532 em28xx_videodbg ("method is set to read;"
1533 " close and open the device again to"
1534 " choose the mmap I/O method\n");
1538 for (i
= 0; i
< dev
->num_frames
; i
++)
1539 if (dev
->frame
[i
].vma_use_count
) {
1540 em28xx_videodbg ("VIDIOC_REQBUFS failed; previous buffers are still mapped\n");
1544 if (dev
->stream
== STREAM_ON
) {
1545 em28xx_videodbg("VIDIOC_REQBUFS: interrupting stream\n");
1546 if ((ret
= em28xx_stream_interrupt(dev
)))
1550 em28xx_empty_framequeues(dev
);
1552 em28xx_release_buffers(dev
);
1555 em28xx_request_buffers(dev
, rb
->count
);
1557 dev
->frame_current
= NULL
;
1559 em28xx_videodbg ("VIDIOC_REQBUFS: setting io method to mmap: num bufs %i\n",
1561 dev
->io
= rb
->count
? IO_MMAP
: IO_NONE
;
1564 case VIDIOC_QUERYBUF
:
1566 struct v4l2_buffer
*b
= arg
;
1568 if (b
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1569 b
->index
>= dev
->num_frames
|| dev
->io
!= IO_MMAP
)
1572 memcpy(b
, &dev
->frame
[b
->index
].buf
, sizeof(*b
));
1574 if (dev
->frame
[b
->index
].vma_use_count
) {
1575 b
->flags
|= V4L2_BUF_FLAG_MAPPED
;
1577 if (dev
->frame
[b
->index
].state
== F_DONE
)
1578 b
->flags
|= V4L2_BUF_FLAG_DONE
;
1579 else if (dev
->frame
[b
->index
].state
!= F_UNUSED
)
1580 b
->flags
|= V4L2_BUF_FLAG_QUEUED
;
1585 struct v4l2_buffer
*b
= arg
;
1586 unsigned long lock_flags
;
1588 if (b
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1589 b
->index
>= dev
->num_frames
|| dev
->io
!= IO_MMAP
) {
1593 if (dev
->frame
[b
->index
].state
!= F_UNUSED
) {
1596 dev
->frame
[b
->index
].state
= F_QUEUED
;
1598 /* add frame to fifo */
1599 spin_lock_irqsave(&dev
->queue_lock
, lock_flags
);
1600 list_add_tail(&dev
->frame
[b
->index
].frame
,
1602 spin_unlock_irqrestore(&dev
->queue_lock
, lock_flags
);
1608 struct v4l2_buffer
*b
= arg
;
1609 struct em28xx_frame_t
*f
;
1610 unsigned long lock_flags
;
1613 if (b
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
1614 || dev
->io
!= IO_MMAP
)
1617 if (list_empty(&dev
->outqueue
)) {
1618 if (dev
->stream
== STREAM_OFF
)
1620 if (filp
->f_flags
& O_NONBLOCK
)
1622 ret
= wait_event_interruptible
1624 (!list_empty(&dev
->outqueue
)) ||
1625 (dev
->state
& DEV_DISCONNECTED
));
1628 if (dev
->state
& DEV_DISCONNECTED
)
1632 spin_lock_irqsave(&dev
->queue_lock
, lock_flags
);
1633 f
= list_entry(dev
->outqueue
.next
,
1634 struct em28xx_frame_t
, frame
);
1635 list_del(dev
->outqueue
.next
);
1636 spin_unlock_irqrestore(&dev
->queue_lock
, lock_flags
);
1638 f
->state
= F_UNUSED
;
1639 memcpy(b
, &f
->buf
, sizeof(*b
));
1641 if (f
->vma_use_count
)
1642 b
->flags
|= V4L2_BUF_FLAG_MAPPED
;
1647 return em28xx_do_ioctl(inode
, filp
, dev
, cmd
, arg
,
1648 em28xx_video_do_ioctl
);
1654 * em28xx_v4l2_ioctl()
1655 * handle v4l2 ioctl the main action happens in em28xx_v4l2_do_ioctl()
1657 static int em28xx_v4l2_ioctl(struct inode
*inode
, struct file
*filp
,
1658 unsigned int cmd
, unsigned long arg
)
1661 struct em28xx
*dev
= filp
->private_data
;
1663 if (mutex_lock_interruptible(&dev
->fileop_lock
))
1664 return -ERESTARTSYS
;
1666 if (dev
->state
& DEV_DISCONNECTED
) {
1667 em28xx_errdev("v4l2 ioctl: device not present\n");
1668 mutex_unlock(&dev
->fileop_lock
);
1672 if (dev
->state
& DEV_MISCONFIGURED
) {
1674 ("v4l2 ioctl: device is misconfigured; close and open it again\n");
1675 mutex_unlock(&dev
->fileop_lock
);
1679 ret
= video_usercopy(inode
, filp
, cmd
, arg
, em28xx_video_do_ioctl
);
1681 mutex_unlock(&dev
->fileop_lock
);
1686 static struct file_operations em28xx_v4l_fops
= {
1687 .owner
= THIS_MODULE
,
1688 .open
= em28xx_v4l2_open
,
1689 .release
= em28xx_v4l2_close
,
1690 .ioctl
= em28xx_v4l2_ioctl
,
1691 .read
= em28xx_v4l2_read
,
1692 .poll
= em28xx_v4l2_poll
,
1693 .mmap
= em28xx_v4l2_mmap
,
1694 .llseek
= no_llseek
,
1695 .compat_ioctl
= v4l_compat_ioctl32
,
1699 /******************************** usb interface *****************************************/
1703 * allocates and inits the device structs, registers i2c bus and v4l device
1705 static int em28xx_init_dev(struct em28xx
**devhandle
, struct usb_device
*udev
,
1706 int minor
, int model
)
1708 struct em28xx
*dev
= *devhandle
;
1709 int retval
= -ENOMEM
;
1711 unsigned int maxh
, maxw
;
1715 mutex_init(&dev
->lock
);
1716 init_waitqueue_head(&dev
->open
);
1718 dev
->em28xx_write_regs
= em28xx_write_regs
;
1719 dev
->em28xx_read_reg
= em28xx_read_reg
;
1720 dev
->em28xx_read_reg_req_len
= em28xx_read_reg_req_len
;
1721 dev
->em28xx_write_regs_req
= em28xx_write_regs_req
;
1722 dev
->em28xx_read_reg_req
= em28xx_read_reg_req
;
1723 dev
->is_em2800
= em28xx_boards
[model
].is_em2800
;
1724 dev
->has_tuner
= em28xx_boards
[model
].has_tuner
;
1725 dev
->has_msp34xx
= em28xx_boards
[model
].has_msp34xx
;
1726 dev
->tda9887_conf
= em28xx_boards
[model
].tda9887_conf
;
1727 dev
->decoder
= em28xx_boards
[model
].decoder
;
1730 dev
->tuner_type
= tuner
;
1732 dev
->tuner_type
= em28xx_boards
[model
].tuner_type
;
1734 dev
->video_inputs
= em28xx_boards
[model
].vchannels
;
1736 for (i
= 0; i
< TVNORMS
; i
++)
1737 if (em28xx_boards
[model
].norm
== tvnorms
[i
].mode
)
1742 dev
->tvnorm
= &tvnorms
[i
]; /* set default norm */
1744 em28xx_videodbg("tvnorm=%s\n", dev
->tvnorm
->name
);
1746 maxw
= norm_maxw(dev
);
1747 maxh
= norm_maxh(dev
);
1749 /* set default image size */
1752 dev
->interlaced
= EM28XX_INTERLACED_DEFAULT
;
1753 dev
->field_size
= dev
->width
* dev
->height
;
1755 dev
->interlaced
? dev
->field_size
<< 1 : dev
->field_size
;
1756 dev
->bytesperline
= dev
->width
* 2;
1761 /* setup video picture settings for saa7113h */
1762 memset(&dev
->vpic
, 0, sizeof(dev
->vpic
));
1763 dev
->vpic
.colour
= 128 << 8;
1764 dev
->vpic
.hue
= 128 << 8;
1765 dev
->vpic
.brightness
= 128 << 8;
1766 dev
->vpic
.contrast
= 192 << 8;
1767 dev
->vpic
.whiteness
= 128 << 8; /* This one isn't used */
1768 dev
->vpic
.depth
= 16;
1769 dev
->vpic
.palette
= VIDEO_PALETTE_YUV422
;
1771 em28xx_pre_card_setup(dev
);
1772 #ifdef CONFIG_MODULES
1773 /* request some modules */
1774 if (dev
->decoder
== EM28XX_SAA7113
|| dev
->decoder
== EM28XX_SAA7114
)
1775 request_module("saa711x");
1776 if (dev
->decoder
== EM28XX_TVP5150
)
1777 request_module("tvp5150");
1779 request_module("tuner");
1780 if (dev
->tda9887_conf
)
1781 request_module("tda9887");
1783 errCode
= em28xx_config(dev
);
1785 em28xx_errdev("error configuring device\n");
1787 em28xx_devused
&=~(1<<dev
->devno
);
1791 mutex_lock(&dev
->lock
);
1792 /* register i2c bus */
1793 em28xx_i2c_register(dev
);
1795 /* Do board specific init and eeprom reading */
1796 em28xx_card_setup(dev
);
1798 /* configure the device */
1799 em28xx_config_i2c(dev
);
1801 mutex_unlock(&dev
->lock
);
1803 errCode
= em28xx_config(dev
);
1805 #ifdef CONFIG_MODULES
1806 if (dev
->has_msp34xx
)
1807 request_module("msp3400");
1809 /* allocate and fill v4l2 device struct */
1810 dev
->vdev
= video_device_alloc();
1811 if (NULL
== dev
->vdev
) {
1812 em28xx_errdev("cannot allocate video_device.\n");
1814 em28xx_devused
&=~(1<<dev
->devno
);
1818 dev
->vbi_dev
= video_device_alloc();
1819 if (NULL
== dev
->vbi_dev
) {
1820 em28xx_errdev("cannot allocate video_device.\n");
1823 em28xx_devused
&=~(1<<dev
->devno
);
1827 /* Fills VBI device info */
1828 dev
->vbi_dev
->type
= VFL_TYPE_VBI
;
1829 dev
->vbi_dev
->hardware
= 0;
1830 dev
->vbi_dev
->fops
= &em28xx_v4l_fops
;
1831 dev
->vbi_dev
->minor
= -1;
1832 dev
->vbi_dev
->dev
= &dev
->udev
->dev
;
1833 dev
->vbi_dev
->release
= video_device_release
;
1834 snprintf(dev
->vbi_dev
->name
, sizeof(dev
->vbi_dev
->name
), "%s#%d %s",
1835 "em28xx",dev
->devno
,"vbi");
1837 /* Fills CAPTURE device info */
1838 dev
->vdev
->type
= VID_TYPE_CAPTURE
;
1840 dev
->vdev
->type
|= VID_TYPE_TUNER
;
1841 dev
->vdev
->hardware
= 0;
1842 dev
->vdev
->fops
= &em28xx_v4l_fops
;
1843 dev
->vdev
->minor
= -1;
1844 dev
->vdev
->dev
= &dev
->udev
->dev
;
1845 dev
->vdev
->release
= video_device_release
;
1846 snprintf(dev
->vdev
->name
, sizeof(dev
->vbi_dev
->name
), "%s#%d %s",
1847 "em28xx",dev
->devno
,"video");
1849 list_add_tail(&dev
->devlist
,&em28xx_devlist
);
1851 /* register v4l2 device */
1852 mutex_lock(&dev
->lock
);
1853 if ((retval
= video_register_device(dev
->vdev
, VFL_TYPE_GRABBER
,
1854 video_nr
[dev
->devno
]))) {
1855 em28xx_errdev("unable to register video device (error=%i).\n",
1857 mutex_unlock(&dev
->lock
);
1858 list_del(&dev
->devlist
);
1859 video_device_release(dev
->vdev
);
1861 em28xx_devused
&=~(1<<dev
->devno
);
1865 if (video_register_device(dev
->vbi_dev
, VFL_TYPE_VBI
,
1866 vbi_nr
[dev
->devno
]) < 0) {
1867 printk("unable to register vbi device\n");
1868 mutex_unlock(&dev
->lock
);
1869 list_del(&dev
->devlist
);
1870 video_device_release(dev
->vbi_dev
);
1871 video_device_release(dev
->vdev
);
1873 em28xx_devused
&=~(1<<dev
->devno
);
1876 printk("registered VBI\n");
1879 if (dev
->has_msp34xx
) {
1880 /* Send a reset to other chips via gpio */
1881 em28xx_write_regs_req(dev
, 0x00, 0x08, "\xf7", 1);
1883 em28xx_write_regs_req(dev
, 0x00, 0x08, "\xff", 1);
1889 mutex_unlock(&dev
->lock
);
1891 em28xx_info("V4L2 device registered as /dev/video%d and /dev/vbi%d\n",
1892 dev
->vdev
->minor
-MINOR_VFL_TYPE_GRABBER_MIN
,
1893 dev
->vbi_dev
->minor
-MINOR_VFL_TYPE_VBI_MIN
);
1899 * em28xx_usb_probe()
1900 * checks for supported devices
1902 static int em28xx_usb_probe(struct usb_interface
*interface
,
1903 const struct usb_device_id
*id
)
1905 const struct usb_endpoint_descriptor
*endpoint
;
1906 struct usb_device
*udev
;
1907 struct usb_interface
*uif
;
1908 struct em28xx
*dev
= NULL
;
1909 int retval
= -ENODEV
;
1910 int model
,i
,nr
,ifnum
;
1912 udev
= usb_get_dev(interface_to_usbdev(interface
));
1913 ifnum
= interface
->altsetting
[0].desc
.bInterfaceNumber
;
1915 /* Check to see next free device and mark as used */
1916 nr
=find_first_zero_bit(&em28xx_devused
,EM28XX_MAXBOARDS
);
1917 em28xx_devused
|=1<<nr
;
1919 /* Don't register audio interfaces */
1920 if (interface
->altsetting
[0].desc
.bInterfaceClass
== USB_CLASS_AUDIO
) {
1921 em28xx_err(DRIVER_NAME
" audio device (%04x:%04x): interface %i, class %i\n",
1922 udev
->descriptor
.idVendor
,udev
->descriptor
.idProduct
,
1924 interface
->altsetting
[0].desc
.bInterfaceClass
);
1926 em28xx_devused
&=~(1<<nr
);
1930 em28xx_err(DRIVER_NAME
" new video device (%04x:%04x): interface %i, class %i\n",
1931 udev
->descriptor
.idVendor
,udev
->descriptor
.idProduct
,
1933 interface
->altsetting
[0].desc
.bInterfaceClass
);
1935 endpoint
= &interface
->cur_altsetting
->endpoint
[1].desc
;
1937 /* check if the the device has the iso in endpoint at the correct place */
1938 if ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) !=
1939 USB_ENDPOINT_XFER_ISOC
) {
1940 em28xx_err(DRIVER_NAME
" probing error: endpoint is non-ISO endpoint!\n");
1941 em28xx_devused
&=~(1<<nr
);
1944 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) == USB_DIR_OUT
) {
1945 em28xx_err(DRIVER_NAME
" probing error: endpoint is ISO OUT endpoint!\n");
1946 em28xx_devused
&=~(1<<nr
);
1950 model
=id
->driver_info
;
1952 if (nr
> EM28XX_MAXBOARDS
) {
1953 printk (DRIVER_NAME
": Supports only %i em28xx boards.\n",EM28XX_MAXBOARDS
);
1954 em28xx_devused
&=~(1<<nr
);
1958 /* allocate memory for our device state and initialize it */
1959 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1961 em28xx_err(DRIVER_NAME
": out of memory!\n");
1962 em28xx_devused
&=~(1<<nr
);
1966 snprintf(dev
->name
, 29, "em28xx #%d", nr
);
1969 /* compute alternate max packet sizes */
1970 uif
= udev
->actconfig
->interface
[0];
1972 dev
->num_alt
=uif
->num_altsetting
;
1973 em28xx_info("Alternate settings: %i\n",dev
->num_alt
);
1974 // dev->alt_max_pkt_size = kmalloc(sizeof(*dev->alt_max_pkt_size)*
1975 dev
->alt_max_pkt_size
= kmalloc(32*
1976 dev
->num_alt
,GFP_KERNEL
);
1977 if (dev
->alt_max_pkt_size
== NULL
) {
1978 em28xx_errdev("out of memory!\n");
1979 em28xx_devused
&=~(1<<nr
);
1983 for (i
= 0; i
< dev
->num_alt
; i
++) {
1984 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[1].desc
.
1986 dev
->alt_max_pkt_size
[i
] =
1987 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1988 em28xx_info("Alternate setting %i, max size= %i\n",i
,
1989 dev
->alt_max_pkt_size
[i
]);
1992 if ((card
[nr
]>=0)&&(card
[nr
]<em28xx_bcount
))
1995 if ((model
==EM2800_BOARD_UNKNOWN
)||(model
==EM2820_BOARD_UNKNOWN
)) {
1996 em28xx_errdev( "Your board has no eeprom inside it and thus can't\n"
1997 "%s: be autodetected. Please pass card=<n> insmod option to\n"
1998 "%s: workaround that. Redirect complaints to the vendor of\n"
1999 "%s: the TV card. Generic type will be used."
2000 "%s: Best regards,\n"
2002 dev
->name
,dev
->name
,dev
->name
,dev
->name
,dev
->name
);
2003 em28xx_errdev("%s: Here is a list of valid choices for the card=<n> insmod option:\n",
2005 for (i
= 0; i
< em28xx_bcount
; i
++) {
2006 em28xx_errdev(" card=%d -> %s\n", i
,
2007 em28xx_boards
[i
].name
);
2011 /* allocate device struct */
2012 retval
= em28xx_init_dev(&dev
, udev
, nr
, model
);
2016 em28xx_info("Found %s\n", em28xx_boards
[model
].name
);
2018 /* save our data pointer in this interface device */
2019 usb_set_intfdata(interface
, dev
);
2024 * em28xx_usb_disconnect()
2025 * called when the device gets diconencted
2026 * video device will be unregistered on v4l2_close in case it is still open
2028 static void em28xx_usb_disconnect(struct usb_interface
*interface
)
2030 struct em28xx
*dev
= usb_get_intfdata(interface
);
2031 usb_set_intfdata(interface
, NULL
);
2036 down_write(&em28xx_disconnect
);
2038 mutex_lock(&dev
->lock
);
2040 em28xx_info("disconnecting %s\n", dev
->vdev
->name
);
2042 wake_up_interruptible_all(&dev
->open
);
2046 ("device /dev/video%d is open! Deregistration and memory "
2047 "deallocation are deferred on close.\n",
2048 dev
->vdev
->minor
-MINOR_VFL_TYPE_GRABBER_MIN
);
2050 dev
->state
|= DEV_MISCONFIGURED
;
2051 em28xx_uninit_isoc(dev
);
2052 dev
->state
|= DEV_DISCONNECTED
;
2053 wake_up_interruptible(&dev
->wait_frame
);
2054 wake_up_interruptible(&dev
->wait_stream
);
2056 dev
->state
|= DEV_DISCONNECTED
;
2057 em28xx_release_resources(dev
);
2060 mutex_unlock(&dev
->lock
);
2063 kfree(dev
->alt_max_pkt_size
);
2067 up_write(&em28xx_disconnect
);
2070 static struct usb_driver em28xx_usb_driver
= {
2072 .probe
= em28xx_usb_probe
,
2073 .disconnect
= em28xx_usb_disconnect
,
2074 .id_table
= em28xx_id_table
,
2077 static int __init
em28xx_module_init(void)
2081 printk(KERN_INFO DRIVER_NAME
" v4l2 driver version %d.%d.%d loaded\n",
2082 (EM28XX_VERSION_CODE
>> 16) & 0xff,
2083 (EM28XX_VERSION_CODE
>> 8) & 0xff, EM28XX_VERSION_CODE
& 0xff);
2085 printk(KERN_INFO DRIVER_NAME
" snapshot date %04d-%02d-%02d\n",
2086 SNAPSHOT
/ 10000, (SNAPSHOT
/ 100) % 100, SNAPSHOT
% 100);
2089 /* register this driver with the USB subsystem */
2090 result
= usb_register(&em28xx_usb_driver
);
2092 em28xx_err(DRIVER_NAME
2093 " usb_register failed. Error number %d.\n", result
);
2098 static void __exit
em28xx_module_exit(void)
2100 /* deregister this driver with the USB subsystem */
2101 usb_deregister(&em28xx_usb_driver
);
2104 module_init(em28xx_module_init
);
2105 module_exit(em28xx_module_exit
);