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