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/module.h>
62 #include <linux/init.h>
63 #include <linux/vmalloc.h>
64 #include <linux/slab.h>
65 #include <linux/pagemap.h>
66 #include <linux/errno.h>
67 #include <linux/videodev.h>
68 #include <media/v4l2-common.h>
69 #include <media/v4l2-ioctl.h>
70 #include <linux/usb.h>
71 #include <linux/mutex.h>
75 static int video_nr
= -1;
77 static int swapRGB
; /* 0 = default for auto select */
79 /* 0 = default to allow auto select; -1 = swap never, +1 = swap always */
80 static int swapRGB_on
;
82 static unsigned int debug
;
84 #define PDEBUG(level, fmt, args...) \
87 info("[%s:%d] " fmt, __func__, __LINE__ , ## args); \
94 #define DRIVER_VERSION "v0.25"
95 #define DRIVER_AUTHOR "Kevin Sisson <kjsisson@bellsouth.net>"
96 #define DRIVER_DESC "STV0680 USB Camera Driver"
98 MODULE_AUTHOR (DRIVER_AUTHOR
);
99 MODULE_DESCRIPTION (DRIVER_DESC
);
100 MODULE_LICENSE ("GPL");
101 module_param(debug
, int, S_IRUGO
| S_IWUSR
);
102 MODULE_PARM_DESC (debug
, "Debug enabled or not");
103 module_param(swapRGB_on
, int, 0);
104 MODULE_PARM_DESC (swapRGB_on
, "Red/blue swap: 1=always, 0=auto, -1=never");
105 module_param(video_nr
, int, 0);
107 /********************************************************************
111 * This is a shameless copy from the USB-cpia driver (linux kernel
112 * version 2.3.29 or so, I have no idea what this code actually does ;).
113 * Actually it seems to be a copy of a shameless copy of the bttv-driver.
114 * Or that is a copy of a shameless copy of ... (To the powers: is there
115 * no generic kernel-function to do this sort of stuff?)
117 * Yes, it was a shameless copy from the bttv-driver. IIRC, Alan says
118 * there will be one, but apparentely not yet -jerdfelt
120 * So I copied it again for the ov511 driver -claudio
122 * Same for the se401 driver -Jeroen
124 * And the STV0680 driver - Kevin
125 ********************************************************************/
126 static void *rvmalloc (unsigned long size
)
131 size
= PAGE_ALIGN(size
);
132 mem
= vmalloc_32 (size
);
136 memset (mem
, 0, size
); /* Clear the ram out, no junk to the user */
137 adr
= (unsigned long) mem
;
139 SetPageReserved(vmalloc_to_page((void *)adr
));
146 static void rvfree (void *mem
, unsigned long size
)
153 adr
= (unsigned long) mem
;
154 while ((long) size
> 0) {
155 ClearPageReserved(vmalloc_to_page((void *)adr
));
163 /*********************************************************************
164 * pencam read/write functions
165 ********************************************************************/
167 static int stv_sndctrl (int set
, struct usb_stv
*stv680
, unsigned short req
, unsigned short value
, unsigned char *buffer
, int size
)
173 ret
= usb_control_msg (stv680
->udev
,
174 usb_rcvctrlpipe (stv680
->udev
, 0),
176 (USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
),
177 value
, 0, buffer
, size
, PENCAM_TIMEOUT
);
181 ret
= usb_control_msg (stv680
->udev
,
182 usb_sndctrlpipe (stv680
->udev
, 0),
184 (USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
),
185 value
, 0, buffer
, size
, PENCAM_TIMEOUT
);
189 ret
= usb_control_msg (stv680
->udev
,
190 usb_rcvctrlpipe (stv680
->udev
, 0),
192 (USB_DIR_IN
| USB_RECIP_DEVICE
),
193 value
, 0, buffer
, size
, PENCAM_TIMEOUT
);
197 ret
= usb_control_msg (stv680
->udev
,
198 usb_sndctrlpipe (stv680
->udev
, 0),
200 (USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
),
201 value
, 0, buffer
, size
, PENCAM_TIMEOUT
);
205 if ((ret
< 0) && (req
!= 0x0a)) {
206 PDEBUG (1, "STV(e): usb_control_msg error %i, request = 0x%x, error = %i", set
, req
, ret
);
211 static int stv_set_config (struct usb_stv
*dev
, int configuration
, int interface
, int alternate
)
214 if (configuration
!= dev
->udev
->actconfig
->desc
.bConfigurationValue
215 || usb_reset_configuration (dev
->udev
) < 0) {
216 PDEBUG (1, "STV(e): FAILED to reset configuration %i", configuration
);
219 if (usb_set_interface (dev
->udev
, interface
, alternate
) < 0) {
220 PDEBUG (1, "STV(e): FAILED to set alternate interface %i", alternate
);
226 static int stv_stop_video (struct usb_stv
*dev
)
231 buf
= kmalloc (40, GFP_KERNEL
);
233 PDEBUG (0, "STV(e): Out of (small buf) memory");
237 /* this is a high priority command; it stops all lower order commands */
238 if ((i
= stv_sndctrl (1, dev
, 0x04, 0x0000, buf
, 0x0)) < 0) {
239 i
= stv_sndctrl (0, dev
, 0x80, 0, buf
, 0x02); /* Get Last Error; 2 = busy */
240 PDEBUG (1, "STV(i): last error: %i, command = 0x%x", buf
[0], buf
[1]);
242 PDEBUG (1, "STV(i): Camera reset to idle mode.");
245 if ((i
= stv_set_config (dev
, 1, 0, 0)) < 0)
246 PDEBUG (1, "STV(e): Reset config during exit failed");
248 /* get current mode */
250 if ((i
= stv_sndctrl (0, dev
, 0x87, 0, buf
, 0x08)) != 0x08) /* get mode */
251 PDEBUG (0, "STV(e): Stop_video: problem setting original mode");
252 if (dev
->origMode
!= buf
[0]) {
254 buf
[0] = (unsigned char) dev
->origMode
;
255 if ((i
= stv_sndctrl (3, dev
, 0x07, 0x0100, buf
, 0x08)) != 0x08) {
256 PDEBUG (0, "STV(e): Stop_video: Set_Camera_Mode failed");
260 i
= stv_sndctrl (0, dev
, 0x87, 0, buf
, 0x08);
261 if ((i
!= 0x08) || (buf
[0] != dev
->origMode
)) {
262 PDEBUG (0, "STV(e): camera NOT set to original resolution.");
265 PDEBUG (0, "STV(i): Camera set to original resolution");
272 static int stv_set_video_mode (struct usb_stv
*dev
)
274 int i
, stop_video
= 1;
277 buf
= kmalloc (40, GFP_KERNEL
);
279 PDEBUG (0, "STV(e): Out of (small buf) memory");
283 if ((i
= stv_set_config (dev
, 1, 0, 0)) < 0) {
288 i
= stv_sndctrl (2, dev
, 0x06, 0x0100, buf
, 0x12);
289 if (!(i
> 0) && (buf
[8] == 0x53) && (buf
[9] == 0x05)) {
290 PDEBUG (1, "STV(e): Could not get descriptor 0100.");
294 /* set alternate interface 1 */
295 if ((i
= stv_set_config (dev
, 1, 0, 1)) < 0)
298 if ((i
= stv_sndctrl (0, dev
, 0x85, 0, buf
, 0x10)) != 0x10)
300 PDEBUG (1, "STV(i): Setting video mode.");
301 /* Switch to Video mode: 0x0100 = VGA (640x480), 0x0000 = CIF (352x288) 0x0300 = QVGA (320x240) */
302 if ((i
= stv_sndctrl (1, dev
, 0x09, dev
->VideoMode
, buf
, 0x0)) < 0) {
311 stv_stop_video (dev
);
319 static int stv_init (struct usb_stv
*stv680
)
322 unsigned char *buffer
;
323 unsigned long int bufsize
;
325 buffer
= kzalloc (40, GFP_KERNEL
);
326 if (buffer
== NULL
) {
327 PDEBUG (0, "STV(e): Out of (small buf) memory");
332 /* set config 1, interface 0, alternate 0 */
333 if ((i
= stv_set_config (stv680
, 1, 0, 0)) < 0) {
335 PDEBUG (0, "STV(e): set config 1,0,0 failed");
338 /* ping camera to be sure STV0680 is present */
339 if ((i
= stv_sndctrl (0, stv680
, 0x88, 0x5678, buffer
, 0x02)) != 0x02)
341 if ((buffer
[0] != 0x56) || (buffer
[1] != 0x78)) {
342 PDEBUG (1, "STV(e): camera ping failed!!");
346 /* get camera descriptor */
347 if ((i
= stv_sndctrl (2, stv680
, 0x06, 0x0200, buffer
, 0x09)) != 0x09)
349 i
= stv_sndctrl (2, stv680
, 0x06, 0x0200, buffer
, 0x22);
350 if (!(i
>= 0) && (buffer
[7] == 0xa0) && (buffer
[8] == 0x23)) {
351 PDEBUG (1, "STV(e): Could not get descriptor 0200.");
354 if ((i
= stv_sndctrl (0, stv680
, 0x8a, 0, buffer
, 0x02)) != 0x02)
356 if ((i
= stv_sndctrl (0, stv680
, 0x8b, 0, buffer
, 0x24)) != 0x24)
358 if ((i
= stv_sndctrl (0, stv680
, 0x85, 0, buffer
, 0x10)) != 0x10)
361 stv680
->SupportedModes
= buffer
[7];
362 i
= stv680
->SupportedModes
;
372 if (stv680
->SupportedModes
== 0) {
373 PDEBUG (0, "STV(e): There are NO supported STV680 modes!!");
378 PDEBUG (0, "STV(i): CIF is supported");
380 PDEBUG (0, "STV(i): QVGA is supported");
382 /* FW rev, ASIC rev, sensor ID */
383 PDEBUG (1, "STV(i): Firmware rev is %i.%i", buffer
[0], buffer
[1]);
384 PDEBUG (1, "STV(i): ASIC rev is %i.%i", buffer
[2], buffer
[3]);
385 PDEBUG (1, "STV(i): Sensor ID is %i", (buffer
[4]*16) + (buffer
[5]>>4));
387 /* set alternate interface 1 */
388 if ((i
= stv_set_config (stv680
, 1, 0, 1)) < 0)
391 if ((i
= stv_sndctrl (0, stv680
, 0x85, 0, buffer
, 0x10)) != 0x10)
393 if ((i
= stv_sndctrl (0, stv680
, 0x8d, 0, buffer
, 0x08)) != 0x08)
396 PDEBUG (0, "STV(i): Camera has %i pictures.", i
);
398 /* get current mode */
399 if ((i
= stv_sndctrl (0, stv680
, 0x87, 0, buffer
, 0x08)) != 0x08)
401 stv680
->origMode
= buffer
[0]; /* 01 = VGA, 03 = QVGA, 00 = CIF */
403 /* This will attemp CIF mode, if supported. If not, set to QVGA */
404 memset (buffer
, 0, 8);
407 else if (stv680
->QVGA
)
409 if ((i
= stv_sndctrl (3, stv680
, 0x07, 0x0100, buffer
, 0x08)) != 0x08) {
410 PDEBUG (0, "STV(i): Set_Camera_Mode failed");
415 stv_sndctrl (0, stv680
, 0x87, 0, buffer
, 0x08);
416 if (((stv680
->CIF
== 1) && (buffer
[0] != 0x00)) || ((stv680
->QVGA
== 1) && (buffer
[0] != 0x03))) {
417 PDEBUG (0, "STV(e): Error setting camera video mode!");
421 if (buffer
[0] == 0) {
422 stv680
->VideoMode
= 0x0000;
423 PDEBUG (0, "STV(i): Video Mode set to CIF");
425 if (buffer
[0] == 0x03) {
426 stv680
->VideoMode
= 0x0300;
427 PDEBUG (0, "STV(i): Video Mode set to QVGA");
430 if ((i
= stv_sndctrl (0, stv680
, 0x8f, 0, buffer
, 0x10)) != 0x10)
432 bufsize
= (buffer
[0] << 24) | (buffer
[1] << 16) | (buffer
[2] << 8) | (buffer
[3]);
433 stv680
->cwidth
= (buffer
[4] << 8) | (buffer
[5]); /* ->camera = 322, 356, 644 */
434 stv680
->cheight
= (buffer
[6] << 8) | (buffer
[7]); /* ->camera = 242, 292, 484 */
435 stv680
->origGain
= buffer
[12];
440 i
= stv_sndctrl (0, stv680
, 0x80, 0, buffer
, 0x02); /* Get Last Error */
441 PDEBUG (1, "STV(i): last error: %i, command = 0x%x", buffer
[0], buffer
[1]);
448 /* video = 320x240, 352x288 */
449 if (stv680
->CIF
== 1) {
450 stv680
->maxwidth
= 352;
451 stv680
->maxheight
= 288;
452 stv680
->vwidth
= 352;
453 stv680
->vheight
= 288;
455 if (stv680
->QVGA
== 1) {
456 stv680
->maxwidth
= 320;
457 stv680
->maxheight
= 240;
458 stv680
->vwidth
= 320;
459 stv680
->vheight
= 240;
462 stv680
->rawbufsize
= bufsize
; /* must be ./. by 8 */
463 stv680
->maxframesize
= bufsize
* 3; /* RGB size */
464 PDEBUG (2, "STV(i): cwidth = %i, cheight = %i", stv680
->cwidth
, stv680
->cheight
);
465 PDEBUG (1, "STV(i): width = %i, height = %i, rawbufsize = %li", stv680
->vwidth
, stv680
->vheight
, stv680
->rawbufsize
);
467 /* some default values */
468 stv680
->bulk_in_endpointAddr
= 0x82;
471 stv680
->framecount
= 0;
472 stv680
->readcount
= 0;
473 stv680
->streaming
= 0;
474 /* bright, white, colour, hue, contrast are set by software, not in stv0680 */
475 stv680
->brightness
= 32767;
476 stv680
->chgbright
= 0;
477 stv680
->whiteness
= 0; /* only for greyscale */
478 stv680
->colour
= 32767;
479 stv680
->contrast
= 32767;
481 stv680
->palette
= STV_VIDEO_PALETTE
;
482 stv680
->depth
= 24; /* rgb24 bits */
483 if ((swapRGB_on
== 0) && (swapRGB
== 0))
484 PDEBUG (1, "STV(i): swapRGB is (auto) OFF");
485 else if ((swapRGB_on
== 0) && (swapRGB
== 1))
486 PDEBUG (1, "STV(i): swapRGB is (auto) ON");
487 else if (swapRGB_on
== 1)
488 PDEBUG (1, "STV(i): swapRGB is (forced) ON");
489 else if (swapRGB_on
== -1)
490 PDEBUG (1, "STV(i): swapRGB is (forced) OFF");
492 if (stv_set_video_mode (stv680
) < 0) {
493 PDEBUG (0, "STV(e): Could not set video mode in stv_init");
500 /***************** last of pencam routines *******************/
502 /****************************************************************************
504 ***************************************************************************/
505 #define stv680_file(name, variable, field) \
506 static ssize_t show_##name(struct device *class_dev, \
507 struct device_attribute *attr, char *buf) \
509 struct video_device *vdev = to_video_device(class_dev); \
510 struct usb_stv *stv = video_get_drvdata(vdev); \
511 return sprintf(buf, field, stv->variable); \
513 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
515 stv680_file(model
, camera_name
, "%s\n");
516 stv680_file(in_use
, user
, "%d\n");
517 stv680_file(streaming
, streaming
, "%d\n");
518 stv680_file(palette
, palette
, "%i\n");
519 stv680_file(frames_total
, readcount
, "%d\n");
520 stv680_file(frames_read
, framecount
, "%d\n");
521 stv680_file(packets_dropped
, dropped
, "%d\n");
522 stv680_file(decoding_errors
, error
, "%d\n");
524 static int stv680_create_sysfs_files(struct video_device
*vdev
)
528 rc
= device_create_file(&vdev
->dev
, &dev_attr_model
);
530 rc
= device_create_file(&vdev
->dev
, &dev_attr_in_use
);
531 if (rc
) goto err_model
;
532 rc
= device_create_file(&vdev
->dev
, &dev_attr_streaming
);
533 if (rc
) goto err_inuse
;
534 rc
= device_create_file(&vdev
->dev
, &dev_attr_palette
);
535 if (rc
) goto err_stream
;
536 rc
= device_create_file(&vdev
->dev
, &dev_attr_frames_total
);
537 if (rc
) goto err_pal
;
538 rc
= device_create_file(&vdev
->dev
, &dev_attr_frames_read
);
539 if (rc
) goto err_framtot
;
540 rc
= device_create_file(&vdev
->dev
, &dev_attr_packets_dropped
);
541 if (rc
) goto err_framread
;
542 rc
= device_create_file(&vdev
->dev
, &dev_attr_decoding_errors
);
543 if (rc
) goto err_dropped
;
548 device_remove_file(&vdev
->dev
, &dev_attr_packets_dropped
);
550 device_remove_file(&vdev
->dev
, &dev_attr_frames_read
);
552 device_remove_file(&vdev
->dev
, &dev_attr_frames_total
);
554 device_remove_file(&vdev
->dev
, &dev_attr_palette
);
556 device_remove_file(&vdev
->dev
, &dev_attr_streaming
);
558 device_remove_file(&vdev
->dev
, &dev_attr_in_use
);
560 device_remove_file(&vdev
->dev
, &dev_attr_model
);
562 PDEBUG(0, "STV(e): Could not create sysfs files");
566 static void stv680_remove_sysfs_files(struct video_device
*vdev
)
568 device_remove_file(&vdev
->dev
, &dev_attr_model
);
569 device_remove_file(&vdev
->dev
, &dev_attr_in_use
);
570 device_remove_file(&vdev
->dev
, &dev_attr_streaming
);
571 device_remove_file(&vdev
->dev
, &dev_attr_palette
);
572 device_remove_file(&vdev
->dev
, &dev_attr_frames_total
);
573 device_remove_file(&vdev
->dev
, &dev_attr_frames_read
);
574 device_remove_file(&vdev
->dev
, &dev_attr_packets_dropped
);
575 device_remove_file(&vdev
->dev
, &dev_attr_decoding_errors
);
578 /********************************************************************
580 *******************************************************************/
582 static int stv680_get_pict (struct usb_stv
*stv680
, struct video_picture
*p
)
584 /* This sets values for v4l interface. max/min = 65535/0 */
586 p
->brightness
= stv680
->brightness
;
587 p
->whiteness
= stv680
->whiteness
; /* greyscale */
588 p
->colour
= stv680
->colour
;
589 p
->contrast
= stv680
->contrast
;
590 p
->hue
= stv680
->hue
;
591 p
->palette
= stv680
->palette
;
592 p
->depth
= stv680
->depth
;
596 static int stv680_set_pict (struct usb_stv
*stv680
, struct video_picture
*p
)
598 /* See above stv680_get_pict */
600 if (p
->palette
!= STV_VIDEO_PALETTE
) {
601 PDEBUG (2, "STV(e): Palette set error in _set_pic");
605 if (stv680
->brightness
!= p
->brightness
) {
606 stv680
->chgbright
= 1;
607 stv680
->brightness
= p
->brightness
;
610 stv680
->whiteness
= p
->whiteness
; /* greyscale */
611 stv680
->colour
= p
->colour
;
612 stv680
->contrast
= p
->contrast
;
613 stv680
->hue
= p
->hue
;
614 stv680
->palette
= p
->palette
;
615 stv680
->depth
= p
->depth
;
620 static void stv680_video_irq (struct urb
*urb
)
622 struct usb_stv
*stv680
= urb
->context
;
623 int length
= urb
->actual_length
;
625 if (length
< stv680
->rawbufsize
)
626 PDEBUG (2, "STV(i): Lost data in transfer: exp %li, got %i", stv680
->rawbufsize
, length
);
629 if (!stv680
->streaming
)
633 PDEBUG (0, "STV(e): device vapourished in video_irq");
637 /* 0 sized packets happen if we are to fast, but sometimes the camera
638 keeps sending them forever...
640 if (length
&& !urb
->status
) {
641 stv680
->nullpackets
= 0;
642 switch (stv680
->scratch
[stv680
->scratch_next
].state
) {
649 memcpy (stv680
->scratch
[stv680
->scratch_next
].data
,
650 (unsigned char *) urb
->transfer_buffer
, length
);
651 stv680
->scratch
[stv680
->scratch_next
].state
= BUFFER_READY
;
652 stv680
->scratch
[stv680
->scratch_next
].length
= length
;
653 if (waitqueue_active (&stv680
->wq
)) {
654 wake_up_interruptible (&stv680
->wq
);
656 stv680
->scratch_overflow
= 0;
657 stv680
->scratch_next
++;
658 if (stv680
->scratch_next
>= STV680_NUMSCRATCH
)
659 stv680
->scratch_next
= 0;
663 stv680
->nullpackets
++;
664 if (stv680
->nullpackets
> STV680_MAX_NULLPACKETS
) {
665 if (waitqueue_active (&stv680
->wq
)) {
666 wake_up_interruptible (&stv680
->wq
);
671 /* Resubmit urb for new data */
673 urb
->dev
= stv680
->udev
;
674 if (usb_submit_urb (urb
, GFP_ATOMIC
))
675 PDEBUG (0, "STV(e): urb burned down in video irq");
679 static int stv680_start_stream (struct usb_stv
*stv680
)
684 stv680
->streaming
= 1;
686 /* Do some memory allocation */
687 for (i
= 0; i
< STV680_NUMFRAMES
; i
++) {
688 stv680
->frame
[i
].data
= stv680
->fbuf
+ i
* stv680
->maxframesize
;
689 stv680
->frame
[i
].curpix
= 0;
691 /* packet size = 4096 */
692 for (i
= 0; i
< STV680_NUMSBUF
; i
++) {
693 stv680
->sbuf
[i
].data
= kmalloc (stv680
->rawbufsize
, GFP_KERNEL
);
694 if (stv680
->sbuf
[i
].data
== NULL
) {
695 PDEBUG (0, "STV(e): Could not kmalloc raw data buffer %i", i
);
700 stv680
->scratch_next
= 0;
701 stv680
->scratch_use
= 0;
702 stv680
->scratch_overflow
= 0;
703 for (i
= 0; i
< STV680_NUMSCRATCH
; i
++) {
704 stv680
->scratch
[i
].data
= kmalloc (stv680
->rawbufsize
, GFP_KERNEL
);
705 if (stv680
->scratch
[i
].data
== NULL
) {
706 PDEBUG (0, "STV(e): Could not kmalloc raw scratch buffer %i", i
);
709 stv680
->scratch
[i
].state
= BUFFER_UNUSED
;
712 for (i
= 0; i
< STV680_NUMSBUF
; i
++) {
713 urb
= usb_alloc_urb (0, GFP_KERNEL
);
717 /* sbuf is urb->transfer_buffer, later gets memcpyed to scratch */
718 usb_fill_bulk_urb (urb
, stv680
->udev
,
719 usb_rcvbulkpipe (stv680
->udev
, stv680
->bulk_in_endpointAddr
),
720 stv680
->sbuf
[i
].data
, stv680
->rawbufsize
,
721 stv680_video_irq
, stv680
);
722 stv680
->urb
[i
] = urb
;
723 err
= usb_submit_urb (stv680
->urb
[i
], GFP_KERNEL
);
725 PDEBUG (0, "STV(e): urb burned down with err "
726 "%d in start stream %d", err
, i
);
729 } /* i STV680_NUMSBUF */
731 stv680
->framecount
= 0;
735 for (i
= 0; i
< STV680_NUMSCRATCH
; i
++) {
736 kfree(stv680
->scratch
[i
].data
);
737 stv680
->scratch
[i
].data
= NULL
;
739 for (i
= 0; i
< STV680_NUMSBUF
; i
++) {
740 usb_kill_urb(stv680
->urb
[i
]);
741 usb_free_urb(stv680
->urb
[i
]);
742 stv680
->urb
[i
] = NULL
;
743 kfree(stv680
->sbuf
[i
].data
);
744 stv680
->sbuf
[i
].data
= NULL
;
750 static int stv680_stop_stream (struct usb_stv
*stv680
)
754 if (!stv680
->streaming
|| !stv680
->udev
)
757 stv680
->streaming
= 0;
759 for (i
= 0; i
< STV680_NUMSBUF
; i
++)
760 if (stv680
->urb
[i
]) {
761 usb_kill_urb (stv680
->urb
[i
]);
762 usb_free_urb (stv680
->urb
[i
]);
763 stv680
->urb
[i
] = NULL
;
764 kfree(stv680
->sbuf
[i
].data
);
766 for (i
= 0; i
< STV680_NUMSCRATCH
; i
++) {
767 kfree(stv680
->scratch
[i
].data
);
768 stv680
->scratch
[i
].data
= NULL
;
774 static int stv680_set_size (struct usb_stv
*stv680
, int width
, int height
)
776 int wasstreaming
= stv680
->streaming
;
778 /* Check to see if we need to change */
779 if ((stv680
->vwidth
== width
) && (stv680
->vheight
== height
))
782 PDEBUG (1, "STV(i): size request for %i x %i", width
, height
);
783 /* Check for a valid mode */
784 if ((!width
|| !height
) || ((width
& 1) || (height
& 1))) {
785 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
);
789 if ((width
< (stv680
->maxwidth
/ 2)) || (height
< (stv680
->maxheight
/ 2))) {
790 width
= stv680
->maxwidth
/ 2;
791 height
= stv680
->maxheight
/ 2;
792 } else if ((width
>= 158) && (width
<= 166) && (stv680
->QVGA
== 1)) {
795 } else if ((width
>= 172) && (width
<= 180) && (stv680
->CIF
== 1)) {
798 } else if ((width
>= 318) && (width
<= 350) && (stv680
->QVGA
== 1)) {
801 } else if ((width
>= 350) && (width
<= 358) && (stv680
->CIF
== 1)) {
805 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
);
809 /* Stop a current stream and start it again at the new size */
811 stv680_stop_stream (stv680
);
812 stv680
->vwidth
= width
;
813 stv680
->vheight
= height
;
814 PDEBUG (1, "STV(i): size set to %i x %i", stv680
->vwidth
, stv680
->vheight
);
816 stv680_start_stream (stv680
);
821 /**********************************************************************
823 **********************************************************************/
825 /******* routines from the pencam program; hey, they work! ********/
828 * STV0680 Vision Camera Chipset Driver
829 * Copyright (C) 2000 Adam Harrison <adam@antispin.org>
835 #define AD(x, y, w) (((y)*(w)+(x))*3)
837 static void bayer_unshuffle (struct usb_stv
*stv680
, struct stv680_scratch
*buffer
)
840 int w
= stv680
->cwidth
;
841 int vw
= stv680
->cwidth
, vh
= stv680
->cheight
;
843 int colour
= 0, bayer
= 0;
844 unsigned char *raw
= buffer
->data
;
845 struct stv680_frame
*frame
= &stv680
->frame
[stv680
->curframe
];
846 unsigned char *output
= frame
->data
;
847 unsigned char *temp
= frame
->data
;
848 int offset
= buffer
->offset
;
850 if (frame
->curpix
== 0) {
851 if (frame
->grabstate
== FRAME_READY
) {
852 frame
->grabstate
= FRAME_GRABBING
;
855 if (offset
!= frame
->curpix
) { /* Regard frame as lost :( */
861 if ((stv680
->vwidth
== 320) || (stv680
->vwidth
== 160)) {
865 if ((stv680
->vwidth
== 352) || (stv680
->vwidth
== 176)) {
870 memset (output
, 0, 3 * vw
* vh
); /* clear output matrix. */
872 for (y
= 0; y
< vh
; y
++) {
873 for (x
= 0; x
< vw
; x
++) {
875 p
= *(raw
+ y
* w
+ (x
>> 1));
877 p
= *(raw
+ y
* w
+ (x
>> 1) + (w
>> 1));
898 i
= (y
* vw
+ x
) * 3;
899 *(output
+ i
+ colour
) = (unsigned char) p
;
904 /****** gamma correction plus hardcoded white balance */
905 /* Thanks to Alexander Schwartx <alexander.schwartx@gmx.net> for this code.
906 Correction values red[], green[], blue[], are generated by
907 (pow(i/256.0, GAMMA)*255.0)*white balanceRGB where GAMMA=0.55, 1<i<255.
908 White balance (RGB)= 1.0, 1.17, 1.48. Values are calculated as double float and
909 converted to unsigned char. Values are in stv680.h */
911 for (y
= 0; y
< vh
; y
++) {
912 for (x
= 0; x
< vw
; x
++) {
913 i
= (y
* vw
+ x
) * 3;
914 *(output
+ i
) = red
[*(output
+ i
)];
915 *(output
+ i
+ 1) = green
[*(output
+ i
+ 1)];
916 *(output
+ i
+ 2) = blue
[*(output
+ i
+ 2)];
920 /****** bayer demosaic ******/
921 for (y
= 1; y
< (vh
- 1); y
++) {
922 for (x
= 1; x
< (vw
- 1); x
++) { /* work out pixel type */
931 case 0: /* green. blue lr, red tb */
932 *(output
+ AD (x
, y
, vw
) + BLUE
) = ((int) *(output
+ AD (x
- 1, y
, vw
) + BLUE
) + (int) *(output
+ AD (x
+ 1, y
, vw
) + BLUE
)) >> 1;
933 *(output
+ AD (x
, y
, vw
) + RED
) = ((int) *(output
+ AD (x
, y
- 1, vw
) + RED
) + (int) *(output
+ AD (x
, y
+ 1, vw
) + RED
)) >> 1;
936 case 1: /* blue. green lrtb, red diagonals */
937 *(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;
938 *(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;
941 case 2: /* red. green lrtb, blue diagonals */
942 *(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;
943 *(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;
946 case 3: /* green. red lr, blue tb */
947 *(output
+ AD (x
, y
, vw
) + RED
) = ((int) *(output
+ AD (x
- 1, y
, vw
) + RED
) + (int) *(output
+ AD (x
+ 1, y
, vw
) + RED
)) >> 1;
948 *(output
+ AD (x
, y
, vw
) + BLUE
) = ((int) *(output
+ AD (x
, y
- 1, vw
) + BLUE
) + (int) *(output
+ AD (x
, y
+ 1, vw
) + BLUE
)) >> 1;
952 } /* for y - end demosaic */
954 /* fix top and bottom row, left and right side */
956 memcpy (output
, (output
+ i
), i
);
957 memcpy ((output
+ (vh
* i
)), (output
+ ((vh
- 1) * i
)), i
);
958 for (y
= 0; y
< vh
; y
++) {
960 memcpy ((output
+ i
), (output
+ i
+ 3), 3);
961 memcpy ((output
+ i
+ (vw
* 3)), (output
+ i
+ (vw
- 1) * 3), 3);
964 /* process all raw data, then trim to size if necessary */
965 if ((stv680
->vwidth
== 160) || (stv680
->vwidth
== 176)) {
967 for (y
= 0; y
< vh
; y
++) {
969 for (x
= 0; x
< vw
; x
++) {
970 p
= (y
* vw
+ x
) * 3;
972 *(output
+ i
) = *(output
+ p
);
973 *(output
+ i
+ 1) = *(output
+ p
+ 1);
974 *(output
+ i
+ 2) = *(output
+ p
+ 2);
981 /* reset to proper width */
982 if ((stv680
->vwidth
== 160)) {
986 if ((stv680
->vwidth
== 176)) {
991 /* output is RGB; some programs want BGR */
992 /* swapRGB_on=0 -> program decides; swapRGB_on=1, always swap */
993 /* swapRGB_on=-1, never swap */
994 if (((swapRGB
== 1) && (swapRGB_on
!= -1)) || (swapRGB_on
== 1)) {
995 for (y
= 0; y
< vh
; y
++) {
996 for (x
= 0; x
< vw
; x
++) {
997 i
= (y
* vw
+ x
) * 3;
998 *(temp
) = *(output
+ i
);
999 *(output
+ i
) = *(output
+ i
+ 2);
1000 *(output
+ i
+ 2) = *(temp
);
1005 if (stv680
->chgbright
== 1) {
1006 if (stv680
->brightness
>= 32767) {
1007 p
= (stv680
->brightness
- 32767) / 256;
1008 for (x
= 0; x
< (vw
* vh
* 3); x
++) {
1009 if ((*(output
+ x
) + (unsigned char) p
) > 255)
1010 *(output
+ x
) = 255;
1012 *(output
+ x
) += (unsigned char) p
;
1015 p
= (32767 - stv680
->brightness
) / 256;
1016 for (x
= 0; x
< (vw
* vh
* 3); x
++) {
1017 if ((unsigned char) p
> *(output
+ x
))
1020 *(output
+ x
) -= (unsigned char) p
;
1026 frame
->curlinepix
= 0;
1027 frame
->grabstate
= FRAME_DONE
;
1028 stv680
->framecount
++;
1029 stv680
->readcount
++;
1030 if (stv680
->frame
[(stv680
->curframe
+ 1) & (STV680_NUMFRAMES
- 1)].grabstate
== FRAME_READY
) {
1031 stv680
->curframe
= (stv680
->curframe
+ 1) & (STV680_NUMFRAMES
- 1);
1034 } /* bayer_unshuffle */
1036 /******* end routines from the pencam program *********/
1038 static int stv680_newframe (struct usb_stv
*stv680
, int framenr
)
1042 while (stv680
->streaming
&& (stv680
->frame
[framenr
].grabstate
== FRAME_READY
|| stv680
->frame
[framenr
].grabstate
== FRAME_GRABBING
)) {
1043 if (!stv680
->frame
[framenr
].curpix
) {
1046 wait_event_interruptible (stv680
->wq
, (stv680
->scratch
[stv680
->scratch_use
].state
== BUFFER_READY
));
1048 if (stv680
->nullpackets
> STV680_MAX_NULLPACKETS
) {
1049 stv680
->nullpackets
= 0;
1050 PDEBUG (2, "STV(i): too many null length packets, restarting capture");
1051 stv680_stop_stream (stv680
);
1052 stv680_start_stream (stv680
);
1054 if (stv680
->scratch
[stv680
->scratch_use
].state
!= BUFFER_READY
) {
1055 stv680
->frame
[framenr
].grabstate
= FRAME_ERROR
;
1056 PDEBUG (2, "STV(e): FRAME_ERROR in _newframe");
1059 stv680
->scratch
[stv680
->scratch_use
].state
= BUFFER_BUSY
;
1061 bayer_unshuffle (stv680
, &stv680
->scratch
[stv680
->scratch_use
]);
1063 stv680
->scratch
[stv680
->scratch_use
].state
= BUFFER_UNUSED
;
1064 stv680
->scratch_use
++;
1065 if (stv680
->scratch_use
>= STV680_NUMSCRATCH
)
1066 stv680
->scratch_use
= 0;
1067 if (errors
> STV680_MAX_ERRORS
) {
1069 PDEBUG (2, "STV(i): too many errors, restarting capture");
1070 stv680_stop_stream (stv680
);
1071 stv680_start_stream (stv680
);
1078 /*********************************************************************
1080 *********************************************************************/
1082 static int stv_open (struct inode
*inode
, struct file
*file
)
1084 struct video_device
*dev
= video_devdata(file
);
1085 struct usb_stv
*stv680
= video_get_drvdata(dev
);
1088 /* we are called with the BKL held */
1090 err
= stv_init (stv680
); /* main initialization routine for camera */
1093 stv680
->fbuf
= rvmalloc (stv680
->maxframesize
* STV680_NUMFRAMES
);
1094 if (!stv680
->fbuf
) {
1095 PDEBUG (0, "STV(e): Could not rvmalloc frame bufer");
1098 file
->private_data
= dev
;
1106 static int stv_close (struct inode
*inode
, struct file
*file
)
1108 struct video_device
*dev
= file
->private_data
;
1109 struct usb_stv
*stv680
= video_get_drvdata(dev
);
1112 for (i
= 0; i
< STV680_NUMFRAMES
; i
++)
1113 stv680
->frame
[i
].grabstate
= FRAME_UNUSED
;
1114 if (stv680
->streaming
)
1115 stv680_stop_stream (stv680
);
1117 if ((i
= stv_stop_video (stv680
)) < 0)
1118 PDEBUG (1, "STV(e): stop_video failed in stv_close");
1120 rvfree (stv680
->fbuf
, stv680
->maxframesize
* STV680_NUMFRAMES
);
1123 if (stv680
->removed
) {
1126 PDEBUG (0, "STV(i): device unregistered");
1128 file
->private_data
= NULL
;
1132 static int stv680_do_ioctl (struct inode
*inode
, struct file
*file
,
1133 unsigned int cmd
, void *arg
)
1135 struct video_device
*vdev
= file
->private_data
;
1136 struct usb_stv
*stv680
= video_get_drvdata(vdev
);
1143 struct video_capability
*b
= arg
;
1145 strcpy (b
->name
, stv680
->camera_name
);
1146 b
->type
= VID_TYPE_CAPTURE
;
1149 b
->maxwidth
= stv680
->maxwidth
;
1150 b
->maxheight
= stv680
->maxheight
;
1151 b
->minwidth
= stv680
->maxwidth
/ 2;
1152 b
->minheight
= stv680
->maxheight
/ 2;
1156 struct video_channel
*v
= arg
;
1158 if (v
->channel
!= 0)
1162 v
->type
= VIDEO_TYPE_CAMERA
;
1163 strcpy (v
->name
, "STV Camera");
1167 struct video_channel
*v
= arg
;
1168 if (v
->channel
!= 0)
1173 struct video_picture
*p
= arg
;
1175 stv680_get_pict (stv680
, p
);
1179 struct video_picture
*p
= arg
;
1181 if (stv680_set_pict (stv680
, p
))
1186 struct video_window
*vw
= arg
;
1192 if (vw
->width
!= stv680
->vwidth
) {
1193 if (stv680_set_size (stv680
, vw
->width
, vw
->height
)) {
1194 PDEBUG (2, "STV(e): failed (from user) set size in VIDIOCSWIN");
1201 struct video_window
*vw
= arg
;
1203 vw
->x
= 0; /* FIXME */
1208 vw
->width
= stv680
->vwidth
;
1209 vw
->height
= stv680
->vheight
;
1213 struct video_mbuf
*vm
= arg
;
1216 memset (vm
, 0, sizeof (*vm
));
1217 vm
->size
= STV680_NUMFRAMES
* stv680
->maxframesize
;
1218 vm
->frames
= STV680_NUMFRAMES
;
1219 for (i
= 0; i
< STV680_NUMFRAMES
; i
++)
1220 vm
->offsets
[i
] = stv680
->maxframesize
* i
;
1223 case VIDIOCMCAPTURE
:{
1224 struct video_mmap
*vm
= arg
;
1226 if (vm
->format
!= STV_VIDEO_PALETTE
) {
1227 PDEBUG (2, "STV(i): VIDIOCMCAPTURE vm.format (%i) != VIDEO_PALETTE (%i)",
1228 vm
->format
, STV_VIDEO_PALETTE
);
1229 if ((vm
->format
== 3) && (swapRGB_on
== 0)) {
1230 PDEBUG (2, "STV(i): VIDIOCMCAPTURE swapRGB is (auto) ON");
1231 /* this may fix those apps (e.g., xawtv) that want BGR */
1236 if (vm
->frame
>= STV680_NUMFRAMES
) {
1237 PDEBUG (2, "STV(e): VIDIOCMCAPTURE vm.frame > NUMFRAMES");
1240 if ((stv680
->frame
[vm
->frame
].grabstate
== FRAME_ERROR
)
1241 || (stv680
->frame
[vm
->frame
].grabstate
== FRAME_GRABBING
)) {
1242 PDEBUG (2, "STV(e): VIDIOCMCAPTURE grabstate (%i) error",
1243 stv680
->frame
[vm
->frame
].grabstate
);
1246 /* Is this according to the v4l spec??? */
1247 if (stv680
->vwidth
!= vm
->width
) {
1248 if (stv680_set_size (stv680
, vm
->width
, vm
->height
)) {
1249 PDEBUG (2, "STV(e): VIDIOCMCAPTURE set_size failed");
1253 stv680
->frame
[vm
->frame
].grabstate
= FRAME_READY
;
1255 if (!stv680
->streaming
)
1256 stv680_start_stream (stv680
);
1264 if (*frame
< 0 || *frame
>= STV680_NUMFRAMES
) {
1265 PDEBUG (2, "STV(e): Bad frame # in VIDIOCSYNC");
1268 ret
= stv680_newframe (stv680
, *frame
);
1269 stv680
->frame
[*frame
].grabstate
= FRAME_UNUSED
;
1273 struct video_buffer
*vb
= arg
;
1275 memset (vb
, 0, sizeof (*vb
));
1282 PDEBUG (2, "STV(e): VIDIOCCAPTURE failed");
1294 return -ENOIOCTLCMD
;
1300 static int stv680_ioctl(struct inode
*inode
, struct file
*file
,
1301 unsigned int cmd
, unsigned long arg
)
1303 return video_usercopy(inode
, file
, cmd
, arg
, stv680_do_ioctl
);
1306 static int stv680_mmap (struct file
*file
, struct vm_area_struct
*vma
)
1308 struct video_device
*dev
= file
->private_data
;
1309 struct usb_stv
*stv680
= video_get_drvdata(dev
);
1310 unsigned long start
= vma
->vm_start
;
1311 unsigned long size
= vma
->vm_end
-vma
->vm_start
;
1312 unsigned long page
, pos
;
1314 mutex_lock(&stv680
->lock
);
1316 if (stv680
->udev
== NULL
) {
1317 mutex_unlock(&stv680
->lock
);
1320 if (size
> (((STV680_NUMFRAMES
* stv680
->maxframesize
) + PAGE_SIZE
- 1)
1321 & ~(PAGE_SIZE
- 1))) {
1322 mutex_unlock(&stv680
->lock
);
1325 pos
= (unsigned long) stv680
->fbuf
;
1327 page
= vmalloc_to_pfn((void *)pos
);
1328 if (remap_pfn_range(vma
, start
, page
, PAGE_SIZE
, PAGE_SHARED
)) {
1329 mutex_unlock(&stv680
->lock
);
1334 if (size
> PAGE_SIZE
)
1339 mutex_unlock(&stv680
->lock
);
1344 static ssize_t
stv680_read (struct file
*file
, char __user
*buf
,
1345 size_t count
, loff_t
*ppos
)
1347 struct video_device
*dev
= file
->private_data
;
1348 unsigned long int realcount
= count
;
1350 struct usb_stv
*stv680
= video_get_drvdata(dev
);
1351 unsigned long int i
;
1353 if (STV680_NUMFRAMES
!= 2) {
1354 PDEBUG (0, "STV(e): STV680_NUMFRAMES needs to be 2!");
1357 if (stv680
->udev
== NULL
)
1359 if (realcount
> (stv680
->vwidth
* stv680
->vheight
* 3))
1360 realcount
= stv680
->vwidth
* stv680
->vheight
* 3;
1362 /* Shouldn't happen: */
1363 if (stv680
->frame
[0].grabstate
== FRAME_GRABBING
) {
1364 PDEBUG (2, "STV(e): FRAME_GRABBING in stv680_read");
1367 stv680
->frame
[0].grabstate
= FRAME_READY
;
1368 stv680
->frame
[1].grabstate
= FRAME_UNUSED
;
1369 stv680
->curframe
= 0;
1371 if (!stv680
->streaming
)
1372 stv680_start_stream (stv680
);
1374 if (!stv680
->streaming
) {
1375 ret
= stv680_newframe (stv680
, 0); /* ret should = 0 */
1378 ret
= stv680_newframe (stv680
, 0);
1381 if ((i
= copy_to_user (buf
, stv680
->frame
[0].data
, realcount
)) != 0) {
1382 PDEBUG (2, "STV(e): copy_to_user frame 0 failed, ret count = %li", i
);
1388 stv680
->frame
[0].grabstate
= FRAME_UNUSED
;
1392 static const struct file_operations stv680_fops
= {
1393 .owner
= THIS_MODULE
,
1395 .release
= stv_close
,
1396 .read
= stv680_read
,
1397 .mmap
= stv680_mmap
,
1398 .ioctl
= stv680_ioctl
,
1399 #ifdef CONFIG_COMPAT
1400 .compat_ioctl
= v4l_compat_ioctl32
,
1402 .llseek
= no_llseek
,
1404 static struct video_device stv680_template
= {
1405 .name
= "STV0680 USB camera",
1406 .fops
= &stv680_fops
,
1407 .release
= video_device_release
,
1411 static int stv680_probe (struct usb_interface
*intf
, const struct usb_device_id
*id
)
1413 struct usb_device
*dev
= interface_to_usbdev(intf
);
1414 struct usb_host_interface
*interface
;
1415 struct usb_stv
*stv680
= NULL
;
1416 char *camera_name
= NULL
;
1419 /* We don't handle multi-config cameras */
1420 if (dev
->descriptor
.bNumConfigurations
!= 1) {
1421 PDEBUG (0, "STV(e): Number of Configurations != 1");
1425 interface
= &intf
->altsetting
[0];
1426 /* Is it a STV680? */
1427 if ((le16_to_cpu(dev
->descriptor
.idVendor
) == USB_PENCAM_VENDOR_ID
) &&
1428 (le16_to_cpu(dev
->descriptor
.idProduct
) == USB_PENCAM_PRODUCT_ID
)) {
1429 camera_name
= "STV0680";
1430 PDEBUG (0, "STV(i): STV0680 camera found.");
1431 } else if ((le16_to_cpu(dev
->descriptor
.idVendor
) == USB_CREATIVEGOMINI_VENDOR_ID
) &&
1432 (le16_to_cpu(dev
->descriptor
.idProduct
) == USB_CREATIVEGOMINI_PRODUCT_ID
)) {
1433 camera_name
= "Creative WebCam Go Mini";
1434 PDEBUG (0, "STV(i): Creative WebCam Go Mini found.");
1436 PDEBUG (0, "STV(e): Vendor/Product ID do not match STV0680 or Creative WebCam Go Mini values.");
1437 PDEBUG (0, "STV(e): Check that the STV0680 or Creative WebCam Go Mini camera is connected to the computer.");
1442 if ((stv680
= kzalloc (sizeof (*stv680
), GFP_KERNEL
)) == NULL
) {
1443 PDEBUG (0, "STV(e): couldn't kmalloc stv680 struct.");
1449 stv680
->camera_name
= camera_name
;
1451 stv680
->vdev
= video_device_alloc();
1452 if (!stv680
->vdev
) {
1456 memcpy(stv680
->vdev
, &stv680_template
, sizeof(stv680_template
));
1457 stv680
->vdev
->parent
= &intf
->dev
;
1458 video_set_drvdata(stv680
->vdev
, stv680
);
1460 memcpy (stv680
->vdev
->name
, stv680
->camera_name
, strlen (stv680
->camera_name
));
1461 init_waitqueue_head (&stv680
->wq
);
1462 mutex_init (&stv680
->lock
);
1465 if (video_register_device(stv680
->vdev
, VFL_TYPE_GRABBER
, video_nr
) < 0) {
1466 PDEBUG (0, "STV(e): video_register_device failed");
1470 PDEBUG (0, "STV(i): registered new video device: video%d", stv680
->vdev
->minor
);
1472 usb_set_intfdata (intf
, stv680
);
1473 retval
= stv680_create_sysfs_files(stv680
->vdev
);
1479 video_unregister_device(stv680
->vdev
);
1481 video_device_release(stv680
->vdev
);
1487 static inline void usb_stv680_remove_disconnected (struct usb_stv
*stv680
)
1491 stv680
->udev
= NULL
;
1492 stv680
->frame
[0].grabstate
= FRAME_ERROR
;
1493 stv680
->frame
[1].grabstate
= FRAME_ERROR
;
1494 stv680
->streaming
= 0;
1496 wake_up_interruptible (&stv680
->wq
);
1498 for (i
= 0; i
< STV680_NUMSBUF
; i
++)
1499 if (stv680
->urb
[i
]) {
1500 usb_kill_urb (stv680
->urb
[i
]);
1501 usb_free_urb (stv680
->urb
[i
]);
1502 stv680
->urb
[i
] = NULL
;
1503 kfree(stv680
->sbuf
[i
].data
);
1505 for (i
= 0; i
< STV680_NUMSCRATCH
; i
++)
1506 kfree(stv680
->scratch
[i
].data
);
1507 PDEBUG (0, "STV(i): %s disconnected", stv680
->camera_name
);
1509 /* Free the memory */
1513 static void stv680_disconnect (struct usb_interface
*intf
)
1515 struct usb_stv
*stv680
= usb_get_intfdata (intf
);
1517 usb_set_intfdata (intf
, NULL
);
1520 /* We don't want people trying to open up the device */
1522 stv680_remove_sysfs_files(stv680
->vdev
);
1523 video_unregister_device(stv680
->vdev
);
1524 stv680
->vdev
= NULL
;
1526 if (!stv680
->user
) {
1527 usb_stv680_remove_disconnected (stv680
);
1529 stv680
->removed
= 1;
1534 static struct usb_driver stv680_driver
= {
1536 .probe
= stv680_probe
,
1537 .disconnect
= stv680_disconnect
,
1538 .id_table
= device_table
1541 /********************************************************************
1543 ********************************************************************/
1545 static int __init
usb_stv680_init (void)
1547 if (usb_register (&stv680_driver
) < 0) {
1548 PDEBUG (0, "STV(e): Could not setup STV0680 driver");
1551 PDEBUG (0, "STV(i): usb camera driver version %s registering", DRIVER_VERSION
);
1553 info(DRIVER_DESC
" " DRIVER_VERSION
);
1557 static void __exit
usb_stv680_exit (void)
1559 usb_deregister (&stv680_driver
);
1560 PDEBUG (0, "STV(i): driver deregistered");
1563 module_init (usb_stv680_init
);
1564 module_exit (usb_stv680_exit
);