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 return 0; 00695 } 00696 00697 00709 static int usb_stk11xx_probe(struct usb_interface *interface, const struct usb_device_id *id) 00710 { 00711 int i; 00712 int err; 00713 size_t buffer_size; 00714 00715 int vendor_id; 00716 int product_id; 00717 int bNumInterfaces; 00718 int webcam_model; 00719 int webcam_type; 00720 00721 struct usb_stk11xx *dev = NULL; 00722 struct usb_device *udev = interface_to_usbdev(interface); 00723 struct usb_host_interface *iface_desc; 00724 struct usb_endpoint_descriptor *endpoint; 00725 00726 00727 // Get USB VendorID and ProductID 00728 vendor_id = le16_to_cpu(udev->descriptor.idVendor); 00729 product_id = le16_to_cpu(udev->descriptor.idProduct); 00730 00731 // Check if we can handle this device 00732 STK_DEBUG("Probe function called with VendorID=%04X, ProductID=%04X and InterfaceNumber=%d\n", 00733 vendor_id, product_id, interface->cur_altsetting->desc.bInterfaceNumber); 00734 00735 // The interface are probed one by one. 00736 // We are interested in the video interface (always the interface '0') 00737 // The interfaces '1' or '2' (if presents) are the audio control. 00738 if (interface->cur_altsetting->desc.bInterfaceNumber > 0) 00739 return -ENODEV; 00740 00741 // Detect device 00742 if (vendor_id == USB_SYNTEK1_VENDOR_ID) { 00743 switch (product_id) { 00744 case USB_STK_A311_PRODUCT_ID: 00745 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00746 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0xA311.\n"); 00747 webcam_model = SYNTEK_STK_A311; 00748 webcam_type = STK11XX_SXGA; 00749 break; 00750 00751 case USB_STK_A821_PRODUCT_ID: 00752 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00753 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xA821.\n"); 00754 webcam_model = SYNTEK_STK_A821; 00755 webcam_type = STK11XX_VGA; 00756 break; 00757 00758 case USB_STK_AA11_PRODUCT_ID: 00759 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xAA11.\n"); 00760 STK_INFO("Using code for Product ID AxA821\n"); 00761 webcam_model = SYNTEK_STK_AA11; 00762 webcam_type = STK11XX_VGA; 00763 break; 00764 00765 case USB_STK_6A31_PRODUCT_ID: 00766 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00767 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A31.\n"); 00768 webcam_model = SYNTEK_STK_6A31; 00769 webcam_type = STK11XX_VGA; 00770 break; 00771 00772 case USB_STK_6A33_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 0x6A33.\n"); 00775 webcam_model = SYNTEK_STK_6A33; 00776 webcam_type = STK11XX_VGA; 00777 break; 00778 00779 case USB_STK_6A51_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 0x6A51.\n"); 00782 webcam_model = SYNTEK_STK_6A51; 00783 webcam_type = STK11XX_VGA; 00784 break; 00785 00786 case USB_STK_6A54_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 0x6A54.\n"); 00789 webcam_model = SYNTEK_STK_6A54; 00790 webcam_type = STK11XX_VGA; 00791 break; 00792 00793 case USB_STK_6D51_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 0x6D51.\n"); 00796 webcam_model = SYNTEK_STK_6D51; 00797 webcam_type = STK11XX_VGA; 00798 break; 00799 00800 default: 00801 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n", 00802 le16_to_cpu(udev->descriptor.idProduct)); 00803 return -ENODEV; 00804 } 00805 } 00806 else if (vendor_id == USB_SYNTEK2_VENDOR_ID) { 00807 switch (product_id) { 00808 case USB_STK_0408_PRODUCT_ID: 00809 STK_INFO("Syntek USB2.0 - STK-1160 based device found.\n"); 00810 STK_INFO("Syntek AVStream USB2.0 Video Capture - Product ID 0x0408.\n"); 00811 webcam_model = SYNTEK_STK_0408; 00812 webcam_type = STK11XX_PAL; 00813 break; 00814 00815 case USB_STK_0500_PRODUCT_ID: 00816 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00817 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0500.\n"); 00818 webcam_model = SYNTEK_STK_0500; 00819 webcam_type = STK11XX_VGA; 00820 break; 00821 00822 case USB_STK_0501_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 0x0501.\n"); 00825 webcam_model = SYNTEK_STK_M811; 00826 webcam_type = STK11XX_SXGA; 00827 break; 00828 00829 default: 00830 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n", 00831 le16_to_cpu(udev->descriptor.idProduct)); 00832 return -ENODEV; 00833 } 00834 } 00835 else 00836 return -ENODEV; 00837 00838 // Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device 00839 dev = kzalloc(sizeof(struct usb_stk11xx), GFP_KERNEL); 00840 00841 if (dev == NULL) { 00842 STK_ERROR("Out of memory !\n"); 00843 return -ENOMEM; 00844 } 00845 00846 // Init mutexes, spinlock, etc. 00847 00848 #ifndef init_MUTEX 00849 sema_init(&dev->mutex,1); 00850 #else 00851 init_MUTEX(&dev->mutex); 00852 #endif 00853 mutex_init(&dev->modlock); 00854 spin_lock_init(&dev->spinlock); 00855 init_waitqueue_head(&dev->wait_frame); 00856 00857 // Save pointers 00858 dev->webcam_model = webcam_model; 00859 dev->webcam_type = webcam_type; 00860 dev->udev = udev; 00861 dev->interface = interface; 00862 00863 // Read the product release 00864 dev->release = le16_to_cpu(udev->descriptor.bcdDevice); 00865 STK_INFO("Release: %04x\n", dev->release); 00866 00867 // How many interfaces (1 or 3) ? 00868 bNumInterfaces = udev->config->desc.bNumInterfaces; 00869 STK_INFO("Number of interfaces : %d\n", bNumInterfaces); 00870 00871 00872 // Constructor 00873 // 2 : enough for webcam 00874 // 3 : for easycap... it's usefull ? 00875 dev->nbuffers = 2; 00876 // dev->nbuffers = 3; 00877 dev->len_per_image = PAGE_ALIGN(STK11XX_FRAME_SIZE); 00878 00879 00880 // Switch on the camera (to detect size of buffers) 00881 dev_stk11xx_camera_on(dev); 00882 00883 00884 // Set up the endpoint information 00885 // use only the first int-in and isoc-in endpoints 00886 // for the current alternate setting 00887 iface_desc = interface->cur_altsetting; 00888 00889 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 00890 endpoint = &iface_desc->endpoint[i].desc; 00891 00892 if (!dev->int_in_endpointAddr 00893 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) 00894 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) { 00895 // we found an interrupt in endpoint 00896 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 00897 00898 dev->int_in_size = buffer_size; 00899 dev->int_in_endpointAddr = (endpoint->bEndpointAddress & 0xf); 00900 } 00901 00902 if (!dev->isoc_in_endpointAddr 00903 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) 00904 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)) { 00905 // we found an isoc in endpoint 00906 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 00907 00908 dev->isoc_in_size = buffer_size; 00909 dev->isoc_in_endpointAddr = (endpoint->bEndpointAddress & 0xf); 00910 } 00911 } 00912 00913 if (!(dev->int_in_endpointAddr && dev->isoc_in_endpointAddr)) { 00914 STK_ERROR("Could not find both int-in and isoc-in endpoints"); 00915 00916 kfree(dev); 00917 00918 return -ENODEV; 00919 } 00920 00921 00922 // Switch off camera 00923 dev_stk11xx_camera_off(dev); 00924 00925 // Initialize the video device 00926 dev->vdev = video_device_alloc(); 00927 00928 if (!dev->vdev) { 00929 kfree(dev); 00930 return -ENOMEM; 00931 } 00932 00933 // Initialize the camera 00934 dev_stk11xx_initialize_device(dev); 00935 00936 // Register the video device 00937 err = v4l_stk11xx_register_video_device(dev); 00938 00939 if (err) { 00940 kfree(dev); 00941 return err; 00942 } 00943 00944 // Create the entries in the sys filesystem 00945 stk11xx_create_sysfs_files(dev->vdev); 00946 00947 // Save our data pointer in this interface device 00948 usb_set_intfdata(interface, dev); 00949 00950 // Default settings video device 00951 usb_stk11xx_default_settings(dev); 00952 00953 // Enable power management feature 00954 // usb_autopm_enable(dev->interface); 00955 00956 return 0; 00957 } 00958 00959 00966 static void usb_stk11xx_disconnect(struct usb_interface *interface) 00967 { 00968 struct usb_stk11xx *dev = usb_get_intfdata(interface); 00969 00970 STK_INFO("Syntek USB2.0 Camera disconnected\n"); 00971 00972 usb_set_intfdata(interface, NULL); 00973 00974 // We got unplugged; this is signalled by an EPIPE error code 00975 if (dev->vopen) { 00976 STK_INFO("Disconnected while webcam is in use !\n"); 00977 dev->error_status = EPIPE; 00978 } 00979 00980 // Alert waiting processes 00981 wake_up_interruptible(&dev->wait_frame); 00982 00983 // Wait until device is closed 00984 while (dev->vopen) 00985 schedule(); 00986 00987 // Remove the entries in the sys filesystem 00988 stk11xx_remove_sysfs_files(dev->vdev); 00989 00990 // Unregister the video device 00991 v4l_stk11xx_unregister_video_device(dev); 00992 } 00993 00994 /* 00995 int usb_stk11xx_suspend(struct usb_interface *interface, pm_message_t message) 00996 { 00997 struct usb_stk11xx *dev = usb_get_intfdata(interface); 00998 00999 STK_INFO("Syntek USB2.0 Camera Suspend\n"); 01000 01001 // Stop the video stream 01002 dev_stk11xx_stop_stream(dev); 01003 01004 // ISOC and URB cleanup 01005 usb_stk11xx_isoc_cleanup(dev); 01006 01007 // Free memory 01008 // stk11xx_free_buffers(dev); 01009 01010 // Switch off the camera 01011 dev_stk11xx_camera_off(dev); 01012 01013 return 0; 01014 } 01015 01016 01017 int usb_stk11xx_resume(struct usb_interface *interface) 01018 { 01019 struct usb_stk11xx *dev = usb_get_intfdata(interface); 01020 01021 STK_INFO("Syntek USB2.0 Camera Resume\n"); 01022 01023 // Initialize the camera 01024 dev_stk11xx_initialize_device(dev); 01025 01026 // Select the new video mode 01027 v4l_stk11xx_select_video_mode(dev, dev->view.x, dev->view.y); 01028 01029 // Clear the buffers 01030 stk11xx_clear_buffers(dev); 01031 01032 // Initialize the device 01033 dev_stk11xx_init_camera(dev); 01034 dev_stk11xx_camera_on(dev); 01035 dev_stk11xx_reconf_camera(dev); 01036 01037 // ISOC and URB init 01038 usb_stk11xx_isoc_init(dev); 01039 01040 // Start the video stream 01041 dev_stk11xx_start_stream(dev); 01042 01043 // Video settings 01044 dev_stk11xx_camera_settings(dev); 01045 01046 return 0; 01047 } 01048 */ 01049 01050 01056 static struct usb_driver usb_stk11xx_driver = { 01057 .name = "usb_stk11xx_driver", 01058 .probe = usb_stk11xx_probe, 01059 .disconnect = usb_stk11xx_disconnect, 01060 .id_table = stk11xx_table, 01061 // .suspend = usb_stk11xx_suspend, 01062 // .resume = usb_stk11xx_resume, 01063 }; 01064 01065 01070 static int fps; 01071 01076 static int hflip = -1; 01077 01082 static int vflip = -1; 01083 01088 static int brightness = -1; 01089 01094 static int whiteness = -1; 01095 01100 static int contrast = -1; 01101 01106 static int colour = -1; 01107 01112 static int norm = -1; 01113 01114 01115 module_param(fps, int, 0444); 01116 module_param(hflip, int, 0444); 01117 module_param(vflip, int, 0444); 01119 module_param(brightness, int, 0444); 01120 module_param(whiteness, int, 0444); 01121 module_param(contrast, int, 0444); 01122 module_param(colour, int, 0444); 01123 module_param(norm, int, 0444); 01134 static int __init usb_stk11xx_init(void) 01135 { 01136 int result; 01137 01138 01139 STK_INFO("Syntek USB2.0 webcam driver startup\n"); 01140 STK_INFO("Copyright(c) 2006-2009 Nicolas VIVIEN\n"); 01141 01142 // Frame per second parameter 01143 if (fps) { 01144 if (fps < 9 || fps > 30) { 01145 STK_ERROR("Framerate out of bounds [10-30] !\n"); 01146 return -EINVAL; 01147 } 01148 01149 default_fps = fps; 01150 } 01151 01152 // Horizontal flip value 01153 if ((hflip == 0) || (hflip == 1)) { 01154 STK_DEBUG("Set horizontal flip = %d\n", hflip); 01155 01156 default_hflip = hflip; 01157 } 01158 01159 // Vertical flip value 01160 if ((vflip == 0) || (vflip == 1)) { 01161 STK_DEBUG("Set vertical flip = %d\n", vflip); 01162 01163 default_vflip = vflip; 01164 } 01165 01166 // Brightness value 01167 if (brightness > -1) { 01168 STK_DEBUG("Set brightness = 0x%X\n", brightness); 01169 01170 default_brightness = 0xffff & brightness; 01171 } 01172 01173 // Whiteness value 01174 if (whiteness > -1) { 01175 STK_DEBUG("Set whiteness = 0x%X\n", whiteness); 01176 01177 default_whiteness = 0xffff & whiteness; 01178 } 01179 01180 // Contrast value 01181 if (contrast > -1) { 01182 STK_DEBUG("Set contrast = 0x%X\n", contrast); 01183 01184 default_contrast = 0xffff & contrast; 01185 } 01186 01187 // Colour value 01188 if (colour > -1) { 01189 STK_DEBUG("Set colour = 0x%X\n", colour); 01190 01191 default_colour = 0xffff & colour; 01192 } 01193 01194 // Norm value 01195 if (norm > -1) { 01196 default_norm = (norm > 0) ? 1 : 0; 01197 01198 STK_INFO("Set norm = %s\n", (default_norm > 0) ? "NTSC" : "PAL"); 01199 } 01200 01201 01202 // Register the driver with the USB subsystem 01203 result = usb_register(&usb_stk11xx_driver); 01204 01205 if (result) 01206 STK_ERROR("usb_register failed ! Error number %d\n", result); 01207 01208 STK_INFO(DRIVER_VERSION " : " DRIVER_DESC "\n"); 01209 01210 return result; 01211 } 01212 01213 01219 static void __exit usb_stk11xx_exit(void) 01220 { 01221 STK_INFO("usb_stk11xx_exit: Syntek USB2.0 webcam driver shutdown\n"); 01222 01223 // Deregister this driver with the USB subsystem 01224 usb_deregister(&usb_stk11xx_driver); 01225 } 01226 01227 01228 module_init(usb_stk11xx_init); 01229 module_exit(usb_stk11xx_exit); 01232 MODULE_PARM_DESC(fps, "Frames per second [5-30]"); 01233 MODULE_PARM_DESC(hflip, "Horizontal image flip"); 01234 MODULE_PARM_DESC(vflip, "Vertical image flip"); 01235 MODULE_PARM_DESC(brightness, "Brightness setting"); 01236 MODULE_PARM_DESC(whiteness, "Whiteness setting"); 01237 MODULE_PARM_DESC(colour, "Colour setting"); 01238 MODULE_PARM_DESC(contrast, "Contrast setting"); 01239 MODULE_PARM_DESC(norm, "Norm setting (0=NTSC, 1=PAL)"); 01242 MODULE_LICENSE("GPL"); 01243 MODULE_AUTHOR(DRIVER_AUTHOR); 01244 MODULE_DESCRIPTION(DRIVER_DESC); 01245 MODULE_SUPPORTED_DEVICE(DRIVER_SUPPORT);