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