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 ([email protected])
   6    (C) 2011 Hans de Goede <[email protected]>
   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 <[email protected]>.
  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 };
 764
 765 /***************************************************************************/
 766 /* USB functions */
 767
 768 /* This function gets called when a new device is plugged in or the usb core
 769  * is loaded.
 770  */
 771
 772 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
 773 {
 774         struct usb_device *udev = interface_to_usbdev(intf);
 775         struct pwc_device *pdev = NULL;
 776         int vendor_id, product_id, type_id;
 777         int rc;
 778         int features = 0;
 779         int compression = 0;
 780         int my_power_save = power_save;
 781         char serial_number[30], *name;
 782
 783         vendor_id = le16_to_cpu(udev->descriptor.idVendor);
 784         product_id = le16_to_cpu(udev->descriptor.idProduct);
 785
 786         /* Check if we can handle this device */
 787         PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
 788                 vendor_id, product_id,
 789                 intf->altsetting->desc.bInterfaceNumber);
 790
 791         /* the interfaces are probed one by one. We are only interested in the
 792            video interface (0) now.
 793            Interface 1 is the Audio Control, and interface 2 Audio itself.
 794          */
 795         if (intf->altsetting->desc.bInterfaceNumber > 0)
 796                 return -ENODEV;
 797
 798         if (vendor_id == 0x0471) {
 799                 switch (product_id) {
 800                 case 0x0302:
 801                         PWC_INFO("Philips PCA645VC USB webcam detected.\n");
 802                         name = "Philips 645 webcam";
 803                         type_id = 645;
 804                         break;
 805                 case 0x0303:
 806                         PWC_INFO("Philips PCA646VC USB webcam detected.\n");
 807                         name = "Philips 646 webcam";
 808                         type_id = 646;
 809                         break;
 810                 case 0x0304:
 811                         PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
 812                         name = "Askey VC010 webcam";
 813                         type_id = 646;
 814                         break;
 815                 case 0x0307:
 816                         PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
 817                         name = "Philips 675 webcam";
 818                         type_id = 675;
 819                         break;
 820                 case 0x0308:
 821                         PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
 822                         name = "Philips 680 webcam";
 823                         type_id = 680;
 824                         break;
 825                 case 0x030C:
 826                         PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
 827                         name = "Philips 690 webcam";
 828                         type_id = 690;
 829                         break;
 830                 case 0x0310:
 831                         PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
 832                         name = "Philips 730 webcam";
 833                         type_id = 730;
 834                         break;
 835                 case 0x0311:
 836                         PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
 837                         name = "Philips 740 webcam";
 838                         type_id = 740;
 839                         break;
 840                 case 0x0312:
 841                         PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
 842                         name = "Philips 750 webcam";
 843                         type_id = 750;
 844                         break;
 845                 case 0x0313:
 846                         PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
 847                         name = "Philips 720K/40 webcam";
 848                         type_id = 720;
 849                         break;
 850                 case 0x0329:
 851                         PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
 852                         name = "Philips SPC 900NC webcam";
 853                         type_id = 740;
 854                         break;
 855                 case 0x032C:
 856                         PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
 857                         name = "Philips SPC 880NC webcam";
 858                         type_id = 740;
 859                         break;
 860                 default:
 861                         return -ENODEV;
 862                 }
 863         }
 864         else if (vendor_id == 0x069A) {
 865                 switch(product_id) {
 866                 case 0x0001:
 867                         PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
 868                         name = "Askey VC010 webcam";
 869                         type_id = 645;
 870                         break;
 871                 default:
 872                         return -ENODEV;
 873                 }
 874         }
 875         else if (vendor_id == 0x046d) {
 876                 switch(product_id) {
 877                 case 0x08b0:
 878                         PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
 879                         name = "Logitech QuickCam Pro 3000";
 880                         type_id = 740; /* CCD sensor */
 881                         break;
 882                 case 0x08b1:
 883                         PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
 884                         name = "Logitech QuickCam Notebook Pro";
 885                         type_id = 740; /* CCD sensor */
 886                         break;
 887                 case 0x08b2:
 888                         PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
 889                         name = "Logitech QuickCam Pro 4000";
 890                         type_id = 740; /* CCD sensor */
 891                         if (my_power_save == -1)
 892                                 my_power_save = 1;
 893                         break;
 894                 case 0x08b3:
 895                         PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
 896                         name = "Logitech QuickCam Zoom";
 897                         type_id = 740; /* CCD sensor */
 898                         break;
 899                 case 0x08B4:
 900                         PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
 901                         name = "Logitech QuickCam Zoom";
 902                         type_id = 740; /* CCD sensor */
 903                         if (my_power_save == -1)
 904                                 my_power_save = 1;
 905                         break;
 906                 case 0x08b5:
 907                         PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
 908                         name = "Logitech QuickCam Orbit";
 909                         type_id = 740; /* CCD sensor */
 910                         if (my_power_save == -1)
 911                                 my_power_save = 1;
 912                         features |= FEATURE_MOTOR_PANTILT;
 913                         break;
 914                 case 0x08b6:
 915                         PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
 916                         name = "Cisco VT Camera";
 917                         type_id = 740; /* CCD sensor */
 918                         break;
 919                 case 0x08b7:
 920                         PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
 921                         name = "Logitech ViewPort AV 100";
 922                         type_id = 740; /* CCD sensor */
 923                         break;
 924                 case 0x08b8: /* Where this released? */
 925                         PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
 926                         name = "Logitech QuickCam (res.)";
 927                         type_id = 730; /* Assuming CMOS */
 928                         break;
 929                 default:
 930                         return -ENODEV;
 931                 }
 932         }
 933         else if (vendor_id == 0x055d) {
 934                 /* I don't know the difference between the C10 and the C30;
 935                    I suppose the difference is the sensor, but both cameras
 936                    work equally well with a type_id of 675
 937                  */
 938                 switch(product_id) {
 939                 case 0x9000:
 940                         PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
 941                         name = "Samsung MPC-C10";
 942                         type_id = 675;
 943                         break;
 944                 case 0x9001:
 945                         PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
 946                         name = "Samsung MPC-C30";
 947                         type_id = 675;
 948                         break;
 949                 case 0x9002:
 950                         PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
 951                         name = "Samsung MPC-C30";
 952                         type_id = 740;
 953                         break;
 954                 default:
 955                         return -ENODEV;
 956                 }
 957         }
 958         else if (vendor_id == 0x041e) {
 959                 switch(product_id) {
 960                 case 0x400c:
 961                         PWC_INFO("Creative Labs Webcam 5 detected.\n");
 962                         name = "Creative Labs Webcam 5";
 963                         type_id = 730;
 964                         if (my_power_save == -1)
 965                                 my_power_save = 1;
 966                         break;
 967                 case 0x4011:
 968                         PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
 969                         name = "Creative Labs Webcam Pro Ex";
 970                         type_id = 740;
 971                         break;
 972                 default:
 973                         return -ENODEV;
 974                 }
 975         }
 976         else if (vendor_id == 0x04cc) {
 977                 switch(product_id) {
 978                 case 0x8116:
 979                         PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
 980                         name = "Sotec Afina Eye";
 981                         type_id = 730;
 982                         break;
 983                 default:
 984                         return -ENODEV;
 985                 }
 986         }
 987         else if (vendor_id == 0x06be) {
 988                 switch(product_id) {
 989                 case 0x8116:
 990                         /* This is essentially the same cam as the Sotec Afina Eye */
 991                         PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
 992                         name = "AME Co. Afina Eye";
 993                         type_id = 750;
 994                         break;
 995                 default:
 996                         return -ENODEV;
 997                 }
 998
 999         }
