2 * STV0680 USB Camera Driver, by Kevin Sisson (kjsisson@bellsouth.net)
4 * Thanks to STMicroelectronics for information on the usb commands, and
5 * to Steve Miller at STM for his help and encouragement while I was
8 * This driver is based heavily on the
9 * Endpoints (formerly known as AOX) se401 USB Camera Driver
10 * Copyright (c) 2000 Jeroen B. Vreeken (pe1rxq@amsat.org)
12 * Still somewhat based on the Linux ov511 driver.
14 * This program is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the
16 * Free Software Foundation; either version 2 of the License, or (at your
17 * option) any later version.
19 * This program is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
21 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software Foundation,
26 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 * ver 0.1 October, 2001. Initial attempt.
31 * ver 0.2 November, 2001. Fixed asbility to resize, added brightness
32 * function, made more stable (?)
34 * ver 0.21 Nov, 2001. Added gamma correction and white balance,
35 * due to Alexander Schwartz. Still trying to
36 * improve stablility. Moved stuff into stv680.h
38 * ver 0.22 Nov, 2001. Added sharpen function (by Michael Sweet,
39 * mike@easysw.com) from GIMP, also used in pencam.
40 * Simple, fast, good integer math routine.
42 * ver 0.23 Dec, 2001 (gkh)
43 * Took out sharpen function, ran code through
44 * Lindent, and did other minor tweaks to get
45 * things to work properly with 2.5.1
47 * ver 0.24 Jan, 2002 (kjs)
48 * Fixed the problem with webcam crashing after
49 * two pictures. Changed the way pic is halved to
50 * improve quality. Got rid of green line around
51 * frame. Fix brightness reset when changing size
52 * bug. Adjusted gamma filters slightly.
54 * ver 0.25 Jan, 2002 (kjs)
55 * Fixed a bug in which the driver sometimes attempted
56 * to set to a non-supported size. This allowed
57 * gnomemeeting to work.
58 * Fixed proc entry removal bug.
61 #include <linux/config.h>
62 #include <linux/module.h>
63 #include <linux/init.h>
64 #include <linux/vmalloc.h>
65 #include <linux/slab.h>
66 #include <linux/pagemap.h>
67 #include <linux/errno.h>
68 #include <linux/videodev.h>
69 #include <media/v4l2-common.h>
70 #include <linux/usb.h>
71 #include <linux/mutex.h>
75 static int video_nr
= -1;
76 static int swapRGB
= 0; /* default for auto sleect */
77 static int swapRGB_on
= 0; /* default to allow auto select; -1=swap never, +1= swap always */
79 static unsigned int debug
= 0;
81 #define PDEBUG(level, fmt, args...) \
84 info("[%s:%d] " fmt, __FUNCTION__, __LINE__ , ## args); \
91 #define DRIVER_VERSION "v0.25"
92 #define DRIVER_AUTHOR "Kevin Sisson <kjsisson@bellsouth.net>"
93 #define DRIVER_DESC "STV0680 USB Camera Driver"
95 MODULE_AUTHOR (DRIVER_AUTHOR
);
96 MODULE_DESCRIPTION (DRIVER_DESC
);
97 MODULE_LICENSE ("GPL");
98 module_param(debug
, int, S_IRUGO
| S_IWUSR
);
99 MODULE_PARM_DESC (debug
, "Debug enabled or not");
100 module_param(swapRGB_on
, int, 0);
101 MODULE_PARM_DESC (swapRGB_on
, "Red/blue swap: 1=always, 0=auto, -1=never");
102 module_param(video_nr
, int, 0);
104 /********************************************************************
108 * This is a shameless copy from the USB-cpia driver (linux kernel
109 * version 2.3.29 or so, I have no idea what this code actually does ;).
110 * Actually it seems to be a copy of a shameless copy of the bttv-driver.
111 * Or that is a copy of a shameless copy of ... (To the powers: is there
112 * no generic kernel-function to do this sort of stuff?)
114 * Yes, it was a shameless copy from the bttv-driver. IIRC, Alan says
115 * there will be one, but apparentely not yet -jerdfelt
117 * So I copied it again for the ov511 driver -claudio
119 * Same for the se401 driver -Jeroen
121 * And the STV0680 driver - Kevin
122 ********************************************************************/
123 static void *rvmalloc (unsigned long size
)
128 size
= PAGE_ALIGN(size
);
129 mem
= vmalloc_32 (size
);
133 memset (mem
, 0, size
); /* Clear the ram out, no junk to the user */
134 adr
= (unsigned long) mem
;
136 SetPageReserved(vmalloc_to_page((void *)adr
));
143 static void rvfree (void *mem
, unsigned long size
)
150 adr
= (unsigned long) mem
;
151 while ((long) size
> 0) {
152 ClearPageReserved(vmalloc_to_page((void *)adr
));
160 /*********************************************************************
161 * pencam read/write functions
162 ********************************************************************/
164 static int stv_sndctrl (int set
, struct usb_stv
*stv680
, unsigned short req
, unsigned short value
, unsigned char *buffer
, int size
)
170 ret
= usb_control_msg (stv680
->udev
,
171 usb_rcvctrlpipe (stv680
->udev
, 0),
173 (USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
),
174 value
, 0, buffer
, size
, PENCAM_TIMEOUT
);
178 ret
= usb_control_msg (stv680
->udev
,
179 usb_sndctrlpipe (stv680
->udev
, 0),
181 (USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
),
182 value
, 0, buffer
, size
, PENCAM_TIMEOUT
);
186 ret
= usb_control_msg (stv680
->udev
,
187 usb_rcvctrlpipe (stv680
->udev
, 0),
189 (USB_DIR_IN
| USB_RECIP_DEVICE
),
190 value
, 0, buffer
, size
, PENCAM_TIMEOUT
);
194 ret
= usb_control_msg (stv680
->udev
,
195 usb_sndctrlpipe (stv680
->udev
, 0),
197 (USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
),
198 value
, 0, buffer
, size
, PENCAM_TIMEOUT
);
202 if ((ret
< 0) && (req
!= 0x0a)) {
203 PDEBUG (1, "STV(e): usb_control_msg error %i, request = 0x%x, error = %i", set
, req
, ret
);
208 static int stv_set_config (struct usb_stv
*dev
, int configuration
, int interface
, int alternate
)
211 if (configuration
!= dev
->udev
->actconfig
->desc
.bConfigurationValue
212 || usb_reset_configuration (dev
->udev
) < 0) {
213 PDEBUG (1, "STV(e): FAILED to reset configuration %i", configuration
);
216 if (usb_set_interface (dev
->udev
, interface
, alternate
) < 0) {
217 PDEBUG (1, "STV(e): FAILED to set alternate interface %i", alternate
);
223 static int stv_stop_video (struct usb_stv
*dev
)
228 buf
= kmalloc (40, GFP_KERNEL
);
230 PDEBUG (0, "STV(e): Out of (small buf) memory");
234 /* this is a high priority command; it stops all lower order commands */
235 if ((i
= stv_sndctrl (1, dev
, 0x04, 0x0000, buf
, 0x0)) < 0) {
236 i
= stv_sndctrl (0, dev
, 0x80, 0, buf
, 0x02); /* Get Last Error; 2 = busy */
237 PDEBUG (1, "STV(i): last error: %i, command = 0x%x", buf
[0], buf
[1]);
239 PDEBUG (1, "STV(i): Camera reset to idle mode.");
242 if ((i
= stv_set_config (dev
, 1, 0, 0)) < 0)
243 PDEBUG (1, "STV(e): Reset config during exit failed");
245 /* get current mode */
247 if ((i
= stv_sndctrl (0, dev
, 0x87, 0, buf
, 0x08)) != 0x08) /* get mode */
248 PDEBUG (0, "STV(e): Stop_video: problem setting original mode");
249 if (dev
->origMode
!= buf
[0]) {
251 buf
[0] = (unsigned char) dev
->origMode
;
252 if ((i
= stv_sndctrl (3, dev
, 0x07, 0x0100, buf
, 0x08)) != 0x08) {
253 PDEBUG (0, "STV(e): Stop_video: Set_Camera_Mode failed");
257 i
= stv_sndctrl (0, dev
, 0x87, 0, buf
, 0x08);
258 if ((i
!= 0x08) || (buf
[0] != dev
->origMode
)) {
259 PDEBUG (0, "STV(e): camera NOT set to original resolution.");
262 PDEBUG (0, "STV(i): Camera set to original resolution");
269 static int stv_set_video_mode (struct usb_stv
*dev
)
271 int i
, stop_video
= 1;
274 buf
= kmalloc (40, GFP_KERNEL
);
276 PDEBUG (0, "STV(e): Out of (small buf) memory");
280 if ((i
= stv_set_config (dev
, 1, 0, 0)) < 0) {
285 i
= stv_sndctrl (2, dev
, 0x06, 0x0100, buf
, 0x12);
286 if (!(i
> 0) && (buf
[8] == 0x53) && (buf
[9] == 0x05)) {
287 PDEBUG (1, "STV(e): Could not get descriptor 0100.");
291 /* set alternate interface 1 */
292 if ((i
= stv_set_config (dev
, 1, 0, 1)) < 0)
295 if ((i
= stv_sndctrl (0, dev
, 0x85, 0, buf
, 0x10)) != 0x10)
297 PDEBUG (1, "STV(i): Setting video mode.");
298 /* Switch to Video mode: 0x0100 = VGA (640x480), 0x0000 = CIF (352x288) 0x0300 = QVGA (320x240) */
299 if ((i
= stv_sndctrl (1, dev
, 0x09, dev
->VideoMode
, buf
, 0x0)) < 0) {
308 stv_stop_video (dev
);
316 static int stv_init (struct usb_stv
*stv680
)
319 unsigned char *buffer
;
320 unsigned long int bufsize
;
322 buffer
= kzalloc (40, GFP_KERNEL
);
323 if (buffer
== NULL
) {
324 PDEBUG (0, "STV(e): Out of (small buf) memory");
329 /* set config 1, interface 0, alternate 0 */
330 if ((i
= stv_set_config (stv680
, 1, 0, 0)) < 0) {
332 PDEBUG (0, "STV(e): set config 1,0,0 failed");
335 /* ping camera to be sure STV0680 is present */
336 if ((i
= stv_sndctrl (0, stv680
, 0x88, 0x5678, buffer
, 0x02)) != 0x02)
338 if ((buffer
[0] != 0x56) || (buffer
[1] != 0x78)) {
339 PDEBUG (1, "STV(e): camera ping failed!!");
343 /* get camera descriptor */
344 if ((i
= stv_sndctrl (2, stv680
, 0x06, 0x0200, buffer
, 0x09)) != 0x09)
346 i
= stv_sndctrl (2, stv680
, 0x06, 0x0200, buffer
, 0x22);
347 if (!(i
>= 0) && (buffer
[7] == 0xa0) && (buffer
[8] == 0x23)) {
348 PDEBUG (1, "STV(e): Could not get descriptor 0200.");
351 if ((i
= stv_sndctrl (0, stv680
, 0x8a, 0, buffer
, 0x02)) != 0x02)
353 if ((i
= stv_sndctrl (0, stv680
, 0x8b, 0, buffer
, 0x24)) != 0x24)
355 if ((i
= stv_sndctrl (0, stv680
, 0x85, 0, buffer
, 0x10)) != 0x10)
358 stv680
->SupportedModes
= buffer
[7];
359 i
= stv680
->SupportedModes
;
369 if (stv680
->SupportedModes
== 0) {
370 PDEBUG (0, "STV(e): There are NO supported STV680 modes!!");
375 PDEBUG (0, "STV(i): CIF is supported");
377 PDEBUG (0, "STV(i): QVGA is supported");
379 /* FW rev, ASIC rev, sensor ID */
380 PDEBUG (1, "STV(i): Firmware rev is %i.%i", buffer
[0], buffer
[1]);
381 PDEBUG (1, "STV(i): ASIC rev is %i.%i", buffer
[2], buffer
[3]);
382 PDEBUG (1, "STV(i): Sensor ID is %i", (buffer
[4]*16) + (buffer
[5]>>4));
384 /* set alternate interface 1 */
385 if ((i
= stv_set_config (stv680
, 1, 0, 1)) < 0)
388 if ((i
= stv_sndctrl (0, stv680
, 0x85, 0, buffer
, 0x10)) != 0x10)
390 if ((i
= stv_sndctrl (0, stv680
, 0x8d, 0, buffer
, 0x08)) != 0x08)
393 PDEBUG (0, "STV(i): Camera has %i pictures.", i
);
395 /* get current mode */
396 if ((i
= stv_sndctrl (0, stv680
, 0x87, 0, buffer
, 0x08)) != 0x08)
398 stv680
->origMode
= buffer
[0]; /* 01 = VGA, 03 = QVGA, 00 = CIF */
400 /* This will attemp CIF mode, if supported. If not, set to QVGA */
401 memset (buffer
, 0, 8);
404 else if (stv680
->QVGA
)
406 if ((i
= stv_sndctrl (3, stv680
, 0x07, 0x0100, buffer
, 0x08)) != 0x08) {
407 PDEBUG (0, "STV(i): Set_Camera_Mode failed");
412 stv_sndctrl (0, stv680
, 0x87, 0, buffer
, 0x08);
413 if (((stv680
->CIF
== 1) && (buffer
[0] != 0x00)) || ((stv680
->QVGA
== 1) && (buffer
[0] != 0x03))) {
414 PDEBUG (0, "STV(e): Error setting camera video mode!");
418 if (buffer
[0] == 0) {
419 stv680
->VideoMode
= 0x0000;
420 PDEBUG (0, "STV(i): Video Mode set to CIF");
422 if (buffer
[0] == 0x03) {
423 stv680
->VideoMode
= 0x0300;
424 PDEBUG (0, "STV(i): Video Mode set to QVGA");
427 if ((i
= stv_sndctrl (0, stv680
, 0x8f, 0, buffer
, 0x10)) != 0x10)
429 bufsize
= (buffer
[0] << 24) | (buffer
[1] << 16) | (buffer
[2] << 8) | (buffer
[3]);
430 stv680
->cwidth
= (buffer
[4] << 8) | (buffer
[5]); /* ->camera = 322, 356, 644 */
431 stv680
->cheight
= (buffer
[6] << 8) | (buffer
[7]); /* ->camera = 242, 292, 484 */
432 stv680
->origGain
= buffer
[12];
437 i
= stv_sndctrl (0, stv680
, 0x80, 0, buffer
, 0x02); /* Get Last Error */
438 PDEBUG (1, "STV(i): last error: %i, command = 0x%x", buffer
[0], buffer
[1]);
445 /* video = 320x240, 352x288 */
446 if (stv680
->CIF
== 1) {
447 stv680
->maxwidth
= 352;
448 stv680
->maxheight
= 288;
449 stv680
->vwidth
= 352;
450 stv680
->vheight
= 288;
452 if (stv680
->QVGA
== 1) {
453 stv680
->maxwidth
= 320;
454 stv680
->maxheight
= 240;
455 stv680
->vwidth
= 320;
456 stv680
->vheight
= 240;
459 stv680
->rawbufsize
= bufsize
; /* must be ./. by 8 */
460 stv680
->maxframesize
= bufsize
* 3; /* RGB size */
461 PDEBUG (2, "STV(i): cwidth = %i, cheight = %i", stv680
->cwidth
, stv680
->cheight
);
462 PDEBUG (1, "STV(i): width = %i, height = %i, rawbufsize = %li", stv680
->vwidth
, stv680
->vheight
, stv680
->rawbufsize
);
464 /* some default values */
465 stv680
->bulk_in_endpointAddr
= 0x82;
468 stv680
->framecount
= 0;
469 stv680
->readcount
= 0;
470 stv680
->streaming
= 0;
471 /* bright, white, colour, hue, contrast are set by software, not in stv0680 */
472 stv680
->brightness
= 32767;
473 stv680
->chgbright
= 0;
474 stv680
->whiteness
= 0; /* only for greyscale */
475 stv680
->colour
= 32767;
476 stv680
->contrast
= 32767;
478 stv680
->palette
= STV_VIDEO_PALETTE
;
479 stv680
->depth
= 24; /* rgb24 bits */
480 if ((swapRGB_on
== 0) && (swapRGB
== 0))
481 PDEBUG (1, "STV(i): swapRGB is (auto) OFF");
482 else if ((swapRGB_on
== 0) && (swapRGB
== 1))
483 PDEBUG (1, "STV(i): swapRGB is (auto) ON");
484 else if (swapRGB_on
== 1)
485 PDEBUG (1, "STV(i): swapRGB is (forced) ON");
486 else if (swapRGB_on
== -1)
487 PDEBUG (1, "STV(i): swapRGB is (forced) OFF");
489 if (stv_set_video_mode (stv680
) < 0) {
490 PDEBUG (0, "STV(e): Could not set video mode in stv_init");
497 /***************** last of pencam routines *******************/
499 /****************************************************************************
501 ***************************************************************************/
502 #define stv680_file(name, variable, field) \
503 static ssize_t show_##name(struct class_device *class_dev, char *buf) \
505 struct video_device *vdev = to_video_device(class_dev); \
506 struct usb_stv *stv = video_get_drvdata(vdev); \
507 return sprintf(buf, field, stv->variable); \
509 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
511 stv680_file(model
, camera_name
, "%s\n");
512 stv680_file(in_use
, user
, "%d\n");
513 stv680_file(streaming
, streaming
, "%d\n");
514 stv680_file(palette
, palette
, "%i\n");
515 stv680_file(frames_total
, readcount
, "%d\n");
516 stv680_file(frames_read
, framecount
, "%d\n");
517 stv680_file(packets_dropped
, dropped
, "%d\n");
518 stv680_file(decoding_errors
, error
, "%d\n");
520 static void stv680_create_sysfs_files(struct video_device
*vdev
)
522 video_device_create_file(vdev
, &class_device_attr_model
);
523 video_device_create_file(vdev
, &class_device_attr_in_use
);
524 video_device_create_file(vdev
, &class_device_attr_streaming
);
525 video_device_create_file(vdev
, &class_device_attr_palette
);
526 video_device_create_file(vdev
, &class_device_attr_frames_total
);
527 video_device_create_file(vdev
, &class_device_attr_frames_read
);
528 video_device_create_file(vdev
, &class_device_attr_packets_dropped
);
529 video_device_create_file(vdev
, &class_device_attr_decoding_errors
);
532 static void stv680_remove_sysfs_files(struct video_device
*vdev
)
534 video_device_remove_file(vdev
, &class_device_attr_model
);
535 video_device_remove_file(vdev
, &class_device_attr_in_use
);
536 video_device_remove_file(vdev
, &class_device_attr_streaming
);
537 video_device_remove_file(vdev
, &class_device_attr_palette
);
538 video_device_remove_file(vdev
, &class_device_attr_frames_total
);
539 video_device_remove_file(vdev
, &class_device_attr_frames_read
);
540 video_device_remove_file(vdev
, &class_device_attr_packets_dropped
);
541 video_device_remove_file(vdev
, &class_device_attr_decoding_errors
);
544 /********************************************************************
546 *******************************************************************/
548 static int stv680_get_pict (struct usb_stv
*stv680
, struct video_picture
*p
)
550 /* This sets values for v4l interface. max/min = 65535/0 */
552 p
->brightness
= stv680
->brightness
;
553 p
->whiteness
= stv680
->whiteness
; /* greyscale */
554 p
->colour
= stv680
->colour
;
555 p
->contrast
= stv680
->contrast
;
556 p
->hue
= stv680
->hue
;
557 p
->palette
= stv680
->palette
;
558 p
->depth
= stv680
->depth
;
562 static int stv680_set_pict (struct usb_stv
*stv680
, struct video_picture
*p
)
564 /* See above stv680_get_pict */
566 if (p
->palette
!= STV_VIDEO_PALETTE
) {
567 PDEBUG (2, "STV(e): Palette set error in _set_pic");
571 if (stv680
->brightness
!= p
->brightness
) {
572 stv680
->chgbright
= 1;
573 stv680
->brightness
= p
->brightness
;
576 stv680
->whiteness
= p
->whiteness
; /* greyscale */
577 stv680
->colour
= p
->colour
;
578 stv680
->contrast
= p
->contrast
;
579 stv680
->hue
= p
->hue
;
580 stv680
->palette
= p
->palette
;
581 stv680
->depth
= p
->depth
;
586 static void stv680_video_irq (struct urb
*urb
, struct pt_regs
*regs
)
588 struct usb_stv
*stv680
= urb
->context
;
589 int length
= urb
->actual_length
;
591 if (length
< stv680
->rawbufsize
)
592 PDEBUG (2, "STV(i): Lost data in transfer: exp %li, got %i", stv680
->rawbufsize
, length
);
595 if (!stv680
->streaming
)
599 PDEBUG (0, "STV(e): device vapourished in video_irq");
603 /* 0 sized packets happen if we are to fast, but sometimes the camera
604 keeps sending them forever...
606 if (length
&& !urb
->status
) {
607 stv680
->nullpackets
= 0;
608 switch (stv680
->scratch
[stv680
->scratch_next
].state
) {
615 memcpy (stv680
->scratch
[stv680
->scratch_next
].data
,
616 (unsigned char *) urb
->transfer_buffer
, length
);
617 stv680
->scratch
[stv680
->scratch_next
].state
= BUFFER_READY
;
618 stv680
->scratch
[stv680
->scratch_next
].length
= length
;
619 if (waitqueue_active (&stv680
->wq
)) {
620 wake_up_interruptible (&stv680
->wq
);
622 stv680
->scratch_overflow
= 0;
623 stv680
->scratch_next
++;
624 if (stv680
->scratch_next
>= STV680_NUMSCRATCH
)
625 stv680
->scratch_next
= 0;
629 stv680
->nullpackets
++;
630 if (stv680
->nullpackets
> STV680_MAX_NULLPACKETS
) {
631 if (waitqueue_active (&stv680
->wq
)) {
632 wake_up_interruptible (&stv680
->wq
);
637 /* Resubmit urb for new data */
639 urb
->dev
= stv680
->udev
;
640 if (usb_submit_urb (urb
, GFP_ATOMIC
))
641 PDEBUG (0, "STV(e): urb burned down in video irq");
645 static int stv680_start_stream (struct usb_stv
*stv680
)
650 stv680
->streaming
= 1;
652 /* Do some memory allocation */
653 for (i
= 0; i
< STV680_NUMFRAMES
; i
++) {
654 stv680
->frame
[i
].data
= stv680
->fbuf
+ i
* stv680
->maxframesize
;
655 stv680
->frame
[i
].curpix
= 0;
657 /* packet size = 4096 */
658 for (i
= 0; i
< STV680_NUMSBUF
; i
++) {
659 stv680
->sbuf
[i
].data
= kmalloc (stv680
->rawbufsize
, GFP_KERNEL
);
660 if (stv680
->sbuf
[i
].data
== NULL
) {
661 PDEBUG (0, "STV(e): Could not kmalloc raw data buffer %i", i
);
666 stv680
->scratch_next
= 0;
667 stv680
->scratch_use
= 0;
668 stv680
->scratch_overflow
= 0;
669 for (i
= 0; i
< STV680_NUMSCRATCH
; i
++) {
670 stv680
->scratch
[i
].data
= kmalloc (stv680
->rawbufsize
, GFP_KERNEL
);
671 if (stv680
->scratch
[i
].data
== NULL
) {
672 PDEBUG (0, "STV(e): Could not kmalloc raw scratch buffer %i", i
);
675 stv680
->scratch
[i
].state
= BUFFER_UNUSED
;
678 for (i
= 0; i
< STV680_NUMSBUF
; i
++) {
679 urb
= usb_alloc_urb (0, GFP_KERNEL
);
683 /* sbuf is urb->transfer_buffer, later gets memcpyed to scratch */
684 usb_fill_bulk_urb (urb
, stv680
->udev
,
685 usb_rcvbulkpipe (stv680
->udev
, stv680
->bulk_in_endpointAddr
),
686 stv680
->sbuf
[i
].data
, stv680
->rawbufsize
,
687 stv680_video_irq
, stv680
);
688 stv680
->urb
[i
] = urb
;
689 err
= usb_submit_urb (stv680
->urb
[i
], GFP_KERNEL
);
691 PDEBUG (0, "STV(e): urb burned down in start stream");
692 } /* i STV680_NUMSBUF */
694 stv680
->framecount
= 0;
698 static int stv680_stop_stream (struct usb_stv
*stv680
)
702 if (!stv680
->streaming
|| !stv680
->udev
)
705 stv680
->streaming
= 0;
707 for (i
= 0; i
< STV680_NUMSBUF
; i
++)
708 if (stv680
->urb
[i
]) {
709 usb_kill_urb (stv680
->urb
[i
]);
710 usb_free_urb (stv680
->urb
[i
]);
711 stv680
->urb
[i
] = NULL
;
712 kfree(stv680
->sbuf
[i
].data
);
714 for (i
= 0; i
< STV680_NUMSCRATCH
; i
++) {
715 kfree(stv680
->scratch
[i
].data
);
716 stv680
->scratch
[i
].data
= NULL
;
722 static int stv680_set_size (struct usb_stv
*stv680
, int width
, int height
)
724 int wasstreaming
= stv680
->streaming
;
726 /* Check to see if we need to change */
727 if ((stv680
->vwidth
== width
) && (stv680
->vheight
== height
))
730 PDEBUG (1, "STV(i): size request for %i x %i", width
, height
);
731 /* Check for a valid mode */
732 if ((!width
|| !height
) || ((width
& 1) || (height
& 1))) {
733 PDEBUG (1, "STV(e): set_size error: request: v.width = %i, v.height = %i actual: stv.width = %i, stv.height = %i", width
, height
, stv680
->vwidth
, stv680
->vheight
);
737 if ((width
< (stv680
->maxwidth
/ 2)) || (height
< (stv680
->maxheight
/ 2))) {
738 width
= stv680
->maxwidth
/ 2;
739 height
= stv680
->maxheight
/ 2;
740 } else if ((width
>= 158) && (width
<= 166) && (stv680
->QVGA
== 1)) {
743 } else if ((width
>= 172) && (width
<= 180) && (stv680
->CIF
== 1)) {
746 } else if ((width
>= 318) && (width
<= 350) && (stv680
->QVGA
== 1)) {
749 } else if ((width
>= 350) && (width
<= 358) && (stv680
->CIF
== 1)) {
753 PDEBUG (1, "STV(e): request for non-supported size: request: v.width = %i, v.height = %i actual: stv.width = %i, stv.height = %i", width
, height
, stv680
->vwidth
, stv680
->vheight
);
757 /* Stop a current stream and start it again at the new size */
759 stv680_stop_stream (stv680
);
760 stv680
->vwidth
= width
;
761 stv680
->vheight
= height
;
762 PDEBUG (1, "STV(i): size set to %i x %i", stv680
->vwidth
, stv680
->vheight
);
764 stv680_start_stream (stv680
);
769 /**********************************************************************
771 **********************************************************************/
773 /******* routines from the pencam program; hey, they work! ********/
776 * STV0680 Vision Camera Chipset Driver
777 * Copyright (C) 2000 Adam Harrison <adam@antispin.org>
783 #define AD(x, y, w) (((y)*(w)+(x))*3)
785 static void bayer_unshuffle (struct usb_stv
*stv680
, struct stv680_scratch
*buffer
)
788 int w
= stv680
->cwidth
;
789 int vw
= stv680
->cwidth
, vh
= stv680
->cheight
;
791 int colour
= 0, bayer
= 0;
792 unsigned char *raw
= buffer
->data
;
793 struct stv680_frame
*frame
= &stv680
->frame
[stv680
->curframe
];
794 unsigned char *output
= frame
->data
;
795 unsigned char *temp
= frame
->data
;
796 int offset
= buffer
->offset
;
798 if (frame
->curpix
== 0) {
799 if (frame
->grabstate
== FRAME_READY
) {
800 frame
->grabstate
= FRAME_GRABBING
;
803 if (offset
!= frame
->curpix
) { /* Regard frame as lost :( */
809 if ((stv680
->vwidth
== 320) || (stv680
->vwidth
== 160)) {
813 if ((stv680
->vwidth
== 352) || (stv680
->vwidth
== 176)) {
818 memset (output
, 0, 3 * vw
* vh
); /* clear output matrix. */
820 for (y
= 0; y
< vh
; y
++) {
821 for (x
= 0; x
< vw
; x
++) {
823 p
= *(raw
+ y
* w
+ (x
>> 1));
825 p
= *(raw
+ y
* w
+ (x
>> 1) + (w
>> 1));
846 i
= (y
* vw
+ x
) * 3;
847 *(output
+ i
+ colour
) = (unsigned char) p
;
852 /****** gamma correction plus hardcoded white balance */
853 /* Thanks to Alexander Schwartx <alexander.schwartx@gmx.net> for this code.
854 Correction values red[], green[], blue[], are generated by
855 (pow(i/256.0, GAMMA)*255.0)*white balanceRGB where GAMMA=0.55, 1<i<255.
856 White balance (RGB)= 1.0, 1.17, 1.48. Values are calculated as double float and
857 converted to unsigned char. Values are in stv680.h */
859 for (y
= 0; y
< vh
; y
++) {
860 for (x
= 0; x
< vw
; x
++) {
861 i
= (y
* vw
+ x
) * 3;
862 *(output
+ i
) = red
[*(output
+ i
)];
863 *(output
+ i
+ 1) = green
[*(output
+ i
+ 1)];
864 *(output
+ i
+ 2) = blue
[*(output
+ i
+ 2)];
868 /****** bayer demosaic ******/
869 for (y
= 1; y
< (vh
- 1); y
++) {
870 for (x
= 1; x
< (vw
- 1); x
++) { /* work out pixel type */
879 case 0: /* green. blue lr, red tb */
880 *(output
+ AD (x
, y
, vw
) + BLUE
) = ((int) *(output
+ AD (x
- 1, y
, vw
) + BLUE
) + (int) *(output
+ AD (x
+ 1, y
, vw
) + BLUE
)) >> 1;
881 *(output
+ AD (x
, y
, vw
) + RED
) = ((int) *(output
+ AD (x
, y
- 1, vw
) + RED
) + (int) *(output
+ AD (x
, y
+ 1, vw
) + RED
)) >> 1;
884 case 1: /* blue. green lrtb, red diagonals */
885 *(output
+ AD (x
, y
, vw
) + GREEN
) = ((int) *(output
+ AD (x
- 1, y
, vw
) + GREEN
) + (int) *(output
+ AD (x
+ 1, y
, vw
) + GREEN
) + (int) *(output
+ AD (x
, y
- 1, vw
) + GREEN
) + (int) *(output
+ AD (x
, y
+ 1, vw
) + GREEN
)) >> 2;
886 *(output
+ AD (x
, y
, vw
) + RED
) = ((int) *(output
+ AD (x
- 1, y
- 1, vw
) + RED
) + (int) *(output
+ AD (x
- 1, y
+ 1, vw
) + RED
) + (int) *(output
+ AD (x
+ 1, y
- 1, vw
) + RED
) + (int) *(output
+ AD (x
+ 1, y
+ 1, vw
) + RED
)) >> 2;
889 case 2: /* red. green lrtb, blue diagonals */
890 *(output
+ AD (x
, y
, vw
) + GREEN
) = ((int) *(output
+ AD (x
- 1, y
, vw
) + GREEN
) + (int) *(output
+ AD (x
+ 1, y
, vw
) + GREEN
) + (int) *(output
+ AD (x
, y
- 1, vw
) + GREEN
) + (int) *(output
+ AD (x
, y
+ 1, vw
) + GREEN
)) >> 2;
891 *(output
+ AD (x
, y
, vw
) + BLUE
) = ((int) *(output
+ AD (x
- 1, y
- 1, vw
) + BLUE
) + (int) *(output
+ AD (x
+ 1, y
- 1, vw
) + BLUE
) + (int) *(output
+ AD (x
- 1, y
+ 1, vw
) + BLUE
) + (int) *(output
+ AD (x
+ 1, y
+ 1, vw
) + BLUE
)) >> 2;
894 case 3: /* green. red lr, blue tb */
895 *(output
+ AD (x
, y
, vw
) + RED
) = ((int) *(output
+ AD (x
- 1, y
, vw
) + RED
) + (int) *(output
+ AD (x
+ 1, y
, vw
) + RED
)) >> 1;
896 *(output
+ AD (x
, y
, vw
) + BLUE
) = ((int) *(output
+ AD (x
, y
- 1, vw
) + BLUE
) + (int) *(output
+ AD (x
, y
+ 1, vw
) + BLUE
)) >> 1;
900 } /* for y - end demosaic */
902 /* fix top and bottom row, left and right side */
904 memcpy (output
, (output
+ i
), i
);
905 memcpy ((output
+ (vh
* i
)), (output
+ ((vh
- 1) * i
)), i
);
906 for (y
= 0; y
< vh
; y
++) {
908 memcpy ((output
+ i
), (output
+ i
+ 3), 3);
909 memcpy ((output
+ i
+ (vw
* 3)), (output
+ i
+ (vw
- 1) * 3), 3);
912 /* process all raw data, then trim to size if necessary */
913 if ((stv680
->vwidth
== 160) || (stv680
->vwidth
== 176)) {
915 for (y
= 0; y
< vh
; y
++) {
917 for (x
= 0; x
< vw
; x
++) {
918 p
= (y
* vw
+ x
) * 3;
920 *(output
+ i
) = *(output
+ p
);
921 *(output
+ i
+ 1) = *(output
+ p
+ 1);
922 *(output
+ i
+ 2) = *(output
+ p
+ 2);
929 /* reset to proper width */
930 if ((stv680
->vwidth
== 160)) {
934 if ((stv680
->vwidth
== 176)) {
939 /* output is RGB; some programs want BGR */
940 /* swapRGB_on=0 -> program decides; swapRGB_on=1, always swap */
941 /* swapRGB_on=-1, never swap */
942 if (((swapRGB
== 1) && (swapRGB_on
!= -1)) || (swapRGB_on
== 1)) {
943 for (y
= 0; y
< vh
; y
++) {
944 for (x
= 0; x
< vw
; x
++) {
945 i
= (y
* vw
+ x
) * 3;
946 *(temp
) = *(output
+ i
);
947 *(output
+ i
) = *(output
+ i
+ 2);
948 *(output
+ i
+ 2) = *(temp
);
953 if (stv680
->chgbright
== 1) {
954 if (stv680
->brightness
>= 32767) {
955 p
= (stv680
->brightness
- 32767) / 256;
956 for (x
= 0; x
< (vw
* vh
* 3); x
++) {
957 if ((*(output
+ x
) + (unsigned char) p
) > 255)
960 *(output
+ x
) += (unsigned char) p
;
963 p
= (32767 - stv680
->brightness
) / 256;
964 for (x
= 0; x
< (vw
* vh
* 3); x
++) {
965 if ((unsigned char) p
> *(output
+ x
))
968 *(output
+ x
) -= (unsigned char) p
;
974 frame
->curlinepix
= 0;
975 frame
->grabstate
= FRAME_DONE
;
976 stv680
->framecount
++;
978 if (stv680
->frame
[(stv680
->curframe
+ 1) & (STV680_NUMFRAMES
- 1)].grabstate
== FRAME_READY
) {
979 stv680
->curframe
= (stv680
->curframe
+ 1) & (STV680_NUMFRAMES
- 1);
982 } /* bayer_unshuffle */
984 /******* end routines from the pencam program *********/
986 static int stv680_newframe (struct usb_stv
*stv680
, int framenr
)
990 while (stv680
->streaming
&& (stv680
->frame
[framenr
].grabstate
== FRAME_READY
|| stv680
->frame
[framenr
].grabstate
== FRAME_GRABBING
)) {
991 if (!stv680
->frame
[framenr
].curpix
) {
994 wait_event_interruptible (stv680
->wq
, (stv680
->scratch
[stv680
->scratch_use
].state
== BUFFER_READY
));
996 if (stv680
->nullpackets
> STV680_MAX_NULLPACKETS
) {
997 stv680
->nullpackets
= 0;
998 PDEBUG (2, "STV(i): too many null length packets, restarting capture");
999 stv680_stop_stream (stv680
);
1000 stv680_start_stream (stv680
);
1002 if (stv680
->scratch
[stv680
->scratch_use
].state
!= BUFFER_READY
) {
1003 stv680
->frame
[framenr
].grabstate
= FRAME_ERROR
;
1004 PDEBUG (2, "STV(e): FRAME_ERROR in _newframe");
1007 stv680
->scratch
[stv680
->scratch_use
].state
= BUFFER_BUSY
;
1009 bayer_unshuffle (stv680
, &stv680
->scratch
[stv680
->scratch_use
]);
1011 stv680
->scratch
[stv680
->scratch_use
].state
= BUFFER_UNUSED
;
1012 stv680
->scratch_use
++;
1013 if (stv680
->scratch_use
>= STV680_NUMSCRATCH
)
1014 stv680
->scratch_use
= 0;
1015 if (errors
> STV680_MAX_ERRORS
) {
1017 PDEBUG (2, "STV(i): too many errors, restarting capture");
1018 stv680_stop_stream (stv680
);
1019 stv680_start_stream (stv680
);
1026 /*********************************************************************
1028 *********************************************************************/
1030 static int stv_open (struct inode
*inode
, struct file
*file
)
1032 struct video_device
*dev
= video_devdata(file
);
1033 struct usb_stv
*stv680
= video_get_drvdata(dev
);
1036 /* we are called with the BKL held */
1038 err
= stv_init (stv680
); /* main initialization routine for camera */
1041 stv680
->fbuf
= rvmalloc (stv680
->maxframesize
* STV680_NUMFRAMES
);
1042 if (!stv680
->fbuf
) {
1043 PDEBUG (0, "STV(e): Could not rvmalloc frame bufer");
1046 file
->private_data
= dev
;
1054 static int stv_close (struct inode
*inode
, struct file
*file
)
1056 struct video_device
*dev
= file
->private_data
;
1057 struct usb_stv
*stv680
= video_get_drvdata(dev
);
1060 for (i
= 0; i
< STV680_NUMFRAMES
; i
++)
1061 stv680
->frame
[i
].grabstate
= FRAME_UNUSED
;
1062 if (stv680
->streaming
)
1063 stv680_stop_stream (stv680
);
1065 if ((i
= stv_stop_video (stv680
)) < 0)
1066 PDEBUG (1, "STV(e): stop_video failed in stv_close");
1068 rvfree (stv680
->fbuf
, stv680
->maxframesize
* STV680_NUMFRAMES
);
1071 if (stv680
->removed
) {
1074 PDEBUG (0, "STV(i): device unregistered");
1076 file
->private_data
= NULL
;
1080 static int stv680_do_ioctl (struct inode
*inode
, struct file
*file
,
1081 unsigned int cmd
, void *arg
)
1083 struct video_device
*vdev
= file
->private_data
;
1084 struct usb_stv
*stv680
= video_get_drvdata(vdev
);
1091 struct video_capability
*b
= arg
;
1093 strcpy (b
->name
, stv680
->camera_name
);
1094 b
->type
= VID_TYPE_CAPTURE
;
1097 b
->maxwidth
= stv680
->maxwidth
;
1098 b
->maxheight
= stv680
->maxheight
;
1099 b
->minwidth
= stv680
->maxwidth
/ 2;
1100 b
->minheight
= stv680
->maxheight
/ 2;
1104 struct video_channel
*v
= arg
;
1106 if (v
->channel
!= 0)
1110 v
->type
= VIDEO_TYPE_CAMERA
;
1111 strcpy (v
->name
, "STV Camera");
1115 struct video_channel
*v
= arg
;
1116 if (v
->channel
!= 0)
1121 struct video_picture
*p
= arg
;
1123 stv680_get_pict (stv680
, p
);
1127 struct video_picture
*p
= arg
;
1129 if (stv680_set_pict (stv680
, p
))
1134 struct video_window
*vw
= arg
;
1140 if (vw
->width
!= stv680
->vwidth
) {
1141 if (stv680_set_size (stv680
, vw
->width
, vw
->height
)) {
1142 PDEBUG (2, "STV(e): failed (from user) set size in VIDIOCSWIN");
1149 struct video_window
*vw
= arg
;
1151 vw
->x
= 0; /* FIXME */
1156 vw
->width
= stv680
->vwidth
;
1157 vw
->height
= stv680
->vheight
;
1161 struct video_mbuf
*vm
= arg
;
1164 memset (vm
, 0, sizeof (*vm
));
1165 vm
->size
= STV680_NUMFRAMES
* stv680
->maxframesize
;
1166 vm
->frames
= STV680_NUMFRAMES
;
1167 for (i
= 0; i
< STV680_NUMFRAMES
; i
++)
1168 vm
->offsets
[i
] = stv680
->maxframesize
* i
;
1171 case VIDIOCMCAPTURE
:{
1172 struct video_mmap
*vm
= arg
;
1174 if (vm
->format
!= STV_VIDEO_PALETTE
) {
1175 PDEBUG (2, "STV(i): VIDIOCMCAPTURE vm.format (%i) != VIDEO_PALETTE (%i)",
1176 vm
->format
, STV_VIDEO_PALETTE
);
1177 if ((vm
->format
== 3) && (swapRGB_on
== 0)) {
1178 PDEBUG (2, "STV(i): VIDIOCMCAPTURE swapRGB is (auto) ON");
1179 /* this may fix those apps (e.g., xawtv) that want BGR */
1184 if (vm
->frame
>= STV680_NUMFRAMES
) {
1185 PDEBUG (2, "STV(e): VIDIOCMCAPTURE vm.frame > NUMFRAMES");
1188 if ((stv680
->frame
[vm
->frame
].grabstate
== FRAME_ERROR
)
1189 || (stv680
->frame
[vm
->frame
].grabstate
== FRAME_GRABBING
)) {
1190 PDEBUG (2, "STV(e): VIDIOCMCAPTURE grabstate (%i) error",
1191 stv680
->frame
[vm
->frame
].grabstate
);
1194 /* Is this according to the v4l spec??? */
1195 if (stv680
->vwidth
!= vm
->width
) {
1196 if (stv680_set_size (stv680
, vm
->width
, vm
->height
)) {
1197 PDEBUG (2, "STV(e): VIDIOCMCAPTURE set_size failed");
1201 stv680
->frame
[vm
->frame
].grabstate
= FRAME_READY
;
1203 if (!stv680
->streaming
)
1204 stv680_start_stream (stv680
);
1212 if (*frame
< 0 || *frame
>= STV680_NUMFRAMES
) {
1213 PDEBUG (2, "STV(e): Bad frame # in VIDIOCSYNC");
1216 ret
= stv680_newframe (stv680
, *frame
);
1217 stv680
->frame
[*frame
].grabstate
= FRAME_UNUSED
;
1221 struct video_buffer
*vb
= arg
;
1223 memset (vb
, 0, sizeof (*vb
));
1230 PDEBUG (2, "STV(e): VIDIOCCAPTURE failed");
1242 return -ENOIOCTLCMD
;
1248 static int stv680_ioctl(struct inode
*inode
, struct file
*file
,
1249 unsigned int cmd
, unsigned long arg
)
1251 return video_usercopy(inode
, file
, cmd
, arg
, stv680_do_ioctl
);
1254 static int stv680_mmap (struct file
*file
, struct vm_area_struct
*vma
)
1256 struct video_device
*dev
= file
->private_data
;
1257 struct usb_stv
*stv680
= video_get_drvdata(dev
);
1258 unsigned long start
= vma
->vm_start
;
1259 unsigned long size
= vma
->vm_end
-vma
->vm_start
;
1260 unsigned long page
, pos
;
1262 mutex_lock(&stv680
->lock
);
1264 if (stv680
->udev
== NULL
) {
1265 mutex_unlock(&stv680
->lock
);
1268 if (size
> (((STV680_NUMFRAMES
* stv680
->maxframesize
) + PAGE_SIZE
- 1)
1269 & ~(PAGE_SIZE
- 1))) {
1270 mutex_unlock(&stv680
->lock
);
1273 pos
= (unsigned long) stv680
->fbuf
;
1275 page
= vmalloc_to_pfn((void *)pos
);
1276 if (remap_pfn_range(vma
, start
, page
, PAGE_SIZE
, PAGE_SHARED
)) {
1277 mutex_unlock(&stv680
->lock
);
1282 if (size
> PAGE_SIZE
)
1287 mutex_unlock(&stv680
->lock
);
1292 static ssize_t
stv680_read (struct file
*file
, char __user
*buf
,
1293 size_t count
, loff_t
*ppos
)
1295 struct video_device
*dev
= file
->private_data
;
1296 unsigned long int realcount
= count
;
1298 struct usb_stv
*stv680
= video_get_drvdata(dev
);
1299 unsigned long int i
;
1301 if (STV680_NUMFRAMES
!= 2) {
1302 PDEBUG (0, "STV(e): STV680_NUMFRAMES needs to be 2!");
1305 if (stv680
->udev
== NULL
)
1307 if (realcount
> (stv680
->vwidth
* stv680
->vheight
* 3))
1308 realcount
= stv680
->vwidth
* stv680
->vheight
* 3;
1310 /* Shouldn't happen: */
1311 if (stv680
->frame
[0].grabstate
== FRAME_GRABBING
) {
1312 PDEBUG (2, "STV(e): FRAME_GRABBING in stv680_read");
1315 stv680
->frame
[0].grabstate
= FRAME_READY
;
1316 stv680
->frame
[1].grabstate
= FRAME_UNUSED
;
1317 stv680
->curframe
= 0;
1319 if (!stv680
->streaming
)
1320 stv680_start_stream (stv680
);
1322 if (!stv680
->streaming
) {
1323 ret
= stv680_newframe (stv680
, 0); /* ret should = 0 */
1326 ret
= stv680_newframe (stv680
, 0);
1329 if ((i
= copy_to_user (buf
, stv680
->frame
[0].data
, realcount
)) != 0) {
1330 PDEBUG (2, "STV(e): copy_to_user frame 0 failed, ret count = %li", i
);
1336 stv680
->frame
[0].grabstate
= FRAME_UNUSED
;
1340 static struct file_operations stv680_fops
= {
1341 .owner
= THIS_MODULE
,
1343 .release
= stv_close
,
1344 .read
= stv680_read
,
1345 .mmap
= stv680_mmap
,
1346 .ioctl
= stv680_ioctl
,
1347 .compat_ioctl
= v4l_compat_ioctl32
,
1348 .llseek
= no_llseek
,
1350 static struct video_device stv680_template
= {
1351 .owner
= THIS_MODULE
,
1352 .name
= "STV0680 USB camera",
1353 .type
= VID_TYPE_CAPTURE
,
1354 .hardware
= VID_HARDWARE_SE401
,
1355 .fops
= &stv680_fops
,
1356 .release
= video_device_release
,
1360 static int stv680_probe (struct usb_interface
*intf
, const struct usb_device_id
*id
)
1362 struct usb_device
*dev
= interface_to_usbdev(intf
);
1363 struct usb_host_interface
*interface
;
1364 struct usb_stv
*stv680
= NULL
;
1365 char *camera_name
= NULL
;
1368 /* We don't handle multi-config cameras */
1369 if (dev
->descriptor
.bNumConfigurations
!= 1) {
1370 PDEBUG (0, "STV(e): Number of Configurations != 1");
1374 interface
= &intf
->altsetting
[0];
1375 /* Is it a STV680? */
1376 if ((le16_to_cpu(dev
->descriptor
.idVendor
) == USB_PENCAM_VENDOR_ID
) &&
1377 (le16_to_cpu(dev
->descriptor
.idProduct
) == USB_PENCAM_PRODUCT_ID
)) {
1378 camera_name
= "STV0680";
1379 PDEBUG (0, "STV(i): STV0680 camera found.");
1380 } else if ((le16_to_cpu(dev
->descriptor
.idVendor
) == USB_CREATIVEGOMINI_VENDOR_ID
) &&
1381 (le16_to_cpu(dev
->descriptor
.idProduct
) == USB_CREATIVEGOMINI_PRODUCT_ID
)) {
1382 camera_name
= "Creative WebCam Go Mini";
1383 PDEBUG (0, "STV(i): Creative WebCam Go Mini found.");
1385 PDEBUG (0, "STV(e): Vendor/Product ID do not match STV0680 or Creative WebCam Go Mini values.");
1386 PDEBUG (0, "STV(e): Check that the STV0680 or Creative WebCam Go Mini camera is connected to the computer.");
1391 if ((stv680
= kzalloc (sizeof (*stv680
), GFP_KERNEL
)) == NULL
) {
1392 PDEBUG (0, "STV(e): couldn't kmalloc stv680 struct.");
1398 stv680
->camera_name
= camera_name
;
1400 stv680
->vdev
= video_device_alloc();
1401 if (!stv680
->vdev
) {
1405 memcpy(stv680
->vdev
, &stv680_template
, sizeof(stv680_template
));
1406 stv680
->vdev
->dev
= &intf
->dev
;
1407 video_set_drvdata(stv680
->vdev
, stv680
);
1409 memcpy (stv680
->vdev
->name
, stv680
->camera_name
, strlen (stv680
->camera_name
));
1410 init_waitqueue_head (&stv680
->wq
);
1411 mutex_init (&stv680
->lock
);
1414 if (video_register_device (stv680
->vdev
, VFL_TYPE_GRABBER
, video_nr
) == -1) {
1415 PDEBUG (0, "STV(e): video_register_device failed");
1419 PDEBUG (0, "STV(i): registered new video device: video%d", stv680
->vdev
->minor
);
1421 usb_set_intfdata (intf
, stv680
);
1422 stv680_create_sysfs_files(stv680
->vdev
);
1426 video_device_release(stv680
->vdev
);
1432 static inline void usb_stv680_remove_disconnected (struct usb_stv
*stv680
)
1436 stv680
->udev
= NULL
;
1437 stv680
->frame
[0].grabstate
= FRAME_ERROR
;
1438 stv680
->frame
[1].grabstate
= FRAME_ERROR
;
1439 stv680
->streaming
= 0;
1441 wake_up_interruptible (&stv680
->wq
);
1443 for (i
= 0; i
< STV680_NUMSBUF
; i
++)
1444 if (stv680
->urb
[i
]) {
1445 usb_kill_urb (stv680
->urb
[i
]);
1446 usb_free_urb (stv680
->urb
[i
]);
1447 stv680
->urb
[i
] = NULL
;
1448 kfree(stv680
->sbuf
[i
].data
);
1450 for (i
= 0; i
< STV680_NUMSCRATCH
; i
++)
1451 kfree(stv680
->scratch
[i
].data
);
1452 PDEBUG (0, "STV(i): %s disconnected", stv680
->camera_name
);
1454 /* Free the memory */
1458 static void stv680_disconnect (struct usb_interface
*intf
)
1460 struct usb_stv
*stv680
= usb_get_intfdata (intf
);
1462 usb_set_intfdata (intf
, NULL
);
1465 /* We don't want people trying to open up the device */
1467 stv680_remove_sysfs_files(stv680
->vdev
);
1468 video_unregister_device(stv680
->vdev
);
1469 stv680
->vdev
= NULL
;
1471 if (!stv680
->user
) {
1472 usb_stv680_remove_disconnected (stv680
);
1474 stv680
->removed
= 1;
1479 static struct usb_driver stv680_driver
= {
1481 .probe
= stv680_probe
,
1482 .disconnect
= stv680_disconnect
,
1483 .id_table
= device_table
1486 /********************************************************************
1488 ********************************************************************/
1490 static int __init
usb_stv680_init (void)
1492 if (usb_register (&stv680_driver
) < 0) {
1493 PDEBUG (0, "STV(e): Could not setup STV0680 driver");
1496 PDEBUG (0, "STV(i): usb camera driver version %s registering", DRIVER_VERSION
);
1498 info(DRIVER_DESC
" " DRIVER_VERSION
);
1502 static void __exit
usb_stv680_exit (void)
1504 usb_deregister (&stv680_driver
);
1505 PDEBUG (0, "STV(i): driver deregistered");
1508 module_init (usb_stv680_init
);
1509 module_exit (usb_stv680_exit
);