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