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