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     init_MUTEX(&dev->mutex);
00800     mutex_init(&dev->modlock);
00801     spin_lock_init(&dev->spinlock);
00802     init_waitqueue_head(&dev->wait_frame);
00803 
00804     // Save pointers
00805     dev->webcam_model = webcam_model;
00806     dev->webcam_type = webcam_type;
00807     dev->udev = udev;
00808     dev->interface = interface;
00809 
00810     // Read the product release 
00811     dev->release = le16_to_cpu(udev->descriptor.bcdDevice);
00812     STK_INFO("Release: %04x\n", dev->release);
00813 
00814     // How many interfaces (1 or 3) ?
00815     bNumInterfaces = udev->config->desc.bNumInterfaces;
00816     STK_INFO("Number of interfaces : %d\n", bNumInterfaces);
00817 
00818 
00819     // Constructor
00820     dev->nbuffers = 2;
00821     dev->len_per_image = PAGE_ALIGN((1280 * 1024 * 4));
00822 
00823 
00824     // Switch on the camera (to detect size of buffers)
00825     dev_stk11xx_camera_on(dev);
00826 
00827 
00828     // Set up the endpoint information 
00829     // use only the first int-in and isoc-in endpoints
00830     // for the current alternate setting
00831     iface_desc = interface->cur_altsetting;
00832 
00833     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
00834         endpoint = &iface_desc->endpoint[i].desc;
00835 
00836         if (!dev->int_in_endpointAddr
00837                 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00838                 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) {
00839             // we found an interrupt in endpoint
00840             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00841 
00842             dev->int_in_size = buffer_size;
00843             dev->int_in_endpointAddr = (endpoint->bEndpointAddress & 0xf);
00844         }
00845 
00846         if (!dev->isoc_in_endpointAddr
00847                 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00848                 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)) {
00849             // we found an isoc in endpoint
00850             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00851 
00852             dev->isoc_in_size = buffer_size;
00853             dev->isoc_in_endpointAddr = (endpoint->bEndpointAddress & 0xf);
00854         }
00855     }
00856 
00857     if (!(dev->int_in_endpointAddr && dev->isoc_in_endpointAddr)) {
00858         STK_ERROR("Could not find both int-in and isoc-in endpoints");
00859 
00860         kfree(dev);
00861 
00862         return -ENODEV;
00863     }
00864 
00865 
00866     // Switch off camera
00867     dev_stk11xx_camera_off(dev);
00868 
00869     // Initialize the video device
00870     dev->vdev = video_device_alloc();
00871 
00872     if (!dev->vdev) {
00873         kfree(dev);
00874         return -ENOMEM;
00875     }
00876 
00877     // Initialize the camera
00878     dev_stk11xx_initialize_device(dev);
00879     
00880     // Register the video device
00881     err = v4l_stk11xx_register_video_device(dev);
00882 
00883     if (err) {
00884         kfree(dev);
00885         return err;
00886     }
00887 
00888     // Create the entries in the sys filesystem
00889     stk11xx_create_sysfs_files(dev->vdev);
00890 
00891     // Save our data pointer in this interface device
00892     usb_set_intfdata(interface, dev);
00893 
00894     // Default settings video device
00895     usb_stk11xx_default_settings(dev);
00896     
00897     // Enable power management feature
00898 //  usb_autopm_enable(dev->interface);
00899 
00900     return 0;
00901 }
00902 
00903 
00910 static void usb_stk11xx_disconnect(struct usb_interface *interface)
00911 {
00912     struct usb_stk11xx *dev = usb_get_intfdata(interface);
00913 
00914     STK_INFO("Syntek USB2.0 Camera disconnected\n");
00915 
00916     // We got unplugged; this is signalled by an EPIPE error code
00917     if (dev->vopen) {
00918         STK_INFO("Disconnected while webcam is in use !\n");
00919         dev->error_status = EPIPE;
00920     }
00921 
00922     // Alert waiting processes
00923     wake_up_interruptible(&dev->wait_frame);
00924 
00925     // Wait until device is closed
00926     while (dev->vopen)
00927         schedule();
00928 
00929     // Remove the entries in the sys filesystem
00930     stk11xx_remove_sysfs_files(dev->vdev);
00931 
00932     // Unregister the video device
00933     v4l_stk11xx_unregister_video_device(dev);
00934 
00935     usb_set_intfdata(interface, NULL);
00936 
00937     kfree(dev);
00938 }
00939 
00940 #ifdef CONFIG_PM
00941 int usb_stk11xx_suspend(struct usb_interface *interface, pm_message_t message)
00942 {
00943     struct usb_stk11xx *dev = usb_get_intfdata(interface);
00944 
00945     STK_INFO("Syntek USB2.0 Camera Suspend\n");
00946 
00947     mutex_lock(&dev->modlock);
00948     if (dev->vopen) {
00949         // Stop the video stream
00950         dev_stk11xx_stop_stream(dev);
00951             
00952         // ISOC and URB cleanup
00953         usb_stk11xx_isoc_cleanup(dev);
00954 
00955         // Free memory
00956         //  stk11xx_free_buffers(dev);
00957 
00958         // Switch off the camera
00959         dev_stk11xx_camera_off(dev);
00960 
00961         dev_stk11xx_camera_asleep(dev);
00962     }
00963     mutex_unlock(&dev->modlock);
00964 
00965     return 0;
00966 }
00967 
00968 
00969 int usb_stk11xx_resume(struct usb_interface *interface)
00970 {
00971     struct usb_stk11xx *dev = usb_get_intfdata(interface);
00972 
00973     STK_INFO("Syntek USB2.0 Camera Resume\n");
00974 
00975     mutex_lock(&dev->modlock);
00976 
00977     // Initialize the camera
00978     dev_stk11xx_initialize_device(dev);
00979 
00980     if (dev->vopen)
00981     {
00982         // Select the video mode
00983         v4l_stk11xx_select_video_mode(dev, dev->view.x, dev->view.y);
00984 
00985         // Clear the buffers
00986         stk11xx_clear_buffers(dev);
00987 
00988         // Initialize the device
00989         dev_stk11xx_init_camera(dev);
00990         dev_stk11xx_camera_on(dev);
00991         dev_stk11xx_reconf_camera(dev);
00992 
00993         // ISOC and URB init
00994         usb_stk11xx_isoc_init(dev);
00995 
00996         // Start the video stream
00997         dev_stk11xx_start_stream(dev);
00998 
00999         // Video settings
01000         dev_stk11xx_camera_settings(dev);
01001     }
01002     mutex_unlock(&dev->modlock);
01003 
01004     return 0;
01005 }
01006 #endif // CONFIG_PM
01007 
01008 
01014 static struct usb_driver usb_stk11xx_driver = {
01015     .name = "usb_stk11xx_driver",
01016     .probe = usb_stk11xx_probe,
01017     .disconnect = usb_stk11xx_disconnect,
01018     .id_table = stk11xx_table,
01019 #ifdef CONFIG_PM
01020     .suspend = usb_stk11xx_suspend,
01021     .resume = usb_stk11xx_resume,
01022 #endif
01023 };
01024 
01025 
01030 static int fps;
01031 
01036 static int hflip = -1;
01037 
01042 static int vflip = -1;
01043 
01048 static int brightness = -1;
01049 
01054 static int whiteness = -1;
01055 
01060 static int contrast = -1;
01061 
01066 static int colour = -1;
01067 
01068 
01069 module_param(fps, int, 0444);           
01070 module_param(hflip, int, 0444);         
01071 module_param(vflip, int, 0444);         
01073 module_param(brightness, int, 0444);    
01074 module_param(whiteness, int, 0444);     
01075 module_param(contrast, int, 0444);      
01076 module_param(colour, int, 0444);        
01087 static int __init usb_stk11xx_init(void)
01088 {
01089     int result;
01090 
01091 
01092     STK_INFO("Syntek USB2.0 webcam driver startup\n");
01093 
01094     // Frame per second parameter
01095     if (fps) {
01096         if (fps < 9 || fps > 30) {
01097             STK_ERROR("Framerate out of bounds [10-30] !\n");
01098             return -EINVAL;
01099         }
01100 
01101         default_fps = fps;
01102     }
01103 
01104     // Horizontal flip value
01105     if ((hflip == 0) || (hflip == 1)) {
01106         STK_DEBUG("Set horizontal flip = %d\n", hflip);
01107 
01108         default_hflip = hflip;
01109     }
01110 
01111     // Vertical flip value
01112     if ((vflip == 0) || (vflip == 1)) {
01113         STK_DEBUG("Set vertical flip = %d\n", vflip);
01114 
01115         default_vflip = vflip;
01116     }
01117 
01118     // Brightness value
01119     if (brightness > -1) {
01120         STK_DEBUG("Set brightness = 0x%X\n", brightness);
01121 
01122         default_brightness = 0xffff & brightness;
01123     }
01124 
01125     // Whiteness value
01126     if (whiteness > -1) {
01127         STK_DEBUG("Set whiteness = 0x%X\n", whiteness);
01128 
01129         default_whiteness = 0xffff & whiteness;
01130     }
01131 
01132     // Contrast value
01133     if (contrast > -1) {
01134         STK_DEBUG("Set contrast = 0x%X\n", contrast);
01135 
01136         default_contrast = 0xffff & contrast;
01137     }
01138 
01139     // Colour value
01140     if (colour > -1) {
01141         STK_DEBUG("Set colour = 0x%X\n", colour);
01142 
01143         default_colour = 0xffff & colour;
01144     }
01145 
01146 
01147     // Register the driver with the USB subsystem
01148     result = usb_register(&usb_stk11xx_driver);
01149 
01150     if (result)
01151         STK_ERROR("usb_register failed ! Error number %d\n", result);
01152 
01153     STK_INFO(DRIVER_VERSION " : " DRIVER_DESC "\n");
01154 
01155     return result;
01156 }
01157 
01158 
01164 static void __exit usb_stk11xx_exit(void)
01165 {
01166     STK_INFO("usb_stk11xx_exit: Syntek USB2.0 webcam driver shutdown\n");
01167 
01168     // Deregister this driver with the USB subsystem
01169     usb_deregister(&usb_stk11xx_driver);
01170 }
01171 
01172 
01173 module_init(usb_stk11xx_init);                      
01174 module_exit(usb_stk11xx_exit);                      
01177 MODULE_PARM_DESC(fps, "Frames per second [5-30]");  
01178 MODULE_PARM_DESC(hflip, "Horizontal image flip");   
01179 MODULE_PARM_DESC(vflip, "Vertical image flip");     
01180 MODULE_PARM_DESC(brightness, "Brightness setting"); 
01181 MODULE_PARM_DESC(whiteness, "Whiteness setting");   
01182 MODULE_PARM_DESC(colour, "Colour setting");         
01183 MODULE_PARM_DESC(contrast, "Contrast setting");     
01186 MODULE_LICENSE("GPL");                              
01187 MODULE_AUTHOR(DRIVER_AUTHOR);                       
01188 MODULE_DESCRIPTION(DRIVER_DESC);                    
01189 MODULE_SUPPORTED_DEVICE(DRIVER_SUPPORT);