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@infradead.org>
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>
41 #include <media/msp3400.h>
43 #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
44 "Markus Rechberger <mrechberger@gmail.com>, " \
45 "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
46 "Sascha Sommer <saschasommer@freenet.de>"
48 #define DRIVER_NAME "em28xx"
49 #define DRIVER_DESC "Empia em28xx based USB video device driver"
50 #define EM28XX_VERSION_CODE KERNEL_VERSION(0, 0, 1)
52 #define em28xx_videodbg(fmt, arg...) do {\
54 printk(KERN_INFO "%s %s :"fmt, \
55 dev->name, __FUNCTION__ , ##arg); } while (0)
57 MODULE_AUTHOR(DRIVER_AUTHOR
);
58 MODULE_DESCRIPTION(DRIVER_DESC
);
59 MODULE_LICENSE("GPL");
61 static LIST_HEAD(em28xx_devlist
);
63 static unsigned int card
[] = {[0 ... (EM28XX_MAXBOARDS
- 1)] = UNSET
};
64 static unsigned int video_nr
[] = {[0 ... (EM28XX_MAXBOARDS
- 1)] = UNSET
};
65 static unsigned int vbi_nr
[] = {[0 ... (EM28XX_MAXBOARDS
- 1)] = UNSET
};
66 module_param_array(card
, int, NULL
, 0444);
67 module_param_array(video_nr
, int, NULL
, 0444);
68 module_param_array(vbi_nr
, int, NULL
, 0444);
69 MODULE_PARM_DESC(card
,"card type");
70 MODULE_PARM_DESC(video_nr
,"video device numbers");
71 MODULE_PARM_DESC(vbi_nr
,"vbi device numbers");
73 static int tuner
= -1;
74 module_param(tuner
, int, 0444);
75 MODULE_PARM_DESC(tuner
, "tuner type");
77 static unsigned int video_debug
= 0;
78 module_param(video_debug
,int,0644);
79 MODULE_PARM_DESC(video_debug
,"enable debug messages [video]");
81 /* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS */
82 static unsigned long em28xx_devused
;
84 /* supported tv norms */
85 static struct em28xx_tvnorm tvnorms
[] = {
89 .mode
= VIDEO_MODE_PAL
,
93 .mode
= VIDEO_MODE_NTSC
,
97 .mode
= VIDEO_MODE_SECAM
,
100 .id
= V4L2_STD_PAL_M
,
101 .mode
= VIDEO_MODE_PAL
,
105 #define TVNORMS ARRAY_SIZE(tvnorms)
107 /* supported controls */
108 /* Common to all boards */
109 static struct v4l2_queryctrl em28xx_qctrl
[] = {
111 .id
= V4L2_CID_AUDIO_VOLUME
,
112 .type
= V4L2_CTRL_TYPE_INTEGER
,
117 .default_value
= 0x1f,
120 .id
= V4L2_CID_AUDIO_MUTE
,
121 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
131 static struct usb_driver em28xx_usb_driver
;
133 static DEFINE_MUTEX(em28xx_sysfs_lock
);
134 static DECLARE_RWSEM(em28xx_disconnect
);
136 /********************* v4l2 interface ******************************************/
140 * inits registers with sane defaults
142 static int em28xx_config(struct em28xx
*dev
)
145 /* Sets I2C speed to 100 KHz */
146 em28xx_write_regs_req(dev
, 0x00, 0x06, "\x40", 1);
148 /* enable vbi capturing */
150 /* em28xx_write_regs_req(dev,0x00,0x0e,"\xC0",1); audio register */
151 /* em28xx_write_regs_req(dev,0x00,0x0f,"\x80",1); clk register */
152 em28xx_write_regs_req(dev
,0x00,0x11,"\x51",1);
154 em28xx_audio_usb_mute(dev
, 1);
155 dev
->mute
= 1; /* maybe not the right place... */
157 em28xx_audio_analog_set(dev
);
158 em28xx_audio_analog_setup(dev
);
159 em28xx_outfmt_set_yuv422(dev
);
160 em28xx_colorlevels_set_default(dev
);
161 em28xx_compression_disable(dev
);
167 * em28xx_config_i2c()
168 * configure i2c attached devices
170 static void em28xx_config_i2c(struct em28xx
*dev
)
172 struct v4l2_frequency f
;
173 struct v4l2_routing route
;
175 route
.input
= INPUT(dev
->ctl_input
)->vmux
;
177 em28xx_i2c_call_clients(dev
, VIDIOC_INT_RESET
, NULL
);
178 em28xx_i2c_call_clients(dev
, VIDIOC_INT_S_VIDEO_ROUTING
, &route
);
179 em28xx_i2c_call_clients(dev
, VIDIOC_STREAMON
, NULL
);
181 /* configure tuner */
183 f
.type
= V4L2_TUNER_ANALOG_TV
;
184 f
.frequency
= 9076; /* FIXME:remove magic number */
185 dev
->ctl_freq
= f
.frequency
;
186 em28xx_i2c_call_clients(dev
, VIDIOC_S_FREQUENCY
, &f
);
188 /* configure tda9887 */
191 /* em28xx_i2c_call_clients(dev,VIDIOC_S_STD,&dev->tvnorm->id); */
195 * em28xx_empty_framequeues()
196 * prepare queues for incoming and outgoing frames
198 static void em28xx_empty_framequeues(struct em28xx
*dev
)
202 INIT_LIST_HEAD(&dev
->inqueue
);
203 INIT_LIST_HEAD(&dev
->outqueue
);
205 for (i
= 0; i
< EM28XX_NUM_FRAMES
; i
++) {
206 dev
->frame
[i
].state
= F_UNUSED
;
207 dev
->frame
[i
].buf
.bytesused
= 0;
211 static void video_mux(struct em28xx
*dev
, int index
)
214 struct v4l2_routing route
;
216 route
.input
= INPUT(index
)->vmux
;
218 dev
->ctl_input
= index
;
219 dev
->ctl_ainput
= INPUT(index
)->amux
;
221 em28xx_i2c_call_clients(dev
, VIDIOC_INT_S_VIDEO_ROUTING
, &route
);
223 em28xx_videodbg("Setting input index=%d, vmux=%d, amux=%d\n",index
,route
.input
,dev
->ctl_ainput
);
225 if (dev
->has_msp34xx
) {
227 em28xx_i2c_call_clients(dev
, VIDIOC_INT_I2S_CLOCK_FREQ
, &dev
->i2s_speed
);
228 route
.input
= dev
->ctl_ainput
;
229 route
.output
= MSP_OUTPUT(MSP_SC_IN_DSP_SCART1
);
230 /* Note: this is msp3400 specific */
231 em28xx_i2c_call_clients(dev
, VIDIOC_INT_S_AUDIO_ROUTING
, &route
);
232 ainput
= EM28XX_AUDIO_SRC_TUNER
;
233 em28xx_audio_source(dev
, ainput
);
235 switch (dev
->ctl_ainput
) {
237 ainput
= EM28XX_AUDIO_SRC_TUNER
;
240 ainput
= EM28XX_AUDIO_SRC_LINE
;
242 em28xx_audio_source(dev
, ainput
);
248 * inits the device and starts isoc transfer
250 static int em28xx_v4l2_open(struct inode
*inode
, struct file
*filp
)
252 int minor
= iminor(inode
);
254 struct em28xx
*h
,*dev
= NULL
;
255 struct list_head
*list
;
257 list_for_each(list
,&em28xx_devlist
) {
258 h
= list_entry(list
, struct em28xx
, devlist
);
259 if (h
->vdev
->minor
== minor
) {
261 dev
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
263 if (h
->vbi_dev
->minor
== minor
) {
265 dev
->type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
271 em28xx_videodbg("open minor=%d type=%s users=%d\n",
272 minor
,v4l2_type_names
[dev
->type
],dev
->users
);
274 if (!down_read_trylock(&em28xx_disconnect
))
278 em28xx_warn("this driver can be opened only once\n");
279 up_read(&em28xx_disconnect
);
283 mutex_init(&dev
->fileop_lock
); /* to 1 == available */
284 spin_lock_init(&dev
->queue_lock
);
285 init_waitqueue_head(&dev
->wait_frame
);
286 init_waitqueue_head(&dev
->wait_stream
);
288 mutex_lock(&dev
->lock
);
290 if (dev
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
291 em28xx_set_alternate(dev
);
293 dev
->width
= norm_maxw(dev
);
294 dev
->height
= norm_maxh(dev
);
295 dev
->frame_size
= dev
->width
* dev
->height
* 2;
296 dev
->field_size
= dev
->frame_size
>> 1; /*both_fileds ? dev->frame_size>>1 : dev->frame_size; */
297 dev
->bytesperline
= dev
->width
* 2;
301 em28xx_capture_start(dev
, 1);
302 em28xx_resolution_set(dev
);
304 /* device needs to be initialized before isoc transfer */
307 /* start the transfer */
308 errCode
= em28xx_init_isoc(dev
);
315 filp
->private_data
= dev
;
317 dev
->stream
= STREAM_OFF
;
321 em28xx_empty_framequeues(dev
);
323 dev
->state
|= DEV_INITIALIZED
;
326 mutex_unlock(&dev
->lock
);
327 up_read(&em28xx_disconnect
);
332 * em28xx_realease_resources()
333 * unregisters the v4l2,i2c and usb devices
334 * called when the device gets disconected or at module unload
336 static void em28xx_release_resources(struct em28xx
*dev
)
338 mutex_lock(&em28xx_sysfs_lock
);
340 /*FIXME: I2C IR should be disconnected */
342 em28xx_info("V4L2 devices /dev/video%d and /dev/vbi%d deregistered\n",
343 dev
->vdev
->minor
-MINOR_VFL_TYPE_GRABBER_MIN
,
344 dev
->vbi_dev
->minor
-MINOR_VFL_TYPE_VBI_MIN
);
345 list_del(&dev
->devlist
);
346 video_unregister_device(dev
->vdev
);
347 video_unregister_device(dev
->vbi_dev
);
348 em28xx_i2c_unregister(dev
);
349 usb_put_dev(dev
->udev
);
350 mutex_unlock(&em28xx_sysfs_lock
);
353 /* Mark device as unused */
354 em28xx_devused
&=~(1<<dev
->devno
);
358 * em28xx_v4l2_close()
359 * stops streaming and deallocates all resources allocated by the v4l2 calls and ioctls
361 static int em28xx_v4l2_close(struct inode
*inode
, struct file
*filp
)
364 struct em28xx
*dev
=filp
->private_data
;
366 em28xx_videodbg("users=%d\n", dev
->users
);
368 mutex_lock(&dev
->lock
);
370 em28xx_uninit_isoc(dev
);
372 em28xx_release_buffers(dev
);
374 /* the device is already disconnect, free the remaining resources */
375 if (dev
->state
& DEV_DISCONNECTED
) {
376 em28xx_release_resources(dev
);
377 mutex_unlock(&dev
->lock
);
382 /* set alternate 0 */
384 em28xx_videodbg("setting alternate 0\n");
385 errCode
= usb_set_interface(dev
->udev
, 0, 0);
387 em28xx_errdev ("cannot change alternate number to 0 (error=%i)\n",
392 wake_up_interruptible_nr(&dev
->open
, 1);
393 mutex_unlock(&dev
->lock
);
399 * will allocate buffers when called for the first time
402 em28xx_v4l2_read(struct file
*filp
, char __user
* buf
, size_t count
,
405 struct em28xx_frame_t
*f
, *i
;
406 unsigned long lock_flags
;
408 struct em28xx
*dev
= filp
->private_data
;
410 if (dev
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
411 em28xx_videodbg("V4l2_Buf_type_videocapture is set\n");
413 if (dev
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
414 em28xx_videodbg("V4L2_BUF_TYPE_VBI_CAPTURE is set\n");
415 em28xx_videodbg("not supported yet! ...\n");
416 if (copy_to_user(buf
, "", 1)) {
417 mutex_unlock(&dev
->fileop_lock
);
422 if (dev
->type
== V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
) {
423 em28xx_videodbg("V4L2_BUF_TYPE_SLICED_VBI_CAPTURE is set\n");
424 em28xx_videodbg("not supported yet! ...\n");
425 if (copy_to_user(buf
, "", 1)) {
426 mutex_unlock(&dev
->fileop_lock
);
432 if (mutex_lock_interruptible(&dev
->fileop_lock
))
435 if (dev
->state
& DEV_DISCONNECTED
) {
436 em28xx_videodbg("device not present\n");
437 mutex_unlock(&dev
->fileop_lock
);
441 if (dev
->state
& DEV_MISCONFIGURED
) {
442 em28xx_videodbg("device misconfigured; close and open it again\n");
443 mutex_unlock(&dev
->fileop_lock
);
447 if (dev
->io
== IO_MMAP
) {
448 em28xx_videodbg ("IO method is set to mmap; close and open"
449 " the device again to choose the read method\n");
450 mutex_unlock(&dev
->fileop_lock
);
454 if (dev
->io
== IO_NONE
) {
455 if (!em28xx_request_buffers(dev
, EM28XX_NUM_READ_FRAMES
)) {
456 em28xx_errdev("read failed, not enough memory\n");
457 mutex_unlock(&dev
->fileop_lock
);
461 dev
->stream
= STREAM_ON
;
462 em28xx_queue_unusedframes(dev
);
466 mutex_unlock(&dev
->fileop_lock
);
470 if (list_empty(&dev
->outqueue
)) {
471 if (filp
->f_flags
& O_NONBLOCK
) {
472 mutex_unlock(&dev
->fileop_lock
);
475 ret
= wait_event_interruptible
477 (!list_empty(&dev
->outqueue
)) ||
478 (dev
->state
& DEV_DISCONNECTED
));
480 mutex_unlock(&dev
->fileop_lock
);
483 if (dev
->state
& DEV_DISCONNECTED
) {
484 mutex_unlock(&dev
->fileop_lock
);
489 f
= list_entry(dev
->outqueue
.prev
, struct em28xx_frame_t
, frame
);
491 spin_lock_irqsave(&dev
->queue_lock
, lock_flags
);
492 list_for_each_entry(i
, &dev
->outqueue
, frame
)
494 INIT_LIST_HEAD(&dev
->outqueue
);
495 spin_unlock_irqrestore(&dev
->queue_lock
, lock_flags
);
497 em28xx_queue_unusedframes(dev
);
499 if (count
> f
->buf
.length
)
500 count
= f
->buf
.length
;
502 if (copy_to_user(buf
, f
->bufmem
, count
)) {
503 mutex_unlock(&dev
->fileop_lock
);
508 mutex_unlock(&dev
->fileop_lock
);
515 * will allocate buffers when called for the first time
517 static unsigned int em28xx_v4l2_poll(struct file
*filp
, poll_table
* wait
)
519 unsigned int mask
= 0;
520 struct em28xx
*dev
= filp
->private_data
;
522 if (mutex_lock_interruptible(&dev
->fileop_lock
))
525 if (dev
->state
& DEV_DISCONNECTED
) {
526 em28xx_videodbg("device not present\n");
527 } else if (dev
->state
& DEV_MISCONFIGURED
) {
528 em28xx_videodbg("device is misconfigured; close and open it again\n");
530 if (dev
->io
== IO_NONE
) {
531 if (!em28xx_request_buffers
532 (dev
, EM28XX_NUM_READ_FRAMES
)) {
534 ("poll() failed, not enough memory\n");
537 dev
->stream
= STREAM_ON
;
541 if (dev
->io
== IO_READ
) {
542 em28xx_queue_unusedframes(dev
);
543 poll_wait(filp
, &dev
->wait_frame
, wait
);
545 if (!list_empty(&dev
->outqueue
))
546 mask
|= POLLIN
| POLLRDNORM
;
548 mutex_unlock(&dev
->fileop_lock
);
554 mutex_unlock(&dev
->fileop_lock
);
561 static void em28xx_vm_open(struct vm_area_struct
*vma
)
563 struct em28xx_frame_t
*f
= vma
->vm_private_data
;
570 static void em28xx_vm_close(struct vm_area_struct
*vma
)
572 /* NOTE: buffers are not freed here */
573 struct em28xx_frame_t
*f
= vma
->vm_private_data
;
577 static struct vm_operations_struct em28xx_vm_ops
= {
578 .open
= em28xx_vm_open
,
579 .close
= em28xx_vm_close
,
585 static int em28xx_v4l2_mmap(struct file
*filp
, struct vm_area_struct
*vma
)
587 unsigned long size
= vma
->vm_end
- vma
->vm_start
,
588 start
= vma
->vm_start
;
592 struct em28xx
*dev
= filp
->private_data
;
594 if (mutex_lock_interruptible(&dev
->fileop_lock
))
597 if (dev
->state
& DEV_DISCONNECTED
) {
598 em28xx_videodbg("mmap: device not present\n");
599 mutex_unlock(&dev
->fileop_lock
);
603 if (dev
->state
& DEV_MISCONFIGURED
) {
604 em28xx_videodbg ("mmap: Device is misconfigured; close and "
606 mutex_unlock(&dev
->fileop_lock
);
610 if (dev
->io
!= IO_MMAP
|| !(vma
->vm_flags
& VM_WRITE
) ||
611 size
!= PAGE_ALIGN(dev
->frame
[0].buf
.length
)) {
612 mutex_unlock(&dev
->fileop_lock
);
616 for (i
= 0; i
< dev
->num_frames
; i
++) {
617 if ((dev
->frame
[i
].buf
.m
.offset
>> PAGE_SHIFT
) == vma
->vm_pgoff
)
620 if (i
== dev
->num_frames
) {
621 em28xx_videodbg("mmap: user supplied mapping address is out of range\n");
622 mutex_unlock(&dev
->fileop_lock
);
626 /* VM_IO is eventually going to replace PageReserved altogether */
627 vma
->vm_flags
|= VM_IO
;
628 vma
->vm_flags
|= VM_RESERVED
; /* avoid to swap out this VMA */
630 pos
= dev
->frame
[i
].bufmem
;
631 while (size
> 0) { /* size is page-aligned */
632 if (vm_insert_page(vma
, start
, vmalloc_to_page(pos
))) {
633 em28xx_videodbg("mmap: vm_insert_page failed\n");
634 mutex_unlock(&dev
->fileop_lock
);
642 vma
->vm_ops
= &em28xx_vm_ops
;
643 vma
->vm_private_data
= &dev
->frame
[i
];
646 mutex_unlock(&dev
->fileop_lock
);
652 * return the current saturation, brightness or contrast, mute state
654 static int em28xx_get_ctrl(struct em28xx
*dev
, struct v4l2_control
*ctrl
)
657 case V4L2_CID_AUDIO_MUTE
:
658 ctrl
->value
= dev
->mute
;
660 case V4L2_CID_AUDIO_VOLUME
:
661 ctrl
->value
= dev
->volume
;
670 * mute or set new saturation, brightness or contrast
672 static int em28xx_set_ctrl(struct em28xx
*dev
, const struct v4l2_control
*ctrl
)
675 case V4L2_CID_AUDIO_MUTE
:
676 if (ctrl
->value
!= dev
->mute
) {
677 dev
->mute
= ctrl
->value
;
678 em28xx_audio_usb_mute(dev
, ctrl
->value
);
679 return em28xx_audio_analog_set(dev
);
682 case V4L2_CID_AUDIO_VOLUME
:
683 dev
->volume
= ctrl
->value
;
684 return em28xx_audio_analog_set(dev
);
691 * em28xx_stream_interrupt()
694 static int em28xx_stream_interrupt(struct em28xx
*dev
)
698 /* stop reading from the device */
700 dev
->stream
= STREAM_INTERRUPT
;
701 ret
= wait_event_timeout(dev
->wait_stream
,
702 (dev
->stream
== STREAM_OFF
) ||
703 (dev
->state
& DEV_DISCONNECTED
),
705 if (dev
->state
& DEV_DISCONNECTED
)
708 dev
->state
|= DEV_MISCONFIGURED
;
709 em28xx_videodbg("device is misconfigured; close and "
710 "open /dev/video%d again\n",
711 dev
->vdev
->minor
-MINOR_VFL_TYPE_GRABBER_MIN
);
718 static int em28xx_set_norm(struct em28xx
*dev
, int width
, int height
)
720 unsigned int hscale
, vscale
;
721 unsigned int maxh
, maxw
;
723 maxw
= norm_maxw(dev
);
724 maxh
= norm_maxh(dev
);
726 /* width must even because of the YUYV format */
727 /* height must be even because of interlacing */
740 if ((hscale
= (((unsigned long)maxw
) << 12) / width
- 4096L) >= 0x4000)
742 width
= (((unsigned long)maxw
) << 12) / (hscale
+ 4096L);
744 if ((vscale
= (((unsigned long)maxh
) << 12) / height
- 4096L) >= 0x4000)
746 height
= (((unsigned long)maxh
) << 12) / (vscale
+ 4096L);
748 /* set new image size */
750 dev
->height
= height
;
751 dev
->frame_size
= dev
->width
* dev
->height
* 2;
752 dev
->field_size
= dev
->frame_size
>> 1; /*both_fileds ? dev->frame_size>>1 : dev->frame_size; */
753 dev
->bytesperline
= dev
->width
* 2;
754 dev
->hscale
= hscale
;
755 dev
->vscale
= vscale
;
757 em28xx_resolution_set(dev
);
762 static int em28xx_get_fmt(struct em28xx
*dev
, struct v4l2_format
*format
)
764 em28xx_videodbg("VIDIOC_G_FMT: type=%s\n",
765 (format
->type
==V4L2_BUF_TYPE_VIDEO_CAPTURE
) ?
766 "V4L2_BUF_TYPE_VIDEO_CAPTURE" :
767 (format
->type
==V4L2_BUF_TYPE_VBI_CAPTURE
) ?
768 "V4L2_BUF_TYPE_VBI_CAPTURE" :
769 (format
->type
==V4L2_CAP_SLICED_VBI_CAPTURE
) ?
770 "V4L2_BUF_TYPE_SLICED_VBI_CAPTURE " :
773 switch (format
->type
) {
774 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
776 format
->fmt
.pix
.width
= dev
->width
;
777 format
->fmt
.pix
.height
= dev
->height
;
778 format
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_YUYV
;
779 format
->fmt
.pix
.bytesperline
= dev
->bytesperline
;
780 format
->fmt
.pix
.sizeimage
= dev
->frame_size
;
781 format
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
782 format
->fmt
.pix
.field
= dev
->interlaced
? V4L2_FIELD_INTERLACED
: V4L2_FIELD_TOP
; /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
784 em28xx_videodbg("VIDIOC_G_FMT: %dx%d\n", dev
->width
,
789 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
791 format
->fmt
.sliced
.service_set
=0;
793 em28xx_i2c_call_clients(dev
,VIDIOC_G_FMT
,format
);
795 if (format
->fmt
.sliced
.service_set
==0)
807 static int em28xx_set_fmt(struct em28xx
*dev
, unsigned int cmd
, struct v4l2_format
*format
)
811 int width
= format
->fmt
.pix
.width
;
812 int height
= format
->fmt
.pix
.height
;
813 unsigned int hscale
, vscale
;
814 unsigned int maxh
, maxw
;
816 maxw
= norm_maxw(dev
);
817 maxh
= norm_maxh(dev
);
819 em28xx_videodbg("%s: type=%s\n",
820 cmd
== VIDIOC_TRY_FMT
?
821 "VIDIOC_TRY_FMT" : "VIDIOC_S_FMT",
822 format
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
?
823 "V4L2_BUF_TYPE_VIDEO_CAPTURE" :
824 format
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
?
825 "V4L2_BUF_TYPE_VBI_CAPTURE " :
828 if (format
->type
== V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
) {
829 em28xx_i2c_call_clients(dev
,VIDIOC_G_FMT
,format
);
831 if (format
->fmt
.sliced
.service_set
==0)
838 if (format
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
841 em28xx_videodbg("%s: requested %dx%d\n",
842 cmd
== VIDIOC_TRY_FMT
?
843 "VIDIOC_TRY_FMT" : "VIDIOC_S_FMT",
844 format
->fmt
.pix
.width
, format
->fmt
.pix
.height
);
846 /* FIXME: Move some code away from here */
847 /* width must even because of the YUYV format */
848 /* height must be even because of interlacing */
862 /* the em2800 can only scale down to 50% */
863 if(height
% (maxh
/ 2))
865 if(width
% (maxw
/ 2))
867 /* according to empiatech support */
868 /* the MaxPacketSize is to small to support */
869 /* framesizes larger than 640x480 @ 30 fps */
870 /* or 640x576 @ 25 fps. As this would cut */
871 /* of a part of the image we prefer */
872 /* 360x576 or 360x480 for now */
873 if(width
== maxw
&& height
== maxh
)
877 if ((hscale
= (((unsigned long)maxw
) << 12) / width
- 4096L) >= 0x4000)
880 width
= (((unsigned long)maxw
) << 12) / (hscale
+ 4096L);
882 if ((vscale
= (((unsigned long)maxh
) << 12) / height
- 4096L) >= 0x4000)
885 height
= (((unsigned long)maxh
) << 12) / (vscale
+ 4096L);
887 format
->fmt
.pix
.width
= width
;
888 format
->fmt
.pix
.height
= height
;
889 format
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_YUYV
;
890 format
->fmt
.pix
.bytesperline
= width
* 2;
891 format
->fmt
.pix
.sizeimage
= width
* 2 * height
;
892 format
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
893 format
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
895 em28xx_videodbg("%s: returned %dx%d (%d, %d)\n",
896 cmd
== VIDIOC_TRY_FMT
?
897 "VIDIOC_TRY_FMT" :"VIDIOC_S_FMT",
898 format
->fmt
.pix
.width
, format
->fmt
.pix
.height
, hscale
, vscale
);
900 if (cmd
== VIDIOC_TRY_FMT
)
903 for (i
= 0; i
< dev
->num_frames
; i
++)
904 if (dev
->frame
[i
].vma_use_count
) {
905 em28xx_videodbg("VIDIOC_S_FMT failed. "
906 "Unmap the buffers first.\n");
910 /* stop io in case it is already in progress */
911 if (dev
->stream
== STREAM_ON
) {
912 em28xx_videodbg("VIDIOC_SET_FMT: interupting stream\n");
913 if ((ret
= em28xx_stream_interrupt(dev
)))
917 em28xx_release_buffers(dev
);
920 /* set new image size */
922 dev
->height
= height
;
923 dev
->frame_size
= dev
->width
* dev
->height
* 2;
924 dev
->field_size
= dev
->frame_size
>> 1;
925 dev
->bytesperline
= dev
->width
* 2;
926 dev
->hscale
= hscale
;
927 dev
->vscale
= vscale
;
928 em28xx_uninit_isoc(dev
);
929 em28xx_set_alternate(dev
);
930 em28xx_capture_start(dev
, 1);
931 em28xx_resolution_set(dev
);
932 em28xx_init_isoc(dev
);
938 * em28xx_v4l2_do_ioctl()
939 * This function is _not_ called directly, but from
940 * em28xx_v4l2_ioctl. Userspace
941 * copying is done already, arg is a kernel pointer.
943 static int em28xx_do_ioctl(struct inode
*inode
, struct file
*filp
,
944 struct em28xx
*dev
, unsigned int cmd
, void *arg
,
945 v4l2_kioctl driver_ioctl
)
950 /* ---------- tv norms ---------- */
953 struct v4l2_standard
*e
= arg
;
959 ret
= v4l2_video_std_construct(e
, tvnorms
[e
->index
].id
,
960 tvnorms
[e
->index
].name
);
968 v4l2_std_id
*id
= arg
;
970 *id
= dev
->tvnorm
->id
;
975 v4l2_std_id
*id
= arg
;
978 for (i
= 0; i
< TVNORMS
; i
++)
979 if (*id
== tvnorms
[i
].id
)
982 for (i
= 0; i
< TVNORMS
; i
++)
983 if (*id
& tvnorms
[i
].id
)
988 mutex_lock(&dev
->lock
);
989 dev
->tvnorm
= &tvnorms
[i
];
991 em28xx_set_norm(dev
, dev
->width
, dev
->height
);
993 em28xx_i2c_call_clients(dev
, VIDIOC_S_STD
,
996 mutex_unlock(&dev
->lock
);
1001 /* ------ input switching ---------- */
1002 case VIDIOC_ENUMINPUT
:
1004 struct v4l2_input
*i
= arg
;
1006 static const char *iname
[] = {
1007 [EM28XX_VMUX_COMPOSITE1
] = "Composite1",
1008 [EM28XX_VMUX_COMPOSITE2
] = "Composite2",
1009 [EM28XX_VMUX_COMPOSITE3
] = "Composite3",
1010 [EM28XX_VMUX_COMPOSITE4
] = "Composite4",
1011 [EM28XX_VMUX_SVIDEO
] = "S-Video",
1012 [EM28XX_VMUX_TELEVISION
] = "Television",
1013 [EM28XX_VMUX_CABLE
] = "Cable TV",
1014 [EM28XX_VMUX_DVB
] = "DVB",
1015 [EM28XX_VMUX_DEBUG
] = "for debug only",
1019 if (n
>= MAX_EM28XX_INPUT
)
1021 if (0 == INPUT(n
)->type
)
1023 memset(i
, 0, sizeof(*i
));
1025 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1026 strcpy(i
->name
, iname
[INPUT(n
)->type
]);
1027 if ((EM28XX_VMUX_TELEVISION
== INPUT(n
)->type
) ||
1028 (EM28XX_VMUX_CABLE
== INPUT(n
)->type
))
1029 i
->type
= V4L2_INPUT_TYPE_TUNER
;
1030 for (n
= 0; n
< ARRAY_SIZE(tvnorms
); n
++)
1031 i
->std
|= tvnorms
[n
].id
;
1034 case VIDIOC_G_INPUT
:
1037 *i
= dev
->ctl_input
;
1041 case VIDIOC_S_INPUT
:
1045 if (*index
>= MAX_EM28XX_INPUT
)
1047 if (0 == INPUT(*index
)->type
)
1050 mutex_lock(&dev
->lock
);
1051 video_mux(dev
, *index
);
1052 mutex_unlock(&dev
->lock
);
1056 case VIDIOC_G_AUDIO
:
1058 struct v4l2_audio
*a
= arg
;
1059 unsigned int index
= a
->index
;
1063 memset(a
, 0, sizeof(*a
));
1064 index
= dev
->ctl_ainput
;
1067 strcpy(a
->name
, "Television");
1069 strcpy(a
->name
, "Line In");
1071 a
->capability
= V4L2_AUDCAP_STEREO
;
1075 case VIDIOC_S_AUDIO
:
1077 struct v4l2_audio
*a
= arg
;
1079 if (a
->index
!= dev
->ctl_ainput
)
1085 /* --- controls ---------------------------------------------- */
1086 case VIDIOC_QUERYCTRL
:
1088 struct v4l2_queryctrl
*qc
= arg
;
1091 memset(qc
,0,sizeof(*qc
));
1094 if (!dev
->has_msp34xx
) {
1095 for (i
= 0; i
< ARRAY_SIZE(em28xx_qctrl
); i
++) {
1096 if (qc
->id
&& qc
->id
== em28xx_qctrl
[i
].id
) {
1097 memcpy(qc
, &(em28xx_qctrl
[i
]),
1103 em28xx_i2c_call_clients(dev
,cmd
,qc
);
1111 struct v4l2_control
*ctrl
= arg
;
1114 if (!dev
->has_msp34xx
)
1115 retval
=em28xx_get_ctrl(dev
, ctrl
);
1116 if (retval
==-EINVAL
) {
1117 em28xx_i2c_call_clients(dev
,cmd
,arg
);
1119 } else return retval
;
1123 struct v4l2_control
*ctrl
= arg
;
1126 if (!dev
->has_msp34xx
){
1127 for (i
= 0; i
< ARRAY_SIZE(em28xx_qctrl
); i
++) {
1128 if (ctrl
->id
== em28xx_qctrl
[i
].id
) {
1130 em28xx_qctrl
[i
].minimum
1132 em28xx_qctrl
[i
].maximum
)
1134 return em28xx_set_ctrl(dev
, ctrl
);
1139 em28xx_i2c_call_clients(dev
,cmd
,arg
);
1142 /* --- tuner ioctls ------------------------------------------ */
1143 case VIDIOC_G_TUNER
:
1145 struct v4l2_tuner
*t
= arg
;
1150 memset(t
, 0, sizeof(*t
));
1151 strcpy(t
->name
, "Tuner");
1152 mutex_lock(&dev
->lock
);
1153 /* let clients fill in the remainder of this struct */
1154 em28xx_i2c_call_clients(dev
, cmd
, t
);
1155 mutex_unlock(&dev
->lock
);
1156 em28xx_videodbg("VIDIO_G_TUNER: signal=%x, afc=%x\n", t
->signal
,
1160 case VIDIOC_S_TUNER
:
1162 struct v4l2_tuner
*t
= arg
;
1166 mutex_lock(&dev
->lock
);
1167 /* let clients handle this */
1168 em28xx_i2c_call_clients(dev
, cmd
, t
);
1169 mutex_unlock(&dev
->lock
);
1172 case VIDIOC_G_FREQUENCY
:
1174 struct v4l2_frequency
*f
= arg
;
1176 memset(f
, 0, sizeof(*f
));
1177 f
->type
= V4L2_TUNER_ANALOG_TV
;
1178 f
->frequency
= dev
->ctl_freq
;
1182 case VIDIOC_S_FREQUENCY
:
1184 struct v4l2_frequency
*f
= arg
;
1189 if (V4L2_TUNER_ANALOG_TV
!= f
->type
)
1192 mutex_lock(&dev
->lock
);
1193 dev
->ctl_freq
= f
->frequency
;
1194 em28xx_i2c_call_clients(dev
, VIDIOC_S_FREQUENCY
, f
);
1195 mutex_unlock(&dev
->lock
);
1198 case VIDIOC_CROPCAP
:
1200 struct v4l2_cropcap
*cc
= arg
;
1202 if (cc
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1204 cc
->bounds
.left
= 0;
1206 cc
->bounds
.width
= dev
->width
;
1207 cc
->bounds
.height
= dev
->height
;
1208 cc
->defrect
= cc
->bounds
;
1209 cc
->pixelaspect
.numerator
= 54; /* 4:3 FIXME: remove magic numbers */
1210 cc
->pixelaspect
.denominator
= 59;
1213 case VIDIOC_STREAMON
:
1217 if (*type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
1218 || dev
->io
!= IO_MMAP
)
1221 if (list_empty(&dev
->inqueue
))
1224 dev
->stream
= STREAM_ON
; /* FIXME: Start video capture here? */
1226 em28xx_videodbg("VIDIOC_STREAMON: starting stream\n");
1230 case VIDIOC_STREAMOFF
:
1235 if (*type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
1236 || dev
->io
!= IO_MMAP
)
1239 if (dev
->stream
== STREAM_ON
) {
1240 em28xx_videodbg ("VIDIOC_STREAMOFF: interrupting stream\n");
1241 if ((ret
= em28xx_stream_interrupt(dev
)))
1244 em28xx_empty_framequeues(dev
);
1249 return v4l_compat_translate_ioctl(inode
, filp
, cmd
, arg
,
1256 * em28xx_v4l2_do_ioctl()
1257 * This function is _not_ called directly, but from
1258 * em28xx_v4l2_ioctl. Userspace
1259 * copying is done already, arg is a kernel pointer.
1261 static int em28xx_video_do_ioctl(struct inode
*inode
, struct file
*filp
,
1262 unsigned int cmd
, void *arg
)
1264 struct em28xx
*dev
= filp
->private_data
;
1269 if (video_debug
> 1)
1270 v4l_print_ioctl(dev
->name
,cmd
);
1274 /* --- capabilities ------------------------------------------ */
1275 case VIDIOC_QUERYCAP
:
1277 struct v4l2_capability
*cap
= arg
;
1279 memset(cap
, 0, sizeof(*cap
));
1280 strlcpy(cap
->driver
, "em28xx", sizeof(cap
->driver
));
1281 strlcpy(cap
->card
, em28xx_boards
[dev
->model
].name
,
1283 strlcpy(cap
->bus_info
, dev
->udev
->dev
.bus_id
,
1284 sizeof(cap
->bus_info
));
1285 cap
->version
= EM28XX_VERSION_CODE
;
1287 V4L2_CAP_SLICED_VBI_CAPTURE
|
1288 V4L2_CAP_VIDEO_CAPTURE
|
1290 V4L2_CAP_READWRITE
| V4L2_CAP_STREAMING
;
1292 cap
->capabilities
|= V4L2_CAP_TUNER
;
1295 /* --- capture ioctls ---------------------------------------- */
1296 case VIDIOC_ENUM_FMT
:
1298 struct v4l2_fmtdesc
*fmtd
= arg
;
1300 if (fmtd
->index
!= 0)
1302 memset(fmtd
, 0, sizeof(*fmtd
));
1303 fmtd
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1304 strcpy(fmtd
->description
, "Packed YUY2");
1305 fmtd
->pixelformat
= V4L2_PIX_FMT_YUYV
;
1306 memset(fmtd
->reserved
, 0, sizeof(fmtd
->reserved
));
1310 return em28xx_get_fmt(dev
, (struct v4l2_format
*) arg
);
1312 case VIDIOC_TRY_FMT
:
1314 return em28xx_set_fmt(dev
, cmd
, (struct v4l2_format
*)arg
);
1316 case VIDIOC_REQBUFS
:
1318 struct v4l2_requestbuffers
*rb
= arg
;
1322 if (rb
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1323 rb
->memory
!= V4L2_MEMORY_MMAP
)
1326 if (dev
->io
== IO_READ
) {
1327 em28xx_videodbg ("method is set to read;"
1328 " close and open the device again to"
1329 " choose the mmap I/O method\n");
1333 for (i
= 0; i
< dev
->num_frames
; i
++)
1334 if (dev
->frame
[i
].vma_use_count
) {
1335 em28xx_videodbg ("VIDIOC_REQBUFS failed; previous buffers are still mapped\n");
1339 if (dev
->stream
== STREAM_ON
) {
1340 em28xx_videodbg("VIDIOC_REQBUFS: interrupting stream\n");
1341 if ((ret
= em28xx_stream_interrupt(dev
)))
1345 em28xx_empty_framequeues(dev
);
1347 em28xx_release_buffers(dev
);
1350 em28xx_request_buffers(dev
, rb
->count
);
1352 dev
->frame_current
= NULL
;
1354 em28xx_videodbg ("VIDIOC_REQBUFS: setting io method to mmap: num bufs %i\n",
1356 dev
->io
= rb
->count
? IO_MMAP
: IO_NONE
;
1359 case VIDIOC_QUERYBUF
:
1361 struct v4l2_buffer
*b
= arg
;
1363 if (b
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1364 b
->index
>= dev
->num_frames
|| dev
->io
!= IO_MMAP
)
1367 memcpy(b
, &dev
->frame
[b
->index
].buf
, sizeof(*b
));
1369 if (dev
->frame
[b
->index
].vma_use_count
) {
1370 b
->flags
|= V4L2_BUF_FLAG_MAPPED
;
1372 if (dev
->frame
[b
->index
].state
== F_DONE
)
1373 b
->flags
|= V4L2_BUF_FLAG_DONE
;
1374 else if (dev
->frame
[b
->index
].state
!= F_UNUSED
)
1375 b
->flags
|= V4L2_BUF_FLAG_QUEUED
;
1380 struct v4l2_buffer
*b
= arg
;
1381 unsigned long lock_flags
;
1383 if (b
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1384 b
->index
>= dev
->num_frames
|| dev
->io
!= IO_MMAP
) {
1388 if (dev
->frame
[b
->index
].state
!= F_UNUSED
) {
1391 dev
->frame
[b
->index
].state
= F_QUEUED
;
1393 /* add frame to fifo */
1394 spin_lock_irqsave(&dev
->queue_lock
, lock_flags
);
1395 list_add_tail(&dev
->frame
[b
->index
].frame
,
1397 spin_unlock_irqrestore(&dev
->queue_lock
, lock_flags
);
1403 struct v4l2_buffer
*b
= arg
;
1404 struct em28xx_frame_t
*f
;
1405 unsigned long lock_flags
;
1408 if (b
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
1409 || dev
->io
!= IO_MMAP
)
1412 if (list_empty(&dev
->outqueue
)) {
1413 if (dev
->stream
== STREAM_OFF
)
1415 if (filp
->f_flags
& O_NONBLOCK
)
1417 ret
= wait_event_interruptible
1419 (!list_empty(&dev
->outqueue
)) ||
1420 (dev
->state
& DEV_DISCONNECTED
));
1423 if (dev
->state
& DEV_DISCONNECTED
)
1427 spin_lock_irqsave(&dev
->queue_lock
, lock_flags
);
1428 f
= list_entry(dev
->outqueue
.next
,
1429 struct em28xx_frame_t
, frame
);
1430 list_del(dev
->outqueue
.next
);
1431 spin_unlock_irqrestore(&dev
->queue_lock
, lock_flags
);
1433 f
->state
= F_UNUSED
;
1434 memcpy(b
, &f
->buf
, sizeof(*b
));
1436 if (f
->vma_use_count
)
1437 b
->flags
|= V4L2_BUF_FLAG_MAPPED
;
1442 return em28xx_do_ioctl(inode
, filp
, dev
, cmd
, arg
,
1443 em28xx_video_do_ioctl
);
1449 * em28xx_v4l2_ioctl()
1450 * handle v4l2 ioctl the main action happens in em28xx_v4l2_do_ioctl()
1452 static int em28xx_v4l2_ioctl(struct inode
*inode
, struct file
*filp
,
1453 unsigned int cmd
, unsigned long arg
)
1456 struct em28xx
*dev
= filp
->private_data
;
1458 if (mutex_lock_interruptible(&dev
->fileop_lock
))
1459 return -ERESTARTSYS
;
1461 if (dev
->state
& DEV_DISCONNECTED
) {
1462 em28xx_errdev("v4l2 ioctl: device not present\n");
1463 mutex_unlock(&dev
->fileop_lock
);
1467 if (dev
->state
& DEV_MISCONFIGURED
) {
1469 ("v4l2 ioctl: device is misconfigured; close and open it again\n");
1470 mutex_unlock(&dev
->fileop_lock
);
1474 ret
= video_usercopy(inode
, filp
, cmd
, arg
, em28xx_video_do_ioctl
);
1476 mutex_unlock(&dev
->fileop_lock
);
1481 static const struct file_operations em28xx_v4l_fops
= {
1482 .owner
= THIS_MODULE
,
1483 .open
= em28xx_v4l2_open
,
1484 .release
= em28xx_v4l2_close
,
1485 .ioctl
= em28xx_v4l2_ioctl
,
1486 .read
= em28xx_v4l2_read
,
1487 .poll
= em28xx_v4l2_poll
,
1488 .mmap
= em28xx_v4l2_mmap
,
1489 .llseek
= no_llseek
,
1490 .compat_ioctl
= v4l_compat_ioctl32
,
1494 /******************************** usb interface *****************************************/
1498 * allocates and inits the device structs, registers i2c bus and v4l device
1500 static int em28xx_init_dev(struct em28xx
**devhandle
, struct usb_device
*udev
,
1501 int minor
, int model
)
1503 struct em28xx
*dev
= *devhandle
;
1504 int retval
= -ENOMEM
;
1506 unsigned int maxh
, maxw
;
1510 mutex_init(&dev
->lock
);
1511 init_waitqueue_head(&dev
->open
);
1513 dev
->em28xx_write_regs
= em28xx_write_regs
;
1514 dev
->em28xx_read_reg
= em28xx_read_reg
;
1515 dev
->em28xx_read_reg_req_len
= em28xx_read_reg_req_len
;
1516 dev
->em28xx_write_regs_req
= em28xx_write_regs_req
;
1517 dev
->em28xx_read_reg_req
= em28xx_read_reg_req
;
1518 dev
->is_em2800
= em28xx_boards
[model
].is_em2800
;
1519 dev
->has_tuner
= em28xx_boards
[model
].has_tuner
;
1520 dev
->has_msp34xx
= em28xx_boards
[model
].has_msp34xx
;
1521 dev
->tda9887_conf
= em28xx_boards
[model
].tda9887_conf
;
1522 dev
->decoder
= em28xx_boards
[model
].decoder
;
1525 dev
->tuner_type
= tuner
;
1527 dev
->tuner_type
= em28xx_boards
[model
].tuner_type
;
1529 dev
->video_inputs
= em28xx_boards
[model
].vchannels
;
1531 for (i
= 0; i
< TVNORMS
; i
++)
1532 if (em28xx_boards
[model
].norm
== tvnorms
[i
].mode
)
1537 dev
->tvnorm
= &tvnorms
[i
]; /* set default norm */
1539 em28xx_videodbg("tvnorm=%s\n", dev
->tvnorm
->name
);
1541 maxw
= norm_maxw(dev
);
1542 maxh
= norm_maxh(dev
);
1544 /* set default image size */
1547 dev
->interlaced
= EM28XX_INTERLACED_DEFAULT
;
1548 dev
->field_size
= dev
->width
* dev
->height
;
1550 dev
->interlaced
? dev
->field_size
<< 1 : dev
->field_size
;
1551 dev
->bytesperline
= dev
->width
* 2;
1556 /* setup video picture settings for saa7113h */
1557 memset(&dev
->vpic
, 0, sizeof(dev
->vpic
));
1558 dev
->vpic
.colour
= 128 << 8;
1559 dev
->vpic
.hue
= 128 << 8;
1560 dev
->vpic
.brightness
= 128 << 8;
1561 dev
->vpic
.contrast
= 192 << 8;
1562 dev
->vpic
.whiteness
= 128 << 8; /* This one isn't used */
1563 dev
->vpic
.depth
= 16;
1564 dev
->vpic
.palette
= VIDEO_PALETTE_YUV422
;
1566 em28xx_pre_card_setup(dev
);
1567 #ifdef CONFIG_MODULES
1568 /* request some modules */
1569 if (dev
->decoder
== EM28XX_SAA7113
|| dev
->decoder
== EM28XX_SAA7114
)
1570 request_module("saa7115");
1571 if (dev
->decoder
== EM28XX_TVP5150
)
1572 request_module("tvp5150");
1574 request_module("tuner");
1576 errCode
= em28xx_config(dev
);
1578 em28xx_errdev("error configuring device\n");
1579 em28xx_devused
&=~(1<<dev
->devno
);
1584 mutex_lock(&dev
->lock
);
1585 /* register i2c bus */
1586 em28xx_i2c_register(dev
);
1588 /* Do board specific init and eeprom reading */
1589 em28xx_card_setup(dev
);
1591 /* configure the device */
1592 em28xx_config_i2c(dev
);
1594 mutex_unlock(&dev
->lock
);
1596 errCode
= em28xx_config(dev
);
1598 #ifdef CONFIG_MODULES
1599 if (dev
->has_msp34xx
)
1600 request_module("msp3400");
1602 /* allocate and fill v4l2 device struct */
1603 dev
->vdev
= video_device_alloc();
1604 if (NULL
== dev
->vdev
) {
1605 em28xx_errdev("cannot allocate video_device.\n");
1606 em28xx_devused
&=~(1<<dev
->devno
);
1611 dev
->vbi_dev
= video_device_alloc();
1612 if (NULL
== dev
->vbi_dev
) {
1613 em28xx_errdev("cannot allocate video_device.\n");
1615 em28xx_devused
&=~(1<<dev
->devno
);
1620 /* Fills VBI device info */
1621 dev
->vbi_dev
->type
= VFL_TYPE_VBI
;
1622 dev
->vbi_dev
->hardware
= 0;
1623 dev
->vbi_dev
->fops
= &em28xx_v4l_fops
;
1624 dev
->vbi_dev
->minor
= -1;
1625 dev
->vbi_dev
->dev
= &dev
->udev
->dev
;
1626 dev
->vbi_dev
->release
= video_device_release
;
1627 snprintf(dev
->vbi_dev
->name
, sizeof(dev
->vbi_dev
->name
), "%s#%d %s",
1628 "em28xx",dev
->devno
,"vbi");
1630 /* Fills CAPTURE device info */
1631 dev
->vdev
->type
= VID_TYPE_CAPTURE
;
1633 dev
->vdev
->type
|= VID_TYPE_TUNER
;
1634 dev
->vdev
->hardware
= 0;
1635 dev
->vdev
->fops
= &em28xx_v4l_fops
;
1636 dev
->vdev
->minor
= -1;
1637 dev
->vdev
->dev
= &dev
->udev
->dev
;
1638 dev
->vdev
->release
= video_device_release
;
1639 snprintf(dev
->vdev
->name
, sizeof(dev
->vbi_dev
->name
), "%s#%d %s",
1640 "em28xx",dev
->devno
,"video");
1642 list_add_tail(&dev
->devlist
,&em28xx_devlist
);
1644 /* register v4l2 device */
1645 mutex_lock(&dev
->lock
);
1646 if ((retval
= video_register_device(dev
->vdev
, VFL_TYPE_GRABBER
,
1647 video_nr
[dev
->devno
]))) {
1648 em28xx_errdev("unable to register video device (error=%i).\n",
1650 mutex_unlock(&dev
->lock
);
1651 list_del(&dev
->devlist
);
1652 video_device_release(dev
->vdev
);
1653 em28xx_devused
&=~(1<<dev
->devno
);
1658 if (video_register_device(dev
->vbi_dev
, VFL_TYPE_VBI
,
1659 vbi_nr
[dev
->devno
]) < 0) {
1660 printk("unable to register vbi device\n");
1661 mutex_unlock(&dev
->lock
);
1662 list_del(&dev
->devlist
);
1663 video_device_release(dev
->vbi_dev
);
1664 video_device_release(dev
->vdev
);
1665 em28xx_devused
&=~(1<<dev
->devno
);
1669 printk("registered VBI\n");
1672 if (dev
->has_msp34xx
) {
1673 /* Send a reset to other chips via gpio */
1674 em28xx_write_regs_req(dev
, 0x00, 0x08, "\xf7", 1);
1676 em28xx_write_regs_req(dev
, 0x00, 0x08, "\xff", 1);
1682 mutex_unlock(&dev
->lock
);
1684 em28xx_info("V4L2 device registered as /dev/video%d and /dev/vbi%d\n",
1685 dev
->vdev
->minor
-MINOR_VFL_TYPE_GRABBER_MIN
,
1686 dev
->vbi_dev
->minor
-MINOR_VFL_TYPE_VBI_MIN
);
1692 * em28xx_usb_probe()
1693 * checks for supported devices
1695 static int em28xx_usb_probe(struct usb_interface
*interface
,
1696 const struct usb_device_id
*id
)
1698 const struct usb_endpoint_descriptor
*endpoint
;
1699 struct usb_device
*udev
;
1700 struct usb_interface
*uif
;
1701 struct em28xx
*dev
= NULL
;
1702 int retval
= -ENODEV
;
1703 int model
,i
,nr
,ifnum
;
1705 udev
= usb_get_dev(interface_to_usbdev(interface
));
1706 ifnum
= interface
->altsetting
[0].desc
.bInterfaceNumber
;
1708 /* Check to see next free device and mark as used */
1709 nr
=find_first_zero_bit(&em28xx_devused
,EM28XX_MAXBOARDS
);
1710 em28xx_devused
|=1<<nr
;
1712 /* Don't register audio interfaces */
1713 if (interface
->altsetting
[0].desc
.bInterfaceClass
== USB_CLASS_AUDIO
) {
1714 em28xx_err(DRIVER_NAME
" audio device (%04x:%04x): interface %i, class %i\n",
1715 udev
->descriptor
.idVendor
,udev
->descriptor
.idProduct
,
1717 interface
->altsetting
[0].desc
.bInterfaceClass
);
1719 em28xx_devused
&=~(1<<nr
);
1723 em28xx_err(DRIVER_NAME
" new video device (%04x:%04x): interface %i, class %i\n",
1724 udev
->descriptor
.idVendor
,udev
->descriptor
.idProduct
,
1726 interface
->altsetting
[0].desc
.bInterfaceClass
);
1728 endpoint
= &interface
->cur_altsetting
->endpoint
[1].desc
;
1730 /* check if the device has the iso in endpoint at the correct place */
1731 if ((endpoint
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) !=
1732 USB_ENDPOINT_XFER_ISOC
) {
1733 em28xx_err(DRIVER_NAME
" probing error: endpoint is non-ISO endpoint!\n");
1734 em28xx_devused
&=~(1<<nr
);
1737 if ((endpoint
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) == USB_DIR_OUT
) {
1738 em28xx_err(DRIVER_NAME
" probing error: endpoint is ISO OUT endpoint!\n");
1739 em28xx_devused
&=~(1<<nr
);
1743 model
=id
->driver_info
;
1745 if (nr
>= EM28XX_MAXBOARDS
) {
1746 printk (DRIVER_NAME
": Supports only %i em28xx boards.\n",EM28XX_MAXBOARDS
);
1747 em28xx_devused
&=~(1<<nr
);
1751 /* allocate memory for our device state and initialize it */
1752 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1754 em28xx_err(DRIVER_NAME
": out of memory!\n");
1755 em28xx_devused
&=~(1<<nr
);
1759 snprintf(dev
->name
, 29, "em28xx #%d", nr
);
1762 /* compute alternate max packet sizes */
1763 uif
= udev
->actconfig
->interface
[0];
1765 dev
->num_alt
=uif
->num_altsetting
;
1766 em28xx_info("Alternate settings: %i\n",dev
->num_alt
);
1767 // dev->alt_max_pkt_size = kmalloc(sizeof(*dev->alt_max_pkt_size)*
1768 dev
->alt_max_pkt_size
= kmalloc(32*
1769 dev
->num_alt
,GFP_KERNEL
);
1770 if (dev
->alt_max_pkt_size
== NULL
) {
1771 em28xx_errdev("out of memory!\n");
1772 em28xx_devused
&=~(1<<nr
);
1777 for (i
= 0; i
< dev
->num_alt
; i
++) {
1778 u16 tmp
= le16_to_cpu(uif
->altsetting
[i
].endpoint
[1].desc
.
1780 dev
->alt_max_pkt_size
[i
] =
1781 (tmp
& 0x07ff) * (((tmp
& 0x1800) >> 11) + 1);
1782 em28xx_info("Alternate setting %i, max size= %i\n",i
,
1783 dev
->alt_max_pkt_size
[i
]);
1786 if ((card
[nr
]>=0)&&(card
[nr
]<em28xx_bcount
))
1789 if ((model
==EM2800_BOARD_UNKNOWN
)||(model
==EM2820_BOARD_UNKNOWN
)) {
1790 em28xx_errdev( "Your board has no eeprom inside it and thus can't\n"
1791 "%s: be autodetected. Please pass card=<n> insmod option to\n"
1792 "%s: workaround that. Redirect complaints to the vendor of\n"
1793 "%s: the TV card. Generic type will be used."
1794 "%s: Best regards,\n"
1796 dev
->name
,dev
->name
,dev
->name
,dev
->name
,dev
->name
);
1797 em28xx_errdev("%s: Here is a list of valid choices for the card=<n> insmod option:\n",
1799 for (i
= 0; i
< em28xx_bcount
; i
++) {
1800 em28xx_errdev(" card=%d -> %s\n", i
,
1801 em28xx_boards
[i
].name
);
1805 /* allocate device struct */
1806 retval
= em28xx_init_dev(&dev
, udev
, nr
, model
);
1810 em28xx_info("Found %s\n", em28xx_boards
[model
].name
);
1812 /* save our data pointer in this interface device */
1813 usb_set_intfdata(interface
, dev
);
1818 * em28xx_usb_disconnect()
1819 * called when the device gets diconencted
1820 * video device will be unregistered on v4l2_close in case it is still open
1822 static void em28xx_usb_disconnect(struct usb_interface
*interface
)
1824 struct em28xx
*dev
= usb_get_intfdata(interface
);
1825 usb_set_intfdata(interface
, NULL
);
1830 down_write(&em28xx_disconnect
);
1832 mutex_lock(&dev
->lock
);
1834 em28xx_info("disconnecting %s\n", dev
->vdev
->name
);
1836 wake_up_interruptible_all(&dev
->open
);
1840 ("device /dev/video%d is open! Deregistration and memory "
1841 "deallocation are deferred on close.\n",
1842 dev
->vdev
->minor
-MINOR_VFL_TYPE_GRABBER_MIN
);
1844 dev
->state
|= DEV_MISCONFIGURED
;
1845 em28xx_uninit_isoc(dev
);
1846 dev
->state
|= DEV_DISCONNECTED
;
1847 wake_up_interruptible(&dev
->wait_frame
);
1848 wake_up_interruptible(&dev
->wait_stream
);
1850 dev
->state
|= DEV_DISCONNECTED
;
1851 em28xx_release_resources(dev
);
1854 mutex_unlock(&dev
->lock
);
1857 kfree(dev
->alt_max_pkt_size
);
1861 up_write(&em28xx_disconnect
);
1864 static struct usb_driver em28xx_usb_driver
= {
1866 .probe
= em28xx_usb_probe
,
1867 .disconnect
= em28xx_usb_disconnect
,
1868 .id_table
= em28xx_id_table
,
1871 static int __init
em28xx_module_init(void)
1875 printk(KERN_INFO DRIVER_NAME
" v4l2 driver version %d.%d.%d loaded\n",
1876 (EM28XX_VERSION_CODE
>> 16) & 0xff,
1877 (EM28XX_VERSION_CODE
>> 8) & 0xff, EM28XX_VERSION_CODE
& 0xff);
1879 printk(KERN_INFO DRIVER_NAME
" snapshot date %04d-%02d-%02d\n",
1880 SNAPSHOT
/ 10000, (SNAPSHOT
/ 100) % 100, SNAPSHOT
% 100);
1883 /* register this driver with the USB subsystem */
1884 result
= usb_register(&em28xx_usb_driver
);
1886 em28xx_err(DRIVER_NAME
1887 " usb_register failed. Error number %d.\n", result
);
1892 static void __exit
em28xx_module_exit(void)
1894 /* deregister this driver with the USB subsystem */
1895 usb_deregister(&em28xx_usb_driver
);
1898 module_init(em28xx_module_init
);
1899 module_exit(em28xx_module_exit
);