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