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