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 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
00042 #include <linux/mm.h>
00043 #endif
00044
00045 #include <linux/usb.h>
00046 #include <media/v4l2-common.h>
00047
00048 #include "stk11xx.h"
00049
00050
00055 static int default_fps = -1;
00056
00061 static int default_hflip = -1;
00062
00067 static int default_vflip = -1;
00068
00073 static int default_brightness = -1;
00074
00079 static int default_whiteness = -1;
00080
00085 static int default_contrast = -1;
00086
00091 static int default_colour = -1;
00092
00093
00098 static struct usb_device_id stk11xx_table[] = {
00099 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A311_PRODUCT_ID) },
00100 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A821_PRODUCT_ID) },
00101 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A31_PRODUCT_ID) },
00102 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A33_PRODUCT_ID) },
00103 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A51_PRODUCT_ID) },
00104 { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A54_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
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
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;
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
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
00228 dev->isoc_init_ok = 1;
00229
00230 return 0;
00231 }
00232
00233
00243 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
00244 void usb_stk11xx_isoc_handler(struct urb *urb, struct pt_regs *regs)
00245 #else
00246 void usb_stk11xx_isoc_handler(struct urb *urb)
00247 #endif
00248 {
00249 int i;
00250 int ret;
00251 int skip;
00252
00253 int awake = 0;
00254 int framestatus;
00255 int framelen;
00256
00257 unsigned char *fill = NULL;
00258 unsigned char *iso_buf = NULL;
00259
00260 struct usb_stk11xx *dev;
00261 struct stk11xx_frame_buf *framebuf;
00262
00263 STK_STREAM("Isoc handler\n");
00264
00265 dev = (struct usb_stk11xx *) urb->context;
00266
00267 if (dev == NULL) {
00268 STK_ERROR("isoc_handler called with NULL device !\n");
00269 return;
00270 }
00271
00272 if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
00273 STK_DEBUG("URB unlinked synchronuously !\n");
00274 return;
00275 }
00276
00277 if (urb->status != -EINPROGRESS && urb->status != 0) {
00278 const char *errmsg;
00279
00280 errmsg = "Unknown";
00281
00282 switch(urb->status) {
00283 case -ENOSR:
00284 errmsg = "Buffer error (overrun)";
00285 break;
00286
00287 case -EPIPE:
00288 errmsg = "Stalled (device not responding)";
00289 break;
00290
00291 case -EOVERFLOW:
00292 errmsg = "Babble (bad cable?)";
00293 break;
00294
00295 case -EPROTO:
00296 errmsg = "Bit-stuff error (bad cable?)";
00297 break;
00298
00299 case -EILSEQ:
00300 errmsg = "CRC/Timeout (could be anything)";
00301 break;
00302
00303 case -ETIMEDOUT:
00304 errmsg = "NAK (device does not respond)";
00305 break;
00306 }
00307
00308 STK_ERROR("isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
00309
00310 dev->visoc_errors++;
00311
00312 wake_up_interruptible(&dev->wait_frame);
00313
00314 urb->dev = dev->udev;
00315 ret = usb_submit_urb(urb, GFP_ATOMIC);
00316
00317 if (ret != 0) {
00318 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00319 }
00320
00321 return;
00322 }
00323
00324 framebuf = dev->fill_frame;
00325
00326 if (framebuf == NULL) {
00327 STK_ERROR("isoc_handler without valid fill frame !\n");
00328
00329 wake_up_interruptible(&dev->wait_frame);
00330
00331 urb->dev = dev->udev;
00332 ret = usb_submit_urb(urb, GFP_ATOMIC);
00333
00334 if (ret != 0) {
00335 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00336 }
00337
00338 return;
00339 }
00340 else {
00341 fill = framebuf->data + framebuf->filled;
00342 }
00343
00344
00345 dev->visoc_errors = 0;
00346
00347
00348 for (i=0; i<urb->number_of_packets; i++) {
00349 framestatus = urb->iso_frame_desc[i].status;
00350 framelen = urb->iso_frame_desc[i].actual_length;
00351 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
00352
00353 if (framestatus == 0) {
00354 skip = 4;
00355
00356 if (framelen > 4) {
00357
00358
00359
00360
00361
00362
00363
00364
00365 if (*iso_buf & 0x80) {
00366 skip = 8;
00367 }
00368
00369
00370 if (framelen - skip + framebuf->filled > dev->frame_size) {
00371 STK_ERROR("Frame buffer overflow !\n");
00372 framebuf->errors++;
00373 }
00374
00375 else {
00376 memcpy(fill, iso_buf + skip, framelen - skip);
00377 fill += framelen - skip;
00378 }
00379
00380
00381 framebuf->filled += framelen - skip;
00382 }
00383
00384 STK_STREAM("URB : Length = %d - Skip = %d - Buffer size = %d\n",
00385 framelen, skip, framebuf->filled);
00386
00387
00388 if (framelen == 4) {
00389 if (framebuf->filled > 0) {
00390
00391 if (framebuf->filled < dev->frame_size)
00392 framebuf->errors++;
00393
00394
00395 if (framebuf->errors == 0) {
00396 if (stk11xx_next_frame(dev))
00397 dev->vframes_dumped++;
00398 }
00399 else
00400 dev->vframes_error++;
00401
00402 awake = 1;
00403 framebuf = dev->fill_frame;
00404 framebuf->filled = 0;
00405 framebuf->errors = 0;
00406 fill = framebuf->data;
00407 }
00408 }
00409 }
00410 else {
00411 STK_ERROR("Iso frame %d of USB has error %d\n", i, framestatus);
00412 }
00413 }
00414
00415 if (awake == 1)
00416 wake_up_interruptible(&dev->wait_frame);
00417
00418 urb->dev = dev->udev;
00419
00420 ret = usb_submit_urb(urb, GFP_ATOMIC);
00421
00422 if (ret != 0) {
00423 STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00424 }
00425 }
00426
00427
00435 void usb_stk11xx_isoc_cleanup(struct usb_stk11xx *dev)
00436 {
00437 int i;
00438
00439 STK_DEBUG("Isoc cleanup\n");
00440
00441 if (dev == NULL)
00442 return;
00443
00444 if (dev->isoc_init_ok == 0)
00445 return;
00446
00447
00448 for (i=0; i<MAX_ISO_BUFS; i++) {
00449 struct urb *urb;
00450
00451 urb = dev->isobuf[i].urb;
00452
00453 if (urb != 0) {
00454 if (dev->isoc_init_ok)
00455 usb_kill_urb(urb);
00456
00457 usb_free_urb(urb);
00458 dev->isobuf[i].urb = NULL;
00459 }
00460 }
00461
00462
00463 dev->isoc_init_ok = 0;
00464 }
00465
00466
00467
00478 int usb_stk11xx_set_feature(struct usb_stk11xx *dev, int index)
00479 {
00480 int result;
00481 struct usb_device *udev = dev->udev;
00482
00483 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00484 USB_REQ_SET_FEATURE,
00485 USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE,
00486 USB_DEVICE_REMOTE_WAKEUP,
00487 index,
00488 NULL,
00489 0,
00490 500);
00491
00492 if (result < 0)
00493 STK_ERROR("SET FEATURE fail !\n");
00494 else
00495 STK_DEBUG("SET FEATURE\n");
00496
00497 return result;
00498 }
00499
00500
00510 int usb_stk11xx_set_configuration(struct usb_stk11xx *dev)
00511 {
00512 int result;
00513 struct usb_device *udev = dev->udev;
00514
00515 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00516 USB_REQ_SET_CONFIGURATION,
00517 USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE,
00518 0,
00519 udev->config[0].desc.bConfigurationValue,
00520 NULL,
00521 0,
00522 500);
00523
00524 if (result < 0)
00525 STK_ERROR("SET CONFIGURATION fail !\n");
00526 else
00527 STK_DEBUG("SET CONFIGURATION %d\n", udev->config[0].desc.bConfigurationValue);
00528
00529 return result;
00530 }
00531
00532
00544 int usb_stk11xx_write_registry(struct usb_stk11xx *dev, __u16 index, __u16 value)
00545 {
00546 int result;
00547 struct usb_device *udev = dev->udev;
00548
00549 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00550 0x01,
00551 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
00552 value,
00553 index,
00554 NULL,
00555 0,
00556 500);
00557
00558 if (result < 0)
00559 STK_ERROR("Write registry fails %02X = %02X", index, value);
00560
00561 return result;
00562 }
00563
00564
00576 int usb_stk11xx_read_registry(struct usb_stk11xx *dev, __u16 index, int *value)
00577 {
00578 int result;
00579
00580 struct usb_device *udev = dev->udev;
00581
00582 *value = 0;
00583
00584 result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
00585 0x00,
00586 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
00587 0x00,
00588 index,
00589 (__u8 *) value,
00590 sizeof(__u8),
00591 500);
00592
00593 if (result < 0)
00594 STK_ERROR("Read registry fails %02X", index);
00595
00596 return result;
00597 }
00598
00599
00610 static int usb_stk11xx_default_settings(struct usb_stk11xx *dev)
00611 {
00612 switch (dev->webcam_model) {
00613 case SYNTEK_STK_M811:
00614 case SYNTEK_STK_A311:
00615 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00616 dev->vsettings.vflip = (default_vflip == -1) ? 1 : default_vflip;
00617 dev->vsettings.hflip = (default_hflip == -1) ? 1 : default_hflip;
00618
00619 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00620 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00621 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00622 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00623 break;
00624
00625 case SYNTEK_STK_A821:
00626 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00627 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00628 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00629
00630 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00631 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00632 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00633 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00634 break;
00635
00636 case SYNTEK_STK_6A31:
00637 case SYNTEK_STK_6A33:
00638 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00639 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00640 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00641
00642 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00643 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00644 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00645 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00646 break;
00647
00648 case SYNTEK_STK_6A51:
00649 case SYNTEK_STK_6A54:
00650 dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00651 dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00652 dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00653
00654 dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00655 dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00656 dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00657 dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00658 break;
00659
00660 default:
00661 return -1;
00662 }
00663
00664 return 0;
00665 }
00666
00667
00679 static int usb_stk11xx_probe(struct usb_interface *interface, const struct usb_device_id *id)
00680 {
00681 int i;
00682 int err;
00683 size_t buffer_size;
00684
00685 int vendor_id;
00686 int product_id;
00687 int bNumInterfaces;
00688 int webcam_model;
00689 int webcam_type;
00690
00691 struct usb_stk11xx *dev = NULL;
00692 struct usb_device *udev = interface_to_usbdev(interface);
00693 struct usb_host_interface *iface_desc;
00694 struct usb_endpoint_descriptor *endpoint;
00695
00696
00697
00698 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
00699 product_id = le16_to_cpu(udev->descriptor.idProduct);
00700
00701
00702 STK_DEBUG("Probe function called with VendorID=%04X, ProductID=%04X and InterfaceNumber=%d\n",
00703 vendor_id, product_id, interface->cur_altsetting->desc.bInterfaceNumber);
00704
00705
00706
00707
00708 if (interface->cur_altsetting->desc.bInterfaceNumber > 0)
00709 return -ENODEV;
00710
00711
00712 if (vendor_id == USB_SYNTEK1_VENDOR_ID) {
00713 switch (product_id) {
00714 case USB_STK_A311_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 0xA311.\n");
00717 webcam_model = SYNTEK_STK_A311;
00718 webcam_type = STK11XX_SXGA;
00719 break;
00720
00721 case USB_STK_A821_PRODUCT_ID:
00722 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00723 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xA821.\n");
00724 webcam_model = SYNTEK_STK_A821;
00725 webcam_type = STK11XX_VGA;
00726 break;
00727
00728 case USB_STK_6A31_PRODUCT_ID:
00729 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00730 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A31.\n");
00731 webcam_model = SYNTEK_STK_6A31;
00732 webcam_type = STK11XX_VGA;
00733 break;
00734
00735 case USB_STK_6A33_PRODUCT_ID:
00736 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00737 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A33.\n");
00738 webcam_model = SYNTEK_STK_6A33;
00739 webcam_type = STK11XX_VGA;
00740 break;
00741
00742 case USB_STK_6A51_PRODUCT_ID:
00743 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00744 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A51.\n");
00745 webcam_model = SYNTEK_STK_6A51;
00746 webcam_type = STK11XX_VGA;
00747 break;
00748
00749 case USB_STK_6A54_PRODUCT_ID:
00750 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00751 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A54.\n");
00752 webcam_model = SYNTEK_STK_6A54;
00753 webcam_type = STK11XX_VGA;
00754 break;
00755
00756 default:
00757 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00758 le16_to_cpu(udev->descriptor.idProduct));
00759 return -ENODEV;
00760 }
00761 }
00762 else if (vendor_id == USB_SYNTEK2_VENDOR_ID) {
00763 switch (product_id) {
00764 case USB_STK_0501_PRODUCT_ID:
00765 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00766 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0501.\n");
00767 webcam_model = SYNTEK_STK_M811;
00768 webcam_type = STK11XX_SXGA;
00769 break;
00770
00771 default:
00772 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00773 le16_to_cpu(udev->descriptor.idProduct));
00774 return -ENODEV;
00775 }
00776 }
00777 else
00778 return -ENODEV;
00779
00780
00781 dev = kzalloc(sizeof(struct usb_stk11xx), GFP_KERNEL);
00782
00783 if (dev == NULL) {
00784 STK_ERROR("Out of memory !\n");
00785 return -ENOMEM;
00786 }
00787
00788
00789 init_MUTEX(&dev->mutex);
00790 spin_lock_init(&dev->spinlock);
00791 init_waitqueue_head(&dev->wait_frame);
00792
00793
00794 dev->webcam_model = webcam_model;
00795 dev->webcam_type = webcam_type;
00796 dev->udev = udev;
00797 dev->interface = interface;
00798
00799
00800 dev->release = le16_to_cpu(udev->descriptor.bcdDevice);
00801 STK_INFO("Release: %04x\n", dev->release);
00802
00803
00804 bNumInterfaces = udev->config->desc.bNumInterfaces;
00805 STK_INFO("Number of interfaces : %d\n", bNumInterfaces);
00806
00807
00808
00809 dev->nbuffers = 2;
00810 dev->len_per_image = PAGE_ALIGN((1280 * 1024 * 4));
00811
00812
00813
00814 dev_stk11xx_camera_on(dev);
00815
00816
00817
00818
00819
00820 iface_desc = interface->cur_altsetting;
00821
00822 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
00823 endpoint = &iface_desc->endpoint[i].desc;
00824
00825 if (!dev->int_in_endpointAddr
00826 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00827 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) {
00828
00829 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00830
00831 dev->int_in_size = buffer_size;
00832 dev->int_in_endpointAddr = (endpoint->bEndpointAddress & 0xf);
00833 }
00834
00835 if (!dev->isoc_in_endpointAddr
00836 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00837 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)) {
00838
00839 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00840
00841 dev->isoc_in_size = buffer_size;
00842 dev->isoc_in_endpointAddr = (endpoint->bEndpointAddress & 0xf);
00843 }
00844 }
00845
00846 if (!(dev->int_in_endpointAddr && dev->isoc_in_endpointAddr)) {
00847 STK_ERROR("Could not find both int-in and isoc-in endpoints");
00848
00849 kfree(dev);
00850
00851 return -ENODEV;
00852 }
00853
00854
00855
00856 dev_stk11xx_camera_off(dev);
00857
00858
00859 dev->vdev = video_device_alloc();
00860
00861 if (!dev->vdev) {
00862 kfree(dev);
00863 return -ENOMEM;
00864 }
00865
00866
00867 dev_stk11xx_initialize_device(dev);
00868
00869
00870 err = v4l_stk11xx_register_video_device(dev);
00871
00872 if (err) {
00873 kfree(dev);
00874 return err;
00875 }
00876
00877
00878 stk11xx_create_sysfs_files(dev->vdev);
00879
00880
00881 usb_set_intfdata(interface, dev);
00882
00883
00884 usb_stk11xx_default_settings(dev);
00885
00886
00887 return 0;
00888 }
00889
00890
00897 static void usb_stk11xx_disconnect(struct usb_interface *interface)
00898 {
00899 struct usb_stk11xx *dev = usb_get_intfdata(interface);
00900
00901 STK_INFO("Syntek USB2.0 Camera disconnected\n");
00902
00903 usb_set_intfdata(interface, NULL);
00904
00905
00906 if (dev->vopen) {
00907 STK_INFO("Disconnected while webcam is in use !\n");
00908 dev->error_status = EPIPE;
00909 }
00910
00911
00912 wake_up_interruptible(&dev->wait_frame);
00913
00914
00915 while (dev->vopen)
00916 schedule();
00917
00918
00919 stk11xx_remove_sysfs_files(dev->vdev);
00920
00921
00922 v4l_stk11xx_unregister_video_device(dev);
00923 }
00924
00925
00931 static struct usb_driver usb_stk11xx_driver = {
00932 .name = "stk11xx",
00933 .probe = usb_stk11xx_probe,
00934 .disconnect = usb_stk11xx_disconnect,
00935 .id_table = stk11xx_table,
00936 };
00937
00938
00943 static int fps;
00944
00949 static int hflip = -1;
00950
00955 static int vflip = -1;
00956
00961 static int brightness = -1;
00962
00967 static int whiteness = -1;
00968
00973 static int contrast = -1;
00974
00979 static int colour = -1;
00980
00981
00982 module_param(fps, int, 0444);
00983 module_param(hflip, int, 0444);
00984 module_param(vflip, int, 0444);
00986 module_param(brightness, int, 0444);
00987 module_param(whiteness, int, 0444);
00988 module_param(contrast, int, 0444);
00989 module_param(colour, int, 0444);
01000 static int __init usb_stk11xx_init(void)
01001 {
01002 int result;
01003
01004
01005 STK_INFO("Syntek USB2.0 webcam driver startup\n");
01006
01007
01008 if (fps) {
01009 if (fps < 9 || fps > 30) {
01010 STK_ERROR("Framerate out of bounds [10-30] !\n");
01011 return -EINVAL;
01012 }
01013
01014 default_fps = fps;
01015 }
01016
01017
01018 if ((hflip == 0) || (hflip == 1)) {
01019 STK_DEBUG("Set horizontal flip = %d\n", hflip);
01020
01021 default_hflip = hflip;
01022 }
01023
01024
01025 if ((vflip == 0) || (vflip == 1)) {
01026 STK_DEBUG("Set vertical flip = %d\n", vflip);
01027
01028 default_vflip = vflip;
01029 }
01030
01031
01032 if (brightness > -1) {
01033 STK_DEBUG("Set brightness = 0x%X\n", brightness);
01034
01035 default_brightness = 0xffff & brightness;
01036 }
01037
01038
01039 if (whiteness > -1) {
01040 STK_DEBUG("Set whiteness = 0x%X\n", whiteness);
01041
01042 default_whiteness = 0xffff & whiteness;
01043 }
01044
01045
01046 if (contrast > -1) {
01047 STK_DEBUG("Set contrast = 0x%X\n", contrast);
01048
01049 default_contrast = 0xffff & contrast;
01050 }
01051
01052
01053 if (colour > -1) {
01054 STK_DEBUG("Set colour = 0x%X\n", colour);
01055
01056 default_colour = 0xffff & colour;
01057 }
01058
01059
01060
01061 result = usb_register(&usb_stk11xx_driver);
01062
01063 if (result)
01064 STK_ERROR("usb_register failed ! Error number %d\n", result);
01065
01066 STK_INFO(DRIVER_VERSION " : " DRIVER_DESC "\n");
01067
01068 return result;
01069 }
01070
01071
01077 static void __exit usb_stk11xx_exit(void)
01078 {
01079 STK_INFO("usb_stk11xx_exit: Syntek USB2.0 webcam driver shutdown\n");
01080
01081
01082 usb_deregister(&usb_stk11xx_driver);
01083 }
01084
01085
01086 module_init(usb_stk11xx_init);
01087 module_exit(usb_stk11xx_exit);
01090 MODULE_PARM_DESC(fps, "Frames per second [5-30]");
01091 MODULE_PARM_DESC(hflip, "Horizontal image flip");
01092 MODULE_PARM_DESC(vflip, "Vertical image flip");
01093 MODULE_PARM_DESC(brightness, "Brightness setting");
01094 MODULE_PARM_DESC(whiteness, "Whiteness setting");
01095 MODULE_PARM_DESC(colour, "Colour setting");
01096 MODULE_PARM_DESC(contrast, "Contrast setting");
01099 MODULE_LICENSE("GPL");
01100 MODULE_AUTHOR(DRIVER_AUTHOR);
01101 MODULE_DESCRIPTION(DRIVER_DESC);
01102 MODULE_SUPPORTED_DEVICE(DRIVER_SUPPORT);