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.field = V4L2_FIELD_NONE; 244 fbuf->vb.sequence = pdev->vframe_count; 245 vb2_buffer_done(&fbuf->vb.vb2_buf, 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.vb2_buf, 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 fbuf->vb.vb2_buf.timestamp = ktime_get_ns(); 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 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[], void *alloc_ctxs[]) 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 default: 814 return -ENODEV; 815 break; 816 } 817 } 818 else if (vendor_id == 0x069A) { 819 switch(product_id) { 820 case 0x0001: 821 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n"); 822 name = "Askey VC010 webcam"; 823 type_id = 645; 824 break; 825 default: 826 return -ENODEV; 827 break; 828 } 829 } 830 else if (vendor_id == 0x046d) { 831 switch(product_id) { 832 case 0x08b0: 833 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n"); 834 name = "Logitech QuickCam Pro 3000"; 835 type_id = 740; /* CCD sensor */ 836 break; 837 case 0x08b1: 838 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n"); 839 name = "Logitech QuickCam Notebook Pro"; 840 type_id = 740; /* CCD sensor */ 841 break; 842 case 0x08b2: 843 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n"); 844 name = "Logitech QuickCam Pro 4000"; 845 type_id = 740; /* CCD sensor */ 846 if (my_power_save == -1) 847 my_power_save = 1; 848 break; 849 case 0x08b3: 850 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n"); 851 name = "Logitech QuickCam Zoom"; 852 type_id = 740; /* CCD sensor */ 853 break; 854 case 0x08B4: 855 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n"); 856 name = "Logitech QuickCam Zoom"; 857 type_id = 740; /* CCD sensor */ 858 if (my_power_save == -1) 859 my_power_save = 1; 860 break; 861 case 0x08b5: 862 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n"); 863 name = "Logitech QuickCam Orbit"; 864 type_id = 740; /* CCD sensor */ 865 if (my_power_save == -1) 866 my_power_save = 1; 867 features |= FEATURE_MOTOR_PANTILT; 868 break; 869 case 0x08b6: 870 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n"); 871 name = "Cisco VT Camera"; 872 type_id = 740; /* CCD sensor */ 873 break; 874 case 0x08b7: 875 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n"); 876 name = "Logitech ViewPort AV 100"; 877 type_id = 740; /* CCD sensor */ 878 break; 879 case 0x08b8: /* Where this released? */ 880 PWC_INFO("Logitech QuickCam detected (reserved ID).\n"); 881 name = "Logitech QuickCam (res.)"; 882 type_id = 730; /* Assuming CMOS */ 883 break; 884 default: 885 return -ENODEV; 886 break; 887 } 888 } 889 else if (vendor_id == 0x055d) { 890 /* I don't know the difference between the C10 and the C30; 891 I suppose the difference is the sensor, but both cameras 892 work equally well with a type_id of 675 893 */ 894 switch(product_id) { 895 case 0x9000: 896 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n"); 897 name = "Samsung MPC-C10"; 898 type_id = 675; 899 break; 900 case 0x9001: 901 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n"); 902 name = "Samsung MPC-C30"; 903 type_id = 675; 904 break; 905 case 0x9002: 906 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n"); 907 name = "Samsung MPC-C30"; 908 type_id = 740; 909 break; 910 default: 911 return -ENODEV; 912 break; 913 } 914 } 915 else if (vendor_id == 0x041e) { 916 switch(product_id) { 917 case 0x400c: 918 PWC_INFO("Creative Labs Webcam 5 detected.\n"); 919 name = "Creative Labs Webcam 5"; 920 type_id = 730; 921 if (my_power_save == -1) 922 my_power_save = 1; 923 break; 924 case 0x4011: 925 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n"); 926 name = "Creative Labs Webcam Pro Ex"; 927 type_id = 740; 928 break; 929 default: 930 return -ENODEV; 931 break; 932 } 933 } 934 else if (vendor_id == 0x04cc) { 935 switch(product_id) { 936 case 0x8116: 937 PWC_INFO("Sotec Afina Eye USB webcam detected.\n"); 938 name = "Sotec Afina Eye"; 939 type_id = 730; 940 break; 941 default: 942 return -ENODEV; 943 break; 944 } 945 } 946 else if (vendor_id == 0x06be) { 947 switch(product_id) { 948 case 0x8116: 949 /* This is essentially the same cam as the Sotec Afina Eye */ 950 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n"); 951 name = "AME Co. Afina Eye"; 952 type_id = 750; 953 break; 954 default: 955 return -ENODEV; 956 break; 957 } 958 959 } 960 else if (vendor_id == 0x0d81) { 961 switch(product_id) { 962 case 0x1900: 963 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n"); 964 name = "Visionite VCS-UC300"; 965 type_id = 740; /* CCD sensor */ 966 break; 967 case 0x1910: 968 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n"); 969 name = "Visionite VCS-UM100"; 970 type_id = 730; /* CMOS sensor */ 971 break; 972 default: 973 return -ENODEV; 974 break; 975 } 976 } 977 else 978 return -ENODEV; /* Not any of the know types; but the list keeps growing. */ 979 980 if (my_power_save == -1) 981 my_power_save = 0; 982 983 memset(serial_number, 0, 30); 984 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29); 985 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number); 986 987 if (udev->descriptor.bNumConfigurations > 1) 988 PWC_WARNING("Warning: more than 1 configuration available.\n"); 989 990 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */ 991 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL); 992 if (pdev == NULL) { 993 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n"); 994 return -ENOMEM; 995 } 996 pdev->type = type_id; 997 pdev->features = features; 998 pwc_construct(pdev); /* set min/max sizes correct */ 999 1000 mutex_init(&pdev->v4l2_lock); 1001 mutex_init(&pdev->vb_queue_lock); 1002 spin_lock_init(&pdev->queued_bufs_lock); 1003 INIT_LIST_HEAD(&pdev->queued_bufs); 1004 1005 pdev->udev = udev; 1006 pdev->power_save = my_power_save; 1007 1008 /* Init videobuf2 queue structure */ 1009 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1010 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ; 1011 pdev->vb_queue.drv_priv = pdev; 1012 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf); 1013 pdev->vb_queue.ops = &pwc_vb_queue_ops; 1014 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops; 1015 pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1016 rc = vb2_queue_init(&pdev->vb_queue); 1017 if (rc < 0) { 1018 PWC_ERROR("Oops, could not initialize vb2 queue.\n"); 1019 goto err_free_mem; 1020 } 1021 1022 /* Init video_device structure */ 1023 pdev->vdev = pwc_template; 1024 strcpy(pdev->vdev.name, name); 1025 pdev->vdev.queue = &pdev->vb_queue; 1026 pdev->vdev.queue->lock = &pdev->vb_queue_lock; 1027 video_set_drvdata(&pdev->vdev, pdev); 1028 1029 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice); 1030 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release); 1031 1032 /* Allocate USB command buffers */ 1033 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL); 1034 if (!pdev->ctrl_buf) { 1035 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n"); 1036 rc = -ENOMEM; 1037 goto err_free_mem; 1038 } 1039 1040 #ifdef CONFIG_USB_PWC_DEBUG 1041 /* Query sensor type */ 1042 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) { 1043 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n", 1044 pdev->vdev.name, 1045 pwc_sensor_type_to_string(rc), rc); 1046 } 1047 #endif 1048 1049 /* Set the leds off */ 1050 pwc_set_leds(pdev, 0, 0); 1051 1052 /* Setup initial videomode */ 1053 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT, 1054 V4L2_PIX_FMT_YUV420, 30, &compression, 1); 1055 if (rc) 1056 goto err_free_mem; 1057 1058 /* Register controls (and read default values from camera */ 1059 rc = pwc_init_controls(pdev); 1060 if (rc) { 1061 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc); 1062 goto err_free_mem; 1063 } 1064 1065 /* And powerdown the camera until streaming starts */ 1066 pwc_camera_power(pdev, 0); 1067 1068 /* Register the v4l2_device structure */ 1069 pdev->v4l2_dev.release = pwc_video_release; 1070 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev); 1071 if (rc) { 1072 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc); 1073 goto err_free_controls; 1074 } 1075 1076 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler; 1077 pdev->vdev.v4l2_dev = &pdev->v4l2_dev; 1078 pdev->vdev.lock = &pdev->v4l2_lock; 1079 1080 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1); 1081 if (rc < 0) { 1082 PWC_ERROR("Failed to register as video device (%d).\n", rc); 1083 goto err_unregister_v4l2_dev; 1084 } 1085 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev)); 1086 1087 #ifdef CONFIG_USB_PWC_INPUT_EVDEV 1088 /* register webcam snapshot button input device */ 1089 pdev->button_dev = input_allocate_device(); 1090 if (!pdev->button_dev) { 1091 rc = -ENOMEM; 1092 goto err_video_unreg; 1093 } 1094 1095 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys)); 1096 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys)); 1097 1098 pdev->button_dev->name = "PWC snapshot button"; 1099 pdev->button_dev->phys = pdev->button_phys; 1100 usb_to_input_id(pdev->udev, &pdev->button_dev->id); 1101 pdev->button_dev->dev.parent = &pdev->udev->dev; 1102 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY); 1103 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA); 1104 1105 rc = input_register_device(pdev->button_dev); 1106 if (rc) { 1107 input_free_device(pdev->button_dev); 1108 pdev->button_dev = NULL; 1109 goto err_video_unreg; 1110 } 1111 #endif 1112 1113 return 0; 1114 1115 err_video_unreg: 1116 video_unregister_device(&pdev->vdev); 1117 err_unregister_v4l2_dev: 1118 v4l2_device_unregister(&pdev->v4l2_dev); 1119 err_free_controls: 1120 v4l2_ctrl_handler_free(&pdev->ctrl_handler); 1121 err_free_mem: 1122 kfree(pdev->ctrl_buf); 1123 kfree(pdev); 1124 return rc; 1125 } 1126 1127 /* The user yanked out the cable... */ 1128 static void usb_pwc_disconnect(struct usb_interface *intf) 1129 { 1130 struct v4l2_device *v = usb_get_intfdata(intf); 1131 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev); 1132 1133 mutex_lock(&pdev->vb_queue_lock); 1134 mutex_lock(&pdev->v4l2_lock); 1135 /* No need to keep the urbs around after disconnection */ 1136 if (pdev->vb_queue.streaming) 1137 pwc_isoc_cleanup(pdev); 1138 pdev->udev = NULL; 1139 1140 v4l2_device_disconnect(&pdev->v4l2_dev); 1141 video_unregister_device(&pdev->vdev); 1142 mutex_unlock(&pdev->v4l2_lock); 1143 mutex_unlock(&pdev->vb_queue_lock); 1144 1145 #ifdef CONFIG_USB_PWC_INPUT_EVDEV 1146 if (pdev->button_dev) 1147 input_unregister_device(pdev->button_dev); 1148 #endif 1149 1150 v4l2_device_put(&pdev->v4l2_dev); 1151 } 1152 1153 1154 /* 1155 * Initialization code & module stuff 1156 */ 1157 1158 static unsigned int leds_nargs; 1159 1160 #ifdef CONFIG_USB_PWC_DEBUG 1161 module_param_named(trace, pwc_trace, int, 0644); 1162 #endif 1163 module_param(power_save, int, 0644); 1164 module_param_array(leds, int, &leds_nargs, 0444); 1165 1166 #ifdef CONFIG_USB_PWC_DEBUG 1167 MODULE_PARM_DESC(trace, "For debugging purposes"); 1168 #endif 1169 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off"); 1170 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds"); 1171 1172 MODULE_DESCRIPTION("Philips & OEM USB webcam driver"); 1173 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>"); 1174 MODULE_LICENSE("GPL"); 1175 MODULE_ALIAS("pwcx"); 1176 MODULE_VERSION( PWC_VERSION ); 1177 1178 module_usb_driver(pwc_driver); 1179