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 
00096 static int default_norm = -1;
00097 
00098  
00103 static struct usb_device_id stk11xx_table[] = {
00104     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A311_PRODUCT_ID) },
00105     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A821_PRODUCT_ID) },
00106     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_AA11_PRODUCT_ID) },
00107     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A31_PRODUCT_ID) },
00108     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A33_PRODUCT_ID) },
00109     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A51_PRODUCT_ID) },
00110     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A54_PRODUCT_ID) },
00111     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6D51_PRODUCT_ID) },
00112 
00113     { USB_DEVICE(USB_SYNTEK2_VENDOR_ID, USB_STK_0408_PRODUCT_ID) },
00114     { USB_DEVICE(USB_SYNTEK2_VENDOR_ID, USB_STK_0500_PRODUCT_ID) },
00115     { USB_DEVICE(USB_SYNTEK2_VENDOR_ID, USB_STK_0501_PRODUCT_ID) },
00116     { }
00117 };
00118 
00119 
00120 MODULE_DEVICE_TABLE(usb, stk11xx_table);        
00133 int usb_stk11xx_isoc_init(struct usb_stk11xx *dev)
00134 {
00135     int i, j;
00136     int ret = 0;
00137     struct urb *urb;
00138     struct usb_device *udev;
00139 
00140     if (dev == NULL)
00141         return -EFAULT;
00142 
00143     if (dev->isoc_init_ok)
00144         return 0;
00145 
00146     udev = dev->udev;
00147 
00148     STK_DEBUG("usb_stk11xx_isoc_init()\n");
00149 
00150     // Allocate URB structure
00151     for (i=0; i<MAX_ISO_BUFS; i++) {
00152         urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
00153 
00154         if (urb == NULL) {
00155             STK_ERROR("Failed to allocate URB %d\n", i);
00156             ret = -ENOMEM;
00157             break;
00158         }
00159 
00160         dev->isobuf[i].urb = urb;
00161     }
00162 
00163     if (ret) {
00164         while (i >= 0) {
00165             if (dev->isobuf[i].urb != NULL)
00166                 usb_free_urb(dev->isobuf[i].urb);
00167 
00168             dev->isobuf[i].urb = NULL;
00169             i--;
00170         }
00171 
00172         return ret;
00173     }
00174 
00175     // Init URB structure
00176     for (i=0; i<MAX_ISO_BUFS; i++) {
00177         urb = dev->isobuf[i].urb;
00178 
00179         urb->interval = 1; 
00180         urb->dev = udev;
00181         urb->pipe = usb_rcvisocpipe(udev, dev->isoc_in_endpointAddr);
00182         urb->transfer_flags = URB_ISO_ASAP;
00183         urb->transfer_buffer = dev->isobuf[i].data;
00184         urb->transfer_buffer_length = ISO_BUFFER_SIZE;
00185         urb->complete = usb_stk11xx_isoc_handler;
00186         urb->context = dev;
00187         urb->start_frame = 0;
00188         urb->number_of_packets = ISO_FRAMES_PER_DESC;
00189 
00190         for (j=0; j<ISO_FRAMES_PER_DESC; j++) {
00191             urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
00192             urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE; //dev->isoc_in_size;
00193         }
00194     }
00195 
00196     STK_DEBUG("dev->isoc_in_size = %X\n", dev->isoc_in_size);
00197     STK_DEBUG("dev->isoc_in_endpointAddr = %X\n", dev->isoc_in_endpointAddr);
00198 
00199     // Link
00200     for (i=0; i<MAX_ISO_BUFS; i++) {
00201         ret = usb_submit_urb(dev->isobuf[i].urb, GFP_KERNEL);
00202 
00203         if (ret)
00204             STK_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
00205         else
00206             STK_DEBUG("URB 0x%p submitted.\n", dev->isobuf[i].urb);
00207 
00208         switch (ret) {
00209             case -ENOMEM:
00210                 STK_ERROR("ENOMEM\n");
00211                 break;
00212             case -ENODEV:
00213                 STK_ERROR("ENODEV\n");
00214                 break;
00215             case -ENXIO:
00216                 STK_ERROR("ENXIO\n");
00217                 break;
00218             case -EINVAL:
00219                 STK_ERROR("EINVAL\n");
00220                 break;
00221             case -EAGAIN:
00222                 STK_ERROR("EAGAIN\n");
00223                 break;
00224             case -EFBIG:
00225                 STK_ERROR("EFBIG\n");
00226                 break;
00227             case -EPIPE:
00228                 STK_ERROR("EPIPE\n");
00229                 break;
00230             case -EMSGSIZE:
00231                 STK_ERROR("EMSGSIZE\n");
00232                 break;
00233         }
00234     }
00235 
00236     // All is done
00237     dev->isoc_init_ok = 1;
00238 
00239     return 0;
00240 }
00241 
00242 
00252 void usb_stk11xx_isoc_handler(struct urb *urb)
00253 {
00254     int i;
00255     int ret;
00256     int skip;
00257 
00258     int awake = 0;
00259     int framestatus;
00260     int framelen;
00261 
00262     unsigned char *fill = NULL;
00263     unsigned char *iso_buf = NULL;
00264 
00265     struct usb_stk11xx *dev;
00266     struct stk11xx_frame_buf *framebuf;
00267 
00268     STK_STREAM("Isoc handler\n");
00269 
00270     dev = (struct usb_stk11xx *) urb->context;
00271 
00272     if (dev == NULL) {
00273         STK_ERROR("isoc_handler called with NULL device !\n");
00274         return;
00275     }
00276 
00277     if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
00278         STK_DEBUG("URB unlinked synchronuously !\n");
00279         return;
00280     }
00281 
00282     if (urb->status != -EINPROGRESS && urb->status != 0) {
00283         const char *errmsg;
00284 
00285         errmsg = "Unknown";
00286 
00287         switch(urb->status) {
00288             case -ENOSR:
00289                 errmsg = "Buffer error (overrun)";
00290                 break;
00291 
00292             case -EPIPE:
00293                 errmsg = "Stalled (device not responding)";
00294                 break;
00295 
00296             case -EOVERFLOW:
00297                 errmsg = "Babble (bad cable?)";
00298                 break;
00299 
00300             case -EPROTO:
00301                 errmsg = "Bit-stuff error (bad cable?)";
00302                 break;
00303 
00304             case -EILSEQ:
00305                 errmsg = "CRC/Timeout (could be anything)";
00306                 break;
00307 
00308             case -ETIMEDOUT:
00309                 errmsg = "NAK (device does not respond)";
00310                 break;
00311         }
00312 
00313         STK_ERROR("isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
00314 
00315         dev->visoc_errors++;
00316 
00317         wake_up_interruptible(&dev->wait_frame);
00318 
00319         urb->dev = dev->udev;
00320         ret = usb_submit_urb(urb, GFP_ATOMIC);
00321 
00322         if (ret != 0) {
00323             STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00324         }
00325 
00326         return;
00327     }
00328 
00329     framebuf = dev->fill_frame;
00330 
00331     if (framebuf == NULL) {
00332         STK_ERROR("isoc_handler without valid fill frame !\n");
00333         
00334         wake_up_interruptible(&dev->wait_frame);
00335 
00336         urb->dev = dev->udev;
00337         ret = usb_submit_urb(urb, GFP_ATOMIC);
00338 
00339         if (ret != 0) {
00340             STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00341         }
00342 
00343         return;
00344     }
00345     else {
00346         fill = framebuf->data + framebuf->filled;
00347     }
00348 
00349     // Reset ISOC error counter
00350     dev->visoc_errors = 0;
00351 
00352     // Compact data
00353     for (i=0; i<urb->number_of_packets; i++) {
00354         framestatus = urb->iso_frame_desc[i].status;
00355         framelen = urb->iso_frame_desc[i].actual_length;
00356         iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
00357 
00358         if (framestatus == 0) {
00359             skip = 4;
00360 
00361             if (framelen > 4) {
00362                 // we found something informational from there
00363                 // the isoc frames have to type of headers
00364                 // type1: 00 xx 00 00 or 20 xx 00 00
00365                 // type2: 80 xx 00 00 00 00 00 00 or a0 xx 00 00 00 00 00 00
00366                 // xx is a sequencer which has never been seen over 0x3f
00367                 //
00368                 // imho data written down looks like bayer, i see similarities after
00369                 // every 640 bytes
00370                 if (*iso_buf & 0x80) {
00371                     skip = 8;
00372                 }
00373 
00374                 // Determine if odd or even frame, and set a flag
00375                 if (framelen == 8) {
00376                     if (*iso_buf & 0x40)
00377                         framebuf->odd = true;
00378                     else
00379                         framebuf->odd = false;
00380                 }
00381                 
00382                 // Our buffer is full !!!
00383                 if (framelen - skip + framebuf->filled > dev->frame_size) {
00384                     STK_ERROR("Frame buffer overflow %d %d %d!\n",
00385                             framelen, framelen-skip+framebuf->filled, dev->frame_size);
00386                     framebuf->errors++;
00387                 }
00388                 // All is OK
00389                 else {
00390                     memcpy(fill, iso_buf + skip, framelen - skip);
00391                     fill += framelen - skip;
00392                 }
00393 
00394                 // New size of our buffer
00395                 framebuf->filled += framelen - skip;
00396             }
00397 
00398             STK_STREAM("URB : Length = %d - Skip = %d - Buffer size = %d\n",
00399                 framelen, skip, framebuf->filled);
00400 
00401             // Data is always follow by a frame with a length '4'
00402             if (framelen == 4) {
00403                 if (framebuf->filled > 0) {
00404                     // Our buffer has enough data ?
00405                     if (framebuf->filled < dev->frame_size)
00406                         framebuf->errors++;
00407 
00408                     // If there are errors, we skip a frame...
00409                     if (framebuf->errors == 0) {
00410                         if (stk11xx_next_frame(dev))
00411                             dev->vframes_dumped++;
00412                     }
00413                     else
00414                         dev->vframes_error++;
00415 
00416                     awake = 1;
00417                     framebuf = dev->fill_frame;
00418                     framebuf->filled = 0;
00419                     framebuf->errors = 0;
00420                     fill = framebuf->data;
00421                 }
00422             }
00423         }
00424         else {
00425             STK_ERROR("Iso frame %d of USB has error %d\n", i, framestatus);
00426         }
00427     }
00428 
00429     if (awake == 1)
00430         wake_up_interruptible(&dev->wait_frame);
00431 
00432     urb->dev = dev->udev;
00433 
00434     ret = usb_submit_urb(urb, GFP_ATOMIC);
00435 
00436     if (ret != 0) {
00437         STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00438     }
00439 }
00440 
00441 
00449 void usb_stk11xx_isoc_cleanup(struct usb_stk11xx *dev)
00450 {
00451     int i;
00452 
00453     STK_DEBUG("Isoc cleanup\n");
00454 
00455     if (dev == NULL)
00456         return;
00457 
00458     if (dev->isoc_init_ok == 0)
00459         return;
00460 
00461     // Unlinking ISOC buffers
00462     for (i=0; i<MAX_ISO_BUFS; i++) {
00463         struct urb *urb;
00464 
00465         urb = dev->isobuf[i].urb;
00466 
00467         if (urb != 0) {
00468             if (dev->isoc_init_ok)
00469                 usb_kill_urb(urb);
00470             
00471             usb_free_urb(urb);
00472             dev->isobuf[i].urb = NULL;
00473         }
00474     }
00475 
00476     // All is done
00477     dev->isoc_init_ok = 0;
00478 }
00479 
00480 
00481 
00492 int usb_stk11xx_set_feature(struct usb_stk11xx *dev, int index)
00493 {
00494     int result;
00495     struct usb_device *udev = dev->udev;
00496 
00497     result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00498             USB_REQ_SET_FEATURE,
00499             USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE,
00500             USB_DEVICE_REMOTE_WAKEUP,
00501             index,
00502             NULL,
00503             0,
00504             500);
00505     
00506     if (result < 0)
00507         STK_ERROR("SET FEATURE fail !\n");
00508     else 
00509         STK_DEBUG("SET FEATURE\n");
00510 
00511     return result;
00512 }
00513 
00514 
00524 int usb_stk11xx_set_configuration(struct usb_stk11xx *dev)
00525 {
00526     int result;
00527     struct usb_device *udev = dev->udev;
00528 
00529     result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00530             USB_REQ_SET_CONFIGURATION,
00531             USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE,
00532             0,
00533             udev->config[0].desc.bConfigurationValue,
00534             NULL,
00535             0,
00536             500);
00537 
00538     if (result < 0)
00539         STK_ERROR("SET CONFIGURATION fail !\n");
00540     else 
00541         STK_DEBUG("SET CONFIGURATION %d\n", udev->config[0].desc.bConfigurationValue);
00542 
00543     return result;
00544 }
00545 
00546 
00558 int usb_stk11xx_write_registry(struct usb_stk11xx *dev, __u16 index, __u16 value)
00559 {
00560     int result;
00561     struct usb_device *udev = dev->udev;
00562 
00563     result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00564             0x01,
00565             USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
00566             value,
00567             index,
00568             NULL,
00569             0,
00570             500);
00571 
00572     if (result < 0)
00573         STK_ERROR("Write registry fails %02X = %02X", index, value);
00574 
00575     return result;
00576 }
00577 
00578 
00590 int usb_stk11xx_read_registry(struct usb_stk11xx *dev, __u16 index, int *value)
00591 {
00592     int result;
00593 
00594     struct usb_device *udev = dev->udev;
00595 
00596     *value = 0;
00597 
00598     result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
00599             0x00,
00600             USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
00601             0x00,
00602             index,
00603             (__u8 *) value,
00604             sizeof(__u8),
00605             500);
00606 
00607     if (result < 0)
00608         STK_ERROR("Read registry fails %02X", index);
00609 
00610     return result;
00611 }
00612 
00613 
00624 static int usb_stk11xx_default_settings(struct usb_stk11xx *dev)
00625 {
00626     switch (dev->webcam_model) {
00627         case SYNTEK_STK_0408:
00628             dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00629             dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00630             dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00631 
00632             dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00633             dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00634             dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00635             dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00636             dev->vsettings.norm = (default_norm == -1) ? 0 : default_norm;
00637             dev->vsettings.input = 0;
00638             break;
00639 
00640         case SYNTEK_STK_M811:
00641         case SYNTEK_STK_A311:
00642             dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00643             dev->vsettings.vflip = (default_vflip == -1) ? 1 : default_vflip;
00644             dev->vsettings.hflip = (default_hflip == -1) ? 1 : default_hflip;
00645 
00646             dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00647             dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00648             dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00649             dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00650             break;
00651 
00652         case SYNTEK_STK_A821:
00653         case SYNTEK_STK_AA11:
00654             dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00655             dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00656             dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00657 
00658             dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00659             dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00660             dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00661             dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00662             break;
00663 
00664         case SYNTEK_STK_6A31:
00665         case SYNTEK_STK_6A33:
00666         case SYNTEK_STK_0500:
00667             dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00668             dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00669             dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00670 
00671             dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00672             dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00673             dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00674             dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00675             break;
00676 
00677         case SYNTEK_STK_6A51:
00678         case SYNTEK_STK_6D51:
00679         case SYNTEK_STK_6A54:
00680             dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00681             dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00682             dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00683 
00684             dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00685             dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00686             dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00687             dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00688             break;
00689 
00690         default:
00691             return -1;
00692     }
00693 
00694     dev->vsettings.default_brightness = dev->vsettings.brightness;
00695     dev->vsettings.default_whiteness = dev->vsettings.whiteness;
00696     dev->vsettings.default_contrast = dev->vsettings.contrast;
00697     dev->vsettings.default_colour = dev->vsettings.colour;
00698     dev->vsettings.default_hflip = dev->vsettings.hflip;
00699     dev->vsettings.default_vflip = dev->vsettings.vflip;
00700 
00701     return 0;
00702 }
00703 
00704 
00716 static int usb_stk11xx_probe(struct usb_interface *interface, const struct usb_device_id *id)
00717 {
00718     int i;
00719     int err;
00720     size_t buffer_size;
00721 
00722     int vendor_id;
00723     int product_id;
00724     int bNumInterfaces;
00725     int webcam_model;
00726     int webcam_type;
00727 
00728     struct usb_stk11xx *dev = NULL;
00729     struct usb_device *udev = interface_to_usbdev(interface);
00730     struct usb_host_interface *iface_desc;
00731     struct usb_endpoint_descriptor *endpoint;
00732 
00733 
00734     // Get USB VendorID and ProductID
00735     vendor_id = le16_to_cpu(udev->descriptor.idVendor);
00736     product_id = le16_to_cpu(udev->descriptor.idProduct);
00737 
00738     // Check if we can handle this device
00739     STK_DEBUG("Probe function called with VendorID=%04X, ProductID=%04X and InterfaceNumber=%d\n",
00740             vendor_id, product_id, interface->cur_altsetting->desc.bInterfaceNumber);
00741 
00742     // The interface are probed one by one.
00743     // We are interested in the video interface (always the interface '0')
00744     // The interfaces '1' or '2' (if presents) are the audio control.
00745     if (interface->cur_altsetting->desc.bInterfaceNumber > 0)
00746         return -ENODEV;
00747 
00748     // Detect device
00749     if (vendor_id == USB_SYNTEK1_VENDOR_ID) {
00750         switch (product_id) {
00751             case USB_STK_A311_PRODUCT_ID:
00752                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00753                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0xA311.\n");
00754                 webcam_model = SYNTEK_STK_A311;
00755                 webcam_type = STK11XX_SXGA;
00756                 break;
00757 
00758             case USB_STK_A821_PRODUCT_ID:
00759                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00760                 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xA821.\n");
00761                 webcam_model = SYNTEK_STK_A821;
00762                 webcam_type = STK11XX_VGA;
00763                 break;
00764 
00765             case USB_STK_AA11_PRODUCT_ID:
00766                 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xAA11.\n");
00767                 STK_INFO("Using code for Product ID AxA821\n");
00768                 webcam_model = SYNTEK_STK_AA11;
00769                 webcam_type = STK11XX_VGA;
00770                 break;
00771 
00772             case USB_STK_6A31_PRODUCT_ID:
00773                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00774                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A31.\n");
00775                 webcam_model = SYNTEK_STK_6A31;
00776                 webcam_type = STK11XX_VGA;
00777                 break;
00778 
00779             case USB_STK_6A33_PRODUCT_ID:
00780                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00781                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A33.\n");
00782                 webcam_model = SYNTEK_STK_6A33;
00783                 webcam_type = STK11XX_VGA;
00784                 break;
00785 
00786             case USB_STK_6A51_PRODUCT_ID:
00787                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00788                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A51.\n");
00789                 webcam_model = SYNTEK_STK_6A51;
00790                 webcam_type = STK11XX_VGA;
00791                 break;
00792 
00793             case USB_STK_6A54_PRODUCT_ID:
00794                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00795                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A54.\n");
00796                 webcam_model = SYNTEK_STK_6A54;
00797                 webcam_type = STK11XX_VGA;
00798                 break;
00799 
00800             case USB_STK_6D51_PRODUCT_ID:
00801                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00802                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6D51.\n");
00803                 webcam_model = SYNTEK_STK_6D51;
00804                 webcam_type = STK11XX_VGA;
00805                 break;
00806 
00807             default:
00808                 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00809                         le16_to_cpu(udev->descriptor.idProduct));
00810                 return -ENODEV;
00811         }
00812     }
00813     else if (vendor_id == USB_SYNTEK2_VENDOR_ID) {
00814         switch (product_id) {
00815             case USB_STK_0408_PRODUCT_ID:
00816                 STK_INFO("Syntek USB2.0 - STK-1160 based device found.\n");
00817                 STK_INFO("Syntek AVStream USB2.0 Video Capture - Product ID 0x0408.\n");
00818                 webcam_model = SYNTEK_STK_0408;
00819                 webcam_type = STK11XX_PAL;
00820                 break;
00821 
00822             case USB_STK_0500_PRODUCT_ID:
00823                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00824                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0500.\n");
00825                 webcam_model = SYNTEK_STK_0500;
00826                 webcam_type = STK11XX_VGA;
00827                 break;
00828 
00829             case USB_STK_0501_PRODUCT_ID:
00830                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00831                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0501.\n");
00832                 webcam_model = SYNTEK_STK_M811;
00833                 webcam_type = STK11XX_SXGA;
00834                 break;
00835 
00836             default:
00837                 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00838                         le16_to_cpu(udev->descriptor.idProduct));
00839                 return -ENODEV;
00840         }
00841     }
00842     else
00843         return -ENODEV;
00844 
00845     // Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device
00846     dev = kzalloc(sizeof(struct usb_stk11xx), GFP_KERNEL);
00847 
00848     if (dev == NULL) {
00849         STK_ERROR("Out of memory !\n");
00850         return -ENOMEM;
00851     }
00852 
00853     // Init mutexes, spinlock, etc.
00854 
00855 #ifndef init_MUTEX
00856     sema_init(&dev->mutex,1);
00857 #else
00858     init_MUTEX(&dev->mutex);
00859 #endif
00860     mutex_init(&dev->modlock);
00861     spin_lock_init(&dev->spinlock);
00862     init_waitqueue_head(&dev->wait_frame);
00863 
00864     // Save pointers
00865     dev->webcam_model = webcam_model;
00866     dev->webcam_type = webcam_type;
00867     dev->udev = udev;
00868     dev->interface = interface;
00869 
00870     // Read the product release 
00871     dev->release = le16_to_cpu(udev->descriptor.bcdDevice);
00872     STK_INFO("Release: %04x\n", dev->release);
00873 
00874     // How many interfaces (1 or 3) ?
00875     bNumInterfaces = udev->config->desc.bNumInterfaces;
00876     STK_INFO("Number of interfaces : %d\n", bNumInterfaces);
00877 
00878 
00879     // Constructor
00880     // 2 : enough for webcam
00881     // 3 : for easycap... it's usefull ?
00882     dev->nbuffers = 2;
00883 //  dev->nbuffers = 3;
00884     dev->len_per_image = PAGE_ALIGN(STK11XX_FRAME_SIZE);
00885 
00886 
00887     // Switch on the camera (to detect size of buffers)
00888     dev_stk11xx_camera_on(dev);
00889 
00890 
00891     // Set up the endpoint information 
00892     // use only the first int-in and isoc-in endpoints
00893     // for the current alternate setting
00894     iface_desc = interface->cur_altsetting;
00895 
00896     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
00897         endpoint = &iface_desc->endpoint[i].desc;
00898 
00899         if (!dev->int_in_endpointAddr
00900                 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00901                 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) {
00902             // we found an interrupt in endpoint
00903             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00904 
00905             dev->int_in_size = buffer_size;
00906             dev->int_in_endpointAddr = (endpoint->bEndpointAddress & 0xf);
00907         }
00908 
00909         if (!dev->isoc_in_endpointAddr
00910                 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00911                 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)) {
00912             // we found an isoc in endpoint
00913             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00914 
00915             dev->isoc_in_size = buffer_size;
00916             dev->isoc_in_endpointAddr = (endpoint->bEndpointAddress & 0xf);
00917         }
00918     }
00919 
00920     if (!(dev->int_in_endpointAddr && dev->isoc_in_endpointAddr)) {
00921         STK_ERROR("Could not find both int-in and isoc-in endpoints");
00922 
00923         kfree(dev);
00924 
00925         return -ENODEV;
00926     }
00927 
00928 
00929     // Switch off camera
00930     dev_stk11xx_camera_off(dev);
00931 
00932     // Initialize the video device
00933     dev->vdev = video_device_alloc();
00934 
00935     if (!dev->vdev) {
00936         kfree(dev);
00937         return -ENOMEM;
00938     }
00939 
00940     // Initialize the camera
00941     dev_stk11xx_initialize_device(dev);
00942     
00943     // Register the video device
00944     err = v4l_stk11xx_register_video_device(dev);
00945 
00946     if (err) {
00947         kfree(dev);
00948         return err;
00949     }
00950 
00951     // Create the entries in the sys filesystem
00952     stk11xx_create_sysfs_files(dev->vdev);
00953 
00954     // Save our data pointer in this interface device
00955     usb_set_intfdata(interface, dev);
00956 
00957     // Default settings video device
00958     usb_stk11xx_default_settings(dev);
00959     
00960     // Enable power management feature
00961 //  usb_autopm_enable(dev->interface);
00962 
00963     return 0;
00964 }
00965 
00966 
00973 static void usb_stk11xx_disconnect(struct usb_interface *interface)
00974 {
00975     struct usb_stk11xx *dev = usb_get_intfdata(interface);
00976 
00977     STK_INFO("Syntek USB2.0 Camera disconnected\n");
00978 
00979     // We got unplugged; this is signalled by an EPIPE error code
00980     if (dev->vopen) {
00981         STK_INFO("Disconnected while webcam is in use !\n");
00982         dev->error_status = EPIPE;
00983     }
00984 
00985     // Alert waiting processes
00986     wake_up_interruptible(&dev->wait_frame);
00987 
00988     // Wait until device is closed
00989     while (dev->vopen)
00990         schedule();
00991 
00992     // Remove the entries in the sys filesystem
00993     stk11xx_remove_sysfs_files(dev->vdev);
00994 
00995     // Unregister the video device
00996     v4l_stk11xx_unregister_video_device(dev);
00997     
00998     usb_set_intfdata(interface, NULL);
00999 
01000     kfree(dev);
01001 }
01002 
01003 /*
01004 int usb_stk11xx_suspend(struct usb_interface *interface, pm_message_t message)
01005 {
01006     struct usb_stk11xx *dev = usb_get_intfdata(interface);
01007 
01008     STK_INFO("Syntek USB2.0 Camera Suspend\n");
01009 
01010     // Stop the video stream
01011     dev_stk11xx_stop_stream(dev);
01012             
01013     // ISOC and URB cleanup
01014     usb_stk11xx_isoc_cleanup(dev);
01015 
01016     // Free memory
01017 //  stk11xx_free_buffers(dev);
01018 
01019     // Switch off the camera
01020     dev_stk11xx_camera_off(dev);
01021 
01022     return 0;
01023 }
01024 
01025 
01026 int usb_stk11xx_resume(struct usb_interface *interface)
01027 {
01028     struct usb_stk11xx *dev = usb_get_intfdata(interface);
01029 
01030     STK_INFO("Syntek USB2.0 Camera Resume\n");
01031 
01032     // Initialize the camera
01033     dev_stk11xx_initialize_device(dev);
01034 
01035     // Select the new video mode
01036     v4l_stk11xx_select_video_mode(dev, dev->view.x, dev->view.y);
01037 
01038     // Clear the buffers
01039     stk11xx_clear_buffers(dev);
01040 
01041     // Initialize the device
01042     dev_stk11xx_init_camera(dev);
01043     dev_stk11xx_camera_on(dev);
01044     dev_stk11xx_reconf_camera(dev);
01045 
01046     // ISOC and URB init
01047     usb_stk11xx_isoc_init(dev);
01048 
01049     // Start the video stream
01050     dev_stk11xx_start_stream(dev);
01051 
01052     // Video settings
01053     dev_stk11xx_camera_settings(dev);
01054 
01055     return 0;
01056 }
01057 */
01058 
01059 
01065 static struct usb_driver usb_stk11xx_driver = {
01066     .name = "usb_stk11xx_driver",
01067     .probe = usb_stk11xx_probe,
01068     .disconnect = usb_stk11xx_disconnect,
01069     .id_table = stk11xx_table,
01070 //  .suspend = usb_stk11xx_suspend,
01071 //  .resume = usb_stk11xx_resume,
01072 };
01073 
01074 
01079 static int fps;
01080 
01085 static int hflip = -1;
01086 
01091 static int vflip = -1;
01092 
01097 static int brightness = -1;
01098 
01103 static int whiteness = -1;
01104 
01109 static int contrast = -1;
01110 
01115 static int colour = -1;
01116 
01121 static int norm = -1;
01122 
01123 
01124 module_param(fps, int, 0444);           
01125 module_param(hflip, int, 0444);         
01126 module_param(vflip, int, 0444);         
01128 module_param(brightness, int, 0444);    
01129 module_param(whiteness, int, 0444);     
01130 module_param(contrast, int, 0444);      
01131 module_param(colour, int, 0444);        
01132 module_param(norm, int, 0444);          
01143 static int __init usb_stk11xx_init(void)
01144 {
01145     int result;
01146 
01147     STK_INFO("%s driver %s startup\n", DRIVER_DESC, DRIVER_VERSION);
01148     STK_INFO("Copyright(c) 2006-%d %s\n", DRIVER_YEAR, DRIVER_AUTHOR);
01149     STK_INFO("%s\n", DRIVER_URL);
01150 
01151     // Frame per second parameter
01152     if (fps) {
01153         if (fps < 9 || fps > 30) {
01154             STK_ERROR("Framerate out of bounds [10-30] !\n");
01155             return -EINVAL;
01156         }
01157 
01158         default_fps = fps;
01159     }
01160 
01161     // Horizontal flip value
01162     if ((hflip == 0) || (hflip == 1)) {
01163         STK_DEBUG("Set horizontal flip = %d\n", hflip);
01164 
01165         default_hflip = hflip;
01166     }
01167 
01168     // Vertical flip value
01169     if ((vflip == 0) || (vflip == 1)) {
01170         STK_DEBUG("Set vertical flip = %d\n", vflip);
01171 
01172         default_vflip = vflip;
01173     }
01174 
01175     // Brightness value
01176     if (brightness > -1) {
01177         STK_DEBUG("Set brightness = 0x%X\n", brightness);
01178 
01179         default_brightness = 0xffff & brightness;
01180     }
01181 
01182     // Whiteness value
01183     if (whiteness > -1) {
01184         STK_DEBUG("Set whiteness = 0x%X\n", whiteness);
01185 
01186         default_whiteness = 0xffff & whiteness;
01187     }
01188 
01189     // Contrast value
01190     if (contrast > -1) {
01191         STK_DEBUG("Set contrast = 0x%X\n", contrast);
01192 
01193         default_contrast = 0xffff & contrast;
01194     }
01195 
01196     // Colour value
01197     if (colour > -1) {
01198         STK_DEBUG("Set colour = 0x%X\n", colour);
01199 
01200         default_colour = 0xffff & colour;
01201     }
01202 
01203     // Norm value
01204     if (norm > -1) {
01205         default_norm = (norm > 0) ? 1 : 0;
01206 
01207         STK_INFO("Set norm = %s\n", (default_norm > 0) ? "NTSC" : "PAL");
01208     }
01209  
01210 
01211     // Register the driver with the USB subsystem
01212     result = usb_register(&usb_stk11xx_driver);
01213 
01214     if (result)
01215         STK_ERROR("usb_register failed ! Error number %d\n", result);
01216 
01217     return result;
01218 }
01219 
01220 
01226 static void __exit usb_stk11xx_exit(void)
01227 {
01228     STK_INFO("usb_stk11xx_exit: Syntek USB2.0 webcam driver shutdown\n");
01229 
01230     // Deregister this driver with the USB subsystem
01231     usb_deregister(&usb_stk11xx_driver);
01232 }
01233 
01234 
01235 module_init(usb_stk11xx_init);                      
01236 module_exit(usb_stk11xx_exit);                      
01239 MODULE_PARM_DESC(fps, "Frames per second [5-30]");  
01240 MODULE_PARM_DESC(hflip, "Horizontal image flip");   
01241 MODULE_PARM_DESC(vflip, "Vertical image flip");     
01242 MODULE_PARM_DESC(brightness, "Brightness setting"); 
01243 MODULE_PARM_DESC(whiteness, "Whiteness setting");   
01244 MODULE_PARM_DESC(colour, "Colour setting");         
01245 MODULE_PARM_DESC(contrast, "Contrast setting");     
01246 MODULE_PARM_DESC(norm, "Norm setting (0=NTSC, 1=PAL)"); 
01249 MODULE_LICENSE("GPL");                              
01250 MODULE_AUTHOR(DRIVER_AUTHOR);                       
01251 MODULE_DESCRIPTION(DRIVER_DESC);                    
01252 MODULE_SUPPORTED_DEVICE(DRIVER_SUPPORT);            
01253 MODULE_VERSION(DRIVER_VERSION);                     
01254 MODULE_INFO(url, DRIVER_URL);