2 tm6000-video.c - driver for TM5600/TM6000/TM6010 USB video capture devices
4 Copyright (C) 2006-2007 Mauro Carvalho Chehab <mchehab@infradead.org>
6 Copyright (C) 2007 Michel Ludwig <michel.ludwig@gmail.com>
7 - Fixed module load/unload
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation version 2
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <linux/module.h>
23 #include <linux/delay.h>
24 #include <linux/errno.h>
26 #include <linux/kernel.h>
27 #include <linux/slab.h>
29 #include <linux/ioport.h>
30 #include <linux/init.h>
31 #include <linux/sched.h>
32 #include <linux/random.h>
33 #include <linux/version.h>
34 #include <linux/usb.h>
35 #include <linux/videodev2.h>
36 #include <media/v4l2-ioctl.h>
37 #include <linux/interrupt.h>
38 #include <linux/kthread.h>
39 #include <linux/highmem.h>
40 #include <linux/freezer.h>
42 #include "tm6000-regs.h"
45 #define BUFFER_TIMEOUT msecs_to_jiffies(2000) /* 2 seconds */
47 /* Limits minimum and default number of buffers */
48 #define TM6000_MIN_BUF 4
49 #define TM6000_DEF_BUF 8
51 #define TM6000_MAX_ISO_PACKETS 40 /* Max number of ISO packets */
53 /* Declare static vars that will be used as parameters */
54 static unsigned int vid_limit
= 16; /* Video memory limit, in Mb */
55 static int video_nr
= -1; /* /dev/videoN, -1 for autodetect */
60 /* supported controls */
61 static struct v4l2_queryctrl tm6000_qctrl
[] = {
63 .id
= V4L2_CID_BRIGHTNESS
,
64 .type
= V4L2_CTRL_TYPE_INTEGER
,
72 .id
= V4L2_CID_CONTRAST
,
73 .type
= V4L2_CTRL_TYPE_INTEGER
,
81 .id
= V4L2_CID_SATURATION
,
82 .type
= V4L2_CTRL_TYPE_INTEGER
,
91 .type
= V4L2_CTRL_TYPE_INTEGER
,
101 static int qctl_regs
[ARRAY_SIZE(tm6000_qctrl
)];
103 static struct tm6000_fmt format
[] = {
105 .name
= "4:2:2, packed, YVY2",
106 .fourcc
= V4L2_PIX_FMT_YUYV
,
109 .name
= "4:2:2, packed, UYVY",
110 .fourcc
= V4L2_PIX_FMT_UYVY
,
113 .name
= "A/V + VBI mux packet",
114 .fourcc
= V4L2_PIX_FMT_TM6000
,
119 /* ------------------------------------------------------------------
120 DMA and thread functions
121 ------------------------------------------------------------------*/
123 #define norm_maxw(a) 720
124 #define norm_maxh(a) 576
126 #define norm_minw(a) norm_maxw(a)
127 #define norm_minh(a) norm_maxh(a)
130 * video-buf generic routine to get the next available buffer
132 static inline void get_next_buf(struct tm6000_dmaqueue
*dma_q
,
133 struct tm6000_buffer
**buf
)
135 struct tm6000_core
*dev
= container_of(dma_q
, struct tm6000_core
, vidq
);
138 if (list_empty(&dma_q
->active
)) {
139 dprintk(dev
, V4L2_DEBUG_QUEUE
, "No active queue to serve\n");
144 *buf
= list_entry(dma_q
->active
.next
,
145 struct tm6000_buffer
, vb
.queue
);
150 /* Cleans up buffer - Usefull for testing for frame/URB loss */
151 outp
= videobuf_to_vmalloc(&(*buf
)->vb
);
153 // memset(outp, 0, (*buf)->vb.size);
159 * Announces that a buffer were filled and request the next
161 static inline void buffer_filled(struct tm6000_core
*dev
,
162 struct tm6000_dmaqueue
*dma_q
,
163 struct tm6000_buffer
*buf
)
165 /* Advice that buffer was filled */
166 dprintk(dev
, V4L2_DEBUG_ISOC
, "[%p/%d] wakeup\n", buf
, buf
->vb
.i
);
167 buf
->vb
.state
= VIDEOBUF_DONE
;
168 buf
->vb
.field_count
++;
169 do_gettimeofday(&buf
->vb
.ts
);
171 list_del(&buf
->vb
.queue
);
172 wake_up(&buf
->vb
.done
);
175 const char *tm6000_msg_type
[] = {
176 "unknown(0)", /* 0 */
182 "unknown(6)", /* 6 */
183 "unknown(7)", /* 7 */
187 * Identify the tm5600/6000 buffer header type and properly handles
189 static int copy_packet(struct urb
*urb
, u32 header
, u8
**ptr
, u8
*endp
,
190 u8
*out_p
, struct tm6000_buffer
**buf
)
192 struct tm6000_dmaqueue
*dma_q
= urb
->context
;
193 struct tm6000_core
*dev
= container_of(dma_q
, struct tm6000_core
, vidq
);
195 unsigned int cmd
, cpysize
, pktsize
, size
, field
, block
, line
, pos
= 0;
197 /* FIXME: move to tm6000-isoc */
198 static int last_line
= -2, start_line
= -2, last_field
= -2;
200 /* FIXME: this is the hardcoded window size
202 unsigned int linewidth
= (*buf
)->vb
.width
<< 1;
204 if (!dev
->isoc_ctl
.cmd
) {
205 c
= (header
>> 24) & 0xff;
207 /* split the header fields */
208 size
= ((header
& 0x7e) << 1);
213 block
= (header
>> 7) & 0xf;
214 field
= (header
>> 11) & 0x1;
215 line
= (header
>> 12) & 0x1ff;
216 cmd
= (header
>> 21) & 0x7;
218 /* Validates header fields */
219 if(size
> TM6000_URB_MSG_LEN
)
220 size
= TM6000_URB_MSG_LEN
;
222 if (cmd
== TM6000_URB_MSG_VIDEO
) {
223 if ((block
+1)*TM6000_URB_MSG_LEN
>linewidth
)
224 cmd
= TM6000_URB_MSG_ERR
;
226 /* FIXME: Mounts the image as field0+field1
227 * It should, instead, check if the user selected
228 * entrelaced or non-entrelaced mode
230 pos
= ((line
<< 1) - field
- 1) * linewidth
+
231 block
* TM6000_URB_MSG_LEN
;
233 /* Don't allow to write out of the buffer */
234 if (pos
+TM6000_URB_MSG_LEN
> (*buf
)->vb
.size
) {
235 dprintk(dev
, V4L2_DEBUG_ISOC
,
236 "ERR: size=%d, num=%d, line=%d, "
238 size
, block
, line
, field
);
240 cmd
= TM6000_URB_MSG_ERR
;
246 /* Prints debug info */
247 dprintk(dev
, V4L2_DEBUG_ISOC
, "size=%d, num=%d, "
248 " line=%d, field=%d\n",
249 size
, block
, line
, field
);
251 if ((last_line
!=line
)&&(last_line
+1!=line
) &&
252 (cmd
!= TM6000_URB_MSG_ERR
) ) {
253 if (cmd
!= TM6000_URB_MSG_VIDEO
) {
254 dprintk(dev
, V4L2_DEBUG_ISOC
, "cmd=%d, "
255 "size=%d, num=%d, line=%d, field=%d\n",
256 cmd
, size
, block
, line
, field
);
259 start_line
=last_line
;
260 /* Prints debug info */
261 dprintk(dev
, V4L2_DEBUG_ISOC
, "lines= %d-%d, "
263 start_line
, last_line
, field
);
265 if ((start_line
<6 && last_line
>200) &&
266 (last_field
!= field
) ) {
268 dev
->isoc_ctl
.nfields
++;
269 if (dev
->isoc_ctl
.nfields
>=2) {
270 dev
->isoc_ctl
.nfields
=0;
272 /* Announces that a new buffer were filled */
273 buffer_filled (dev
, dma_q
, *buf
);
274 dprintk(dev
, V4L2_DEBUG_ISOC
,
275 "new buffer filled\n");
276 get_next_buf (dma_q
, buf
);
279 out_p
= videobuf_to_vmalloc(&((*buf
)->vb
));
283 pos
= dev
->isoc_ctl
.pos
= 0;
290 if (cmd
== TM6000_URB_MSG_VIDEO
)
293 pktsize
= TM6000_URB_MSG_LEN
;
295 /* Continue the last copy */
296 cmd
= dev
->isoc_ctl
.cmd
;
297 size
= dev
->isoc_ctl
.size
;
298 pos
= dev
->isoc_ctl
.pos
;
299 pktsize
= dev
->isoc_ctl
.pktsize
;
302 cpysize
= (endp
-(*ptr
) > size
) ? size
: endp
- *ptr
;
305 /* handles each different URB message */
307 case TM6000_URB_MSG_VIDEO
:
308 /* Fills video buffer */
309 memcpy(&out_p
[pos
], *ptr
, cpysize
);
311 case TM6000_URB_MSG_PTS
:
313 case TM6000_URB_MSG_AUDIO
:
314 /* Need some code to process audio */
315 printk ("%ld: cmd=%s, size=%d\n", jiffies
,
316 tm6000_msg_type
[cmd
],size
);
318 case TM6000_URB_MSG_VBI
:
321 dprintk (dev
, V4L2_DEBUG_ISOC
, "cmd=%s, size=%d\n",
322 tm6000_msg_type
[cmd
],size
);
326 /* End of URB packet, but cmd processing is not
327 * complete. Preserve the state for a next packet
329 dev
->isoc_ctl
.pos
= pos
+cpysize
;
330 dev
->isoc_ctl
.size
= size
-cpysize
;
331 dev
->isoc_ctl
.cmd
= cmd
;
332 dev
->isoc_ctl
.pktsize
= pktsize
-cpysize
;
335 dev
->isoc_ctl
.cmd
= 0;
342 static int copy_streams(u8
*data
, u8
*out_p
, unsigned long len
,
343 struct urb
*urb
, struct tm6000_buffer
**buf
)
345 struct tm6000_dmaqueue
*dma_q
= urb
->context
;
346 struct tm6000_core
*dev
= container_of(dma_q
,struct tm6000_core
,vidq
);
347 u8
*ptr
=data
, *endp
=data
+len
;
348 unsigned long header
=0;
351 for (ptr
=data
; ptr
<endp
;) {
352 if (!dev
->isoc_ctl
.cmd
) {
353 u8
*p
=(u8
*)&dev
->isoc_ctl
.tmp_buf
;
354 /* FIXME: This seems very complex
355 * It just recovers up to 3 bytes of the header that
356 * might be at the previous packet
358 if (dev
->isoc_ctl
.tmp_buf_len
) {
359 while (dev
->isoc_ctl
.tmp_buf_len
) {
360 if ( *(ptr
+3-dev
->isoc_ctl
.tmp_buf_len
) == 0x47) {
364 dev
->isoc_ctl
.tmp_buf_len
--;
366 if (dev
->isoc_ctl
.tmp_buf_len
) {
368 dev
->isoc_ctl
.tmp_buf_len
);
369 memcpy((u8
*)&header
+
370 dev
->isoc_ctl
.tmp_buf_len
,
372 4 - dev
->isoc_ctl
.tmp_buf_len
);
373 ptr
+= 4 - dev
->isoc_ctl
.tmp_buf_len
;
378 for (;ptr
<endp
-3;ptr
++) {
384 dev
->isoc_ctl
.tmp_buf_len
=endp
-ptr
;
385 memcpy (&dev
->isoc_ctl
.tmp_buf
,ptr
,
386 dev
->isoc_ctl
.tmp_buf_len
);
391 /* Get message header */
392 header
=*(unsigned long *)ptr
;
396 /* Copy or continue last copy */
397 rc
=copy_packet(urb
,header
,&ptr
,endp
,out_p
,buf
);
400 printk(KERN_ERR
"tm6000: buffer underrun at %ld\n",
411 * Identify the tm5600/6000 buffer header type and properly handles
413 static int copy_multiplexed(u8
*ptr
, u8
*out_p
, unsigned long len
,
414 struct urb
*urb
, struct tm6000_buffer
**buf
)
416 struct tm6000_dmaqueue
*dma_q
= urb
->context
;
417 struct tm6000_core
*dev
= container_of(dma_q
,struct tm6000_core
,vidq
);
418 unsigned int pos
=dev
->isoc_ctl
.pos
,cpysize
;
422 cpysize
=min(len
,(*buf
)->vb
.size
-pos
);
423 //printk("Copying %d bytes (max=%lu) from %p to %p[%u]\n",cpysize,(*buf)->vb.size,ptr,out_p,pos);
424 memcpy(&out_p
[pos
], ptr
, cpysize
);
428 if (pos
>= (*buf
)->vb
.size
) {
430 /* Announces that a new buffer were filled */
431 buffer_filled (dev
, dma_q
, *buf
);
432 dprintk(dev
, V4L2_DEBUG_ISOC
, "new buffer filled\n");
433 get_next_buf (dma_q
, buf
);
436 out_p
= videobuf_to_vmalloc(&((*buf
)->vb
));
443 dev
->isoc_ctl
.pos
=pos
;
447 static void inline print_err_status (struct tm6000_core
*dev
,
448 int packet
, int status
)
450 char *errmsg
= "Unknown";
454 errmsg
= "unlinked synchronuously";
457 errmsg
= "unlinked asynchronuously";
460 errmsg
= "Buffer error (overrun)";
463 errmsg
= "Stalled (device not responding)";
466 errmsg
= "Babble (bad cable?)";
469 errmsg
= "Bit-stuff error (bad cable?)";
472 errmsg
= "CRC/Timeout (could be anything)";
475 errmsg
= "Device does not respond";
479 dprintk(dev
, V4L2_DEBUG_QUEUE
, "URB status %d [%s].\n",
482 dprintk(dev
, V4L2_DEBUG_QUEUE
, "URB packet %d, status %d [%s].\n",
483 packet
, status
, errmsg
);
489 * Controls the isoc copy of each urb packet
491 static inline int tm6000_isoc_copy(struct urb
*urb
)
493 struct tm6000_dmaqueue
*dma_q
= urb
->context
;
494 struct tm6000_core
*dev
= container_of(dma_q
,struct tm6000_core
,vidq
);
495 struct tm6000_buffer
*buf
;
498 char *outp
= NULL
, *p
;
499 unsigned long copied
;
501 get_next_buf(dma_q
, &buf
);
503 outp
= videobuf_to_vmalloc(&buf
->vb
);
513 print_err_status (dev
,-1,urb
->status
);
517 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
518 int status
= urb
->iso_frame_desc
[i
].status
;
521 print_err_status (dev
,i
,status
);
525 len
=urb
->iso_frame_desc
[i
].actual_length
;
527 // if (len>=TM6000_URB_MSG_LEN) {
528 p
=urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
;
529 if (!urb
->iso_frame_desc
[i
].status
) {
530 if ((buf
->fmt
->fourcc
)==V4L2_PIX_FMT_TM6000
) {
531 rc
=copy_multiplexed(p
, outp
, len
, urb
, &buf
);
535 copy_streams(p
, outp
, len
, urb
, &buf
);
539 if (copied
>= size
|| !buf
)
546 /* ------------------------------------------------------------------
548 ------------------------------------------------------------------*/
551 * IRQ callback, called by URB callback
553 static void tm6000_irq_callback(struct urb
*urb
)
555 struct tm6000_dmaqueue
*dma_q
= urb
->context
;
556 struct tm6000_core
*dev
= container_of(dma_q
, struct tm6000_core
, vidq
);
562 spin_lock(&dev
->slock
);
563 tm6000_isoc_copy(urb
);
564 spin_unlock(&dev
->slock
);
566 /* Reset urb buffers */
567 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
568 urb
->iso_frame_desc
[i
].status
= 0;
569 urb
->iso_frame_desc
[i
].actual_length
= 0;
572 urb
->status
= usb_submit_urb(urb
, GFP_ATOMIC
);
574 tm6000_err("urb resubmit failed (error=%i)\n",
579 * Stop and Deallocate URBs
581 static void tm6000_uninit_isoc(struct tm6000_core
*dev
)
586 dev
->isoc_ctl
.nfields
= -1;
587 dev
->isoc_ctl
.buf
= NULL
;
588 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
589 urb
=dev
->isoc_ctl
.urb
[i
];
593 if (dev
->isoc_ctl
.transfer_buffer
[i
]) {
594 usb_free_coherent(dev
->udev
,
595 urb
->transfer_buffer_length
,
596 dev
->isoc_ctl
.transfer_buffer
[i
],
600 dev
->isoc_ctl
.urb
[i
] = NULL
;
602 dev
->isoc_ctl
.transfer_buffer
[i
] = NULL
;
605 kfree (dev
->isoc_ctl
.urb
);
606 kfree (dev
->isoc_ctl
.transfer_buffer
);
608 dev
->isoc_ctl
.urb
=NULL
;
609 dev
->isoc_ctl
.transfer_buffer
=NULL
;
610 dev
->isoc_ctl
.num_bufs
= 0;
612 dev
->isoc_ctl
.num_bufs
=0;
616 * Allocate URBs and start IRQ
618 static int tm6000_prepare_isoc(struct tm6000_core
*dev
, unsigned int framesize
)
620 struct tm6000_dmaqueue
*dma_q
= &dev
->vidq
;
621 int i
, j
, sb_size
, pipe
, size
, max_packets
, num_bufs
= 5;
624 /* De-allocates all pending stuff */
625 tm6000_uninit_isoc(dev
);
627 usb_set_interface(dev
->udev
,
628 dev
->isoc_in
.bInterfaceNumber
,
629 dev
->isoc_in
.bAlternateSetting
);
631 pipe
= usb_rcvisocpipe(dev
->udev
,
632 dev
->isoc_in
.endp
->desc
.bEndpointAddress
&
633 USB_ENDPOINT_NUMBER_MASK
);
635 size
= usb_maxpacket(dev
->udev
, pipe
, usb_pipeout(pipe
));
637 if (size
> dev
->isoc_in
.maxsize
)
638 size
= dev
->isoc_in
.maxsize
;
640 dev
->isoc_ctl
.max_pkt_size
= size
;
642 max_packets
= ( framesize
+ size
- 1) / size
;
644 if (max_packets
> TM6000_MAX_ISO_PACKETS
)
645 max_packets
= TM6000_MAX_ISO_PACKETS
;
647 sb_size
= max_packets
* size
;
649 dev
->isoc_ctl
.num_bufs
= num_bufs
;
651 dev
->isoc_ctl
.urb
= kmalloc(sizeof(void *)*num_bufs
, GFP_KERNEL
);
652 if (!dev
->isoc_ctl
.urb
) {
653 tm6000_err("cannot alloc memory for usb buffers\n");
657 dev
->isoc_ctl
.transfer_buffer
= kmalloc(sizeof(void *)*num_bufs
,
659 if (!dev
->isoc_ctl
.transfer_buffer
) {
660 tm6000_err("cannot allocate memory for usbtransfer\n");
661 kfree(dev
->isoc_ctl
.urb
);
665 dprintk(dev
, V4L2_DEBUG_QUEUE
, "Allocating %d x %d packets"
666 " (%d bytes) of %d bytes each to handle %u size\n",
667 max_packets
, num_bufs
, sb_size
,
668 dev
->isoc_in
.maxsize
, size
);
670 /* allocate urbs and transfer buffers */
671 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
672 urb
= usb_alloc_urb(max_packets
, GFP_KERNEL
);
674 tm6000_err("cannot alloc isoc_ctl.urb %i\n", i
);
675 tm6000_uninit_isoc(dev
);
679 dev
->isoc_ctl
.urb
[i
] = urb
;
681 dev
->isoc_ctl
.transfer_buffer
[i
] = usb_alloc_coherent(dev
->udev
,
682 sb_size
, GFP_KERNEL
, &urb
->transfer_dma
);
683 if (!dev
->isoc_ctl
.transfer_buffer
[i
]) {
684 tm6000_err ("unable to allocate %i bytes for transfer"
687 in_interrupt()?" while in int":"");
688 tm6000_uninit_isoc(dev
);
691 memset(dev
->isoc_ctl
.transfer_buffer
[i
], 0, sb_size
);
693 usb_fill_bulk_urb(urb
, dev
->udev
, pipe
,
694 dev
->isoc_ctl
.transfer_buffer
[i
], sb_size
,
695 tm6000_irq_callback
, dma_q
);
696 urb
->interval
= dev
->isoc_in
.endp
->desc
.bInterval
;
697 urb
->number_of_packets
= max_packets
;
698 urb
->transfer_flags
= URB_ISO_ASAP
| URB_NO_TRANSFER_DMA_MAP
;
700 for (j
= 0; j
< max_packets
; j
++) {
701 urb
->iso_frame_desc
[j
].offset
= size
* j
;
702 urb
->iso_frame_desc
[j
].length
= size
;
709 static int tm6000_start_thread( struct tm6000_core
*dev
)
711 struct tm6000_dmaqueue
*dma_q
= &dev
->vidq
;
715 dma_q
->ini_jiffies
=jiffies
;
717 init_waitqueue_head(&dma_q
->wq
);
719 /* submit urbs and enables IRQ */
720 for (i
= 0; i
< dev
->isoc_ctl
.num_bufs
; i
++) {
721 int rc
= usb_submit_urb(dev
->isoc_ctl
.urb
[i
], GFP_ATOMIC
);
723 tm6000_err("submit of urb %i failed (error=%i)\n", i
,
725 tm6000_uninit_isoc(dev
);
733 /* ------------------------------------------------------------------
735 ------------------------------------------------------------------*/
738 buffer_setup(struct videobuf_queue
*vq
, unsigned int *count
, unsigned int *size
)
740 struct tm6000_fh
*fh
= vq
->priv_data
;
742 *size
= fh
->fmt
->depth
* fh
->width
* fh
->height
>> 3;
744 *count
= TM6000_DEF_BUF
;
746 if (*count
< TM6000_MIN_BUF
) {
747 *count
=TM6000_MIN_BUF
;
750 while (*size
* *count
> vid_limit
* 1024 * 1024)
756 static void free_buffer(struct videobuf_queue
*vq
, struct tm6000_buffer
*buf
)
758 struct tm6000_fh
*fh
= vq
->priv_data
;
759 struct tm6000_core
*dev
= fh
->dev
;
765 /* We used to wait for the buffer to finish here, but this didn't work
766 because, as we were keeping the state as VIDEOBUF_QUEUED,
767 videobuf_queue_cancel marked it as finished for us.
768 (Also, it could wedge forever if the hardware was misconfigured.)
770 This should be safe; by the time we get here, the buffer isn't
771 queued anymore. If we ever start marking the buffers as
772 VIDEOBUF_ACTIVE, it won't be, though.
774 spin_lock_irqsave(&dev
->slock
, flags
);
775 if (dev
->isoc_ctl
.buf
== buf
)
776 dev
->isoc_ctl
.buf
= NULL
;
777 spin_unlock_irqrestore(&dev
->slock
, flags
);
779 videobuf_vmalloc_free(&buf
->vb
);
780 buf
->vb
.state
= VIDEOBUF_NEEDS_INIT
;
784 buffer_prepare(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
,
785 enum v4l2_field field
)
787 struct tm6000_fh
*fh
= vq
->priv_data
;
788 struct tm6000_buffer
*buf
= container_of(vb
,struct tm6000_buffer
,vb
);
789 struct tm6000_core
*dev
= fh
->dev
;
790 int rc
= 0, urb_init
= 0;
792 BUG_ON(NULL
== fh
->fmt
);
795 /* FIXME: It assumes depth=2 */
796 /* The only currently supported format is 16 bits/pixel */
797 buf
->vb
.size
= fh
->fmt
->depth
*fh
->width
*fh
->height
>> 3;
798 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< buf
->vb
.size
)
801 if (buf
->fmt
!= fh
->fmt
||
802 buf
->vb
.width
!= fh
->width
||
803 buf
->vb
.height
!= fh
->height
||
804 buf
->vb
.field
!= field
) {
806 buf
->vb
.width
= fh
->width
;
807 buf
->vb
.height
= fh
->height
;
808 buf
->vb
.field
= field
;
809 buf
->vb
.state
= VIDEOBUF_NEEDS_INIT
;
812 if (VIDEOBUF_NEEDS_INIT
== buf
->vb
.state
) {
813 if (0 != (rc
= videobuf_iolock(vq
, &buf
->vb
, NULL
)))
818 if (!dev
->isoc_ctl
.num_bufs
)
822 rc
= tm6000_prepare_isoc(dev
, buf
->vb
.size
);
826 rc
= tm6000_start_thread(dev
);
832 buf
->vb
.state
= VIDEOBUF_PREPARED
;
836 free_buffer(vq
, buf
);
841 buffer_queue(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
)
843 struct tm6000_buffer
*buf
= container_of(vb
,struct tm6000_buffer
,vb
);
844 struct tm6000_fh
*fh
= vq
->priv_data
;
845 struct tm6000_core
*dev
= fh
->dev
;
846 struct tm6000_dmaqueue
*vidq
= &dev
->vidq
;
848 buf
->vb
.state
= VIDEOBUF_QUEUED
;
849 list_add_tail(&buf
->vb
.queue
, &vidq
->active
);
852 static void buffer_release(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
)
854 struct tm6000_buffer
*buf
= container_of(vb
,struct tm6000_buffer
,vb
);
859 static struct videobuf_queue_ops tm6000_video_qops
= {
860 .buf_setup
= buffer_setup
,
861 .buf_prepare
= buffer_prepare
,
862 .buf_queue
= buffer_queue
,
863 .buf_release
= buffer_release
,
866 /* ------------------------------------------------------------------
868 ------------------------------------------------------------------*/
870 static int res_get(struct tm6000_core
*dev
, struct tm6000_fh
*fh
)
873 mutex_lock(&dev
->lock
);
874 if (dev
->resources
) {
875 /* no, someone else uses it */
876 mutex_unlock(&dev
->lock
);
879 /* it's free, grab it */
881 dprintk(dev
, V4L2_DEBUG_RES_LOCK
, "res: get\n");
882 mutex_unlock(&dev
->lock
);
886 static int res_locked(struct tm6000_core
*dev
)
888 return (dev
->resources
);
891 static void res_free(struct tm6000_core
*dev
, struct tm6000_fh
*fh
)
893 mutex_lock(&dev
->lock
);
895 dprintk(dev
, V4L2_DEBUG_RES_LOCK
, "res: put\n");
896 mutex_unlock(&dev
->lock
);
899 /* ------------------------------------------------------------------
900 IOCTL vidioc handling
901 ------------------------------------------------------------------*/
902 static int vidioc_querycap (struct file
*file
, void *priv
,
903 struct v4l2_capability
*cap
)
905 // struct tm6000_core *dev = ((struct tm6000_fh *)priv)->dev;
907 strlcpy(cap
->driver
, "tm6000", sizeof(cap
->driver
));
908 strlcpy(cap
->card
,"Trident TVMaster TM5600/6000/6010", sizeof(cap
->card
));
909 // strlcpy(cap->bus_info, dev->udev->dev.bus_id, sizeof(cap->bus_info));
910 cap
->version
= TM6000_VERSION
;
911 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
|
918 static int vidioc_enum_fmt_vid_cap (struct file
*file
, void *priv
,
919 struct v4l2_fmtdesc
*f
)
921 if (unlikely(f
->index
>= ARRAY_SIZE(format
)))
924 strlcpy(f
->description
,format
[f
->index
].name
,sizeof(f
->description
));
925 f
->pixelformat
= format
[f
->index
].fourcc
;
929 static int vidioc_g_fmt_vid_cap (struct file
*file
, void *priv
,
930 struct v4l2_format
*f
)
932 struct tm6000_fh
*fh
=priv
;
934 f
->fmt
.pix
.width
= fh
->width
;
935 f
->fmt
.pix
.height
= fh
->height
;
936 f
->fmt
.pix
.field
= fh
->vb_vidq
.field
;
937 f
->fmt
.pix
.pixelformat
= fh
->fmt
->fourcc
;
938 f
->fmt
.pix
.bytesperline
=
939 (f
->fmt
.pix
.width
* fh
->fmt
->depth
) >> 3;
940 f
->fmt
.pix
.sizeimage
=
941 f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
946 static struct tm6000_fmt
* format_by_fourcc(unsigned int fourcc
)
950 for (i
= 0; i
< ARRAY_SIZE(format
); i
++)
951 if (format
[i
].fourcc
== fourcc
)
956 static int vidioc_try_fmt_vid_cap (struct file
*file
, void *priv
,
957 struct v4l2_format
*f
)
959 struct tm6000_core
*dev
= ((struct tm6000_fh
*)priv
)->dev
;
960 struct tm6000_fmt
*fmt
;
961 enum v4l2_field field
;
963 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
965 dprintk(dev
, V4L2_DEBUG_IOCTL_ARG
, "Fourcc format (0x%08x)"
966 " invalid.\n", f
->fmt
.pix
.pixelformat
);
970 field
= f
->fmt
.pix
.field
;
972 if (field
== V4L2_FIELD_ANY
) {
973 // field=V4L2_FIELD_INTERLACED;
974 field
=V4L2_FIELD_SEQ_TB
;
975 } else if (V4L2_FIELD_INTERLACED
!= field
) {
976 dprintk(dev
, V4L2_DEBUG_IOCTL_ARG
, "Field type invalid.\n");
980 tm6000_get_std_res (dev
);
982 f
->fmt
.pix
.width
= dev
->width
;
983 f
->fmt
.pix
.height
= dev
->height
;
985 f
->fmt
.pix
.width
&= ~0x01;
987 f
->fmt
.pix
.field
= field
;
989 f
->fmt
.pix
.bytesperline
=
990 (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
991 f
->fmt
.pix
.sizeimage
=
992 f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
997 /*FIXME: This seems to be generic enough to be at videodev2 */
998 static int vidioc_s_fmt_vid_cap (struct file
*file
, void *priv
,
999 struct v4l2_format
*f
)
1001 struct tm6000_fh
*fh
=priv
;
1002 struct tm6000_core
*dev
= fh
->dev
;
1003 int ret
= vidioc_try_fmt_vid_cap(file
,fh
,f
);
1007 fh
->fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
1008 fh
->width
= f
->fmt
.pix
.width
;
1009 fh
->height
= f
->fmt
.pix
.height
;
1010 fh
->vb_vidq
.field
= f
->fmt
.pix
.field
;
1013 dev
->fourcc
= f
->fmt
.pix
.pixelformat
;
1015 tm6000_set_fourcc_format(dev
);
1020 static int vidioc_reqbufs (struct file
*file
, void *priv
,
1021 struct v4l2_requestbuffers
*p
)
1023 struct tm6000_fh
*fh
=priv
;
1025 return (videobuf_reqbufs(&fh
->vb_vidq
, p
));
1028 static int vidioc_querybuf (struct file
*file
, void *priv
,
1029 struct v4l2_buffer
*p
)
1031 struct tm6000_fh
*fh
=priv
;
1033 return (videobuf_querybuf(&fh
->vb_vidq
, p
));
1036 static int vidioc_qbuf (struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
1038 struct tm6000_fh
*fh
=priv
;
1040 return (videobuf_qbuf(&fh
->vb_vidq
, p
));
1043 static int vidioc_dqbuf (struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
1045 struct tm6000_fh
*fh
=priv
;
1047 return (videobuf_dqbuf(&fh
->vb_vidq
, p
,
1048 file
->f_flags
& O_NONBLOCK
));
1051 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1052 static int vidiocgmbuf (struct file
*file
, void *priv
, struct video_mbuf
*mbuf
)
1054 struct tm6000_fh
*fh
=priv
;
1056 return videobuf_cgmbuf (&fh
->vb_vidq
, mbuf
, 8);
1060 static int vidioc_streamon(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
1062 struct tm6000_fh
*fh
=priv
;
1063 struct tm6000_core
*dev
= fh
->dev
;
1065 if (fh
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1070 if (!res_get(dev
,fh
))
1072 return (videobuf_streamon(&fh
->vb_vidq
));
1075 static int vidioc_streamoff(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
1077 struct tm6000_fh
*fh
=priv
;
1078 struct tm6000_core
*dev
= fh
->dev
;
1080 if (fh
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1085 videobuf_streamoff(&fh
->vb_vidq
);
1091 static int vidioc_s_std (struct file
*file
, void *priv
, v4l2_std_id
*norm
)
1094 struct tm6000_fh
*fh
=priv
;
1095 struct tm6000_core
*dev
= fh
->dev
;
1097 rc
=tm6000_set_standard (dev
, norm
);
1099 fh
->width
= dev
->width
;
1100 fh
->height
= dev
->height
;
1105 v4l2_device_call_all(&dev
->v4l2_dev
, 0, core
, s_std
, dev
->norm
);
1110 static int vidioc_enum_input (struct file
*file
, void *priv
,
1111 struct v4l2_input
*inp
)
1113 switch (inp
->index
) {
1114 case TM6000_INPUT_TV
:
1115 inp
->type
= V4L2_INPUT_TYPE_TUNER
;
1116 strcpy(inp
->name
,"Television");
1118 case TM6000_INPUT_COMPOSITE
:
1119 inp
->type
= V4L2_INPUT_TYPE_CAMERA
;
1120 strcpy(inp
->name
,"Composite");
1122 case TM6000_INPUT_SVIDEO
:
1123 inp
->type
= V4L2_INPUT_TYPE_CAMERA
;
1124 strcpy(inp
->name
,"S-Video");
1129 inp
->std
= TM6000_STD
;
1134 static int vidioc_g_input (struct file
*file
, void *priv
, unsigned int *i
)
1136 struct tm6000_fh
*fh
=priv
;
1137 struct tm6000_core
*dev
= fh
->dev
;
1143 static int vidioc_s_input (struct file
*file
, void *priv
, unsigned int i
)
1145 struct tm6000_fh
*fh
=priv
;
1146 struct tm6000_core
*dev
= fh
->dev
;
1151 case TM6000_INPUT_TV
:
1155 case TM6000_INPUT_COMPOSITE
:
1156 case TM6000_INPUT_SVIDEO
:
1163 rc
=tm6000_read_write_usb (dev
, USB_DIR_OUT
| USB_TYPE_VENDOR
,
1164 REQ_03_SET_GET_MCU_PIN
, 0x03, 1, buf
, 1);
1168 rc
=vidioc_s_std (file
, priv
, &dev
->vfd
->current_norm
);
1174 /* --- controls ---------------------------------------------- */
1175 static int vidioc_queryctrl (struct file
*file
, void *priv
,
1176 struct v4l2_queryctrl
*qc
)
1180 for (i
= 0; i
< ARRAY_SIZE(tm6000_qctrl
); i
++)
1181 if (qc
->id
&& qc
->id
== tm6000_qctrl
[i
].id
) {
1182 memcpy(qc
, &(tm6000_qctrl
[i
]),
1190 static int vidioc_g_ctrl (struct file
*file
, void *priv
,
1191 struct v4l2_control
*ctrl
)
1193 struct tm6000_fh
*fh
=priv
;
1194 struct tm6000_core
*dev
= fh
->dev
;
1197 /* FIXME: Probably, those won't work! Maybe we need shadow regs */
1199 case V4L2_CID_CONTRAST
:
1200 val
= tm6000_get_reg(dev
, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ
, 0);
1202 case V4L2_CID_BRIGHTNESS
:
1203 val
= tm6000_get_reg(dev
, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ
, 0);
1205 case V4L2_CID_SATURATION
:
1206 val
= tm6000_get_reg(dev
, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ
, 0);
1209 val
= tm6000_get_reg(dev
, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ
, 0);
1222 static int vidioc_s_ctrl (struct file
*file
, void *priv
,
1223 struct v4l2_control
*ctrl
)
1225 struct tm6000_fh
*fh
=priv
;
1226 struct tm6000_core
*dev
= fh
->dev
;
1230 case V4L2_CID_CONTRAST
:
1231 tm6000_set_reg(dev
, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ
, val
);
1233 case V4L2_CID_BRIGHTNESS
:
1234 tm6000_set_reg(dev
, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ
, val
);
1236 case V4L2_CID_SATURATION
:
1237 tm6000_set_reg(dev
, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ
, val
);
1240 tm6000_set_reg(dev
, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ
, val
);
1246 static int vidioc_g_tuner (struct file
*file
, void *priv
,
1247 struct v4l2_tuner
*t
)
1249 struct tm6000_fh
*fh
=priv
;
1250 struct tm6000_core
*dev
= fh
->dev
;
1252 if (unlikely(UNSET
== dev
->tuner_type
))
1257 strcpy(t
->name
, "Television");
1258 t
->type
= V4L2_TUNER_ANALOG_TV
;
1259 t
->capability
= V4L2_TUNER_CAP_NORM
;
1260 t
->rangehigh
= 0xffffffffUL
;
1261 t
->rxsubchans
= V4L2_TUNER_SUB_MONO
;
1266 static int vidioc_s_tuner (struct file
*file
, void *priv
,
1267 struct v4l2_tuner
*t
)
1269 struct tm6000_fh
*fh
=priv
;
1270 struct tm6000_core
*dev
= fh
->dev
;
1272 if (UNSET
== dev
->tuner_type
)
1280 static int vidioc_g_frequency (struct file
*file
, void *priv
,
1281 struct v4l2_frequency
*f
)
1283 struct tm6000_fh
*fh
=priv
;
1284 struct tm6000_core
*dev
= fh
->dev
;
1286 if (unlikely(UNSET
== dev
->tuner_type
))
1289 f
->type
= V4L2_TUNER_ANALOG_TV
;
1290 f
->frequency
= dev
->freq
;
1292 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, g_frequency
, f
);
1297 static int vidioc_s_frequency (struct file
*file
, void *priv
,
1298 struct v4l2_frequency
*f
)
1300 struct tm6000_fh
*fh
=priv
;
1301 struct tm6000_core
*dev
= fh
->dev
;
1303 if (unlikely(f
->type
!= V4L2_TUNER_ANALOG_TV
))
1306 if (unlikely(UNSET
== dev
->tuner_type
))
1308 if (unlikely(f
->tuner
!= 0))
1311 // mutex_lock(&dev->lock);
1312 dev
->freq
= f
->frequency
;
1313 v4l2_device_call_all(&dev
->v4l2_dev
, 0, tuner
, s_frequency
, f
);
1314 // mutex_unlock(&dev->lock);
1319 /* ------------------------------------------------------------------
1320 File operations for the device
1321 ------------------------------------------------------------------*/
1323 static int tm6000_open(struct file
*file
)
1325 struct video_device
*vdev
= video_devdata(file
);
1326 struct tm6000_core
*dev
= video_drvdata(file
);
1327 struct tm6000_fh
*fh
;
1328 enum v4l2_buf_type type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1331 printk(KERN_INFO
"tm6000: open called (dev=%s)\n",
1332 video_device_node_name(vdev
));
1334 dprintk(dev
, V4L2_DEBUG_OPEN
, "tm6000: open called (dev=%s)\n",
1335 video_device_node_name(vdev
));
1338 /* If more than one user, mutex should be added */
1341 dprintk(dev
, V4L2_DEBUG_OPEN
, "open dev=%s type=%s users=%d\n",
1342 video_device_node_name(vdev
), v4l2_type_names
[type
],
1345 /* allocate + initialize per filehandle data */
1346 fh
= kzalloc(sizeof(*fh
),GFP_KERNEL
);
1352 file
->private_data
= fh
;
1355 fh
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1356 dev
->fourcc
= format
[0].fourcc
;
1358 fh
->fmt
= format_by_fourcc(dev
->fourcc
);
1360 tm6000_get_std_res (dev
);
1362 fh
->width
= dev
->width
;
1363 fh
->height
= dev
->height
;
1365 dprintk(dev
, V4L2_DEBUG_OPEN
, "Open: fh=0x%08lx, dev=0x%08lx, "
1366 "dev->vidq=0x%08lx\n",
1367 (unsigned long)fh
,(unsigned long)dev
,(unsigned long)&dev
->vidq
);
1368 dprintk(dev
, V4L2_DEBUG_OPEN
, "Open: list_empty "
1369 "queued=%d\n",list_empty(&dev
->vidq
.queued
));
1370 dprintk(dev
, V4L2_DEBUG_OPEN
, "Open: list_empty "
1371 "active=%d\n",list_empty(&dev
->vidq
.active
));
1373 /* initialize hardware on analog mode */
1374 if (dev
->mode
!=TM6000_MODE_ANALOG
) {
1375 rc
=tm6000_init_analog_mode (dev
);
1379 /* Put all controls at a sane state */
1380 for (i
= 0; i
< ARRAY_SIZE(tm6000_qctrl
); i
++)
1381 qctl_regs
[i
] =tm6000_qctrl
[i
].default_value
;
1383 dev
->mode
=TM6000_MODE_ANALOG
;
1386 videobuf_queue_vmalloc_init(&fh
->vb_vidq
, &tm6000_video_qops
,
1389 V4L2_FIELD_INTERLACED
,
1390 sizeof(struct tm6000_buffer
),fh
);
1396 tm6000_read(struct file
*file
, char __user
*data
, size_t count
, loff_t
*pos
)
1398 struct tm6000_fh
*fh
= file
->private_data
;
1400 if (fh
->type
==V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1401 if (res_locked(fh
->dev
))
1404 return videobuf_read_stream(&fh
->vb_vidq
, data
, count
, pos
, 0,
1405 file
->f_flags
& O_NONBLOCK
);
1411 tm6000_poll(struct file
*file
, struct poll_table_struct
*wait
)
1413 struct tm6000_fh
*fh
= file
->private_data
;
1414 struct tm6000_buffer
*buf
;
1416 if (V4L2_BUF_TYPE_VIDEO_CAPTURE
!= fh
->type
)
1419 if (res_get(fh
->dev
,fh
)) {
1420 /* streaming capture */
1421 if (list_empty(&fh
->vb_vidq
.stream
))
1423 buf
= list_entry(fh
->vb_vidq
.stream
.next
,struct tm6000_buffer
,vb
.stream
);
1425 /* read() capture */
1426 return videobuf_poll_stream(file
, &fh
->vb_vidq
,
1429 poll_wait(file
, &buf
->vb
.done
, wait
);
1430 if (buf
->vb
.state
== VIDEOBUF_DONE
||
1431 buf
->vb
.state
== VIDEOBUF_ERROR
)
1432 return POLLIN
|POLLRDNORM
;
1436 static int tm6000_release(struct file
*file
)
1438 struct tm6000_fh
*fh
= file
->private_data
;
1439 struct tm6000_core
*dev
= fh
->dev
;
1440 struct video_device
*vdev
= video_devdata(file
);
1442 dprintk(dev
, V4L2_DEBUG_OPEN
, "tm6000: close called (dev=%s, users=%d)\n",
1443 video_device_node_name(vdev
), dev
->users
);
1448 tm6000_uninit_isoc(dev
);
1449 videobuf_mmap_free(&fh
->vb_vidq
);
1457 static int tm6000_mmap(struct file
*file
, struct vm_area_struct
* vma
)
1459 struct tm6000_fh
*fh
= file
->private_data
;
1462 ret
=videobuf_mmap_mapper(&fh
->vb_vidq
, vma
);
1467 static struct v4l2_file_operations tm6000_fops
= {
1468 .owner
= THIS_MODULE
,
1469 .open
= tm6000_open
,
1470 .release
= tm6000_release
,
1471 .ioctl
= video_ioctl2
, /* V4L2 ioctl handler */
1472 .read
= tm6000_read
,
1473 .poll
= tm6000_poll
,
1474 .mmap
= tm6000_mmap
,
1477 static const struct v4l2_ioctl_ops video_ioctl_ops
= {
1478 .vidioc_querycap
= vidioc_querycap
,
1479 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1480 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1481 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1482 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1483 .vidioc_s_std
= vidioc_s_std
,
1484 .vidioc_enum_input
= vidioc_enum_input
,
1485 .vidioc_g_input
= vidioc_g_input
,
1486 .vidioc_s_input
= vidioc_s_input
,
1487 .vidioc_queryctrl
= vidioc_queryctrl
,
1488 .vidioc_g_ctrl
= vidioc_g_ctrl
,
1489 .vidioc_s_ctrl
= vidioc_s_ctrl
,
1490 .vidioc_g_tuner
= vidioc_g_tuner
,
1491 .vidioc_s_tuner
= vidioc_s_tuner
,
1492 .vidioc_g_frequency
= vidioc_g_frequency
,
1493 .vidioc_s_frequency
= vidioc_s_frequency
,
1494 .vidioc_streamon
= vidioc_streamon
,
1495 .vidioc_streamoff
= vidioc_streamoff
,
1496 .vidioc_reqbufs
= vidioc_reqbufs
,
1497 .vidioc_querybuf
= vidioc_querybuf
,
1498 .vidioc_qbuf
= vidioc_qbuf
,
1499 .vidioc_dqbuf
= vidioc_dqbuf
,
1500 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1501 .vidiocgmbuf
= vidiocgmbuf
,
1505 static struct video_device tm6000_template
= {
1507 .fops
= &tm6000_fops
,
1508 .ioctl_ops
= &video_ioctl_ops
,
1509 .release
= video_device_release
,
1510 .tvnorms
= TM6000_STD
,
1511 .current_norm
= V4L2_STD_NTSC_M
,
1514 /* -----------------------------------------------------------------
1515 Initialization and module stuff
1516 ------------------------------------------------------------------*/
1518 int tm6000_v4l2_register(struct tm6000_core
*dev
)
1521 struct video_device
*vfd
;
1523 vfd
= video_device_alloc();
1529 /* init video dma queues */
1530 INIT_LIST_HEAD(&dev
->vidq
.active
);
1531 INIT_LIST_HEAD(&dev
->vidq
.queued
);
1533 memcpy (dev
->vfd
, &tm6000_template
, sizeof(*(dev
->vfd
)));
1534 dev
->vfd
->debug
=tm6000_debug
;
1535 vfd
->v4l2_dev
= &dev
->v4l2_dev
;
1536 video_set_drvdata(vfd
, dev
);
1538 ret
= video_register_device(dev
->vfd
, VFL_TYPE_GRABBER
, video_nr
);
1539 printk(KERN_INFO
"Trident TVMaster TM5600/TM6000/TM6010 USB2 board (Load status: %d)\n", ret
);
1543 int tm6000_v4l2_unregister(struct tm6000_core
*dev
)
1545 video_unregister_device(dev
->vfd
);
1550 int tm6000_v4l2_exit(void)
1555 module_param(video_nr
, int, 0);
1556 MODULE_PARM_DESC(video_nr
,"Allow changing video device number");
1558 module_param_named (debug
, tm6000_debug
, int, 0444);
1559 MODULE_PARM_DESC(debug
,"activates debug info");
1561 module_param(vid_limit
,int,0644);
1562 MODULE_PARM_DESC(vid_limit
,"capture memory limit in megabytes");