00001
00034 #include <linux/module.h>
00035 #include <linux/init.h>
00036 #include <linux/kernel.h>
00037 #include <linux/errno.h>
00038 #include <linux/slab.h>
00039 #include <linux/kref.h>
00040
00041 #include <linux/usb.h>
00042 #include <media/v4l2-common.h>
00043
00044 #include "stk11xx.h"
00045
00046
00051 static int default_fps = -1;
00052
00057 static int default_hflip = -1;
00058
00063 static int default_vflip = -1;
00064
00069 static int default_brightness = -1;
00070
00075 static int default_whiteness = -1;
00076
00081 static int default_contrast = -1;
00082
00087 static int default_colour = -1;
00088
00089
00094 static struct usb_device_id stk11xx_table[] = {
00095 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A311_PRODUCT_ID) },
00096 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A821_PRODUCT_ID) },
00097 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A31_PRODUCT_ID) },
00098
00099 { USB_DEVICE(USB_SYNTEK2_VENDOR_ID, USB_STK_0501_PRODUCT_ID) },
00100 { }
00101 };
00102
00103
00104 MODULE_DEVICE_TABLE(usb, stk11xx_table);
00117 int usb_stk11xx_isoc_init(struct usb_stk11xx *dev)
00118 {
00119 int i, j;
00120 int ret = 0;
00121 struct urb *urb;
00122 struct usb_device *udev;
00123
00124 if (dev == NULL)
00125 return -EFAULT;
00126
00127 if (dev->isoc_init_ok)
00128 return 0;
00129
00130 udev = dev->udev;
00131
00132 STK_DEBUG("usb_stk11xx_isoc_init()\n");
00133
00134
00135 for (i=0; i<MAX_ISO_BUFS; i++) {
00136 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
00137
00138 if (urb == NULL) {
00139 STK_ERROR("Failed to allocate URB %d\n", i);
00140 ret = -ENOMEM;
00141 break;
00142 }
00143
00144 dev->isobuf[i].urb = urb;
00145 }
00146
00147 if (ret) {
00148 while (i >= 0) {
00149 if (dev->isobuf[i].urb != NULL)
00150 usb_free_urb(dev->isobuf[i].urb);
00151
00152 dev->isobuf[i].urb = NULL;
00153 i--;
00154 }
00155
00156 return ret;
00157 }
00158
00159
00160 for (i=0; i<MAX_ISO_BUFS; i++) {
00161 urb = dev->isobuf[i].urb;
00162
00163 urb->interval = 1;
00164 urb->dev = udev;
00165 urb->pipe = usb_rcvisocpipe(udev, dev->isoc_in_endpointAddr);
00166 urb->transfer_flags = URB_ISO_ASAP;
00167 urb->transfer_buffer = dev->isobuf[i].data;
00168 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
00169 urb->complete = usb_stk11xx_isoc_handler;
00170 urb->context = dev;
00171 urb->start_frame = 0;
00172 urb->number_of_packets = ISO_FRAMES_PER_DESC;
00173
00174 for (j=0; j<ISO_FRAMES_PER_DESC; j++) {
00175 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
00176 urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE;
00177 }
00178 }
00179
00180 STK_DEBUG("dev->isoc_in_size = %X\n", dev->isoc_in_size);
00181 STK_DEBUG("dev->isoc_in_endpointAddr = %X\n", dev->isoc_in_endpointAddr);
00182
00183
00184 for (i=0; i<MAX_ISO_BUFS; i++) {
00185 ret = usb_submit_urb(dev->isobuf[i].urb, GFP_KERNEL);
00186
00187 if (ret)
00188 STK_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
00189 else
00190 STK_DEBUG("URB 0x%p submitted.\n", dev->isobuf[i].urb);
00191
00192 switch (ret) {
00193 case -ENOMEM:
00194 STK_ERROR("ENOMEM\n");
00195 break;
00196 case -ENODEV:
00197 STK_ERROR("ENODEV\n");
00198 break;
00199 case -ENXIO:
00200 STK_ERROR("ENXIO\n");
00201 break;
00202 case -EINVAL:
00203 STK_ERROR("EINVAL\n");
00204 break;
00205 case -EAGAIN:
00206 STK_ERROR("EAGAIN\n");
00207 break;
00208 case -EFBIG:
00209 STK_ERROR("EFBIG\n");
00210 break;
00211 case -EPIPE:
00212 STK_ERROR("EPIPE\n");
00213 break;
00214 case -EMSGSIZE:
00215 STK_ERROR("EMSGSIZE\n");
00216 break;
00217 }
00218 }
00219
00220
00221 dev->isoc_init_ok = 1;
00222
00223 return 0;
00224 }
00225
00226
00236 void usb_stk11xx_isoc_handler(struct urb *urb)
00237 {
00238 int i;
00239 int ret;
00240 int skip;
00241
00242 int awake = 0;
00243 int framestatus;
00244 int framelen;
00245
00246 unsigned char *fill = NULL;
00247 unsigned char *iso_buf = NULL;
00248
00249 struct usb_stk11xx *dev;
00250 struct stk11xx_frame_buf *framebuf;
00251
00252 STK_STREAM("Isoc handler\n");
00253
00254 dev = (struct usb_stk11xx *) urb->context;
00255
00256 if (dev == NULL) {
00257 STK_ERROR("isoc_handler called with NULL device !\n");
00258 return;
00259 }
00260
00261 if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
00262 STK_DEBUG("URB unlinked synchronuously !\n");
00263 return;
00264 }
00265
00266 if (urb->status != -EINPROGRESS && urb->status != 0) {
00267 const char *errmsg;
00268
00269 errmsg = "Unknown";
00270
00271 switch(urb->status) {
00272 case -ENOSR:
00273 errmsg = "Buffer error (overrun)";
00274 break;
00275
00276 case -EPIPE:
00277 errmsg = "Stalled (device not responding)";
00278 break;
00279
00280 case -EOVERFLOW:
00281 errmsg = "Babble (bad cable?)";
00282 break;
00283
00284 case -EPROTO:
00285 errmsg = "Bit-stuff error (bad cable?)";
00286 break;
00287
00288 case -EILSEQ:
00289 errmsg = "CRC/Timeout (could be anything)";
00290 break;
00291
00292 case -ETIMEDOUT:
00293 errmsg = "NAK (device does not respond)";
00294 break;
00295 }
00296
00297 STK_ERROR("isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
00298
00299 dev->visoc_errors++;
00300
00301 wake_up_interruptible(&dev->wait_frame);
00302
00303 urb->dev = dev->udev;
00304 ret = usb_submit_urb(urb, GFP_ATOMIC);
00305
00306 if (ret != 0) {
00307 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00308 }
00309
00310 return;
00311 }
00312
00313 framebuf = dev->fill_frame;
00314
00315 if (framebuf == NULL) {
00316 STK_ERROR("isoc_handler without valid fill frame !\n");
00317
00318 wake_up_interruptible(&dev->wait_frame);
00319
00320 urb->dev = dev->udev;
00321 ret = usb_submit_urb(urb, GFP_ATOMIC);
00322
00323 if (ret != 0) {
00324 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00325 }
00326
00327 return;
00328 }
00329 else {
00330 fill = framebuf->data + framebuf->filled;
00331 }
00332
00333
00334 dev->visoc_errors = 0;
00335
00336
00337 for (i=0; i<urb->number_of_packets; i++) {
00338 framestatus = urb->iso_frame_desc[i].status;
00339 framelen = urb->iso_frame_desc[i].actual_length;
00340 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
00341
00342 if (framestatus == 0) {
00343 skip = 4;
00344
00345 if (framelen > 4) {
00346
00347
00348
00349
00350
00351
00352
00353
00354 if (*iso_buf & 0x80) {
00355 skip = 8;
00356 }
00357
00358
00359 if (framelen - skip + framebuf->filled > dev->frame_size) {
00360 STK_ERROR("Frame buffer overflow !\n");
00361 framebuf->errors++;
00362 }
00363
00364 else {
00365 memcpy(fill, iso_buf + skip, framelen - skip);
00366 fill += framelen - skip;
00367 }
00368
00369
00370 framebuf->filled += framelen - skip;
00371 }
00372
00373 STK_STREAM("URB : Length = %d - Skip = %d - Buffer size = %d\n",
00374 framelen, skip, framebuf->filled);
00375
00376
00377 if (framelen == 4) {
00378 if (framebuf->filled > 0) {
00379
00380 if (framebuf->filled < dev->frame_size)
00381 framebuf->errors++;
00382
00383
00384 if (framebuf->errors == 0) {
00385 if (stk11xx_next_frame(dev))
00386 dev->vframes_dumped++;
00387 }
00388 else
00389 dev->vframes_error++;
00390
00391 awake = 1;
00392 framebuf = dev->fill_frame;
00393 framebuf->filled = 0;
00394 framebuf->errors = 0;
00395 fill = framebuf->data;
00396 }
00397 }
00398 }
00399 else {
00400 STK_ERROR("Iso frame %d of USB has error %d\n", i, framestatus);
00401 }
00402 }
00403
00404 if (awake == 1)
00405 wake_up_interruptible(&dev->wait_frame);
00406
00407 urb->dev = dev->udev;
00408
00409 ret = usb_submit_urb(urb, GFP_ATOMIC);
00410
00411 if (ret != 0) {
00412 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00413 }
00414 }
00415
00416
00424 void usb_stk11xx_isoc_cleanup(struct usb_stk11xx *dev)
00425 {
00426 int i;
00427
00428 STK_DEBUG("Isoc cleanup\n");
00429
00430 if (dev == NULL)
00431 return;
00432
00433 if (dev->isoc_init_ok == 0)
00434 return;
00435
00436
00437 for (i=0; i<MAX_ISO_BUFS; i++) {
00438 struct urb *urb;
00439
00440 urb = dev->isobuf[i].urb;
00441
00442 if (urb != 0) {
00443 if (dev->isoc_init_ok)
00444 usb_kill_urb(urb);
00445
00446 usb_free_urb(urb);
00447 dev->isobuf[i].urb = NULL;
00448 }
00449 }
00450
00451
00452 dev->isoc_init_ok = 0;
00453 }
00454
00455
00456
00467 int usb_stk11xx_set_feature(struct usb_stk11xx *dev, int index)
00468 {
00469 int result;
00470 struct usb_device *udev = dev->udev;
00471
00472 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00473 USB_REQ_SET_FEATURE,
00474 USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE,
00475 USB_DEVICE_REMOTE_WAKEUP,
00476 index,
00477 NULL,
00478 0,
00479 500);
00480
00481 if (result < 0)
00482 STK_ERROR("SET FEATURE fail !\n");
00483 else
00484 STK_DEBUG("SET FEATURE\n");
00485
00486 return result;
00487 }
00488
00489
00499 int usb_stk11xx_set_configuration(struct usb_stk11xx *dev)
00500 {
00501 int result;
00502 struct usb_device *udev = dev->udev;
00503
00504 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00505 USB_REQ_SET_CONFIGURATION,
00506 USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE,
00507 0,
00508 udev->config[0].desc.bConfigurationValue,
00509 NULL,
00510 0,
00511 500);
00512
00513 if (result < 0)
00514 STK_ERROR("SET CONFIGURATION fail !\n");
00515 else
00516 STK_DEBUG("SET CONFIGURATION %d\n", udev->config[0].desc.bConfigurationValue);
00517
00518 return result;
00519 }
00520
00521
00533 int usb_stk11xx_write_registry(struct usb_stk11xx *dev, __u16 index, __u16 value)
00534 {
00535 int result;
00536 struct usb_device *udev = dev->udev;
00537
00538 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00539 0x01,
00540 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
00541 value,
00542 index,
00543 NULL,
00544 0,
00545 500);
00546
00547 if (result < 0)
00548 STK_ERROR("Write registry fails %02X = %02X", index, value);
00549
00550 return result;
00551 }
00552
00553
00565 int usb_stk11xx_read_registry(struct usb_stk11xx *dev, __u16 index, int *value)
00566 {
00567 int result;
00568
00569 struct usb_device *udev = dev->udev;
00570
00571 *value = 0;
00572
00573 result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
00574 0x00,
00575 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
00576 0x00,
00577 index,
00578 (__u8 *) value,
00579 sizeof(__u8),
00580 500);
00581
00582 if (result < 0)
00583 STK_ERROR("Read registry fails %02X", index);
00584
00585 return result;
00586 }
00587
00588
00599 static int usb_stk11xx_default_settings(struct usb_stk11xx *dev)
00600 {
00601 switch (dev->webcam_model) {
00602 case SYNTEK_STK_M811:
00603 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00604 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00605 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00606
00607 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00608 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00609 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00610 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00611 break;
00612
00613 case SYNTEK_STK_A311:
00614 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00615 dev->vsettings.vflip = (default_vflip == -1) ? 1 : default_vflip;
00616 dev->vsettings.hflip = (default_hflip == -1) ? 1 : default_hflip;
00617
00618 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00619 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00620 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00621 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00622 break;
00623
00624 case SYNTEK_STK_A821:
00625 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00626 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00627 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00628
00629 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00630 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00631 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00632 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00633 break;
00634
00635 case SYNTEK_STK_6A31:
00636 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00637 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00638 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00639
00640 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00641 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00642 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00643 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00644 break;
00645
00646 default:
00647 return -1;
00648 }
00649
00650 return 0;
00651 }
00652
00653
00665 static int usb_stk11xx_probe(struct usb_interface *interface, const struct usb_device_id *id)
00666 {
00667 int i;
00668 int err;
00669 size_t buffer_size;
00670
00671 int vendor_id;
00672 int product_id;
00673 int bNumInterfaces;
00674 int webcam_model;
00675 int webcam_type;
00676
00677 struct usb_stk11xx *dev = NULL;
00678 struct usb_device *udev = interface_to_usbdev(interface);
00679 struct usb_host_interface *iface_desc;
00680 struct usb_endpoint_descriptor *endpoint;
00681
00682
00683
00684 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
00685 product_id = le16_to_cpu(udev->descriptor.idProduct);
00686
00687
00688 STK_DEBUG("Probe function called with VendorID=%04X, ProductID=%04X and InterfaceNumber=%d\n",
00689 vendor_id, product_id, interface->cur_altsetting->desc.bInterfaceNumber);
00690
00691
00692
00693
00694 if (interface->cur_altsetting->desc.bInterfaceNumber > 0)
00695 return -ENODEV;
00696
00697
00698 if (vendor_id == USB_SYNTEK1_VENDOR_ID) {
00699 switch (product_id) {
00700 case USB_STK_A311_PRODUCT_ID:
00701 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00702 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0xA311.\n");
00703 webcam_model = SYNTEK_STK_A311;
00704 webcam_type = STK11XX_SXGA;
00705 break;
00706
00707 case USB_STK_A821_PRODUCT_ID:
00708 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00709 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xA821.\n");
00710 webcam_model = SYNTEK_STK_A821;
00711 webcam_type = STK11XX_VGA;
00712 break;
00713
00714 case USB_STK_6A31_PRODUCT_ID:
00715 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00716 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A31.\n");
00717 webcam_model = SYNTEK_STK_6A31;
00718 webcam_type = STK11XX_VGA;
00719 break;
00720
00721 default:
00722 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00723 le16_to_cpu(udev->descriptor.idProduct));
00724 return -ENODEV;
00725 }
00726 }
00727 else if (vendor_id == USB_SYNTEK2_VENDOR_ID) {
00728 switch (product_id) {
00729 case USB_STK_0501_PRODUCT_ID:
00730 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00731 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0501.\n");
00732 webcam_model = SYNTEK_STK_M811;
00733 webcam_type = STK11XX_SXGA;
00734 break;
00735
00736 default:
00737 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00738 le16_to_cpu(udev->descriptor.idProduct));
00739 return -ENODEV;
00740 }
00741 }
00742 else
00743 return -ENODEV;
00744
00745
00746 dev = kzalloc(sizeof(struct usb_stk11xx), GFP_KERNEL);
00747
00748 if (dev == NULL) {
00749 STK_ERROR("Out of memory !\n");
00750 return -ENOMEM;
00751 }
00752
00753
00754 init_MUTEX(&dev->mutex);
00755 spin_lock_init(&dev->spinlock);
00756 init_waitqueue_head(&dev->wait_frame);
00757
00758
00759 dev->webcam_model = webcam_model;
00760 dev->webcam_type = webcam_type;
00761 dev->udev = udev;
00762 dev->interface = interface;
00763
00764
00765 dev->release = le16_to_cpu(udev->descriptor.bcdDevice);
00766 STK_INFO("Release: %04x\n", dev->release);
00767
00768
00769 bNumInterfaces = udev->config->desc.bNumInterfaces;
00770 STK_INFO("Number of interfaces : %d\n", bNumInterfaces);
00771
00772
00773
00774 dev->nbuffers = 2;
00775 dev->len_per_image = PAGE_ALIGN((1280 * 1024 * 4));
00776
00777
00778
00779 dev_stk11xx_camera_on(dev);
00780
00781
00782
00783
00784
00785 iface_desc = interface->cur_altsetting;
00786
00787 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
00788 endpoint = &iface_desc->endpoint[i].desc;
00789
00790 if (!dev->int_in_endpointAddr
00791 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00792 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) {
00793
00794 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00795
00796 dev->int_in_size = buffer_size;
00797 dev->int_in_endpointAddr = (endpoint->bEndpointAddress & 0xF);
00798 }
00799
00800 if (!dev->isoc_in_endpointAddr
00801 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00802 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)) {
00803
00804 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00805
00806 dev->isoc_in_size = buffer_size;
00807 dev->isoc_in_endpointAddr = (endpoint->bEndpointAddress & 0xF);
00808 }
00809 }
00810
00811 if (!(dev->int_in_endpointAddr && dev->isoc_in_endpointAddr)) {
00812 STK_ERROR("Could not find both int-in and isoc-in endpoints");
00813
00814 kfree(dev);
00815
00816 return -ENODEV;
00817 }
00818
00819
00820
00821 dev_stk11xx_camera_off(dev);
00822
00823
00824 dev->vdev = video_device_alloc();
00825
00826 if (!dev->vdev) {
00827 kfree(dev);
00828 return -ENOMEM;
00829 }
00830
00831
00832 dev_stk11xx_initialize_device(dev);
00833
00834
00835 err = v4l_stk11xx_register_video_device(dev);
00836
00837 if (err) {
00838 kfree(dev);
00839 return err;
00840 }
00841
00842
00843 stk11xx_create_sysfs_files(dev->vdev);
00844
00845
00846 usb_set_intfdata(interface, dev);
00847
00848
00849 usb_stk11xx_default_settings(dev);
00850
00851
00852 return 0;
00853 }
00854
00855
00862 static void usb_stk11xx_disconnect(struct usb_interface *interface)
00863 {
00864 struct usb_stk11xx *dev = usb_get_intfdata(interface);
00865
00866 STK_INFO("Syntek USB2.0 Camera disconnected\n");
00867
00868 usb_set_intfdata(interface, NULL);
00869
00870
00871 if (dev->vopen) {
00872 STK_INFO("Disconnected while webcam is in use !\n");
00873 dev->error_status = EPIPE;
00874 }
00875
00876
00877 wake_up_interruptible(&dev->wait_frame);
00878
00879
00880 while (dev->vopen)
00881 schedule();
00882
00883
00884 v4l_stk11xx_unregister_video_device(dev);
00885
00886
00887 stk11xx_remove_sysfs_files(dev->vdev);
00888 }
00889
00890
00896 static struct usb_driver usb_stk11xx_driver = {
00897 .name = "usb_stk11xx_driver",
00898 .probe = usb_stk11xx_probe,
00899 .disconnect = usb_stk11xx_disconnect,
00900 .id_table = stk11xx_table,
00901 };
00902
00903
00908 static int fps;
00909
00914 static int hflip = -1;
00915
00920 static int vflip = -1;
00921
00926 static int brightness = -1;
00927
00932 static int whiteness = -1;
00933
00938 static int contrast = -1;
00939
00944 static int colour = -1;
00945
00946
00947 module_param(fps, int, 0444);
00948 module_param(hflip, int, 0444);
00949 module_param(vflip, int, 0444);
00951 module_param(brightness, int, 0444);
00952 module_param(whiteness, int, 0444);
00953 module_param(contrast, int, 0444);
00954 module_param(colour, int, 0444);
00965 static int __init usb_stk11xx_init(void)
00966 {
00967 int result;
00968
00969
00970 STK_INFO("Syntek USB2.0 webcam driver startup\n");
00971
00972
00973 if (fps) {
00974 if (fps < 9 || fps > 30) {
00975 STK_ERROR("Framerate out of bounds [10-30] !\n");
00976 return -EINVAL;
00977 }
00978
00979 default_fps = fps;
00980 }
00981
00982
00983 if ((hflip == 0) || (hflip == 1)) {
00984 STK_DEBUG("Set horizontal flip = %d\n", hflip);
00985
00986 default_hflip = hflip;
00987 }
00988
00989
00990 if ((vflip == 0) || (vflip == 1)) {
00991 STK_DEBUG("Set vertical flip = %d\n", vflip);
00992
00993 default_vflip = vflip;
00994 }
00995
00996
00997 if (brightness > -1) {
00998 STK_DEBUG("Set brightness = 0x%X\n", brightness);
00999
01000 default_brightness = 0xFFFF & brightness;
01001 }
01002
01003
01004 if (whiteness > -1) {
01005 STK_DEBUG("Set whiteness = 0x%X\n", whiteness);
01006
01007 default_whiteness = 0xFFFF & whiteness;
01008 }
01009
01010
01011 if (contrast > -1) {
01012 STK_DEBUG("Set contrast = 0x%X\n", contrast);
01013
01014 default_contrast = 0xFFFF & contrast;
01015 }
01016
01017
01018 if (colour > -1) {
01019 STK_DEBUG("Set colour = 0x%X\n", colour);
01020
01021 default_colour = 0xFFFF & colour;
01022 }
01023
01024
01025
01026 result = usb_register(&usb_stk11xx_driver);
01027
01028 if (result)
01029 STK_ERROR("usb_register failed ! Error number %d\n", result);
01030
01031 STK_INFO(DRIVER_VERSION " : " DRIVER_DESC "\n");
01032
01033 return result;
01034 }
01035
01036
01042 static void __exit usb_stk11xx_exit(void)
01043 {
01044 STK_INFO("usb_stk11xx_exit: Syntek USB2.0 webcam driver shutdown\n");
01045
01046
01047 usb_deregister(&usb_stk11xx_driver);
01048 }
01049
01050
01051 module_init(usb_stk11xx_init);
01052 module_exit(usb_stk11xx_exit);
01055 MODULE_PARM_DESC(fps, "Frames per second [5-30]");
01056 MODULE_PARM_DESC(hflip, "Horizontal image flip");
01057 MODULE_PARM_DESC(vflip, "Vertical image flip");
01058 MODULE_PARM_DESC(brightness, "Brightness setting");
01059 MODULE_PARM_DESC(whiteness, "Whiteness setting");
01060 MODULE_PARM_DESC(colour, "Colour setting");
01061 MODULE_PARM_DESC(contrast, "Contrast setting");
01064 MODULE_LICENSE("GPL");
01065 MODULE_AUTHOR(DRIVER_AUTHOR);
01066 MODULE_DESCRIPTION(DRIVER_DESC);
01067 MODULE_SUPPORTED_DEVICE(DRIVER_SUPPORT);