/drivers/media/video/pwc/pwc-if.c
C | 2116 lines | 1552 code | 226 blank | 338 comment | 343 complexity | 7b073174d8068e2bcbed40f8e6be1baa MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0, AGPL-1.0
Large files files are truncated, but you can click here to view the full file
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/*
1295 * FIXME: what about two parallel reads ????
1296 * ANSWER: Not supported. You can't open the device more than once,
1297 despite what the V4L1 interface says. First, I don't see
1298 the need, second there's no mechanism of alerting the
1299 2nd/3rd/... process of events like changing image size.
1300 And I don't see the point of blocking that for the
1301 2nd/3rd/... process.
1302 In multi-threaded environments reading parallel from any
1303 device is tricky anyhow.
1304 */
1305
1306static ssize_t pwc_video_read(struct file *file, char __user *buf,
1307 size_t count, loff_t *ppos)
1308{
1309 struct video_device *vdev = file->private_data;
1310 struct pwc_device *pdev;
1311 int noblock = file->f_flags & O_NONBLOCK;
1312 DECLARE_WAITQUEUE(wait, current);
1313 int bytes_to_read, rv = 0;
1314 void *image_buffer_addr;
1315
1316 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1317 vdev, buf, count);
1318 if (vdev == NULL)
1319 return -EFAULT;
1320 pdev = video_get_drvdata(vdev);
1321 if (pdev == NULL)
1322 return -EFAULT;
1323
1324 mutex_lock(&pdev->modlock);
1325 if (pdev->error_status) {
1326 rv = -pdev->error_status; /* Something happened, report what. */
1327 goto err_out;
1328 }
1329
1330 /* In case we're doing partial reads, we don't have to wait for a frame */
1331 if (pdev->image_read_pos == 0) {
1332 /* Do wait queueing according to the (doc)book */
1333 add_wait_queue(&pdev->frameq, &wait);
1334 while (pdev->full_frames == NULL) {
1335 /* Check for unplugged/etc. here */
1336 if (pdev->error_status) {
1337 remove_wait_queue(&pdev->frameq, &wait);
1338 set_current_state(TASK_RUNNING);
1339 rv = -pdev->error_status ;
1340 goto err_out;
1341 }
1342 if (noblock) {
1343 remove_wait_queue(&pdev->frameq, &wait);
1344 set_current_state(TASK_RUNNING);
1345 rv = -EWOULDBLOCK;
1346 goto err_out;
1347 }
1348 if (signal_pending(current)) {
1349 remove_wait_queue(&pdev->frameq, &wait);
1350 set_current_state(TASK_RUNNING);
1351 rv = -ERESTARTSYS;
1352 goto err_out;
1353 }
1354 schedule();
1355 set_current_state(TASK_INTERRUPTIBLE);
1356 }
1357 remove_wait_queue(&pdev->frameq, &wait);
1358 set_current_state(TASK_RUNNING);
1359
1360 /* Decompress and release frame */
1361 if (pwc_handle_frame(pdev)) {
1362 rv = -EFAULT;
1363 goto err_out;
1364 }
1365 }
1366
1367 PWC_DEBUG_READ("Copying data to user space.\n");
1368 if (pdev->vpalette == VIDEO_PALETTE_RAW)
1369 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1370 else
1371 bytes_to_read = pdev->view.size;
1372
1373 /* copy bytes to user space; we allow for partial reads */
1374 if (count + pdev->image_read_pos > bytes_to_read)
1375 count = bytes_to_read - pdev->image_read_pos;
1376 image_buffer_addr = pdev->image_data;
1377 image_buffer_addr += pdev->images[pdev->fill_image].offset;
1378 image_buffer_addr += pdev->image_read_pos;
1379 if (copy_to_user(buf, image_buffer_addr, count)) {
1380 rv = -EFAULT;
1381 goto err_out;
1382 }
1383 pdev->image_read_pos += count;
1384 if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
1385 pdev->image_read_pos = 0;
1386 pwc_next_image(pdev);
1387 }
1388 mutex_unlock(&pdev->modlock);
1389 return count;
1390err_out:
1391 mutex_unlock(&pdev->modlock);
1392 return rv;
1393}
1394
1395static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1396{
1397 struct video_device *vdev = file->private_data;
1398 struct pwc_device *pdev;
1399
1400 if (vdev == NULL)
1401 return -EFAULT;
1402 pdev = video_get_drvdata(vdev);
1403 if (pdev == NULL)
1404 return -EFAULT;
1405
1406 poll_wait(file, &pdev->frameq, wait);
1407 if (pdev->error_status)
1408 return POLLERR;
1409 if (pdev->full_frames != NULL) /* we have frames waiting */
1410 return (POLLIN | POLLRDNORM);
1411
1412 return 0;
1413}
1414
1415static long pwc_video_ioctl(struct file *file,
1416 unsigned int cmd, unsigned long arg)
1417{
1418 struct video_device *vdev = file->private_data;
1419 struct pwc_device *pdev;
1420 long r = -ENODEV;
1421
1422 if (!vdev)
1423 goto out;
1424 pdev = video_get_drvdata(vdev);
1425
1426 mutex_lock(&pdev->modlock);
1427 if (!pdev->unplugged)
1428 r = video_usercopy(file, cmd, arg, pwc_video_do_ioctl);
1429 mutex_unlock(&pdev->modlock);
1430out:
1431 return r;
1432}
1433
1434static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1435{
1436 struct video_device *vdev = file->private_data;
1437 struct pwc_device *pdev;
1438 unsigned long start;
1439 unsigned long size;
1440 unsigned long page, pos = 0;
1441 int index;
1442
1443 PWC_DEBUG_MEMORY(">> %s\n", __func__);
1444 pdev = video_get_drvdata(vdev);
1445 size = vma->vm_end - vma->vm_start;
1446 start = vma->vm_start;
1447
1448 /* Find the idx buffer for this mapping */
1449 for (index = 0; index < pwc_mbufs; index++) {
1450 pos = pdev->images[index].offset;
1451 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1452 break;
1453 }
1454 if (index == MAX_IMAGES)
1455 return -EINVAL;
1456 if (index == 0) {
1457 /*
1458 * Special case for v4l1. In v4l1, we map only one big buffer,
1459 * but in v4l2 each buffer is mapped
1460 */
1461 unsigned long total_size;
1462 total_size = pwc_mbufs * pdev->len_per_image;
1463 if (size != pdev->len_per_image && size != total_size) {
1464 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1465 size, pdev->len_per_image, total_size);
1466 return -EINVAL;
1467 }
1468 } else if (size > pdev->len_per_image)
1469 return -EINVAL;
1470
1471 vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
1472
1473 pos += (unsigned long)pdev->image_data;
1474 while (size > 0) {
1475 page = vmalloc_to_pfn((void *)pos);
1476 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1477 return -EAGAIN;
1478 start += PAGE_SIZE;
1479 pos += PAGE_SIZE;
1480 if (size > PAGE_SIZE)
1481 size -= PAGE_SIZE;
1482 else
1483 size = 0;
1484 }
1485 return 0;
1486}
1487
1488/***************************************************************************/
1489/* USB functions */
1490
1491/* This function gets called when a new device is plugged in or the usb core
1492 * is loaded.
1493 */
1494
1495static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1496{
1497 struct usb_device *udev = interface_to_usbdev(intf);
1498 struct pwc_device *pdev = NULL;
1499 int vendor_id, product_id, type_id;
1500 int hint, rc;
1501 int features = 0;
1502 int video_nr = -1; /* default: use next available device */
1503 char serial_number[30], *name;
1504
1505 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1506 product_id = le16_to_cpu(udev->descriptor.idProduct);
1507
1508 /* Check if we can handle this device */
1509 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1510 vendor_id, product_id,
1511 intf->altsetting->desc.bInterfaceNumber);
1512
1513 /* the interfaces are probed one by one. We are only interested in the
1514 video interface (0) now.
1515 Interface 1 is the Audio Control, and interface 2 Audio itself.
1516 */
1517 if (intf->altsetting->desc.bInterfaceNumber > 0)
1518 return -ENODEV;
1519
1520 if (vendor_id == 0x0471) {
1521 switch (product_id) {
1522 case 0x0302:
1523 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1524 name = "Philips 645 webcam";
1525 type_id = 645;
1526 break;
1527 case 0x0303:
1528 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1529 name = "Philips 646 webcam";
1530 type_id = 646;
1531 break;
1532 case 0x0304:
1533 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1534 name = "Askey VC010 webcam";
1535 type_id = 646;
1536 break;
1537 case 0x0307:
1538 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1539 name = "Philips 675 webcam";
1540 type_id = 675;
1541 break;
1542 case 0x0308:
1543 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1544 name = "Philips 680 webcam";
1545 type_id = 680;
1546 break;
1547 case 0x030C:
1548 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1549 name = "Philips 690 webcam";
1550 type_id = 690;
1551 break;
1552 case 0x0310:
1553 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1554 name = "Philips 730 webcam";
1555 type_id = 730;
1556 break;
1557 case 0x0311:
1558 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1559 name = "Philips 740 webcam";
1560 type_id = 740;
1561 break;
1562 case 0x0312:
1563 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1564 name = "Philips 750 webcam";
1565 type_id = 750;
1566 break;
1567 case 0x0313:
1568 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1569 name = "Philips 720K/40 webcam";
1570 type_id = 720;
1571 break;
1572 case 0x0329:
1573 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1574 name = "Philips SPC 900NC webcam";
1575 type_id = 740;
1576 break;
1577 default:
1578 return -ENODEV;
1579 break;
1580 }
1581 }
1582 else if (vendor_id == 0x069A) {
1583 switch(product_id) {
1584 case 0x0001:
1585 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1586 name = "Askey VC010 webcam";
1587 type_id = 645;
1588 break;
1589 default:
1590 return -ENODEV;
1591 break;
1592 }
1593 }
1594 else if (vendor_id == 0x046d) {
1595 switch(product_id) {
1596 case 0x08b0:
1597 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1598 name = "Logitech QuickCam Pro 3000";
1599 type_id = 740; /* CCD sensor */
1600 break;
1601 case 0x08b1:
1602 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1603 name = "Logitech QuickCam Notebook Pro";
1604 type_id = 740; /* CCD sensor */
1605 break;
1606 case 0x08b2:
1607 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1608 name = "Logitech QuickCam Pro 4000";
1609 type_id = 740; /* CCD sensor */
1610 break;
1611 case 0x08b3:
1612 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1613 name = "Logitech QuickCam Zoom";
1614 type_id = 740; /* CCD sensor */
1615 break;
1616 case 0x08B4:
1617 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1618 name = "Logitech QuickCam Zoom";
1619 type_id = 740; /* CCD sensor */
1620 power_save = 1;
1621 break;
1622 case 0x08b5:
1623 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1624 name = "Logitech QuickCam Orbit";
1625 type_id = 740; /* CCD sensor */
1626 features |= FEATURE_MOTOR_PANTILT;
1627 break;
1628 case 0x08b6:
1629 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1630 name = "Cisco VT Camera";
1631 type_id = 740; /* CCD sensor */
1632 break;
1633 case 0x08b7:
1634 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1635 name = "Logitech ViewPort AV 100";
1636 type_id = 740; /* CCD sensor */
1637 break;
1638 case 0x08b8: /* Where this released? */
1639 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1640 name = "Logitech QuickCam (res.)";
1641 type_id = 730; /* Assuming CMOS */
1642 break;
1643 default:
1644 return -ENODEV;
1645 break;
1646 }
1647 }
1648 else if (vendor_id == 0x055d) {
1649 /* I don't know the difference between the C10 and the C30;
1650 I suppose the difference is the sensor, but both cameras
1651 work equally well with a type_id of 675
1652 */
1653 switch(product_id) {
1654 case 0x9000:
1655 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1656 name = "Samsung MPC-C10";
1657 type_id = 675;
1658 break;
1659 case 0x9001:
1660 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1661 name = "Samsung MPC-C30";
1662 type_id = 675;
1663 break;
1664 case 0x9002:
1665 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1666 name = "Samsung MPC-C30";
1667 type_id = 740;
1668 break;
1669 default:
1670 return -ENODEV;
1671 break;
1672 }
1673 }
1674 else if (vendor_id == 0x041e) {
1675 switch(product_id) {
1676 case 0x400c:
1677 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1678 name = "Creative Labs Webcam 5";
1679 type_id = 730;
1680 break;
1681 case 0x4011:
1682 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1683 name = "Creative Labs Webcam Pro Ex";
1684 type_id = 740;
1685 break;
1686 default:
1687 return -ENODEV;
1688 break;
1689 }
1690 }
1691 else if (vendor_id == 0x04cc) {
1692 switch(product_id) {
1693 case 0x8116:
1694 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1695 name = "Sotec Afina Eye";
1696 type_id = 730;
1697 break;
1698 default:
1699 return -ENODEV;
1700 break;
1701 }
1702 }
1703 else if (vendor_id == 0x06be) {
1704 switch(product_id) {
1705 case 0x8116:
1706 /* This is essentially the same cam as the Sotec Afina Eye */
1707 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1708 name = "AME Co. Afina Eye";
1709 type_id = 750;
1710 break;
1711 default:
1712 return -ENODEV;
1713 break;
1714 }
1715
1716 }
1717 else if (vendor_id == 0x0d81) {
1718 switch(product_id) {
1719 case 0x1900…Large files files are truncated, but you can click here to view the full file