drivers/media/usb/pwc/pwc-if.c

   1 /* Linux driver for Philips webcam
   2    USB and Video4Linux interface part.
   3    (C) 1999-2004 Nemosoft Unv.
   4    (C) 2004-2006 Luc Saillard (luc@saillard.org)
   5    (C) 2011 Hans de Goede <hdegoede@redhat.com>
   6
   7    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
   8    driver and thus may have bugs that are not present in the original version.
   9    Please send bug reports and support requests to <luc@saillard.org>.
  10    The decompression routines have been implemented by reverse-engineering the
  11    Nemosoft binary pwcx module. Caveat emptor.
  12
  13    This program is free software; you can redistribute it and/or modify
  14    it under the terms of the GNU General Public License as published by
  15    the Free Software Foundation; either version 2 of the License, or
  16    (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26
  27 */
  28
  29 /*
  30    This code forms the interface between the USB layers and the Philips
  31    specific stuff. Some adanved stuff of the driver falls under an
  32    NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
  33    is thus not distributed in source form. The binary pwcx.o module
  34    contains the code that falls under the NDA.
  35
  36    In case you're wondering: 'pwc' stands for "Philips WebCam", but
  37    I really didn't want to type 'philips_web_cam' every time (I'm lazy as
  38    any Linux kernel hacker, but I don't like uncomprehensible abbreviations
  39    without explanation).
  40
  41    Oh yes, convention: to disctinguish between all the various pointers to
  42    device-structures, I use these names for the pointer variables:
  43    udev: struct usb_device *
  44    vdev: struct video_device (member of pwc_dev)
  45    pdev: struct pwc_devive *
  46 */
  47
  48 /* Contributors:
  49    - Alvarado: adding whitebalance code
  50    - Alistar Moire: QuickCam 3000 Pro device/product ID
  51    - Tony Hoyle: Creative Labs Webcam 5 device/product ID
  52    - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
  53    - Jk Fang: Sotec Afina Eye ID
  54    - Xavier Roche: QuickCam Pro 4000 ID
  55    - Jens Knudsen: QuickCam Zoom ID
  56    - J. Debert: QuickCam for Notebooks ID
  57    - Pham Thanh Nam: webcam snapshot button as an event input device
  58 */
  59
  60 #include <linux/errno.h>
  61 #include <linux/init.h>
  62 #include <linux/mm.h>
  63 #include <linux/module.h>
  64 #include <linux/poll.h>
  65 #include <linux/slab.h>
  66 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
  67 #include <linux/usb/input.h>
  68 #endif
  69 #include <linux/vmalloc.h>
  70 #include <asm/io.h>
  71 #include <linux/kernel.h>               /* simple_strtol() */
  72
  73 #include "pwc.h"
  74 #include "pwc-kiara.h"
  75 #include "pwc-timon.h"
  76 #include "pwc-dec23.h"
  77 #include "pwc-dec1.h"
  78
  79 /* Function prototypes and driver templates */
  80
  81 /* hotplug device table support */
  82 static const struct usb_device_id pwc_device_table [] = {
  83         { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */
  84         { USB_DEVICE(0x0471, 0x0303) },
  85         { USB_DEVICE(0x0471, 0x0304) },
  86         { USB_DEVICE(0x0471, 0x0307) },
  87         { USB_DEVICE(0x0471, 0x0308) },
  88         { USB_DEVICE(0x0471, 0x030C) },
  89         { USB_DEVICE(0x0471, 0x0310) },
  90         { USB_DEVICE(0x0471, 0x0311) }, /* Philips ToUcam PRO II */
  91         { USB_DEVICE(0x0471, 0x0312) },
  92         { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
  93         { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC PC Camera */
  94         { USB_DEVICE(0x0471, 0x032C) }, /* Philips SPC 880NC PC Camera */
  95         { USB_DEVICE(0x069A, 0x0001) }, /* Askey */
  96         { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
  97         { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
  98         { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
  99         { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
 100         { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
 101         { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
 102         { USB_DEVICE(0x046D, 0x08B6) }, /* Cisco VT Camera */
 103         { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
 104         { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
 105         { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
 106         { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
 107         { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
 108         { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
 109         { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
 110         { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
 111         { USB_DEVICE(0x06BE, 0x8116) }, /* new Afina Eye */
 112         { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
 113         { USB_DEVICE(0x0d81, 0x1900) },
 114         { }
 115 };
 116 MODULE_DEVICE_TABLE(usb, pwc_device_table);
 117
 118 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
 119 static void usb_pwc_disconnect(struct usb_interface *intf);
 120 static void pwc_isoc_cleanup(struct pwc_device *pdev);
 121
 122 static struct usb_driver pwc_driver = {
 123         .name =                 "Philips webcam",       /* name */
 124         .id_table =             pwc_device_table,
 125         .probe =                usb_pwc_probe,          /* probe() */
 126         .disconnect =           usb_pwc_disconnect,     /* disconnect() */
 127 };
 128
 129 #define MAX_DEV_HINTS   20
 130 #define MAX_ISOC_ERRORS 20
 131
 132 #ifdef CONFIG_USB_PWC_DEBUG
 133         int pwc_trace = PWC_DEBUG_LEVEL;
 134 #endif
 135 static int power_save = -1;
 136 static int leds[2] = { 100, 0 };
 137
 138 /***/
 139
 140 static const struct v4l2_file_operations pwc_fops = {
 141         .owner =        THIS_MODULE,
 142         .open =         v4l2_fh_open,
 143         .release =      vb2_fop_release,
 144         .read =         vb2_fop_read,
 145         .poll =         vb2_fop_poll,
 146         .mmap =         vb2_fop_mmap,
 147         .unlocked_ioctl = video_ioctl2,
 148 };
 149 static struct video_device pwc_template = {
 150         .name =         "Philips Webcam",       /* Filled in later */
 151         .release =      video_device_release_empty,
 152         .fops =         &pwc_fops,
 153         .ioctl_ops =    &pwc_ioctl_ops,
 154 };
 155
 156 /***************************************************************************/
 157 /* Private functions */
 158
 159 static struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
 160 {
 161         unsigned long flags = 0;
 162         struct pwc_frame_buf *buf = NULL;
 163
 164         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
 165         if (list_empty(&pdev->queued_bufs))
 166                 goto leave;
 167
 168         buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
 169         list_del(&buf->list);
 170 leave:
 171         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
 172         return buf;
 173 }
 174
 175 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
 176 {
 177         if (down) {
 178                 PWC_TRACE("Snapshot button pressed.\n");
 179         } else {
 180                 PWC_TRACE("Snapshot button released.\n");
 181         }
 182
 183 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
 184         if (pdev->button_dev) {
 185                 input_report_key(pdev->button_dev, KEY_CAMERA, down);
 186                 input_sync(pdev->button_dev);
 187         }
 188 #endif
 189 }
 190
 191 static void pwc_frame_complete(struct pwc_device *pdev)
 192 {
 193         struct pwc_frame_buf *fbuf = pdev->fill_buf;
 194
 195         /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
 196            frames on the USB wire after an exposure change. This conditition is
 197            however detected  in the cam and a bit is set in the header.
 198            */
 199         if (pdev->type == 730) {
 200                 unsigned char *ptr = (unsigned char *)fbuf->data;
 201
 202                 if (ptr[1] == 1 && ptr[0] & 0x10) {
 203                         PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
 204                         pdev->drop_frames += 2;
 205                 }
 206                 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
 207                         pwc_snapshot_button(pdev, ptr[0] & 0x01);
 208                 }
 209                 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
 210                         if (ptr[0] & 0x02)
 211                                 PWC_TRACE("Image is mirrored.\n");
 212                         else
 213                                 PWC_TRACE("Image is normal.\n");
 214                 }
 215                 pdev->vmirror = ptr[0] & 0x03;
 216                 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
 217                    after a short frame; this condition is filtered out specifically. A 4 byte
 218                    frame doesn't make sense anyway.
 219                    So we get either this sequence:
 220                    drop_bit set -> 4 byte frame -> short frame -> good frame
 221                    Or this one:
 222                    drop_bit set -> short frame -> good frame
 223                    So we drop either 3 or 2 frames in all!
 224                    */
 225                 if (fbuf->filled == 4)
 226                         pdev->drop_frames++;
 227         } else if (pdev->type == 740 || pdev->type == 720) {
 228                 unsigned char *ptr = (unsigned char *)fbuf->data;
 229                 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
 230                         pwc_snapshot_button(pdev, ptr[0] & 0x01);
 231                 }
 232                 pdev->vmirror = ptr[0] & 0x03;
 233         }
 234
 235         /* In case we were instructed to drop the frame, do so silently. */
 236         if (pdev->drop_frames > 0) {
 237                 pdev->drop_frames--;
 238         } else {
 239                 /* Check for underflow first */
 240                 if (fbuf->filled < pdev->frame_total_size) {
 241                         PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
 242                                        " discarded.\n", fbuf->filled);
 243                 } else {
 244                         fbuf->vb.field = V4L2_FIELD_NONE;
 245                         fbuf->vb.sequence = pdev->vframe_count;
 246                         vb2_buffer_done(&fbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
 247                         pdev->fill_buf = NULL;
 248                         pdev->vsync = 0;
 249                 }
 250         } /* !drop_frames */
 251         pdev->vframe_count++;
 252 }
 253
 254 /* This gets called for the Isochronous pipe (video). This is done in
 255  * interrupt time, so it has to be fast, not crash, and not stall. Neat.
 256  */
 257 static void pwc_isoc_handler(struct urb *urb)
 258 {
 259         struct pwc_device *pdev = (struct pwc_device *)urb->context;
 260         int i, fst, flen;
 261         unsigned char *iso_buf = NULL;
 262
 263         if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
 264             urb->status == -ESHUTDOWN) {
 265                 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
 266                 return;
 267         }
 268
 269         if (pdev->fill_buf == NULL)
 270                 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
 271
 272         if (urb->status != 0) {
 273                 const char *errmsg;
 274
 275                 errmsg = "Unknown";
 276                 switch(urb->status) {
 277                         case -ENOSR:            errmsg = "Buffer error (overrun)"; break;
 278                         case -EPIPE:            errmsg = "Stalled (device not responding)"; break;
 279                         case -EOVERFLOW:        errmsg = "Babble (bad cable?)"; break;
 280                         case -EPROTO:           errmsg = "Bit-stuff error (bad cable?)"; break;
 281                         case -EILSEQ:           errmsg = "CRC/Timeout (could be anything)"; break;
 282                         case -ETIME:            errmsg = "Device does not respond"; break;
 283                 }
 284                 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
 285                           urb->status, errmsg);
 286                 /* Give up after a number of contiguous errors */
 287                 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
 288                 {
 289                         PWC_ERROR("Too many ISOC errors, bailing out.\n");
 290                         if (pdev->fill_buf) {
 291                                 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
 292                                                 VB2_BUF_STATE_ERROR);
 293                                 pdev->fill_buf = NULL;
 294                         }
 295                 }
 296                 pdev->vsync = 0; /* Drop the current frame */
 297                 goto handler_end;
 298         }
 299
 300         /* Reset ISOC error counter. We did get here, after all. */
 301         pdev->visoc_errors = 0;
 302
 303         /* vsync: 0 = don't copy data
 304                   1 = sync-hunt
 305                   2 = synched
 306          */
 307         /* Compact data */
 308         for (i = 0; i < urb->number_of_packets; i++) {
 309                 fst  = urb->iso_frame_desc[i].status;
 310                 flen = urb->iso_frame_desc[i].actual_length;
 311                 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
 312                 if (fst != 0) {
 313                         PWC_ERROR("Iso frame %d has error %d\n", i, fst);
 314                         continue;
 315                 }
 316                 if (flen > 0 && pdev->vsync) {
 317                         struct pwc_frame_buf *fbuf = pdev->fill_buf;
 318
 319                         if (pdev->vsync == 1) {
 320                                 fbuf->vb.vb2_buf.timestamp = ktime_get_ns();
 321                                 pdev->vsync = 2;
 322                         }
 323
 324                         if (flen + fbuf->filled > pdev->frame_total_size) {
 325                                 PWC_ERROR("Frame overflow (%d > %d)\n",
 326                                           flen + fbuf->filled,
 327                                           pdev->frame_total_size);
 328                                 pdev->vsync = 0; /* Let's wait for an EOF */
 329                         } else {
 330                                 memcpy(fbuf->data + fbuf->filled, iso_buf,
 331                                        flen);
 332                                 fbuf->filled += flen;
 333                         }
 334                 }
 335                 if (flen < pdev->vlast_packet_size) {
 336                         /* Shorter packet... end of frame */
 337                         if (pdev->vsync == 2)
 338                                 pwc_frame_complete(pdev);
 339                         if (pdev->fill_buf == NULL)
 340                                 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
 341                         if (pdev->fill_buf) {
 342                                 pdev->fill_buf->filled = 0;
 343                                 pdev->vsync = 1;
 344                         }
 345                 }
 346                 pdev->vlast_packet_size = flen;
 347         }
 348
 349 handler_end:
 350         i = usb_submit_urb(urb, GFP_ATOMIC);
 351         if (i != 0)
 352                 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
 353 }
 354
 355 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
 356 static int pwc_isoc_init(struct pwc_device *pdev)
 357 {
 358         struct usb_device *udev;
 359         struct urb *urb;
 360         int i, j, ret;
 361         struct usb_interface *intf;
 362         struct usb_host_interface *idesc = NULL;
 363         int compression = 0; /* 0..3 = uncompressed..high */
 364
 365         pdev->vsync = 0;
 366         pdev->vlast_packet_size = 0;
 367         pdev->fill_buf = NULL;
 368         pdev->vframe_count = 0;
 369         pdev->visoc_errors = 0;
 370         udev = pdev->udev;
 371
 372 retry:
 373         /* We first try with low compression and then retry with a higher
 374            compression setting if there is not enough bandwidth. */
 375         ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
 376                                  pdev->vframes, &compression, 1);
 377
 378         /* Get the current alternate interface, adjust packet size */
 379         intf = usb_ifnum_to_if(udev, 0);
 380         if (intf)
 381                 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
 382         if (!idesc)
 383                 return -EIO;
 384
 385         /* Search video endpoint */
 386         pdev->vmax_packet_size = -1;
 387         for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
 388                 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
 389                         pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
 390                         break;
 391                 }
 392         }
 393
 394         if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
 395                 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
 396                 return -ENFILE; /* Odd error, that should be noticeable */
 397         }
 398
 399         /* Set alternate interface */
 400         PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
 401         ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
 402         if (ret == -ENOSPC && compression < 3) {
 403                 compression++;
 404                 goto retry;
 405         }
 406         if (ret < 0)
 407                 return ret;
 408
 409         /* Allocate and init Isochronuous urbs */
 410         for (i = 0; i < MAX_ISO_BUFS; i++) {
 411                 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
 412                 if (urb == NULL) {
 413                         PWC_ERROR("Failed to allocate urb %d\n", i);
 414                         pwc_isoc_cleanup(pdev);
 415                         return -ENOMEM;
 416                 }
 417                 pdev->urbs[i] = urb;
 418                 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
 419
 420                 urb->interval = 1; // devik
 421                 urb->dev = udev;
 422                 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
 423                 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
 424                 urb->transfer_buffer = usb_alloc_coherent(udev,
 425                                                           ISO_BUFFER_SIZE,
 426                                                           GFP_KERNEL,
 427                                                           &urb->transfer_dma);
 428                 if (urb->transfer_buffer == NULL) {
 429                         PWC_ERROR("Failed to allocate urb buffer %d\n", i);
 430                         pwc_isoc_cleanup(pdev);
 431                         return -ENOMEM;
 432                 }
 433                 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
 434                 urb->complete = pwc_isoc_handler;
 435                 urb->context = pdev;
 436                 urb->start_frame = 0;
 437                 urb->number_of_packets = ISO_FRAMES_PER_DESC;
 438                 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
 439                         urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
 440                         urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
 441                 }
 442         }
 443
 444         /* link */
 445         for (i = 0; i < MAX_ISO_BUFS; i++) {
 446                 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
 447                 if (ret == -ENOSPC && compression < 3) {
 448                         compression++;
 449                         pwc_isoc_cleanup(pdev);
 450                         goto retry;
 451                 }
 452                 if (ret) {
 453                         PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
 454                         pwc_isoc_cleanup(pdev);
 455                         return ret;
 456                 }
 457                 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
 458         }
 459
 460         /* All is done... */
 461         PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
 462         return 0;
 463 }
 464
 465 static void pwc_iso_stop(struct pwc_device *pdev)
 466 {
 467         int i;
 468
 469         /* Unlinking ISOC buffers one by one */
 470         for (i = 0; i < MAX_ISO_BUFS; i++) {
 471                 if (pdev->urbs[i]) {
 472                         PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
 473                         usb_kill_urb(pdev->urbs[i]);
 474                 }
 475         }
 476 }
 477
 478 static void pwc_iso_free(struct pwc_device *pdev)
 479 {
 480         int i;
 481
 482         /* Freeing ISOC buffers one by one */
 483         for (i = 0; i < MAX_ISO_BUFS; i++) {
 484                 if (pdev->urbs[i]) {
 485                         PWC_DEBUG_MEMORY("Freeing URB\n");
 486                         if (pdev->urbs[i]->transfer_buffer) {
 487                                 usb_free_coherent(pdev->udev,
 488                                         pdev->urbs[i]->transfer_buffer_length,
 489                                         pdev->urbs[i]->transfer_buffer,
 490                                         pdev->urbs[i]->transfer_dma);
 491                         }
 492                         usb_free_urb(pdev->urbs[i]);
 493                         pdev->urbs[i] = NULL;
 494                 }
 495         }
 496 }
 497
 498 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
 499 static void pwc_isoc_cleanup(struct pwc_device *pdev)
 500 {
 501         PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
 502
 503         pwc_iso_stop(pdev);
 504         pwc_iso_free(pdev);
 505         usb_set_interface(pdev->udev, 0, 0);
 506
 507         PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
 508 }
 509
 510 /* Must be called with vb_queue_lock hold */
 511 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev,
 512                                     enum vb2_buffer_state state)
 513 {
 514         unsigned long flags = 0;
 515
 516         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
 517         while (!list_empty(&pdev->queued_bufs)) {
 518                 struct pwc_frame_buf *buf;
 519
 520                 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
 521                                  list);
 522                 list_del(&buf->list);
 523                 vb2_buffer_done(&buf->vb.vb2_buf, state);
 524         }
 525         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
 526 }
 527
 528 #ifdef CONFIG_USB_PWC_DEBUG
 529 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
 530 {
 531         switch(sensor_type) {
 532                 case 0x00:
 533                         return "Hyundai CMOS sensor";
 534                 case 0x20:
 535                         return "Sony CCD sensor + TDA8787";
 536                 case 0x2E:
 537                         return "Sony CCD sensor + Exas 98L59";
 538                 case 0x2F:
 539                         return "Sony CCD sensor + ADI 9804";
 540                 case 0x30:
 541                         return "Sharp CCD sensor + TDA8787";
 542                 case 0x3E:
 543                         return "Sharp CCD sensor + Exas 98L59";
 544                 case 0x3F:
 545                         return "Sharp CCD sensor + ADI 9804";
 546                 case 0x40:
 547                         return "UPA 1021 sensor";
 548                 case 0x100:
 549                         return "VGA sensor";
 550                 case 0x101:
 551                         return "PAL MR sensor";
 552                 default:
 553                         return "unknown type of sensor";
 554         }
 555 }
 556 #endif
 557
 558 /***************************************************************************/
 559 /* Video4Linux functions */
 560
 561 static void pwc_video_release(struct v4l2_device *v)
 562 {
 563         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
 564
 565         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
 566         v4l2_device_unregister(&pdev->v4l2_dev);
 567         kfree(pdev->ctrl_buf);
 568         kfree(pdev);
 569 }
 570
 571 /***************************************************************************/
 572 /* Videobuf2 operations */
 573
 574 static int queue_setup(struct vb2_queue *vq,
 575                                 unsigned int *nbuffers, unsigned int *nplanes,
 576                                 unsigned int sizes[], struct device *alloc_devs[])
 577 {
 578         struct pwc_device *pdev = vb2_get_drv_priv(vq);
 579         int size;
 580
 581         if (*nbuffers < MIN_FRAMES)
 582                 *nbuffers = MIN_FRAMES;
 583         else if (*nbuffers > MAX_FRAMES)
 584                 *nbuffers = MAX_FRAMES;
 585
 586         *nplanes = 1;
 587
 588         size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
 589         sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
 590                               pwc_image_sizes[size][1] * 3 / 2);
 591
 592         return 0;
 593 }
 594
 595 static int buffer_init(struct vb2_buffer *vb)
 596 {
 597         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 598         struct pwc_frame_buf *buf =
 599                 container_of(vbuf, struct pwc_frame_buf, vb);
 600
 601         /* need vmalloc since frame buffer > 128K */
 602         buf->data = vzalloc(PWC_FRAME_SIZE);
 603         if (buf->data == NULL)
 604                 return -ENOMEM;
 605
 606         return 0;
 607 }
 608
 609 static int buffer_prepare(struct vb2_buffer *vb)
 610 {
 611         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
 612
 613         /* Don't allow queing new buffers after device disconnection */
 614         if (!pdev->udev)
 615                 return -ENODEV;
 616
 617         return 0;
 618 }
 619
 620 static void buffer_finish(struct vb2_buffer *vb)
 621 {
 622         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
 623         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 624         struct pwc_frame_buf *buf =
 625                 container_of(vbuf, struct pwc_frame_buf, vb);
 626
 627         if (vb->state == VB2_BUF_STATE_DONE) {
 628                 /*
 629                  * Application has called dqbuf and is getting back a buffer
 630                  * we've filled, take the pwc data we've stored in buf->data
 631                  * and decompress it into a usable format, storing the result
 632                  * in the vb2_buffer.
 633                  */
 634                 pwc_decompress(pdev, buf);
 635         }
 636 }
 637
 638 static void buffer_cleanup(struct vb2_buffer *vb)
 639 {
 640         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 641         struct pwc_frame_buf *buf =
 642                 container_of(vbuf, struct pwc_frame_buf, vb);
 643
 644         vfree(buf->data);
 645 }
 646
 647 static void buffer_queue(struct vb2_buffer *vb)
 648 {
 649         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
 650         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 651         struct pwc_frame_buf *buf =
 652                 container_of(vbuf, struct pwc_frame_buf, vb);
 653         unsigned long flags = 0;
 654
 655         /* Check the device has not disconnected between prep and queuing */
 656         if (!pdev->udev) {
 657                 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
 658                 return;
 659         }
 660
 661         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
 662         list_add_tail(&buf->list, &pdev->queued_bufs);
 663         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
 664 }
 665
 666 static int start_streaming(struct vb2_queue *vq, unsigned int count)
 667 {
 668         struct pwc_device *pdev = vb2_get_drv_priv(vq);
 669         int r;
 670
 671         if (!pdev->udev)
 672                 return -ENODEV;
 673
 674         if (mutex_lock_interruptible(&pdev->v4l2_lock))
 675                 return -ERESTARTSYS;
 676         /* Turn on camera and set LEDS on */
 677         pwc_camera_power(pdev, 1);
 678         pwc_set_leds(pdev, leds[0], leds[1]);
 679
 680         r = pwc_isoc_init(pdev);
 681         if (r) {
 682                 /* If we failed turn camera and LEDS back off */
 683                 pwc_set_leds(pdev, 0, 0);
 684                 pwc_camera_power(pdev, 0);
 685                 /* And cleanup any queued bufs!! */
 686                 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED);
 687         }
 688         mutex_unlock(&pdev->v4l2_lock);
 689
 690         return r;
 691 }
 692
 693 static void stop_streaming(struct vb2_queue *vq)
 694 {
 695         struct pwc_device *pdev = vb2_get_drv_priv(vq);
 696
 697         mutex_lock(&pdev->v4l2_lock);
 698         if (pdev->udev) {
 699                 pwc_set_leds(pdev, 0, 0);
 700                 pwc_camera_power(pdev, 0);
 701                 pwc_isoc_cleanup(pdev);
 702         }
 703
 704         pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR);
 705         if (pdev->fill_buf)
 706                 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
 707                                 VB2_BUF_STATE_ERROR);
 708         mutex_unlock(&pdev->v4l2_lock);
 709 }
 710
 711 static struct vb2_ops pwc_vb_queue_ops = {
 712         .queue_setup            = queue_setup,
 713         .buf_init               = buffer_init,
 714         .buf_prepare            = buffer_prepare,
 715         .buf_finish             = buffer_finish,
 716         .buf_cleanup            = buffer_cleanup,
 717         .buf_queue              = buffer_queue,
 718         .start_streaming        = start_streaming,
 719         .stop_streaming         = stop_streaming,
 720         .wait_prepare           = vb2_ops_wait_prepare,
 721         .wait_finish            = vb2_ops_wait_finish,
 722 };
 723
 724 /***************************************************************************/
 725 /* USB functions */
 726
 727 /* This function gets called when a new device is plugged in or the usb core
 728  * is loaded.
 729  */
 730
 731 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
 732 {
 733         struct usb_device *udev = interface_to_usbdev(intf);
 734         struct pwc_device *pdev = NULL;
 735         int vendor_id, product_id, type_id;
 736         int rc;
 737         int features = 0;
 738         int compression = 0;
 739         int my_power_save = power_save;
 740         char serial_number[30], *name;
 741
 742         vendor_id = le16_to_cpu(udev->descriptor.idVendor);
 743         product_id = le16_to_cpu(udev->descriptor.idProduct);
 744
 745         /* Check if we can handle this device */
 746         PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
 747                 vendor_id, product_id,
 748                 intf->altsetting->desc.bInterfaceNumber);
 749
 750         /* the interfaces are probed one by one. We are only interested in the
 751            video interface (0) now.
 752            Interface 1 is the Audio Control, and interface 2 Audio itself.
 753          */
 754         if (intf->altsetting->desc.bInterfaceNumber > 0)
 755                 return -ENODEV;
 756
 757         if (vendor_id == 0x0471) {
 758                 switch (product_id) {
 759                 case 0x0302:
 760                         PWC_INFO("Philips PCA645VC USB webcam detected.\n");
 761                         name = "Philips 645 webcam";
 762                         type_id = 645;
 763                         break;
 764                 case 0x0303:
 765                         PWC_INFO("Philips PCA646VC USB webcam detected.\n");
 766                         name = "Philips 646 webcam";
 767                         type_id = 646;
 768                         break;
 769                 case 0x0304:
 770                         PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
 771                         name = "Askey VC010 webcam";
 772                         type_id = 646;
 773                         break;
 774                 case 0x0307:
 775                         PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
 776                         name = "Philips 675 webcam";
 777                         type_id = 675;
 778                         break;
 779                 case 0x0308:
 780                         PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
 781                         name = "Philips 680 webcam";
 782                         type_id = 680;
 783                         break;
 784                 case 0x030C:
 785                         PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
 786                         name = "Philips 690 webcam";
 787                         type_id = 690;
 788                         break;
 789                 case 0x0310:
 790                         PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
 791                         name = "Philips 730 webcam";
 792                         type_id = 730;
 793                         break;
 794                 case 0x0311:
 795                         PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
 796                         name = "Philips 740 webcam";
 797                         type_id = 740;
 798                         break;
 799                 case 0x0312:
 800                         PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
 801                         name = "Philips 750 webcam";
 802                         type_id = 750;
 803                         break;
 804                 case 0x0313:
 805                         PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
 806                         name = "Philips 720K/40 webcam";
 807                         type_id = 720;
 808                         break;
 809                 case 0x0329:
 810                         PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
 811                         name = "Philips SPC 900NC webcam";
 812                         type_id = 740;
 813                         break;
 814                 case 0x032C:
 815                         PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
 816                         name = "Philips SPC 880NC webcam";
 817                         type_id = 740;
 818                         break;
 819                 default:
 820                         return -ENODEV;
 821                         break;
 822                 }
 823         }
 824         else if (vendor_id == 0x069A) {
 825                 switch(product_id) {
 826                 case 0x0001:
 827                         PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
 828                         name = "Askey VC010 webcam";
 829                         type_id = 645;
 830                         break;
 831                 default:
 832                         return -ENODEV;
 833                         break;
 834                 }
 835         }
 836         else if (vendor_id == 0x046d) {
 837                 switch(product_id) {
 838                 case 0x08b0:
 839                         PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
 840                         name = "Logitech QuickCam Pro 3000";
 841                         type_id = 740; /* CCD sensor */
 842                         break;
 843                 case 0x08b1:
 844                         PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
 845                         name = "Logitech QuickCam Notebook Pro";
 846                         type_id = 740; /* CCD sensor */
 847                         break;
 848                 case 0x08b2:
 849                         PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
 850                         name = "Logitech QuickCam Pro 4000";
 851                         type_id = 740; /* CCD sensor */
 852                         if (my_power_save == -1)
 853                                 my_power_save = 1;
 854                         break;
 855                 case 0x08b3:
 856                         PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
 857                         name = "Logitech QuickCam Zoom";
 858                         type_id = 740; /* CCD sensor */
 859                         break;
 860                 case 0x08B4:
 861                         PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
 862                         name = "Logitech QuickCam Zoom";
 863                         type_id = 740; /* CCD sensor */
 864                         if (my_power_save == -1)
 865                                 my_power_save = 1;
 866                         break;
 867                 case 0x08b5:
 868                         PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
 869                         name = "Logitech QuickCam Orbit";
 870                         type_id = 740; /* CCD sensor */
 871                         if (my_power_save == -1)
 872                                 my_power_save = 1;
 873                         features |= FEATURE_MOTOR_PANTILT;
 874                         break;
 875                 case 0x08b6:
 876                         PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
 877                         name = "Cisco VT Camera";
 878                         type_id = 740; /* CCD sensor */
 879                         break;
 880                 case 0x08b7:
 881                         PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
 882                         name = "Logitech ViewPort AV 100";
 883                         type_id = 740; /* CCD sensor */
 884                         break;
 885                 case 0x08b8: /* Where this released? */
 886                         PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
 887                         name = "Logitech QuickCam (res.)";
 888                         type_id = 730; /* Assuming CMOS */
 889                         break;
 890                 default:
 891                         return -ENODEV;
 892                         break;
 893                 }
 894         }
 895         else if (vendor_id == 0x055d) {
 896                 /* I don't know the difference between the C10 and the C30;
 897                    I suppose the difference is the sensor, but both cameras
 898                    work equally well with a type_id of 675
 899                  */
 900                 switch(product_id) {
 901                 case 0x9000:
 902                         PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
 903                         name = "Samsung MPC-C10";
 904                         type_id = 675;
 905                         break;
 906                 case 0x9001:
 907                         PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
 908                         name = "Samsung MPC-C30";
 909                         type_id = 675;
 910                         break;
 911                 case 0x9002:
 912                         PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
 913                         name = "Samsung MPC-C30";
 914                         type_id = 740;
 915                         break;
 916                 default:
 917                         return -ENODEV;
 918                         break;
 919                 }
 920         }
 921         else if (vendor_id == 0x041e) {
 922                 switch(product_id) {
 923                 case 0x400c:
 924                         PWC_INFO("Creative Labs Webcam 5 detected.\n");
 925                         name = "Creative Labs Webcam 5";
 926                         type_id = 730;
 927                         if (my_power_save == -1)
 928                                 my_power_save = 1;
 929                         break;
 930                 case 0x4011:
 931                         PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
 932                         name = "Creative Labs Webcam Pro Ex";
 933                         type_id = 740;
 934                         break;
 935                 default:
 936                         return -ENODEV;
 937                         break;
 938                 }
 939         }
 940         else if (vendor_id == 0x04cc) {
 941                 switch(product_id) {
 942                 case 0x8116:
 943                         PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
 944                         name = "Sotec Afina Eye";
 945                         type_id = 730;
 946                         break;
 947                 default:
 948                         return -ENODEV;
 949                         break;
 950                 }
 951         }
 952         else if (vendor_id == 0x06be) {
 953                 switch(product_id) {
 954                 case 0x8116:
 955                         /* This is essentially the same cam as the Sotec Afina Eye */
 956                         PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
 957                         name = "AME Co. Afina Eye";
 958                         type_id = 750;
 959                         break;
 960                 default:
 961                         return -ENODEV;
 962                         break;
 963                 }
 964
 965         }
 966         else if (vendor_id == 0x0d81) {
 967                 switch(product_id) {
 968                 case 0x1900:
 969                         PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
 970                         name = "Visionite VCS-UC300";
 971                         type_id = 740; /* CCD sensor */
 972                         break;
 973                 case 0x1910:
 974                         PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
 975                         name = "Visionite VCS-UM100";
 976                         type_id = 730; /* CMOS sensor */
 977                         break;
 978                 default:
 979                         return -ENODEV;
 980                         break;
 981                 }
 982         }
 983         else
 984                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
 985
 986         if (my_power_save == -1)
 987                 my_power_save = 0;
 988
 989         memset(serial_number, 0, 30);
 990         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
 991         PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
 992
 993         if (udev->descriptor.bNumConfigurations > 1)
 994                 PWC_WARNING("Warning: more than 1 configuration available.\n");
 995
 996         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
 997         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
 998         if (pdev == NULL) {
 999                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1000                 return -ENOMEM;
1001         }
1002         pdev->type = type_id;
1003         pdev->features = features;
1004         pwc_construct(pdev); /* set min/max sizes correct */
1005
1006         mutex_init(&pdev->v4l2_lock);
1007         mutex_init(&pdev->vb_queue_lock);
1008         spin_lock_init(&pdev->queued_bufs_lock);
1009         INIT_LIST_HEAD(&pdev->queued_bufs);
1010
1011         pdev->udev = udev;
1012         pdev->power_save = my_power_save;
1013
1014         /* Init videobuf2 queue structure */
1015         pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1016         pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1017         pdev->vb_queue.drv_priv = pdev;
1018         pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1019         pdev->vb_queue.ops = &pwc_vb_queue_ops;
1020         pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1021         pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1022         rc = vb2_queue_init(&pdev->vb_queue);
1023         if (rc < 0) {
1024                 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1025                 goto err_free_mem;
1026         }
1027
1028         /* Init video_device structure */
1029         pdev->vdev = pwc_template;
1030         strcpy(pdev->vdev.name, name);
1031         pdev->vdev.queue = &pdev->vb_queue;
1032         pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1033         video_set_drvdata(&pdev->vdev, pdev);
1034
1035         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1036         PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1037
1038         /* Allocate USB command buffers */
1039         pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1040         if (!pdev->ctrl_buf) {
1041                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1042                 rc = -ENOMEM;
1043                 goto err_free_mem;
1044         }
1045
1046 #ifdef CONFIG_USB_PWC_DEBUG
1047         /* Query sensor type */
1048         if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1049                 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1050                                 pdev->vdev.name,
1051                                 pwc_sensor_type_to_string(rc), rc);
1052         }
1053 #endif
1054
1055         /* Set the leds off */
1056         pwc_set_leds(pdev, 0, 0);
1057
1058         /* Setup initial videomode */
1059         rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1060                                 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1061         if (rc)
1062                 goto err_free_mem;
1063
1064         /* Register controls (and read default values from camera */
1065         rc = pwc_init_controls(pdev);
1066         if (rc) {
1067                 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1068                 goto err_free_mem;
1069         }
1070
1071         /* And powerdown the camera until streaming starts */
1072         pwc_camera_power(pdev, 0);
1073
1074         /* Register the v4l2_device structure */
1075         pdev->v4l2_dev.release = pwc_video_release;
1076         rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1077         if (rc) {
1078                 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1079                 goto err_free_controls;
1080         }
1081
1082         pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1083         pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1084         pdev->vdev.lock = &pdev->v4l2_lock;
1085
1086         rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1087         if (rc < 0) {
1088                 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1089                 goto err_unregister_v4l2_dev;
1090         }
1091         PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1092
1093 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1094         /* register webcam snapshot button input device */
1095         pdev->button_dev = input_allocate_device();
1096         if (!pdev->button_dev) {
1097                 rc = -ENOMEM;
1098                 goto err_video_unreg;
1099         }
1100
1101         usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1102         strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1103
1104         pdev->button_dev->name = "PWC snapshot button";
1105         pdev->button_dev->phys = pdev->button_phys;
1106         usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1107         pdev->button_dev->dev.parent = &pdev->udev->dev;
1108         pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1109         pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1110
1111         rc = input_register_device(pdev->button_dev);
1112         if (rc) {
1113                 input_free_device(pdev->button_dev);
1114                 pdev->button_dev = NULL;
1115                 goto err_video_unreg;
1116         }
1117 #endif
1118
1119         return 0;
1120
1121 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1122 err_video_unreg:
1123         video_unregister_device(&pdev->vdev);
1124 #endif
1125 err_unregister_v4l2_dev:
1126         v4l2_device_unregister(&pdev->v4l2_dev);
1127 err_free_controls:
1128         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1129 err_free_mem:
1130         kfree(pdev->ctrl_buf);
1131         kfree(pdev);
1132         return rc;
1133 }
1134
1135 /* The user yanked out the cable... */
1136 static void usb_pwc_disconnect(struct usb_interface *intf)
1137 {
1138         struct v4l2_device *v = usb_get_intfdata(intf);
1139         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1140
1141         mutex_lock(&pdev->vb_queue_lock);
1142         mutex_lock(&pdev->v4l2_lock);
1143         /* No need to keep the urbs around after disconnection */
1144         if (pdev->vb_queue.streaming)
1145                 pwc_isoc_cleanup(pdev);
1146         pdev->udev = NULL;
1147
1148         v4l2_device_disconnect(&pdev->v4l2_dev);
1149         video_unregister_device(&pdev->vdev);
1150         mutex_unlock(&pdev->v4l2_lock);
1151         mutex_unlock(&pdev->vb_queue_lock);
1152
1153 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1154         if (pdev->button_dev)
1155                 input_unregister_device(pdev->button_dev);
1156 #endif
1157
1158         v4l2_device_put(&pdev->v4l2_dev);
1159 }
1160
1161
1162 /*
1163  * Initialization code & module stuff
1164  */
1165
1166 static unsigned int leds_nargs;
1167
1168 #ifdef CONFIG_USB_PWC_DEBUG
1169 module_param_named(trace, pwc_trace, int, 0644);
1170 #endif
1171 module_param(power_save, int, 0644);
1172 module_param_array(leds, int, &leds_nargs, 0444);
1173
1174 #ifdef CONFIG_USB_PWC_DEBUG
1175 MODULE_PARM_DESC(trace, "For debugging purposes");
1176 #endif
1177 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1178 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1179
1180 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1181 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1182 MODULE_LICENSE("GPL");
1183 MODULE_ALIAS("pwcx");
1184 MODULE_VERSION( PWC_VERSION );
1185
1186 module_usb_driver(pwc_driver);