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
72 #include "pwc.h"
73 #include "pwc-kiara.h"
74 #include "pwc-timon.h"
75 #include "pwc-dec23.h"
76 #include "pwc-dec1.h"
77 #include "pwc-uncompress.h"
78
79 /* Function prototypes and driver templates */
80
81 /* hotplug device table support */
82 static const struct usb_device_id pwc_device_table [] = {
83 { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */
84 { USB_DEVICE(0x0471, 0x0303) },
85 { USB_DEVICE(0x0471, 0x0304) },
86 { USB_DEVICE(0x0471, 0x0307) },
87 { USB_DEVICE(0x0471, 0x0308) },
88 { USB_DEVICE(0x0471, 0x030C) },
89 { USB_DEVICE(0x0471, 0x0310) },
90 { USB_DEVICE(0x0471, 0x0311) }, /* Philips ToUcam PRO II */
91 { USB_DEVICE(0x0471, 0x0312) },
92 { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
93 { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC PC Camera */
94 { USB_DEVICE(0x069A, 0x0001) }, /* Askey */
95 { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
96 { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
97 { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
98 { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
99 { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
100 { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
101 { USB_DEVICE(0x046D, 0x08B6) }, /* Cisco VT Camera */
102 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
103 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
104 { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
105 { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
106 { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
107 { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
108 { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
109 { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
110 { USB_DEVICE(0x06BE, 0x8116) }, /* new Afina Eye */
111 { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
112 { USB_DEVICE(0x0d81, 0x1900) },
113 { }
114 };
115 MODULE_DEVICE_TABLE(usb, pwc_device_table);
116
117 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
118 static void usb_pwc_disconnect(struct usb_interface *intf);
119
120 static struct usb_driver pwc_driver = {
121 .name = "Philips webcam", /* name */
122 .id_table = pwc_device_table,
123 .probe = usb_pwc_probe, /* probe() */
124 .disconnect = usb_pwc_disconnect, /* disconnect() */
125 };
126
127 #define MAX_DEV_HINTS 20
128 #define MAX_ISOC_ERRORS 20
129
130 static int default_size = PSZ_QCIF;
131 static int default_fps = 10;
132 static int default_fbufs = 3; /* Default number of frame buffers */
133 int pwc_mbufs = 2; /* Default number of mmap() buffers */
134 #ifdef CONFIG_USB_PWC_DEBUG
135 int pwc_trace = PWC_DEBUG_LEVEL;
136 #endif
137 static int power_save;
138 static int led_on = 100, led_off; /* defaults to LED that is on while in use */
139 static int pwc_preferred_compression = 1; /* 0..3 = uncompressed..high */
140 static struct {
141 int type;
142 char serial_number[30];
143 int device_node;
144 struct pwc_device *pdev;
145 } device_hint[MAX_DEV_HINTS];
146
147 /***/
148
149 static int pwc_video_open(struct file *file);
150 static int pwc_video_close(struct file *file);
151 static ssize_t pwc_video_read(struct file *file, char __user *buf,
152 size_t count, loff_t *ppos);
153 static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
154 static long pwc_video_ioctl(struct file *file,
155 unsigned int ioctlnr, unsigned long arg);
156 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
157
158 static const struct v4l2_file_operations pwc_fops = {
159 .owner = THIS_MODULE,
160 .open = pwc_video_open,
161 .release = pwc_video_close,
162 .read = pwc_video_read,
163 .poll = pwc_video_poll,
164 .mmap = pwc_video_mmap,
165 .ioctl = pwc_video_ioctl,
166 };
167 static struct video_device pwc_template = {
168 .name = "Philips Webcam", /* Filled in later */
169 .release = video_device_release,
170 .fops = &pwc_fops,
171 .minor = -1,
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
214 static 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
234 static 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
254 static 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
336 static 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 */
439 static 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 */
485 static 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 */
519 int 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 */
571 void 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 */
581 static 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
594 static 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
611 static 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 */
689 static 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
803 handler_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
814 int 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
915 static 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
931 static 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
948 void 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
971 int 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 *********/
1004 static 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
1010 static 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
1017 static 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 }
1035 static DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
1036 store_pan_tilt);
1037
1038 static 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
1047 static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
1048 NULL);
1049
1050 static 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) goto err_button;
1061 }
1062
1063 return 0;
1064
1065 err_button:
1066 device_remove_file(&vdev->dev, &dev_attr_button);
1067 err:
1068 PWC_ERROR("Could not create sysfs files.\n");
1069 return rc;
1070 }
1071
1072 static void pwc_remove_sysfs_files(struct video_device *vdev)
1073 {
1074 struct pwc_device *pdev = video_get_drvdata(vdev);
1075 if (pdev->features & FEATURE_MOTOR_PANTILT)
1076 device_remove_file(&vdev->dev, &dev_attr_pan_tilt);
1077 device_remove_file(&vdev->dev, &dev_attr_button);
1078 }
1079
1080 #ifdef CONFIG_USB_PWC_DEBUG
1081 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
1082 {
1083 switch(sensor_type) {
1084 case 0x00:
1085 return "Hyundai CMOS sensor";
1086 case 0x20:
1087 return "Sony CCD sensor + TDA8787";
1088 case 0x2E:
1089 return "Sony CCD sensor + Exas 98L59";
1090 case 0x2F:
1091 return "Sony CCD sensor + ADI 9804";
1092 case 0x30:
1093 return "Sharp CCD sensor + TDA8787";
1094 case 0x3E:
1095 return "Sharp CCD sensor + Exas 98L59";
1096 case 0x3F:
1097 return "Sharp CCD sensor + ADI 9804";
1098 case 0x40:
1099 return "UPA 1021 sensor";
1100 case 0x100:
1101 return "VGA sensor";
1102 case 0x101:
1103 return "PAL MR sensor";
1104 default:
1105 return "unknown type of sensor";
1106 }
1107 }
1108 #endif
1109
1110 /***************************************************************************/
1111 /* Video4Linux functions */
1112
1113 static int pwc_video_open(struct file *file)
1114 {
1115 int i, ret;
1116 struct video_device *vdev = video_devdata(file);
1117 struct pwc_device *pdev;
1118
1119 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
1120
1121 pdev = video_get_drvdata(vdev);
1122 BUG_ON(!pdev);
1123 if (pdev->vopen) {
1124 PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
1125 return -EBUSY;
1126 }
1127
1128 mutex_lock(&pdev->modlock);
1129 pwc_construct(pdev); /* set min/max sizes correct */
1130 if (!pdev->usb_init) {
1131 PWC_DEBUG_OPEN("Doing first time initialization.\n");
1132 pdev->usb_init = 1;
1133
1134 /* Query sensor type */
1135 ret = pwc_get_cmos_sensor(pdev, &i);
1136 if (ret >= 0)
1137 {
1138 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1139 pdev->vdev->name,
1140 pwc_sensor_type_to_string(i), i);
1141 }
1142 }
1143
1144 /* Turn on camera */
1145 if (power_save) {
1146 i = pwc_camera_power(pdev, 1);
1147 if (i < 0)
1148 PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
1149 }
1150 /* Set LED on/off time */
1151 if (pwc_set_leds(pdev, led_on, led_off) < 0)
1152 PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
1153
1154
1155 /* So far, so good. Allocate memory. */
1156 i = pwc_allocate_buffers(pdev);
1157 if (i < 0) {
1158 PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
1159 pwc_free_buffers(pdev);
1160 mutex_unlock(&pdev->modlock);
1161 return i;
1162 }
1163
1164 /* Reset buffers & parameters */
1165 pwc_reset_buffers(pdev);
1166 for (i = 0; i < pwc_mbufs; i++)
1167 pdev->image_used[i] = 0;
1168 pdev->vframe_count = 0;
1169 pdev->vframes_dumped = 0;
1170 pdev->vframes_error = 0;
1171 pdev->visoc_errors = 0;
1172 pdev->error_status = 0;
1173 pwc_construct(pdev); /* set min/max sizes correct */
1174
1175 /* Set some defaults */
1176 pdev->vsnapshot = 0;
1177
1178 /* Start iso pipe for video; first try the last used video size
1179 (or the default one); if that fails try QCIF/10 or QSIF/10;
1180 it that fails too, give up.
1181 */
1182 i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
1183 if (i) {
1184 unsigned int default_resolution;
1185 PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
1186 if (pdev->type>= 730)
1187 default_resolution = PSZ_QSIF;
1188 else
1189 default_resolution = PSZ_QCIF;
1190
1191 i = pwc_set_video_mode(pdev,
1192 pwc_image_sizes[default_resolution].x,
1193 pwc_image_sizes[default_resolution].y,
1194 10,
1195 pdev->vcompression,
1196 0);
1197 }
1198 if (i) {
1199 PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
1200 pwc_free_buffers(pdev);
1201 mutex_unlock(&pdev->modlock);
1202 return i;
1203 }
1204
1205 i = pwc_isoc_init(pdev);
1206 if (i) {
1207 PWC_DEBUG_OPEN("Failed to init ISOC stuff = %d.\n", i);
1208 pwc_isoc_cleanup(pdev);
1209 pwc_free_buffers(pdev);
1210 mutex_unlock(&pdev->modlock);
1211 return i;
1212 }
1213
1214 /* Initialize the webcam to sane value */
1215 pwc_set_brightness(pdev, 0x7fff);
1216 pwc_set_agc(pdev, 1, 0);
1217
1218 pdev->vopen++;
1219 file->private_data = vdev;
1220 mutex_unlock(&pdev->modlock);
1221 PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
1222 return 0;
1223 }
1224
1225
1226 static void pwc_cleanup(struct pwc_device *pdev)
1227 {
1228 pwc_remove_sysfs_files(pdev->vdev);
1229 video_unregister_device(pdev->vdev);
1230
1231 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1232 if (pdev->button_dev) {
1233 input_unregister_device(pdev->button_dev);
1234 input_free_device(pdev->button_dev);
1235 kfree(pdev->button_dev->phys);
1236 pdev->button_dev = NULL;
1237 }
1238 #endif
1239 }
1240
1241 /* Note that all cleanup is done in the reverse order as in _open */
1242 static 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 /* Free memory (don't set pdev to 0 just yet) */
1285 kfree(pdev);
1286 /* search device_hint[] table if we occupy a slot, by any chance */
1287 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1288 if (device_hint[hint].pdev == pdev)
1289 device_hint[hint].pdev = NULL;
1290 }
1291 unlock_kernel();
1292
1293 return 0;
1294 }
1295
1296 /*
1297 * FIXME: what about two parallel reads ????
1298 * ANSWER: Not supported. You can't open the device more than once,
1299 despite what the V4L1 interface says. First, I don't see
1300 the need, second there's no mechanism of alerting the
1301 2nd/3rd/... process of events like changing image size.
1302 And I don't see the point of blocking that for the
1303 2nd/3rd/... process.
1304 In multi-threaded environments reading parallel from any
1305 device is tricky anyhow.
1306 */
1307
1308 static ssize_t pwc_video_read(struct file *file, char __user *buf,
1309 size_t count, loff_t *ppos)
1310 {
1311 struct video_device *vdev = file->private_data;
1312 struct pwc_device *pdev;
1313 int noblock = file->f_flags & O_NONBLOCK;
1314 DECLARE_WAITQUEUE(wait, current);
1315 int bytes_to_read, rv = 0;
1316 void *image_buffer_addr;
1317
1318 PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
1319 vdev, buf, count);
1320 if (vdev == NULL)
1321 return -EFAULT;
1322 pdev = video_get_drvdata(vdev);
1323 if (pdev == NULL)
1324 return -EFAULT;
1325
1326 mutex_lock(&pdev->modlock);
1327 if (pdev->error_status) {
1328 rv = -pdev->error_status; /* Something happened, report what. */
1329 goto err_out;
1330 }
1331
1332 /* In case we're doing partial reads, we don't have to wait for a frame */
1333 if (pdev->image_read_pos == 0) {
1334 /* Do wait queueing according to the (doc)book */
1335 add_wait_queue(&pdev->frameq, &wait);
1336 while (pdev->full_frames == NULL) {
1337 /* Check for unplugged/etc. here */
1338 if (pdev->error_status) {
1339 remove_wait_queue(&pdev->frameq, &wait);
1340 set_current_state(TASK_RUNNING);
1341 rv = -pdev->error_status ;
1342 goto err_out;
1343 }
1344 if (noblock) {
1345 remove_wait_queue(&pdev->frameq, &wait);
1346 set_current_state(TASK_RUNNING);
1347 rv = -EWOULDBLOCK;
1348 goto err_out;
1349 }
1350 if (signal_pending(current)) {
1351 remove_wait_queue(&pdev->frameq, &wait);
1352 set_current_state(TASK_RUNNING);
1353 rv = -ERESTARTSYS;
1354 goto err_out;
1355 }
1356 schedule();
1357 set_current_state(TASK_INTERRUPTIBLE);
1358 }
1359 remove_wait_queue(&pdev->frameq, &wait);
1360 set_current_state(TASK_RUNNING);
1361
1362 /* Decompress and release frame */
1363 if (pwc_handle_frame(pdev)) {
1364 rv = -EFAULT;
1365 goto err_out;
1366 }
1367 }
1368
1369 PWC_DEBUG_READ("Copying data to user space.\n");
1370 if (pdev->vpalette == VIDEO_PALETTE_RAW)
1371 bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
1372 else
1373 bytes_to_read = pdev->view.size;
1374
1375 /* copy bytes to user space; we allow for partial reads */
1376 if (count + pdev->image_read_pos > bytes_to_read)
1377 count = bytes_to_read - pdev->image_read_pos;
1378 image_buffer_addr = pdev->image_data;
1379 image_buffer_addr += pdev->images[pdev->fill_image].offset;
1380 image_buffer_addr += pdev->image_read_pos;
1381 if (copy_to_user(buf, image_buffer_addr, count)) {
1382 rv = -EFAULT;
1383 goto err_out;
1384 }
1385 pdev->image_read_pos += count;
1386 if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
1387 pdev->image_read_pos = 0;
1388 pwc_next_image(pdev);
1389 }
1390 mutex_unlock(&pdev->modlock);
1391 return count;
1392 err_out:
1393 mutex_unlock(&pdev->modlock);
1394 return rv;
1395 }
1396
1397 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
1398 {
1399 struct video_device *vdev = file->private_data;
1400 struct pwc_device *pdev;
1401
1402 if (vdev == NULL)
1403 return -EFAULT;
1404 pdev = video_get_drvdata(vdev);
1405 if (pdev == NULL)
1406 return -EFAULT;
1407
1408 poll_wait(file, &pdev->frameq, wait);
1409 if (pdev->error_status)
1410 return POLLERR;
1411 if (pdev->full_frames != NULL) /* we have frames waiting */
1412 return (POLLIN | POLLRDNORM);
1413
1414 return 0;
1415 }
1416
1417 static long pwc_video_ioctl(struct file *file,
1418 unsigned int cmd, unsigned long arg)
1419 {
1420 struct video_device *vdev = file->private_data;
1421 struct pwc_device *pdev;
1422 long r = -ENODEV;
1423
1424 if (!vdev)
1425 goto out;
1426 pdev = video_get_drvdata(vdev);
1427
1428 mutex_lock(&pdev->modlock);
1429 if (!pdev->unplugged)
1430 r = video_usercopy(file, cmd, arg, pwc_video_do_ioctl);
1431 mutex_unlock(&pdev->modlock);
1432 out:
1433 return r;
1434 }
1435
1436 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
1437 {
1438 struct video_device *vdev = file->private_data;
1439 struct pwc_device *pdev;
1440 unsigned long start;
1441 unsigned long size;
1442 unsigned long page, pos = 0;
1443 int index;
1444
1445 PWC_DEBUG_MEMORY(">> %s\n", __func__);
1446 pdev = video_get_drvdata(vdev);
1447 size = vma->vm_end - vma->vm_start;
1448 start = vma->vm_start;
1449
1450 /* Find the idx buffer for this mapping */
1451 for (index = 0; index < pwc_mbufs; index++) {
1452 pos = pdev->images[index].offset;
1453 if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
1454 break;
1455 }
1456 if (index == MAX_IMAGES)
1457 return -EINVAL;
1458 if (index == 0) {
1459 /*
1460 * Special case for v4l1. In v4l1, we map only one big buffer,
1461 * but in v4l2 each buffer is mapped
1462 */
1463 unsigned long total_size;
1464 total_size = pwc_mbufs * pdev->len_per_image;
1465 if (size != pdev->len_per_image && size != total_size) {
1466 PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
1467 size, pdev->len_per_image, total_size);
1468 return -EINVAL;
1469 }
1470 } else if (size > pdev->len_per_image)
1471 return -EINVAL;
1472
1473 vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
1474
1475 pos += (unsigned long)pdev->image_data;
1476 while (size > 0) {
1477 page = vmalloc_to_pfn((void *)pos);
1478 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
1479 return -EAGAIN;
1480 start += PAGE_SIZE;
1481 pos += PAGE_SIZE;
1482 if (size > PAGE_SIZE)
1483 size -= PAGE_SIZE;
1484 else
1485 size = 0;
1486 }
1487 return 0;
1488 }
1489
1490 /***************************************************************************/
1491 /* USB functions */
1492
1493 /* This function gets called when a new device is plugged in or the usb core
1494 * is loaded.
1495 */
1496
1497 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
1498 {
1499 struct usb_device *udev = interface_to_usbdev(intf);
1500 struct pwc_device *pdev = NULL;
1501 int vendor_id, product_id, type_id;
1502 int i, hint, rc;
1503 int features = 0;
1504 int video_nr = -1; /* default: use next available device */
1505 char serial_number[30], *name;
1506 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1507 char *phys = NULL;
1508 #endif
1509
1510 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
1511 product_id = le16_to_cpu(udev->descriptor.idProduct);
1512
1513 /* Check if we can handle this device */
1514 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
1515 vendor_id, product_id,
1516 intf->altsetting->desc.bInterfaceNumber);
1517
1518 /* the interfaces are probed one by one. We are only interested in the
1519 video interface (0) now.
1520 Interface 1 is the Audio Control, and interface 2 Audio itself.
1521 */
1522 if (intf->altsetting->desc.bInterfaceNumber > 0)
1523 return -ENODEV;
1524
1525 if (vendor_id == 0x0471) {
1526 switch (product_id) {
1527 case 0x0302:
1528 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
1529 name = "Philips 645 webcam";
1530 type_id = 645;
1531 break;
1532 case 0x0303:
1533 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
1534 name = "Philips 646 webcam";
1535 type_id = 646;
1536 break;
1537 case 0x0304:
1538 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
1539 name = "Askey VC010 webcam";
1540 type_id = 646;
1541 break;
1542 case 0x0307:
1543 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
1544 name = "Philips 675 webcam";
1545 type_id = 675;
1546 break;
1547 case 0x0308:
1548 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
1549 name = "Philips 680 webcam";
1550 type_id = 680;
1551 break;
1552 case 0x030C:
1553 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
1554 name = "Philips 690 webcam";
1555 type_id = 690;
1556 break;
1557 case 0x0310:
1558 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
1559 name = "Philips 730 webcam";
1560 type_id = 730;
1561 break;
1562 case 0x0311:
1563 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
1564 name = "Philips 740 webcam";
1565 type_id = 740;
1566 break;
1567 case 0x0312:
1568 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
1569 name = "Philips 750 webcam";
1570 type_id = 750;
1571 break;
1572 case 0x0313:
1573 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
1574 name = "Philips 720K/40 webcam";
1575 type_id = 720;
1576 break;
1577 case 0x0329:
1578 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
1579 name = "Philips SPC 900NC webcam";
1580 type_id = 740;
1581 break;
1582 default:
1583 return -ENODEV;
1584 break;
1585 }
1586 }
1587 else if (vendor_id == 0x069A) {
1588 switch(product_id) {
1589 case 0x0001:
1590 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
1591 name = "Askey VC010 webcam";
1592 type_id = 645;
1593 break;
1594 default:
1595 return -ENODEV;
1596 break;
1597 }
1598 }
1599 else if (vendor_id == 0x046d) {
1600 switch(product_id) {
1601 case 0x08b0:
1602 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
1603 name = "Logitech QuickCam Pro 3000";
1604 type_id = 740; /* CCD sensor */
1605 break;
1606 case 0x08b1:
1607 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
1608 name = "Logitech QuickCam Notebook Pro";
1609 type_id = 740; /* CCD sensor */
1610 break;
1611 case 0x08b2:
1612 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
1613 name = "Logitech QuickCam Pro 4000";
1614 type_id = 740; /* CCD sensor */
1615 break;
1616 case 0x08b3:
1617 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1618 name = "Logitech QuickCam Zoom";
1619 type_id = 740; /* CCD sensor */
1620 break;
1621 case 0x08B4:
1622 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1623 name = "Logitech QuickCam Zoom";
1624 type_id = 740; /* CCD sensor */
1625 power_save = 1;
1626 break;
1627 case 0x08b5:
1628 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1629 name = "Logitech QuickCam Orbit";
1630 type_id = 740; /* CCD sensor */
1631 features |= FEATURE_MOTOR_PANTILT;
1632 break;
1633 case 0x08b6:
1634 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1635 name = "Cisco VT Camera";
1636 type_id = 740; /* CCD sensor */
1637 break;
1638 case 0x08b7:
1639 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1640 name = "Logitech ViewPort AV 100";
1641 type_id = 740; /* CCD sensor */
1642 break;
1643 case 0x08b8: /* Where this released? */
1644 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1645 name = "Logitech QuickCam (res.)";
1646 type_id = 730; /* Assuming CMOS */
1647 break;
1648 default:
1649 return -ENODEV;
1650 break;
1651 }
1652 }
1653 else if (vendor_id == 0x055d) {
1654 /* I don't know the difference between the C10 and the C30;
1655 I suppose the difference is the sensor, but both cameras
1656 work equally well with a type_id of 675
1657 */
1658 switch(product_id) {
1659 case 0x9000:
1660 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1661 name = "Samsung MPC-C10";
1662 type_id = 675;
1663 break;
1664 case 0x9001:
1665 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1666 name = "Samsung MPC-C30";
1667 type_id = 675;
1668 break;
1669 case 0x9002:
1670 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1671 name = "Samsung MPC-C30";
1672 type_id = 740;
1673 break;
1674 default:
1675 return -ENODEV;
1676 break;
1677 }
1678 }
1679 else if (vendor_id == 0x041e) {
1680 switch(product_id) {
1681 case 0x400c:
1682 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1683 name = "Creative Labs Webcam 5";
1684 type_id = 730;
1685 break;
1686 case 0x4011:
1687 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1688 name = "Creative Labs Webcam Pro Ex";
1689 type_id = 740;
1690 break;
1691 default:
1692 return -ENODEV;
1693 break;
1694 }
1695 }
1696 else if (vendor_id == 0x04cc) {
1697 switch(product_id) {
1698 case 0x8116:
1699 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1700 name = "Sotec Afina Eye";
1701 type_id = 730;
1702 break;
1703 default:
1704 return -ENODEV;
1705 break;
1706 }
1707 }
1708 else if (vendor_id == 0x06be) {
1709 switch(product_id) {
1710 case 0x8116:
1711 /* This is essentially the same cam as the Sotec Afina Eye */
1712 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1713 name = "AME Co. Afina Eye";
1714 type_id = 750;
1715 break;
1716 default:
1717 return -ENODEV;
1718 break;
1719 }
1720
1721 }
1722 else if (vendor_id == 0x0d81) {
1723 switch(product_id) {
1724 case 0x1900:
1725 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1726 name = "Visionite VCS-UC300";
1727 type_id = 740; /* CCD sensor */
1728 break;
1729 case 0x1910:
1730 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1731 name = "Visionite VCS-UM100";
1732 type_id = 730; /* CMOS sensor */
1733 break;
1734 default:
1735 return -ENODEV;
1736 break;
1737 }
1738 }
1739 else
1740 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1741
1742 memset(serial_number, 0, 30);
1743 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1744 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1745
1746 if (udev->descriptor.bNumConfigurations > 1)
1747 PWC_WARNING("Warning: more than 1 configuration available.\n");
1748
1749 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1750 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1751 if (pdev == NULL) {
1752 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1753 return -ENOMEM;
1754 }
1755 pdev->type = type_id;
1756 pdev->vsize = default_size;
1757 pdev->vframes = default_fps;
1758 strcpy(pdev->serial, serial_number);
1759 pdev->features = features;
1760 if (vendor_id == 0x046D && product_id == 0x08B5)
1761 {
1762 /* Logitech QuickCam Orbit
1763 The ranges have been determined experimentally; they may differ from cam to cam.
1764 Also, the exact ranges left-right and up-down are different for my cam
1765 */
1766 pdev->angle_range.pan_min = -7000;
1767 pdev->angle_range.pan_max = 7000;
1768 pdev->angle_range.tilt_min = -3000;
1769 pdev->angle_range.tilt_max = 2500;
1770 }
1771
1772 mutex_init(&pdev->modlock);
1773 spin_lock_init(&pdev->ptrlock);
1774
1775 pdev->udev = udev;
1776 init_waitqueue_head(&pdev->frameq);
1777 pdev->vcompression = pwc_preferred_compression;
1778
1779 /* Allocate video_device structure */
1780 pdev->vdev = video_device_alloc();
1781 if (!pdev->vdev) {
1782 PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
1783 kfree(pdev);
1784 return -ENOMEM;
1785 }
1786 memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
1787 pdev->vdev->parent = &intf->dev;
1788 strcpy(pdev->vdev->name, name);
1789 video_set_drvdata(pdev->vdev, pdev);
1790
1791 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1792 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1793
1794 /* Now search device_hint[] table for a match, so we can hint a node number. */
1795 for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1796 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1797 (device_hint[hint].pdev == NULL)) {
1798 /* so far, so good... try serial number */
1799 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1800 /* match! */
1801 video_nr = device_hint[hint].device_node;
1802 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1803 break;
1804 }
1805 }
1806 }
1807
1808 pdev->vdev->release = video_device_release;
1809 i = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1810 if (i < 0) {
1811 PWC_ERROR("Failed to register as video device (%d).\n", i);
1812 rc = i;
1813 goto err;
1814 }
1815 else {
1816 PWC_INFO("Registered as /dev/video%d.\n", pdev->vdev->num);
1817 }
1818
1819 /* occupy slot */
1820 if (hint < MAX_DEV_HINTS)
1821 device_hint[hint].pdev = pdev;
1822
1823 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1824 usb_set_intfdata (intf, pdev);
1825 rc = pwc_create_sysfs_files(pdev->vdev);
1826 if (rc)
1827 goto err_unreg;
1828
1829 /* Set the leds off */
1830 pwc_set_leds(pdev, 0, 0);
1831 pwc_camera_power(pdev, 0);
1832
1833 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1834 /* register webcam snapshot button input device */
1835 pdev->button_dev = input_allocate_device();
1836 if (!pdev->button_dev) {
1837 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1838 return -ENOMEM;
1839 }
1840
1841 pdev->button_dev->name = "PWC snapshot button";
1842 phys = kasprintf(GFP_KERNEL,"usb-%s-%s", pdev->udev->bus->bus_name, pdev->udev->devpath);
1843 if (!phys) {
1844 input_free_device(pdev->button_dev);
1845 return -ENOMEM;
1846 }
1847 pdev->button_dev->phys = phys;
1848 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1849 pdev->button_dev->dev.parent = &pdev->udev->dev;
1850 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1851 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1852
1853 rc = input_register_device(pdev->button_dev);
1854 if (rc) {
1855 input_free_device(pdev->button_dev);
1856 kfree(pdev->button_dev->phys);
1857 pdev->button_dev = NULL;
1858 return rc;
1859 }
1860 #endif
1861
1862 return 0;
1863
1864 err_unreg:
1865 if (hint < MAX_DEV_HINTS)
1866 device_hint[hint].pdev = NULL;
1867 video_unregister_device(pdev->vdev);
1868 err:
1869 video_device_release(pdev->vdev); /* Drip... drip... drip... */
1870 kfree(pdev); /* Oops, no memory leaks please */
1871 return rc;
1872 }
1873
1874 /* The user janked out the cable... */
1875 static void usb_pwc_disconnect(struct usb_interface *intf)
1876 {
1877 struct pwc_device *pdev;
1878 int hint;
1879
1880 lock_kernel();
1881 pdev = usb_get_intfdata (intf);
1882 usb_set_intfdata (intf, NULL);
1883 if (pdev == NULL) {
1884 PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
1885 goto disconnect_out;
1886 }
1887 if (pdev->udev == NULL) {
1888 PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
1889 goto disconnect_out;
1890 }
1891 if (pdev->udev != interface_to_usbdev(intf)) {
1892 PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
1893 goto disconnect_out;
1894 }
1895
1896 /* We got unplugged; this is signalled by an EPIPE error code */
1897 if (pdev->vopen) {
1898 PWC_INFO("Disconnected while webcam is in use!\n");
1899 pdev->error_status = EPIPE;
1900 }
1901
1902 /* Alert waiting processes */
1903 wake_up_interruptible(&pdev->frameq);
1904 /* Wait until device is closed */
1905 if(pdev->vopen) {
1906 mutex_lock(&pdev->modlock);
1907 pdev->unplugged = 1;
1908 mutex_unlock(&pdev->modlock);
1909 pwc_iso_stop(pdev);
1910 } else {
1911 /* Device is closed, so we can safely unregister it */
1912 PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
1913 pwc_cleanup(pdev);
1914 /* Free memory (don't set pdev to 0 just yet) */
1915 kfree(pdev);
1916
1917 disconnect_out:
1918 /* search device_hint[] table if we occupy a slot, by any chance */
1919 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
1920 if (device_hint[hint].pdev == pdev)
1921 device_hint[hint].pdev = NULL;
1922 }
1923
1924 unlock_kernel();
1925 }
1926
1927 /* *grunt* We have to do atoi ourselves :-( */
1928 static int pwc_atoi(const char *s)
1929 {
1930 int k = 0;
1931
1932 k = 0;
1933 while (*s != '\0' && *s >= '' && *s <= '9') {
1934 k = 10 * k + (*s - '');
1935 s++;
1936 }
1937 return k;
1938 }
1939
1940
1941 /*
1942 * Initialization code & module stuff
1943 */
1944
1945 static char *size;
1946 static int fps;
1947 static int fbufs;
1948 static int mbufs;
1949 static int compression = -1;
1950 static int leds[2] = { -1, -1 };
1951 static unsigned int leds_nargs;
1952 static char *dev_hint[MAX_DEV_HINTS];
1953 static unsigned int dev_hint_nargs;
1954
1955 module_param(size, charp, 0444);
1956 module_param(fps, int, 0444);
1957 module_param(fbufs, int, 0444);
1958 module_param(mbufs, int, 0444);
1959 #ifdef CONFIG_USB_PWC_DEBUG
1960 module_param_named(trace, pwc_trace, int, 0644);
1961 #endif
1962 module_param(power_save, int, 0444);
1963 module_param(compression, int, 0444);
1964 module_param_array(leds, int, &leds_nargs, 0444);
1965 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1966
1967 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
1968 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1969 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
1970 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
1971 MODULE_PARM_DESC(trace, "For debugging purposes");
1972 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
1973 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1974 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1975 MODULE_PARM_DESC(dev_hint, "Device node hints");
1976
1977 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1978 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1979 MODULE_LICENSE("GPL");
1980 MODULE_ALIAS("pwcx");
1981 MODULE_VERSION( PWC_VERSION );
1982
1983 static int __init usb_pwc_init(void)
1984 {
1985 int i, sz;
1986 char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
1987
1988 PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1989 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1990 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1991 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1992
1993 if (fps) {
1994 if (fps < 4 || fps > 30) {
1995 PWC_ERROR("Framerate out of bounds (4-30).\n");
1996 return -EINVAL;
1997 }
1998 default_fps = fps;
1999 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
2000 }
2001
2002 if (size) {
2003 /* string; try matching with array */
2004 for (sz = 0; sz < PSZ_MAX; sz++) {
2005 if (!strcmp(sizenames[sz], size)) { /* Found! */
2006 default_size = sz;
2007 break;
2008 }
2009 }
2010 if (sz == PSZ_MAX) {
2011 PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
2012 return -EINVAL;
2013 }
2014 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);
2015 }
2016 if (mbufs) {
2017 if (mbufs < 1 || mbufs > MAX_IMAGES) {
2018 PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
2019 return -EINVAL;
2020 }
2021 pwc_mbufs = mbufs;
2022 PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
2023 }
2024 if (fbufs) {
2025 if (fbufs < 2 || fbufs > MAX_FRAMES) {
2026 PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
2027 return -EINVAL;
2028 }
2029 default_fbufs = fbufs;
2030 PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
2031 }
2032 #ifdef CONFIG_USB_PWC_DEBUG
2033 if (pwc_trace >= 0) {
2034 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
2035 }
2036 #endif
2037 if (compression >= 0) {
2038 if (compression > 3) {
2039 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
2040 return -EINVAL;
2041 }
2042 pwc_preferred_compression = compression;
2043 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
2044 }
2045 if (power_save)
2046 PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
2047 if (leds[0] >= 0)
2048 led_on = leds[0];
2049 if (leds[1] >= 0)
2050 led_off = leds[1];
2051
2052 /* Big device node whoopla. Basically, it allows you to assign a
2053 device node (/dev/videoX) to a camera, based on its type
2054 & serial number. The format is [type[.serialnumber]:]node.
2055
2056 Any camera that isn't matched by these rules gets the next
2057 available free device node.
2058 */
2059 for (i = 0; i < MAX_DEV_HINTS; i++) {
2060 char *s, *colon, *dot;
2061
2062 /* This loop also initializes the array */
2063 device_hint[i].pdev = NULL;
2064 s = dev_hint[i];
2065 if (s != NULL && *s != '\0') {
2066 device_hint[i].type = -1; /* wildcard */
2067 strcpy(device_hint[i].serial_number, "*");
2068
2069 /* parse string: chop at ':' & '/' */
2070 colon = dot = s;
2071 while (*colon != '\0' && *colon != ':')
2072 colon++;
2073 while (*dot != '\0' && *dot != '.')
2074 dot++;
2075 /* Few sanity checks */
2076 if (*dot != '\0' && dot > colon) {
2077 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
2078 return -EINVAL;
2079 }
2080
2081 if (*colon == '\0') {
2082 /* No colon */
2083 if (*dot != '\0') {
2084 PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
2085 return -EINVAL;
2086 }
2087 else {
2088 /* No type or serial number specified, just a number. */
2089 device_hint[i].device_node = pwc_atoi(s);
2090 }
2091 }
2092 else {
2093 /* There's a colon, so we have at least a type and a device node */
2094 device_hint[i].type = pwc_atoi(s);
2095 device_hint[i].device_node = pwc_atoi(colon + 1);
2096 if (*dot != '\0') {
2097 /* There's a serial number as well */
2098 int k;
2099
2100 dot++;
2101 k = 0;
2102 while (*dot != ':' && k < 29) {
2103 device_hint[i].serial_number[k++] = *dot;
2104 dot++;
2105 }
2106 device_hint[i].serial_number[k] = '\0';
2107 }
2108 }
2109 PWC_TRACE("device_hint[%d]:\n", i);
2110 PWC_TRACE(" type : %d\n", device_hint[i].type);
2111 PWC_TRACE(" serial# : %s\n", device_hint[i].serial_number);
2112 PWC_TRACE(" node : %d\n", device_hint[i].device_node);
2113 }
2114 else
2115 device_hint[i].type = 0; /* not filled */
2116 } /* ..for MAX_DEV_HINTS */
2117
2118 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
2119 return usb_register(&pwc_driver);
2120 }
2121
2122 static void __exit usb_pwc_exit(void)
2123 {
2124 PWC_DEBUG_MODULE("Deregistering driver.\n");
2125 usb_deregister(&pwc_driver);
2126 PWC_INFO("Philips webcam module removed.\n");
2127 }
2128
2129 module_init(usb_pwc_init);
2130 module_exit(usb_pwc_exit);
2131
2132 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
2133
|
This page was automatically generated by the
LXR engine.
|