1000         else if (vendor_id == 0x0d81) {
1001                 switch(product_id) {
1002                 case 0x1900:
1003                         PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1004                         name = "Visionite VCS-UC300";
1005                         type_id = 740; /* CCD sensor */
1006                         break;
1007                 case 0x1910:
1008                         PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1009                         name = "Visionite VCS-UM100";
1010                         type_id = 730; /* CMOS sensor */
1011                         break;
1012                 default:
1013                         return -ENODEV;
1014                 }
1015         }
1016         else
1017                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1018
1019         if (my_power_save == -1)
1020                 my_power_save = 0;
1021
1022         memset(serial_number, 0, 30);
1023         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1024         PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1025
1026         if (udev->descriptor.bNumConfigurations > 1)
1027                 PWC_WARNING("Warning: more than 1 configuration available.\n");
1028
1029         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1030         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1031         if (pdev == NULL) {
1032                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1033                 return -ENOMEM;
1034         }
1035         pdev->type = type_id;
1036         pdev->features = features;
1037         pwc_construct(pdev); /* set min/max sizes correct */
1038
1039         mutex_init(&pdev->v4l2_lock);
1040         mutex_init(&pdev->vb_queue_lock);
1041         spin_lock_init(&pdev->queued_bufs_lock);
1042         INIT_LIST_HEAD(&pdev->queued_bufs);
1043
1044         pdev->udev = udev;
1045         pdev->power_save = my_power_save;
1046
1047         /* Init videobuf2 queue structure */
1048         pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1049         pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1050         pdev->vb_queue.drv_priv = pdev;
1051         pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1052         pdev->vb_queue.ops = &pwc_vb_queue_ops;
1053         pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1054         pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1055         pdev->vb_queue.lock = &pdev->vb_queue_lock;
1056         rc = vb2_queue_init(&pdev->vb_queue);
1057         if (rc < 0) {
1058                 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1059                 goto err_free_mem;
1060         }
1061
1062         /* Init video_device structure */
1063         pdev->vdev = pwc_template;
1064         strscpy(pdev->vdev.name, name, sizeof(pdev->vdev.name));
1065         pdev->vdev.queue = &pdev->vb_queue;
1066         video_set_drvdata(&pdev->vdev, pdev);
1067
1068         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1069         PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1070
1071         /* Allocate USB command buffers */
1072         pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1073         if (!pdev->ctrl_buf) {
1074                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1075                 rc = -ENOMEM;
1076                 goto err_free_mem;
1077         }
1078
1079 #ifdef CONFIG_USB_PWC_DEBUG
1080         /* Query sensor type */
1081         if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1082                 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1083                                 pdev->vdev.name,
1084                                 pwc_sensor_type_to_string(rc), rc);
1085         }
1086 #endif
1087
1088         /* Set the leds off */
1089         pwc_set_leds(pdev, 0, 0);
1090
1091         /* Setup initial videomode */
1092         rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1093                                 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1094         if (rc)
1095                 goto err_free_mem;
1096
1097         /* Register controls (and read default values from camera */
1098         rc = pwc_init_controls(pdev);
1099         if (rc) {
1100                 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1101                 goto err_free_mem;
1102         }
1103
1104         /* And powerdown the camera until streaming starts */
1105         pwc_camera_power(pdev, 0);
1106
1107         /* Register the v4l2_device structure */
1108         pdev->v4l2_dev.release = pwc_video_release;
1109         rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1110         if (rc) {
1111                 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1112                 goto err_free_controls;
1113         }
1114
1115         pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1116         pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1117         pdev->vdev.lock = &pdev->v4l2_lock;
1118         pdev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
1119                                  V4L2_CAP_READWRITE;
1120
1121         rc = video_register_device(&pdev->vdev, VFL_TYPE_VIDEO, -1);
1122         if (rc < 0) {
1123                 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1124                 goto err_unregister_v4l2_dev;
1125         }
1126         PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1127
1128 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1129         /* register webcam snapshot button input device */
1130         pdev->button_dev = input_allocate_device();
1131         if (!pdev->button_dev) {
1132                 rc = -ENOMEM;
1133                 goto err_video_unreg;
1134         }
1135
1136         usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1137         strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1138
1139         pdev->button_dev->name = "PWC snapshot button";
1140         pdev->button_dev->phys = pdev->button_phys;
1141         usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1142         pdev->button_dev->dev.parent = &pdev->udev->dev;
1143         pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1144         pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1145
1146         rc = input_register_device(pdev->button_dev);
1147         if (rc) {
1148                 input_free_device(pdev->button_dev);
1149                 pdev->button_dev = NULL;
1150                 goto err_video_unreg;
1151         }
1152 #endif
1153
1154         return 0;
1155
1156 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1157 err_video_unreg:
1158         video_unregister_device(&pdev->vdev);
1159 #endif
1160 err_unregister_v4l2_dev:
1161         v4l2_device_unregister(&pdev->v4l2_dev);
1162 err_free_controls:
1163         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1164 err_free_mem:
1165         kfree(pdev->ctrl_buf);
1166         kfree(pdev);
1167         return rc;
1168 }
1169
1170 /* The user yanked out the cable... */
1171 static void usb_pwc_disconnect(struct usb_interface *intf)
1172 {
1173         struct v4l2_device *v = usb_get_intfdata(intf);
1174         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1175
1176         mutex_lock(&pdev->vb_queue_lock);
1177         mutex_lock(&pdev->v4l2_lock);
1178         /* No need to keep the urbs around after disconnection */
1179         if (pdev->vb_queue.streaming)
1180                 pwc_isoc_cleanup(pdev);
1181         pdev->udev = NULL;
1182
1183         v4l2_device_disconnect(&pdev->v4l2_dev);
1184         video_unregister_device(&pdev->vdev);
1185         mutex_unlock(&pdev->v4l2_lock);
1186         mutex_unlock(&pdev->vb_queue_lock);
1187
1188 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1189         if (pdev->button_dev)
1190                 input_unregister_device(pdev->button_dev);
1191 #endif
1192
1193         v4l2_device_put(&pdev->v4l2_dev);
1194 }
1195
1196
1197 /*
1198  * Initialization code & module stuff
1199  */
1200
1201 static unsigned int leds_nargs;
1202
1203 #ifdef CONFIG_USB_PWC_DEBUG
1204 module_param_named(trace, pwc_trace, int, 0644);
1205 #endif
1206 module_param(power_save, int, 0644);
1207 module_param_array(leds, int, &leds_nargs, 0444);
1208
1209 #ifdef CONFIG_USB_PWC_DEBUG
1210 MODULE_PARM_DESC(trace, "For debugging purposes");
1211 #endif
1212 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1213 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1214
1215 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1216 MODULE_AUTHOR("Luc Saillard <[email protected]>");
1217 MODULE_LICENSE("GPL");
1218 MODULE_ALIAS("pwcx");
1219 MODULE_VERSION( PWC_VERSION );
1220
1221 module_usb_driver(pwc_driver);