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 */ 82static 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}; 116MODULE_DEVICE_TABLE(usb, pwc_device_table); 117 118static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id); 119static void usb_pwc_disconnect(struct usb_interface *intf); 120static void pwc_isoc_cleanup(struct pwc_device *pdev); 121 122static 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 135static int power_save = -1; 136static int leds[2] = { 100, 0 }; 137 138/***/ 139 140static 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}; 149static 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 159static 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); 170leave: 171 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags); 172 return buf; 173} 174 175static 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 191static 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.v4l2_buf.field = V4L2_FIELD_NONE; 245 fbuf->vb.v4l2_buf.sequence = pdev->vframe_count; 246 vb2_buffer_done(&fbuf->vb, 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 */ 257static 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, 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 v4l2_get_timestamp( 321 &fbuf->vb.v4l2_buf.timestamp); 322 pdev->vsync = 2; 323 } 324 325 if (flen + fbuf->filled > pdev->frame_total_size) { 326 PWC_ERROR("Frame overflow (%d > %d)\n", 327 flen + fbuf->filled, 328 pdev->frame_total_size); 329 pdev->vsync = 0; /* Let's wait for an EOF */ 330 } else { 331 memcpy(fbuf->data + fbuf->filled, iso_buf, 332 flen); 333 fbuf->filled += flen; 334 } 335 } 336 if (flen < pdev->vlast_packet_size) { 337 /* Shorter packet... end of frame */ 338 if (pdev->vsync == 2) 339 pwc_frame_complete(pdev); 340 if (pdev->fill_buf == NULL) 341 pdev->fill_buf = pwc_get_next_fill_buf(pdev); 342 if (pdev->fill_buf) { 343 pdev->fill_buf->filled = 0; 344 pdev->vsync = 1; 345 } 346 } 347 pdev->vlast_packet_size = flen; 348 } 349 350handler_end: 351 i = usb_submit_urb(urb, GFP_ATOMIC); 352 if (i != 0) 353 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i); 354} 355 356/* Both v4l2_lock and vb_queue_lock should be locked when calling this */ 357static int pwc_isoc_init(struct pwc_device *pdev) 358{ 359 struct usb_device *udev; 360 struct urb *urb; 361 int i, j, ret; 362 struct usb_interface *intf; 363 struct usb_host_interface *idesc = NULL; 364 int compression = 0; /* 0..3 = uncompressed..high */ 365 366 pdev->vsync = 0; 367 pdev->vlast_packet_size = 0; 368 pdev->fill_buf = NULL; 369 pdev->vframe_count = 0; 370 pdev->visoc_errors = 0; 371 udev = pdev->udev; 372 373retry: 374 /* We first try with low compression and then retry with a higher 375 compression setting if there is not enough bandwidth. */ 376 ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt, 377 pdev->vframes, &compression, 1); 378 379 /* Get the current alternate interface, adjust packet size */ 380 intf = usb_ifnum_to_if(udev, 0); 381 if (intf) 382 idesc = usb_altnum_to_altsetting(intf, pdev->valternate); 383 if (!idesc) 384 return -EIO; 385 386 /* Search video endpoint */ 387 pdev->vmax_packet_size = -1; 388 for (i = 0; i < idesc->desc.bNumEndpoints; i++) { 389 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) { 390 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize); 391 break; 392 } 393 } 394 395 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) { 396 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n"); 397 return -ENFILE; /* Odd error, that should be noticeable */ 398 } 399 400 /* Set alternate interface */ 401 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate); 402 ret = usb_set_interface(pdev->udev, 0, pdev->valternate); 403 if (ret == -ENOSPC && compression < 3) { 404 compression++; 405 goto retry; 406 } 407 if (ret < 0) 408 return ret; 409 410 /* Allocate and init Isochronuous urbs */ 411 for (i = 0; i < MAX_ISO_BUFS; i++) { 412 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL); 413 if (urb == NULL) { 414 PWC_ERROR("Failed to allocate urb %d\n", i); 415 pwc_isoc_cleanup(pdev); 416 return -ENOMEM; 417 } 418 pdev->urbs[i] = urb; 419 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb); 420 421 urb->interval = 1; // devik 422 urb->dev = udev; 423 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint); 424 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; 425 urb->transfer_buffer = usb_alloc_coherent(udev, 426 ISO_BUFFER_SIZE, 427 GFP_KERNEL, 428 &urb->transfer_dma); 429 if (urb->transfer_buffer == NULL) { 430 PWC_ERROR("Failed to allocate urb buffer %d\n", i); 431 pwc_isoc_cleanup(pdev); 432 return -ENOMEM; 433 } 434 urb->transfer_buffer_length = ISO_BUFFER_SIZE; 435 urb->complete = pwc_isoc_handler; 436 urb->context = pdev; 437 urb->start_frame = 0; 438 urb->number_of_packets = ISO_FRAMES_PER_DESC; 439 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) { 440 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE; 441 urb->iso_frame_desc[j].length = pdev->vmax_packet_size; 442 } 443 } 444 445 /* link */ 446 for (i = 0; i < MAX_ISO_BUFS; i++) { 447 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL); 448 if (ret == -ENOSPC && compression < 3) { 449 compression++; 450 pwc_isoc_cleanup(pdev); 451 goto retry; 452 } 453 if (ret) { 454 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret); 455 pwc_isoc_cleanup(pdev); 456 return ret; 457 } 458 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]); 459 } 460 461 /* All is done... */ 462 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n"); 463 return 0; 464} 465 466static void pwc_iso_stop(struct pwc_device *pdev) 467{ 468 int i; 469 470 /* Unlinking ISOC buffers one by one */ 471 for (i = 0; i < MAX_ISO_BUFS; i++) { 472 if (pdev->urbs[i]) { 473 PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]); 474 usb_kill_urb(pdev->urbs[i]); 475 } 476 } 477} 478 479static void pwc_iso_free(struct pwc_device *pdev) 480{ 481 int i; 482 483 /* Freeing ISOC buffers one by one */ 484 for (i = 0; i < MAX_ISO_BUFS; i++) { 485 if (pdev->urbs[i]) { 486 PWC_DEBUG_MEMORY("Freeing URB\n"); 487 if (pdev->urbs[i]->transfer_buffer) { 488 usb_free_coherent(pdev->udev, 489 pdev->urbs[i]->transfer_buffer_length, 490 pdev->urbs[i]->transfer_buffer, 491 pdev->urbs[i]->transfer_dma); 492 } 493 usb_free_urb(pdev->urbs[i]); 494 pdev->urbs[i] = NULL; 495 } 496 } 497} 498 499/* Both v4l2_lock and vb_queue_lock should be locked when calling this */ 500static void pwc_isoc_cleanup(struct pwc_device *pdev) 501{ 502 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n"); 503 504 pwc_iso_stop(pdev); 505 pwc_iso_free(pdev); 506 usb_set_interface(pdev->udev, 0, 0); 507 508 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n"); 509} 510 511/* Must be called with vb_queue_lock hold */ 512static void pwc_cleanup_queued_bufs(struct pwc_device *pdev, 513 enum vb2_buffer_state state) 514{ 515 unsigned long flags = 0; 516 517 spin_lock_irqsave(&pdev->queued_bufs_lock, flags); 518 while (!list_empty(&pdev->queued_bufs)) { 519 struct pwc_frame_buf *buf; 520 521 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, 522 list); 523 list_del(&buf->list); 524 vb2_buffer_done(&buf->vb, state); 525 } 526 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags); 527} 528 529#ifdef CONFIG_USB_PWC_DEBUG 530static const char *pwc_sensor_type_to_string(unsigned int sensor_type) 531{ 532 switch(sensor_type) { 533 case 0x00: 534 return "Hyundai CMOS sensor"; 535 case 0x20: 536 return "Sony CCD sensor + TDA8787"; 537 case 0x2E: 538 return "Sony CCD sensor + Exas 98L59"; 539 case 0x2F: 540 return "Sony CCD sensor + ADI 9804"; 541 case 0x30: 542 return "Sharp CCD sensor + TDA8787"; 543 case 0x3E: 544 return "Sharp CCD sensor + Exas 98L59"; 545 case 0x3F: 546 return "Sharp CCD sensor + ADI 9804"; 547 case 0x40: 548 return "UPA 1021 sensor"; 549 case 0x100: 550 return "VGA sensor"; 551 case 0x101: 552 return "PAL MR sensor"; 553 default: 554 return "unknown type of sensor"; 555 } 556} 557#endif 558 559/***************************************************************************/ 560/* Video4Linux functions */ 561 562static void pwc_video_release(struct v4l2_device *v) 563{ 564 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev); 565 566 v4l2_ctrl_handler_free(&pdev->ctrl_handler); 567 v4l2_device_unregister(&pdev->v4l2_dev); 568 kfree(pdev->ctrl_buf); 569 kfree(pdev); 570} 571 572/***************************************************************************/ 573/* Videobuf2 operations */ 574 575static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt, 576 unsigned int *nbuffers, unsigned int *nplanes, 577 unsigned int sizes[], void *alloc_ctxs[]) 578{ 579 struct pwc_device *pdev = vb2_get_drv_priv(vq); 580 int size; 581 582 if (*nbuffers < MIN_FRAMES) 583 *nbuffers = MIN_FRAMES; 584 else if (*nbuffers > MAX_FRAMES) 585 *nbuffers = MAX_FRAMES; 586 587 *nplanes = 1; 588 589 size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT); 590 sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] * 591 pwc_image_sizes[size][1] * 3 / 2); 592 593 return 0; 594} 595 596static int buffer_init(struct vb2_buffer *vb) 597{ 598 struct pwc_frame_buf *buf = container_of(vb, 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 608static 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 619static void buffer_finish(struct vb2_buffer *vb) 620{ 621 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue); 622 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb); 623 624 if (vb->state == VB2_BUF_STATE_DONE) { 625 /* 626 * Application has called dqbuf and is getting back a buffer 627 * we've filled, take the pwc data we've stored in buf->data 628 * and decompress it into a usable format, storing the result 629 * in the vb2_buffer. 630 */ 631 pwc_decompress(pdev, buf); 632 } 633} 634 635static void buffer_cleanup(struct vb2_buffer *vb) 636{ 637 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb); 638 639 vfree(buf->data); 640} 641 642static void buffer_queue(struct vb2_buffer *vb) 643{ 644 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue); 645 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb); 646 unsigned long flags = 0; 647 648 /* Check the device has not disconnected between prep and queuing */ 649 if (!pdev->udev) { 650 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR); 651 return; 652 } 653 654 spin_lock_irqsave(&pdev->queued_bufs_lock, flags); 655 list_add_tail(&buf->list, &pdev->queued_bufs); 656 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags); 657} 658 659static int start_streaming(struct vb2_queue *vq, unsigned int count) 660{ 661 struct pwc_device *pdev = vb2_get_drv_priv(vq); 662 int r; 663 664 if (!pdev->udev) 665 return -ENODEV; 666 667 if (mutex_lock_interruptible(&pdev->v4l2_lock)) 668 return -ERESTARTSYS; 669 /* Turn on camera and set LEDS on */ 670 pwc_camera_power(pdev, 1); 671 pwc_set_leds(pdev, leds[0], leds[1]); 672 673 r = pwc_isoc_init(pdev); 674 if (r) { 675 /* If we failed turn camera and LEDS back off */ 676 pwc_set_leds(pdev, 0, 0); 677 pwc_camera_power(pdev, 0); 678 /* And cleanup any queued bufs!! */ 679 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED); 680 } 681 mutex_unlock(&pdev->v4l2_lock); 682 683 return r; 684} 685 686static void stop_streaming(struct vb2_queue *vq) 687{ 688 struct pwc_device *pdev = vb2_get_drv_priv(vq); 689 690 mutex_lock(&pdev->v4l2_lock); 691 if (pdev->udev) { 692 pwc_set_leds(pdev, 0, 0); 693 pwc_camera_power(pdev, 0); 694 pwc_isoc_cleanup(pdev); 695 } 696 697 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR); 698 if (pdev->fill_buf) 699 vb2_buffer_done(&pdev->fill_buf->vb, VB2_BUF_STATE_ERROR); 700 mutex_unlock(&pdev->v4l2_lock); 701} 702 703static struct vb2_ops pwc_vb_queue_ops = { 704 .queue_setup = queue_setup, 705 .buf_init = buffer_init, 706 .buf_prepare = buffer_prepare, 707 .buf_finish = buffer_finish, 708 .buf_cleanup = buffer_cleanup, 709 .buf_queue = buffer_queue, 710 .start_streaming = start_streaming, 711 .stop_streaming = stop_streaming, 712 .wait_prepare = vb2_ops_wait_prepare, 713 .wait_finish = vb2_ops_wait_finish, 714}; 715 716/***************************************************************************/ 717/* USB functions */ 718 719/* This function gets called when a new device is plugged in or the usb core 720 * is loaded. 721 */ 722 723static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id) 724{ 725 struct usb_device *udev = interface_to_usbdev(intf); 726 struct pwc_device *pdev = NULL; 727 int vendor_id, product_id, type_id; 728 int rc; 729 int features = 0; 730 int compression = 0; 731 int my_power_save = power_save; 732 char serial_number[30], *name; 733 734 vendor_id = le16_to_cpu(udev->descriptor.idVendor); 735 product_id = le16_to_cpu(udev->descriptor.idProduct); 736 737 /* Check if we can handle this device */ 738 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n", 739 vendor_id, product_id, 740 intf->altsetting->desc.bInterfaceNumber); 741 742 /* the interfaces are probed one by one. We are only interested in the 743 video interface (0) now. 744 Interface 1 is the Audio Control, and interface 2 Audio itself. 745 */ 746 if (intf->altsetting->desc.bInterfaceNumber > 0) 747 return -ENODEV; 748 749 if (vendor_id == 0x0471) { 750 switch (product_id) { 751 case 0x0302: 752 PWC_INFO("Philips PCA645VC USB webcam detected.\n"); 753 name = "Philips 645 webcam"; 754 type_id = 645; 755 break; 756 case 0x0303: 757 PWC_INFO("Philips PCA646VC USB webcam detected.\n"); 758 name = "Philips 646 webcam"; 759 type_id = 646; 760 break; 761 case 0x0304: 762 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n"); 763 name = "Askey VC010 webcam"; 764 type_id = 646; 765 break; 766 case 0x0307: 767 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n"); 768 name = "Philips 675 webcam"; 769 type_id = 675; 770 break; 771 case 0x0308: 772 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n"); 773 name = "Philips 680 webcam"; 774 type_id = 680; 775 break; 776 case 0x030C: 777 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n"); 778 name = "Philips 690 webcam"; 779 type_id = 690; 780 break; 781 case 0x0310: 782 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n"); 783 name = "Philips 730 webcam"; 784 type_id = 730; 785 break; 786 case 0x0311: 787 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n"); 788 name = "Philips 740 webcam"; 789 type_id = 740; 790 break; 791 case 0x0312: 792 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n"); 793 name = "Philips 750 webcam"; 794 type_id = 750; 795 break; 796 case 0x0313: 797 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n"); 798 name = "Philips 720K/40 webcam"; 799 type_id = 720; 800 break; 801 case 0x0329: 802 PWC_INFO("Philips SPC 900NC USB webcam detected.\n"); 803 name = "Philips SPC 900NC webcam"; 804 type_id = 740; 805 break; 806 case 0x032C: 807 PWC_INFO("Philips SPC 880NC USB webcam detected.\n"); 808 name = "Philips SPC 880NC webcam"; 809 type_id = 740; 810 break; 811 default: 812 return -ENODEV; 813 break; 814 } 815 } 816 else if (vendor_id == 0x069A) { 817 switch(product_id) { 818 case 0x0001: 819 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n"); 820 name = "Askey VC010 webcam"; 821 type_id = 645; 822 break; 823 default: 824 return -ENODEV; 825 break; 826 } 827 } 828 else if (vendor_id == 0x046d) { 829 switch(product_id) { 830 case 0x08b0: 831 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n"); 832 name = "Logitech QuickCam Pro 3000"; 833 type_id = 740; /* CCD sensor */ 834 break; 835 case 0x08b1: 836 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n"); 837 name = "Logitech QuickCam Notebook Pro"; 838 type_id = 740; /* CCD sensor */ 839 break; 840 case 0x08b2: 841 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n"); 842 name = "Logitech QuickCam Pro 4000"; 843 type_id = 740; /* CCD sensor */ 844 if (my_power_save == -1) 845 my_power_save = 1; 846 break; 847 case 0x08b3: 848 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n"); 849 name = "Logitech QuickCam Zoom"; 850 type_id = 740; /* CCD sensor */ 851 break; 852 case 0x08B4: 853 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n"); 854 name = "Logitech QuickCam Zoom"; 855 type_id = 740; /* CCD sensor */ 856 if (my_power_save == -1) 857 my_power_save = 1; 858 break; 859 case 0x08b5: 860 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n"); 861 name = "Logitech QuickCam Orbit"; 862 type_id = 740; /* CCD sensor */ 863 if (my_power_save == -1) 864 my_power_save = 1; 865 features |= FEATURE_MOTOR_PANTILT; 866 break; 867 case 0x08b6: 868 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n"); 869 name = "Cisco VT Camera"; 870 type_id = 740; /* CCD sensor */ 871 break; 872 case 0x08b7: 873 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n"); 874 name = "Logitech ViewPort AV 100"; 875 type_id = 740; /* CCD sensor */ 876 break; 877 case 0x08b8: /* Where this released? */ 878 PWC_INFO("Logitech QuickCam detected (reserved ID).\n"); 879 name = "Logitech QuickCam (res.)"; 880 type_id = 730; /* Assuming CMOS */ 881 break; 882 default: 883 return -ENODEV; 884 break; 885 } 886 } 887 else if (vendor_id == 0x055d) { 888 /* I don't know the difference between the C10 and the C30; 889 I suppose the difference is the sensor, but both cameras 890 work equally well with a type_id of 675 891 */ 892 switch(product_id) { 893 case 0x9000: 894 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n"); 895 name = "Samsung MPC-C10"; 896 type_id = 675; 897 break; 898 case 0x9001: 899 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n"); 900 name = "Samsung MPC-C30"; 901 type_id = 675; 902 break; 903 case 0x9002: 904 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n"); 905 name = "Samsung MPC-C30"; 906 type_id = 740; 907 break; 908 default: 909 return -ENODEV; 910 break; 911 } 912 } 913 else if (vendor_id == 0x041e) { 914 switch(product_id) { 915 case 0x400c: 916 PWC_INFO("Creative Labs Webcam 5 detected.\n"); 917 name = "Creative Labs Webcam 5"; 918 type_id = 730; 919 if (my_power_save == -1) 920 my_power_save = 1; 921 break; 922 case 0x4011: 923 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n"); 924 name = "Creative Labs Webcam Pro Ex"; 925 type_id = 740; 926 break; 927 default: 928 return -ENODEV; 929 break; 930 } 931 } 932 else if (vendor_id == 0x04cc) { 933 switch(product_id) { 934 case 0x8116: 935 PWC_INFO("Sotec Afina Eye USB webcam detected.\n"); 936 name = "Sotec Afina Eye"; 937 type_id = 730; 938 break; 939 default: 940 return -ENODEV; 941 break; 942 } 943 } 944 else if (vendor_id == 0x06be) { 945 switch(product_id) { 946 case 0x8116: 947 /* This is essentially the same cam as the Sotec Afina Eye */ 948 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n"); 949 name = "AME Co. Afina Eye"; 950 type_id = 750; 951 break; 952 default: 953 return -ENODEV; 954 break; 955 } 956 957 } 958 else if (vendor_id == 0x0d81) { 959 switch(product_id) { 960 case 0x1900: 961 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n"); 962 name = "Visionite VCS-UC300"; 963 type_id = 740; /* CCD sensor */ 964 break; 965 case 0x1910: 966 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n"); 967 name = "Visionite VCS-UM100"; 968 type_id = 730; /* CMOS sensor */ 969 break; 970 default: 971 return -ENODEV; 972 break; 973 } 974 } 975 else 976 return -ENODEV; /* Not any of the know types; but the list keeps growing. */ 977 978 if (my_power_save == -1) 979 my_power_save = 0; 980 981 memset(serial_number, 0, 30); 982 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29); 983 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number); 984 985 if (udev->descriptor.bNumConfigurations > 1) 986 PWC_WARNING("Warning: more than 1 configuration available.\n"); 987 988 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */ 989 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL); 990 if (pdev == NULL) { 991 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n"); 992 return -ENOMEM; 993 } 994 pdev->type = type_id; 995 pdev->features = features; 996 pwc_construct(pdev); /* set min/max sizes correct */ 997 998 mutex_init(&pdev->v4l2_lock); 999 mutex_init(&pdev->vb_queue_lock); 1000 spin_lock_init(&pdev->queued_bufs_lock); 1001 INIT_LIST_HEAD(&pdev->queued_bufs); 1002 1003 pdev->udev = udev; 1004 pdev->power_save = my_power_save; 1005 1006 /* Init videobuf2 queue structure */ 1007 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1008 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ; 1009 pdev->vb_queue.drv_priv = pdev; 1010 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf); 1011 pdev->vb_queue.ops = &pwc_vb_queue_ops; 1012 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops; 1013 pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1014 rc = vb2_queue_init(&pdev->vb_queue); 1015 if (rc < 0) { 1016 PWC_ERROR("Oops, could not initialize vb2 queue.\n"); 1017 goto err_free_mem; 1018 } 1019 1020 /* Init video_device structure */ 1021 pdev->vdev = pwc_template; 1022 strcpy(pdev->vdev.name, name); 1023 pdev->vdev.queue = &pdev->vb_queue; 1024 pdev->vdev.queue->lock = &pdev->vb_queue_lock; 1025 video_set_drvdata(&pdev->vdev, pdev); 1026 1027 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice); 1028 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release); 1029 1030 /* Allocate USB command buffers */ 1031 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL); 1032 if (!pdev->ctrl_buf) { 1033 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n"); 1034 rc = -ENOMEM; 1035 goto err_free_mem; 1036 } 1037 1038#ifdef CONFIG_USB_PWC_DEBUG 1039 /* Query sensor type */ 1040 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) { 1041 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n", 1042 pdev->vdev.name, 1043 pwc_sensor_type_to_string(rc), rc); 1044 } 1045#endif 1046 1047 /* Set the leds off */ 1048 pwc_set_leds(pdev, 0, 0); 1049 1050 /* Setup initial videomode */ 1051 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT, 1052 V4L2_PIX_FMT_YUV420, 30, &compression, 1); 1053 if (rc) 1054 goto err_free_mem; 1055 1056 /* Register controls (and read default values from camera */ 1057 rc = pwc_init_controls(pdev); 1058 if (rc) { 1059 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc); 1060 goto err_free_mem; 1061 } 1062 1063 /* And powerdown the camera until streaming starts */ 1064 pwc_camera_power(pdev, 0); 1065 1066 /* Register the v4l2_device structure */ 1067 pdev->v4l2_dev.release = pwc_video_release; 1068 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev); 1069 if (rc) { 1070 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc); 1071 goto err_free_controls; 1072 } 1073 1074 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler; 1075 pdev->vdev.v4l2_dev = &pdev->v4l2_dev; 1076 pdev->vdev.lock = &pdev->v4l2_lock; 1077 1078 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1); 1079 if (rc < 0) { 1080 PWC_ERROR("Failed to register as video device (%d).\n", rc); 1081 goto err_unregister_v4l2_dev; 1082 } 1083 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev)); 1084 1085#ifdef CONFIG_USB_PWC_INPUT_EVDEV 1086 /* register webcam snapshot button input device */ 1087 pdev->button_dev = input_allocate_device(); 1088 if (!pdev->button_dev) { 1089 rc = -ENOMEM; 1090 goto err_video_unreg; 1091 } 1092 1093 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys)); 1094 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys)); 1095 1096 pdev->button_dev->name = "PWC snapshot button"; 1097 pdev->button_dev->phys = pdev->button_phys; 1098 usb_to_input_id(pdev->udev, &pdev->button_dev->id); 1099 pdev->button_dev->dev.parent = &pdev->udev->dev; 1100 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY); 1101 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA); 1102 1103 rc = input_register_device(pdev->button_dev); 1104 if (rc) { 1105 input_free_device(pdev->button_dev); 1106 pdev->button_dev = NULL; 1107 goto err_video_unreg; 1108 } 1109#endif 1110 1111 return 0; 1112 1113err_video_unreg: 1114 video_unregister_device(&pdev->vdev); 1115err_unregister_v4l2_dev: 1116 v4l2_device_unregister(&pdev->v4l2_dev); 1117err_free_controls: 1118 v4l2_ctrl_handler_free(&pdev->ctrl_handler); 1119err_free_mem: 1120 kfree(pdev->ctrl_buf); 1121 kfree(pdev); 1122 return rc; 1123} 1124 1125/* The user yanked out the cable... */ 1126static void usb_pwc_disconnect(struct usb_interface *intf) 1127{ 1128 struct v4l2_device *v = usb_get_intfdata(intf); 1129 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev); 1130 1131 mutex_lock(&pdev->vb_queue_lock); 1132 mutex_lock(&pdev->v4l2_lock); 1133 /* No need to keep the urbs around after disconnection */ 1134 if (pdev->vb_queue.streaming) 1135 pwc_isoc_cleanup(pdev); 1136 pdev->udev = NULL; 1137 1138 v4l2_device_disconnect(&pdev->v4l2_dev); 1139 video_unregister_device(&pdev->vdev); 1140 mutex_unlock(&pdev->v4l2_lock); 1141 mutex_unlock(&pdev->vb_queue_lock); 1142 1143#ifdef CONFIG_USB_PWC_INPUT_EVDEV 1144 if (pdev->button_dev) 1145 input_unregister_device(pdev->button_dev); 1146#endif 1147 1148 v4l2_device_put(&pdev->v4l2_dev); 1149} 1150 1151 1152/* 1153 * Initialization code & module stuff 1154 */ 1155 1156static unsigned int leds_nargs; 1157 1158#ifdef CONFIG_USB_PWC_DEBUG 1159module_param_named(trace, pwc_trace, int, 0644); 1160#endif 1161module_param(power_save, int, 0644); 1162module_param_array(leds, int, &leds_nargs, 0444); 1163 1164#ifdef CONFIG_USB_PWC_DEBUG 1165MODULE_PARM_DESC(trace, "For debugging purposes"); 1166#endif 1167MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off"); 1168MODULE_PARM_DESC(leds, "LED on,off time in milliseconds"); 1169 1170MODULE_DESCRIPTION("Philips & OEM USB webcam driver"); 1171MODULE_AUTHOR("Luc Saillard <luc@saillard.org>"); 1172MODULE_LICENSE("GPL"); 1173MODULE_ALIAS("pwcx"); 1174MODULE_VERSION( PWC_VERSION ); 1175 1176module_usb_driver(pwc_driver); 1177