?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'moduleh/module.h-split'
[linux-2.6/next.git] / drivers / media / video / pwc / pwc-if.c
blob51ca3589b1b5987b7a19284613d8bc894376e982
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 (C) 2011 Hans de Goede <hdegoede@redhat.com>
6
7 NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
8 driver and thus may have bugs that are not present in the original version.
9 Please send bug reports and support requests to <luc@saillard.org>.
10 The decompression routines have been implemented by reverse-engineering the
11 Nemosoft binary pwcx module. Caveat emptor.
12
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26
27 */
28
29 /*
30 This code forms the interface between the USB layers and the Philips
31 specific stuff. Some adanved stuff of the driver falls under an
32 NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
33 is thus not distributed in source form. The binary pwcx.o module
34 contains the code that falls under the NDA.
35
36 In case you're wondering: 'pwc' stands for "Philips WebCam", but
37 I really didn't want to type 'philips_web_cam' every time (I'm lazy as
38 any Linux kernel hacker, but I don't like uncomprehensible abbreviations
39 without explanation).
40
41 Oh yes, convention: to disctinguish between all the various pointers to
42 device-structures, I use these names for the pointer variables:
43 udev: struct usb_device *
44 vdev: struct video_device (member of pwc_dev)
45 pdev: struct pwc_devive *
46 */
47
48 /* Contributors:
49 - Alvarado: adding whitebalance code
50 - Alistar Moire: QuickCam 3000 Pro device/product ID
51 - Tony Hoyle: Creative Labs Webcam 5 device/product ID
52 - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
53 - Jk Fang: Sotec Afina Eye ID
54 - Xavier Roche: QuickCam Pro 4000 ID
55 - Jens Knudsen: QuickCam Zoom ID
56 - J. Debert: QuickCam for Notebooks ID
57 - Pham Thanh Nam: webcam snapshot button as an event input device
58 */
59
60 #include <linux/errno.h>
61 #include <linux/init.h>
62 #include <linux/mm.h>
63 #include <linux/module.h>
64 #include <linux/poll.h>
65 #include <linux/slab.h>
66 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
67 #include <linux/usb/input.h>
68 #endif
69 #include <linux/vmalloc.h>
70 #include <asm/io.h>
71 #include <linux/kernel.h> /* simple_strtol() */
72
73 #include "pwc.h"
74 #include "pwc-kiara.h"
75 #include "pwc-timon.h"
76 #include "pwc-dec23.h"
77 #include "pwc-dec1.h"
78
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 static void pwc_isoc_cleanup(struct pwc_device *pdev);
120
121 static struct usb_driver pwc_driver = {
122 .name = "Philips webcam", /* name */
123 .id_table = pwc_device_table,
124 .probe = usb_pwc_probe, /* probe() */
125 .disconnect = usb_pwc_disconnect, /* disconnect() */
126 };
127
128 #define MAX_DEV_HINTS 20
129 #define MAX_ISOC_ERRORS 20
130
131 static int default_fps = 10;
132 #ifdef CONFIG_USB_PWC_DEBUG
133 int pwc_trace = PWC_DEBUG_LEVEL;
134 #endif
135 static int power_save = -1;
136 static int led_on = 100, led_off; /* defaults to LED that is on while in use */
137 static int pwc_preferred_compression = 1; /* 0..3 = uncompressed..high */
138 static struct {
139 int type;
140 char serial_number[30];
141 int device_node;
142 struct pwc_device *pdev;
143 } device_hint[MAX_DEV_HINTS];
144
145 /***/
146
147 static int pwc_video_open(struct file *file);
148 static int pwc_video_close(struct file *file);
149 static ssize_t pwc_video_read(struct file *file, char __user *buf,
150 size_t count, loff_t *ppos);
151 static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
152 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma);
153 static void pwc_video_release(struct video_device *vfd);
154
155 static const struct v4l2_file_operations pwc_fops = {
156 .owner = THIS_MODULE,
157 .open = pwc_video_open,
158 .release = pwc_video_close,
159 .read = pwc_video_read,
160 .poll = pwc_video_poll,
161 .mmap = pwc_video_mmap,
162 .unlocked_ioctl = video_ioctl2,
163 };
164 static struct video_device pwc_template = {
165 .name = "Philips Webcam", /* Filled in later */
166 .release = pwc_video_release,
167 .fops = &pwc_fops,
168 .ioctl_ops = &pwc_ioctl_ops,
169 };
170
171 /***************************************************************************/
172 /* Private functions */
173
174 struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
175 {
176 unsigned long flags = 0;
177 struct pwc_frame_buf *buf = NULL;
178
179 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
180 if (list_empty(&pdev->queued_bufs))
181 goto leave;
182
183 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
184 list_del(&buf->list);
185 leave:
186 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
187 return buf;
188 }
189
190 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
191 {
192 if (down) {
193 PWC_TRACE("Snapshot button pressed.\n");
194 pdev->snapshot_button_status = 1;
195 } else {
196 PWC_TRACE("Snapshot button released.\n");
197 }
198
199 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
200 if (pdev->button_dev) {
201 input_report_key(pdev->button_dev, KEY_CAMERA, down);
202 input_sync(pdev->button_dev);
203 }
204 #endif
205 }
206
207 static void pwc_frame_complete(struct pwc_device *pdev)
208 {
209 struct pwc_frame_buf *fbuf = pdev->fill_buf;
210
211 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
212 frames on the USB wire after an exposure change. This conditition is
213 however detected in the cam and a bit is set in the header.
214 */
215 if (pdev->type == 730) {
216 unsigned char *ptr = (unsigned char *)fbuf->data;
217
218 if (ptr[1] == 1 && ptr[0] & 0x10) {
219 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
220 pdev->drop_frames += 2;
221 }
222 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
223 pwc_snapshot_button(pdev, ptr[0] & 0x01);
224 }
225 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
226 if (ptr[0] & 0x02)
227 PWC_TRACE("Image is mirrored.\n");
228 else
229 PWC_TRACE("Image is normal.\n");
230 }
231 pdev->vmirror = ptr[0] & 0x03;
232 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
233 after a short frame; this condition is filtered out specifically. A 4 byte
234 frame doesn't make sense anyway.
235 So we get either this sequence:
236 drop_bit set -> 4 byte frame -> short frame -> good frame
237 Or this one:
238 drop_bit set -> short frame -> good frame
239 So we drop either 3 or 2 frames in all!
240 */
241 if (fbuf->filled == 4)
242 pdev->drop_frames++;
243 } else if (pdev->type == 740 || pdev->type == 720) {
244 unsigned char *ptr = (unsigned char *)fbuf->data;
245 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
246 pwc_snapshot_button(pdev, ptr[0] & 0x01);
247 }
248 pdev->vmirror = ptr[0] & 0x03;
249 }
250
251 /* In case we were instructed to drop the frame, do so silently. */
252 if (pdev->drop_frames > 0) {
253 pdev->drop_frames--;
254 } else {
255 /* Check for underflow first */
256 if (fbuf->filled < pdev->frame_total_size) {
257 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
258 " discarded.\n", fbuf->filled);
259 } else {
260 fbuf->vb.v4l2_buf.field = V4L2_FIELD_NONE;
261 fbuf->vb.v4l2_buf.sequence = pdev->vframe_count;
262 vb2_buffer_done(&fbuf->vb, VB2_BUF_STATE_DONE);
263 pdev->fill_buf = NULL;
264 pdev->vsync = 0;
265 }
266 } /* !drop_frames */
267 pdev->vframe_count++;
268 }
269
270 /* This gets called for the Isochronous pipe (video). This is done in
271 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
272 */
273 static void pwc_isoc_handler(struct urb *urb)
274 {
275 struct pwc_device *pdev = (struct pwc_device *)urb->context;
276 int i, fst, flen;
277 unsigned char *iso_buf = NULL;
278
279 if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
280 urb->status == -ESHUTDOWN) {
281 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
282 return;
283 }
284
285 if (pdev->fill_buf == NULL)
286 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
287
288 if (urb->status != 0) {
289 const char *errmsg;
290
291 errmsg = "Unknown";
292 switch(urb->status) {
293 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
294 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
295 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
296 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
297 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
298 case -ETIME: errmsg = "Device does not respond"; break;
299 }
300 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
301 urb->status, errmsg);
302 /* Give up after a number of contiguous errors */
303 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
304 {
305 PWC_ERROR("Too many ISOC errors, bailing out.\n");
306 if (pdev->fill_buf) {
307 vb2_buffer_done(&pdev->fill_buf->vb,
308 VB2_BUF_STATE_ERROR);
309 pdev->fill_buf = NULL;
310 }
311 }
312 pdev->vsync = 0; /* Drop the current frame */
313 goto handler_end;
314 }
315
316 /* Reset ISOC error counter. We did get here, after all. */
317 pdev->visoc_errors = 0;
318
319 /* vsync: 0 = don't copy data
320 1 = sync-hunt
321 2 = synched
322 */
323 /* Compact data */
324 for (i = 0; i < urb->number_of_packets; i++) {
325 fst = urb->iso_frame_desc[i].status;
326 flen = urb->iso_frame_desc[i].actual_length;
327 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
328 if (fst != 0) {
329 PWC_ERROR("Iso frame %d has error %d\n", i, fst);
330 continue;
331 }
332 if (flen > 0 && pdev->vsync) {
333 struct pwc_frame_buf *fbuf = pdev->fill_buf;
334
335 if (pdev->vsync == 1) {
336 do_gettimeofday(&fbuf->vb.v4l2_buf.timestamp);
337 pdev->vsync = 2;
338 }
339
340 if (flen + fbuf->filled > pdev->frame_total_size) {
341 PWC_ERROR("Frame overflow (%d > %d)\n",
342 flen + fbuf->filled,
343 pdev->frame_total_size);
344 pdev->vsync = 0; /* Let's wait for an EOF */
345 } else {
346 memcpy(fbuf->data + fbuf->filled, iso_buf,
347 flen);
348 fbuf->filled += flen;
349 }
350 }
351 if (flen < pdev->vlast_packet_size) {
352 /* Shorter packet... end of frame */
353 if (pdev->vsync == 2)
354 pwc_frame_complete(pdev);
355 if (pdev->fill_buf == NULL)
356 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
357 if (pdev->fill_buf) {
358 pdev->fill_buf->filled = 0;
359 pdev->vsync = 1;
360 }
361 }
362 pdev->vlast_packet_size = flen;
363 }
364
365 handler_end:
366 i = usb_submit_urb(urb, GFP_ATOMIC);
367 if (i != 0)
368 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
369 }
370
371 static int pwc_isoc_init(struct pwc_device *pdev)
372 {
373 struct usb_device *udev;
374 struct urb *urb;
375 int i, j, ret;
376 struct usb_interface *intf;
377 struct usb_host_interface *idesc = NULL;
378
379 if (pdev->iso_init)
380 return 0;
381
382 pdev->vsync = 0;
383 pdev->vlast_packet_size = 0;
384 pdev->fill_buf = NULL;
385 pdev->vframe_count = 0;
386 pdev->visoc_errors = 0;
387 udev = pdev->udev;
388
389 /* Get the current alternate interface, adjust packet size */
390 intf = usb_ifnum_to_if(udev, 0);
391 if (intf)
392 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
393 if (!idesc)
394 return -EIO;
395
396 /* Search video endpoint */
397 pdev->vmax_packet_size = -1;
398 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
399 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
400 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
401 break;
402 }
403 }
404
405 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
406 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
407 return -ENFILE; /* Odd error, that should be noticeable */
408 }
409
410 /* Set alternate interface */
411 ret = 0;
412 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
413 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
414 if (ret < 0)
415 return ret;
416
417 /* Allocate and init Isochronuous urbs */
418 for (i = 0; i < MAX_ISO_BUFS; i++) {
419 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
420 if (urb == NULL) {
421 PWC_ERROR("Failed to allocate urb %d\n", i);
422 pdev->iso_init = 1;
423 pwc_isoc_cleanup(pdev);
424 return -ENOMEM;
425 }
426 pdev->urbs[i] = urb;
427 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
428
429 urb->interval = 1; // devik
430 urb->dev = udev;
431 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
432 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
433 urb->transfer_buffer = usb_alloc_coherent(udev,
434 ISO_BUFFER_SIZE,
435 GFP_KERNEL,
436 &urb->transfer_dma);
437 if (urb->transfer_buffer == NULL) {
438 PWC_ERROR("Failed to allocate urb buffer %d\n", i);
439 pdev->iso_init = 1;
440 pwc_isoc_cleanup(pdev);
441 return -ENOMEM;
442 }
443 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
444 urb->complete = pwc_isoc_handler;
445 urb->context = pdev;
446 urb->start_frame = 0;
447 urb->number_of_packets = ISO_FRAMES_PER_DESC;
448 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
449 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
450 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
451 }
452 }
453
454 /* link */
455 for (i = 0; i < MAX_ISO_BUFS; i++) {
456 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
457 if (ret) {
458 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
459 pdev->iso_init = 1;
460 pwc_isoc_cleanup(pdev);
461 return ret;
462 }
463 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
464 }
465
466 /* All is done... */
467 pdev->iso_init = 1;
468 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
469 return 0;
470 }
471
472 static void pwc_iso_stop(struct pwc_device *pdev)
473 {
474 int i;
475
476 /* Unlinking ISOC buffers one by one */
477 for (i = 0; i < MAX_ISO_BUFS; i++) {
478 if (pdev->urbs[i]) {
479 PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
480 usb_kill_urb(pdev->urbs[i]);
481 }
482 }
483 }
484
485 static void pwc_iso_free(struct pwc_device *pdev)
486 {
487 int i;
488
489 /* Freeing ISOC buffers one by one */
490 for (i = 0; i < MAX_ISO_BUFS; i++) {
491 if (pdev->urbs[i]) {
492 PWC_DEBUG_MEMORY("Freeing URB\n");
493 if (pdev->urbs[i]->transfer_buffer) {
494 usb_free_coherent(pdev->udev,
495 pdev->urbs[i]->transfer_buffer_length,
496 pdev->urbs[i]->transfer_buffer,
497 pdev->urbs[i]->transfer_dma);
498 }
499 usb_free_urb(pdev->urbs[i]);
500 pdev->urbs[i] = NULL;
501 }
502 }
503 }
504
505 static void pwc_isoc_cleanup(struct pwc_device *pdev)
506 {
507 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
508
509 if (pdev->iso_init == 0)
510 return;
511
512 pwc_iso_stop(pdev);
513 pwc_iso_free(pdev);
514 usb_set_interface(pdev->udev, 0, 0);
515
516 pdev->iso_init = 0;
517 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
518 }
519
520 /*
521 * Release all queued buffers, no need to take queued_bufs_lock, since all
522 * iso urbs have been killed when we're called so pwc_isoc_handler won't run.
523 */
524 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev)
525 {
526 while (!list_empty(&pdev->queued_bufs)) {
527 struct pwc_frame_buf *buf;
528
529 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
530 list);
531 list_del(&buf->list);
532 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
533 }
534 }
535
536 /*********
537 * sysfs
538 *********/
539 static struct pwc_device *cd_to_pwc(struct device *cd)
540 {
541 struct video_device *vdev = to_video_device(cd);
542 return video_get_drvdata(vdev);
543 }
544
545 static ssize_t show_pan_tilt(struct device *class_dev,
546 struct device_attribute *attr, char *buf)
547 {
548 struct pwc_device *pdev = cd_to_pwc(class_dev);
549 return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
550 }
551
552 static ssize_t store_pan_tilt(struct device *class_dev,
553 struct device_attribute *attr,
554 const char *buf, size_t count)
555 {
556 struct pwc_device *pdev = cd_to_pwc(class_dev);
557 int pan, tilt;
558 int ret = -EINVAL;
559
560 if (strncmp(buf, "reset", 5) == 0)
561 ret = pwc_mpt_reset(pdev, 0x3);
562
563 else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
564 ret = pwc_mpt_set_angle(pdev, pan, tilt);
565
566 if (ret < 0)
567 return ret;
568 return strlen(buf);
569 }
570 static DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
571 store_pan_tilt);
572
573 static ssize_t show_snapshot_button_status(struct device *class_dev,
574 struct device_attribute *attr, char *buf)
575 {
576 struct pwc_device *pdev = cd_to_pwc(class_dev);
577 int status = pdev->snapshot_button_status;
578 pdev->snapshot_button_status = 0;
579 return sprintf(buf, "%d\n", status);
580 }
581
582 static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
583 NULL);
584
585 static int pwc_create_sysfs_files(struct pwc_device *pdev)
586 {
587 int rc;
588
589 rc = device_create_file(&pdev->vdev.dev, &dev_attr_button);
590 if (rc)
591 goto err;
592 if (pdev->features & FEATURE_MOTOR_PANTILT) {
593 rc = device_create_file(&pdev->vdev.dev, &dev_attr_pan_tilt);
594 if (rc)
595 goto err_button;
596 }
597
598 return 0;
599
600 err_button:
601 device_remove_file(&pdev->vdev.dev, &dev_attr_button);
602 err:
603 PWC_ERROR("Could not create sysfs files.\n");
604 return rc;
605 }
606
607 static void pwc_remove_sysfs_files(struct pwc_device *pdev)
608 {
609 if (pdev->features & FEATURE_MOTOR_PANTILT)
610 device_remove_file(&pdev->vdev.dev, &dev_attr_pan_tilt);
611 device_remove_file(&pdev->vdev.dev, &dev_attr_button);
612 }
613
614 #ifdef CONFIG_USB_PWC_DEBUG
615 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
616 {
617 switch(sensor_type) {
618 case 0x00:
619 return "Hyundai CMOS sensor";
620 case 0x20:
621 return "Sony CCD sensor + TDA8787";
622 case 0x2E:
623 return "Sony CCD sensor + Exas 98L59";
624 case 0x2F:
625 return "Sony CCD sensor + ADI 9804";
626 case 0x30:
627 return "Sharp CCD sensor + TDA8787";
628 case 0x3E:
629 return "Sharp CCD sensor + Exas 98L59";
630 case 0x3F:
631 return "Sharp CCD sensor + ADI 9804";
632 case 0x40:
633 return "UPA 1021 sensor";
634 case 0x100:
635 return "VGA sensor";
636 case 0x101:
637 return "PAL MR sensor";
638 default:
639 return "unknown type of sensor";
640 }
641 }
642 #endif
643
644 /***************************************************************************/
645 /* Video4Linux functions */
646
647 static int pwc_video_open(struct file *file)
648 {
649 struct video_device *vdev = video_devdata(file);
650 struct pwc_device *pdev;
651
652 PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
653
654 pdev = video_get_drvdata(vdev);
655 if (!pdev->udev)
656 return -ENODEV;
657
658 file->private_data = vdev;
659 PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
660 return 0;
661 }
662
663 static void pwc_video_release(struct video_device *vfd)
664 {
665 struct pwc_device *pdev = container_of(vfd, struct pwc_device, vdev);
666 int hint;
667
668 /* search device_hint[] table if we occupy a slot, by any chance */
669 for (hint = 0; hint < MAX_DEV_HINTS; hint++)
670 if (device_hint[hint].pdev == pdev)
671 device_hint[hint].pdev = NULL;
672
673 /* Free intermediate decompression buffer & tables */
674 if (pdev->decompress_data != NULL) {
675 PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n",
676 pdev->decompress_data);
677 kfree(pdev->decompress_data);
678 pdev->decompress_data = NULL;
679 }
680
681 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
682
683 kfree(pdev);
684 }
685
686 static int pwc_video_close(struct file *file)
687 {
688 struct video_device *vdev = file->private_data;
689 struct pwc_device *pdev;
690
691 PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
692
693 pdev = video_get_drvdata(vdev);
694 if (pdev->capt_file == file) {
695 vb2_queue_release(&pdev->vb_queue);
696 pdev->capt_file = NULL;
697 }
698
699 PWC_DEBUG_OPEN("<< video_close()\n");
700 return 0;
701 }
702
703 static ssize_t pwc_video_read(struct file *file, char __user *buf,
704 size_t count, loff_t *ppos)
705 {
706 struct video_device *vdev = file->private_data;
707 struct pwc_device *pdev = video_get_drvdata(vdev);
708
709 if (!pdev->udev)
710 return -ENODEV;
711
712 if (pdev->capt_file != NULL &&
713 pdev->capt_file != file)
714 return -EBUSY;
715
716 pdev->capt_file = file;
717
718 return vb2_read(&pdev->vb_queue, buf, count, ppos,
719 file->f_flags & O_NONBLOCK);
720 }
721
722 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
723 {
724 struct video_device *vdev = file->private_data;
725 struct pwc_device *pdev = video_get_drvdata(vdev);
726
727 if (!pdev->udev)
728 return POLL_ERR;
729
730 return vb2_poll(&pdev->vb_queue, file, wait);
731 }
732
733 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
734 {
735 struct video_device *vdev = file->private_data;
736 struct pwc_device *pdev = video_get_drvdata(vdev);
737
738 if (pdev->capt_file != file)
739 return -EBUSY;
740
741 return vb2_mmap(&pdev->vb_queue, vma);
742 }
743
744 /***************************************************************************/
745 /* Videobuf2 operations */
746
747 static int queue_setup(struct vb2_queue *vq, unsigned int *nbuffers,
748 unsigned int *nplanes, unsigned long sizes[],
749 void *alloc_ctxs[])
750 {
751 struct pwc_device *pdev = vb2_get_drv_priv(vq);
752
753 if (*nbuffers < MIN_FRAMES)
754 *nbuffers = MIN_FRAMES;
755 else if (*nbuffers > MAX_FRAMES)
756 *nbuffers = MAX_FRAMES;
757
758 *nplanes = 1;
759
760 sizes[0] = PAGE_ALIGN((pdev->abs_max.x * pdev->abs_max.y * 3) / 2);
761
762 return 0;
763 }
764
765 static int buffer_init(struct vb2_buffer *vb)
766 {
767 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
768
769 /* need vmalloc since frame buffer > 128K */
770 buf->data = vzalloc(PWC_FRAME_SIZE);
771 if (buf->data == NULL)
772 return -ENOMEM;
773
774 return 0;
775 }
776
777 static int buffer_prepare(struct vb2_buffer *vb)
778 {
779 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
780
781 /* Don't allow queing new buffers after device disconnection */
782 if (!pdev->udev)
783 return -ENODEV;
784
785 return 0;
786 }
787
788 static int buffer_finish(struct vb2_buffer *vb)
789 {
790 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
791 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
792
793 /*
794 * Application has called dqbuf and is getting back a buffer we've
795 * filled, take the pwc data we've stored in buf->data and decompress
796 * it into a usable format, storing the result in the vb2_buffer
797 */
798 return pwc_decompress(pdev, buf);
799 }
800
801 static void buffer_cleanup(struct vb2_buffer *vb)
802 {
803 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
804
805 vfree(buf->data);
806 }
807
808 static void buffer_queue(struct vb2_buffer *vb)
809 {
810 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
811 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
812 unsigned long flags = 0;
813
814 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
815 list_add_tail(&buf->list, &pdev->queued_bufs);
816 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
817 }
818
819 static int start_streaming(struct vb2_queue *vq)
820 {
821 struct pwc_device *pdev = vb2_get_drv_priv(vq);
822
823 if (!pdev->udev)
824 return -ENODEV;
825
826 /* Turn on camera and set LEDS on */
827 pwc_camera_power(pdev, 1);
828 if (pdev->power_save) {
829 /* Restore video mode */
830 pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y,
831 pdev->vframes, pdev->vcompression,
832 pdev->vsnapshot);
833 }
834 pwc_set_leds(pdev, led_on, led_off);
835
836 return pwc_isoc_init(pdev);
837 }
838
839 static int stop_streaming(struct vb2_queue *vq)
840 {
841 struct pwc_device *pdev = vb2_get_drv_priv(vq);
842
843 if (pdev->udev) {
844 pwc_set_leds(pdev, 0, 0);
845 pwc_camera_power(pdev, 0);
846 pwc_isoc_cleanup(pdev);
847 }
848 pwc_cleanup_queued_bufs(pdev);
849
850 return 0;
851 }
852
853 static void pwc_lock(struct vb2_queue *vq)
854 {
855 struct pwc_device *pdev = vb2_get_drv_priv(vq);
856 mutex_lock(&pdev->modlock);
857 }
858
859 static void pwc_unlock(struct vb2_queue *vq)
860 {
861 struct pwc_device *pdev = vb2_get_drv_priv(vq);
862 mutex_unlock(&pdev->modlock);
863 }
864
865 static struct vb2_ops pwc_vb_queue_ops = {
866 .queue_setup = queue_setup,
867 .buf_init = buffer_init,
868 .buf_prepare = buffer_prepare,
869 .buf_finish = buffer_finish,
870 .buf_cleanup = buffer_cleanup,
871 .buf_queue = buffer_queue,
872 .start_streaming = start_streaming,
873 .stop_streaming = stop_streaming,
874 .wait_prepare = pwc_unlock,
875 .wait_finish = pwc_lock,
876 };
877
878 /***************************************************************************/
879 /* USB functions */
880
881 /* This function gets called when a new device is plugged in or the usb core
882 * is loaded.
883 */
884
885 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
886 {
887 struct usb_device *udev = interface_to_usbdev(intf);
888 struct pwc_device *pdev = NULL;
889 int vendor_id, product_id, type_id;
890 int hint, rc;
891 int features = 0;
892 int video_nr = -1; /* default: use next available device */
893 int my_power_save = power_save;
894 char serial_number[30], *name;
895
896 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
897 product_id = le16_to_cpu(udev->descriptor.idProduct);
898
899 /* Check if we can handle this device */
900 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
901 vendor_id, product_id,
902 intf->altsetting->desc.bInterfaceNumber);
903
904 /* the interfaces are probed one by one. We are only interested in the
905 video interface (0) now.
906 Interface 1 is the Audio Control, and interface 2 Audio itself.
907 */
908 if (intf->altsetting->desc.bInterfaceNumber > 0)
909 return -ENODEV;
910
911 if (vendor_id == 0x0471) {
912 switch (product_id) {
913 case 0x0302:
914 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
915 name = "Philips 645 webcam";
916 type_id = 645;
917 break;
918 case 0x0303:
919 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
920 name = "Philips 646 webcam";
921 type_id = 646;
922 break;
923 case 0x0304:
924 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
925 name = "Askey VC010 webcam";
926 type_id = 646;
927 break;
928 case 0x0307:
929 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
930 name = "Philips 675 webcam";
931 type_id = 675;
932 break;
933 case 0x0308:
934 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
935 name = "Philips 680 webcam";
936 type_id = 680;
937 break;
938 case 0x030C:
939 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
940 name = "Philips 690 webcam";
941 type_id = 690;
942 break;
943 case 0x0310:
944 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
945 name = "Philips 730 webcam";
946 type_id = 730;
947 break;
948 case 0x0311:
949 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
950 name = "Philips 740 webcam";
951 type_id = 740;
952 break;
953 case 0x0312:
954 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
955 name = "Philips 750 webcam";
956 type_id = 750;
957 break;
958 case 0x0313:
959 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
960 name = "Philips 720K/40 webcam";
961 type_id = 720;
962 break;
963 case 0x0329:
964 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
965 name = "Philips SPC 900NC webcam";
966 type_id = 740;
967 break;
968 default:
969 return -ENODEV;
970 break;
971 }
972 }
973 else if (vendor_id == 0x069A) {
974 switch(product_id) {
975 case 0x0001:
976 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
977 name = "Askey VC010 webcam";
978 type_id = 645;
979 break;
980 default:
981 return -ENODEV;
982 break;
983 }
984 }
985 else if (vendor_id == 0x046d) {
986 switch(product_id) {
987 case 0x08b0:
988 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
989 name = "Logitech QuickCam Pro 3000";
990 type_id = 740; /* CCD sensor */
991 break;
992 case 0x08b1:
993 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
994 name = "Logitech QuickCam Notebook Pro";
995 type_id = 740; /* CCD sensor */
996 break;
997 case 0x08b2:
998 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
999 name = "Logitech QuickCam Pro 4000";
1000 type_id = 740; /* CCD sensor */
1001 if (my_power_save == -1)
1002 my_power_save = 1;
1003 break;
1004 case 0x08b3:
1005 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
1006 name = "Logitech QuickCam Zoom";
1007 type_id = 740; /* CCD sensor */
1008 break;
1009 case 0x08B4:
1010 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
1011 name = "Logitech QuickCam Zoom";
1012 type_id = 740; /* CCD sensor */
1013 if (my_power_save == -1)
1014 my_power_save = 1;
1015 break;
1016 case 0x08b5:
1017 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
1018 name = "Logitech QuickCam Orbit";
1019 type_id = 740; /* CCD sensor */
1020 if (my_power_save == -1)
1021 my_power_save = 1;
1022 features |= FEATURE_MOTOR_PANTILT;
1023 break;
1024 case 0x08b6:
1025 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
1026 name = "Cisco VT Camera";
1027 type_id = 740; /* CCD sensor */
1028 break;
1029 case 0x08b7:
1030 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
1031 name = "Logitech ViewPort AV 100";
1032 type_id = 740; /* CCD sensor */
1033 break;
1034 case 0x08b8: /* Where this released? */
1035 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
1036 name = "Logitech QuickCam (res.)";
1037 type_id = 730; /* Assuming CMOS */
1038 break;
1039 default:
1040 return -ENODEV;
1041 break;
1042 }
1043 }
1044 else if (vendor_id == 0x055d) {
1045 /* I don't know the difference between the C10 and the C30;
1046 I suppose the difference is the sensor, but both cameras
1047 work equally well with a type_id of 675
1048 */
1049 switch(product_id) {
1050 case 0x9000:
1051 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
1052 name = "Samsung MPC-C10";
1053 type_id = 675;
1054 break;
1055 case 0x9001:
1056 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
1057 name = "Samsung MPC-C30";
1058 type_id = 675;
1059 break;
1060 case 0x9002:
1061 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
1062 name = "Samsung MPC-C30";
1063 type_id = 740;
1064 break;
1065 default:
1066 return -ENODEV;
1067 break;
1068 }
1069 }
1070 else if (vendor_id == 0x041e) {
1071 switch(product_id) {
1072 case 0x400c:
1073 PWC_INFO("Creative Labs Webcam 5 detected.\n");
1074 name = "Creative Labs Webcam 5";
1075 type_id = 730;
1076 if (my_power_save == -1)
1077 my_power_save = 1;
1078 break;
1079 case 0x4011:
1080 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
1081 name = "Creative Labs Webcam Pro Ex";
1082 type_id = 740;
1083 break;
1084 default:
1085 return -ENODEV;
1086 break;
1087 }
1088 }
1089 else if (vendor_id == 0x04cc) {
1090 switch(product_id) {
1091 case 0x8116:
1092 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
1093 name = "Sotec Afina Eye";
1094 type_id = 730;
1095 break;
1096 default:
1097 return -ENODEV;
1098 break;
1099 }
1100 }
1101 else if (vendor_id == 0x06be) {
1102 switch(product_id) {
1103 case 0x8116:
1104 /* This is essentially the same cam as the Sotec Afina Eye */
1105 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1106 name = "AME Co. Afina Eye";
1107 type_id = 750;
1108 break;
1109 default:
1110 return -ENODEV;
1111 break;
1112 }
1113
1114 }
1115 else if (vendor_id == 0x0d81) {
1116 switch(product_id) {
1117 case 0x1900:
1118 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1119 name = "Visionite VCS-UC300";
1120 type_id = 740; /* CCD sensor */
1121 break;
1122 case 0x1910:
1123 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1124 name = "Visionite VCS-UM100";
1125 type_id = 730; /* CMOS sensor */
1126 break;
1127 default:
1128 return -ENODEV;
1129 break;
1130 }
1131 }
1132 else
1133 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1134
1135 if (my_power_save == -1)
1136 my_power_save = 0;
1137
1138 memset(serial_number, 0, 30);
1139 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1140 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1141
1142 if (udev->descriptor.bNumConfigurations > 1)
1143 PWC_WARNING("Warning: more than 1 configuration available.\n");
1144
1145 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1146 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1147 if (pdev == NULL) {
1148 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1149 return -ENOMEM;
1150 }
1151 pdev->type = type_id;
1152 pdev->vframes = default_fps;
1153 strcpy(pdev->serial, serial_number);
1154 pdev->features = features;
1155 if (vendor_id == 0x046D && product_id == 0x08B5) {
1156 /* Logitech QuickCam Orbit
1157 The ranges have been determined experimentally; they may differ from cam to cam.
1158 Also, the exact ranges left-right and up-down are different for my cam
1159 */
1160 pdev->angle_range.pan_min = -7000;
1161 pdev->angle_range.pan_max = 7000;
1162 pdev->angle_range.tilt_min = -3000;
1163 pdev->angle_range.tilt_max = 2500;
1164 }
1165 pwc_construct(pdev); /* set min/max sizes correct */
1166
1167 mutex_init(&pdev->modlock);
1168 mutex_init(&pdev->udevlock);
1169 spin_lock_init(&pdev->queued_bufs_lock);
1170 INIT_LIST_HEAD(&pdev->queued_bufs);
1171
1172 pdev->udev = udev;
1173 pdev->vcompression = pwc_preferred_compression;
1174 pdev->power_save = my_power_save;
1175
1176 /* Init videobuf2 queue structure */
1177 memset(&pdev->vb_queue, 0, sizeof(pdev->vb_queue));
1178 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1179 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1180 pdev->vb_queue.drv_priv = pdev;
1181 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1182 pdev->vb_queue.ops = &pwc_vb_queue_ops;
1183 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1184 vb2_queue_init(&pdev->vb_queue);
1185
1186 /* Init video_device structure */
1187 memcpy(&pdev->vdev, &pwc_template, sizeof(pwc_template));
1188 pdev->vdev.parent = &intf->dev;
1189 pdev->vdev.lock = &pdev->modlock;
1190 strcpy(pdev->vdev.name, name);
1191 video_set_drvdata(&pdev->vdev, pdev);
1192
1193 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1194 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1195
1196 /* Now search device_hint[] table for a match, so we can hint a node number. */
1197 for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
1198 if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
1199 (device_hint[hint].pdev == NULL)) {
1200 /* so far, so good... try serial number */
1201 if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
1202 /* match! */
1203 video_nr = device_hint[hint].device_node;
1204 PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
1205 break;
1206 }
1207 }
1208 }
1209
1210 /* occupy slot */
1211 if (hint < MAX_DEV_HINTS)
1212 device_hint[hint].pdev = pdev;
1213
1214 PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
1215 usb_set_intfdata(intf, pdev);
1216
1217 #ifdef CONFIG_USB_PWC_DEBUG
1218 /* Query sensor type */
1219 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1220 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1221 pdev->vdev.name,
1222 pwc_sensor_type_to_string(rc), rc);
1223 }
1224 #endif
1225
1226 /* Set the leds off */
1227 pwc_set_leds(pdev, 0, 0);
1228
1229 /* Setup intial videomode */
1230 rc = pwc_set_video_mode(pdev, pdev->view_max.x, pdev->view_max.y,
1231 pdev->vframes, pdev->vcompression, 0);
1232 if (rc)
1233 goto err_free_mem;
1234
1235 /* Register controls (and read default values from camera */
1236 rc = pwc_init_controls(pdev);
1237 if (rc) {
1238 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1239 goto err_free_mem;
1240 }
1241
1242 pdev->vdev.ctrl_handler = &pdev->ctrl_handler;
1243
1244 /* And powerdown the camera until streaming starts */
1245 pwc_camera_power(pdev, 0);
1246
1247 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, video_nr);
1248 if (rc < 0) {
1249 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1250 goto err_free_controls;
1251 }
1252 rc = pwc_create_sysfs_files(pdev);
1253 if (rc)
1254 goto err_video_unreg;
1255
1256 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1257
1258 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1259 /* register webcam snapshot button input device */
1260 pdev->button_dev = input_allocate_device();
1261 if (!pdev->button_dev) {
1262 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
1263 rc = -ENOMEM;
1264 pwc_remove_sysfs_files(pdev);
1265 goto err_video_unreg;
1266 }
1267
1268 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1269 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1270
1271 pdev->button_dev->name = "PWC snapshot button";
1272 pdev->button_dev->phys = pdev->button_phys;
1273 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1274 pdev->button_dev->dev.parent = &pdev->udev->dev;
1275 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1276 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1277
1278 rc = input_register_device(pdev->button_dev);
1279 if (rc) {
1280 input_free_device(pdev->button_dev);
1281 pdev->button_dev = NULL;
1282 pwc_remove_sysfs_files(pdev);
1283 goto err_video_unreg;
1284 }
1285 #endif
1286
1287 return 0;
1288
1289 err_video_unreg:
1290 if (hint < MAX_DEV_HINTS)
1291 device_hint[hint].pdev = NULL;
1292 video_unregister_device(&pdev->vdev);
1293 err_free_controls:
1294 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1295 err_free_mem:
1296 usb_set_intfdata(intf, NULL);
1297 kfree(pdev);
1298 return rc;
1299 }
1300
1301 /* The user yanked out the cable... */
1302 static void usb_pwc_disconnect(struct usb_interface *intf)
1303 {
1304 struct pwc_device *pdev = usb_get_intfdata(intf);
1305
1306 mutex_lock(&pdev->udevlock);
1307 mutex_lock(&pdev->modlock);
1308
1309 usb_set_intfdata(intf, NULL);
1310 /* No need to keep the urbs around after disconnection */
1311 pwc_isoc_cleanup(pdev);
1312 pwc_cleanup_queued_bufs(pdev);
1313 pdev->udev = NULL;
1314
1315 mutex_unlock(&pdev->modlock);
1316 mutex_unlock(&pdev->udevlock);
1317
1318 pwc_remove_sysfs_files(pdev);
1319 video_unregister_device(&pdev->vdev);
1320
1321 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1322 if (pdev->button_dev)
1323 input_unregister_device(pdev->button_dev);
1324 #endif
1325 }
1326
1327
1328 /*
1329 * Initialization code & module stuff
1330 */
1331
1332 static int fps;
1333 static int compression = -1;
1334 static int leds[2] = { -1, -1 };
1335 static unsigned int leds_nargs;
1336 static char *dev_hint[MAX_DEV_HINTS];
1337 static unsigned int dev_hint_nargs;
1338
1339 module_param(fps, int, 0444);
1340 #ifdef CONFIG_USB_PWC_DEBUG
1341 module_param_named(trace, pwc_trace, int, 0644);
1342 #endif
1343 module_param(power_save, int, 0644);
1344 module_param(compression, int, 0444);
1345 module_param_array(leds, int, &leds_nargs, 0444);
1346 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
1347
1348 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
1349 #ifdef CONFIG_USB_PWC_DEBUG
1350 MODULE_PARM_DESC(trace, "For debugging purposes");
1351 #endif
1352 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1353 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
1354 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1355 MODULE_PARM_DESC(dev_hint, "Device node hints");
1356
1357 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1358 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1359 MODULE_LICENSE("GPL");
1360 MODULE_ALIAS("pwcx");
1361 MODULE_VERSION( PWC_VERSION );
1362
1363 static int __init usb_pwc_init(void)
1364 {
1365 int i;
1366
1367 #ifdef CONFIG_USB_PWC_DEBUG
1368 PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
1369 PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
1370 PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
1371 PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
1372
1373 if (pwc_trace >= 0) {
1374 PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
1375 }
1376 #endif
1377
1378 if (fps) {
1379 if (fps < 4 || fps > 30) {
1380 PWC_ERROR("Framerate out of bounds (4-30).\n");
1381 return -EINVAL;
1382 }
1383 default_fps = fps;
1384 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
1385 }
1386
1387 if (compression >= 0) {
1388 if (compression > 3) {
1389 PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
1390 return -EINVAL;
1391 }
1392 pwc_preferred_compression = compression;
1393 PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
1394 }
1395 if (leds[0] >= 0)
1396 led_on = leds[0];
1397 if (leds[1] >= 0)
1398 led_off = leds[1];
1399
1400 /* Big device node whoopla. Basically, it allows you to assign a
1401 device node (/dev/videoX) to a camera, based on its type
1402 & serial number. The format is [type[.serialnumber]:]node.
1403
1404 Any camera that isn't matched by these rules gets the next
1405 available free device node.
1406 */
1407 for (i = 0; i < MAX_DEV_HINTS; i++) {
1408 char *s, *colon, *dot;
1409
1410 /* This loop also initializes the array */
1411 device_hint[i].pdev = NULL;
1412 s = dev_hint[i];
1413 if (s != NULL && *s != '\0') {
1414 device_hint[i].type = -1; /* wildcard */
1415 strcpy(device_hint[i].serial_number, "*");
1416
1417 /* parse string: chop at ':' & '/' */
1418 colon = dot = s;
1419 while (*colon != '\0' && *colon != ':')
1420 colon++;
1421 while (*dot != '\0' && *dot != '.')
1422 dot++;
1423 /* Few sanity checks */
1424 if (*dot != '\0' && dot > colon) {
1425 PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
1426 return -EINVAL;
1427 }
1428
1429 if (*colon == '\0') {
1430 /* No colon */
1431 if (*dot != '\0') {
1432 PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
1433 return -EINVAL;
1434 }
1435 else {
1436 /* No type or serial number specified, just a number. */
1437 device_hint[i].device_node =
1438 simple_strtol(s, NULL, 10);
1439 }
1440 }
1441 else {
1442 /* There's a colon, so we have at least a type and a device node */
1443 device_hint[i].type =
1444 simple_strtol(s, NULL, 10);
1445 device_hint[i].device_node =
1446 simple_strtol(colon + 1, NULL, 10);
1447 if (*dot != '\0') {
1448 /* There's a serial number as well */
1449 int k;
1450
1451 dot++;
1452 k = 0;
1453 while (*dot != ':' && k < 29) {
1454 device_hint[i].serial_number[k++] = *dot;
1455 dot++;
1456 }
1457 device_hint[i].serial_number[k] = '\0';
1458 }
1459 }
1460 PWC_TRACE("device_hint[%d]:\n", i);
1461 PWC_TRACE(" type : %d\n", device_hint[i].type);
1462 PWC_TRACE(" serial# : %s\n", device_hint[i].serial_number);
1463 PWC_TRACE(" node : %d\n", device_hint[i].device_node);
1464 }
1465 else
1466 device_hint[i].type = 0; /* not filled */
1467 } /* ..for MAX_DEV_HINTS */
1468
1469 PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
1470 return usb_register(&pwc_driver);
1471 }
1472
1473 static void __exit usb_pwc_exit(void)
1474 {
1475 PWC_DEBUG_MODULE("Deregistering driver.\n");
1476 usb_deregister(&pwc_driver);
1477 PWC_INFO("Philips webcam module removed.\n");
1478 }
1479
1480 module_init(usb_pwc_init);
1481 module_exit(usb_pwc_exit);
1482
1483 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
linux-next