kernel/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                                 v4l2_get_timestamp(
 321                                         &fbuf->vb.timestamp);
 322                                 pdev->vsync = 2;
 323                         }
 324
 325                         if (flen + fbuf->filled > pdev->frame_total_size) {
 326                                 PWC_ERROR("Frame overflow (%d > %d)\n",
 327                                           flen + fbuf->filled,
 328                                           pdev->frame_total_size);
 329                                 pdev->vsync = 0; /* Let's wait for an EOF */
 330                         } else {
 331                                 memcpy(fbuf->data + fbuf->filled, iso_buf,
 332                                        flen);
 333                                 fbuf->filled += flen;
 334                         }
 335                 }
 336                 if (flen < pdev->vlast_packet_size) {
 337                         /* Shorter packet... end of frame */
 338                         if (pdev->vsync == 2)
 339                                 pwc_frame_complete(pdev);
 340                         if (pdev->fill_buf == NULL)
 341                                 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
 342                         if (pdev->fill_buf) {
 343                                 pdev->fill_buf->filled = 0;
 344                                 pdev->vsync = 1;
 345                         }
 346                 }
 347                 pdev->vlast_packet_size = flen;
 348         }
 349
 350 handler_end:
 351         i = usb_submit_urb(urb, GFP_ATOMIC);
 352         if (i != 0)
 353                 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
 354 }
 355
 356 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
 357 static int pwc_isoc_init(struct pwc_device *pdev)
 358 {
 359         struct usb_device *udev;
 360         struct urb *urb;
 361         int i, j, ret;
 362         struct usb_interface *intf;
 363         struct usb_host_interface *idesc = NULL;
 364         int compression = 0; /* 0..3 = uncompressed..high */
 365
 366         pdev->vsync = 0;
 367         pdev->vlast_packet_size = 0;
 368         pdev->fill_buf = NULL;
 369         pdev->vframe_count = 0;
 370         pdev->visoc_errors = 0;
 371         udev = pdev->udev;
 372
 373 retry:
 374         /* We first try with low compression and then retry with a higher
 375            compression setting if there is not enough bandwidth. */
 376         ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
 377                                  pdev->vframes, &compression, 1);
 378
 379         /* Get the current alternate interface, adjust packet size */
 380         intf = usb_ifnum_to_if(udev, 0);
 381         if (intf)
 382                 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
 383         if (!idesc)
 384                 return -EIO;
 385
 386         /* Search video endpoint */
 387         pdev->vmax_packet_size = -1;
 388         for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
 389                 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
 390                         pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
 391                         break;
 392                 }
 393         }
 394
 395         if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
 396                 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
 397                 return -ENFILE; /* Odd error, that should be noticeable */
 398         }
 399
 400         /* Set alternate interface */
 401         PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
 402         ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
 403         if (ret == -ENOSPC && compression < 3) {
 404                 compression++;
 405                 goto retry;
 406         }
 407         if (ret < 0)
 408                 return ret;
 409
 410         /* Allocate and init Isochronuous urbs */
 411         for (i = 0; i < MAX_ISO_BUFS; i++) {
 412                 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
 413                 if (urb == NULL) {
 414                         PWC_ERROR("Failed to allocate urb %d\n", i);
 415                         pwc_isoc_cleanup(pdev);
 416                         return -ENOMEM;
 417                 }
 418                 pdev->urbs[i] = urb;
 419                 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
 420
 421                 urb->interval = 1; // devik
 422                 urb->dev = udev;
 423                 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
 424                 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
 425                 urb->transfer_buffer = usb_alloc_coherent(udev,
 426                                                           ISO_BUFFER_SIZE,
 427                                                           GFP_KERNEL,
 428                                                           &urb->transfer_dma);
 429                 if (urb->transfer_buffer == NULL) {
 430                         PWC_ERROR("Failed to allocate urb buffer %d\n", i);
 431                         pwc_isoc_cleanup(pdev);
 432                         return -ENOMEM;
 433                 }
 434                 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
 435                 urb->complete = pwc_isoc_handler;
 436                 urb->context = pdev;
 437                 urb->start_frame = 0;
 438                 urb->number_of_packets = ISO_FRAMES_PER_DESC;
 439                 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
 440                         urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
 441                         urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
 442                 }
 443         }
 444
 445         /* link */
 446         for (i = 0; i < MAX_ISO_BUFS; i++) {
 447                 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
 448                 if (ret == -ENOSPC && compression < 3) {
 449                         compression++;
 450                         pwc_isoc_cleanup(pdev);
 451                         goto retry;
 452                 }
 453                 if (ret) {
 454                         PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
 455                         pwc_isoc_cleanup(pdev);
 456                         return ret;
 457                 }
 458                 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
 459         }
 460
 461         /* All is done... */
 462         PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
 463         return 0;
 464 }
 465
 466 static void pwc_iso_stop(struct pwc_device *pdev)
 467 {
 468         int i;
 469
 470         /* Unlinking ISOC buffers one by one */
 471         for (i = 0; i < MAX_ISO_BUFS; i++) {
 472                 if (pdev->urbs[i]) {
 473                         PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
 474                         usb_kill_urb(pdev->urbs[i]);
 475                 }
 476         }
 477 }
 478
 479 static void pwc_iso_free(struct pwc_device *pdev)
 480 {
 481         int i;
 482
 483         /* Freeing ISOC buffers one by one */
 484         for (i = 0; i < MAX_ISO_BUFS; i++) {
 485                 if (pdev->urbs[i]) {
 486                         PWC_DEBUG_MEMORY("Freeing URB\n");
 487                         if (pdev->urbs[i]->transfer_buffer) {
 488                                 usb_free_coherent(pdev->udev,
 489                                         pdev->urbs[i]->transfer_buffer_length,
 490                                         pdev->urbs[i]->transfer_buffer,
 491                                         pdev->urbs[i]->transfer_dma);
 492                         }
 493                         usb_free_urb(pdev->urbs[i]);
 494                         pdev->urbs[i] = NULL;
 495                 }
 496         }
 497 }
 498
 499 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
 500 static void pwc_isoc_cleanup(struct pwc_device *pdev)
 501 {
 502         PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
 503
 504         pwc_iso_stop(pdev);
 505         pwc_iso_free(pdev);
 506         usb_set_interface(pdev->udev, 0, 0);
 507
 508         PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
 509 }
 510
 511 /* Must be called with vb_queue_lock hold */
 512 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev,
 513                                     enum vb2_buffer_state state)
 514 {
 515         unsigned long flags = 0;
 516
 517         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
 518         while (!list_empty(&pdev->queued_bufs)) {
 519                 struct pwc_frame_buf *buf;
 520
 521                 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
 522                                  list);
 523                 list_del(&buf->list);
 524                 vb2_buffer_done(&buf->vb.vb2_buf, state);
 525         }
 526         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
 527 }
 528
 529 #ifdef CONFIG_USB_PWC_DEBUG
 530 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
 531 {
 532         switch(sensor_type) {
 533                 case 0x00:
 534                         return "Hyundai CMOS sensor";
 535                 case 0x20:
 536                         return "Sony CCD sensor + TDA8787";
 537                 case 0x2E:
 538                         return "Sony CCD sensor + Exas 98L59";
 539                 case 0x2F:
 540                         return "Sony CCD sensor + ADI 9804";
 541                 case 0x30:
 542                         return "Sharp CCD sensor + TDA8787";
 543                 case 0x3E:
 544                         return "Sharp CCD sensor + Exas 98L59";
 545                 case 0x3F:
 546                         return "Sharp CCD sensor + ADI 9804";
 547                 case 0x40:
 548                         return "UPA 1021 sensor";
 549                 case 0x100:
 550                         return "VGA sensor";
 551                 case 0x101:
 552                         return "PAL MR sensor";
 553                 default:
 554                         return "unknown type of sensor";
 555         }
 556 }
 557 #endif
 558
 559 /***************************************************************************/
 560 /* Video4Linux functions */
 561
 562 static void pwc_video_release(struct v4l2_device *v)
 563 {
 564         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
 565
 566         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
 567         v4l2_device_unregister(&pdev->v4l2_dev);
 568         kfree(pdev->ctrl_buf);
 569         kfree(pdev);
 570 }
 571
 572 /***************************************************************************/
 573 /* Videobuf2 operations */
 574
 575 static int queue_setup(struct vb2_queue *vq, const void *parg,
 576                                 unsigned int *nbuffers, unsigned int *nplanes,
 577                                 unsigned int sizes[], void *alloc_ctxs[])
 578 {
 579         struct pwc_device *pdev = vb2_get_drv_priv(vq);
 580         int size;
 581
 582         if (*nbuffers < MIN_FRAMES)
 583                 *nbuffers = MIN_FRAMES;
 584         else if (*nbuffers > MAX_FRAMES)
 585                 *nbuffers = MAX_FRAMES;
 586
 587         *nplanes = 1;
 588
 589         size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
 590         sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
 591                               pwc_image_sizes[size][1] * 3 / 2);
 592
 593         return 0;
 594 }
 595
 596 static int buffer_init(struct vb2_buffer *vb)
 597 {
 598         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 599         struct pwc_frame_buf *buf =
 600                 container_of(vbuf, struct pwc_frame_buf, vb);
 601
 602         /* need vmalloc since frame buffer > 128K */
 603         buf->data = vzalloc(PWC_FRAME_SIZE);
 604         if (buf->data == NULL)
 605                 return -ENOMEM;
 606
 607         return 0;
 608 }
 609
 610 static int buffer_prepare(struct vb2_buffer *vb)
 611 {
 612         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
 613
 614         /* Don't allow queing new buffers after device disconnection */
 615         if (!pdev->udev)
 616                 return -ENODEV;
 617
 618         return 0;
 619 }
 620
 621 static void buffer_finish(struct vb2_buffer *vb)
 622 {
 623         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
 624         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 625         struct pwc_frame_buf *buf =
 626                 container_of(vbuf, struct pwc_frame_buf, vb);
 627
 628         if (vb->state == VB2_BUF_STATE_DONE) {
 629                 /*
 630                  * Application has called dqbuf and is getting back a buffer
 631                  * we've filled, take the pwc data we've stored in buf->data
 632                  * and decompress it into a usable format, storing the result
 633                  * in the vb2_buffer.
 634                  */
 635                 pwc_decompress(pdev, buf);
 636         }
 637 }
 638
 639 static void buffer_cleanup(struct vb2_buffer *vb)
 640 {
 641         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 642         struct pwc_frame_buf *buf =
 643                 container_of(vbuf, struct pwc_frame_buf, vb);
 644
 645         vfree(buf->data);
 646 }
 647
 648 static void buffer_queue(struct vb2_buffer *vb)
 649 {
 650         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
 651         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 652         struct pwc_frame_buf *buf =
 653                 container_of(vbuf, struct pwc_frame_buf, vb);
 654         unsigned long flags = 0;
 655
 656         /* Check the device has not disconnected between prep and queuing */
 657         if (!pdev->udev) {
 658                 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
 659                 return;
 660         }
 661
 662         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
 663         list_add_tail(&buf->list, &pdev->queued_bufs);
 664         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
 665 }
 666
 667 static int start_streaming(struct vb2_queue *vq, unsigned int count)
 668 {
 669         struct pwc_device *pdev = vb2_get_drv_priv(vq);
 670         int r;
 671
 672         if (!pdev->udev)
 673                 return -ENODEV;
 674
 675         if (mutex_lock_interruptible(&pdev->v4l2_lock))
 676                 return -ERESTARTSYS;
 677         /* Turn on camera and set LEDS on */
 678         pwc_camera_power(pdev, 1);
 679         pwc_set_leds(pdev, leds[0], leds[1]);
 680
 681         r = pwc_isoc_init(pdev);
 682         if (r) {
 683                 /* If we failed turn camera and LEDS back off */
 684                 pwc_set_leds(pdev, 0, 0);
 685                 pwc_camera_power(pdev, 0);
 686                 /* And cleanup any queued bufs!! */
 687                 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED);
 688         }
 689         mutex_unlock(&pdev->v4l2_lock);
 690
 691         return r;
 692 }
 693
 694 static void stop_streaming(struct vb2_queue *vq)
 695 {
 696         struct pwc_device *pdev = vb2_get_drv_priv(vq);
 697
 698         mutex_lock(&pdev->v4l2_lock);
 699         if (pdev->udev) {
 700                 pwc_set_leds(pdev, 0, 0);
 701                 pwc_camera_power(pdev, 0);
 702                 pwc_isoc_cleanup(pdev);
 703         }
 704
 705         pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR);
 706         if (pdev->fill_buf)
 707                 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
 708                                 VB2_BUF_STATE_ERROR);
 709         mutex_unlock(&pdev->v4l2_lock);
 710 }
 711
 712 static struct vb2_ops pwc_vb_queue_ops = {
 713         .queue_setup            = queue_setup,
 714         .buf_init               = buffer_init,
 715         .buf_prepare            = buffer_prepare,
 716         .buf_finish             = buffer_finish,
 717         .buf_cleanup            = buffer_cleanup,
 718         .buf_queue              = buffer_queue,
 719         .start_streaming        = start_streaming,
 720         .stop_streaming         = stop_streaming,
 721         .wait_prepare           = vb2_ops_wait_prepare,
 722         .wait_finish            = vb2_ops_wait_finish,
 723 };
 724
 725 /***************************************************************************/
 726 /* USB functions */
 727
 728 /* This function gets called when a new device is plugged in or the usb core
 729  * is loaded.
 730  */
 731
 732 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
 733 {
 734         struct usb_device *udev = interface_to_usbdev(intf);
 735         struct pwc_device *pdev = NULL;
 736         int vendor_id, product_id, type_id;
 737         int rc;
 738         int features = 0;
 739         int compression = 0;
 740         int my_power_save = power_save;
 741         char serial_number[30], *name;
 742
 743         vendor_id = le16_to_cpu(udev->descriptor.idVendor);
 744         product_id = le16_to_cpu(udev->descriptor.idProduct);
 745
 746         /* Check if we can handle this device */
 747         PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
 748                 vendor_id, product_id,
 749                 intf->altsetting->desc.bInterfaceNumber);
 750
 751         /* the interfaces are probed one by one. We are only interested in the
 752            video interface (0) now.
 753            Interface 1 is the Audio Control, and interface 2 Audio itself.
 754          */
 755         if (intf->altsetting->desc.bInterfaceNumber > 0)
 756                 return -ENODEV;
 757
 758         if (vendor_id == 0x0471) {
 759                 switch (product_id) {
 760                 case 0x0302:
 761                         PWC_INFO("Philips PCA645VC USB webcam detected.\n");
 762                         name = "Philips 645 webcam";
 763                         type_id = 645;
 764                         break;
 765                 case 0x0303:
 766                         PWC_INFO("Philips PCA646VC USB webcam detected.\n");
 767                         name = "Philips 646 webcam";
 768                         type_id = 646;
 769                         break;
 770                 case 0x0304:
 771                         PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
 772                         name = "Askey VC010 webcam";
 773                         type_id = 646;
 774                         break;
 775                 case 0x0307:
 776                         PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
 777                         name = "Philips 675 webcam";
 778                         type_id = 675;
 779                         break;
 780                 case 0x0308:
 781                         PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
 782                         name = "Philips 680 webcam";
 783                         type_id = 680;
 784                         break;
 785                 case 0x030C:
 786                         PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
 787                         name = "Philips 690 webcam";
 788                         type_id = 690;
 789                         break;
 790                 case 0x0310:
 791                         PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
 792                         name = "Philips 730 webcam";
 793                         type_id = 730;
 794                         break;
 795                 case 0x0311:
 796                         PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
 797                         name = "Philips 740 webcam";
 798                         type_id = 740;
 799                         break;
 800                 case 0x0312:
 801                         PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
 802                         name = "Philips 750 webcam";
 803                         type_id = 750;
 804                         break;
 805                 case 0x0313:
 806                         PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
 807                         name = "Philips 720K/40 webcam";
 808                         type_id = 720;
 809                         break;
 810                 case 0x0329:
 811                         PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
 812                         name = "Philips SPC 900NC webcam";
 813                         type_id = 740;
 814                         break;
 815                 case 0x032C:
 816                         PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
 817                         name = "Philips SPC 880NC webcam";
 818                         type_id = 740;
 819                         break;
 820                 default:
 821                         return -ENODEV;
 822                         break;
 823                 }
 824         }
 825         else if (vendor_id == 0x069A) {
 826                 switch(product_id) {
 827                 case 0x0001:
 828                         PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
 829                         name = "Askey VC010 webcam";
 830                         type_id = 645;
 831                         break;
 832                 default:
 833                         return -ENODEV;
 834                         break;
 835                 }
 836         }
 837         else if (vendor_id == 0x046d) {
 838                 switch(product_id) {
 839                 case 0x08b0:
 840                         PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
 841                         name = "Logitech QuickCam Pro 3000";
 842                         type_id = 740; /* CCD sensor */
 843                         break;
 844                 case 0x08b1:
 845                         PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
 846                         name = "Logitech QuickCam Notebook Pro";
 847                         type_id = 740; /* CCD sensor */
 848                         break;
 849                 case 0x08b2:
 850                         PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
 851                         name = "Logitech QuickCam Pro 4000";
 852                         type_id = 740; /* CCD sensor */
 853                         if (my_power_save == -1)
 854                                 my_power_save = 1;
 855                         break;
 856                 case 0x08b3:
 857                         PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
 858                         name = "Logitech QuickCam Zoom";
 859                         type_id = 740; /* CCD sensor */
 860                         break;
 861                 case 0x08B4:
 862                         PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
 863                         name = "Logitech QuickCam Zoom";
 864                         type_id = 740; /* CCD sensor */
 865                         if (my_power_save == -1)
 866                                 my_power_save = 1;
 867                         break;
 868                 case 0x08b5:
 869                         PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
 870                         name = "Logitech QuickCam Orbit";
 871                         type_id = 740; /* CCD sensor */
 872                         if (my_power_save == -1)
 873                                 my_power_save = 1;
 874                         features |= FEATURE_MOTOR_PANTILT;
 875                         break;
 876                 case 0x08b6:
 877                         PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
 878                         name = "Cisco VT Camera";
 879                         type_id = 740; /* CCD sensor */
 880                         break;
 881                 case 0x08b7:
 882                         PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
 883                         name = "Logitech ViewPort AV 100";
 884                         type_id = 740; /* CCD sensor */
 885                         break;
 886                 case 0x08b8: /* Where this released? */
 887                         PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
 888                         name = "Logitech QuickCam (res.)";
 889                         type_id = 730; /* Assuming CMOS */
 890                         break;
 891                 default:
 892                         return -ENODEV;
 893                         break;
 894                 }
 895         }
 896         else if (vendor_id == 0x055d) {
 897                 /* I don't know the difference between the C10 and the C30;
 898                    I suppose the difference is the sensor, but both cameras
 899                    work equally well with a type_id of 675
 900                  */
 901                 switch(product_id) {
 902                 case 0x9000:
 903                         PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
 904                         name = "Samsung MPC-C10";
 905                         type_id = 675;
 906                         break;
 907                 case 0x9001:
 908                         PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
 909                         name = "Samsung MPC-C30";
 910                         type_id = 675;
 911                         break;
 912                 case 0x9002:
 913                         PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
 914                         name = "Samsung MPC-C30";
 915                         type_id = 740;
 916                         break;
 917                 default:
 918                         return -ENODEV;
 919                         break;
 920                 }
 921         }
 922         else if (vendor_id == 0x041e) {
 923                 switch(product_id) {
 924                 case 0x400c:
 925                         PWC_INFO("Creative Labs Webcam 5 detected.\n");
 926                         name = "Creative Labs Webcam 5";
 927                         type_id = 730;
 928                         if (my_power_save == -1)
 929                                 my_power_save = 1;
 930                         break;
 931                 case 0x4011:
 932                         PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
 933                         name = "Creative Labs Webcam Pro Ex";
 934                         type_id = 740;
 935                         break;
 936                 default:
 937                         return -ENODEV;
 938                         break;
 939                 }
 940         }
 941         else if (vendor_id == 0x04cc) {
 942                 switch(product_id) {
 943                 case 0x8116:
 944                         PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
 945                         name = "Sotec Afina Eye";
 946                         type_id = 730;
 947                         break;
 948                 default:
 949                         return -ENODEV;
 950                         break;
 951                 }
 952         }
 953         else if (vendor_id == 0x06be) {
 954                 switch(product_id) {
 955                 case 0x8116:
 956                         /* This is essentially the same cam as the Sotec Afina Eye */
 957                         PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
 958                         name = "AME Co. Afina Eye";
 959                         type_id = 750;
 960                         break;
 961                 default:
 962                         return -ENODEV;
 963                         break;
 964                 }
 965
 966         }
 967         else if (vendor_id == 0x0d81) {
 968                 switch(product_id) {
 969                 case 0x1900:
 970                         PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
 971                         name = "Visionite VCS-UC300";
 972                         type_id = 740; /* CCD sensor */
 973                         break;
 974                 case 0x1910:
 975                         PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
 976                         name = "Visionite VCS-UM100";
 977                         type_id = 730; /* CMOS sensor */
 978                         break;
 979                 default:
 980                         return -ENODEV;
 981                         break;
 982                 }
 983         }
 984         else
 985                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
 986
 987         if (my_power_save == -1)
 988                 my_power_save = 0;
 989
 990         memset(serial_number, 0, 30);
 991         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
 992         PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
 993
 994         if (udev->descriptor.bNumConfigurations > 1)
 995                 PWC_WARNING("Warning: more than 1 configuration available.\n");
 996
 997         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
 998         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
 999         if (pdev == NULL) {
1000                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1001                 return -ENOMEM;
1002         }
1003         pdev->type = type_id;
1004         pdev->features = features;
1005         pwc_construct(pdev); /* set min/max sizes correct */
1006
1007         mutex_init(&pdev->v4l2_lock);
1008         mutex_init(&pdev->vb_queue_lock);
1009         spin_lock_init(&pdev->queued_bufs_lock);
1010         INIT_LIST_HEAD(&pdev->queued_bufs);
1011
1012         pdev->udev = udev;
1013         pdev->power_save = my_power_save;
1014
1015         /* Init videobuf2 queue structure */
1016         pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1017         pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1018         pdev->vb_queue.drv_priv = pdev;
1019         pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1020         pdev->vb_queue.ops = &pwc_vb_queue_ops;
1021         pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1022         pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1023         rc = vb2_queue_init(&pdev->vb_queue);
1024         if (rc < 0) {
1025                 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1026                 goto err_free_mem;
1027         }
1028
1029         /* Init video_device structure */
1030         pdev->vdev = pwc_template;
1031         strcpy(pdev->vdev.name, name);
1032         pdev->vdev.queue = &pdev->vb_queue;
1033         pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1034         video_set_drvdata(&pdev->vdev, pdev);
1035
1036         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1037         PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1038
1039         /* Allocate USB command buffers */
1040         pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1041         if (!pdev->ctrl_buf) {
1042                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1043                 rc = -ENOMEM;
1044                 goto err_free_mem;
1045         }
1046
1047 #ifdef CONFIG_USB_PWC_DEBUG
1048         /* Query sensor type */
1049         if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1050                 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1051                                 pdev->vdev.name,
1052                                 pwc_sensor_type_to_string(rc), rc);
1053         }
1054 #endif
1055
1056         /* Set the leds off */
1057         pwc_set_leds(pdev, 0, 0);
1058
1059         /* Setup initial videomode */
1060         rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1061                                 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1062         if (rc)
1063                 goto err_free_mem;
1064
1065         /* Register controls (and read default values from camera */
1066         rc = pwc_init_controls(pdev);
1067         if (rc) {
1068                 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1069                 goto err_free_mem;
1070         }
1071
1072         /* And powerdown the camera until streaming starts */
1073         pwc_camera_power(pdev, 0);
1074
1075         /* Register the v4l2_device structure */
1076         pdev->v4l2_dev.release = pwc_video_release;
1077         rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1078         if (rc) {
1079                 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1080                 goto err_free_controls;
1081         }
1082
1083         pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1084         pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1085         pdev->vdev.lock = &pdev->v4l2_lock;
1086
1087         rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1088         if (rc < 0) {
1089                 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1090                 goto err_unregister_v4l2_dev;
1091         }
1092         PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1093
1094 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1095         /* register webcam snapshot button input device */
1096         pdev->button_dev = input_allocate_device();
1097         if (!pdev->button_dev) {
1098                 rc = -ENOMEM;
1099                 goto err_video_unreg;
1100         }
1101
1102         usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1103         strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1104
1105         pdev->button_dev->name = "PWC snapshot button";
1106         pdev->button_dev->phys = pdev->button_phys;
1107         usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1108         pdev->button_dev->dev.parent = &pdev->udev->dev;
1109         pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1110         pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1111
1112         rc = input_register_device(pdev->button_dev);
1113         if (rc) {
1114                 input_free_device(pdev->button_dev);
1115                 pdev->button_dev = NULL;
1116                 goto err_video_unreg;
1117         }
1118 #endif
1119
1120         return 0;
1121
1122 err_video_unreg:
1123         video_unregister_device(&pdev->vdev);
1124 err_unregister_v4l2_dev:
1125         v4l2_device_unregister(&pdev->v4l2_dev);
1126 err_free_controls:
1127         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1128 err_free_mem:
1129         kfree(pdev->ctrl_buf);
1130         kfree(pdev);
1131         return rc;
1132 }
1133
1134 /* The user yanked out the cable... */
1135 static void usb_pwc_disconnect(struct usb_interface *intf)
1136 {
1137         struct v4l2_device *v = usb_get_intfdata(intf);
1138         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1139
1140         mutex_lock(&pdev->vb_queue_lock);
1141         mutex_lock(&pdev->v4l2_lock);
1142         /* No need to keep the urbs around after disconnection */
1143         if (pdev->vb_queue.streaming)
1144                 pwc_isoc_cleanup(pdev);
1145         pdev->udev = NULL;
1146
1147         v4l2_device_disconnect(&pdev->v4l2_dev);
1148         video_unregister_device(&pdev->vdev);
1149         mutex_unlock(&pdev->v4l2_lock);
1150         mutex_unlock(&pdev->vb_queue_lock);
1151
1152 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1153         if (pdev->button_dev)
1154                 input_unregister_device(pdev->button_dev);
1155 #endif
1156
1157         v4l2_device_put(&pdev->v4l2_dev);
1158 }
1159
1160
1161 /*
1162  * Initialization code & module stuff
1163  */
1164
1165 static unsigned int leds_nargs;
1166
1167 #ifdef CONFIG_USB_PWC_DEBUG
1168 module_param_named(trace, pwc_trace, int, 0644);
1169 #endif
1170 module_param(power_save, int, 0644);
1171 module_param_array(leds, int, &leds_nargs, 0444);
1172
1173 #ifdef CONFIG_USB_PWC_DEBUG
1174 MODULE_PARM_DESC(trace, "For debugging purposes");
1175 #endif
1176 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1177 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1178
1179 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1180 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1181 MODULE_LICENSE("GPL");
1182 MODULE_ALIAS("pwcx");
1183 MODULE_VERSION( PWC_VERSION );
1184
1185 module_usb_driver(pwc_driver);