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

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