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 00092 00097 static struct usb_device_id stk11xx_table[] = { 00098 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A311_PRODUCT_ID) }, 00099 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A821_PRODUCT_ID) }, 00100 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A31_PRODUCT_ID) }, 00101 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A33_PRODUCT_ID) }, 00102 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A51_PRODUCT_ID) }, 00103 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A54_PRODUCT_ID) }, 00104 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6D51_PRODUCT_ID) }, 00105 00106 { USB_DEVICE(USB_SYNTEK2_VENDOR_ID, USB_STK_0501_PRODUCT_ID) }, 00107 { } 00108 }; 00109 00110 00111 MODULE_DEVICE_TABLE(usb, stk11xx_table); 00124 int usb_stk11xx_isoc_init(struct usb_stk11xx *dev) 00125 { 00126 int i, j; 00127 int ret = 0; 00128 struct urb *urb; 00129 struct usb_device *udev; 00130 00131 if (dev == NULL) 00132 return -EFAULT; 00133 00134 if (dev->isoc_init_ok) 00135 return 0; 00136 00137 udev = dev->udev; 00138 00139 STK_DEBUG("usb_stk11xx_isoc_init()\n"); 00140 00141 // Allocate URB structure 00142 for (i=0; i<MAX_ISO_BUFS; i++) { 00143 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL); 00144 00145 if (urb == NULL) { 00146 STK_ERROR("Failed to allocate URB %d\n", i); 00147 ret = -ENOMEM; 00148 break; 00149 } 00150 00151 dev->isobuf[i].urb = urb; 00152 } 00153 00154 if (ret) { 00155 while (i >= 0) { 00156 if (dev->isobuf[i].urb != NULL) 00157 usb_free_urb(dev->isobuf[i].urb); 00158 00159 dev->isobuf[i].urb = NULL; 00160 i--; 00161 } 00162 00163 return ret; 00164 } 00165 00166 // Init URB structure 00167 for (i=0; i<MAX_ISO_BUFS; i++) { 00168 urb = dev->isobuf[i].urb; 00169 00170 urb->interval = 1; 00171 urb->dev = udev; 00172 urb->pipe = usb_rcvisocpipe(udev, dev->isoc_in_endpointAddr); 00173 urb->transfer_flags = URB_ISO_ASAP; 00174 urb->transfer_buffer = dev->isobuf[i].data; 00175 urb->transfer_buffer_length = ISO_BUFFER_SIZE; 00176 urb->complete = usb_stk11xx_isoc_handler; 00177 urb->context = dev; 00178 urb->start_frame = 0; 00179 urb->number_of_packets = ISO_FRAMES_PER_DESC; 00180 00181 for (j=0; j<ISO_FRAMES_PER_DESC; j++) { 00182 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE; 00183 urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE; //dev->isoc_in_size; 00184 } 00185 } 00186 00187 STK_DEBUG("dev->isoc_in_size = %X\n", dev->isoc_in_size); 00188 STK_DEBUG("dev->isoc_in_endpointAddr = %X\n", dev->isoc_in_endpointAddr); 00189 00190 // Link 00191 for (i=0; i<MAX_ISO_BUFS; i++) { 00192 ret = usb_submit_urb(dev->isobuf[i].urb, GFP_KERNEL); 00193 00194 if (ret) 00195 STK_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret); 00196 else 00197 STK_DEBUG("URB 0x%p submitted.\n", dev->isobuf[i].urb); 00198 00199 switch (ret) { 00200 case -ENOMEM: 00201 STK_ERROR("ENOMEM\n"); 00202 break; 00203 case -ENODEV: 00204 STK_ERROR("ENODEV\n"); 00205 break; 00206 case -ENXIO: 00207 STK_ERROR("ENXIO\n"); 00208 break; 00209 case -EINVAL: 00210 STK_ERROR("EINVAL\n"); 00211 break; 00212 case -EAGAIN: 00213 STK_ERROR("EAGAIN\n"); 00214 break; 00215 case -EFBIG: 00216 STK_ERROR("EFBIG\n"); 00217 break; 00218 case -EPIPE: 00219 STK_ERROR("EPIPE\n"); 00220 break; 00221 case -EMSGSIZE: 00222 STK_ERROR("EMSGSIZE\n"); 00223 break; 00224 } 00225 } 00226 00227 // All is done 00228 dev->isoc_init_ok = 1; 00229 00230 return 0; 00231 } 00232 00233 00243 void usb_stk11xx_isoc_handler(struct urb *urb) 00244 { 00245 int i; 00246 int ret; 00247 int skip; 00248 00249 int awake = 0; 00250 int framestatus; 00251 int framelen; 00252 00253 unsigned char *fill = NULL; 00254 unsigned char *iso_buf = NULL; 00255 00256 struct usb_stk11xx *dev; 00257 struct stk11xx_frame_buf *framebuf; 00258 00259 STK_STREAM("Isoc handler\n"); 00260 00261 dev = (struct usb_stk11xx *) urb->context; 00262 00263 if (dev == NULL) { 00264 STK_ERROR("isoc_handler called with NULL device !\n"); 00265 return; 00266 } 00267 00268 if (urb->status == -ENOENT || urb->status == -ECONNRESET) { 00269 STK_DEBUG("URB unlinked synchronuously !\n"); 00270 return; 00271 } 00272 00273 if (urb->status != -EINPROGRESS && urb->status != 0) { 00274 const char *errmsg; 00275 00276 errmsg = "Unknown"; 00277 00278 switch(urb->status) { 00279 case -ENOSR: 00280 errmsg = "Buffer error (overrun)"; 00281 break; 00282 00283 case -EPIPE: 00284 errmsg = "Stalled (device not responding)"; 00285 break; 00286 00287 case -EOVERFLOW: 00288 errmsg = "Babble (bad cable?)"; 00289 break; 00290 00291 case -EPROTO: 00292 errmsg = "Bit-stuff error (bad cable?)"; 00293 break; 00294 00295 case -EILSEQ: 00296 errmsg = "CRC/Timeout (could be anything)"; 00297 break; 00298 00299 case -ETIMEDOUT: 00300 errmsg = "NAK (device does not respond)"; 00301 break; 00302 } 00303 00304 STK_ERROR("isoc_handler() called with status %d [%s].\n", urb->status, errmsg); 00305 00306 dev->visoc_errors++; 00307 00308 wake_up_interruptible(&dev->wait_frame); 00309 00310 urb->dev = dev->udev; 00311 ret = usb_submit_urb(urb, GFP_ATOMIC); 00312 00313 if (ret != 0) { 00314 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret); 00315 } 00316 00317 return; 00318 } 00319 00320 framebuf = dev->fill_frame; 00321 00322 if (framebuf == NULL) { 00323 STK_ERROR("isoc_handler without valid fill frame !\n"); 00324 00325 wake_up_interruptible(&dev->wait_frame); 00326 00327 urb->dev = dev->udev; 00328 ret = usb_submit_urb(urb, GFP_ATOMIC); 00329 00330 if (ret != 0) { 00331 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret); 00332 } 00333 00334 return; 00335 } 00336 else { 00337 fill = framebuf->data + framebuf->filled; 00338 } 00339 00340 // Reset ISOC error counter 00341 dev->visoc_errors = 0; 00342 00343 // Compact data 00344 for (i=0; i<urb->number_of_packets; i++) { 00345 framestatus = urb->iso_frame_desc[i].status; 00346 framelen = urb->iso_frame_desc[i].actual_length; 00347 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset; 00348 00349 if (framestatus == 0) { 00350 skip = 4; 00351 00352 if (framelen > 4) { 00353 // we found something informational from there 00354 // the isoc frames have to type of headers 00355 // type1: 00 xx 00 00 or 20 xx 00 00 00356 // type2: 80 xx 00 00 00 00 00 00 or a0 xx 00 00 00 00 00 00 00357 // xx is a sequencer which has never been seen over 0x3f 00358 // 00359 // imho data written down looks like bayer, i see similarities after 00360 // every 640 bytes 00361 if (*iso_buf & 0x80) { 00362 skip = 8; 00363 } 00364 00365 // Our buffer is full !!! 00366 if (framelen - skip + framebuf->filled > dev->frame_size) { 00367 STK_ERROR("Frame buffer overflow !\n"); 00368 framebuf->errors++; 00369 } 00370 // All is OK 00371 else { 00372 memcpy(fill, iso_buf + skip, framelen - skip); 00373 fill += framelen - skip; 00374 } 00375 00376 // New size of our buffer 00377 framebuf->filled += framelen - skip; 00378 } 00379 00380 STK_STREAM("URB : Length = %d - Skip = %d - Buffer size = %d\n", 00381 framelen, skip, framebuf->filled); 00382 00383 // Data is always follow by a frame with a length '4' 00384 if (framelen == 4) { 00385 if (framebuf->filled > 0) { 00386 // Our buffer has enough data ? 00387 if (framebuf->filled < dev->frame_size) 00388 framebuf->errors++; 00389 00390 // If there are errors, we skip a frame... 00391 if (framebuf->errors == 0) { 00392 if (stk11xx_next_frame(dev)) 00393 dev->vframes_dumped++; 00394 } 00395 else 00396 dev->vframes_error++; 00397 00398 awake = 1; 00399 framebuf = dev->fill_frame; 00400 framebuf->filled = 0; 00401 framebuf->errors = 0; 00402 fill = framebuf->data; 00403 } 00404 } 00405 } 00406 else { 00407 STK_ERROR("Iso frame %d of USB has error %d\n", i, framestatus); 00408 } 00409 } 00410 00411 if (awake == 1) 00412 wake_up_interruptible(&dev->wait_frame); 00413 00414 urb->dev = dev->udev; 00415 00416 ret = usb_submit_urb(urb, GFP_ATOMIC); 00417 00418 if (ret != 0) { 00419 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret); 00420 } 00421 } 00422 00423 00431 void usb_stk11xx_isoc_cleanup(struct usb_stk11xx *dev) 00432 { 00433 int i; 00434 00435 STK_DEBUG("Isoc cleanup\n"); 00436 00437 if (dev == NULL) 00438 return; 00439 00440 if (dev->isoc_init_ok == 0) 00441 return; 00442 00443 // Unlinking ISOC buffers 00444 for (i=0; i<MAX_ISO_BUFS; i++) { 00445 struct urb *urb; 00446 00447 urb = dev->isobuf[i].urb; 00448 00449 if (urb != 0) { 00450 if (dev->isoc_init_ok) 00451 usb_kill_urb(urb); 00452 00453 usb_free_urb(urb); 00454 dev->isobuf[i].urb = NULL; 00455 } 00456 } 00457 00458 // All is done 00459 dev->isoc_init_ok = 0; 00460 } 00461 00462 00463 00474 int usb_stk11xx_set_feature(struct usb_stk11xx *dev, int index) 00475 { 00476 int result; 00477 struct usb_device *udev = dev->udev; 00478 00479 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 00480 USB_REQ_SET_FEATURE, 00481 USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE, 00482 USB_DEVICE_REMOTE_WAKEUP, 00483 index, 00484 NULL, 00485 0, 00486 500); 00487 00488 if (result < 0) 00489 STK_ERROR("SET FEATURE fail !\n"); 00490 else 00491 STK_DEBUG("SET FEATURE\n"); 00492 00493 return result; 00494 } 00495 00496 00506 int usb_stk11xx_set_configuration(struct usb_stk11xx *dev) 00507 { 00508 int result; 00509 struct usb_device *udev = dev->udev; 00510 00511 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 00512 USB_REQ_SET_CONFIGURATION, 00513 USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE, 00514 0, 00515 udev->config[0].desc.bConfigurationValue, 00516 NULL, 00517 0, 00518 500); 00519 00520 if (result < 0) 00521 STK_ERROR("SET CONFIGURATION fail !\n"); 00522 else 00523 STK_DEBUG("SET CONFIGURATION %d\n", udev->config[0].desc.bConfigurationValue); 00524 00525 return result; 00526 } 00527 00528 00540 int usb_stk11xx_write_registry(struct usb_stk11xx *dev, __u16 index, __u16 value) 00541 { 00542 int result; 00543 struct usb_device *udev = dev->udev; 00544 00545 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 00546 0x01, 00547 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 00548 value, 00549 index, 00550 NULL, 00551 0, 00552 500); 00553 00554 if (result < 0) 00555 STK_ERROR("Write registry fails %02X = %02X", index, value); 00556 00557 return result; 00558 } 00559 00560 00572 int usb_stk11xx_read_registry(struct usb_stk11xx *dev, __u16 index, int *value) 00573 { 00574 int result; 00575 00576 struct usb_device *udev = dev->udev; 00577 00578 *value = 0; 00579 00580 result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 00581 0x00, 00582 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 00583 0x00, 00584 index, 00585 (__u8 *) value, 00586 sizeof(__u8), 00587 500); 00588 00589 if (result < 0) 00590 STK_ERROR("Read registry fails %02X", index); 00591 00592 return result; 00593 } 00594 00595 00606 static int usb_stk11xx_default_settings(struct usb_stk11xx *dev) 00607 { 00608 switch (dev->webcam_model) { 00609 case SYNTEK_STK_M811: 00610 case SYNTEK_STK_A311: 00611 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps; 00612 dev->vsettings.vflip = (default_vflip == -1) ? 1 : default_vflip; 00613 dev->vsettings.hflip = (default_hflip == -1) ? 1 : default_hflip; 00614 00615 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness; 00616 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness; 00617 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast; 00618 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour; 00619 break; 00620 00621 case SYNTEK_STK_A821: 00622 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps; 00623 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip; 00624 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip; 00625 00626 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness; 00627 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness; 00628 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast; 00629 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour; 00630 break; 00631 00632 case SYNTEK_STK_6A31: 00633 case SYNTEK_STK_6A33: 00634 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps; 00635 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip; 00636 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip; 00637 00638 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness; 00639 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness; 00640 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast; 00641 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour; 00642 break; 00643 00644 case SYNTEK_STK_6A51: 00645 case SYNTEK_STK_6D51: 00646 case SYNTEK_STK_6A54: 00647 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps; 00648 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip; 00649 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip; 00650 00651 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness; 00652 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness; 00653 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast; 00654 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour; 00655 break; 00656 00657 default: 00658 return -1; 00659 } 00660 00661 dev->vsettings.default_brightness = dev->vsettings.brightness; 00662 dev->vsettings.default_whiteness = dev->vsettings.whiteness; 00663 dev->vsettings.default_contrast = dev->vsettings.contrast; 00664 dev->vsettings.default_colour = dev->vsettings.colour; 00665 dev->vsettings.default_hflip = dev->vsettings.hflip; 00666 dev->vsettings.default_vflip = dev->vsettings.vflip; 00667 return 0; 00668 } 00669 00670 00682 static int usb_stk11xx_probe(struct usb_interface *interface, const struct usb_device_id *id) 00683 { 00684 int i; 00685 int err; 00686 size_t buffer_size; 00687 00688 int vendor_id; 00689 int product_id; 00690 int bNumInterfaces; 00691 int webcam_model; 00692 int webcam_type; 00693 00694 struct usb_stk11xx *dev = NULL; 00695 struct usb_device *udev = interface_to_usbdev(interface); 00696 struct usb_host_interface *iface_desc; 00697 struct usb_endpoint_descriptor *endpoint; 00698 00699 00700 // Get USB VendorID and ProductID 00701 vendor_id = le16_to_cpu(udev->descriptor.idVendor); 00702 product_id = le16_to_cpu(udev->descriptor.idProduct); 00703 00704 // Check if we can handle this device 00705 STK_DEBUG("Probe function called with VendorID=%04X, ProductID=%04X and InterfaceNumber=%d\n", 00706 vendor_id, product_id, interface->cur_altsetting->desc.bInterfaceNumber); 00707 00708 // The interface are probed one by one. 00709 // We are interested in the video interface (always the interface '0') 00710 // The interfaces '1' or '2' (if presents) are the audio control. 00711 if (interface->cur_altsetting->desc.bInterfaceNumber > 0) 00712 return -ENODEV; 00713 00714 // Detect device 00715 if (vendor_id == USB_SYNTEK1_VENDOR_ID) { 00716 switch (product_id) { 00717 case USB_STK_A311_PRODUCT_ID: 00718 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00719 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0xA311.\n"); 00720 webcam_model = SYNTEK_STK_A311; 00721 webcam_type = STK11XX_SXGA; 00722 break; 00723 00724 case USB_STK_A821_PRODUCT_ID: 00725 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00726 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xA821.\n"); 00727 webcam_model = SYNTEK_STK_A821; 00728 webcam_type = STK11XX_VGA; 00729 break; 00730 00731 case USB_STK_6A31_PRODUCT_ID: 00732 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00733 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A31.\n"); 00734 webcam_model = SYNTEK_STK_6A31; 00735 webcam_type = STK11XX_VGA; 00736 break; 00737 00738 case USB_STK_6A33_PRODUCT_ID: 00739 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00740 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A33.\n"); 00741 webcam_model = SYNTEK_STK_6A33; 00742 webcam_type = STK11XX_VGA; 00743 break; 00744 00745 case USB_STK_6A51_PRODUCT_ID: 00746 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00747 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A51.\n"); 00748 webcam_model = SYNTEK_STK_6A51; 00749 webcam_type = STK11XX_VGA; 00750 break; 00751 00752 case USB_STK_6A54_PRODUCT_ID: 00753 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00754 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A54.\n"); 00755 webcam_model = SYNTEK_STK_6A54; 00756 webcam_type = STK11XX_VGA; 00757 break; 00758 00759 case USB_STK_6D51_PRODUCT_ID: 00760 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00761 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6D51.\n"); 00762 webcam_model = SYNTEK_STK_6D51; 00763 webcam_type = STK11XX_VGA; 00764 break; 00765 00766 default: 00767 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n", 00768 le16_to_cpu(udev->descriptor.idProduct)); 00769 return -ENODEV; 00770 } 00771 } 00772 else if (vendor_id == USB_SYNTEK2_VENDOR_ID) { 00773 switch (product_id) { 00774 case USB_STK_0501_PRODUCT_ID: 00775 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n"); 00776 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0501.\n"); 00777 webcam_model = SYNTEK_STK_M811; 00778 webcam_type = STK11XX_SXGA; 00779 break; 00780 00781 default: 00782 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n", 00783 le16_to_cpu(udev->descriptor.idProduct)); 00784 return -ENODEV; 00785 } 00786 } 00787 else 00788 return -ENODEV; 00789 00790 // Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device 00791 dev = kzalloc(sizeof(struct usb_stk11xx), GFP_KERNEL); 00792 00793 if (dev == NULL) { 00794 STK_ERROR("Out of memory !\n"); 00795 return -ENOMEM; 00796 } 00797 00798 // Init mutexes, spinlock, etc. 00799 init_MUTEX(&dev->mutex); 00800 mutex_init(&dev->modlock); 00801 spin_lock_init(&dev->spinlock); 00802 init_waitqueue_head(&dev->wait_frame); 00803 00804 // Save pointers 00805 dev->webcam_model = webcam_model; 00806 dev->webcam_type = webcam_type; 00807 dev->udev = udev; 00808 dev->interface = interface; 00809 00810 // Read the product release 00811 dev->release = le16_to_cpu(udev->descriptor.bcdDevice); 00812 STK_INFO("Release: %04x\n", dev->release); 00813 00814 // How many interfaces (1 or 3) ? 00815 bNumInterfaces = udev->config->desc.bNumInterfaces; 00816 STK_INFO("Number of interfaces : %d\n", bNumInterfaces); 00817 00818 00819 // Constructor 00820 dev->nbuffers = 2; 00821 dev->len_per_image = PAGE_ALIGN((1280 * 1024 * 4)); 00822 00823 00824 // Switch on the camera (to detect size of buffers) 00825 dev_stk11xx_camera_on(dev); 00826 00827 00828 // Set up the endpoint information 00829 // use only the first int-in and isoc-in endpoints 00830 // for the current alternate setting 00831 iface_desc = interface->cur_altsetting; 00832 00833 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 00834 endpoint = &iface_desc->endpoint[i].desc; 00835 00836 if (!dev->int_in_endpointAddr 00837 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) 00838 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) { 00839 // we found an interrupt in endpoint 00840 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 00841 00842 dev->int_in_size = buffer_size; 00843 dev->int_in_endpointAddr = (endpoint->bEndpointAddress & 0xf); 00844 } 00845 00846 if (!dev->isoc_in_endpointAddr 00847 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) 00848 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)) { 00849 // we found an isoc in endpoint 00850 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 00851 00852 dev->isoc_in_size = buffer_size; 00853 dev->isoc_in_endpointAddr = (endpoint->bEndpointAddress & 0xf); 00854 } 00855 } 00856 00857 if (!(dev->int_in_endpointAddr && dev->isoc_in_endpointAddr)) { 00858 STK_ERROR("Could not find both int-in and isoc-in endpoints"); 00859 00860 kfree(dev); 00861 00862 return -ENODEV; 00863 } 00864 00865 00866 // Switch off camera 00867 dev_stk11xx_camera_off(dev); 00868 00869 // Initialize the video device 00870 dev->vdev = video_device_alloc(); 00871 00872 if (!dev->vdev) { 00873 kfree(dev); 00874 return -ENOMEM; 00875 } 00876 00877 // Initialize the camera 00878 dev_stk11xx_initialize_device(dev); 00879 00880 // Register the video device 00881 err = v4l_stk11xx_register_video_device(dev); 00882 00883 if (err) { 00884 kfree(dev); 00885 return err; 00886 } 00887 00888 // Create the entries in the sys filesystem 00889 stk11xx_create_sysfs_files(dev->vdev); 00890 00891 // Save our data pointer in this interface device 00892 usb_set_intfdata(interface, dev); 00893 00894 // Default settings video device 00895 usb_stk11xx_default_settings(dev); 00896 00897 // Enable power management feature 00898 // usb_autopm_enable(dev->interface); 00899 00900 return 0; 00901 } 00902 00903 00910 static void usb_stk11xx_disconnect(struct usb_interface *interface) 00911 { 00912 struct usb_stk11xx *dev = usb_get_intfdata(interface); 00913 00914 STK_INFO("Syntek USB2.0 Camera disconnected\n"); 00915 00916 // We got unplugged; this is signalled by an EPIPE error code 00917 if (dev->vopen) { 00918 STK_INFO("Disconnected while webcam is in use !\n"); 00919 dev->error_status = EPIPE; 00920 } 00921 00922 // Alert waiting processes 00923 wake_up_interruptible(&dev->wait_frame); 00924 00925 // Wait until device is closed 00926 while (dev->vopen) 00927 schedule(); 00928 00929 // Remove the entries in the sys filesystem 00930 stk11xx_remove_sysfs_files(dev->vdev); 00931 00932 // Unregister the video device 00933 v4l_stk11xx_unregister_video_device(dev); 00934 00935 usb_set_intfdata(interface, NULL); 00936 00937 kfree(dev); 00938 } 00939 00940 #ifdef CONFIG_PM 00941 int usb_stk11xx_suspend(struct usb_interface *interface, pm_message_t message) 00942 { 00943 struct usb_stk11xx *dev = usb_get_intfdata(interface); 00944 00945 STK_INFO("Syntek USB2.0 Camera Suspend\n"); 00946 00947 mutex_lock(&dev->modlock); 00948 if (dev->vopen) { 00949 // Stop the video stream 00950 dev_stk11xx_stop_stream(dev); 00951 00952 // ISOC and URB cleanup 00953 usb_stk11xx_isoc_cleanup(dev); 00954 00955 // Free memory 00956 // stk11xx_free_buffers(dev); 00957 00958 // Switch off the camera 00959 dev_stk11xx_camera_off(dev); 00960 00961 dev_stk11xx_camera_asleep(dev); 00962 } 00963 mutex_unlock(&dev->modlock); 00964 00965 return 0; 00966 } 00967 00968 00969 int usb_stk11xx_resume(struct usb_interface *interface) 00970 { 00971 struct usb_stk11xx *dev = usb_get_intfdata(interface); 00972 00973 STK_INFO("Syntek USB2.0 Camera Resume\n"); 00974 00975 mutex_lock(&dev->modlock); 00976 00977 // Initialize the camera 00978 dev_stk11xx_initialize_device(dev); 00979 00980 if (dev->vopen) 00981 { 00982 // Select the video mode 00983 v4l_stk11xx_select_video_mode(dev, dev->view.x, dev->view.y); 00984 00985 // Clear the buffers 00986 stk11xx_clear_buffers(dev); 00987 00988 // Initialize the device 00989 dev_stk11xx_init_camera(dev); 00990 dev_stk11xx_camera_on(dev); 00991 dev_stk11xx_reconf_camera(dev); 00992 00993 // ISOC and URB init 00994 usb_stk11xx_isoc_init(dev); 00995 00996 // Start the video stream 00997 dev_stk11xx_start_stream(dev); 00998 00999 // Video settings 01000 dev_stk11xx_camera_settings(dev); 01001 } 01002 mutex_unlock(&dev->modlock); 01003 01004 return 0; 01005 } 01006 #endif // CONFIG_PM 01007 01008 01014 static struct usb_driver usb_stk11xx_driver = { 01015 .name = "usb_stk11xx_driver", 01016 .probe = usb_stk11xx_probe, 01017 .disconnect = usb_stk11xx_disconnect, 01018 .id_table = stk11xx_table, 01019 #ifdef CONFIG_PM 01020 .suspend = usb_stk11xx_suspend, 01021 .resume = usb_stk11xx_resume, 01022 #endif 01023 }; 01024 01025 01030 static int fps; 01031 01036 static int hflip = -1; 01037 01042 static int vflip = -1; 01043 01048 static int brightness = -1; 01049 01054 static int whiteness = -1; 01055 01060 static int contrast = -1; 01061 01066 static int colour = -1; 01067 01068 01069 module_param(fps, int, 0444); 01070 module_param(hflip, int, 0444); 01071 module_param(vflip, int, 0444); 01073 module_param(brightness, int, 0444); 01074 module_param(whiteness, int, 0444); 01075 module_param(contrast, int, 0444); 01076 module_param(colour, int, 0444); 01087 static int __init usb_stk11xx_init(void) 01088 { 01089 int result; 01090 01091 01092 STK_INFO("Syntek USB2.0 webcam driver startup\n"); 01093 01094 // Frame per second parameter 01095 if (fps) { 01096 if (fps < 9 || fps > 30) { 01097 STK_ERROR("Framerate out of bounds [10-30] !\n"); 01098 return -EINVAL; 01099 } 01100 01101 default_fps = fps; 01102 } 01103 01104 // Horizontal flip value 01105 if ((hflip == 0) || (hflip == 1)) { 01106 STK_DEBUG("Set horizontal flip = %d\n", hflip); 01107 01108 default_hflip = hflip; 01109 } 01110 01111 // Vertical flip value 01112 if ((vflip == 0) || (vflip == 1)) { 01113 STK_DEBUG("Set vertical flip = %d\n", vflip); 01114 01115 default_vflip = vflip; 01116 } 01117 01118 // Brightness value 01119 if (brightness > -1) { 01120 STK_DEBUG("Set brightness = 0x%X\n", brightness); 01121 01122 default_brightness = 0xffff & brightness; 01123 } 01124 01125 // Whiteness value 01126 if (whiteness > -1) { 01127 STK_DEBUG("Set whiteness = 0x%X\n", whiteness); 01128 01129 default_whiteness = 0xffff & whiteness; 01130 } 01131 01132 // Contrast value 01133 if (contrast > -1) { 01134 STK_DEBUG("Set contrast = 0x%X\n", contrast); 01135 01136 default_contrast = 0xffff & contrast; 01137 } 01138 01139 // Colour value 01140 if (colour > -1) { 01141 STK_DEBUG("Set colour = 0x%X\n", colour); 01142 01143 default_colour = 0xffff & colour; 01144 } 01145 01146 01147 // Register the driver with the USB subsystem 01148 result = usb_register(&usb_stk11xx_driver); 01149 01150 if (result) 01151 STK_ERROR("usb_register failed ! Error number %d\n", result); 01152 01153 STK_INFO(DRIVER_VERSION " : " DRIVER_DESC "\n"); 01154 01155 return result; 01156 } 01157 01158 01164 static void __exit usb_stk11xx_exit(void) 01165 { 01166 STK_INFO("usb_stk11xx_exit: Syntek USB2.0 webcam driver shutdown\n"); 01167 01168 // Deregister this driver with the USB subsystem 01169 usb_deregister(&usb_stk11xx_driver); 01170 } 01171 01172 01173 module_init(usb_stk11xx_init); 01174 module_exit(usb_stk11xx_exit); 01177 MODULE_PARM_DESC(fps, "Frames per second [5-30]"); 01178 MODULE_PARM_DESC(hflip, "Horizontal image flip"); 01179 MODULE_PARM_DESC(vflip, "Vertical image flip"); 01180 MODULE_PARM_DESC(brightness, "Brightness setting"); 01181 MODULE_PARM_DESC(whiteness, "Whiteness setting"); 01182 MODULE_PARM_DESC(colour, "Colour setting"); 01183 MODULE_PARM_DESC(contrast, "Contrast setting"); 01186 MODULE_LICENSE("GPL"); 01187 MODULE_AUTHOR(DRIVER_AUTHOR); 01188 MODULE_DESCRIPTION(DRIVER_DESC); 01189 MODULE_SUPPORTED_DEVICE(DRIVER_SUPPORT);