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