Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /* Linux driver for Philips webcam
0003    USB and Video4Linux interface part.
0004    (C) 1999-2004 Nemosoft Unv.
0005    (C) 2004-2006 Luc Saillard (luc@saillard.org)
0006    (C) 2011 Hans de Goede <hdegoede@redhat.com>
0007 
0008    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
0009    driver and thus may have bugs that are not present in the original version.
0010    Please send bug reports and support requests to <luc@saillard.org>.
0011    The decompression routines have been implemented by reverse-engineering the
0012    Nemosoft binary pwcx module. Caveat emptor.
0013 
0014 
0015 */
0016 
0017 /*
0018    This code forms the interface between the USB layers and the Philips
0019    specific stuff. Some adanved stuff of the driver falls under an
0020    NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
0021    is thus not distributed in source form. The binary pwcx.o module
0022    contains the code that falls under the NDA.
0023 
0024    In case you're wondering: 'pwc' stands for "Philips WebCam", but
0025    I really didn't want to type 'philips_web_cam' every time (I'm lazy as
0026    any Linux kernel hacker, but I don't like uncomprehensible abbreviations
0027    without explanation).
0028 
0029    Oh yes, convention: to disctinguish between all the various pointers to
0030    device-structures, I use these names for the pointer variables:
0031    udev: struct usb_device *
0032    vdev: struct video_device (member of pwc_dev)
0033    pdev: struct pwc_devive *
0034 */
0035 
0036 /* Contributors:
0037    - Alvarado: adding whitebalance code
0038    - Alistar Moire: QuickCam 3000 Pro device/product ID
0039    - Tony Hoyle: Creative Labs Webcam 5 device/product ID
0040    - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
0041    - Jk Fang: Sotec Afina Eye ID
0042    - Xavier Roche: QuickCam Pro 4000 ID
0043    - Jens Knudsen: QuickCam Zoom ID
0044    - J. Debert: QuickCam for Notebooks ID
0045    - Pham Thanh Nam: webcam snapshot button as an event input device
0046 */
0047 
0048 #include <linux/errno.h>
0049 #include <linux/init.h>
0050 #include <linux/mm.h>
0051 #include <linux/module.h>
0052 #include <linux/poll.h>
0053 #include <linux/slab.h>
0054 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
0055 #include <linux/usb/input.h>
0056 #endif
0057 #include <linux/vmalloc.h>
0058 #include <asm/io.h>
0059 #include <linux/kernel.h>       /* simple_strtol() */
0060 
0061 #include "pwc.h"
0062 #include "pwc-kiara.h"
0063 #include "pwc-timon.h"
0064 #include "pwc-dec23.h"
0065 #include "pwc-dec1.h"
0066 
0067 #define CREATE_TRACE_POINTS
0068 #include <trace/events/pwc.h>
0069 
0070 /* Function prototypes and driver templates */
0071 
0072 /* hotplug device table support */
0073 static const struct usb_device_id pwc_device_table [] = {
0074     { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
0075     { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
0076 
0077     { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam 3000 Pro */
0078     { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
0079     { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam 4000 Pro */
0080     { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
0081     { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
0082     { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
0083     { USB_DEVICE(0x046D, 0x08B6) }, /* Logitech/Cisco VT Camera */
0084     { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
0085     { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech QuickCam */
0086 
0087     { USB_DEVICE(0x0471, 0x0302) }, /* Philips PCA645VC */
0088     { USB_DEVICE(0x0471, 0x0303) }, /* Philips PCA646VC */
0089     { USB_DEVICE(0x0471, 0x0304) }, /* Askey VC010 type 2 */
0090     { USB_DEVICE(0x0471, 0x0307) }, /* Philips PCVC675K (Vesta) */
0091     { USB_DEVICE(0x0471, 0x0308) }, /* Philips PCVC680K (Vesta Pro) */
0092     { USB_DEVICE(0x0471, 0x030C) }, /* Philips PCVC690K (Vesta Pro Scan) */
0093     { USB_DEVICE(0x0471, 0x0310) }, /* Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) */
0094     { USB_DEVICE(0x0471, 0x0311) }, /* Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) */
0095     { USB_DEVICE(0x0471, 0x0312) }, /* Philips PCVC750K (ToUCam Pro Scan) */
0096     { USB_DEVICE(0x0471, 0x0313) }, /* Philips PCVC720K/40 (ToUCam XS) */
0097     { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC webcam */
0098     { USB_DEVICE(0x0471, 0x032C) }, /* Philips SPC 880NC webcam */
0099 
0100     { USB_DEVICE(0x04CC, 0x8116) }, /* Sotec Afina Eye */
0101 
0102     { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
0103     { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
0104     { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
0105 
0106     { USB_DEVICE(0x069A, 0x0001) }, /* Askey VC010 type 1 */
0107 
0108     { USB_DEVICE(0x06BE, 0x8116) }, /* AME Co. Afina Eye */
0109 
0110     { USB_DEVICE(0x0d81, 0x1900) }, /* Visionite VCS-UC300 */
0111     { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite VCS-UM100 */
0112 
0113     { }
0114 };
0115 MODULE_DEVICE_TABLE(usb, pwc_device_table);
0116 
0117 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
0118 static void usb_pwc_disconnect(struct usb_interface *intf);
0119 static void pwc_isoc_cleanup(struct pwc_device *pdev);
0120 
0121 static struct usb_driver pwc_driver = {
0122     .name =         "Philips webcam",   /* name */
0123     .id_table =     pwc_device_table,
0124     .probe =        usb_pwc_probe,      /* probe() */
0125     .disconnect =       usb_pwc_disconnect, /* disconnect() */
0126 };
0127 
0128 #define MAX_DEV_HINTS   20
0129 #define MAX_ISOC_ERRORS 20
0130 
0131 #ifdef CONFIG_USB_PWC_DEBUG
0132     int pwc_trace = PWC_DEBUG_LEVEL;
0133 #endif
0134 static int power_save = -1;
0135 static int leds[2] = { 100, 0 };
0136 
0137 /***/
0138 
0139 static const struct v4l2_file_operations pwc_fops = {
0140     .owner =    THIS_MODULE,
0141     .open =     v4l2_fh_open,
0142     .release =  vb2_fop_release,
0143     .read =     vb2_fop_read,
0144     .poll =     vb2_fop_poll,
0145     .mmap =     vb2_fop_mmap,
0146     .unlocked_ioctl = video_ioctl2,
0147 };
0148 static const struct video_device pwc_template = {
0149     .name =     "Philips Webcam",   /* Filled in later */
0150     .release =  video_device_release_empty,
0151     .fops =         &pwc_fops,
0152     .ioctl_ops =    &pwc_ioctl_ops,
0153 };
0154 
0155 /***************************************************************************/
0156 /* Private functions */
0157 
0158 static void *pwc_alloc_urb_buffer(struct usb_device *dev,
0159                   size_t size, dma_addr_t *dma_handle)
0160 {
0161     struct device *dmadev = dev->bus->sysdev;
0162     void *buffer = kmalloc(size, GFP_KERNEL);
0163 
0164     if (!buffer)
0165         return NULL;
0166 
0167     *dma_handle = dma_map_single(dmadev, buffer, size, DMA_FROM_DEVICE);
0168     if (dma_mapping_error(dmadev, *dma_handle)) {
0169         kfree(buffer);
0170         return NULL;
0171     }
0172 
0173     return buffer;
0174 }
0175 
0176 static void pwc_free_urb_buffer(struct usb_device *dev,
0177                 size_t size,
0178                 void *buffer,
0179                 dma_addr_t dma_handle)
0180 {
0181     struct device *dmadev = dev->bus->sysdev;
0182 
0183     dma_unmap_single(dmadev, dma_handle, size, DMA_FROM_DEVICE);
0184     kfree(buffer);
0185 }
0186 
0187 static struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
0188 {
0189     unsigned long flags = 0;
0190     struct pwc_frame_buf *buf = NULL;
0191 
0192     spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
0193     if (list_empty(&pdev->queued_bufs))
0194         goto leave;
0195 
0196     buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
0197     list_del(&buf->list);
0198 leave:
0199     spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
0200     return buf;
0201 }
0202 
0203 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
0204 {
0205     if (down) {
0206         PWC_TRACE("Snapshot button pressed.\n");
0207     } else {
0208         PWC_TRACE("Snapshot button released.\n");
0209     }
0210 
0211 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
0212     if (pdev->button_dev) {
0213         input_report_key(pdev->button_dev, KEY_CAMERA, down);
0214         input_sync(pdev->button_dev);
0215     }
0216 #endif
0217 }
0218 
0219 static void pwc_frame_complete(struct pwc_device *pdev)
0220 {
0221     struct pwc_frame_buf *fbuf = pdev->fill_buf;
0222 
0223     /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
0224        frames on the USB wire after an exposure change. This conditition is
0225        however detected  in the cam and a bit is set in the header.
0226        */
0227     if (pdev->type == 730) {
0228         unsigned char *ptr = (unsigned char *)fbuf->data;
0229 
0230         if (ptr[1] == 1 && ptr[0] & 0x10) {
0231             PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
0232             pdev->drop_frames += 2;
0233         }
0234         if ((ptr[0] ^ pdev->vmirror) & 0x01) {
0235             pwc_snapshot_button(pdev, ptr[0] & 0x01);
0236         }
0237         if ((ptr[0] ^ pdev->vmirror) & 0x02) {
0238             if (ptr[0] & 0x02)
0239                 PWC_TRACE("Image is mirrored.\n");
0240             else
0241                 PWC_TRACE("Image is normal.\n");
0242         }
0243         pdev->vmirror = ptr[0] & 0x03;
0244         /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
0245            after a short frame; this condition is filtered out specifically. A 4 byte
0246            frame doesn't make sense anyway.
0247            So we get either this sequence:
0248            drop_bit set -> 4 byte frame -> short frame -> good frame
0249            Or this one:
0250            drop_bit set -> short frame -> good frame
0251            So we drop either 3 or 2 frames in all!
0252            */
0253         if (fbuf->filled == 4)
0254             pdev->drop_frames++;
0255     } else if (pdev->type == 740 || pdev->type == 720) {
0256         unsigned char *ptr = (unsigned char *)fbuf->data;
0257         if ((ptr[0] ^ pdev->vmirror) & 0x01) {
0258             pwc_snapshot_button(pdev, ptr[0] & 0x01);
0259         }
0260         pdev->vmirror = ptr[0] & 0x03;
0261     }
0262 
0263     /* In case we were instructed to drop the frame, do so silently. */
0264     if (pdev->drop_frames > 0) {
0265         pdev->drop_frames--;
0266     } else {
0267         /* Check for underflow first */
0268         if (fbuf->filled < pdev->frame_total_size) {
0269             PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes); discarded.\n",
0270                        fbuf->filled);
0271         } else {
0272             fbuf->vb.field = V4L2_FIELD_NONE;
0273             fbuf->vb.sequence = pdev->vframe_count;
0274             vb2_buffer_done(&fbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
0275             pdev->fill_buf = NULL;
0276             pdev->vsync = 0;
0277         }
0278     } /* !drop_frames */
0279     pdev->vframe_count++;
0280 }
0281 
0282 /* This gets called for the Isochronous pipe (video). This is done in
0283  * interrupt time, so it has to be fast, not crash, and not stall. Neat.
0284  */
0285 static void pwc_isoc_handler(struct urb *urb)
0286 {
0287     struct pwc_device *pdev = (struct pwc_device *)urb->context;
0288     struct device *dmadev = urb->dev->bus->sysdev;
0289     int i, fst, flen;
0290     unsigned char *iso_buf = NULL;
0291 
0292     trace_pwc_handler_enter(urb, pdev);
0293 
0294     if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
0295         urb->status == -ESHUTDOWN) {
0296         PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronously.\n",
0297                    urb, urb->status == -ENOENT ? "" : "a");
0298         return;
0299     }
0300 
0301     if (pdev->fill_buf == NULL)
0302         pdev->fill_buf = pwc_get_next_fill_buf(pdev);
0303 
0304     if (urb->status != 0) {
0305         const char *errmsg;
0306 
0307         errmsg = "Unknown";
0308         switch(urb->status) {
0309             case -ENOSR:        errmsg = "Buffer error (overrun)"; break;
0310             case -EPIPE:        errmsg = "Stalled (device not responding)"; break;
0311             case -EOVERFLOW:    errmsg = "Babble (bad cable?)"; break;
0312             case -EPROTO:       errmsg = "Bit-stuff error (bad cable?)"; break;
0313             case -EILSEQ:       errmsg = "CRC/Timeout (could be anything)"; break;
0314             case -ETIME:        errmsg = "Device does not respond"; break;
0315         }
0316         PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
0317               urb->status, errmsg);
0318         /* Give up after a number of contiguous errors */
0319         if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
0320         {
0321             PWC_ERROR("Too many ISOC errors, bailing out.\n");
0322             if (pdev->fill_buf) {
0323                 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
0324                         VB2_BUF_STATE_ERROR);
0325                 pdev->fill_buf = NULL;
0326             }
0327         }
0328         pdev->vsync = 0; /* Drop the current frame */
0329         goto handler_end;
0330     }
0331 
0332     /* Reset ISOC error counter. We did get here, after all. */
0333     pdev->visoc_errors = 0;
0334 
0335     dma_sync_single_for_cpu(dmadev,
0336                 urb->transfer_dma,
0337                 urb->transfer_buffer_length,
0338                 DMA_FROM_DEVICE);
0339 
0340     /* vsync: 0 = don't copy data
0341           1 = sync-hunt
0342           2 = synched
0343      */
0344     /* Compact data */
0345     for (i = 0; i < urb->number_of_packets; i++) {
0346         fst  = urb->iso_frame_desc[i].status;
0347         flen = urb->iso_frame_desc[i].actual_length;
0348         iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
0349         if (fst != 0) {
0350             PWC_ERROR("Iso frame %d has error %d\n", i, fst);
0351             continue;
0352         }
0353         if (flen > 0 && pdev->vsync) {
0354             struct pwc_frame_buf *fbuf = pdev->fill_buf;
0355 
0356             if (pdev->vsync == 1) {
0357                 fbuf->vb.vb2_buf.timestamp = ktime_get_ns();
0358                 pdev->vsync = 2;
0359             }
0360 
0361             if (flen + fbuf->filled > pdev->frame_total_size) {
0362                 PWC_ERROR("Frame overflow (%d > %d)\n",
0363                       flen + fbuf->filled,
0364                       pdev->frame_total_size);
0365                 pdev->vsync = 0; /* Let's wait for an EOF */
0366             } else {
0367                 memcpy(fbuf->data + fbuf->filled, iso_buf,
0368                        flen);
0369                 fbuf->filled += flen;
0370             }
0371         }
0372         if (flen < pdev->vlast_packet_size) {
0373             /* Shorter packet... end of frame */
0374             if (pdev->vsync == 2)
0375                 pwc_frame_complete(pdev);
0376             if (pdev->fill_buf == NULL)
0377                 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
0378             if (pdev->fill_buf) {
0379                 pdev->fill_buf->filled = 0;
0380                 pdev->vsync = 1;
0381             }
0382         }
0383         pdev->vlast_packet_size = flen;
0384     }
0385 
0386     dma_sync_single_for_device(dmadev,
0387                    urb->transfer_dma,
0388                    urb->transfer_buffer_length,
0389                    DMA_FROM_DEVICE);
0390 
0391 handler_end:
0392     trace_pwc_handler_exit(urb, pdev);
0393 
0394     i = usb_submit_urb(urb, GFP_ATOMIC);
0395     if (i != 0)
0396         PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
0397 }
0398 
0399 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
0400 static int pwc_isoc_init(struct pwc_device *pdev)
0401 {
0402     struct usb_device *udev;
0403     struct urb *urb;
0404     int i, j, ret;
0405     struct usb_interface *intf;
0406     struct usb_host_interface *idesc = NULL;
0407     int compression = 0; /* 0..3 = uncompressed..high */
0408 
0409     pdev->vsync = 0;
0410     pdev->vlast_packet_size = 0;
0411     pdev->fill_buf = NULL;
0412     pdev->vframe_count = 0;
0413     pdev->visoc_errors = 0;
0414     udev = pdev->udev;
0415 
0416 retry:
0417     /* We first try with low compression and then retry with a higher
0418        compression setting if there is not enough bandwidth. */
0419     ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
0420                  pdev->vframes, &compression, 1);
0421 
0422     /* Get the current alternate interface, adjust packet size */
0423     intf = usb_ifnum_to_if(udev, 0);
0424     if (intf)
0425         idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
0426     if (!idesc)
0427         return -EIO;
0428 
0429     /* Search video endpoint */
0430     pdev->vmax_packet_size = -1;
0431     for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
0432         if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
0433             pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
0434             break;
0435         }
0436     }
0437 
0438     if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
0439         PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
0440         return -ENFILE; /* Odd error, that should be noticeable */
0441     }
0442 
0443     /* Set alternate interface */
0444     PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
0445     ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
0446     if (ret == -ENOSPC && compression < 3) {
0447         compression++;
0448         goto retry;
0449     }
0450     if (ret < 0)
0451         return ret;
0452 
0453     /* Allocate and init Isochronuous urbs */
0454     for (i = 0; i < MAX_ISO_BUFS; i++) {
0455         urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
0456         if (urb == NULL) {
0457             pwc_isoc_cleanup(pdev);
0458             return -ENOMEM;
0459         }
0460         pdev->urbs[i] = urb;
0461         PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
0462 
0463         urb->interval = 1; // devik
0464         urb->dev = udev;
0465         urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
0466         urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
0467         urb->transfer_buffer_length = ISO_BUFFER_SIZE;
0468         urb->transfer_buffer = pwc_alloc_urb_buffer(udev,
0469                                 urb->transfer_buffer_length,
0470                                 &urb->transfer_dma);
0471         if (urb->transfer_buffer == NULL) {
0472             PWC_ERROR("Failed to allocate urb buffer %d\n", i);
0473             pwc_isoc_cleanup(pdev);
0474             return -ENOMEM;
0475         }
0476         urb->complete = pwc_isoc_handler;
0477         urb->context = pdev;
0478         urb->start_frame = 0;
0479         urb->number_of_packets = ISO_FRAMES_PER_DESC;
0480         for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
0481             urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
0482             urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
0483         }
0484     }
0485 
0486     /* link */
0487     for (i = 0; i < MAX_ISO_BUFS; i++) {
0488         ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
0489         if (ret == -ENOSPC && compression < 3) {
0490             compression++;
0491             pwc_isoc_cleanup(pdev);
0492             goto retry;
0493         }
0494         if (ret) {
0495             PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
0496             pwc_isoc_cleanup(pdev);
0497             return ret;
0498         }
0499         PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
0500     }
0501 
0502     /* All is done... */
0503     PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
0504     return 0;
0505 }
0506 
0507 static void pwc_iso_stop(struct pwc_device *pdev)
0508 {
0509     int i;
0510 
0511     /* Unlinking ISOC buffers one by one */
0512     for (i = 0; i < MAX_ISO_BUFS; i++) {
0513         if (pdev->urbs[i]) {
0514             PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
0515             usb_kill_urb(pdev->urbs[i]);
0516         }
0517     }
0518 }
0519 
0520 static void pwc_iso_free(struct pwc_device *pdev)
0521 {
0522     int i;
0523 
0524     /* Freeing ISOC buffers one by one */
0525     for (i = 0; i < MAX_ISO_BUFS; i++) {
0526         struct urb *urb = pdev->urbs[i];
0527 
0528         if (urb) {
0529             PWC_DEBUG_MEMORY("Freeing URB\n");
0530             if (urb->transfer_buffer)
0531                 pwc_free_urb_buffer(urb->dev,
0532                             urb->transfer_buffer_length,
0533                             urb->transfer_buffer,
0534                             urb->transfer_dma);
0535             usb_free_urb(urb);
0536             pdev->urbs[i] = NULL;
0537         }
0538     }
0539 }
0540 
0541 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
0542 static void pwc_isoc_cleanup(struct pwc_device *pdev)
0543 {
0544     PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
0545 
0546     pwc_iso_stop(pdev);
0547     pwc_iso_free(pdev);
0548     usb_set_interface(pdev->udev, 0, 0);
0549 
0550     PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
0551 }
0552 
0553 /* Must be called with vb_queue_lock hold */
0554 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev,
0555                     enum vb2_buffer_state state)
0556 {
0557     unsigned long flags = 0;
0558 
0559     spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
0560     while (!list_empty(&pdev->queued_bufs)) {
0561         struct pwc_frame_buf *buf;
0562 
0563         buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
0564                  list);
0565         list_del(&buf->list);
0566         vb2_buffer_done(&buf->vb.vb2_buf, state);
0567     }
0568     spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
0569 }
0570 
0571 #ifdef CONFIG_USB_PWC_DEBUG
0572 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
0573 {
0574     switch(sensor_type) {
0575         case 0x00:
0576             return "Hyundai CMOS sensor";
0577         case 0x20:
0578             return "Sony CCD sensor + TDA8787";
0579         case 0x2E:
0580             return "Sony CCD sensor + Exas 98L59";
0581         case 0x2F:
0582             return "Sony CCD sensor + ADI 9804";
0583         case 0x30:
0584             return "Sharp CCD sensor + TDA8787";
0585         case 0x3E:
0586             return "Sharp CCD sensor + Exas 98L59";
0587         case 0x3F:
0588             return "Sharp CCD sensor + ADI 9804";
0589         case 0x40:
0590             return "UPA 1021 sensor";
0591         case 0x100:
0592             return "VGA sensor";
0593         case 0x101:
0594             return "PAL MR sensor";
0595         default:
0596             return "unknown type of sensor";
0597     }
0598 }
0599 #endif
0600 
0601 /***************************************************************************/
0602 /* Video4Linux functions */
0603 
0604 static void pwc_video_release(struct v4l2_device *v)
0605 {
0606     struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
0607 
0608     v4l2_ctrl_handler_free(&pdev->ctrl_handler);
0609     v4l2_device_unregister(&pdev->v4l2_dev);
0610     kfree(pdev->ctrl_buf);
0611     kfree(pdev);
0612 }
0613 
0614 /***************************************************************************/
0615 /* Videobuf2 operations */
0616 
0617 static int queue_setup(struct vb2_queue *vq,
0618                 unsigned int *nbuffers, unsigned int *nplanes,
0619                 unsigned int sizes[], struct device *alloc_devs[])
0620 {
0621     struct pwc_device *pdev = vb2_get_drv_priv(vq);
0622     int size;
0623 
0624     if (*nbuffers < MIN_FRAMES)
0625         *nbuffers = MIN_FRAMES;
0626     else if (*nbuffers > MAX_FRAMES)
0627         *nbuffers = MAX_FRAMES;
0628 
0629     *nplanes = 1;
0630 
0631     size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
0632     sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
0633                   pwc_image_sizes[size][1] * 3 / 2);
0634 
0635     return 0;
0636 }
0637 
0638 static int buffer_init(struct vb2_buffer *vb)
0639 {
0640     struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
0641     struct pwc_frame_buf *buf =
0642         container_of(vbuf, struct pwc_frame_buf, vb);
0643 
0644     /* need vmalloc since frame buffer > 128K */
0645     buf->data = vzalloc(PWC_FRAME_SIZE);
0646     if (buf->data == NULL)
0647         return -ENOMEM;
0648 
0649     return 0;
0650 }
0651 
0652 static int buffer_prepare(struct vb2_buffer *vb)
0653 {
0654     struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
0655 
0656     /* Don't allow queueing new buffers after device disconnection */
0657     if (!pdev->udev)
0658         return -ENODEV;
0659 
0660     return 0;
0661 }
0662 
0663 static void buffer_finish(struct vb2_buffer *vb)
0664 {
0665     struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
0666     struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
0667     struct pwc_frame_buf *buf =
0668         container_of(vbuf, struct pwc_frame_buf, vb);
0669 
0670     if (vb->state == VB2_BUF_STATE_DONE) {
0671         /*
0672          * Application has called dqbuf and is getting back a buffer
0673          * we've filled, take the pwc data we've stored in buf->data
0674          * and decompress it into a usable format, storing the result
0675          * in the vb2_buffer.
0676          */
0677         pwc_decompress(pdev, buf);
0678     }
0679 }
0680 
0681 static void buffer_cleanup(struct vb2_buffer *vb)
0682 {
0683     struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
0684     struct pwc_frame_buf *buf =
0685         container_of(vbuf, struct pwc_frame_buf, vb);
0686 
0687     vfree(buf->data);
0688 }
0689 
0690 static void buffer_queue(struct vb2_buffer *vb)
0691 {
0692     struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
0693     struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
0694     struct pwc_frame_buf *buf =
0695         container_of(vbuf, struct pwc_frame_buf, vb);
0696     unsigned long flags = 0;
0697 
0698     /* Check the device has not disconnected between prep and queuing */
0699     if (!pdev->udev) {
0700         vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
0701         return;
0702     }
0703 
0704     spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
0705     list_add_tail(&buf->list, &pdev->queued_bufs);
0706     spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
0707 }
0708 
0709 static int start_streaming(struct vb2_queue *vq, unsigned int count)
0710 {
0711     struct pwc_device *pdev = vb2_get_drv_priv(vq);
0712     int r;
0713 
0714     if (!pdev->udev)
0715         return -ENODEV;
0716 
0717     if (mutex_lock_interruptible(&pdev->v4l2_lock))
0718         return -ERESTARTSYS;
0719     /* Turn on camera and set LEDS on */
0720     pwc_camera_power(pdev, 1);
0721     pwc_set_leds(pdev, leds[0], leds[1]);
0722 
0723     r = pwc_isoc_init(pdev);
0724     if (r) {
0725         /* If we failed turn camera and LEDS back off */
0726         pwc_set_leds(pdev, 0, 0);
0727         pwc_camera_power(pdev, 0);
0728         /* And cleanup any queued bufs!! */
0729         pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED);
0730     }
0731     mutex_unlock(&pdev->v4l2_lock);
0732 
0733     return r;
0734 }
0735 
0736 static void stop_streaming(struct vb2_queue *vq)
0737 {
0738     struct pwc_device *pdev = vb2_get_drv_priv(vq);
0739 
0740     mutex_lock(&pdev->v4l2_lock);
0741     if (pdev->udev) {
0742         pwc_set_leds(pdev, 0, 0);
0743         pwc_camera_power(pdev, 0);
0744         pwc_isoc_cleanup(pdev);
0745     }
0746 
0747     pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR);
0748     if (pdev->fill_buf)
0749         vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
0750                 VB2_BUF_STATE_ERROR);
0751     mutex_unlock(&pdev->v4l2_lock);
0752 }
0753 
0754 static const struct vb2_ops pwc_vb_queue_ops = {
0755     .queue_setup        = queue_setup,
0756     .buf_init       = buffer_init,
0757     .buf_prepare        = buffer_prepare,
0758     .buf_finish     = buffer_finish,
0759     .buf_cleanup        = buffer_cleanup,
0760     .buf_queue      = buffer_queue,
0761     .start_streaming    = start_streaming,
0762     .stop_streaming     = stop_streaming,
0763     .wait_prepare       = vb2_ops_wait_prepare,
0764     .wait_finish        = vb2_ops_wait_finish,
0765 };
0766 
0767 /***************************************************************************/
0768 /* USB functions */
0769 
0770 /* This function gets called when a new device is plugged in or the usb core
0771  * is loaded.
0772  */
0773 
0774 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
0775 {
0776     struct usb_device *udev = interface_to_usbdev(intf);
0777     struct pwc_device *pdev = NULL;
0778     int vendor_id, product_id, type_id;
0779     int rc;
0780     int features = 0;
0781     int compression = 0;
0782     int my_power_save = power_save;
0783     char serial_number[30], *name;
0784 
0785     vendor_id = le16_to_cpu(udev->descriptor.idVendor);
0786     product_id = le16_to_cpu(udev->descriptor.idProduct);
0787 
0788     /* Check if we can handle this device */
0789     PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
0790         vendor_id, product_id,
0791         intf->altsetting->desc.bInterfaceNumber);
0792 
0793     /* the interfaces are probed one by one. We are only interested in the
0794        video interface (0) now.
0795        Interface 1 is the Audio Control, and interface 2 Audio itself.
0796      */
0797     if (intf->altsetting->desc.bInterfaceNumber > 0)
0798         return -ENODEV;
0799 
0800     if (vendor_id == 0x0471) {
0801         switch (product_id) {
0802         case 0x0302:
0803             PWC_INFO("Philips PCA645VC USB webcam detected.\n");
0804             name = "Philips 645 webcam";
0805             type_id = 645;
0806             break;
0807         case 0x0303:
0808             PWC_INFO("Philips PCA646VC USB webcam detected.\n");
0809             name = "Philips 646 webcam";
0810             type_id = 646;
0811             break;
0812         case 0x0304:
0813             PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
0814             name = "Askey VC010 webcam";
0815             type_id = 646;
0816             break;
0817         case 0x0307:
0818             PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
0819             name = "Philips 675 webcam";
0820             type_id = 675;
0821             break;
0822         case 0x0308:
0823             PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
0824             name = "Philips 680 webcam";
0825             type_id = 680;
0826             break;
0827         case 0x030C:
0828             PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
0829             name = "Philips 690 webcam";
0830             type_id = 690;
0831             break;
0832         case 0x0310:
0833             PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
0834             name = "Philips 730 webcam";
0835             type_id = 730;
0836             break;
0837         case 0x0311:
0838             PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
0839             name = "Philips 740 webcam";
0840             type_id = 740;
0841             break;
0842         case 0x0312:
0843             PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
0844             name = "Philips 750 webcam";
0845             type_id = 750;
0846             break;
0847         case 0x0313:
0848             PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
0849             name = "Philips 720K/40 webcam";
0850             type_id = 720;
0851             break;
0852         case 0x0329:
0853             PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
0854             name = "Philips SPC 900NC webcam";
0855             type_id = 740;
0856             break;
0857         case 0x032C:
0858             PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
0859             name = "Philips SPC 880NC webcam";
0860             type_id = 740;
0861             break;
0862         default:
0863             return -ENODEV;
0864         }
0865     }
0866     else if (vendor_id == 0x069A) {
0867         switch(product_id) {
0868         case 0x0001:
0869             PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
0870             name = "Askey VC010 webcam";
0871             type_id = 645;
0872             break;
0873         default:
0874             return -ENODEV;
0875         }
0876     }
0877     else if (vendor_id == 0x046d) {
0878         switch(product_id) {
0879         case 0x08b0:
0880             PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
0881             name = "Logitech QuickCam Pro 3000";
0882             type_id = 740; /* CCD sensor */
0883             break;
0884         case 0x08b1:
0885             PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
0886             name = "Logitech QuickCam Notebook Pro";
0887             type_id = 740; /* CCD sensor */
0888             break;
0889         case 0x08b2:
0890             PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
0891             name = "Logitech QuickCam Pro 4000";
0892             type_id = 740; /* CCD sensor */
0893             if (my_power_save == -1)
0894                 my_power_save = 1;
0895             break;
0896         case 0x08b3:
0897             PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
0898             name = "Logitech QuickCam Zoom";
0899             type_id = 740; /* CCD sensor */
0900             break;
0901         case 0x08B4:
0902             PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
0903             name = "Logitech QuickCam Zoom";
0904             type_id = 740; /* CCD sensor */
0905             if (my_power_save == -1)
0906                 my_power_save = 1;
0907             break;
0908         case 0x08b5:
0909             PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
0910             name = "Logitech QuickCam Orbit";
0911             type_id = 740; /* CCD sensor */
0912             if (my_power_save == -1)
0913                 my_power_save = 1;
0914             features |= FEATURE_MOTOR_PANTILT;
0915             break;
0916         case 0x08b6:
0917             PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
0918             name = "Cisco VT Camera";
0919             type_id = 740; /* CCD sensor */
0920             break;
0921         case 0x08b7:
0922             PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
0923             name = "Logitech ViewPort AV 100";
0924             type_id = 740; /* CCD sensor */
0925             break;
0926         case 0x08b8: /* Where this released? */
0927             PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
0928             name = "Logitech QuickCam (res.)";
0929             type_id = 730; /* Assuming CMOS */
0930             break;
0931         default:
0932             return -ENODEV;
0933         }
0934     }
0935     else if (vendor_id == 0x055d) {
0936         /* I don't know the difference between the C10 and the C30;
0937            I suppose the difference is the sensor, but both cameras
0938            work equally well with a type_id of 675
0939          */
0940         switch(product_id) {
0941         case 0x9000:
0942             PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
0943             name = "Samsung MPC-C10";
0944             type_id = 675;
0945             break;
0946         case 0x9001:
0947             PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
0948             name = "Samsung MPC-C30";
0949             type_id = 675;
0950             break;
0951         case 0x9002:
0952             PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
0953             name = "Samsung MPC-C30";
0954             type_id = 740;
0955             break;
0956         default:
0957             return -ENODEV;
0958         }
0959     }
0960     else if (vendor_id == 0x041e) {
0961         switch(product_id) {
0962         case 0x400c:
0963             PWC_INFO("Creative Labs Webcam 5 detected.\n");
0964             name = "Creative Labs Webcam 5";
0965             type_id = 730;
0966             if (my_power_save == -1)
0967                 my_power_save = 1;
0968             break;
0969         case 0x4011:
0970             PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
0971             name = "Creative Labs Webcam Pro Ex";
0972             type_id = 740;
0973             break;
0974         default:
0975             return -ENODEV;
0976         }
0977     }
0978     else if (vendor_id == 0x04cc) {
0979         switch(product_id) {
0980         case 0x8116:
0981             PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
0982             name = "Sotec Afina Eye";
0983             type_id = 730;
0984             break;
0985         default:
0986             return -ENODEV;
0987         }
0988     }
0989     else if (vendor_id == 0x06be) {
0990         switch(product_id) {
0991         case 0x8116:
0992             /* This is essentially the same cam as the Sotec Afina Eye */
0993             PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
0994             name = "AME Co. Afina Eye";
0995             type_id = 750;
0996             break;
0997         default:
0998             return -ENODEV;
0999         }
1000 
1001     }
1002     else if (vendor_id == 0x0d81) {
1003         switch(product_id) {
1004         case 0x1900:
1005             PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1006             name = "Visionite VCS-UC300";
1007             type_id = 740; /* CCD sensor */
1008             break;
1009         case 0x1910:
1010             PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1011             name = "Visionite VCS-UM100";
1012             type_id = 730; /* CMOS sensor */
1013             break;
1014         default:
1015             return -ENODEV;
1016         }
1017     }
1018     else
1019         return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1020 
1021     if (my_power_save == -1)
1022         my_power_save = 0;
1023 
1024     memset(serial_number, 0, 30);
1025     usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1026     PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1027 
1028     if (udev->descriptor.bNumConfigurations > 1)
1029         PWC_WARNING("Warning: more than 1 configuration available.\n");
1030 
1031     /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1032     pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1033     if (pdev == NULL) {
1034         PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1035         return -ENOMEM;
1036     }
1037     pdev->type = type_id;
1038     pdev->features = features;
1039     pwc_construct(pdev); /* set min/max sizes correct */
1040 
1041     mutex_init(&pdev->v4l2_lock);
1042     mutex_init(&pdev->vb_queue_lock);
1043     spin_lock_init(&pdev->queued_bufs_lock);
1044     INIT_LIST_HEAD(&pdev->queued_bufs);
1045 
1046     pdev->udev = udev;
1047     pdev->power_save = my_power_save;
1048 
1049     /* Init videobuf2 queue structure */
1050     pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1051     pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1052     pdev->vb_queue.drv_priv = pdev;
1053     pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1054     pdev->vb_queue.ops = &pwc_vb_queue_ops;
1055     pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1056     pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1057     rc = vb2_queue_init(&pdev->vb_queue);
1058     if (rc < 0) {
1059         PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1060         goto err_free_mem;
1061     }
1062 
1063     /* Init video_device structure */
1064     pdev->vdev = pwc_template;
1065     strscpy(pdev->vdev.name, name, sizeof(pdev->vdev.name));
1066     pdev->vdev.queue = &pdev->vb_queue;
1067     pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1068     video_set_drvdata(&pdev->vdev, pdev);
1069 
1070     pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1071     PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1072 
1073     /* Allocate USB command buffers */
1074     pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1075     if (!pdev->ctrl_buf) {
1076         PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1077         rc = -ENOMEM;
1078         goto err_free_mem;
1079     }
1080 
1081 #ifdef CONFIG_USB_PWC_DEBUG
1082     /* Query sensor type */
1083     if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1084         PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1085                 pdev->vdev.name,
1086                 pwc_sensor_type_to_string(rc), rc);
1087     }
1088 #endif
1089 
1090     /* Set the leds off */
1091     pwc_set_leds(pdev, 0, 0);
1092 
1093     /* Setup initial videomode */
1094     rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1095                 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1096     if (rc)
1097         goto err_free_mem;
1098 
1099     /* Register controls (and read default values from camera */
1100     rc = pwc_init_controls(pdev);
1101     if (rc) {
1102         PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1103         goto err_free_mem;
1104     }
1105 
1106     /* And powerdown the camera until streaming starts */
1107     pwc_camera_power(pdev, 0);
1108 
1109     /* Register the v4l2_device structure */
1110     pdev->v4l2_dev.release = pwc_video_release;
1111     rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1112     if (rc) {
1113         PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1114         goto err_free_controls;
1115     }
1116 
1117     pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1118     pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1119     pdev->vdev.lock = &pdev->v4l2_lock;
1120     pdev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
1121                  V4L2_CAP_READWRITE;
1122 
1123     rc = video_register_device(&pdev->vdev, VFL_TYPE_VIDEO, -1);
1124     if (rc < 0) {
1125         PWC_ERROR("Failed to register as video device (%d).\n", rc);
1126         goto err_unregister_v4l2_dev;
1127     }
1128     PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1129 
1130 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1131     /* register webcam snapshot button input device */
1132     pdev->button_dev = input_allocate_device();
1133     if (!pdev->button_dev) {
1134         rc = -ENOMEM;
1135         goto err_video_unreg;
1136     }
1137 
1138     usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1139     strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1140 
1141     pdev->button_dev->name = "PWC snapshot button";
1142     pdev->button_dev->phys = pdev->button_phys;
1143     usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1144     pdev->button_dev->dev.parent = &pdev->udev->dev;
1145     pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1146     pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1147 
1148     rc = input_register_device(pdev->button_dev);
1149     if (rc) {
1150         input_free_device(pdev->button_dev);
1151         pdev->button_dev = NULL;
1152         goto err_video_unreg;
1153     }
1154 #endif
1155 
1156     return 0;
1157 
1158 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1159 err_video_unreg:
1160     video_unregister_device(&pdev->vdev);
1161 #endif
1162 err_unregister_v4l2_dev:
1163     v4l2_device_unregister(&pdev->v4l2_dev);
1164 err_free_controls:
1165     v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1166 err_free_mem:
1167     kfree(pdev->ctrl_buf);
1168     kfree(pdev);
1169     return rc;
1170 }
1171 
1172 /* The user yanked out the cable... */
1173 static void usb_pwc_disconnect(struct usb_interface *intf)
1174 {
1175     struct v4l2_device *v = usb_get_intfdata(intf);
1176     struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1177 
1178     mutex_lock(&pdev->vb_queue_lock);
1179     mutex_lock(&pdev->v4l2_lock);
1180     /* No need to keep the urbs around after disconnection */
1181     if (pdev->vb_queue.streaming)
1182         pwc_isoc_cleanup(pdev);
1183     pdev->udev = NULL;
1184 
1185     v4l2_device_disconnect(&pdev->v4l2_dev);
1186     video_unregister_device(&pdev->vdev);
1187     mutex_unlock(&pdev->v4l2_lock);
1188     mutex_unlock(&pdev->vb_queue_lock);
1189 
1190 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1191     if (pdev->button_dev)
1192         input_unregister_device(pdev->button_dev);
1193 #endif
1194 
1195     v4l2_device_put(&pdev->v4l2_dev);
1196 }
1197 
1198 
1199 /*
1200  * Initialization code & module stuff
1201  */
1202 
1203 static unsigned int leds_nargs;
1204 
1205 #ifdef CONFIG_USB_PWC_DEBUG
1206 module_param_named(trace, pwc_trace, int, 0644);
1207 #endif
1208 module_param(power_save, int, 0644);
1209 module_param_array(leds, int, &leds_nargs, 0444);
1210 
1211 #ifdef CONFIG_USB_PWC_DEBUG
1212 MODULE_PARM_DESC(trace, "For debugging purposes");
1213 #endif
1214 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1215 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1216 
1217 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1218 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1219 MODULE_LICENSE("GPL");
1220 MODULE_ALIAS("pwcx");
1221 MODULE_VERSION( PWC_VERSION );
1222 
1223 module_usb_driver(pwc_driver);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!