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 6 NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx 7 driver and thus may have bugs that are not present in the original version. 8 Please send bug reports and support requests to <luc@saillard.org>. 9 The decompression routines have been implemented by reverse-engineering the 10 Nemosoft binary pwcx module. Caveat emptor. 11 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; either version 2 of the License, or 15 (at your option) any later version. 16 17 This program is distributed in the hope that it will be useful, 18 but WITHOUT ANY WARRANTY; without even the implied warranty of 19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 GNU General Public License for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with this program; if not, write to the Free Software 24 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 25 26*/ 27 28/* 29 This code forms the interface between the USB layers and the Philips 30 specific stuff. Some adanved stuff of the driver falls under an 31 NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and 32 is thus not distributed in source form. The binary pwcx.o module 33 contains the code that falls under the NDA. 34 35 In case you're wondering: 'pwc' stands for "Philips WebCam", but 36 I really didn't want to type 'philips_web_cam' every time (I'm lazy as 37 any Linux kernel hacker, but I don't like uncomprehensible abbreviations 38 without explanation). 39 40 Oh yes, convention: to disctinguish between all the various pointers to 41 device-structures, I use these names for the pointer variables: 42 udev: struct usb_device * 43 vdev: struct video_device * 44 pdev: struct pwc_devive * 45*/ 46 47/* Contributors: 48 - Alvarado: adding whitebalance code 49 - Alistar Moire: QuickCam 3000 Pro device/product ID 50 - Tony Hoyle: Creative Labs Webcam 5 device/product ID 51 - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged 52 - Jk Fang: Sotec Afina Eye ID 53 - Xavier Roche: QuickCam Pro 4000 ID 54 - Jens Knudsen: QuickCam Zoom ID 55 - J. Debert: QuickCam for Notebooks ID 56 - Pham Thanh Nam: webcam snapshot button as an event input device 57*/ 58 59#include <linux/errno.h> 60#include <linux/init.h> 61#include <linux/mm.h> 62#include <linux/module.h> 63#include <linux/poll.h> 64#include <linux/slab.h> 65#include <linux/smp_lock.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#include "pwc-uncompress.h" 79 80/* Function prototypes and driver templates */ 81 82/* hotplug device table support */ 83static const struct usb_device_id pwc_device_table [] = { 84 { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */ 85 { USB_DEVICE(0x0471, 0x0303) }, 86 { USB_DEVICE(0x0471, 0x0304) }, 87 { USB_DEVICE(0x0471, 0x0307) }, 88 { USB_DEVICE(0x0471, 0x0308) }, 89 { USB_DEVICE(0x0471, 0x030C) }, 90 { USB_DEVICE(0x0471, 0x0310) }, 91 { USB_DEVICE(0x0471, 0x0311) }, /* Philips ToUcam PRO II */ 92 { USB_DEVICE(0x0471, 0x0312) }, 93 { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */ 94 { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC 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); 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 131static int default_size = PSZ_QCIF; 132static int default_fps = 10; 133static int default_fbufs = 3; /* Default number of frame buffers */ 134 int pwc_mbufs = 2; /* Default number of mmap() buffers */ 135#ifdef CONFIG_USB_PWC_DEBUG 136 int pwc_trace = PWC_DEBUG_LEVEL; 137#endif 138static int power_save; 139static int led_on = 100, led_off; /* defaults to LED that is on while in use */ 140static int pwc_preferred_compression = 1; /* 0..3 = uncompressed..high */ 141static struct { 142 int type; 143 char serial_number[30]; 144 int device_node; 145 struct pwc_device *pdev; 146} device_hint[MAX_DEV_HINTS]; 147 148/***/ 149 150static int pwc_video_open(struct file *file); 151static int pwc_video_close(struct file *file); 152static ssize_t pwc_video_read(struct file *file, char __user *buf, 153 size_t count, loff_t *ppos); 154static unsigned int pwc_video_poll(struct file *file, poll_table *wait); 155static long pwc_video_ioctl(struct file *file, 156 unsigned int ioctlnr, unsigned long arg); 157static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma); 158 159static const struct v4l2_file_operations pwc_fops = { 160 .owner = THIS_MODULE, 161 .open = pwc_video_open, 162 .release = pwc_video_close, 163 .read = pwc_video_read, 164 .poll = pwc_video_poll, 165 .mmap = pwc_video_mmap, 166 .ioctl = pwc_video_ioctl, 167}; 168static struct video_device pwc_template = { 169 .name = "Philips Webcam", /* Filled in later */ 170 .release = video_device_release, 171 .fops = &pwc_fops, 172}; 173 174/***************************************************************************/ 175 176/* Okay, this is some magic that I worked out and the reasoning behind it... 177 178 The biggest problem with any USB device is of course: "what to do 179 when the user unplugs the device while it is in use by an application?" 180 We have several options: 181 1) Curse them with the 7 plagues when they do (requires divine intervention) 182 2) Tell them not to (won't work: they'll do it anyway) 183 3) Oops the kernel (this will have a negative effect on a user's uptime) 184 4) Do something sensible. 185 186 Of course, we go for option 4. 187 188 It happens that this device will be linked to two times, once from 189 usb_device and once from the video_device in their respective 'private' 190 pointers. This is done when the device is probed() and all initialization 191 succeeded. The pwc_device struct links back to both structures. 192 193 When a device is unplugged while in use it will be removed from the 194 list of known USB devices; I also de-register it as a V4L device, but 195 unfortunately I can't free the memory since the struct is still in use 196 by the file descriptor. This free-ing is then deferend until the first 197 opportunity. Crude, but it works. 198 199 A small 'advantage' is that if a user unplugs the cam and plugs it back 200 in, it should get assigned the same video device minor, but unfortunately 201 it's non-trivial to re-link the cam back to the video device... (that 202 would surely be magic! :)) 203*/ 204 205/***************************************************************************/ 206/* Private functions */ 207 208/* Here we want the physical address of the memory. 209 * This is used when initializing the contents of the area. 210 */ 211 212 213 214static void *pwc_rvmalloc(unsigned long size) 215{ 216 void * mem; 217 unsigned long adr; 218 219 mem=vmalloc_32(size); 220 if (!mem) 221 return NULL; 222 223 memset(mem, 0, size); /* Clear the ram out, no junk to the user */ 224 adr=(unsigned long) mem; 225 while (size > 0) 226 { 227 SetPageReserved(vmalloc_to_page((void *)adr)); 228 adr += PAGE_SIZE; 229 size -= PAGE_SIZE; 230 } 231 return mem; 232} 233 234static void pwc_rvfree(void * mem, unsigned long size) 235{ 236 unsigned long adr; 237 238 if (!mem) 239 return; 240 241 adr=(unsigned long) mem; 242 while ((long) size > 0) 243 { 244 ClearPageReserved(vmalloc_to_page((void *)adr)); 245 adr += PAGE_SIZE; 246 size -= PAGE_SIZE; 247 } 248 vfree(mem); 249} 250 251 252 253 254static int pwc_allocate_buffers(struct pwc_device *pdev) 255{ 256 int i, err; 257 void *kbuf; 258 259 PWC_DEBUG_MEMORY(">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev); 260 261 if (pdev == NULL) 262 return -ENXIO; 263 264 /* Allocate Isochronuous pipe buffers */ 265 for (i = 0; i < MAX_ISO_BUFS; i++) { 266 if (pdev->sbuf[i].data == NULL) { 267 kbuf = kzalloc(ISO_BUFFER_SIZE, GFP_KERNEL); 268 if (kbuf == NULL) { 269 PWC_ERROR("Failed to allocate iso buffer %d.\n", i); 270 return -ENOMEM; 271 } 272 PWC_DEBUG_MEMORY("Allocated iso buffer at %p.\n", kbuf); 273 pdev->sbuf[i].data = kbuf; 274 } 275 } 276 277 /* Allocate frame buffer structure */ 278 if (pdev->fbuf == NULL) { 279 kbuf = kzalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL); 280 if (kbuf == NULL) { 281 PWC_ERROR("Failed to allocate frame buffer structure.\n"); 282 return -ENOMEM; 283 } 284 PWC_DEBUG_MEMORY("Allocated frame buffer structure at %p.\n", kbuf); 285 pdev->fbuf = kbuf; 286 } 287 288 /* create frame buffers, and make circular ring */ 289 for (i = 0; i < default_fbufs; i++) { 290 if (pdev->fbuf[i].data == NULL) { 291 kbuf = vmalloc(PWC_FRAME_SIZE); /* need vmalloc since frame buffer > 128K */ 292 if (kbuf == NULL) { 293 PWC_ERROR("Failed to allocate frame buffer %d.\n", i); 294 return -ENOMEM; 295 } 296 PWC_DEBUG_MEMORY("Allocated frame buffer %d at %p.\n", i, kbuf); 297 pdev->fbuf[i].data = kbuf; 298 memset(kbuf, 0, PWC_FRAME_SIZE); 299 } 300 } 301 302 /* Allocate decompressor table space */ 303 if (DEVICE_USE_CODEC1(pdev->type)) 304 err = pwc_dec1_alloc(pdev); 305 else 306 err = pwc_dec23_alloc(pdev); 307 308 if (err) { 309 PWC_ERROR("Failed to allocate decompress table.\n"); 310 return err; 311 } 312 313 /* Allocate image buffer; double buffer for mmap() */ 314 kbuf = pwc_rvmalloc(pwc_mbufs * pdev->len_per_image); 315 if (kbuf == NULL) { 316 PWC_ERROR("Failed to allocate image buffer(s). needed (%d)\n", 317 pwc_mbufs * pdev->len_per_image); 318 return -ENOMEM; 319 } 320 PWC_DEBUG_MEMORY("Allocated image buffer at %p.\n", kbuf); 321 pdev->image_data = kbuf; 322 for (i = 0; i < pwc_mbufs; i++) { 323 pdev->images[i].offset = i * pdev->len_per_image; 324 pdev->images[i].vma_use_count = 0; 325 } 326 for (; i < MAX_IMAGES; i++) { 327 pdev->images[i].offset = 0; 328 } 329 330 kbuf = NULL; 331 332 PWC_DEBUG_MEMORY("<< pwc_allocate_buffers()\n"); 333 return 0; 334} 335 336static void pwc_free_buffers(struct pwc_device *pdev) 337{ 338 int i; 339 340 PWC_DEBUG_MEMORY("Entering free_buffers(%p).\n", pdev); 341 342 if (pdev == NULL) 343 return; 344 /* Release Iso-pipe buffers */ 345 for (i = 0; i < MAX_ISO_BUFS; i++) 346 if (pdev->sbuf[i].data != NULL) { 347 PWC_DEBUG_MEMORY("Freeing ISO buffer at %p.\n", pdev->sbuf[i].data); 348 kfree(pdev->sbuf[i].data); 349 pdev->sbuf[i].data = NULL; 350 } 351 352 /* The same for frame buffers */ 353 if (pdev->fbuf != NULL) { 354 for (i = 0; i < default_fbufs; i++) { 355 if (pdev->fbuf[i].data != NULL) { 356 PWC_DEBUG_MEMORY("Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data); 357 vfree(pdev->fbuf[i].data); 358 pdev->fbuf[i].data = NULL; 359 } 360 } 361 kfree(pdev->fbuf); 362 pdev->fbuf = NULL; 363 } 364 365 /* Intermediate decompression buffer & tables */ 366 if (pdev->decompress_data != NULL) { 367 PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n", pdev->decompress_data); 368 kfree(pdev->decompress_data); 369 pdev->decompress_data = NULL; 370 } 371 372 /* Release image buffers */ 373 if (pdev->image_data != NULL) { 374 PWC_DEBUG_MEMORY("Freeing image buffer at %p.\n", pdev->image_data); 375 pwc_rvfree(pdev->image_data, pwc_mbufs * pdev->len_per_image); 376 } 377 pdev->image_data = NULL; 378 379 PWC_DEBUG_MEMORY("Leaving free_buffers().\n"); 380} 381 382/* The frame & image buffer mess. 383 384 Yes, this is a mess. Well, it used to be simple, but alas... In this 385 module, 3 buffers schemes are used to get the data from the USB bus to 386 the user program. The first scheme involves the ISO buffers (called thus 387 since they transport ISO data from the USB controller), and not really 388 interesting. Suffices to say the data from this buffer is quickly 389 gathered in an interrupt handler (pwc_isoc_handler) and placed into the 390 frame buffer. 391 392 The frame buffer is the second scheme, and is the central element here. 393 It collects the data from a single frame from the camera (hence, the 394 name). Frames are delimited by the USB camera with a short USB packet, 395 so that's easy to detect. The frame buffers form a list that is filled 396 by the camera+USB controller and drained by the user process through 397 either read() or mmap(). 398 399 The image buffer is the third scheme, in which frames are decompressed 400 and converted into planar format. For mmap() there is more than 401 one image buffer available. 402 403 The frame buffers provide the image buffering. In case the user process 404 is a bit slow, this introduces lag and some undesired side-effects. 405 The problem arises when the frame buffer is full. I used to drop the last 406 frame, which makes the data in the queue stale very quickly. But dropping 407 the frame at the head of the queue proved to be a litte bit more difficult. 408 I tried a circular linked scheme, but this introduced more problems than 409 it solved. 410 411 Because filling and draining are completely asynchronous processes, this 412 requires some fiddling with pointers and mutexes. 413 414 Eventually, I came up with a system with 2 lists: an 'empty' frame list 415 and a 'full' frame list: 416 * Initially, all frame buffers but one are on the 'empty' list; the one 417 remaining buffer is our initial fill frame. 418 * If a frame is needed for filling, we try to take it from the 'empty' 419 list, unless that list is empty, in which case we take the buffer at 420 the head of the 'full' list. 421 * When our fill buffer has been filled, it is appended to the 'full' 422 list. 423 * If a frame is needed by read() or mmap(), it is taken from the head of 424 the 'full' list, handled, and then appended to the 'empty' list. If no 425 buffer is present on the 'full' list, we wait. 426 The advantage is that the buffer that is currently being decompressed/ 427 converted, is on neither list, and thus not in our way (any other scheme 428 I tried had the problem of old data lingering in the queue). 429 430 Whatever strategy you choose, it always remains a tradeoff: with more 431 frame buffers the chances of a missed frame are reduced. On the other 432 hand, on slower machines it introduces lag because the queue will 433 always be full. 434 */ 435 436/** 437 \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first. 438 */ 439static int pwc_next_fill_frame(struct pwc_device *pdev) 440{ 441 int ret; 442 unsigned long flags; 443 444 ret = 0; 445 spin_lock_irqsave(&pdev->ptrlock, flags); 446 if (pdev->fill_frame != NULL) { 447 /* append to 'full' list */ 448 if (pdev->full_frames == NULL) { 449 pdev->full_frames = pdev->fill_frame; 450 pdev->full_frames_tail = pdev->full_frames; 451 } 452 else { 453 pdev->full_frames_tail->next = pdev->fill_frame; 454 pdev->full_frames_tail = pdev->fill_frame; 455 } 456 } 457 if (pdev->empty_frames != NULL) { 458 /* We have empty frames available. That's easy */ 459 pdev->fill_frame = pdev->empty_frames; 460 pdev->empty_frames = pdev->empty_frames->next; 461 } 462 else { 463 /* Hmm. Take it from the full list */ 464 /* sanity check */ 465 if (pdev->full_frames == NULL) { 466 PWC_ERROR("Neither empty or full frames available!\n"); 467 spin_unlock_irqrestore(&pdev->ptrlock, flags); 468 return -EINVAL; 469 } 470 pdev->fill_frame = pdev->full_frames; 471 pdev->full_frames = pdev->full_frames->next; 472 ret = 1; 473 } 474 pdev->fill_frame->next = NULL; 475 spin_unlock_irqrestore(&pdev->ptrlock, flags); 476 return ret; 477} 478 479 480/** 481 \brief Reset all buffers, pointers and lists, except for the image_used[] buffer. 482 483 If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble. 484 */ 485static void pwc_reset_buffers(struct pwc_device *pdev) 486{ 487 int i; 488 unsigned long flags; 489 490 PWC_DEBUG_MEMORY(">> %s __enter__\n", __func__); 491 492 spin_lock_irqsave(&pdev->ptrlock, flags); 493 pdev->full_frames = NULL; 494 pdev->full_frames_tail = NULL; 495 for (i = 0; i < default_fbufs; i++) { 496 pdev->fbuf[i].filled = 0; 497 if (i > 0) 498 pdev->fbuf[i].next = &pdev->fbuf[i - 1]; 499 else 500 pdev->fbuf->next = NULL; 501 } 502 pdev->empty_frames = &pdev->fbuf[default_fbufs - 1]; 503 pdev->empty_frames_tail = pdev->fbuf; 504 pdev->read_frame = NULL; 505 pdev->fill_frame = pdev->empty_frames; 506 pdev->empty_frames = pdev->empty_frames->next; 507 508 pdev->image_read_pos = 0; 509 pdev->fill_image = 0; 510 spin_unlock_irqrestore(&pdev->ptrlock, flags); 511 512 PWC_DEBUG_MEMORY("<< %s __leaving__\n", __func__); 513} 514 515 516/** 517 \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers. 518 */ 519int pwc_handle_frame(struct pwc_device *pdev) 520{ 521 int ret = 0; 522 unsigned long flags; 523 524 spin_lock_irqsave(&pdev->ptrlock, flags); 525 /* First grab our read_frame; this is removed from all lists, so 526 we can release the lock after this without problems */ 527 if (pdev->read_frame != NULL) { 528 /* This can't theoretically happen */ 529 PWC_ERROR("Huh? Read frame still in use?\n"); 530 spin_unlock_irqrestore(&pdev->ptrlock, flags); 531 return ret; 532 } 533 534 535 if (pdev->full_frames == NULL) { 536 PWC_ERROR("Woops. No frames ready.\n"); 537 } 538 else { 539 pdev->read_frame = pdev->full_frames; 540 pdev->full_frames = pdev->full_frames->next; 541 pdev->read_frame->next = NULL; 542 } 543 544 if (pdev->read_frame != NULL) { 545 /* Decompression is a lengthy process, so it's outside of the lock. 546 This gives the isoc_handler the opportunity to fill more frames 547 in the mean time. 548 */ 549 spin_unlock_irqrestore(&pdev->ptrlock, flags); 550 ret = pwc_decompress(pdev); 551 spin_lock_irqsave(&pdev->ptrlock, flags); 552 553 /* We're done with read_buffer, tack it to the end of the empty buffer list */ 554 if (pdev->empty_frames == NULL) { 555 pdev->empty_frames = pdev->read_frame; 556 pdev->empty_frames_tail = pdev->empty_frames; 557 } 558 else { 559 pdev->empty_frames_tail->next = pdev->read_frame; 560 pdev->empty_frames_tail = pdev->read_frame; 561 } 562 pdev->read_frame = NULL; 563 } 564 spin_unlock_irqrestore(&pdev->ptrlock, flags); 565 return ret; 566} 567 568/** 569 \brief Advance pointers of image buffer (after each user request) 570*/ 571void pwc_next_image(struct pwc_device *pdev) 572{ 573 pdev->image_used[pdev->fill_image] = 0; 574 pdev->fill_image = (pdev->fill_image + 1) % pwc_mbufs; 575} 576 577/** 578 * Print debug information when a frame is discarded because all of our buffer 579 * is full 580 */ 581static void pwc_frame_dumped(struct pwc_device *pdev) 582{ 583 pdev->vframes_dumped++; 584 if (pdev->vframe_count < FRAME_LOWMARK) 585 return; 586 587 if (pdev->vframes_dumped < 20) 588 PWC_DEBUG_FLOW("Dumping frame %d\n", pdev->vframe_count); 589 else if (pdev->vframes_dumped == 20) 590 PWC_DEBUG_FLOW("Dumping frame %d (last message)\n", 591 pdev->vframe_count); 592} 593 594static void pwc_snapshot_button(struct pwc_device *pdev, int down) 595{ 596 if (down) { 597 PWC_TRACE("Snapshot button pressed.\n"); 598 pdev->snapshot_button_status = 1; 599 } else { 600 PWC_TRACE("Snapshot button released.\n"); 601 } 602 603#ifdef CONFIG_USB_PWC_INPUT_EVDEV 604 if (pdev->button_dev) { 605 input_report_key(pdev->button_dev, KEY_CAMERA, down); 606 input_sync(pdev->button_dev); 607 } 608#endif 609} 610 611static int pwc_rcv_short_packet(struct pwc_device *pdev, const struct pwc_frame_buf *fbuf) 612{ 613 int awake = 0; 614 615 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus 616 frames on the USB wire after an exposure change. This conditition is 617 however detected in the cam and a bit is set in the header. 618 */ 619 if (pdev->type == 730) { 620 unsigned char *ptr = (unsigned char *)fbuf->data; 621 622 if (ptr[1] == 1 && ptr[0] & 0x10) { 623 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n"); 624 pdev->drop_frames += 2; 625 pdev->vframes_error++; 626 } 627 if ((ptr[0] ^ pdev->vmirror) & 0x01) { 628 pwc_snapshot_button(pdev, ptr[0] & 0x01); 629 } 630 if ((ptr[0] ^ pdev->vmirror) & 0x02) { 631 if (ptr[0] & 0x02) 632 PWC_TRACE("Image is mirrored.\n"); 633 else 634 PWC_TRACE("Image is normal.\n"); 635 } 636 pdev->vmirror = ptr[0] & 0x03; 637 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet 638 after a short frame; this condition is filtered out specifically. A 4 byte 639 frame doesn't make sense anyway. 640 So we get either this sequence: 641 drop_bit set -> 4 byte frame -> short frame -> good frame 642 Or this one: 643 drop_bit set -> short frame -> good frame 644 So we drop either 3 or 2 frames in all! 645 */ 646 if (fbuf->filled == 4) 647 pdev->drop_frames++; 648 } 649 else if (pdev->type == 740 || pdev->type == 720) { 650 unsigned char *ptr = (unsigned char *)fbuf->data; 651 if ((ptr[0] ^ pdev->vmirror) & 0x01) { 652 pwc_snapshot_button(pdev, ptr[0] & 0x01); 653 } 654 pdev->vmirror = ptr[0] & 0x03; 655 } 656 657 /* In case we were instructed to drop the frame, do so silently. 658 The buffer pointers are not updated either (but the counters are reset below). 659 */ 660 if (pdev->drop_frames > 0) 661 pdev->drop_frames--; 662 else { 663 /* Check for underflow first */ 664 if (fbuf->filled < pdev->frame_total_size) { 665 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);" 666 " discarded.\n", fbuf->filled); 667 pdev->vframes_error++; 668 } 669 else { 670 /* Send only once per EOF */ 671 awake = 1; /* delay wake_ups */ 672 673 /* Find our next frame to fill. This will always succeed, since we 674 * nick a frame from either empty or full list, but if we had to 675 * take it from the full list, it means a frame got dropped. 676 */ 677 if (pwc_next_fill_frame(pdev)) 678 pwc_frame_dumped(pdev); 679 680 } 681 } /* !drop_frames */ 682 pdev->vframe_count++; 683 return awake; 684} 685 686/* This gets called for the Isochronous pipe (video). This is done in 687 * interrupt time, so it has to be fast, not crash, and not stall. Neat. 688 */ 689static void pwc_isoc_handler(struct urb *urb) 690{ 691 struct pwc_device *pdev; 692 int i, fst, flen; 693 int awake; 694 struct pwc_frame_buf *fbuf; 695 unsigned char *fillptr = NULL, *iso_buf = NULL; 696 697 awake = 0; 698 pdev = (struct pwc_device *)urb->context; 699 if (pdev == NULL) { 700 PWC_ERROR("isoc_handler() called with NULL device?!\n"); 701 return; 702 } 703 704 if (urb->status == -ENOENT || urb->status == -ECONNRESET) { 705 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a"); 706 return; 707 } 708 if (urb->status != -EINPROGRESS && urb->status != 0) { 709 const char *errmsg; 710 711 errmsg = "Unknown"; 712 switch(urb->status) { 713 case -ENOSR: errmsg = "Buffer error (overrun)"; break; 714 case -EPIPE: errmsg = "Stalled (device not responding)"; break; 715 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break; 716 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break; 717 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break; 718 case -ETIME: errmsg = "Device does not respond"; break; 719 } 720 PWC_DEBUG_FLOW("pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg); 721 /* Give up after a number of contiguous errors on the USB bus. 722 Appearantly something is wrong so we simulate an unplug event. 723 */ 724 if (++pdev->visoc_errors > MAX_ISOC_ERRORS) 725 { 726 PWC_INFO("Too many ISOC errors, bailing out.\n"); 727 pdev->error_status = EIO; 728 awake = 1; 729 wake_up_interruptible(&pdev->frameq); 730 } 731 goto handler_end; // ugly, but practical 732 } 733 734 fbuf = pdev->fill_frame; 735 if (fbuf == NULL) { 736 PWC_ERROR("pwc_isoc_handler without valid fill frame.\n"); 737 awake = 1; 738 goto handler_end; 739 } 740 else { 741 fillptr = fbuf->data + fbuf->filled; 742 } 743 744 /* Reset ISOC error counter. We did get here, after all. */ 745 pdev->visoc_errors = 0; 746 747 /* vsync: 0 = don't copy data 748 1 = sync-hunt 749 2 = synched 750 */ 751 /* Compact data */ 752 for (i = 0; i < urb->number_of_packets; i++) { 753 fst = urb->iso_frame_desc[i].status; 754 flen = urb->iso_frame_desc[i].actual_length; 755 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset; 756 if (fst == 0) { 757 if (flen > 0) { /* if valid data... */ 758 if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */ 759 pdev->vsync = 2; 760 761 /* ...copy data to frame buffer, if possible */ 762 if (flen + fbuf->filled > pdev->frame_total_size) { 763 PWC_DEBUG_FLOW("Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen, pdev->frame_total_size); 764 pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */ 765 pdev->vframes_error++; 766 } 767 else { 768 memmove(fillptr, iso_buf, flen); 769 fillptr += flen; 770 } 771 } 772 fbuf->filled += flen; 773 } /* ..flen > 0 */ 774 775 if (flen < pdev->vlast_packet_size) { 776 /* Shorter packet... We probably have the end of an image-frame; 777 wake up read() process and let select()/poll() do something. 778 Decompression is done in user time over there. 779 */ 780 if (pdev->vsync == 2) { 781 if (pwc_rcv_short_packet(pdev, fbuf)) { 782 awake = 1; 783 fbuf = pdev->fill_frame; 784 } 785 } 786 fbuf->filled = 0; 787 fillptr = fbuf->data; 788 pdev->vsync = 1; 789 } 790 791 pdev->vlast_packet_size = flen; 792 } /* ..status == 0 */ 793 else { 794 /* This is normally not interesting to the user, unless 795 * you are really debugging something, default = 0 */ 796 static int iso_error; 797 iso_error++; 798 if (iso_error < 20) 799 PWC_DEBUG_FLOW("Iso frame %d of USB has error %d\n", i, fst); 800 } 801 } 802 803handler_end: 804 if (awake) 805 wake_up_interruptible(&pdev->frameq); 806 807 urb->dev = pdev->udev; 808 i = usb_submit_urb(urb, GFP_ATOMIC); 809 if (i != 0) 810 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i); 811} 812 813 814int pwc_isoc_init(struct pwc_device *pdev) 815{ 816 struct usb_device *udev; 817 struct urb *urb; 818 int i, j, ret; 819 820 struct usb_interface *intf; 821 struct usb_host_interface *idesc = NULL; 822 823 if (pdev == NULL) 824 return -EFAULT; 825 if (pdev->iso_init) 826 return 0; 827 pdev->vsync = 0; 828 udev = pdev->udev; 829 830 /* Get the current alternate interface, adjust packet size */ 831 if (!udev->actconfig) 832 return -EFAULT; 833 intf = usb_ifnum_to_if(udev, 0); 834 if (intf) 835 idesc = usb_altnum_to_altsetting(intf, pdev->valternate); 836 837 if (!idesc) 838 return -EFAULT; 839 840 /* Search video endpoint */ 841 pdev->vmax_packet_size = -1; 842 for (i = 0; i < idesc->desc.bNumEndpoints; i++) { 843 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) { 844 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize); 845 break; 846 } 847 } 848 849 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) { 850 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n"); 851 return -ENFILE; /* Odd error, that should be noticeable */ 852 } 853 854 /* Set alternate interface */ 855 ret = 0; 856 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate); 857 ret = usb_set_interface(pdev->udev, 0, pdev->valternate); 858 if (ret < 0) 859 return ret; 860 861 for (i = 0; i < MAX_ISO_BUFS; i++) { 862 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL); 863 if (urb == NULL) { 864 PWC_ERROR("Failed to allocate urb %d\n", i); 865 ret = -ENOMEM; 866 break; 867 } 868 pdev->sbuf[i].urb = urb; 869 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb); 870 } 871 if (ret) { 872 /* De-allocate in reverse order */ 873 while (i--) { 874 usb_free_urb(pdev->sbuf[i].urb); 875 pdev->sbuf[i].urb = NULL; 876 } 877 return ret; 878 } 879 880 /* init URB structure */ 881 for (i = 0; i < MAX_ISO_BUFS; i++) { 882 urb = pdev->sbuf[i].urb; 883 884 urb->interval = 1; // devik 885 urb->dev = udev; 886 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint); 887 urb->transfer_flags = URB_ISO_ASAP; 888 urb->transfer_buffer = pdev->sbuf[i].data; 889 urb->transfer_buffer_length = ISO_BUFFER_SIZE; 890 urb->complete = pwc_isoc_handler; 891 urb->context = pdev; 892 urb->start_frame = 0; 893 urb->number_of_packets = ISO_FRAMES_PER_DESC; 894 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) { 895 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE; 896 urb->iso_frame_desc[j].length = pdev->vmax_packet_size; 897 } 898 } 899 900 /* link */ 901 for (i = 0; i < MAX_ISO_BUFS; i++) { 902 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL); 903 if (ret) 904 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret); 905 else 906 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->sbuf[i].urb); 907 } 908 909 /* All is done... */ 910 pdev->iso_init = 1; 911 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n"); 912 return 0; 913} 914 915static void pwc_iso_stop(struct pwc_device *pdev) 916{ 917 int i; 918 919 /* Unlinking ISOC buffers one by one */ 920 for (i = 0; i < MAX_ISO_BUFS; i++) { 921 struct urb *urb; 922 923 urb = pdev->sbuf[i].urb; 924 if (urb) { 925 PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb); 926 usb_kill_urb(urb); 927 } 928 } 929} 930 931static void pwc_iso_free(struct pwc_device *pdev) 932{ 933 int i; 934 935 /* Freeing ISOC buffers one by one */ 936 for (i = 0; i < MAX_ISO_BUFS; i++) { 937 struct urb *urb; 938 939 urb = pdev->sbuf[i].urb; 940 if (urb) { 941 PWC_DEBUG_MEMORY("Freeing URB\n"); 942 usb_free_urb(urb); 943 pdev->sbuf[i].urb = NULL; 944 } 945 } 946} 947 948void pwc_isoc_cleanup(struct pwc_device *pdev) 949{ 950 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n"); 951 if (pdev == NULL) 952 return; 953 if (pdev->iso_init == 0) 954 return; 955 956 pwc_iso_stop(pdev); 957 pwc_iso_free(pdev); 958 959 /* Stop camera, but only if we are sure the camera is still there (unplug 960 is signalled by EPIPE) 961 */ 962 if (pdev->error_status && pdev->error_status != EPIPE) { 963 PWC_DEBUG_OPEN("Setting alternate interface 0.\n"); 964 usb_set_interface(pdev->udev, 0, 0); 965 } 966 967 pdev->iso_init = 0; 968 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n"); 969} 970 971int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot) 972{ 973 int ret, start; 974 975 /* Stop isoc stuff */ 976 pwc_isoc_cleanup(pdev); 977 /* Reset parameters */ 978 pwc_reset_buffers(pdev); 979 /* Try to set video mode... */ 980 start = ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot); 981 if (ret) { 982 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 1 failed.\n"); 983 /* That failed... restore old mode (we know that worked) */ 984 start = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot); 985 if (start) { 986 PWC_DEBUG_FLOW("pwc_set_video_mode attempt 2 failed.\n"); 987 } 988 } 989 if (start == 0) 990 { 991 if (pwc_isoc_init(pdev) < 0) 992 { 993 PWC_WARNING("Failed to restart ISOC transfers in pwc_try_video_mode.\n"); 994 ret = -EAGAIN; /* let's try again, who knows if it works a second time */ 995 } 996 } 997 pdev->drop_frames++; /* try to avoid garbage during switch */ 998 return ret; /* Return original error code */ 999} 1000 1001/********* 1002 * sysfs 1003 *********/ 1004static struct pwc_device *cd_to_pwc(struct device *cd) 1005{ 1006 struct video_device *vdev = to_video_device(cd); 1007 return video_get_drvdata(vdev); 1008} 1009 1010static ssize_t show_pan_tilt(struct device *class_dev, 1011 struct device_attribute *attr, char *buf) 1012{ 1013 struct pwc_device *pdev = cd_to_pwc(class_dev); 1014 return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle); 1015} 1016 1017static ssize_t store_pan_tilt(struct device *class_dev, 1018 struct device_attribute *attr, 1019 const char *buf, size_t count) 1020{ 1021 struct pwc_device *pdev = cd_to_pwc(class_dev); 1022 int pan, tilt; 1023 int ret = -EINVAL; 1024 1025 if (strncmp(buf, "reset", 5) == 0) 1026 ret = pwc_mpt_reset(pdev, 0x3); 1027 1028 else if (sscanf(buf, "%d %d", &pan, &tilt) > 0) 1029 ret = pwc_mpt_set_angle(pdev, pan, tilt); 1030 1031 if (ret < 0) 1032 return ret; 1033 return strlen(buf); 1034} 1035static DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt, 1036 store_pan_tilt); 1037 1038static ssize_t show_snapshot_button_status(struct device *class_dev, 1039 struct device_attribute *attr, char *buf) 1040{ 1041 struct pwc_device *pdev = cd_to_pwc(class_dev); 1042 int status = pdev->snapshot_button_status; 1043 pdev->snapshot_button_status = 0; 1044 return sprintf(buf, "%d\n", status); 1045} 1046 1047static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status, 1048 NULL); 1049 1050static int pwc_create_sysfs_files(struct video_device *vdev) 1051{ 1052 struct pwc_device *pdev = video_get_drvdata(vdev); 1053 int rc; 1054 1055 rc = device_create_file(&vdev->dev, &dev_attr_button); 1056 if (rc) 1057 goto err; 1058 if (pdev->features & FEATURE_MOTOR_PANTILT) { 1059 rc = device_create_file(&vdev->dev, &dev_attr_pan_tilt); 1060 if (rc) 1061 goto err_button; 1062 } 1063 1064 return 0; 1065 1066err_button: 1067 device_remove_file(&vdev->dev, &dev_attr_button); 1068err: 1069 PWC_ERROR("Could not create sysfs files.\n"); 1070 return rc; 1071} 1072 1073static void pwc_remove_sysfs_files(struct video_device *vdev) 1074{ 1075 struct pwc_device *pdev = video_get_drvdata(vdev); 1076 1077 if (pdev->features & FEATURE_MOTOR_PANTILT) 1078 device_remove_file(&vdev->dev, &dev_attr_pan_tilt); 1079 device_remove_file(&vdev->dev, &dev_attr_button); 1080} 1081 1082#ifdef CONFIG_USB_PWC_DEBUG 1083static const char *pwc_sensor_type_to_string(unsigned int sensor_type) 1084{ 1085 switch(sensor_type) { 1086 case 0x00: 1087 return "Hyundai CMOS sensor"; 1088 case 0x20: 1089 return "Sony CCD sensor + TDA8787"; 1090 case 0x2E: 1091 return "Sony CCD sensor + Exas 98L59"; 1092 case 0x2F: 1093 return "Sony CCD sensor + ADI 9804"; 1094 case 0x30: 1095 return "Sharp CCD sensor + TDA8787"; 1096 case 0x3E: 1097 return "Sharp CCD sensor + Exas 98L59"; 1098 case 0x3F: 1099 return "Sharp CCD sensor + ADI 9804"; 1100 case 0x40: 1101 return "UPA 1021 sensor"; 1102 case 0x100: 1103 return "VGA sensor"; 1104 case 0x101: 1105 return "PAL MR sensor"; 1106 default: 1107 return "unknown type of sensor"; 1108 } 1109} 1110#endif 1111 1112/***************************************************************************/ 1113/* Video4Linux functions */ 1114 1115static int pwc_video_open(struct file *file) 1116{ 1117 int i, ret; 1118 struct video_device *vdev = video_devdata(file); 1119 struct pwc_device *pdev; 1120 1121 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev); 1122 1123 pdev = video_get_drvdata(vdev); 1124 BUG_ON(!pdev); 1125 if (pdev->vopen) { 1126 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n"); 1127 return -EBUSY; 1128 } 1129 1130 mutex_lock(&pdev->modlock); 1131 pwc_construct(pdev); /* set min/max sizes correct */ 1132 if (!pdev->usb_init) { 1133 PWC_DEBUG_OPEN("Doing first time initialization.\n"); 1134 pdev->usb_init = 1; 1135 1136 /* Query sensor type */ 1137 ret = pwc_get_cmos_sensor(pdev, &i); 1138 if (ret >= 0) 1139 { 1140 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n", 1141 pdev->vdev->name, 1142 pwc_sensor_type_to_string(i), i); 1143 } 1144 } 1145 1146 /* Turn on camera */ 1147 if (power_save) { 1148 i = pwc_camera_power(pdev, 1); 1149 if (i < 0) 1150 PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i); 1151 } 1152 /* Set LED on/off time */ 1153 if (pwc_set_leds(pdev, led_on, led_off) < 0) 1154 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n"); 1155 1156 1157 /* So far, so good. Allocate memory. */ 1158 i = pwc_allocate_buffers(pdev); 1159 if (i < 0) { 1160 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n"); 1161 pwc_free_buffers(pdev); 1162 mutex_unlock(&pdev->modlock); 1163 return i; 1164 } 1165 1166 /* Reset buffers & parameters */ 1167 pwc_reset_buffers(pdev); 1168 for (i = 0; i < pwc_mbufs; i++) 1169 pdev->image_used[i] = 0; 1170 pdev->vframe_count = 0; 1171 pdev->vframes_dumped = 0; 1172 pdev->vframes_error = 0; 1173 pdev->visoc_errors = 0; 1174 pdev->error_status = 0; 1175 pwc_construct(pdev); /* set min/max sizes correct */ 1176 1177 /* Set some defaults */ 1178 pdev->vsnapshot = 0; 1179 1180 /* Start iso pipe for video; first try the last used video size 1181 (or the default one); if that fails try QCIF/10 or QSIF/10; 1182 it that fails too, give up. 1183 */ 1184 i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0); 1185 if (i) { 1186 unsigned int default_resolution; 1187 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n"); 1188 if (pdev->type>= 730) 1189 default_resolution = PSZ_QSIF; 1190 else 1191 default_resolution = PSZ_QCIF; 1192 1193 i = pwc_set_video_mode(pdev, 1194 pwc_image_sizes[default_resolution].x, 1195 pwc_image_sizes[default_resolution].y, 1196 10, 1197 pdev->vcompression, 1198 0); 1199 } 1200 if (i) { 1201 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n"); 1202 pwc_free_buffers(pdev); 1203 mutex_unlock(&pdev->modlock); 1204 return i; 1205 } 1206 1207 i = pwc_isoc_init(pdev); 1208 if (i) { 1209 PWC_DEBUG_OPEN("Failed to init ISOC stuff = %d.\n", i); 1210 pwc_isoc_cleanup(pdev); 1211 pwc_free_buffers(pdev); 1212 mutex_unlock(&pdev->modlock); 1213 return i; 1214 } 1215 1216 /* Initialize the webcam to sane value */ 1217 pwc_set_brightness(pdev, 0x7fff); 1218 pwc_set_agc(pdev, 1, 0); 1219 1220 pdev->vopen++; 1221 file->private_data = vdev; 1222 mutex_unlock(&pdev->modlock); 1223 PWC_DEBUG_OPEN("<< video_open() returns 0.\n"); 1224 return 0; 1225} 1226 1227 1228static void pwc_cleanup(struct pwc_device *pdev) 1229{ 1230 pwc_remove_sysfs_files(pdev->vdev); 1231 video_unregister_device(pdev->vdev); 1232 1233#ifdef CONFIG_USB_PWC_INPUT_EVDEV 1234 if (pdev->button_dev) 1235 input_unregister_device(pdev->button_dev); 1236#endif 1237 1238 kfree(pdev); 1239} 1240 1241/* Note that all cleanup is done in the reverse order as in _open */ 1242static int pwc_video_close(struct file *file) 1243{ 1244 struct video_device *vdev = file->private_data; 1245 struct pwc_device *pdev; 1246 int i, hint; 1247 1248 PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev); 1249 1250 lock_kernel(); 1251 pdev = video_get_drvdata(vdev); 1252 if (pdev->vopen == 0) 1253 PWC_DEBUG_MODULE("video_close() called on closed device?\n"); 1254 1255 /* Dump statistics, but only if a reasonable amount of frames were 1256 processed (to prevent endless log-entries in case of snap-shot 1257 programs) 1258 */ 1259 if (pdev->vframe_count > 20) 1260 PWC_DEBUG_MODULE("Closing video device: %d frames received, dumped %d frames, %d frames with errors.\n", pdev->vframe_count, pdev->vframes_dumped, pdev->vframes_error); 1261 1262 if (DEVICE_USE_CODEC1(pdev->type)) 1263 pwc_dec1_exit(); 1264 else 1265 pwc_dec23_exit(); 1266 1267 pwc_isoc_cleanup(pdev); 1268 pwc_free_buffers(pdev); 1269 1270 /* Turn off LEDS and power down camera, but only when not unplugged */ 1271 if (!pdev->unplugged) { 1272 /* Turn LEDs off */ 1273 if (pwc_set_leds(pdev, 0, 0) < 0) 1274 PWC_DEBUG_MODULE("Failed to set LED on/off time.\n"); 1275 if (power_save) { 1276 i = pwc_camera_power(pdev, 0); 1277 if (i < 0) 1278 PWC_ERROR("Failed to power down camera (%d)\n", i); 1279 } 1280 pdev->vopen--; 1281 PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen); 1282 } else { 1283 pwc_cleanup(pdev); 1284 /* search device_hint[] table if we occupy a slot, by any chance */ 1285 for (hint = 0; hint < MAX_DEV_HINTS; hint++) 1286 if (device_hint[hint].pdev == pdev) 1287 device_hint[hint].pdev = NULL; 1288 } 1289 unlock_kernel(); 1290 1291 return 0; 1292} 1293 1294 1295static ssize_t pwc_video_read(struct file *file, char __user *buf, 1296 size_t count, loff_t *ppos) 1297{ 1298 struct video_device *vdev = file->private_data; 1299 struct pwc_device *pdev; 1300 int noblock = file->f_flags & O_NONBLOCK; 1301 DECLARE_WAITQUEUE(wait, current); 1302 int bytes_to_read, rv = 0; 1303 void *image_buffer_addr; 1304 1305 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n", 1306 vdev, buf, count); 1307 if (vdev == NULL) 1308 return -EFAULT; 1309 pdev = video_get_drvdata(vdev); 1310 if (pdev == NULL) 1311 return -EFAULT; 1312 1313 mutex_lock(&pdev->modlock); 1314 if (pdev->error_status) { 1315 rv = -pdev->error_status; /* Something happened, report what. */ 1316 goto err_out; 1317 } 1318 1319 /* In case we're doing partial reads, we don't have to wait for a frame */ 1320 if (pdev->image_read_pos == 0) { 1321 /* Do wait queueing according to the (doc)book */ 1322 add_wait_queue(&pdev->frameq, &wait); 1323 while (pdev->full_frames == NULL) { 1324 /* Check for unplugged/etc. here */ 1325 if (pdev->error_status) { 1326 remove_wait_queue(&pdev->frameq, &wait); 1327 set_current_state(TASK_RUNNING); 1328 rv = -pdev->error_status ; 1329 goto err_out; 1330 } 1331 if (noblock) { 1332 remove_wait_queue(&pdev->frameq, &wait); 1333 set_current_state(TASK_RUNNING); 1334 rv = -EWOULDBLOCK; 1335 goto err_out; 1336 } 1337 if (signal_pending(current)) { 1338 remove_wait_queue(&pdev->frameq, &wait); 1339 set_current_state(TASK_RUNNING); 1340 rv = -ERESTARTSYS; 1341 goto err_out; 1342 } 1343 schedule(); 1344 set_current_state(TASK_INTERRUPTIBLE); 1345 } 1346 remove_wait_queue(&pdev->frameq, &wait); 1347 set_current_state(TASK_RUNNING); 1348 1349 /* Decompress and release frame */ 1350 if (pwc_handle_frame(pdev)) { 1351 rv = -EFAULT; 1352 goto err_out; 1353 } 1354 } 1355 1356 PWC_DEBUG_READ("Copying data to user space.\n"); 1357 if (pdev->vpalette == VIDEO_PALETTE_RAW) 1358 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame); 1359 else 1360 bytes_to_read = pdev->view.size; 1361 1362 /* copy bytes to user space; we allow for partial reads */ 1363 if (count + pdev->image_read_pos > bytes_to_read) 1364 count = bytes_to_read - pdev->image_read_pos; 1365 image_buffer_addr = pdev->image_data; 1366 image_buffer_addr += pdev->images[pdev->fill_image].offset; 1367 image_buffer_addr += pdev->image_read_pos; 1368 if (copy_to_user(buf, image_buffer_addr, count)) { 1369 rv = -EFAULT; 1370 goto err_out; 1371 } 1372 pdev->image_read_pos += count; 1373 if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */ 1374 pdev->image_read_pos = 0; 1375 pwc_next_image(pdev); 1376 } 1377 mutex_unlock(&pdev->modlock); 1378 return count; 1379err_out: 1380 mutex_unlock(&pdev->modlock); 1381 return rv; 1382} 1383 1384static unsigned int pwc_video_poll(struct file *file, poll_table *wait) 1385{ 1386 struct video_device *vdev = file->private_data; 1387 struct pwc_device *pdev; 1388 1389 if (vdev == NULL) 1390 return -EFAULT; 1391 pdev = video_get_drvdata(vdev); 1392 if (pdev == NULL) 1393 return -EFAULT; 1394 1395 poll_wait(file, &pdev->frameq, wait); 1396 if (pdev->error_status) 1397 return POLLERR; 1398 if (pdev->full_frames != NULL) /* we have frames waiting */ 1399 return (POLLIN | POLLRDNORM); 1400 1401 return 0; 1402} 1403 1404static long pwc_video_ioctl(struct file *file, 1405 unsigned int cmd, unsigned long arg) 1406{ 1407 struct video_device *vdev = file->private_data; 1408 struct pwc_device *pdev; 1409 long r = -ENODEV; 1410 1411 if (!vdev) 1412 goto out; 1413 pdev = video_get_drvdata(vdev); 1414 1415 mutex_lock(&pdev->modlock); 1416 if (!pdev->unplugged) 1417 r = video_usercopy(file, cmd, arg, pwc_video_do_ioctl); 1418 mutex_unlock(&pdev->modlock); 1419out: 1420 return r; 1421} 1422 1423static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma) 1424{ 1425 struct video_device *vdev = file->private_data; 1426 struct pwc_device *pdev; 1427 unsigned long start; 1428 unsigned long size; 1429 unsigned long page, pos = 0; 1430 int index; 1431 1432 PWC_DEBUG_MEMORY(">> %s\n", __func__); 1433 pdev = video_get_drvdata(vdev); 1434 size = vma->vm_end - vma->vm_start; 1435 start = vma->vm_start; 1436 1437 /* Find the idx buffer for this mapping */ 1438 for (index = 0; index < pwc_mbufs; index++) { 1439 pos = pdev->images[index].offset; 1440 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff) 1441 break; 1442 } 1443 if (index == MAX_IMAGES) 1444 return -EINVAL; 1445 if (index == 0) { 1446 /* 1447 * Special case for v4l1. In v4l1, we map only one big buffer, 1448 * but in v4l2 each buffer is mapped 1449 */ 1450 unsigned long total_size; 1451 total_size = pwc_mbufs * pdev->len_per_image; 1452 if (size != pdev->len_per_image && size != total_size) { 1453 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n", 1454 size, pdev->len_per_image, total_size); 1455 return -EINVAL; 1456 } 1457 } else if (size > pdev->len_per_image) 1458 return -EINVAL; 1459 1460 vma->vm_flags |= VM_IO; /* from 2.6.9-acX */ 1461 1462 pos += (unsigned long)pdev->image_data; 1463 while (size > 0) { 1464 page = vmalloc_to_pfn((void *)pos); 1465 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) 1466 return -EAGAIN; 1467 start += PAGE_SIZE; 1468 pos += PAGE_SIZE; 1469 if (size > PAGE_SIZE) 1470 size -= PAGE_SIZE; 1471 else 1472 size = 0; 1473 } 1474 return 0; 1475} 1476 1477/***************************************************************************/ 1478/* USB functions */ 1479 1480/* This function gets called when a new device is plugged in or the usb core 1481 * is loaded. 1482 */ 1483 1484static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id) 1485{ 1486 struct usb_device *udev = interface_to_usbdev(intf); 1487 struct pwc_device *pdev = NULL; 1488 int vendor_id, product_id, type_id; 1489 int hint, rc; 1490 int features = 0; 1491 int video_nr = -1; /* default: use next available device */ 1492 char serial_number[30], *name; 1493 1494 vendor_id = le16_to_cpu(udev->descriptor.idVendor); 1495 product_id = le16_to_cpu(udev->descriptor.idProduct); 1496 1497 /* Check if we can handle this device */ 1498 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n", 1499 vendor_id, product_id, 1500 intf->altsetting->desc.bInterfaceNumber); 1501 1502 /* the interfaces are probed one by one. We are only interested in the 1503 video interface (0) now. 1504 Interface 1 is the Audio Control, and interface 2 Audio itself. 1505 */ 1506 if (intf->altsetting->desc.bInterfaceNumber > 0) 1507 return -ENODEV; 1508 1509 if (vendor_id == 0x0471) { 1510 switch (product_id) { 1511 case 0x0302: 1512 PWC_INFO("Philips PCA645VC USB webcam detected.\n"); 1513 name = "Philips 645 webcam"; 1514 type_id = 645; 1515 break; 1516 case 0x0303: 1517 PWC_INFO("Philips PCA646VC USB webcam detected.\n"); 1518 name = "Philips 646 webcam"; 1519 type_id = 646; 1520 break; 1521 case 0x0304: 1522 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n"); 1523 name = "Askey VC010 webcam"; 1524 type_id = 646; 1525 break; 1526 case 0x0307: 1527 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n"); 1528 name = "Philips 675 webcam"; 1529 type_id = 675; 1530 break; 1531 case 0x0308: 1532 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n"); 1533 name = "Philips 680 webcam"; 1534 type_id = 680; 1535 break; 1536 case 0x030C: 1537 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n"); 1538 name = "Philips 690 webcam"; 1539 type_id = 690; 1540 break; 1541 case 0x0310: 1542 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n"); 1543 name = "Philips 730 webcam"; 1544 type_id = 730; 1545 break; 1546 case 0x0311: 1547 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n"); 1548 name = "Philips 740 webcam"; 1549 type_id = 740; 1550 break; 1551 case 0x0312: 1552 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n"); 1553 name = "Philips 750 webcam"; 1554 type_id = 750; 1555 break; 1556 case 0x0313: 1557 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n"); 1558 name = "Philips 720K/40 webcam"; 1559 type_id = 720; 1560 break; 1561 case 0x0329: 1562 PWC_INFO("Philips SPC 900NC USB webcam detected.\n"); 1563 name = "Philips SPC 900NC webcam"; 1564 type_id = 740; 1565 break; 1566 default: 1567 return -ENODEV; 1568 break; 1569 } 1570 } 1571 else if (vendor_id == 0x069A) { 1572 switch(product_id) { 1573 case 0x0001: 1574 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n"); 1575 name = "Askey VC010 webcam"; 1576 type_id = 645; 1577 break; 1578 default: 1579 return -ENODEV; 1580 break; 1581 } 1582 } 1583 else if (vendor_id == 0x046d) { 1584 switch(product_id) { 1585 case 0x08b0: 1586 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n"); 1587 name = "Logitech QuickCam Pro 3000"; 1588 type_id = 740; /* CCD sensor */ 1589 break; 1590 case 0x08b1: 1591 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n"); 1592 name = "Logitech QuickCam Notebook Pro"; 1593 type_id = 740; /* CCD sensor */ 1594 break; 1595 case 0x08b2: 1596 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n"); 1597 name = "Logitech QuickCam Pro 4000"; 1598 type_id = 740; /* CCD sensor */ 1599 break; 1600 case 0x08b3: 1601 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n"); 1602 name = "Logitech QuickCam Zoom"; 1603 type_id = 740; /* CCD sensor */ 1604 break; 1605 case 0x08B4: 1606 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n"); 1607 name = "Logitech QuickCam Zoom"; 1608 type_id = 740; /* CCD sensor */ 1609 power_save = 1; 1610 break; 1611 case 0x08b5: 1612 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n"); 1613 name = "Logitech QuickCam Orbit"; 1614 type_id = 740; /* CCD sensor */ 1615 features |= FEATURE_MOTOR_PANTILT; 1616 break; 1617 case 0x08b6: 1618 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n"); 1619 name = "Cisco VT Camera"; 1620 type_id = 740; /* CCD sensor */ 1621 break; 1622 case 0x08b7: 1623 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n"); 1624 name = "Logitech ViewPort AV 100"; 1625 type_id = 740; /* CCD sensor */ 1626 break; 1627 case 0x08b8: /* Where this released? */ 1628 PWC_INFO("Logitech QuickCam detected (reserved ID).\n"); 1629 name = "Logitech QuickCam (res.)"; 1630 type_id = 730; /* Assuming CMOS */ 1631 break; 1632 default: 1633 return -ENODEV; 1634 break; 1635 } 1636 } 1637 else if (vendor_id == 0x055d) { 1638 /* I don't know the difference between the C10 and the C30; 1639 I suppose the difference is the sensor, but both cameras 1640 work equally well with a type_id of 675 1641 */ 1642 switch(product_id) { 1643 case 0x9000: 1644 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n"); 1645 name = "Samsung MPC-C10"; 1646 type_id = 675; 1647 break; 1648 case 0x9001: 1649 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n"); 1650 name = "Samsung MPC-C30"; 1651 type_id = 675; 1652 break; 1653 case 0x9002: 1654 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n"); 1655 name = "Samsung MPC-C30"; 1656 type_id = 740; 1657 break; 1658 default: 1659 return -ENODEV; 1660 break; 1661 } 1662 } 1663 else if (vendor_id == 0x041e) { 1664 switch(product_id) { 1665 case 0x400c: 1666 PWC_INFO("Creative Labs Webcam 5 detected.\n"); 1667 name = "Creative Labs Webcam 5"; 1668 type_id = 730; 1669 break; 1670 case 0x4011: 1671 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n"); 1672 name = "Creative Labs Webcam Pro Ex"; 1673 type_id = 740; 1674 break; 1675 default: 1676 return -ENODEV; 1677 break; 1678 } 1679 } 1680 else if (vendor_id == 0x04cc) { 1681 switch(product_id) { 1682 case 0x8116: 1683 PWC_INFO("Sotec Afina Eye USB webcam detected.\n"); 1684 name = "Sotec Afina Eye"; 1685 type_id = 730; 1686 break; 1687 default: 1688 return -ENODEV; 1689 break; 1690 } 1691 } 1692 else if (vendor_id == 0x06be) { 1693 switch(product_id) { 1694 case 0x8116: 1695 /* This is essentially the same cam as the Sotec Afina Eye */ 1696 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n"); 1697 name = "AME Co. Afina Eye"; 1698 type_id = 750; 1699 break; 1700 default: 1701 return -ENODEV; 1702 break; 1703 } 1704 1705 } 1706 else if (vendor_id == 0x0d81) { 1707 switch(product_id) { 1708 case 0x1900: 1709 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n"); 1710 name = "Visionite VCS-UC300"; 1711 type_id = 740; /* CCD sensor */ 1712 break; 1713 case 0x1910: 1714 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n"); 1715 name = "Visionite VCS-UM100"; 1716 type_id = 730; /* CMOS sensor */ 1717 break; 1718 default: 1719 return -ENODEV; 1720 break; 1721 } 1722 } 1723 else 1724 return -ENODEV; /* Not any of the know types; but the list keeps growing. */ 1725 1726 memset(serial_number, 0, 30); 1727 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29); 1728 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number); 1729 1730 if (udev->descriptor.bNumConfigurations > 1) 1731 PWC_WARNING("Warning: more than 1 configuration available.\n"); 1732 1733 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */ 1734 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL); 1735 if (pdev == NULL) { 1736 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n"); 1737 return -ENOMEM; 1738 } 1739 pdev->type = type_id; 1740 pdev->vsize = default_size; 1741 pdev->vframes = default_fps; 1742 strcpy(pdev->serial, serial_number); 1743 pdev->features = features; 1744 if (vendor_id == 0x046D && product_id == 0x08B5) { 1745 /* Logitech QuickCam Orbit 1746 The ranges have been determined experimentally; they may differ from cam to cam. 1747 Also, the exact ranges left-right and up-down are different for my cam 1748 */ 1749 pdev->angle_range.pan_min = -7000; 1750 pdev->angle_range.pan_max = 7000; 1751 pdev->angle_range.tilt_min = -3000; 1752 pdev->angle_range.tilt_max = 2500; 1753 } 1754 1755 mutex_init(&pdev->modlock); 1756 spin_lock_init(&pdev->ptrlock); 1757 1758 pdev->udev = udev; 1759 init_waitqueue_head(&pdev->frameq); 1760 pdev->vcompression = pwc_preferred_compression; 1761 1762 /* Allocate video_device structure */ 1763 pdev->vdev = video_device_alloc(); 1764 if (!pdev->vdev) { 1765 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe."); 1766 rc = -ENOMEM; 1767 goto err_free_mem; 1768 } 1769 memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template)); 1770 pdev->vdev->parent = &intf->dev; 1771 strcpy(pdev->vdev->name, name); 1772 video_set_drvdata(pdev->vdev, pdev); 1773 1774 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice); 1775 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release); 1776 1777 /* Now search device_hint[] table for a match, so we can hint a node number. */ 1778 for (hint = 0; hint < MAX_DEV_HINTS; hint++) { 1779 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) && 1780 (device_hint[hint].pdev == NULL)) { 1781 /* so far, so good... try serial number */ 1782 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) { 1783 /* match! */ 1784 video_nr = device_hint[hint].device_node; 1785 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr); 1786 break; 1787 } 1788 } 1789 } 1790 1791 pdev->vdev->release = video_device_release; 1792 rc = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr); 1793 if (rc < 0) { 1794 PWC_ERROR("Failed to register as video device (%d).\n", rc); 1795 goto err_video_release; 1796 } 1797 1798 PWC_INFO("Registered as %s.\n", video_device_node_name(pdev->vdev)); 1799 1800 /* occupy slot */ 1801 if (hint < MAX_DEV_HINTS) 1802 device_hint[hint].pdev = pdev; 1803 1804 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev); 1805 usb_set_intfdata(intf, pdev); 1806 rc = pwc_create_sysfs_files(pdev->vdev); 1807 if (rc) 1808 goto err_video_unreg; 1809 1810 /* Set the leds off */ 1811 pwc_set_leds(pdev, 0, 0); 1812 pwc_camera_power(pdev, 0); 1813 1814#ifdef CONFIG_USB_PWC_INPUT_EVDEV 1815 /* register webcam snapshot button input device */ 1816 pdev->button_dev = input_allocate_device(); 1817 if (!pdev->button_dev) { 1818 PWC_ERROR("Err, insufficient memory for webcam snapshot button device."); 1819 rc = -ENOMEM; 1820 pwc_remove_sysfs_files(pdev->vdev); 1821 goto err_video_unreg; 1822 } 1823 1824 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys)); 1825 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys)); 1826 1827 pdev->button_dev->name = "PWC snapshot button"; 1828 pdev->button_dev->phys = pdev->button_phys; 1829 usb_to_input_id(pdev->udev, &pdev->button_dev->id); 1830 pdev->button_dev->dev.parent = &pdev->udev->dev; 1831 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY); 1832 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA); 1833 1834 rc = input_register_device(pdev->button_dev); 1835 if (rc) { 1836 input_free_device(pdev->button_dev); 1837 pdev->button_dev = NULL; 1838 pwc_remove_sysfs_files(pdev->vdev); 1839 goto err_video_unreg; 1840 } 1841#endif 1842 1843 return 0; 1844 1845err_video_unreg: 1846 if (hint < MAX_DEV_HINTS) 1847 device_hint[hint].pdev = NULL; 1848 video_unregister_device(pdev->vdev); 1849 pdev->vdev = NULL; /* So we don't try to release it below */ 1850err_video_release: 1851 video_device_release(pdev->vdev); 1852err_free_mem: 1853 kfree(pdev); 1854 return rc; 1855} 1856 1857/* The user yanked out the cable... */ 1858static void usb_pwc_disconnect(struct usb_interface *intf) 1859{ 1860 struct pwc_device *pdev; 1861 int hint; 1862 1863 lock_kernel(); 1864 pdev = usb_get_intfdata (intf); 1865 usb_set_intfdata (intf, NULL); 1866 if (pdev == NULL) { 1867 PWC_ERROR("pwc_disconnect() Called without private pointer.\n"); 1868 goto disconnect_out; 1869 } 1870 if (pdev->udev == NULL) { 1871 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev); 1872 goto disconnect_out; 1873 } 1874 if (pdev->udev != interface_to_usbdev(intf)) { 1875 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n"); 1876 goto disconnect_out; 1877 } 1878 1879 /* We got unplugged; this is signalled by an EPIPE error code */ 1880 if (pdev->vopen) { 1881 PWC_INFO("Disconnected while webcam is in use!\n"); 1882 pdev->error_status = EPIPE; 1883 } 1884 1885 /* Alert waiting processes */ 1886 wake_up_interruptible(&pdev->frameq); 1887 /* Wait until device is closed */ 1888 if (pdev->vopen) { 1889 mutex_lock(&pdev->modlock); 1890 pdev->unplugged = 1; 1891 mutex_unlock(&pdev->modlock); 1892 pwc_iso_stop(pdev); 1893 } else { 1894 /* Device is closed, so we can safely unregister it */ 1895 PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n"); 1896 pwc_cleanup(pdev); 1897 1898disconnect_out: 1899 /* search device_hint[] table if we occupy a slot, by any chance */ 1900 for (hint = 0; hint < MAX_DEV_HINTS; hint++) 1901 if (device_hint[hint].pdev == pdev) 1902 device_hint[hint].pdev = NULL; 1903 } 1904 1905 unlock_kernel(); 1906} 1907 1908 1909/* 1910 * Initialization code & module stuff 1911 */ 1912 1913static char *size; 1914static int fps; 1915static int fbufs; 1916static int mbufs; 1917static int compression = -1; 1918static int leds[2] = { -1, -1 }; 1919static unsigned int leds_nargs; 1920static char *dev_hint[MAX_DEV_HINTS]; 1921static unsigned int dev_hint_nargs; 1922 1923module_param(size, charp, 0444); 1924module_param(fps, int, 0444); 1925module_param(fbufs, int, 0444); 1926module_param(mbufs, int, 0444); 1927#ifdef CONFIG_USB_PWC_DEBUG 1928module_param_named(trace, pwc_trace, int, 0644); 1929#endif 1930module_param(power_save, int, 0444); 1931module_param(compression, int, 0444); 1932module_param_array(leds, int, &leds_nargs, 0444); 1933module_param_array(dev_hint, charp, &dev_hint_nargs, 0444); 1934 1935MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga"); 1936MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30"); 1937MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve"); 1938MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers"); 1939#ifdef CONFIG_USB_PWC_DEBUG 1940MODULE_PARM_DESC(trace, "For debugging purposes"); 1941#endif 1942MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off"); 1943MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)"); 1944MODULE_PARM_DESC(leds, "LED on,off time in milliseconds"); 1945MODULE_PARM_DESC(dev_hint, "Device node hints"); 1946 1947MODULE_DESCRIPTION("Philips & OEM USB webcam driver"); 1948MODULE_AUTHOR("Luc Saillard <luc@saillard.org>"); 1949MODULE_LICENSE("GPL"); 1950MODULE_ALIAS("pwcx"); 1951MODULE_VERSION( PWC_VERSION ); 1952 1953static int __init usb_pwc_init(void) 1954{ 1955 int i, sz; 1956 char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" }; 1957 1958 PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n"); 1959 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n"); 1960 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n"); 1961 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n"); 1962 1963 if (fps) { 1964 if (fps < 4 || fps > 30) { 1965 PWC_ERROR("Framerate out of bounds (4-30).\n"); 1966 return -EINVAL; 1967 } 1968 default_fps = fps; 1969 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps); 1970 } 1971 1972 if (size) { 1973 /* string; try matching with array */ 1974 for (sz = 0; sz < PSZ_MAX; sz++) { 1975 if (!strcmp(sizenames[sz], size)) { /* Found! */ 1976 default_size = sz; 1977 break; 1978 } 1979 } 1980 if (sz == PSZ_MAX) { 1981 PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n"); 1982 return -EINVAL; 1983 } 1984 PWC_DEBUG_MODULE("Default image size set to %s [%dx%d].\n", sizenames[default_size], pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y); 1985 } 1986 if (mbufs) { 1987 if (mbufs < 1 || mbufs > MAX_IMAGES) { 1988 PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES); 1989 return -EINVAL; 1990 } 1991 pwc_mbufs = mbufs; 1992 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs); 1993 } 1994 if (fbufs) { 1995 if (fbufs < 2 || fbufs > MAX_FRAMES) { 1996 PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES); 1997 return -EINVAL; 1998 } 1999 default_fbufs = fbufs; 2000 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs); 2001 } 2002#ifdef CONFIG_USB_PWC_DEBUG 2003 if (pwc_trace >= 0) { 2004 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace); 2005 } 2006#endif 2007 if (compression >= 0) { 2008 if (compression > 3) { 2009 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n"); 2010 return -EINVAL; 2011 } 2012 pwc_preferred_compression = compression; 2013 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression); 2014 } 2015 if (power_save) 2016 PWC_DEBUG_MODULE("Enabling power save on open/close.\n"); 2017 if (leds[0] >= 0) 2018 led_on = leds[0]; 2019 if (leds[1] >= 0) 2020 led_off = leds[1]; 2021 2022 /* Big device node whoopla. Basically, it allows you to assign a 2023 device node (/dev/videoX) to a camera, based on its type 2024 & serial number. The format is [type[.serialnumber]:]node. 2025 2026 Any camera that isn't matched by these rules gets the next 2027 available free device node. 2028 */ 2029 for (i = 0; i < MAX_DEV_HINTS; i++) { 2030 char *s, *colon, *dot; 2031 2032 /* This loop also initializes the array */ 2033 device_hint[i].pdev = NULL; 2034 s = dev_hint[i]; 2035 if (s != NULL && *s != '\0') { 2036 device_hint[i].type = -1; /* wildcard */ 2037 strcpy(device_hint[i].serial_number, "*"); 2038 2039 /* parse string: chop at ':' & '/' */ 2040 colon = dot = s; 2041 while (*colon != '\0' && *colon != ':') 2042 colon++; 2043 while (*dot != '\0' && *dot != '.') 2044 dot++; 2045 /* Few sanity checks */ 2046 if (*dot != '\0' && dot > colon) { 2047 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n"); 2048 return -EINVAL; 2049 } 2050 2051 if (*colon == '\0') { 2052 /* No colon */ 2053 if (*dot != '\0') { 2054 PWC_ERROR("Malformed camera hint: no colon + device node given.\n"); 2055 return -EINVAL; 2056 } 2057 else { 2058 /* No type or serial number specified, just a number. */ 2059 device_hint[i].device_node = 2060 simple_strtol(s, NULL, 10); 2061 } 2062 } 2063 else { 2064 /* There's a colon, so we have at least a type and a device node */ 2065 device_hint[i].type = 2066 simple_strtol(s, NULL, 10); 2067 device_hint[i].device_node = 2068 simple_strtol(colon + 1, NULL, 10); 2069 if (*dot != '\0') { 2070 /* There's a serial number as well */ 2071 int k; 2072 2073 dot++; 2074 k = 0; 2075 while (*dot != ':' && k < 29) { 2076 device_hint[i].serial_number[k++] = *dot; 2077 dot++; 2078 } 2079 device_hint[i].serial_number[k] = '\0'; 2080 } 2081 } 2082 PWC_TRACE("device_hint[%d]:\n", i); 2083 PWC_TRACE(" type : %d\n", device_hint[i].type); 2084 PWC_TRACE(" serial# : %s\n", device_hint[i].serial_number); 2085 PWC_TRACE(" node : %d\n", device_hint[i].device_node); 2086 } 2087 else 2088 device_hint[i].type = 0; /* not filled */ 2089 } /* ..for MAX_DEV_HINTS */ 2090 2091 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver); 2092 return usb_register(&pwc_driver); 2093} 2094 2095static void __exit usb_pwc_exit(void) 2096{ 2097 PWC_DEBUG_MODULE("Deregistering driver.\n"); 2098 usb_deregister(&pwc_driver); 2099 PWC_INFO("Philips webcam module removed.\n"); 2100} 2101 2102module_init(usb_pwc_init); 2103module_exit(usb_pwc_exit); 2104 2105/* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */ 2106