SyntekUSBVideoCamera
|
00001 00034 #include <linux/module.h> 00035 #include <linux/init.h> 00036 #include <linux/kernel.h> 00037 #include <linux/version.h> 00038 #include <linux/errno.h> 00039 #include <linux/slab.h> 00040 #include <linux/kref.h> 00041 #include <linux/mm.h> 00042 00043 #include <linux/usb.h> 00044 #include <media/v4l2-common.h> 00045 #include <media/v4l2-ioctl.h> 00046 00047 #include "stk11xx.h" 00048 00049 00054 static int default_fps = -1; 00055 00060 static int default_hflip = -1; 00061 00066 static int default_vflip = -1; 00067 00072 static int default_brightness = -1; 00073 00078 static int default_whiteness = -1; 00079 00084 static int default_contrast = -1; 00085 00090 static int default_colour = -1; 00091 00096 static int default_norm = -1; 00097 00098 00103 static struct usb_device_id stk11xx_table[] = { 00104 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A311_PRODUCT_ID) }, 00105 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A821_PRODUCT_ID) }, 00106 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_AA11_PRODUCT_ID) }, 00107 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A31_PRODUCT_ID) }, 00108 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A33_PRODUCT_ID) }, 00109 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A51_PRODUCT_ID) }, 00110 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A54_PRODUCT_ID) }, 00111 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6D51_PRODUCT_ID) }, 00112 00113 { USB_DEVICE(USB_SYNTEK2_VENDOR_ID, USB_STK_0408_PRODUCT_ID) }, 00114 { USB_DEVICE(USB_SYNTEK2_VENDOR_ID, USB_STK_0500_PRODUCT_ID) }, 00115 { USB_DEVICE(USB_SYNTEK2_VENDOR_ID, USB_STK_0501_PRODUCT_ID) }, 00116 { } 00117 }; 00118 00119 00120 MODULE_DEVICE_TABLE(usb, stk11xx_table); 00133 int usb_stk11xx_isoc_init(struct usb_stk11xx *dev) 00134 { 00135 int i, j; 00136 int ret = 0; 00137 struct urb *urb; 00138 struct usb_device *udev; 00139 00140 if (dev == NULL) 00141 return -EFAULT; 00142 00143 if (dev->isoc_init_ok) 00144 return 0; 00145 00146 udev = dev->udev; 00147 00148 STK_DEBUG("usb_stk11xx_isoc_init()\n"); 00149 00150 // Allocate URB structure 00151 for (i=0; i<MAX_ISO_BUFS; i++) { 00152 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL); 00153 00154 if (urb == NULL) { 00155 STK_ERROR("Failed to allocate URB %d\n", i); 00156 ret = -ENOMEM; 00157 break; 00158 } 00159 00160 dev->isobuf[i].urb = urb; 00161 } 00162 00163 if (ret) { 00164 while (i >= 0) { 00165 if (dev->isobuf[i].urb != NULL) 00166 usb_free_urb(dev->isobuf[i].urb); 00167 00168 dev->isobuf[i].urb = NULL; 00169 i--; 00170 } 00171 00172 return ret; 00173 } 00174 00175 // Init URB structure 00176 for (i=0; i<MAX_ISO_BUFS; i++) { 00177 urb = dev->isobuf[i].urb; 00178 00179 urb->interval = 1; 00180 urb->dev = udev; 00181 urb->pipe = usb_rcvisocpipe(udev, dev->isoc_in_endpointAddr); 00182 urb->transfer_flags = URB_ISO_ASAP; 00183 urb->transfer_buffer = dev->isobuf[i].data; 00184 urb->transfer_buffer_length = ISO_BUFFER_SIZE; 00185 urb->complete = usb_stk11xx_isoc_handler; 00186 urb->context = dev; 00187 urb->start_frame = 0; 00188 urb->number_of_packets = ISO_FRAMES_PER_DESC; 00189 00190 for (j=0; j<ISO_FRAMES_PER_DESC; j++) { 00191 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE; 00192 urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE; //dev->isoc_in_size; 00193 } 00194 } 00195 00196 STK_DEBUG("dev->isoc_in_size = %X\n", dev->isoc_in_size); 00197 STK_DEBUG("dev->isoc_in_endpointAddr = %X\n", dev->isoc_in_endpointAddr); 00198 00199 // Link 00200 for (i=0; i<MAX_ISO_BUFS; i++) { 00201 ret = usb_submit_urb(dev->isobuf[i].urb, GFP_KERNEL); 00202 00203 if (ret) 00204 STK_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret); 00205 else 00206 STK_DEBUG("URB 0x%p submitted.\n", dev->isobuf[i].urb); 00207 00208 switch (ret) { 00209 case -ENOMEM: 00210 STK_ERROR("ENOMEM\n"); 00211 break; 00212 case -ENODEV: 00213 STK_ERROR("ENODEV\n"); 00214 break; 00215 case -ENXIO: 00216 STK_ERROR("ENXIO\n"); 00217 break; 00218 case -EINVAL: 00219 STK_ERROR("EINVAL\n"); 00220 break; 00221 case -EAGAIN: 00222 STK_ERROR("EAGAIN\n"); 00223 break; 00224 case -EFBIG: 00225 STK_ERROR("EFBIG\n"); 00226 break; 00227 case -EPIPE: 00228 STK_ERROR("EPIPE\n"); 00229 break; 00230 case -EMSGSIZE: 00231 STK_ERROR("EMSGSIZE\n"); 00232 break; 00233 } 00234 } 00235 00236 // All is done 00237 dev->isoc_init_ok = 1; 00238 00239 return 0; 00240 } 00241 00242 00252 void usb_stk11xx_isoc_handler(struct urb *urb) 00253 { 00254 int i; 00255 int ret; 00256 int skip; 00257 00258 int awake = 0; 00259 int framestatus; 00260 int framelen; 00261 00262 unsigned char *fill = NULL; 00263 unsigned char *iso_buf = NULL; 00264 00265 struct usb_stk11xx *dev; 00266 struct stk11xx_frame_buf *framebuf; 00267 00268 STK_STREAM("Isoc handler\n"); 00269 00270 dev = (struct usb_stk11xx *) urb->context; 00271 00272 if (dev == NULL) { 00273 STK_ERROR("isoc_handler called with NULL device !\n"); 00274 return; 00275 } 00276 00277 if (urb->status == -ENOENT || urb->status == -ECONNRESET) { 00278 STK_DEBUG("URB unlinked synchronuously !\n"); 00279 return; 00280 } 00281 00282 if (urb->status != -EINPROGRESS && urb->status != 0) { 00283 const char *errmsg; 00284 00285 errmsg = "Unknown"; 00286 00287 switch(urb->status) { 00288 case -ENOSR: 00289 errmsg = "Buffer error (overrun)"; 00290 break; 00291 00292 case -EPIPE: 00293 errmsg = "Stalled (device not responding)"; 00294 break; 00295 00296 case -EOVERFLOW: 00297 errmsg = "Babble (bad cable?)"; 00298 break; 00299 00300 case -EPROTO: 00301 errmsg = "Bit-stuff error (bad cable?)"; 00302 break; 00303 00304 case -EILSEQ: 00305 errmsg = "CRC/Timeout (could be anything)"; 00306 break; 00307 00308 case -ETIMEDOUT: 00309 errmsg = "NAK (device does not respond)"; 00310 break; 00311 } 00312 00313 STK_ERROR("isoc_handler() called with status %d [%s].\n", urb->status, errmsg); 00314 00315 dev->visoc_errors++; 00316 00317 wake_up_interruptible(&dev->wait_frame); 00318 00319 urb->dev = dev->udev; 00320 ret = usb_submit_urb(urb, GFP_ATOMIC); 00321 00322 if (ret != 0) { 00323 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret); 00324 } 00325 00326 return; 00327 } 00328 00329 framebuf = dev->fill_frame; 00330 00331 if (framebuf == NULL) { 00332 STK_ERROR("isoc_handler without valid fill frame !\n"); 00333 00334 wake_up_interruptible(&dev->wait_frame); 00335 00336 urb->dev = dev->udev; 00337 ret = usb_submit_urb(urb, GFP_ATOMIC); 00338 00339 if (ret != 0) { 00340 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret); 00341 } 00342 00343 return; 00344 } 00345 else { 00346 fill = framebuf->data + framebuf->filled; 00347 } 00348 00349 // Reset ISOC error counter 00350 dev->visoc_errors = 0; 00351 00352 // Compact data 00353 for (i=0; i<urb->number_of_packets; i++) { 00354 framestatus = urb->iso_frame_desc[i].status; 00355 framelen = urb->iso_frame_desc[i].actual_length; 00356 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset; 00357 00358 if (framestatus == 0) { 00359 skip = 4; 00360 00361 if (framelen > 4) { 00362 // we found something informational from there 00363 // the isoc frames have to type of headers 00364 // type1: 00 xx 00 00 or 20 xx 00 00 00365 // type2: 80 xx 00 00 00 00 00 00 or a0 xx 00 00 00 00 00 00 00366 // xx is a sequencer which has never been seen over 0x3f 00367 // 00368 // imho data written down looks like bayer, i see similarities after 00369 // every 640 bytes 00370 if (*iso_buf & 0x80) { 00371 skip = 8; 00372 } 00373 00374 // Determine if odd or even frame, and set a flag 00375 if (framelen == 8) { 00376 if (*iso_buf & 0x40) 00377 framebuf->odd = true; 00378 else 00379 framebuf->odd = false; 00380 } 00381 00382 // Our buffer is full !!! 00383 if (framelen - skip + framebuf->filled > dev->frame_size) { 00384 STK_ERROR("Frame buffer overflow %d %d %d!\n", 00385 framelen, framelen-skip+framebuf->filled, dev->frame_size); 00386 framebuf->errors++; 00387 } 00388 // All is OK 00389 else { 00390 memcpy(fill, iso_buf + skip, framelen - skip); 00391 fill += framelen - skip; 00392 } 00393 00394 // New size of our buffer 00395 framebuf->filled += framelen - skip; 00396 } 00397 00398 STK_STREAM("URB : Length = %d - Skip = %d - Buffer size = %d\n", 00399 framelen, skip, framebuf->filled); 00400 00401 // Data is always follow by a frame with a length '4' 00402 if (framelen == 4) { 00403 if (framebuf->filled > 0) { 00404 // Our buffer has enough data ? 00405 if (framebuf->filled < dev->frame_size) 00406 framebuf->errors++; 00407 00408 // If there are errors, we skip a frame... 00409 if (framebuf->errors == 0) { 00410 if (stk11xx_next_frame(dev)) 00411 dev->vframes_dumped++; 00412 } 00413 else 00414 dev->vframes_error++; 00415 00416 awake = 1; 00417 framebuf = dev->fill_frame; 00418 framebuf->filled = 0; 00419 framebuf->errors = 0; 00420 fill = framebuf->data; 00421 } 00422 } 00423 } 00424 else { 00425 STK_ERROR("Iso frame %d of USB has error %d\n", i, framestatus); 00426 } 00427 } 00428 00429 if (awake == 1) 00430 wake_up_interruptible(&dev->wait_frame); 00431 00432 urb->dev = dev->udev; 00433 00434 ret = usb_submit_urb(urb, GFP_ATOMIC); 00435 00436 if (ret != 0) { 00437 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret); 00438 } 00439 } 00440 00441 00449 void usb_stk11xx_isoc_cleanup(struct usb_stk11xx *dev) 00450 { 00451 int i; 00452 00453 STK_DEBUG("Isoc cleanup\n"); 00454 00455 if (dev == NULL) 00456 return; 00457 00458 if (dev->isoc_init_ok == 0) 00459 return; 00460 00461 // Unlinking ISOC buffers 00462 for (i=0; i<MAX_ISO_BUFS; i++) { 00463 struct urb *urb; 00464 00465 urb = dev->isobuf[i].urb; 00466 00467 if (urb != 0) { 00468 if (dev->isoc_init_ok) 00469 usb_kill_urb(urb); 00470 00471 usb_free_urb(urb); 00472 dev->isobuf[i].urb = NULL; 00473 } 00474 } 00475 00476 // All is done 00477 dev->isoc_init_ok = 0; 00478 } 00479 00480 00481 00492 int usb_stk11xx_set_feature(struct usb_stk11xx *dev, int index) 00493 { 00494 int result; 00495 struct usb_device *udev = dev->udev; 00496 00497 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 00498 USB_REQ_SET_FEATURE, 00499 USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE, 00500 USB_DEVICE_REMOTE_WAKEUP, 00501 index, 00502 NULL, 00503 0, 00504 500); 00505 00506 if (result < 0) 00507 STK_ERROR("SET FEATURE fail !\n"); 00508 else 00509 STK_DEBUG("SET FEATURE\n"); 00510 00511 return result; 00512 } 00513 00514 00524 int usb_stk11xx_set_configuration(struct usb_stk11xx *dev) 00525 { 00526 int result; 00527 struct usb_device *udev = dev->udev; 00528 00529 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 00530 USB_REQ_SET_CONFIGURATION, 00531 USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE, 00532 0, 00533 udev->config[0].desc.bConfigurationValue, 00534 NULL, 00535 0, 00536 500); 00537 00538 if (result < 0) 00539 STK_ERROR("SET CONFIGURATION fail !\n"); 00540 else 00541 STK_DEBUG("SET CONFIGURATION %d\n", udev->config[0].desc.bConfigurationValue); 00542 00543 return result; 00544 } 00545 00546 00558 int usb_stk11xx_write_registry(struct usb_stk11xx *dev, __u16 index, __u16 value) 00559 { 00560 int result; 00561 struct usb_device *udev = dev->udev; 00562 00563 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 00564 0x01, 00565 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 00566 value, 00567 index, 00568 NULL, 00569 0, 00570 500); 00571 00572 if (result < 0) 00573 STK_ERROR("Write registry fails %02X = %02X", index, value); 00574 00575 return result; 00576 } 00577 00578 00590 int usb_stk11xx_read_registry(struct usb_stk11xx *dev, __u16 index, int *value) 00591 { 00592 int result; 00593 00594 struct usb_device *udev = dev->udev; 00595 00596 *value = 0; 00597 00598 result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 00599 0x00, 00600 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 00601 0x00, 00602 index, 00603 (__u8 *) value, 00604 sizeof(__u8), 00605 500); 00606 00607 if (result < 0) 00608 STK_ERROR("Read registry fails %02X", index); 00609 00610 return result; 00611 } 00612 00613 00624 static int usb_stk11xx_default_settings(struct usb_stk11xx *dev) 00625 { 00626 switch (dev->webcam_model) { 00627 case SYNTEK_STK_0408: 00628 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps; 00629 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip; 00630 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip; 00631 00632 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness; 00633 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness; 00634 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast; 00635 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour; 00636 dev->vsettings.norm = (default_norm == -1) ? 0 : default_norm; 00637 dev->vsettings.input = 0; 00638 break; 00639 00640 case SYNTEK_STK_M811: 00641 case SYNTEK_STK_A311: 00642 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps; 00643 dev->vsettings.vflip = (default_vflip == -1) ? 1 : default_vflip; 00644 dev->vsettings.hflip = (default_hflip == -1) ? 1 : default_hflip; 00645 00646 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness; 00647 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness; 00648 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast; 00649 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour; 00650 break; 00651 00652 case SYNTEK_STK_A821: 00653 case SYNTEK_STK_AA11: 00654 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps; 00655 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip; 00656 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip; 00657 00658 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness; 00659 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness; 00660 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast; 00661 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour; 00662 break; 00663 00664 case SYNTEK_STK_6A31: 00665 case SYNTEK_STK_6A33: 00666 case SYNTEK_STK_0500: 00667 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps; 00668 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip; 00669 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip; 00670 00671 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness; 00672 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness; 00673 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast; 00674 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour; 00675 break; 00676 00677 case SYNTEK_STK_6A51: 00678 case SYNTEK_STK_6D51: 00679 case SYNTEK_STK_6A54: 00680 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps; 00681 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip; 00682 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip; 00683 00684 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness; 00685 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness; 00686 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast; 00687 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour; 00688 break; 00689 00690 default: 00691 return -1; 00692 } 00693 00694 dev->vsettings.default_brightness = dev->vsettings.brightness; 00695 dev->vsettings.default_whiteness = dev->vsettings.whiteness; 00696 dev->vsettings.default_contrast = dev->vsettings.contrast; 00697 dev->vsettings.default_colour = dev->vsettings.colour; 00698 dev->vsettings.default_hflip = dev->vsettings.hflip; 00699 dev->vsettings.default_vflip = dev->vsettings.vflip; 00700 00701 return 0; 00702 } 00703 00704 00716 static int usb_stk11xx_probe(struct usb_interface *interface, const struct usb_device_id *id) 00717 { 00718 int i; 00719 int err; 00720 size_t buffer_size; 00721 00722 int vendor_id; 00723 int product_id; 00724 int bNumInterfaces; 00725 int webcam_model; 00726 int webcam_type; 00727 00728 struct usb_stk11xx *dev = NULL; 00729 struct usb_device *udev = interface_to_usbdev(interface); 00730 struct usb_host_interface *iface_desc; 00731 struct usb_endpoint_descriptor *endpoint; 00732 00733 00734 // Get USB VendorID and ProductID 00735 vendor_id = le16_to_cpu(udev->descriptor.idVendor); 00736 product_id = le16_to_cpu(udev->descriptor.idProduct); 00737 00738 // Check if we can handle this device 00739 STK_DEBUG("Probe function called with VendorID=%04X, ProductID=%04X and InterfaceNumber=%d\n", 00740 vendor_id, product_id, interface->cur_altsetting->desc.bInterfaceNumber); 00741 00742 // The interface are probed one by one. 00743 // We are interested in the video interface (always the interface '0') 00744 // The interfaces '1' or '2' (if presents) are the audio control. 00745 if (interface->cur_altsetting->desc.bInterfaceNumber > 0) 00746 return -ENODEV; 00747 00748 // Detect device 00749 if (vendor_id == USB_SYNTEK1_VENDOR_ID) { 00750 switch (product_id) { 00751 case USB_STK_A311_PRODUCT_ID: 00752 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00753 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0xA311.\n"); 00754 webcam_model = SYNTEK_STK_A311; 00755 webcam_type = STK11XX_SXGA; 00756 break; 00757 00758 case USB_STK_A821_PRODUCT_ID: 00759 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00760 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xA821.\n"); 00761 webcam_model = SYNTEK_STK_A821; 00762 webcam_type = STK11XX_VGA; 00763 break; 00764 00765 case USB_STK_AA11_PRODUCT_ID: 00766 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xAA11.\n"); 00767 STK_INFO("Using code for Product ID AxA821\n"); 00768 webcam_model = SYNTEK_STK_AA11; 00769 webcam_type = STK11XX_VGA; 00770 break; 00771 00772 case USB_STK_6A31_PRODUCT_ID: 00773 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00774 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A31.\n"); 00775 webcam_model = SYNTEK_STK_6A31; 00776 webcam_type = STK11XX_VGA; 00777 break; 00778 00779 case USB_STK_6A33_PRODUCT_ID: 00780 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00781 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A33.\n"); 00782 webcam_model = SYNTEK_STK_6A33; 00783 webcam_type = STK11XX_VGA; 00784 break; 00785 00786 case USB_STK_6A51_PRODUCT_ID: 00787 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00788 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A51.\n"); 00789 webcam_model = SYNTEK_STK_6A51; 00790 webcam_type = STK11XX_VGA; 00791 break; 00792 00793 case USB_STK_6A54_PRODUCT_ID: 00794 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00795 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A54.\n"); 00796 webcam_model = SYNTEK_STK_6A54; 00797 webcam_type = STK11XX_VGA; 00798 break; 00799 00800 case USB_STK_6D51_PRODUCT_ID: 00801 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00802 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6D51.\n"); 00803 webcam_model = SYNTEK_STK_6D51; 00804 webcam_type = STK11XX_VGA; 00805 break; 00806 00807 default: 00808 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n", 00809 le16_to_cpu(udev->descriptor.idProduct)); 00810 return -ENODEV; 00811 } 00812 } 00813 else if (vendor_id == USB_SYNTEK2_VENDOR_ID) { 00814 switch (product_id) { 00815 case USB_STK_0408_PRODUCT_ID: 00816 STK_INFO("Syntek USB2.0 - STK-1160 based device found.\n"); 00817 STK_INFO("Syntek AVStream USB2.0 Video Capture - Product ID 0x0408.\n"); 00818 webcam_model = SYNTEK_STK_0408; 00819 webcam_type = STK11XX_PAL; 00820 break; 00821 00822 case USB_STK_0500_PRODUCT_ID: 00823 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00824 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0500.\n"); 00825 webcam_model = SYNTEK_STK_0500; 00826 webcam_type = STK11XX_VGA; 00827 break; 00828 00829 case USB_STK_0501_PRODUCT_ID: 00830 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00831 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0501.\n"); 00832 webcam_model = SYNTEK_STK_M811; 00833 webcam_type = STK11XX_SXGA; 00834 break; 00835 00836 default: 00837 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n", 00838 le16_to_cpu(udev->descriptor.idProduct)); 00839 return -ENODEV; 00840 } 00841 } 00842 else 00843 return -ENODEV; 00844 00845 // Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device 00846 dev = kzalloc(sizeof(struct usb_stk11xx), GFP_KERNEL); 00847 00848 if (dev == NULL) { 00849 STK_ERROR("Out of memory !\n"); 00850 return -ENOMEM; 00851 } 00852 00853 // Init mutexes, spinlock, etc. 00854 00855 #ifndef init_MUTEX 00856 sema_init(&dev->mutex,1); 00857 #else 00858 init_MUTEX(&dev->mutex); 00859 #endif 00860 mutex_init(&dev->modlock); 00861 spin_lock_init(&dev->spinlock); 00862 init_waitqueue_head(&dev->wait_frame); 00863 00864 // Save pointers 00865 dev->webcam_model = webcam_model; 00866 dev->webcam_type = webcam_type; 00867 dev->udev = udev; 00868 dev->interface = interface; 00869 00870 // Read the product release 00871 dev->release = le16_to_cpu(udev->descriptor.bcdDevice); 00872 STK_INFO("Release: %04x\n", dev->release); 00873 00874 // How many interfaces (1 or 3) ? 00875 bNumInterfaces = udev->config->desc.bNumInterfaces; 00876 STK_INFO("Number of interfaces : %d\n", bNumInterfaces); 00877 00878 00879 // Constructor 00880 // 2 : enough for webcam 00881 // 3 : for easycap... it's usefull ? 00882 dev->nbuffers = 2; 00883 // dev->nbuffers = 3; 00884 dev->len_per_image = PAGE_ALIGN(STK11XX_FRAME_SIZE); 00885 00886 00887 // Switch on the camera (to detect size of buffers) 00888 dev_stk11xx_camera_on(dev); 00889 00890 00891 // Set up the endpoint information 00892 // use only the first int-in and isoc-in endpoints 00893 // for the current alternate setting 00894 iface_desc = interface->cur_altsetting; 00895 00896 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 00897 endpoint = &iface_desc->endpoint[i].desc; 00898 00899 if (!dev->int_in_endpointAddr 00900 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) 00901 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) { 00902 // we found an interrupt in endpoint 00903 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 00904 00905 dev->int_in_size = buffer_size; 00906 dev->int_in_endpointAddr = (endpoint->bEndpointAddress & 0xf); 00907 } 00908 00909 if (!dev->isoc_in_endpointAddr 00910 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) 00911 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)) { 00912 // we found an isoc in endpoint 00913 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 00914 00915 dev->isoc_in_size = buffer_size; 00916 dev->isoc_in_endpointAddr = (endpoint->bEndpointAddress & 0xf); 00917 } 00918 } 00919 00920 if (!(dev->int_in_endpointAddr && dev->isoc_in_endpointAddr)) { 00921 STK_ERROR("Could not find both int-in and isoc-in endpoints"); 00922 00923 kfree(dev); 00924 00925 return -ENODEV; 00926 } 00927 00928 00929 // Switch off camera 00930 dev_stk11xx_camera_off(dev); 00931 00932 // Initialize the video device 00933 dev->vdev = video_device_alloc(); 00934 00935 if (!dev->vdev) { 00936 kfree(dev); 00937 return -ENOMEM; 00938 } 00939 00940 // Initialize the camera 00941 dev_stk11xx_initialize_device(dev); 00942 00943 // Register the video device 00944 err = v4l_stk11xx_register_video_device(dev); 00945 00946 if (err) { 00947 kfree(dev); 00948 return err; 00949 } 00950 00951 // Create the entries in the sys filesystem 00952 stk11xx_create_sysfs_files(dev->vdev); 00953 00954 // Save our data pointer in this interface device 00955 usb_set_intfdata(interface, dev); 00956 00957 // Default settings video device 00958 usb_stk11xx_default_settings(dev); 00959 00960 // Enable power management feature 00961 // usb_autopm_enable(dev->interface); 00962 00963 return 0; 00964 } 00965 00966 00973 static void usb_stk11xx_disconnect(struct usb_interface *interface) 00974 { 00975 struct usb_stk11xx *dev = usb_get_intfdata(interface); 00976 00977 STK_INFO("Syntek USB2.0 Camera disconnected\n"); 00978 00979 // We got unplugged; this is signalled by an EPIPE error code 00980 if (dev->vopen) { 00981 STK_INFO("Disconnected while webcam is in use !\n"); 00982 dev->error_status = EPIPE; 00983 } 00984 00985 // Alert waiting processes 00986 wake_up_interruptible(&dev->wait_frame); 00987 00988 // Wait until device is closed 00989 while (dev->vopen) 00990 schedule(); 00991 00992 // Remove the entries in the sys filesystem 00993 stk11xx_remove_sysfs_files(dev->vdev); 00994 00995 // Unregister the video device 00996 v4l_stk11xx_unregister_video_device(dev); 00997 00998 usb_set_intfdata(interface, NULL); 00999 01000 kfree(dev); 01001 } 01002 01003 /* 01004 int usb_stk11xx_suspend(struct usb_interface *interface, pm_message_t message) 01005 { 01006 struct usb_stk11xx *dev = usb_get_intfdata(interface); 01007 01008 STK_INFO("Syntek USB2.0 Camera Suspend\n"); 01009 01010 // Stop the video stream 01011 dev_stk11xx_stop_stream(dev); 01012 01013 // ISOC and URB cleanup 01014 usb_stk11xx_isoc_cleanup(dev); 01015 01016 // Free memory 01017 // stk11xx_free_buffers(dev); 01018 01019 // Switch off the camera 01020 dev_stk11xx_camera_off(dev); 01021 01022 return 0; 01023 } 01024 01025 01026 int usb_stk11xx_resume(struct usb_interface *interface) 01027 { 01028 struct usb_stk11xx *dev = usb_get_intfdata(interface); 01029 01030 STK_INFO("Syntek USB2.0 Camera Resume\n"); 01031 01032 // Initialize the camera 01033 dev_stk11xx_initialize_device(dev); 01034 01035 // Select the new video mode 01036 v4l_stk11xx_select_video_mode(dev, dev->view.x, dev->view.y); 01037 01038 // Clear the buffers 01039 stk11xx_clear_buffers(dev); 01040 01041 // Initialize the device 01042 dev_stk11xx_init_camera(dev); 01043 dev_stk11xx_camera_on(dev); 01044 dev_stk11xx_reconf_camera(dev); 01045 01046 // ISOC and URB init 01047 usb_stk11xx_isoc_init(dev); 01048 01049 // Start the video stream 01050 dev_stk11xx_start_stream(dev); 01051 01052 // Video settings 01053 dev_stk11xx_camera_settings(dev); 01054 01055 return 0; 01056 } 01057 */ 01058 01059 01065 static struct usb_driver usb_stk11xx_driver = { 01066 .name = "usb_stk11xx_driver", 01067 .probe = usb_stk11xx_probe, 01068 .disconnect = usb_stk11xx_disconnect, 01069 .id_table = stk11xx_table, 01070 // .suspend = usb_stk11xx_suspend, 01071 // .resume = usb_stk11xx_resume, 01072 }; 01073 01074 01079 static int fps; 01080 01085 static int hflip = -1; 01086 01091 static int vflip = -1; 01092 01097 static int brightness = -1; 01098 01103 static int whiteness = -1; 01104 01109 static int contrast = -1; 01110 01115 static int colour = -1; 01116 01121 static int norm = -1; 01122 01123 01124 module_param(fps, int, 0444); 01125 module_param(hflip, int, 0444); 01126 module_param(vflip, int, 0444); 01128 module_param(brightness, int, 0444); 01129 module_param(whiteness, int, 0444); 01130 module_param(contrast, int, 0444); 01131 module_param(colour, int, 0444); 01132 module_param(norm, int, 0444); 01143 static int __init usb_stk11xx_init(void) 01144 { 01145 int result; 01146 01147 STK_INFO("%s driver %s startup\n", DRIVER_DESC, DRIVER_VERSION); 01148 STK_INFO("Copyright(c) 2006-%d %s\n", DRIVER_YEAR, DRIVER_AUTHOR); 01149 STK_INFO("%s\n", DRIVER_URL); 01150 01151 // Frame per second parameter 01152 if (fps) { 01153 if (fps < 9 || fps > 30) { 01154 STK_ERROR("Framerate out of bounds [10-30] !\n"); 01155 return -EINVAL; 01156 } 01157 01158 default_fps = fps; 01159 } 01160 01161 // Horizontal flip value 01162 if ((hflip == 0) || (hflip == 1)) { 01163 STK_DEBUG("Set horizontal flip = %d\n", hflip); 01164 01165 default_hflip = hflip; 01166 } 01167 01168 // Vertical flip value 01169 if ((vflip == 0) || (vflip == 1)) { 01170 STK_DEBUG("Set vertical flip = %d\n", vflip); 01171 01172 default_vflip = vflip; 01173 } 01174 01175 // Brightness value 01176 if (brightness > -1) { 01177 STK_DEBUG("Set brightness = 0x%X\n", brightness); 01178 01179 default_brightness = 0xffff & brightness; 01180 } 01181 01182 // Whiteness value 01183 if (whiteness > -1) { 01184 STK_DEBUG("Set whiteness = 0x%X\n", whiteness); 01185 01186 default_whiteness = 0xffff & whiteness; 01187 } 01188 01189 // Contrast value 01190 if (contrast > -1) { 01191 STK_DEBUG("Set contrast = 0x%X\n", contrast); 01192 01193 default_contrast = 0xffff & contrast; 01194 } 01195 01196 // Colour value 01197 if (colour > -1) { 01198 STK_DEBUG("Set colour = 0x%X\n", colour); 01199 01200 default_colour = 0xffff & colour; 01201 } 01202 01203 // Norm value 01204 if (norm > -1) { 01205 default_norm = (norm > 0) ? 1 : 0; 01206 01207 STK_INFO("Set norm = %s\n", (default_norm > 0) ? "NTSC" : "PAL"); 01208 } 01209 01210 01211 // Register the driver with the USB subsystem 01212 result = usb_register(&usb_stk11xx_driver); 01213 01214 if (result) 01215 STK_ERROR("usb_register failed ! Error number %d\n", result); 01216 01217 return result; 01218 } 01219 01220 01226 static void __exit usb_stk11xx_exit(void) 01227 { 01228 STK_INFO("usb_stk11xx_exit: Syntek USB2.0 webcam driver shutdown\n"); 01229 01230 // Deregister this driver with the USB subsystem 01231 usb_deregister(&usb_stk11xx_driver); 01232 } 01233 01234 01235 module_init(usb_stk11xx_init); 01236 module_exit(usb_stk11xx_exit); 01239 MODULE_PARM_DESC(fps, "Frames per second [5-30]"); 01240 MODULE_PARM_DESC(hflip, "Horizontal image flip"); 01241 MODULE_PARM_DESC(vflip, "Vertical image flip"); 01242 MODULE_PARM_DESC(brightness, "Brightness setting"); 01243 MODULE_PARM_DESC(whiteness, "Whiteness setting"); 01244 MODULE_PARM_DESC(colour, "Colour setting"); 01245 MODULE_PARM_DESC(contrast, "Contrast setting"); 01246 MODULE_PARM_DESC(norm, "Norm setting (0=NTSC, 1=PAL)"); 01249 MODULE_LICENSE("GPL"); 01250 MODULE_AUTHOR(DRIVER_AUTHOR); 01251 MODULE_DESCRIPTION(DRIVER_DESC); 01252 MODULE_SUPPORTED_DEVICE(DRIVER_SUPPORT); 01253 MODULE_VERSION(DRIVER_VERSION); 01254 MODULE_INFO(url, DRIVER_URL);