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,
 389                                  pdev->vframes, &compression);
 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         /* Free intermediate decompression buffer & tables */
 607         if (pdev->decompress_data != NULL) {
 608                 PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n",
 609                                  pdev->decompress_data);
 610                 kfree(pdev->decompress_data);
 611                 pdev->decompress_data = NULL;
 612         }
 613
 614         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
 615
 616         kfree(pdev);
 617 }
 618
 619 static int pwc_video_close(struct file *file)
 620 {
 621         struct pwc_device *pdev = video_drvdata(file);
 622
 623         if (pdev->capt_file == file) {
 624                 vb2_queue_release(&pdev->vb_queue);
 625                 pdev->capt_file = NULL;
 626         }
 627         return v4l2_fh_release(file);
 628 }
 629
 630 static ssize_t pwc_video_read(struct file *file, char __user *buf,
 631                               size_t count, loff_t *ppos)
 632 {
 633         struct pwc_device *pdev = video_drvdata(file);
 634
 635         if (!pdev->udev)
 636                 return -ENODEV;
 637
 638         if (pwc_test_n_set_capt_file(pdev, file))
 639                 return -EBUSY;
 640
 641         return vb2_read(&pdev->vb_queue, buf, count, ppos,
 642                         file->f_flags & O_NONBLOCK);
 643 }
 644
 645 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
 646 {
 647         struct pwc_device *pdev = video_drvdata(file);
 648
 649         if (!pdev->udev)
 650                 return POLL_ERR;
 651
 652         return vb2_poll(&pdev->vb_queue, file, wait);
 653 }
 654
 655 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
 656 {
 657         struct pwc_device *pdev = video_drvdata(file);
 658
 659         if (pdev->capt_file != file)
 660                 return -EBUSY;
 661
 662         return vb2_mmap(&pdev->vb_queue, vma);
 663 }
 664
 665 /***************************************************************************/
 666 /* Videobuf2 operations */
 667
 668 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
 669                                 unsigned int *nbuffers, unsigned int *nplanes,
 670                                 unsigned int sizes[], void *alloc_ctxs[])
 671 {
 672         struct pwc_device *pdev = vb2_get_drv_priv(vq);
 673         int size;
 674
 675         if (*nbuffers < MIN_FRAMES)
 676                 *nbuffers = MIN_FRAMES;
 677         else if (*nbuffers > MAX_FRAMES)
 678                 *nbuffers = MAX_FRAMES;
 679
 680         *nplanes = 1;
 681
 682         size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
 683         sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
 684                               pwc_image_sizes[size][1] * 3 / 2);
 685
 686         return 0;
 687 }
 688
 689 static int buffer_init(struct vb2_buffer *vb)
 690 {
 691         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
 692
 693         /* need vmalloc since frame buffer > 128K */
 694         buf->data = vzalloc(PWC_FRAME_SIZE);
 695         if (buf->data == NULL)
 696                 return -ENOMEM;
 697
 698         return 0;
 699 }
 700
 701 static int buffer_prepare(struct vb2_buffer *vb)
 702 {
 703         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
 704
 705         /* Don't allow queing new buffers after device disconnection */
 706         if (!pdev->udev)
 707                 return -ENODEV;
 708
 709         return 0;
 710 }
 711
 712 static int buffer_finish(struct vb2_buffer *vb)
 713 {
 714         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
 715         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
 716
 717         /*
 718          * Application has called dqbuf and is getting back a buffer we've
 719          * filled, take the pwc data we've stored in buf->data and decompress
 720          * it into a usable format, storing the result in the vb2_buffer
 721          */
 722         return pwc_decompress(pdev, buf);
 723 }
 724
 725 static void buffer_cleanup(struct vb2_buffer *vb)
 726 {
 727         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
 728
 729         vfree(buf->data);
 730 }
 731
 732 static void buffer_queue(struct vb2_buffer *vb)
 733 {
 734         struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
 735         struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
 736         unsigned long flags = 0;
 737
 738         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
 739         /* Check the device has not disconnected between prep and queuing */
 740         if (pdev->udev)
 741                 list_add_tail(&buf->list, &pdev->queued_bufs);
 742         else
 743                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
 744         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
 745 }
 746
 747 static int start_streaming(struct vb2_queue *vq, unsigned int count)
 748 {
 749         struct pwc_device *pdev = vb2_get_drv_priv(vq);
 750         int r;
 751
 752         mutex_lock(&pdev->udevlock);
 753         if (!pdev->udev) {
 754                 r = -ENODEV;
 755                 goto leave;
 756         }
 757
 758         /* Turn on camera and set LEDS on */
 759         pwc_camera_power(pdev, 1);
 760         pwc_set_leds(pdev, led_on, led_off);
 761
 762         r = pwc_isoc_init(pdev);
 763         if (r) {
 764                 /* If we failed turn camera and LEDS back off */
 765                 pwc_set_leds(pdev, 0, 0);
 766                 pwc_camera_power(pdev, 0);
 767                 /* And cleanup any queued bufs!! */
 768                 pwc_cleanup_queued_bufs(pdev);
 769         }
 770 leave:
 771         mutex_unlock(&pdev->udevlock);
 772         return r;
 773 }
 774
 775 static int stop_streaming(struct vb2_queue *vq)
 776 {
 777         struct pwc_device *pdev = vb2_get_drv_priv(vq);
 778
 779         mutex_lock(&pdev->udevlock);
 780         if (pdev->udev) {
 781                 pwc_set_leds(pdev, 0, 0);
 782                 pwc_camera_power(pdev, 0);
 783                 pwc_isoc_cleanup(pdev);
 784         }
 785         mutex_unlock(&pdev->udevlock);
 786
 787         pwc_cleanup_queued_bufs(pdev);
 788
 789         return 0;
 790 }
 791
 792 static struct vb2_ops pwc_vb_queue_ops = {
 793         .queue_setup            = queue_setup,
 794         .buf_init               = buffer_init,
 795         .buf_prepare            = buffer_prepare,
 796         .buf_finish             = buffer_finish,
 797         .buf_cleanup            = buffer_cleanup,
 798         .buf_queue              = buffer_queue,
 799         .start_streaming        = start_streaming,
 800         .stop_streaming         = stop_streaming,
 801 };
 802
 803 /***************************************************************************/
 804 /* USB functions */
 805
 806 /* This function gets called when a new device is plugged in or the usb core
 807  * is loaded.
 808  */
 809
 810 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
 811 {
 812         struct usb_device *udev = interface_to_usbdev(intf);
 813         struct pwc_device *pdev = NULL;
 814         int vendor_id, product_id, type_id;
 815         int hint, rc;
 816         int features = 0;
 817         int compression = 0;
 818         int video_nr = -1; /* default: use next available device */
 819         int my_power_save = power_save;
 820         char serial_number[30], *name;
 821
 822         vendor_id = le16_to_cpu(udev->descriptor.idVendor);
 823         product_id = le16_to_cpu(udev->descriptor.idProduct);
 824
 825         /* Check if we can handle this device */
 826         PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
 827                 vendor_id, product_id,
 828                 intf->altsetting->desc.bInterfaceNumber);
 829
 830         /* the interfaces are probed one by one. We are only interested in the
 831            video interface (0) now.
 832            Interface 1 is the Audio Control, and interface 2 Audio itself.
 833          */
 834         if (intf->altsetting->desc.bInterfaceNumber > 0)
 835                 return -ENODEV;
 836
 837         if (vendor_id == 0x0471) {
 838                 switch (product_id) {
 839                 case 0x0302:
 840                         PWC_INFO("Philips PCA645VC USB webcam detected.\n");
 841                         name = "Philips 645 webcam";
 842                         type_id = 645;
 843                         break;
 844                 case 0x0303:
 845                         PWC_INFO("Philips PCA646VC USB webcam detected.\n");
 846                         name = "Philips 646 webcam";
 847                         type_id = 646;
 848                         break;
 849                 case 0x0304:
 850                         PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
 851                         name = "Askey VC010 webcam";
 852                         type_id = 646;
 853                         break;
 854                 case 0x0307:
 855                         PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
 856                         name = "Philips 675 webcam";
 857                         type_id = 675;
 858                         break;
 859                 case 0x0308:
 860                         PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
 861                         name = "Philips 680 webcam";
 862                         type_id = 680;
 863                         break;
 864                 case 0x030C:
 865                         PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
 866                         name = "Philips 690 webcam";
 867                         type_id = 690;
 868                         break;
 869                 case 0x0310:
 870                         PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
 871                         name = "Philips 730 webcam";
 872                         type_id = 730;
 873                         break;
 874                 case 0x0311:
 875                         PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
 876                         name = "Philips 740 webcam";
 877                         type_id = 740;
 878                         break;
 879                 case 0x0312:
 880                         PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
 881                         name = "Philips 750 webcam";
 882                         type_id = 750;
 883                         break;
 884                 case 0x0313:
 885                         PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
 886                         name = "Philips 720K/40 webcam";
 887                         type_id = 720;
 888                         break;
 889                 case 0x0329:
 890                         PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
 891                         name = "Philips SPC 900NC webcam";
 892                         type_id = 740;
 893                         break;
 894                 default:
 895                         return -ENODEV;
 896                         break;
 897                 }
 898         }
 899         else if (vendor_id == 0x069A) {
 900                 switch(product_id) {
 901                 case 0x0001:
 902                         PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
 903                         name = "Askey VC010 webcam";
 904                         type_id = 645;
 905                         break;
 906                 default:
 907                         return -ENODEV;
 908                         break;
 909                 }
 910         }
 911         else if (vendor_id == 0x046d) {
 912                 switch(product_id) {
 913                 case 0x08b0:
 914                         PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
 915                         name = "Logitech QuickCam Pro 3000";
 916                         type_id = 740; /* CCD sensor */
 917                         break;
 918                 case 0x08b1:
 919                         PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
 920                         name = "Logitech QuickCam Notebook Pro";
 921                         type_id = 740; /* CCD sensor */
 922                         break;
 923                 case 0x08b2:
 924                         PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
 925                         name = "Logitech QuickCam Pro 4000";
 926                         type_id = 740; /* CCD sensor */
 927                         if (my_power_save == -1)
 928                                 my_power_save = 1;
 929                         break;
 930                 case 0x08b3:
 931                         PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
 932                         name = "Logitech QuickCam Zoom";
 933                         type_id = 740; /* CCD sensor */
 934                         break;
 935                 case 0x08B4:
 936                         PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
 937                         name = "Logitech QuickCam Zoom";
 938                         type_id = 740; /* CCD sensor */
 939                         if (my_power_save == -1)
 940                                 my_power_save = 1;
 941                         break;
 942                 case 0x08b5:
 943                         PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
 944                         name = "Logitech QuickCam Orbit";
 945                         type_id = 740; /* CCD sensor */
 946                         if (my_power_save == -1)
 947                                 my_power_save = 1;
 948                         features |= FEATURE_MOTOR_PANTILT;
 949                         break;
 950                 case 0x08b6:
 951                         PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
 952                         name = "Cisco VT Camera";
 953                         type_id = 740; /* CCD sensor */
 954                         break;
 955                 case 0x08b7:
 956                         PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
 957                         name = "Logitech ViewPort AV 100";
 958                         type_id = 740; /* CCD sensor */
 959                         break;
 960                 case 0x08b8: /* Where this released? */
 961                         PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
 962                         name = "Logitech QuickCam (res.)";
 963                         type_id = 730; /* Assuming CMOS */
 964                         break;
 965                 default:
 966                         return -ENODEV;
 967                         break;
 968                 }
 969         }
 970         else if (vendor_id == 0x055d) {
 971                 /* I don't know the difference between the C10 and the C30;
 972                    I suppose the difference is the sensor, but both cameras
 973                    work equally well with a type_id of 675
 974                  */
 975                 switch(product_id) {
 976                 case 0x9000:
 977                         PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
 978                         name = "Samsung MPC-C10";
 979                         type_id = 675;
 980                         break;
 981                 case 0x9001:
 982                         PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
 983                         name = "Samsung MPC-C30";
 984                         type_id = 675;
 985                         break;
 986                 case 0x9002:
 987                         PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
 988                         name = "Samsung MPC-C30";
 989                         type_id = 740;
 990                         break;
 991                 default:
 992                         return -ENODEV;
 993                         break;
 994                 }
 995         }
 996         else if (vendor_id == 0x041e) {
 997                 switch(product_id) {
 998                 case 0x400c:
 999                         PWC_INFO("Creative Labs Webcam 5 detected.\n");
1000                         name = "Creative Labs Webcam 5";
1001                         type_id = 730;
1002                         if (my_power_save == -1)
1003                                 my_power_save = 1;
1004                         break;
1005                 case 0x4011:
1006                         PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1007                         name = "Creative Labs Webcam Pro Ex";
1008                         type_id = 740;
1009                         break;
1010                 default:
1011                         return -ENODEV;
1012                         break;
1013                 }
1014         }
1015         else if (vendor_id == 0x04cc) {
1016                 switch(product_id) {
1017                 case 0x8116:
1018                         PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1019                         name = "Sotec Afina Eye";
1020                         type_id = 730;
1021                         break;
1022                 default:
1023                         return -ENODEV;
1024                         break;
1025                 }
1026         }
1027         else if (vendor_id == 0x06be) {
1028                 switch(product_id) {
1029                 case 0x8116:
1030                         /* This is essentially the same cam as the Sotec Afina Eye */
1031                         PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1032                         name = "AME Co. Afina Eye";
1033                         type_id = 750;
1034                         break;
1035                 default:
1036                         return -ENODEV;
1037                         break;
1038                 }
1039
1040         }
1041         else if (vendor_id == 0x0d81) {
1042                 switch(product_id) {
1043                 case 0x1900:
1044                         PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1045                         name = "Visionite VCS-UC300";
1046                         type_id = 740; /* CCD sensor */
1047                         break;
1048                 case 0x1910:
1049                         PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1050                         name = "Visionite VCS-UM100";
1051                         type_id = 730; /* CMOS sensor */
1052                         break;
1053                 default:
1054                         return -ENODEV;
1055                         break;
1056                 }
1057         }
1058         else
1059                 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1060
1061         if (my_power_save == -1)
1062                 my_power_save = 0;
1063
1064         memset(serial_number, 0, 30);
1065         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1066         PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1067
1068         if (udev->descriptor.bNumConfigurations > 1)
1069                 PWC_WARNING("Warning: more than 1 configuration available.\n");
1070
1071         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1072         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1073         if (pdev == NULL) {
1074                 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1075                 return -ENOMEM;
1076         }
1077         pdev->type = type_id;
1078         pdev->features = features;
1079         pwc_construct(pdev); /* set min/max sizes correct */
1080
1081         mutex_init(&pdev->capt_file_lock);
1082         mutex_init(&pdev->udevlock);
1083         spin_lock_init(&pdev->queued_bufs_lock);
1084         INIT_LIST_HEAD(&pdev->queued_bufs);
1085
1086         pdev->udev = udev;
1087         pdev->power_save = my_power_save;
1088
1089         /* Init videobuf2 queue structure */
1090         memset(&pdev->vb_queue, 0, sizeof(pdev->vb_queue));
1091         pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1092         pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1093         pdev->vb_queue.drv_priv = pdev;
1094         pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1095         pdev->vb_queue.ops = &pwc_vb_queue_ops;
1096         pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1097         vb2_queue_init(&pdev->vb_queue);
1098
1099         /* Init video_device structure */
1100         memcpy(&pdev->vdev, &pwc_template, sizeof(pwc_template));
1101         strcpy(pdev->vdev.name, name);
1102         set_bit(V4L2_FL_USE_FH_PRIO, &pdev->vdev.flags);
1103         video_set_drvdata(&pdev->vdev, pdev);
1104
1105         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1106         PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1107
1108         /* Now search device_hint[] table for a match, so we can hint a node number. */
1109         for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1110                 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1111                      (device_hint[hint].pdev == NULL)) {
1112                         /* so far, so good... try serial number */
1113                         if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1114                                 /* match! */
1115                                 video_nr = device_hint[hint].device_node;
1116                                 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1117                                 break;
1118                         }
1119                 }
1120         }
1121
1122         /* occupy slot */
1123         if (hint < MAX_DEV_HINTS)
1124                 device_hint[hint].pdev = pdev;
1125
1126 #ifdef CONFIG_USB_PWC_DEBUG
1127         /* Query sensor type */
1128         if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1129                 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1130                                 pdev->vdev.name,
1131                                 pwc_sensor_type_to_string(rc), rc);
1132         }
1133 #endif
1134
1135         /* Set the leds off */
1136         pwc_set_leds(pdev, 0, 0);
1137
1138         /* Setup intial videomode */
1139         rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT, 30, &compression);
1140         if (rc)
1141                 goto err_free_mem;
1142
1143         /* Register controls (and read default values from camera */
1144         rc = pwc_init_controls(pdev);
1145         if (rc) {
1146                 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1147                 goto err_free_mem;
1148         }
1149
1150         /* And powerdown the camera until streaming starts */
1151         pwc_camera_power(pdev, 0);
1152
1153         /* Register the v4l2_device structure */
1154         pdev->v4l2_dev.release = pwc_video_release;
1155         rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1156         if (rc) {
1157                 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1158                 goto err_free_controls;
1159         }
1160
1161         pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1162         pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1163
1164         rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1165         if (rc < 0) {
1166                 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1167                 goto err_unregister_v4l2_dev;
1168         }
1169         PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1170
1171 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1172         /* register webcam snapshot button input device */
1173         pdev->button_dev = input_allocate_device();
1174         if (!pdev->button_dev) {
1175                 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1176                 rc = -ENOMEM;
1177                 goto err_video_unreg;
1178         }
1179
1180         usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1181         strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1182
1183         pdev->button_dev->name = "PWC snapshot button";
1184         pdev->button_dev->phys = pdev->button_phys;
1185         usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1186         pdev->button_dev->dev.parent = &pdev->udev->dev;
1187         pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1188         pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1189
1190         rc = input_register_device(pdev->button_dev);
1191         if (rc) {
1192                 input_free_device(pdev->button_dev);
1193                 pdev->button_dev = NULL;
1194                 goto err_video_unreg;
1195         }
1196 #endif
1197
1198         return 0;
1199
1200 err_video_unreg:
1201         video_unregister_device(&pdev->vdev);
1202 err_unregister_v4l2_dev:
1203         v4l2_device_unregister(&pdev->v4l2_dev);
1204 err_free_controls:
1205         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1206 err_free_mem:
1207         if (hint < MAX_DEV_HINTS)
1208                 device_hint[hint].pdev = NULL;
1209         kfree(pdev);
1210         return rc;
1211 }
1212
1213 /* The user yanked out the cable... */
1214 static void usb_pwc_disconnect(struct usb_interface *intf)
1215 {
1216         struct v4l2_device *v = usb_get_intfdata(intf);
1217         struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1218
1219         mutex_lock(&pdev->udevlock);
1220         /* No need to keep the urbs around after disconnection */
1221         pwc_isoc_cleanup(pdev);
1222         pdev->udev = NULL;
1223         mutex_unlock(&pdev->udevlock);
1224
1225         pwc_cleanup_queued_bufs(pdev);
1226
1227         video_unregister_device(&pdev->vdev);
1228         v4l2_device_unregister(&pdev->v4l2_dev);
1229
1230 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1231         if (pdev->button_dev)
1232                 input_unregister_device(pdev->button_dev);
1233 #endif
1234
1235         v4l2_device_put(&pdev->v4l2_dev);
1236 }
1237
1238
1239 /*
1240  * Initialization code & module stuff
1241  */
1242
1243 static int leds[2] = { -1, -1 };
1244 static unsigned int leds_nargs;
1245 static char *dev_hint[MAX_DEV_HINTS];
1246 static unsigned int dev_hint_nargs;
1247
1248 #ifdef CONFIG_USB_PWC_DEBUG
1249 module_param_named(trace, pwc_trace, int, 0644);
1250 #endif
1251 module_param(power_save, int, 0644);
1252 module_param_array(leds, int, &leds_nargs, 0444);
1253 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1254
1255 #ifdef CONFIG_USB_PWC_DEBUG
1256 MODULE_PARM_DESC(trace, "For debugging purposes");
1257 #endif
1258 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1259 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1260 MODULE_PARM_DESC(dev_hint, "Device node hints");
1261
1262 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1263 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1264 MODULE_LICENSE("GPL");
1265 MODULE_ALIAS("pwcx");
1266 MODULE_VERSION( PWC_VERSION );
1267
1268 static int __init usb_pwc_init(void)
1269 {
1270         int i;
1271
1272 #ifdef CONFIG_USB_PWC_DEBUG
1273         PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1274         PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1275         PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1276         PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1277
1278         if (pwc_trace >= 0) {
1279                 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1280         }
1281 #endif
1282
1283         if (leds[0] >= 0)
1284                 led_on = leds[0];
1285         if (leds[1] >= 0)
1286                 led_off = leds[1];
1287
1288         /* Big device node whoopla. Basically, it allows you to assign a
1289            device node (/dev/videoX) to a camera, based on its type
1290            & serial number. The format is [type[.serialnumber]:]node.
1291
1292            Any camera that isn't matched by these rules gets the next
1293            available free device node.
1294          */
1295         for (i = 0; i < MAX_DEV_HINTS; i++) {
1296                 char *s, *colon, *dot;
1297
1298                 /* This loop also initializes the array */
1299                 device_hint[i].pdev = NULL;
1300                 s = dev_hint[i];
1301                 if (s != NULL && *s != '\0') {
1302                         device_hint[i].type = -1; /* wildcard */
1303                         strcpy(device_hint[i].serial_number, "*");
1304
1305                         /* parse string: chop at ':' & '/' */
1306                         colon = dot = s;
1307                         while (*colon != '\0' && *colon != ':')
1308                                 colon++;
1309                         while (*dot != '\0' && *dot != '.')
1310                                 dot++;
1311                         /* Few sanity checks */
1312                         if (*dot != '\0' && dot > colon) {
1313                                 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
1314                                 return -EINVAL;
1315                         }
1316
1317                         if (*colon == '\0') {
1318                                 /* No colon */
1319                                 if (*dot != '\0') {
1320                                         PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
1321                                         return -EINVAL;
1322                                 }
1323                                 else {
1324                                         /* No type or serial number specified, just a number. */
1325                                         device_hint[i].device_node =
1326                                                 simple_strtol(s, NULL, 10);
1327                                 }
1328                         }
1329                         else {
1330                                 /* There's a colon, so we have at least a type and a device node */
1331                                 device_hint[i].type =
1332                                         simple_strtol(s, NULL, 10);
1333                                 device_hint[i].device_node =
1334                                         simple_strtol(colon + 1, NULL, 10);
1335                                 if (*dot != '\0') {
1336                                         /* There's a serial number as well */
1337                                         int k;
1338
1339                                         dot++;
1340                                         k = 0;
1341                                         while (*dot != ':' && k < 29) {
1342                                                 device_hint[i].serial_number[k++] = *dot;
1343                                                 dot++;
1344                                         }
1345                                         device_hint[i].serial_number[k] = '\0';
1346                                 }
1347                         }
1348                         PWC_TRACE("device_hint[%d]:\n", i);
1349                         PWC_TRACE("  type    : %d\n", device_hint[i].type);
1350                         PWC_TRACE("  serial# : %s\n", device_hint[i].serial_number);
1351                         PWC_TRACE("  node    : %d\n", device_hint[i].device_node);
1352                 }
1353                 else
1354                         device_hint[i].type = 0; /* not filled */
1355         } /* ..for MAX_DEV_HINTS */
1356
1357         PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
1358         return usb_register(&pwc_driver);
1359 }
1360
1361 static void __exit usb_pwc_exit(void)
1362 {
1363         PWC_DEBUG_MODULE("Deregistering driver.\n");
1364         usb_deregister(&pwc_driver);
1365         PWC_INFO("Philips webcam module removed.\n");
1366 }
1367
1368 module_init(usb_pwc_init);
1369 module_exit(usb_pwc_exit);
1370
1371 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */