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

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