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     return 0;
00695 }
00696 
00697 
00709 static int usb_stk11xx_probe(struct usb_interface *interface, const struct usb_device_id *id)
00710 {
00711     int i;
00712     int err;
00713     size_t buffer_size;
00714 
00715     int vendor_id;
00716     int product_id;
00717     int bNumInterfaces;
00718     int webcam_model;
00719     int webcam_type;
00720 
00721     struct usb_stk11xx *dev = NULL;
00722     struct usb_device *udev = interface_to_usbdev(interface);
00723     struct usb_host_interface *iface_desc;
00724     struct usb_endpoint_descriptor *endpoint;
00725 
00726 
00727     // Get USB VendorID and ProductID
00728     vendor_id = le16_to_cpu(udev->descriptor.idVendor);
00729     product_id = le16_to_cpu(udev->descriptor.idProduct);
00730 
00731     // Check if we can handle this device
00732     STK_DEBUG("Probe function called with VendorID=%04X, ProductID=%04X and InterfaceNumber=%d\n",
00733             vendor_id, product_id, interface->cur_altsetting->desc.bInterfaceNumber);
00734 
00735     // The interface are probed one by one.
00736     // We are interested in the video interface (always the interface '0')
00737     // The interfaces '1' or '2' (if presents) are the audio control.
00738     if (interface->cur_altsetting->desc.bInterfaceNumber > 0)
00739         return -ENODEV;
00740 
00741     // Detect device
00742     if (vendor_id == USB_SYNTEK1_VENDOR_ID) {
00743         switch (product_id) {
00744             case USB_STK_A311_PRODUCT_ID:
00745                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00746                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0xA311.\n");
00747                 webcam_model = SYNTEK_STK_A311;
00748                 webcam_type = STK11XX_SXGA;
00749                 break;
00750 
00751             case USB_STK_A821_PRODUCT_ID:
00752                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00753                 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xA821.\n");
00754                 webcam_model = SYNTEK_STK_A821;
00755                 webcam_type = STK11XX_VGA;
00756                 break;
00757 
00758             case USB_STK_AA11_PRODUCT_ID:
00759                 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xAA11.\n");
00760                 STK_INFO("Using code for Product ID AxA821\n");
00761                 webcam_model = SYNTEK_STK_AA11;
00762                 webcam_type = STK11XX_VGA;
00763                 break;
00764 
00765             case USB_STK_6A31_PRODUCT_ID:
00766                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00767                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A31.\n");
00768                 webcam_model = SYNTEK_STK_6A31;
00769                 webcam_type = STK11XX_VGA;
00770                 break;
00771 
00772             case USB_STK_6A33_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 0x6A33.\n");
00775                 webcam_model = SYNTEK_STK_6A33;
00776                 webcam_type = STK11XX_VGA;
00777                 break;
00778 
00779             case USB_STK_6A51_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 0x6A51.\n");
00782                 webcam_model = SYNTEK_STK_6A51;
00783                 webcam_type = STK11XX_VGA;
00784                 break;
00785 
00786             case USB_STK_6A54_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 0x6A54.\n");
00789                 webcam_model = SYNTEK_STK_6A54;
00790                 webcam_type = STK11XX_VGA;
00791                 break;
00792 
00793             case USB_STK_6D51_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 0x6D51.\n");
00796                 webcam_model = SYNTEK_STK_6D51;
00797                 webcam_type = STK11XX_VGA;
00798                 break;
00799 
00800             default:
00801                 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00802                         le16_to_cpu(udev->descriptor.idProduct));
00803                 return -ENODEV;
00804         }
00805     }
00806     else if (vendor_id == USB_SYNTEK2_VENDOR_ID) {
00807         switch (product_id) {
00808             case USB_STK_0408_PRODUCT_ID:
00809                 STK_INFO("Syntek USB2.0 - STK-1160 based device found.\n");
00810                 STK_INFO("Syntek AVStream USB2.0 Video Capture - Product ID 0x0408.\n");
00811                 webcam_model = SYNTEK_STK_0408;
00812                 webcam_type = STK11XX_PAL;
00813                 break;
00814 
00815             case USB_STK_0500_PRODUCT_ID:
00816                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00817                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0500.\n");
00818                 webcam_model = SYNTEK_STK_0500;
00819                 webcam_type = STK11XX_VGA;
00820                 break;
00821 
00822             case USB_STK_0501_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 0x0501.\n");
00825                 webcam_model = SYNTEK_STK_M811;
00826                 webcam_type = STK11XX_SXGA;
00827                 break;
00828 
00829             default:
00830                 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00831                         le16_to_cpu(udev->descriptor.idProduct));
00832                 return -ENODEV;
00833         }
00834     }
00835     else
00836         return -ENODEV;
00837 
00838     // Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device
00839     dev = kzalloc(sizeof(struct usb_stk11xx), GFP_KERNEL);
00840 
00841     if (dev == NULL) {
00842         STK_ERROR("Out of memory !\n");
00843         return -ENOMEM;
00844     }
00845 
00846     // Init mutexes, spinlock, etc.
00847 
00848 #ifndef init_MUTEX
00849     sema_init(&dev->mutex,1);
00850 #else
00851     init_MUTEX(&dev->mutex);
00852 #endif
00853     mutex_init(&dev->modlock);
00854     spin_lock_init(&dev->spinlock);
00855     init_waitqueue_head(&dev->wait_frame);
00856 
00857     // Save pointers
00858     dev->webcam_model = webcam_model;
00859     dev->webcam_type = webcam_type;
00860     dev->udev = udev;
00861     dev->interface = interface;
00862 
00863     // Read the product release 
00864     dev->release = le16_to_cpu(udev->descriptor.bcdDevice);
00865     STK_INFO("Release: %04x\n", dev->release);
00866 
00867     // How many interfaces (1 or 3) ?
00868     bNumInterfaces = udev->config->desc.bNumInterfaces;
00869     STK_INFO("Number of interfaces : %d\n", bNumInterfaces);
00870 
00871 
00872     // Constructor
00873     // 2 : enough for webcam
00874     // 3 : for easycap... it's usefull ?
00875     dev->nbuffers = 2;
00876 //  dev->nbuffers = 3;
00877     dev->len_per_image = PAGE_ALIGN(STK11XX_FRAME_SIZE);
00878 
00879 
00880     // Switch on the camera (to detect size of buffers)
00881     dev_stk11xx_camera_on(dev);
00882 
00883 
00884     // Set up the endpoint information 
00885     // use only the first int-in and isoc-in endpoints
00886     // for the current alternate setting
00887     iface_desc = interface->cur_altsetting;
00888 
00889     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
00890         endpoint = &iface_desc->endpoint[i].desc;
00891 
00892         if (!dev->int_in_endpointAddr
00893                 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00894                 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) {
00895             // we found an interrupt in endpoint
00896             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00897 
00898             dev->int_in_size = buffer_size;
00899             dev->int_in_endpointAddr = (endpoint->bEndpointAddress & 0xf);
00900         }
00901 
00902         if (!dev->isoc_in_endpointAddr
00903                 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00904                 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)) {
00905             // we found an isoc in endpoint
00906             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00907 
00908             dev->isoc_in_size = buffer_size;
00909             dev->isoc_in_endpointAddr = (endpoint->bEndpointAddress & 0xf);
00910         }
00911     }
00912 
00913     if (!(dev->int_in_endpointAddr && dev->isoc_in_endpointAddr)) {
00914         STK_ERROR("Could not find both int-in and isoc-in endpoints");
00915 
00916         kfree(dev);
00917 
00918         return -ENODEV;
00919     }
00920 
00921 
00922     // Switch off camera
00923     dev_stk11xx_camera_off(dev);
00924 
00925     // Initialize the video device
00926     dev->vdev = video_device_alloc();
00927 
00928     if (!dev->vdev) {
00929         kfree(dev);
00930         return -ENOMEM;
00931     }
00932 
00933     // Initialize the camera
00934     dev_stk11xx_initialize_device(dev);
00935     
00936     // Register the video device
00937     err = v4l_stk11xx_register_video_device(dev);
00938 
00939     if (err) {
00940         kfree(dev);
00941         return err;
00942     }
00943 
00944     // Create the entries in the sys filesystem
00945     stk11xx_create_sysfs_files(dev->vdev);
00946 
00947     // Save our data pointer in this interface device
00948     usb_set_intfdata(interface, dev);
00949 
00950     // Default settings video device
00951     usb_stk11xx_default_settings(dev);
00952     
00953     // Enable power management feature
00954 //  usb_autopm_enable(dev->interface);
00955 
00956     return 0;
00957 }
00958 
00959 
00966 static void usb_stk11xx_disconnect(struct usb_interface *interface)
00967 {
00968     struct usb_stk11xx *dev = usb_get_intfdata(interface);
00969 
00970     STK_INFO("Syntek USB2.0 Camera disconnected\n");
00971 
00972     usb_set_intfdata(interface, NULL);
00973 
00974     // We got unplugged; this is signalled by an EPIPE error code
00975     if (dev->vopen) {
00976         STK_INFO("Disconnected while webcam is in use !\n");
00977         dev->error_status = EPIPE;
00978     }
00979 
00980     // Alert waiting processes
00981     wake_up_interruptible(&dev->wait_frame);
00982 
00983     // Wait until device is closed
00984     while (dev->vopen)
00985         schedule();
00986 
00987     // Remove the entries in the sys filesystem
00988     stk11xx_remove_sysfs_files(dev->vdev);
00989 
00990     // Unregister the video device
00991     v4l_stk11xx_unregister_video_device(dev);
00992 }
00993 
00994 /*
00995 int usb_stk11xx_suspend(struct usb_interface *interface, pm_message_t message)
00996 {
00997     struct usb_stk11xx *dev = usb_get_intfdata(interface);
00998 
00999     STK_INFO("Syntek USB2.0 Camera Suspend\n");
01000 
01001     // Stop the video stream
01002     dev_stk11xx_stop_stream(dev);
01003             
01004     // ISOC and URB cleanup
01005     usb_stk11xx_isoc_cleanup(dev);
01006 
01007     // Free memory
01008 //  stk11xx_free_buffers(dev);
01009 
01010     // Switch off the camera
01011     dev_stk11xx_camera_off(dev);
01012 
01013     return 0;
01014 }
01015 
01016 
01017 int usb_stk11xx_resume(struct usb_interface *interface)
01018 {
01019     struct usb_stk11xx *dev = usb_get_intfdata(interface);
01020 
01021     STK_INFO("Syntek USB2.0 Camera Resume\n");
01022 
01023     // Initialize the camera
01024     dev_stk11xx_initialize_device(dev);
01025 
01026     // Select the new video mode
01027     v4l_stk11xx_select_video_mode(dev, dev->view.x, dev->view.y);
01028 
01029     // Clear the buffers
01030     stk11xx_clear_buffers(dev);
01031 
01032     // Initialize the device
01033     dev_stk11xx_init_camera(dev);
01034     dev_stk11xx_camera_on(dev);
01035     dev_stk11xx_reconf_camera(dev);
01036 
01037     // ISOC and URB init
01038     usb_stk11xx_isoc_init(dev);
01039 
01040     // Start the video stream
01041     dev_stk11xx_start_stream(dev);
01042 
01043     // Video settings
01044     dev_stk11xx_camera_settings(dev);
01045 
01046     return 0;
01047 }
01048 */
01049 
01050 
01056 static struct usb_driver usb_stk11xx_driver = {
01057     .name = "usb_stk11xx_driver",
01058     .probe = usb_stk11xx_probe,
01059     .disconnect = usb_stk11xx_disconnect,
01060     .id_table = stk11xx_table,
01061 //  .suspend = usb_stk11xx_suspend,
01062 //  .resume = usb_stk11xx_resume,
01063 };
01064 
01065 
01070 static int fps;
01071 
01076 static int hflip = -1;
01077 
01082 static int vflip = -1;
01083 
01088 static int brightness = -1;
01089 
01094 static int whiteness = -1;
01095 
01100 static int contrast = -1;
01101 
01106 static int colour = -1;
01107 
01112 static int norm = -1;
01113 
01114 
01115 module_param(fps, int, 0444);           
01116 module_param(hflip, int, 0444);         
01117 module_param(vflip, int, 0444);         
01119 module_param(brightness, int, 0444);    
01120 module_param(whiteness, int, 0444);     
01121 module_param(contrast, int, 0444);      
01122 module_param(colour, int, 0444);        
01123 module_param(norm, int, 0444);          
01134 static int __init usb_stk11xx_init(void)
01135 {
01136     int result;
01137 
01138 
01139     STK_INFO("Syntek USB2.0 webcam driver startup\n");
01140     STK_INFO("Copyright(c) 2006-2009 Nicolas VIVIEN\n");
01141 
01142     // Frame per second parameter
01143     if (fps) {
01144         if (fps < 9 || fps > 30) {
01145             STK_ERROR("Framerate out of bounds [10-30] !\n");
01146             return -EINVAL;
01147         }
01148 
01149         default_fps = fps;
01150     }
01151 
01152     // Horizontal flip value
01153     if ((hflip == 0) || (hflip == 1)) {
01154         STK_DEBUG("Set horizontal flip = %d\n", hflip);
01155 
01156         default_hflip = hflip;
01157     }
01158 
01159     // Vertical flip value
01160     if ((vflip == 0) || (vflip == 1)) {
01161         STK_DEBUG("Set vertical flip = %d\n", vflip);
01162 
01163         default_vflip = vflip;
01164     }
01165 
01166     // Brightness value
01167     if (brightness > -1) {
01168         STK_DEBUG("Set brightness = 0x%X\n", brightness);
01169 
01170         default_brightness = 0xffff & brightness;
01171     }
01172 
01173     // Whiteness value
01174     if (whiteness > -1) {
01175         STK_DEBUG("Set whiteness = 0x%X\n", whiteness);
01176 
01177         default_whiteness = 0xffff & whiteness;
01178     }
01179 
01180     // Contrast value
01181     if (contrast > -1) {
01182         STK_DEBUG("Set contrast = 0x%X\n", contrast);
01183 
01184         default_contrast = 0xffff & contrast;
01185     }
01186 
01187     // Colour value
01188     if (colour > -1) {
01189         STK_DEBUG("Set colour = 0x%X\n", colour);
01190 
01191         default_colour = 0xffff & colour;
01192     }
01193 
01194     // Norm value
01195     if (norm > -1) {
01196         default_norm = (norm > 0) ? 1 : 0;
01197 
01198         STK_INFO("Set norm = %s\n", (default_norm > 0) ? "NTSC" : "PAL");
01199     }
01200  
01201 
01202     // Register the driver with the USB subsystem
01203     result = usb_register(&usb_stk11xx_driver);
01204 
01205     if (result)
01206         STK_ERROR("usb_register failed ! Error number %d\n", result);
01207 
01208     STK_INFO(DRIVER_VERSION " : " DRIVER_DESC "\n");
01209 
01210     return result;
01211 }
01212 
01213 
01219 static void __exit usb_stk11xx_exit(void)
01220 {
01221     STK_INFO("usb_stk11xx_exit: Syntek USB2.0 webcam driver shutdown\n");
01222 
01223     // Deregister this driver with the USB subsystem
01224     usb_deregister(&usb_stk11xx_driver);
01225 }
01226 
01227 
01228 module_init(usb_stk11xx_init);                      
01229 module_exit(usb_stk11xx_exit);                      
01232 MODULE_PARM_DESC(fps, "Frames per second [5-30]");  
01233 MODULE_PARM_DESC(hflip, "Horizontal image flip");   
01234 MODULE_PARM_DESC(vflip, "Vertical image flip");     
01235 MODULE_PARM_DESC(brightness, "Brightness setting"); 
01236 MODULE_PARM_DESC(whiteness, "Whiteness setting");   
01237 MODULE_PARM_DESC(colour, "Colour setting");         
01238 MODULE_PARM_DESC(contrast, "Contrast setting");     
01239 MODULE_PARM_DESC(norm, "Norm setting (0=NTSC, 1=PAL)"); 
01242 MODULE_LICENSE("GPL");                              
01243 MODULE_AUTHOR(DRIVER_AUTHOR);                       
01244 MODULE_DESCRIPTION(DRIVER_DESC);                    
01245 MODULE_SUPPORTED_DEVICE(DRIVER_SUPPORT);