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/errno.h>
00038 #include <linux/slab.h>
00039 #include <linux/kref.h>
00040 
00041 #include <linux/usb.h>
00042 #include <media/v4l2-common.h>
00043 
00044 #include "stk11xx.h"
00045 
00046 
00051 static int default_fps = -1;
00052 
00057 static int default_hflip = -1;
00058 
00063 static int default_vflip = -1;
00064 
00069 static int default_brightness = -1;
00070 
00075 static int default_whiteness = -1;
00076 
00081 static int default_contrast = -1;
00082 
00087 static int default_colour = -1;
00088 
00089 
00094 static struct usb_device_id stk11xx_table[] = {
00095     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A311_PRODUCT_ID) },
00096     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_A821_PRODUCT_ID) },
00097     { USB_DEVICE(USB_SYNTEK1_VENDOR_ID, USB_STK_6A31_PRODUCT_ID) },
00098 
00099     { USB_DEVICE(USB_SYNTEK2_VENDOR_ID, USB_STK_0501_PRODUCT_ID) },
00100     { }
00101 };
00102 
00103 
00104 MODULE_DEVICE_TABLE(usb, stk11xx_table);        
00117 int usb_stk11xx_isoc_init(struct usb_stk11xx *dev)
00118 {
00119     int i, j;
00120     int ret = 0;
00121     struct urb *urb;
00122     struct usb_device *udev;
00123 
00124     if (dev == NULL)
00125         return -EFAULT;
00126 
00127     if (dev->isoc_init_ok)
00128         return 0;
00129 
00130     udev = dev->udev;
00131 
00132     STK_DEBUG("usb_stk11xx_isoc_init()\n");
00133 
00134     // Allocate URB structure
00135     for (i=0; i<MAX_ISO_BUFS; i++) {
00136         urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
00137 
00138         if (urb == NULL) {
00139             STK_ERROR("Failed to allocate URB %d\n", i);
00140             ret = -ENOMEM;
00141             break;
00142         }
00143 
00144         dev->isobuf[i].urb = urb;
00145     }
00146 
00147     if (ret) {
00148         while (i >= 0) {
00149             if (dev->isobuf[i].urb != NULL)
00150                 usb_free_urb(dev->isobuf[i].urb);
00151 
00152             dev->isobuf[i].urb = NULL;
00153             i--;
00154         }
00155 
00156         return ret;
00157     }
00158 
00159     // Init URB structure
00160     for (i=0; i<MAX_ISO_BUFS; i++) {
00161         urb = dev->isobuf[i].urb;
00162 
00163         urb->interval = 1; 
00164         urb->dev = udev;
00165         urb->pipe = usb_rcvisocpipe(udev, dev->isoc_in_endpointAddr);
00166         urb->transfer_flags = URB_ISO_ASAP;
00167         urb->transfer_buffer = dev->isobuf[i].data;
00168         urb->transfer_buffer_length = ISO_BUFFER_SIZE;
00169         urb->complete = usb_stk11xx_isoc_handler;
00170         urb->context = dev;
00171         urb->start_frame = 0;
00172         urb->number_of_packets = ISO_FRAMES_PER_DESC;
00173 
00174         for (j=0; j<ISO_FRAMES_PER_DESC; j++) {
00175             urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
00176             urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE; //dev->isoc_in_size;
00177         }
00178     }
00179 
00180     STK_DEBUG("dev->isoc_in_size = %X\n", dev->isoc_in_size);
00181     STK_DEBUG("dev->isoc_in_endpointAddr = %X\n", dev->isoc_in_endpointAddr);
00182 
00183     // Link
00184     for (i=0; i<MAX_ISO_BUFS; i++) {
00185         ret = usb_submit_urb(dev->isobuf[i].urb, GFP_KERNEL);
00186 
00187         if (ret)
00188             STK_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
00189         else
00190             STK_DEBUG("URB 0x%p submitted.\n", dev->isobuf[i].urb);
00191 
00192         switch (ret) {
00193             case -ENOMEM:
00194                 STK_ERROR("ENOMEM\n");
00195                 break;
00196             case -ENODEV:
00197                 STK_ERROR("ENODEV\n");
00198                 break;
00199             case -ENXIO:
00200                 STK_ERROR("ENXIO\n");
00201                 break;
00202             case -EINVAL:
00203                 STK_ERROR("EINVAL\n");
00204                 break;
00205             case -EAGAIN:
00206                 STK_ERROR("EAGAIN\n");
00207                 break;
00208             case -EFBIG:
00209                 STK_ERROR("EFBIG\n");
00210                 break;
00211             case -EPIPE:
00212                 STK_ERROR("EPIPE\n");
00213                 break;
00214             case -EMSGSIZE:
00215                 STK_ERROR("EMSGSIZE\n");
00216                 break;
00217         }
00218     }
00219 
00220     // All is done
00221     dev->isoc_init_ok = 1;
00222 
00223     return 0;
00224 }
00225 
00226 
00236 void usb_stk11xx_isoc_handler(struct urb *urb)
00237 {
00238     int i;
00239     int ret;
00240     int skip;
00241 
00242     int awake = 0;
00243     int framestatus;
00244     int framelen;
00245 
00246     unsigned char *fill = NULL;
00247     unsigned char *iso_buf = NULL;
00248 
00249     struct usb_stk11xx *dev;
00250     struct stk11xx_frame_buf *framebuf;
00251 
00252     STK_STREAM("Isoc handler\n");
00253 
00254     dev = (struct usb_stk11xx *) urb->context;
00255 
00256     if (dev == NULL) {
00257         STK_ERROR("isoc_handler called with NULL device !\n");
00258         return;
00259     }
00260 
00261     if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
00262         STK_DEBUG("URB unlinked synchronuously !\n");
00263         return;
00264     }
00265 
00266     if (urb->status != -EINPROGRESS && urb->status != 0) {
00267         const char *errmsg;
00268 
00269         errmsg = "Unknown";
00270 
00271         switch(urb->status) {
00272             case -ENOSR:
00273                 errmsg = "Buffer error (overrun)";
00274                 break;
00275 
00276             case -EPIPE:
00277                 errmsg = "Stalled (device not responding)";
00278                 break;
00279 
00280             case -EOVERFLOW:
00281                 errmsg = "Babble (bad cable?)";
00282                 break;
00283 
00284             case -EPROTO:
00285                 errmsg = "Bit-stuff error (bad cable?)";
00286                 break;
00287 
00288             case -EILSEQ:
00289                 errmsg = "CRC/Timeout (could be anything)";
00290                 break;
00291 
00292             case -ETIMEDOUT:
00293                 errmsg = "NAK (device does not respond)";
00294                 break;
00295         }
00296 
00297         STK_ERROR("isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
00298 
00299         dev->visoc_errors++;
00300 
00301         wake_up_interruptible(&dev->wait_frame);
00302 
00303         urb->dev = dev->udev;
00304         ret = usb_submit_urb(urb, GFP_ATOMIC);
00305 
00306         if (ret != 0) {
00307             STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00308         }
00309 
00310         return;
00311     }
00312 
00313     framebuf = dev->fill_frame;
00314 
00315     if (framebuf == NULL) {
00316         STK_ERROR("isoc_handler without valid fill frame !\n");
00317         
00318         wake_up_interruptible(&dev->wait_frame);
00319 
00320         urb->dev = dev->udev;
00321         ret = usb_submit_urb(urb, GFP_ATOMIC);
00322 
00323         if (ret != 0) {
00324             STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00325         }
00326 
00327         return;
00328     }
00329     else {
00330         fill = framebuf->data + framebuf->filled;
00331     }
00332 
00333     // Reset ISOC error counter
00334     dev->visoc_errors = 0;
00335 
00336     // Compact data
00337     for (i=0; i<urb->number_of_packets; i++) {
00338         framestatus = urb->iso_frame_desc[i].status;
00339         framelen = urb->iso_frame_desc[i].actual_length;
00340         iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
00341 
00342         if (framestatus == 0) {
00343             skip = 4;
00344 
00345             if (framelen > 4) {
00346                 // we found something informational from there
00347                 // the isoc frames have to type of headers
00348                 // type1: 00 xx 00 00 or 20 xx 00 00
00349                 // type2: 80 xx 00 00 00 00 00 00 or a0 xx 00 00 00 00 00 00
00350                 // xx is a sequencer which has never been seen over 0x3f
00351                 //
00352                 // imho data written down looks like bayer, i see similarities after
00353                 // every 640 bytes
00354                 if (*iso_buf & 0x80) {
00355                     skip = 8;
00356                 }
00357 
00358                 // Our buffer is full !!!
00359                 if (framelen - skip + framebuf->filled > dev->frame_size) {
00360                     STK_ERROR("Frame buffer overflow !\n");
00361                     framebuf->errors++;
00362                 }
00363                 // All is OK
00364                 else {
00365                     memcpy(fill, iso_buf + skip, framelen - skip);
00366                     fill += framelen - skip;
00367                 }
00368 
00369                 // New size of our buffer
00370                 framebuf->filled += framelen - skip;
00371             }
00372 
00373             STK_STREAM("URB : Length = %d - Skip = %d - Buffer size = %d\n",
00374                 framelen, skip, framebuf->filled);
00375 
00376             // Data is always follow by a frame with a length '4'
00377             if (framelen == 4) {
00378                 if (framebuf->filled > 0) {
00379                     // Our buffer has enough data ?
00380                     if (framebuf->filled < dev->frame_size)
00381                         framebuf->errors++;
00382 
00383                     // If there are errors, we skip a frame...
00384                     if (framebuf->errors == 0) {
00385                         if (stk11xx_next_frame(dev))
00386                             dev->vframes_dumped++;
00387                     }
00388                     else
00389                         dev->vframes_error++;
00390 
00391                     awake = 1;
00392                     framebuf = dev->fill_frame;
00393                     framebuf->filled = 0;
00394                     framebuf->errors = 0;
00395                     fill = framebuf->data;
00396                 }
00397             }
00398         }
00399         else {
00400             STK_ERROR("Iso frame %d of USB has error %d\n", i, framestatus);
00401         }
00402     }
00403 
00404     if (awake == 1)
00405         wake_up_interruptible(&dev->wait_frame);
00406 
00407     urb->dev = dev->udev;
00408 
00409     ret = usb_submit_urb(urb, GFP_ATOMIC);
00410 
00411     if (ret != 0) {
00412         STK_ERROR("Error (%d) re-submitting urb in stk11xx_isoc_handler.\n", ret);
00413     }
00414 }
00415 
00416 
00424 void usb_stk11xx_isoc_cleanup(struct usb_stk11xx *dev)
00425 {
00426     int i;
00427 
00428     STK_DEBUG("Isoc cleanup\n");
00429 
00430     if (dev == NULL)
00431         return;
00432 
00433     if (dev->isoc_init_ok == 0)
00434         return;
00435 
00436     // Unlinking ISOC buffers
00437     for (i=0; i<MAX_ISO_BUFS; i++) {
00438         struct urb *urb;
00439 
00440         urb = dev->isobuf[i].urb;
00441 
00442         if (urb != 0) {
00443             if (dev->isoc_init_ok)
00444                 usb_kill_urb(urb);
00445             
00446             usb_free_urb(urb);
00447             dev->isobuf[i].urb = NULL;
00448         }
00449     }
00450 
00451     // All is done
00452     dev->isoc_init_ok = 0;
00453 }
00454 
00455 
00456 
00467 int usb_stk11xx_set_feature(struct usb_stk11xx *dev, int index)
00468 {
00469     int result;
00470     struct usb_device *udev = dev->udev;
00471 
00472     result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00473             USB_REQ_SET_FEATURE,
00474             USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE,
00475             USB_DEVICE_REMOTE_WAKEUP,
00476             index,
00477             NULL,
00478             0,
00479             500);
00480     
00481     if (result < 0)
00482         STK_ERROR("SET FEATURE fail !\n");
00483     else 
00484         STK_DEBUG("SET FEATURE\n");
00485 
00486     return result;
00487 }
00488 
00489 
00499 int usb_stk11xx_set_configuration(struct usb_stk11xx *dev)
00500 {
00501     int result;
00502     struct usb_device *udev = dev->udev;
00503 
00504     result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00505             USB_REQ_SET_CONFIGURATION,
00506             USB_TYPE_STANDARD | USB_DIR_OUT | USB_RECIP_DEVICE,
00507             0,
00508             udev->config[0].desc.bConfigurationValue,
00509             NULL,
00510             0,
00511             500);
00512 
00513     if (result < 0)
00514         STK_ERROR("SET CONFIGURATION fail !\n");
00515     else 
00516         STK_DEBUG("SET CONFIGURATION %d\n", udev->config[0].desc.bConfigurationValue);
00517 
00518     return result;
00519 }
00520 
00521 
00533 int usb_stk11xx_write_registry(struct usb_stk11xx *dev, __u16 index, __u16 value)
00534 {
00535     int result;
00536     struct usb_device *udev = dev->udev;
00537 
00538     result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
00539             0x01,
00540             USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
00541             value,
00542             index,
00543             NULL,
00544             0,
00545             500);
00546 
00547     if (result < 0)
00548         STK_ERROR("Write registry fails %02X = %02X", index, value);
00549 
00550     return result;
00551 }
00552 
00553 
00565 int usb_stk11xx_read_registry(struct usb_stk11xx *dev, __u16 index, int *value)
00566 {
00567     int result;
00568 
00569     struct usb_device *udev = dev->udev;
00570 
00571     *value = 0;
00572 
00573     result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
00574             0x00,
00575             USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
00576             0x00,
00577             index,
00578             (__u8 *) value,
00579             sizeof(__u8),
00580             500);
00581 
00582     if (result < 0)
00583         STK_ERROR("Read registry fails %02X", index);
00584 
00585     return result;
00586 }
00587 
00588 
00599 static int usb_stk11xx_default_settings(struct usb_stk11xx *dev)
00600 {
00601     switch (dev->webcam_model) {
00602         case SYNTEK_STK_M811:
00603             dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00604             dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00605             dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00606 
00607             dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00608             dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00609             dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00610             dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00611             break;
00612 
00613         case SYNTEK_STK_A311:
00614             dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00615             dev->vsettings.vflip = (default_vflip == -1) ? 1 : default_vflip;
00616             dev->vsettings.hflip = (default_hflip == -1) ? 1 : default_hflip;
00617 
00618             dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00619             dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00620             dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00621             dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00622             break;
00623 
00624         case SYNTEK_STK_A821:
00625             dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00626             dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00627             dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00628 
00629             dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00630             dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00631             dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00632             dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00633             break;
00634 
00635         case SYNTEK_STK_6A31:
00636             dev->vsettings.fps = (default_fps == -1) ? 25 : default_fps;
00637             dev->vsettings.vflip = (default_vflip == -1) ? 0 : default_vflip;
00638             dev->vsettings.hflip = (default_hflip == -1) ? 0 : default_hflip;
00639 
00640             dev->vsettings.brightness = (default_brightness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_brightness;
00641             dev->vsettings.whiteness = (default_whiteness == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_whiteness;
00642             dev->vsettings.contrast = (default_contrast == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_contrast;
00643             dev->vsettings.colour = (default_colour == -1) ? STK11XX_PERCENT(50, 0xFFFF) : default_colour;
00644             break;
00645 
00646         default:
00647             return -1;
00648     }
00649 
00650     return 0;
00651 }
00652 
00653 
00665 static int usb_stk11xx_probe(struct usb_interface *interface, const struct usb_device_id *id)
00666 {
00667     int i;
00668     int err;
00669     size_t buffer_size;
00670 
00671     int vendor_id;
00672     int product_id;
00673     int bNumInterfaces;
00674     int webcam_model;
00675     int webcam_type;
00676 
00677     struct usb_stk11xx *dev = NULL;
00678     struct usb_device *udev = interface_to_usbdev(interface);
00679     struct usb_host_interface *iface_desc;
00680     struct usb_endpoint_descriptor *endpoint;
00681 
00682 
00683     // Get USB VendorID and ProductID
00684     vendor_id = le16_to_cpu(udev->descriptor.idVendor);
00685     product_id = le16_to_cpu(udev->descriptor.idProduct);
00686 
00687     // Check if we can handle this device
00688     STK_DEBUG("Probe function called with VendorID=%04X, ProductID=%04X and InterfaceNumber=%d\n",
00689             vendor_id, product_id, interface->cur_altsetting->desc.bInterfaceNumber);
00690 
00691     // The interface are probed one by one.
00692     // We are interested in the video interface (always the interface '0')
00693     // The interfaces '1' or '2' (if presents) are the audio control.
00694     if (interface->cur_altsetting->desc.bInterfaceNumber > 0)
00695         return -ENODEV;
00696 
00697     // Detect device
00698     if (vendor_id == USB_SYNTEK1_VENDOR_ID) {
00699         switch (product_id) {
00700             case USB_STK_A311_PRODUCT_ID:
00701                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00702                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0xA311.\n");
00703                 webcam_model = SYNTEK_STK_A311;
00704                 webcam_type = STK11XX_SXGA;
00705                 break;
00706 
00707             case USB_STK_A821_PRODUCT_ID:
00708                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00709                 STK_INFO("Syntek AVStream USB2.0 VGA WebCam - Product ID 0xA821.\n");
00710                 webcam_model = SYNTEK_STK_A821;
00711                 webcam_type = STK11XX_VGA;
00712                 break;
00713 
00714             case USB_STK_6A31_PRODUCT_ID:
00715                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00716                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x6A31.\n");
00717                 webcam_model = SYNTEK_STK_6A31;
00718                 webcam_type = STK11XX_VGA;
00719                 break;
00720 
00721             default:
00722                 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00723                         le16_to_cpu(udev->descriptor.idProduct));
00724                 return -ENODEV;
00725         }
00726     }
00727     else if (vendor_id == USB_SYNTEK2_VENDOR_ID) {
00728         switch (product_id) {
00729             case USB_STK_0501_PRODUCT_ID:
00730                 STK_INFO("Syntek USB2.0 - STK-1135 based webcam found.\n");
00731                 STK_INFO("Syntek AVStream USB2.0 1.3M WebCam - Product ID 0x0501.\n");
00732                 webcam_model = SYNTEK_STK_M811;
00733                 webcam_type = STK11XX_SXGA;
00734                 break;
00735 
00736             default:
00737                 STK_ERROR("usb_stk11xx_probe failed ! Camera product 0x%04X is not supported.\n",
00738                         le16_to_cpu(udev->descriptor.idProduct));
00739                 return -ENODEV;
00740         }
00741     }
00742     else
00743         return -ENODEV;
00744 
00745     // Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device
00746     dev = kzalloc(sizeof(struct usb_stk11xx), GFP_KERNEL);
00747 
00748     if (dev == NULL) {
00749         STK_ERROR("Out of memory !\n");
00750         return -ENOMEM;
00751     }
00752 
00753     // Init mutexes, spinlock, etc.
00754     init_MUTEX(&dev->mutex);
00755     spin_lock_init(&dev->spinlock);
00756     init_waitqueue_head(&dev->wait_frame);
00757 
00758     // Save pointers
00759     dev->webcam_model = webcam_model;
00760     dev->webcam_type = webcam_type;
00761     dev->udev = udev;
00762     dev->interface = interface;
00763 
00764     // Read the product release 
00765     dev->release = le16_to_cpu(udev->descriptor.bcdDevice);
00766     STK_INFO("Release: %04x\n", dev->release);
00767 
00768     // How many interfaces (1 or 3)
00769     bNumInterfaces = udev->config->desc.bNumInterfaces;
00770     STK_INFO("Number of interfaces : %d\n", bNumInterfaces);
00771 
00772 
00773     // Constructor
00774     dev->nbuffers = 2;
00775     dev->len_per_image = PAGE_ALIGN((1280 * 1024 * 4));
00776 
00777 
00778     // Switch on the camera (to detect size of buffers)
00779     dev_stk11xx_camera_on(dev);
00780 
00781 
00782     // Set up the endpoint information 
00783     // use only the first int-in and isoc-in endpoints
00784     // for the current alternate setting
00785     iface_desc = interface->cur_altsetting;
00786 
00787     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
00788         endpoint = &iface_desc->endpoint[i].desc;
00789 
00790         if (!dev->int_in_endpointAddr
00791                 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00792                 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) {
00793             // we found an interrupt in endpoint
00794             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00795 
00796             dev->int_in_size = buffer_size;
00797             dev->int_in_endpointAddr = (endpoint->bEndpointAddress & 0xF);
00798         }
00799 
00800         if (!dev->isoc_in_endpointAddr
00801                 && ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
00802                 && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)) {
00803             // we found an isoc in endpoint
00804             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
00805 
00806             dev->isoc_in_size = buffer_size;
00807             dev->isoc_in_endpointAddr = (endpoint->bEndpointAddress & 0xF);
00808         }
00809     }
00810 
00811     if (!(dev->int_in_endpointAddr && dev->isoc_in_endpointAddr)) {
00812         STK_ERROR("Could not find both int-in and isoc-in endpoints");
00813 
00814         kfree(dev);
00815 
00816         return -ENODEV;
00817     }
00818 
00819 
00820     // Switch off camera
00821     dev_stk11xx_camera_off(dev);
00822 
00823     // Initialize the video device
00824     dev->vdev = video_device_alloc();
00825 
00826     if (!dev->vdev) {
00827         kfree(dev);
00828         return -ENOMEM;
00829     }
00830 
00831     // Initialize the camera
00832     dev_stk11xx_initialize_device(dev);
00833     
00834     // Register the video device
00835     err = v4l_stk11xx_register_video_device(dev);
00836 
00837     if (err) {
00838         kfree(dev);
00839         return err;
00840     }
00841 
00842     // Create the entries in the sys filesystem
00843     stk11xx_create_sysfs_files(dev->vdev);
00844 
00845     // Save our data pointer in this interface device
00846     usb_set_intfdata(interface, dev);
00847 
00848     // Default settings video device
00849     usb_stk11xx_default_settings(dev);
00850     
00851 
00852     return 0;
00853 }
00854 
00855 
00862 static void usb_stk11xx_disconnect(struct usb_interface *interface)
00863 {
00864     struct usb_stk11xx *dev = usb_get_intfdata(interface);
00865 
00866     STK_INFO("Syntek USB2.0 Camera disconnected\n");
00867 
00868     usb_set_intfdata(interface, NULL);
00869 
00870     // We got unplugged; this is signalled by an EPIPE error code
00871     if (dev->vopen) {
00872         STK_INFO("Disconnected while webcam is in use !\n");
00873         dev->error_status = EPIPE;
00874     }
00875 
00876     // Alert waiting processes
00877     wake_up_interruptible(&dev->wait_frame);
00878 
00879     // Wait until device is closed
00880     while (dev->vopen)
00881         schedule();
00882 
00883     // Unregister the video device
00884     v4l_stk11xx_unregister_video_device(dev);
00885 
00886     // Remove the entries in the sys filesystem
00887     stk11xx_remove_sysfs_files(dev->vdev);
00888 }
00889 
00890 
00896 static struct usb_driver usb_stk11xx_driver = {
00897     .name = "usb_stk11xx_driver",
00898     .probe = usb_stk11xx_probe,
00899     .disconnect = usb_stk11xx_disconnect,
00900     .id_table = stk11xx_table,
00901 };
00902 
00903 
00908 static int fps;
00909 
00914 static int hflip = -1;
00915 
00920 static int vflip = -1;
00921 
00926 static int brightness = -1;
00927 
00932 static int whiteness = -1;
00933 
00938 static int contrast = -1;
00939 
00944 static int colour = -1;
00945 
00946 
00947 module_param(fps, int, 0444);           
00948 module_param(hflip, int, 0444);         
00949 module_param(vflip, int, 0444);         
00951 module_param(brightness, int, 0444);    
00952 module_param(whiteness, int, 0444);     
00953 module_param(contrast, int, 0444);      
00954 module_param(colour, int, 0444);        
00965 static int __init usb_stk11xx_init(void)
00966 {
00967     int result;
00968 
00969 
00970     STK_INFO("Syntek USB2.0 webcam driver startup\n");
00971 
00972     // Frame per second parameter
00973     if (fps) {
00974         if (fps < 9 || fps > 30) {
00975             STK_ERROR("Framerate out of bounds [10-30] !\n");
00976             return -EINVAL;
00977         }
00978 
00979         default_fps = fps;
00980     }
00981 
00982     // Horizontal flip value
00983     if ((hflip == 0) || (hflip == 1)) {
00984         STK_DEBUG("Set horizontal flip = %d\n", hflip);
00985 
00986         default_hflip = hflip;
00987     }
00988 
00989     // Vertical flip value
00990     if ((vflip == 0) || (vflip == 1)) {
00991         STK_DEBUG("Set vertical flip = %d\n", vflip);
00992 
00993         default_vflip = vflip;
00994     }
00995 
00996     // Brightness value
00997     if (brightness > -1) {
00998         STK_DEBUG("Set brightness = 0x%X\n", brightness);
00999 
01000         default_brightness = 0xFFFF & brightness;
01001     }
01002 
01003     // Whiteness value
01004     if (whiteness > -1) {
01005         STK_DEBUG("Set whiteness = 0x%X\n", whiteness);
01006 
01007         default_whiteness = 0xFFFF & whiteness;
01008     }
01009 
01010     // Contrast value
01011     if (contrast > -1) {
01012         STK_DEBUG("Set contrast = 0x%X\n", contrast);
01013 
01014         default_contrast = 0xFFFF & contrast;
01015     }
01016 
01017     // Colour value
01018     if (colour > -1) {
01019         STK_DEBUG("Set colour = 0x%X\n", colour);
01020 
01021         default_colour = 0xFFFF & colour;
01022     }
01023 
01024 
01025     // Register the driver with the USB subsystem
01026     result = usb_register(&usb_stk11xx_driver);
01027 
01028     if (result)
01029         STK_ERROR("usb_register failed ! Error number %d\n", result);
01030 
01031     STK_INFO(DRIVER_VERSION " : " DRIVER_DESC "\n");
01032 
01033     return result;
01034 }
01035 
01036 
01042 static void __exit usb_stk11xx_exit(void)
01043 {
01044     STK_INFO("usb_stk11xx_exit: Syntek USB2.0 webcam driver shutdown\n");
01045 
01046     // Deregister this driver with the USB subsystem
01047     usb_deregister(&usb_stk11xx_driver);
01048 }
01049 
01050 
01051 module_init(usb_stk11xx_init);                      
01052 module_exit(usb_stk11xx_exit);                      
01055 MODULE_PARM_DESC(fps, "Frames per second [5-30]");  
01056 MODULE_PARM_DESC(hflip, "Horizontal image flip");   
01057 MODULE_PARM_DESC(vflip, "Vertical image flip");     
01058 MODULE_PARM_DESC(brightness, "Brightness setting"); 
01059 MODULE_PARM_DESC(whiteness, "Whiteness setting");   
01060 MODULE_PARM_DESC(colour, "Colour setting");         
01061 MODULE_PARM_DESC(contrast, "Contrast setting");     
01064 MODULE_LICENSE("GPL");                              
01065 MODULE_AUTHOR(DRIVER_AUTHOR);                       
01066 MODULE_DESCRIPTION(DRIVER_DESC);                    
01067 MODULE_SUPPORTED_DEVICE(DRIVER_SUPPORT);            

Generated on Tue Oct 30 13:32:13 2007 for SyntekUSBVideoCamera by  doxygen 1.5.3