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
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 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
00341 dev->visoc_errors = 0;
00342
00343
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
00354
00355
00356
00357
00358
00359
00360
00361 if (*iso_buf & 0x80) {
00362 skip = 8;
00363 }
00364
00365
00366 if (framelen - skip + framebuf->filled > dev->frame_size) {
00367 STK_ERROR("Frame buffer overflow !\n");
00368 framebuf->errors++;
00369 }
00370
00371 else {
00372 memcpy(fill, iso_buf + skip, framelen - skip);
00373 fill += framelen - skip;
00374 }
00375
00376
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
00384 if (framelen == 4) {
00385 if (framebuf->filled > 0) {
00386
00387 if (framebuf->filled < dev->frame_size)
00388 framebuf->errors++;
00389
00390
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
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
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 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 case USB_STK_6D51_PRODUCT_ID:
00754 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00755 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6D51.\n");
00756 webcam_model = SYNTEK_STK_6D51;
00757 webcam_type = STK11XX_VGA;
00758 break;
00759
00760 default:
00761 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00762 le16_to_cpu(udev->descriptor.idProduct));
00763 return -ENODEV;
00764 }
00765 }
00766 else if (vendor_id == USB_SYNTEK2_VENDOR_ID) {
00767 switch (product_id) {
00768 case USB_STK_0501_PRODUCT_ID:
00769 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00770 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0501.\n");
00771 webcam_model = SYNTEK_STK_M811;
00772 webcam_type = STK11XX_SXGA;
00773 break;
00774
00775 default:
00776 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00777 le16_to_cpu(udev->descriptor.idProduct));
00778 return -ENODEV;
00779 }
00780 }
00781 else
00782 return -ENODEV;
00783
00784
00785 dev = kzalloc(sizeof(struct usb_stk11xx), GFP_KERNEL);
00786
00787 if (dev == NULL) {
00788 STK_ERROR("Out of memory !\n");
00789 return -ENOMEM;
00790 }
00791
00792
00793 init_MUTEX(&dev->mutex);
00794 mutex_init(&dev->modlock);
00795 spin_lock_init(&dev->spinlock);
00796 init_waitqueue_head(&dev->wait_frame);
00797
00798
00799 dev->webcam_model = webcam_model;
00800 dev->webcam_type = webcam_type;
00801 dev->udev = udev;
00802 dev->interface = interface;
00803
00804
00805 dev->release = le16_to_cpu(udev->descriptor.bcdDevice);
00806 STK_INFO("Release: %04x\n", dev->release);
00807
00808
00809 bNumInterfaces = udev->config->desc.bNumInterfaces;
00810 STK_INFO("Number of interfaces : %d\n", bNumInterfaces);
00811
00812
00813
00814 dev->nbuffers = 2;
00815 dev->len_per_image = PAGE_ALIGN((1280 * 1024 * 4));
00816
00817
00818
00819 dev_stk11xx_camera_on(dev);
00820
00821
00822
00823
00824
00825 iface_desc = interface->cur_altsetting;
00826
00827 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
00828 endpoint = &iface_desc->endpoint[i].desc;
00829
00830 if (!dev->int_in_endpointAddr
00831 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00832 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) {
00833
00834 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00835
00836 dev->int_in_size = buffer_size;
00837 dev->int_in_endpointAddr = (endpoint->bEndpointAddress & 0xf);
00838 }
00839
00840 if (!dev->isoc_in_endpointAddr
00841 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00842 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)) {
00843
00844 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00845
00846 dev->isoc_in_size = buffer_size;
00847 dev->isoc_in_endpointAddr = (endpoint->bEndpointAddress & 0xf);
00848 }
00849 }
00850
00851 if (!(dev->int_in_endpointAddr && dev->isoc_in_endpointAddr)) {
00852 STK_ERROR("Could not find both int-in and isoc-in endpoints");
00853
00854 kfree(dev);
00855
00856 return -ENODEV;
00857 }
00858
00859
00860
00861 dev_stk11xx_camera_off(dev);
00862
00863
00864 dev->vdev = video_device_alloc();
00865
00866 if (!dev->vdev) {
00867 kfree(dev);
00868 return -ENOMEM;
00869 }
00870
00871
00872 dev_stk11xx_initialize_device(dev);
00873
00874
00875 err = v4l_stk11xx_register_video_device(dev);
00876
00877 if (err) {
00878 kfree(dev);
00879 return err;
00880 }
00881
00882
00883 stk11xx_create_sysfs_files(dev->vdev);
00884
00885
00886 usb_set_intfdata(interface, dev);
00887
00888
00889 usb_stk11xx_default_settings(dev);
00890
00891
00892
00893
00894 return 0;
00895 }
00896
00897
00904 static void usb_stk11xx_disconnect(struct usb_interface *interface)
00905 {
00906 struct usb_stk11xx *dev = usb_get_intfdata(interface);
00907
00908 STK_INFO("Syntek USB2.0 Camera disconnected\n");
00909
00910 usb_set_intfdata(interface, NULL);
00911
00912
00913 if (dev->vopen) {
00914 STK_INFO("Disconnected while webcam is in use !\n");
00915 dev->error_status = EPIPE;
00916 }
00917
00918
00919 wake_up_interruptible(&dev->wait_frame);
00920
00921
00922 while (dev->vopen)
00923 schedule();
00924
00925
00926 stk11xx_remove_sysfs_files(dev->vdev);
00927
00928
00929 v4l_stk11xx_unregister_video_device(dev);
00930 }
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983
00984
00985
00986
00987
00988
00994 static struct usb_driver usb_stk11xx_driver = {
00995 .name = "usb_stk11xx_driver",
00996 .probe = usb_stk11xx_probe,
00997 .disconnect = usb_stk11xx_disconnect,
00998 .id_table = stk11xx_table,
00999
01000
01001 };
01002
01003
01008 static int fps;
01009
01014 static int hflip = -1;
01015
01020 static int vflip = -1;
01021
01026 static int brightness = -1;
01027
01032 static int whiteness = -1;
01033
01038 static int contrast = -1;
01039
01044 static int colour = -1;
01045
01046
01047 module_param(fps, int, 0444);
01048 module_param(hflip, int, 0444);
01049 module_param(vflip, int, 0444);
01051 module_param(brightness, int, 0444);
01052 module_param(whiteness, int, 0444);
01053 module_param(contrast, int, 0444);
01054 module_param(colour, int, 0444);
01065 static int __init usb_stk11xx_init(void)
01066 {
01067 int result;
01068
01069
01070 STK_INFO("Syntek USB2.0 webcam driver startup\n");
01071
01072
01073 if (fps) {
01074 if (fps < 9 || fps > 30) {
01075 STK_ERROR("Framerate out of bounds [10-30] !\n");
01076 return -EINVAL;
01077 }
01078
01079 default_fps = fps;
01080 }
01081
01082
01083 if ((hflip == 0) || (hflip == 1)) {
01084 STK_DEBUG("Set horizontal flip = %d\n", hflip);
01085
01086 default_hflip = hflip;
01087 }
01088
01089
01090 if ((vflip == 0) || (vflip == 1)) {
01091 STK_DEBUG("Set vertical flip = %d\n", vflip);
01092
01093 default_vflip = vflip;
01094 }
01095
01096
01097 if (brightness > -1) {
01098 STK_DEBUG("Set brightness = 0x%X\n", brightness);
01099
01100 default_brightness = 0xffff & brightness;
01101 }
01102
01103
01104 if (whiteness > -1) {
01105 STK_DEBUG("Set whiteness = 0x%X\n", whiteness);
01106
01107 default_whiteness = 0xffff & whiteness;
01108 }
01109
01110
01111 if (contrast > -1) {
01112 STK_DEBUG("Set contrast = 0x%X\n", contrast);
01113
01114 default_contrast = 0xffff & contrast;
01115 }
01116
01117
01118 if (colour > -1) {
01119 STK_DEBUG("Set colour = 0x%X\n", colour);
01120
01121 default_colour = 0xffff & colour;
01122 }
01123
01124
01125
01126 result = usb_register(&usb_stk11xx_driver);
01127
01128 if (result)
01129 STK_ERROR("usb_register failed ! Error number %d\n", result);
01130
01131 STK_INFO(DRIVER_VERSION " : " DRIVER_DESC "\n");
01132
01133 return result;
01134 }
01135
01136
01142 static void __exit usb_stk11xx_exit(void)
01143 {
01144 STK_INFO("usb_stk11xx_exit: Syntek USB2.0 webcam driver shutdown\n");
01145
01146
01147 usb_deregister(&usb_stk11xx_driver);
01148 }
01149
01150
01151 module_init(usb_stk11xx_init);
01152 module_exit(usb_stk11xx_exit);
01155 MODULE_PARM_DESC(fps, "Frames per second [5-30]");
01156 MODULE_PARM_DESC(hflip, "Horizontal image flip");
01157 MODULE_PARM_DESC(vflip, "Vertical image flip");
01158 MODULE_PARM_DESC(brightness, "Brightness setting");
01159 MODULE_PARM_DESC(whiteness, "Whiteness setting");
01160 MODULE_PARM_DESC(colour, "Colour setting");
01161 MODULE_PARM_DESC(contrast, "Contrast setting");
01164 MODULE_LICENSE("GPL");
01165 MODULE_AUTHOR(DRIVER_AUTHOR);
01166 MODULE_DESCRIPTION(DRIVER_DESC);
01167 MODULE_SUPPORTED_DEVICE(DRIVER_SUPPORT);