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