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.field = V4L2_FIELD_NONE; 245 fbuf->vb.sequence = pdev->vframe_count; 246 vb2_buffer_done(&fbuf->vb.vb2_buf, VB2_BUF_STATE_DONE); 247 pdev->fill_buf = NULL; 248 pdev->vsync = 0; 249 } 250 } /* !drop_frames */ 251 pdev->vframe_count++; 252} 253 254/* This gets called for the Isochronous pipe (video). This is done in 255 * interrupt time, so it has to be fast, not crash, and not stall. Neat. 256 */ 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.vb2_buf, 292 VB2_BUF_STATE_ERROR); 293 pdev->fill_buf = NULL; 294 } 295 } 296 pdev->vsync = 0; /* Drop the current frame */ 297 goto handler_end; 298 } 299 300 /* Reset ISOC error counter. We did get here, after all. */ 301 pdev->visoc_errors = 0; 302 303 /* vsync: 0 = don't copy data 304 1 = sync-hunt 305 2 = synched 306 */ 307 /* Compact data */ 308 for (i = 0; i < urb->number_of_packets; i++) { 309 fst = urb->iso_frame_desc[i].status; 310 flen = urb->iso_frame_desc[i].actual_length; 311 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset; 312 if (fst != 0) { 313 PWC_ERROR("Iso frame %d has error %d\n", i, fst); 314 continue; 315 } 316 if (flen > 0 && pdev->vsync) { 317 struct pwc_frame_buf *fbuf = pdev->fill_buf; 318 319 if (pdev->vsync == 1) { 320 v4l2_get_timestamp( 321 &fbuf->vb.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.vb2_buf, 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 void *parg, 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 vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 599 struct pwc_frame_buf *buf = 600 container_of(vbuf, struct pwc_frame_buf, vb); 601 602 /* need vmalloc since frame buffer > 128K */ 603 buf->data = vzalloc(PWC_FRAME_SIZE); 604 if (buf->data == NULL) 605 return -ENOMEM; 606 607 return 0; 608} 609 610static int buffer_prepare(struct vb2_buffer *vb) 611{ 612 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue); 613 614 /* Don't allow queing new buffers after device disconnection */ 615 if (!pdev->udev) 616 return -ENODEV; 617 618 return 0; 619} 620 621static void buffer_finish(struct vb2_buffer *vb) 622{ 623 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue); 624 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 625 struct pwc_frame_buf *buf = 626 container_of(vbuf, struct pwc_frame_buf, vb); 627 628 if (vb->state == VB2_BUF_STATE_DONE) { 629 /* 630 * Application has called dqbuf and is getting back a buffer 631 * we've filled, take the pwc data we've stored in buf->data 632 * and decompress it into a usable format, storing the result 633 * in the vb2_buffer. 634 */ 635 pwc_decompress(pdev, buf); 636 } 637} 638 639static void buffer_cleanup(struct vb2_buffer *vb) 640{ 641 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 642 struct pwc_frame_buf *buf = 643 container_of(vbuf, struct pwc_frame_buf, vb); 644 645 vfree(buf->data); 646} 647 648static void buffer_queue(struct vb2_buffer *vb) 649{ 650 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue); 651 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 652 struct pwc_frame_buf *buf = 653 container_of(vbuf, struct pwc_frame_buf, vb); 654 unsigned long flags = 0; 655 656 /* Check the device has not disconnected between prep and queuing */ 657 if (!pdev->udev) { 658 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR); 659 return; 660 } 661 662 spin_lock_irqsave(&pdev->queued_bufs_lock, flags); 663 list_add_tail(&buf->list, &pdev->queued_bufs); 664 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags); 665} 666 667static int start_streaming(struct vb2_queue *vq, unsigned int count) 668{ 669 struct pwc_device *pdev = vb2_get_drv_priv(vq); 670 int r; 671 672 if (!pdev->udev) 673 return -ENODEV; 674 675 if (mutex_lock_interruptible(&pdev->v4l2_lock)) 676 return -ERESTARTSYS; 677 /* Turn on camera and set LEDS on */ 678 pwc_camera_power(pdev, 1); 679 pwc_set_leds(pdev, leds[0], leds[1]); 680 681 r = pwc_isoc_init(pdev); 682 if (r) { 683 /* If we failed turn camera and LEDS back off */ 684 pwc_set_leds(pdev, 0, 0); 685 pwc_camera_power(pdev, 0); 686 /* And cleanup any queued bufs!! */ 687 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED); 688 } 689 mutex_unlock(&pdev->v4l2_lock); 690 691 return r; 692} 693 694static void stop_streaming(struct vb2_queue *vq) 695{ 696 struct pwc_device *pdev = vb2_get_drv_priv(vq); 697 698 mutex_lock(&pdev->v4l2_lock); 699 if (pdev->udev) { 700 pwc_set_leds(pdev, 0, 0); 701 pwc_camera_power(pdev, 0); 702 pwc_isoc_cleanup(pdev); 703 } 704 705 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR); 706 if (pdev->fill_buf) 707 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf, 708 VB2_BUF_STATE_ERROR); 709 mutex_unlock(&pdev->v4l2_lock); 710} 711 712static struct vb2_ops pwc_vb_queue_ops = { 713 .queue_setup = queue_setup, 714 .buf_init = buffer_init, 715 .buf_prepare = buffer_prepare, 716 .buf_finish = buffer_finish, 717 .buf_cleanup = buffer_cleanup, 718 .buf_queue = buffer_queue, 719 .start_streaming = start_streaming, 720 .stop_streaming = stop_streaming, 721 .wait_prepare = vb2_ops_wait_prepare, 722 .wait_finish = vb2_ops_wait_finish, 723}; 724 725/***************************************************************************/ 726/* USB functions */ 727 728/* This function gets called when a new device is plugged in or the usb core 729 * is loaded. 730 */ 731 732static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id) 733{ 734 struct usb_device *udev = interface_to_usbdev(intf); 735 struct pwc_device *pdev = NULL; 736 int vendor_id, product_id, type_id; 737 int rc; 738 int features = 0; 739 int compression = 0; 740 int my_power_save = power_save; 741 char serial_number[30], *name; 742 743 vendor_id = le16_to_cpu(udev->descriptor.idVendor); 744 product_id = le16_to_cpu(udev->descriptor.idProduct); 745 746 /* Check if we can handle this device */ 747 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n", 748 vendor_id, product_id, 749 intf->altsetting->desc.bInterfaceNumber); 750 751 /* the interfaces are probed one by one. We are only interested in the 752 video interface (0) now. 753 Interface 1 is the Audio Control, and interface 2 Audio itself. 754 */ 755 if (intf->altsetting->desc.bInterfaceNumber > 0) 756 return -ENODEV; 757 758 if (vendor_id == 0x0471) { 759 switch (product_id) { 760 case 0x0302: 761 PWC_INFO("Philips PCA645VC USB webcam detected.\n"); 762 name = "Philips 645 webcam"; 763 type_id = 645; 764 break; 765 case 0x0303: 766 PWC_INFO("Philips PCA646VC USB webcam detected.\n"); 767 name = "Philips 646 webcam"; 768 type_id = 646; 769 break; 770 case 0x0304: 771 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n"); 772 name = "Askey VC010 webcam"; 773 type_id = 646; 774 break; 775 case 0x0307: 776 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n"); 777 name = "Philips 675 webcam"; 778 type_id = 675; 779 break; 780 case 0x0308: 781 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n"); 782 name = "Philips 680 webcam"; 783 type_id = 680; 784 break; 785 case 0x030C: 786 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n"); 787 name = "Philips 690 webcam"; 788 type_id = 690; 789 break; 790 case 0x0310: 791 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n"); 792 name = "Philips 730 webcam"; 793 type_id = 730; 794 break; 795 case 0x0311: 796 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n"); 797 name = "Philips 740 webcam"; 798 type_id = 740; 799 break; 800 case 0x0312: 801 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n"); 802 name = "Philips 750 webcam"; 803 type_id = 750; 804 break; 805 case 0x0313: 806 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n"); 807 name = "Philips 720K/40 webcam"; 808 type_id = 720; 809 break; 810 case 0x0329: 811 PWC_INFO("Philips SPC 900NC USB webcam detected.\n"); 812 name = "Philips SPC 900NC webcam"; 813 type_id = 740; 814 break; 815 case 0x032C: 816 PWC_INFO("Philips SPC 880NC USB webcam detected.\n"); 817 name = "Philips SPC 880NC webcam"; 818 type_id = 740; 819 break; 820 default: 821 return -ENODEV; 822 break; 823 } 824 } 825 else if (vendor_id == 0x069A) { 826 switch(product_id) { 827 case 0x0001: 828 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n"); 829 name = "Askey VC010 webcam"; 830 type_id = 645; 831 break; 832 default: 833 return -ENODEV; 834 break; 835 } 836 } 837 else if (vendor_id == 0x046d) { 838 switch(product_id) { 839 case 0x08b0: 840 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n"); 841 name = "Logitech QuickCam Pro 3000"; 842 type_id = 740; /* CCD sensor */ 843 break; 844 case 0x08b1: 845 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n"); 846 name = "Logitech QuickCam Notebook Pro"; 847 type_id = 740; /* CCD sensor */ 848 break; 849 case 0x08b2: 850 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n"); 851 name = "Logitech QuickCam Pro 4000"; 852 type_id = 740; /* CCD sensor */ 853 if (my_power_save == -1) 854 my_power_save = 1; 855 break; 856 case 0x08b3: 857 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n"); 858 name = "Logitech QuickCam Zoom"; 859 type_id = 740; /* CCD sensor */ 860 break; 861 case 0x08B4: 862 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n"); 863 name = "Logitech QuickCam Zoom"; 864 type_id = 740; /* CCD sensor */ 865 if (my_power_save == -1) 866 my_power_save = 1; 867 break; 868 case 0x08b5: 869 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n"); 870 name = "Logitech QuickCam Orbit"; 871 type_id = 740; /* CCD sensor */ 872 if (my_power_save == -1) 873 my_power_save = 1; 874 features |= FEATURE_MOTOR_PANTILT; 875 break; 876 case 0x08b6: 877 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n"); 878 name = "Cisco VT Camera"; 879 type_id = 740; /* CCD sensor */ 880 break; 881 case 0x08b7: 882 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n"); 883 name = "Logitech ViewPort AV 100"; 884 type_id = 740; /* CCD sensor */ 885 break; 886 case 0x08b8: /* Where this released? */ 887 PWC_INFO("Logitech QuickCam detected (reserved ID).\n"); 888 name = "Logitech QuickCam (res.)"; 889 type_id = 730; /* Assuming CMOS */ 890 break; 891 default: 892 return -ENODEV; 893 break; 894 } 895 } 896 else if (vendor_id == 0x055d) { 897 /* I don't know the difference between the C10 and the C30; 898 I suppose the difference is the sensor, but both cameras 899 work equally well with a type_id of 675 900 */ 901 switch(product_id) { 902 case 0x9000: 903 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n"); 904 name = "Samsung MPC-C10"; 905 type_id = 675; 906 break; 907 case 0x9001: 908 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n"); 909 name = "Samsung MPC-C30"; 910 type_id = 675; 911 break; 912 case 0x9002: 913 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n"); 914 name = "Samsung MPC-C30"; 915 type_id = 740; 916 break; 917 default: 918 return -ENODEV; 919 break; 920 } 921 } 922 else if (vendor_id == 0x041e) { 923 switch(product_id) { 924 case 0x400c: 925 PWC_INFO("Creative Labs Webcam 5 detected.\n"); 926 name = "Creative Labs Webcam 5"; 927 type_id = 730; 928 if (my_power_save == -1) 929 my_power_save = 1; 930 break; 931 case 0x4011: 932 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n"); 933 name = "Creative Labs Webcam Pro Ex"; 934 type_id = 740; 935 break; 936 default: 937 return -ENODEV; 938 break; 939 } 940 } 941 else if (vendor_id == 0x04cc) { 942 switch(product_id) { 943 case 0x8116: 944 PWC_INFO("Sotec Afina Eye USB webcam detected.\n"); 945 name = "Sotec Afina Eye"; 946 type_id = 730; 947 break; 948 default: 949 return -ENODEV; 950 break; 951 } 952 } 953 else if (vendor_id == 0x06be) { 954 switch(product_id) { 955 case 0x8116: 956 /* This is essentially the same cam as the Sotec Afina Eye */ 957 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n"); 958 name = "AME Co. Afina Eye"; 959 type_id = 750; 960 break; 961 default: 962 return -ENODEV; 963 break; 964 } 965 966 } 967 else if (vendor_id == 0x0d81) { 968 switch(product_id) { 969 case 0x1900: 970 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n"); 971 name = "Visionite VCS-UC300"; 972 type_id = 740; /* CCD sensor */ 973 break; 974 case 0x1910: 975 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n"); 976 name = "Visionite VCS-UM100"; 977 type_id = 730; /* CMOS sensor */ 978 break; 979 default: 980 return -ENODEV; 981 break; 982 } 983 } 984 else 985 return -ENODEV; /* Not any of the know types; but the list keeps growing. */ 986 987 if (my_power_save == -1) 988 my_power_save = 0; 989 990 memset(serial_number, 0, 30); 991 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29); 992 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number); 993 994 if (udev->descriptor.bNumConfigurations > 1) 995 PWC_WARNING("Warning: more than 1 configuration available.\n"); 996 997 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */ 998 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL); 999 if (pdev == NULL) { 1000 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n"); 1001 return -ENOMEM; 1002 } 1003 pdev->type = type_id; 1004 pdev->features = features; 1005 pwc_construct(pdev); /* set min/max sizes correct */ 1006 1007 mutex_init(&pdev->v4l2_lock); 1008 mutex_init(&pdev->vb_queue_lock); 1009 spin_lock_init(&pdev->queued_bufs_lock); 1010 INIT_LIST_HEAD(&pdev->queued_bufs); 1011 1012 pdev->udev = udev; 1013 pdev->power_save = my_power_save; 1014 1015 /* Init videobuf2 queue structure */ 1016 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1017 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ; 1018 pdev->vb_queue.drv_priv = pdev; 1019 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf); 1020 pdev->vb_queue.ops = &pwc_vb_queue_ops; 1021 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops; 1022 pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1023 rc = vb2_queue_init(&pdev->vb_queue); 1024 if (rc < 0) { 1025 PWC_ERROR("Oops, could not initialize vb2 queue.\n"); 1026 goto err_free_mem; 1027 } 1028 1029 /* Init video_device structure */ 1030 pdev->vdev = pwc_template; 1031 strcpy(pdev->vdev.name, name); 1032 pdev->vdev.queue = &pdev->vb_queue; 1033 pdev->vdev.queue->lock = &pdev->vb_queue_lock; 1034 video_set_drvdata(&pdev->vdev, pdev); 1035 1036 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice); 1037 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release); 1038 1039 /* Allocate USB command buffers */ 1040 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL); 1041 if (!pdev->ctrl_buf) { 1042 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n"); 1043 rc = -ENOMEM; 1044 goto err_free_mem; 1045 } 1046 1047#ifdef CONFIG_USB_PWC_DEBUG 1048 /* Query sensor type */ 1049 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) { 1050 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n", 1051 pdev->vdev.name, 1052 pwc_sensor_type_to_string(rc), rc); 1053 } 1054#endif 1055 1056 /* Set the leds off */ 1057 pwc_set_leds(pdev, 0, 0); 1058 1059 /* Setup initial videomode */ 1060 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT, 1061 V4L2_PIX_FMT_YUV420, 30, &compression, 1); 1062 if (rc) 1063 goto err_free_mem; 1064 1065 /* Register controls (and read default values from camera */ 1066 rc = pwc_init_controls(pdev); 1067 if (rc) { 1068 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc); 1069 goto err_free_mem; 1070 } 1071 1072 /* And powerdown the camera until streaming starts */ 1073 pwc_camera_power(pdev, 0); 1074 1075 /* Register the v4l2_device structure */ 1076 pdev->v4l2_dev.release = pwc_video_release; 1077 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev); 1078 if (rc) { 1079 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc); 1080 goto err_free_controls; 1081 } 1082 1083 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler; 1084 pdev->vdev.v4l2_dev = &pdev->v4l2_dev; 1085 pdev->vdev.lock = &pdev->v4l2_lock; 1086 1087 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1); 1088 if (rc < 0) { 1089 PWC_ERROR("Failed to register as video device (%d).\n", rc); 1090 goto err_unregister_v4l2_dev; 1091 } 1092 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev)); 1093 1094#ifdef CONFIG_USB_PWC_INPUT_EVDEV 1095 /* register webcam snapshot button input device */ 1096 pdev->button_dev = input_allocate_device(); 1097 if (!pdev->button_dev) { 1098 rc = -ENOMEM; 1099 goto err_video_unreg; 1100 } 1101 1102 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys)); 1103 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys)); 1104 1105 pdev->button_dev->name = "PWC snapshot button"; 1106 pdev->button_dev->phys = pdev->button_phys; 1107 usb_to_input_id(pdev->udev, &pdev->button_dev->id); 1108 pdev->button_dev->dev.parent = &pdev->udev->dev; 1109 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY); 1110 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA); 1111 1112 rc = input_register_device(pdev->button_dev); 1113 if (rc) { 1114 input_free_device(pdev->button_dev); 1115 pdev->button_dev = NULL; 1116 goto err_video_unreg; 1117 } 1118#endif 1119 1120 return 0; 1121 1122err_video_unreg: 1123 video_unregister_device(&pdev->vdev); 1124err_unregister_v4l2_dev: 1125 v4l2_device_unregister(&pdev->v4l2_dev); 1126err_free_controls: 1127 v4l2_ctrl_handler_free(&pdev->ctrl_handler); 1128err_free_mem: 1129 kfree(pdev->ctrl_buf); 1130 kfree(pdev); 1131 return rc; 1132} 1133 1134/* The user yanked out the cable... */ 1135static void usb_pwc_disconnect(struct usb_interface *intf) 1136{ 1137 struct v4l2_device *v = usb_get_intfdata(intf); 1138 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev); 1139 1140 mutex_lock(&pdev->vb_queue_lock); 1141 mutex_lock(&pdev->v4l2_lock); 1142 /* No need to keep the urbs around after disconnection */ 1143 if (pdev->vb_queue.streaming) 1144 pwc_isoc_cleanup(pdev); 1145 pdev->udev = NULL; 1146 1147 v4l2_device_disconnect(&pdev->v4l2_dev); 1148 video_unregister_device(&pdev->vdev); 1149 mutex_unlock(&pdev->v4l2_lock); 1150 mutex_unlock(&pdev->vb_queue_lock); 1151 1152#ifdef CONFIG_USB_PWC_INPUT_EVDEV 1153 if (pdev->button_dev) 1154 input_unregister_device(pdev->button_dev); 1155#endif 1156 1157 v4l2_device_put(&pdev->v4l2_dev); 1158} 1159 1160 1161/* 1162 * Initialization code & module stuff 1163 */ 1164 1165static unsigned int leds_nargs; 1166 1167#ifdef CONFIG_USB_PWC_DEBUG 1168module_param_named(trace, pwc_trace, int, 0644); 1169#endif 1170module_param(power_save, int, 0644); 1171module_param_array(leds, int, &leds_nargs, 0444); 1172 1173#ifdef CONFIG_USB_PWC_DEBUG 1174MODULE_PARM_DESC(trace, "For debugging purposes"); 1175#endif 1176MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off"); 1177MODULE_PARM_DESC(leds, "LED on,off time in milliseconds"); 1178 1179MODULE_DESCRIPTION("Philips & OEM USB webcam driver"); 1180MODULE_AUTHOR("Luc Saillard <luc@saillard.org>"); 1181MODULE_LICENSE("GPL"); 1182MODULE_ALIAS("pwcx"); 1183MODULE_VERSION( PWC_VERSION ); 1184 1185module_usb_driver(pwc_driver); 1186