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