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