?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[drm/drm-misc.git] / drivers / media / usb / pwc / pwc-if.c
blob3ec9eb5956edd0d6c7d4b4b62ba5a5cc64a2483d
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Linux driver for Philips webcam
3 USB and Video4Linux interface part.
4 (C) 1999-2004 Nemosoft Unv.
5 (C) 2004-2006 Luc Saillard (luc@saillard.org)
6 (C) 2011 Hans de Goede <hdegoede@redhat.com>
7
8 NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
9 driver and thus may have bugs that are not present in the original version.
10 Please send bug reports and support requests to <luc@saillard.org>.
11 The decompression routines have been implemented by reverse-engineering the
12 Nemosoft binary pwcx module. Caveat emptor.
13
14
15 */
16
17 /*
18 This code forms the interface between the USB layers and the Philips
19 specific stuff. Some adanved stuff of the driver falls under an
20 NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
21 is thus not distributed in source form. The binary pwcx.o module
22 contains the code that falls under the NDA.
23
24 In case you're wondering: 'pwc' stands for "Philips WebCam", but
25 I really didn't want to type 'philips_web_cam' every time (I'm lazy as
26 any Linux kernel hacker, but I don't like uncomprehensible abbreviations
27 without explanation).
28
29 Oh yes, convention: to disctinguish between all the various pointers to
30 device-structures, I use these names for the pointer variables:
31 udev: struct usb_device *
32 vdev: struct video_device (member of pwc_dev)
33 pdev: struct pwc_devive *
34 */
35
36 /* Contributors:
37 - Alvarado: adding whitebalance code
38 - Alistar Moire: QuickCam 3000 Pro device/product ID
39 - Tony Hoyle: Creative Labs Webcam 5 device/product ID
40 - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
41 - Jk Fang: Sotec Afina Eye ID
42 - Xavier Roche: QuickCam Pro 4000 ID
43 - Jens Knudsen: QuickCam Zoom ID
44 - J. Debert: QuickCam for Notebooks ID
45 - Pham Thanh Nam: webcam snapshot button as an event input device
46 */
47
48 #include <linux/errno.h>
49 #include <linux/init.h>
50 #include <linux/mm.h>
51 #include <linux/module.h>
52 #include <linux/poll.h>
53 #include <linux/slab.h>
54 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
55 #include <linux/usb/input.h>
56 #endif
57 #include <linux/vmalloc.h>
58 #include <asm/io.h>
59 #include <linux/kernel.h> /* simple_strtol() */
60
61 #include "pwc.h"
62 #include "pwc-kiara.h"
63 #include "pwc-timon.h"
64 #include "pwc-dec23.h"
65 #include "pwc-dec1.h"
66
67 #define CREATE_TRACE_POINTS
68 #include <trace/events/pwc.h>
69
70 /* Function prototypes and driver templates */
71
72 /* hotplug device table support */
73 static const struct usb_device_id pwc_device_table [] = {
74 { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
75 { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
76
77 { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam 3000 Pro */
78 { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
79 { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam 4000 Pro */
80 { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
81 { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
82 { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
83 { USB_DEVICE(0x046D, 0x08B6) }, /* Logitech/Cisco VT Camera */
84 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
85 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech QuickCam */
86
87 { USB_DEVICE(0x0471, 0x0302) }, /* Philips PCA645VC */
88 { USB_DEVICE(0x0471, 0x0303) }, /* Philips PCA646VC */
89 { USB_DEVICE(0x0471, 0x0304) }, /* Askey VC010 type 2 */
90 { USB_DEVICE(0x0471, 0x0307) }, /* Philips PCVC675K (Vesta) */
91 { USB_DEVICE(0x0471, 0x0308) }, /* Philips PCVC680K (Vesta Pro) */
92 { USB_DEVICE(0x0471, 0x030C) }, /* Philips PCVC690K (Vesta Pro Scan) */
93 { USB_DEVICE(0x0471, 0x0310) }, /* Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) */
94 { USB_DEVICE(0x0471, 0x0311) }, /* Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) */
95 { USB_DEVICE(0x0471, 0x0312) }, /* Philips PCVC750K (ToUCam Pro Scan) */
96 { USB_DEVICE(0x0471, 0x0313) }, /* Philips PCVC720K/40 (ToUCam XS) */
97 { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC webcam */
98 { USB_DEVICE(0x0471, 0x032C) }, /* Philips SPC 880NC webcam */
99
100 { USB_DEVICE(0x04CC, 0x8116) }, /* Sotec Afina Eye */
101
102 { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
103 { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
104 { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
105
106 { USB_DEVICE(0x069A, 0x0001) }, /* Askey VC010 type 1 */
107
108 { USB_DEVICE(0x06BE, 0x8116) }, /* AME Co. Afina Eye */
109
110 { USB_DEVICE(0x0d81, 0x1900) }, /* Visionite VCS-UC300 */
111 { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite VCS-UM100 */
112
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 #ifdef CONFIG_USB_PWC_DEBUG
132 int pwc_trace = PWC_DEBUG_LEVEL;
133 #endif
134 static int power_save = -1;
135 static int leds[2] = { 100, 0 };
136
137 /***/
138
139 static const struct v4l2_file_operations pwc_fops = {
140 .owner = THIS_MODULE,
141 .open = v4l2_fh_open,
142 .release = vb2_fop_release,
143 .read = vb2_fop_read,
144 .poll = vb2_fop_poll,
145 .mmap = vb2_fop_mmap,
146 .unlocked_ioctl = video_ioctl2,
147 };
148 static const struct video_device pwc_template = {
149 .name = "Philips Webcam", /* Filled in later */
150 .release = video_device_release_empty,
151 .fops = &pwc_fops,
152 .ioctl_ops = &pwc_ioctl_ops,
153 };
154
155 /***************************************************************************/
156 /* Private functions */
157
158 static void *pwc_alloc_urb_buffer(struct usb_device *dev,
159 size_t size, dma_addr_t *dma_handle)
160 {
161 struct device *dmadev = dev->bus->sysdev;
162 void *buffer = kmalloc(size, GFP_KERNEL);
163
164 if (!buffer)
165 return NULL;
166
167 *dma_handle = dma_map_single(dmadev, buffer, size, DMA_FROM_DEVICE);
168 if (dma_mapping_error(dmadev, *dma_handle)) {
169 kfree(buffer);
170 return NULL;
171 }
172
173 return buffer;
174 }
175
176 static void pwc_free_urb_buffer(struct usb_device *dev,
177 size_t size,
178 void *buffer,
179 dma_addr_t dma_handle)
180 {
181 struct device *dmadev = dev->bus->sysdev;
182
183 dma_unmap_single(dmadev, dma_handle, size, DMA_FROM_DEVICE);
184 kfree(buffer);
185 }
186
187 static struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
188 {
189 unsigned long flags = 0;
190 struct pwc_frame_buf *buf = NULL;
191
192 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
193 if (list_empty(&pdev->queued_bufs))
194 goto leave;
195
196 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
197 list_del(&buf->list);
198 leave:
199 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
200 return buf;
201 }
202
203 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
204 {
205 if (down) {
206 PWC_TRACE("Snapshot button pressed.\n");
207 } else {
208 PWC_TRACE("Snapshot button released.\n");
209 }
210
211 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
212 if (pdev->button_dev) {
213 input_report_key(pdev->button_dev, KEY_CAMERA, down);
214 input_sync(pdev->button_dev);
215 }
216 #endif
217 }
218
219 static void pwc_frame_complete(struct pwc_device *pdev)
220 {
221 struct pwc_frame_buf *fbuf = pdev->fill_buf;
222
223 /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
224 frames on the USB wire after an exposure change. This conditition is
225 however detected in the cam and a bit is set in the header.
226 */
227 if (pdev->type == 730) {
228 unsigned char *ptr = (unsigned char *)fbuf->data;
229
230 if (ptr[1] == 1 && ptr[0] & 0x10) {
231 PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
232 pdev->drop_frames += 2;
233 }
234 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
235 pwc_snapshot_button(pdev, ptr[0] & 0x01);
236 }
237 if ((ptr[0] ^ pdev->vmirror) & 0x02) {
238 if (ptr[0] & 0x02)
239 PWC_TRACE("Image is mirrored.\n");
240 else
241 PWC_TRACE("Image is normal.\n");
242 }
243 pdev->vmirror = ptr[0] & 0x03;
244 /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
245 after a short frame; this condition is filtered out specifically. A 4 byte
246 frame doesn't make sense anyway.
247 So we get either this sequence:
248 drop_bit set -> 4 byte frame -> short frame -> good frame
249 Or this one:
250 drop_bit set -> short frame -> good frame
251 So we drop either 3 or 2 frames in all!
252 */
253 if (fbuf->filled == 4)
254 pdev->drop_frames++;
255 } else if (pdev->type == 740 || pdev->type == 720) {
256 unsigned char *ptr = (unsigned char *)fbuf->data;
257 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
258 pwc_snapshot_button(pdev, ptr[0] & 0x01);
259 }
260 pdev->vmirror = ptr[0] & 0x03;
261 }
262
263 /* In case we were instructed to drop the frame, do so silently. */
264 if (pdev->drop_frames > 0) {
265 pdev->drop_frames--;
266 } else {
267 /* Check for underflow first */
268 if (fbuf->filled < pdev->frame_total_size) {
269 PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes); discarded.\n",
270 fbuf->filled);
271 } else {
272 fbuf->vb.field = V4L2_FIELD_NONE;
273 fbuf->vb.sequence = pdev->vframe_count;
274 vb2_buffer_done(&fbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
275 pdev->fill_buf = NULL;
276 pdev->vsync = 0;
277 }
278 } /* !drop_frames */
279 pdev->vframe_count++;
280 }
281
282 /* This gets called for the Isochronous pipe (video). This is done in
283 * interrupt time, so it has to be fast, not crash, and not stall. Neat.
284 */
285 static void pwc_isoc_handler(struct urb *urb)
286 {
287 struct pwc_device *pdev = (struct pwc_device *)urb->context;
288 struct device *dmadev = urb->dev->bus->sysdev;
289 int i, fst, flen;
290 unsigned char *iso_buf = NULL;
291
292 trace_pwc_handler_enter(urb, pdev);
293
294 if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
295 urb->status == -ESHUTDOWN) {
296 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronously.\n",
297 urb, urb->status == -ENOENT ? "" : "a");
298 return;
299 }
300
301 if (pdev->fill_buf == NULL)
302 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
303
304 if (urb->status != 0) {
305 const char *errmsg;
306
307 errmsg = "Unknown";
308 switch(urb->status) {
309 case -ENOSR: errmsg = "Buffer error (overrun)"; break;
310 case -EPIPE: errmsg = "Stalled (device not responding)"; break;
311 case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
312 case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
313 case -EILSEQ: errmsg = "CRC/Timeout (could be anything)"; break;
314 case -ETIME: errmsg = "Device does not respond"; break;
315 }
316 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
317 urb->status, errmsg);
318 /* Give up after a number of contiguous errors */
319 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
320 {
321 PWC_ERROR("Too many ISOC errors, bailing out.\n");
322 if (pdev->fill_buf) {
323 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
324 VB2_BUF_STATE_ERROR);
325 pdev->fill_buf = NULL;
326 }
327 }
328 pdev->vsync = 0; /* Drop the current frame */
329 goto handler_end;
330 }
331
332 /* Reset ISOC error counter. We did get here, after all. */
333 pdev->visoc_errors = 0;
334
335 dma_sync_single_for_cpu(dmadev,
336 urb->transfer_dma,
337 urb->transfer_buffer_length,
338 DMA_FROM_DEVICE);
339
340 /* vsync: 0 = don't copy data
341 1 = sync-hunt
342 2 = synched
343 */
344 /* Compact data */
345 for (i = 0; i < urb->number_of_packets; i++) {
346 fst = urb->iso_frame_desc[i].status;
347 flen = urb->iso_frame_desc[i].actual_length;
348 iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
349 if (fst != 0) {
350 PWC_ERROR("Iso frame %d has error %d\n", i, fst);
351 continue;
352 }
353 if (flen > 0 && pdev->vsync) {
354 struct pwc_frame_buf *fbuf = pdev->fill_buf;
355
356 if (pdev->vsync == 1) {
357 fbuf->vb.vb2_buf.timestamp = ktime_get_ns();
358 pdev->vsync = 2;
359 }
360
361 if (flen + fbuf->filled > pdev->frame_total_size) {
362 PWC_ERROR("Frame overflow (%d > %d)\n",
363 flen + fbuf->filled,
364 pdev->frame_total_size);
365 pdev->vsync = 0; /* Let's wait for an EOF */
366 } else {
367 memcpy(fbuf->data + fbuf->filled, iso_buf,
368 flen);
369 fbuf->filled += flen;
370 }
371 }
372 if (flen < pdev->vlast_packet_size) {
373 /* Shorter packet... end of frame */
374 if (pdev->vsync == 2)
375 pwc_frame_complete(pdev);
376 if (pdev->fill_buf == NULL)
377 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
378 if (pdev->fill_buf) {
379 pdev->fill_buf->filled = 0;
380 pdev->vsync = 1;
381 }
382 }
383 pdev->vlast_packet_size = flen;
384 }
385
386 dma_sync_single_for_device(dmadev,
387 urb->transfer_dma,
388 urb->transfer_buffer_length,
389 DMA_FROM_DEVICE);
390
391 handler_end:
392 trace_pwc_handler_exit(urb, pdev);
393
394 i = usb_submit_urb(urb, GFP_ATOMIC);
395 if (i != 0)
396 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
397 }
398
399 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
400 static int pwc_isoc_init(struct pwc_device *pdev)
401 {
402 struct usb_device *udev;
403 struct urb *urb;
404 int i, j, ret;
405 struct usb_interface *intf;
406 struct usb_host_interface *idesc = NULL;
407 int compression = 0; /* 0..3 = uncompressed..high */
408
409 pdev->vsync = 0;
410 pdev->vlast_packet_size = 0;
411 pdev->fill_buf = NULL;
412 pdev->vframe_count = 0;
413 pdev->visoc_errors = 0;
414 udev = pdev->udev;
415
416 retry:
417 /* We first try with low compression and then retry with a higher
418 compression setting if there is not enough bandwidth. */
419 ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
420 pdev->vframes, &compression, 1);
421
422 /* Get the current alternate interface, adjust packet size */
423 intf = usb_ifnum_to_if(udev, 0);
424 if (intf)
425 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
426 if (!idesc)
427 return -EIO;
428
429 /* Search video endpoint */
430 pdev->vmax_packet_size = -1;
431 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
432 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
433 pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
434 break;
435 }
436 }
437
438 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
439 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
440 return -ENFILE; /* Odd error, that should be noticeable */
441 }
442
443 /* Set alternate interface */
444 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
445 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
446 if (ret == -ENOSPC && compression < 3) {
447 compression++;
448 goto retry;
449 }
450 if (ret < 0)
451 return ret;
452
453 /* Allocate and init Isochronuous urbs */
454 for (i = 0; i < MAX_ISO_BUFS; i++) {
455 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
456 if (urb == NULL) {
457 pwc_isoc_cleanup(pdev);
458 return -ENOMEM;
459 }
460 pdev->urbs[i] = urb;
461 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
462
463 urb->interval = 1; // devik
464 urb->dev = udev;
465 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
466 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
467 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
468 urb->transfer_buffer = pwc_alloc_urb_buffer(udev,
469 urb->transfer_buffer_length,
470 &urb->transfer_dma);
471 if (urb->transfer_buffer == NULL) {
472 PWC_ERROR("Failed to allocate urb buffer %d\n", i);
473 pwc_isoc_cleanup(pdev);
474 return -ENOMEM;
475 }
476 urb->complete = pwc_isoc_handler;
477 urb->context = pdev;
478 urb->start_frame = 0;
479 urb->number_of_packets = ISO_FRAMES_PER_DESC;
480 for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
481 urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
482 urb->iso_frame_desc[j].length = pdev->vmax_packet_size;
483 }
484 }
485
486 /* link */
487 for (i = 0; i < MAX_ISO_BUFS; i++) {
488 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
489 if (ret == -ENOSPC && compression < 3) {
490 compression++;
491 pwc_isoc_cleanup(pdev);
492 goto retry;
493 }
494 if (ret) {
495 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
496 pwc_isoc_cleanup(pdev);
497 return ret;
498 }
499 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
500 }
501
502 /* All is done... */
503 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
504 return 0;
505 }
506
507 static void pwc_iso_stop(struct pwc_device *pdev)
508 {
509 int i;
510
511 /* Unlinking ISOC buffers one by one */
512 for (i = 0; i < MAX_ISO_BUFS; i++) {
513 if (pdev->urbs[i]) {
514 PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
515 usb_kill_urb(pdev->urbs[i]);
516 }
517 }
518 }
519
520 static void pwc_iso_free(struct pwc_device *pdev)
521 {
522 int i;
523
524 /* Freeing ISOC buffers one by one */
525 for (i = 0; i < MAX_ISO_BUFS; i++) {
526 struct urb *urb = pdev->urbs[i];
527
528 if (urb) {
529 PWC_DEBUG_MEMORY("Freeing URB\n");
530 if (urb->transfer_buffer)
531 pwc_free_urb_buffer(urb->dev,
532 urb->transfer_buffer_length,
533 urb->transfer_buffer,
534 urb->transfer_dma);
535 usb_free_urb(urb);
536 pdev->urbs[i] = NULL;
537 }
538 }
539 }
540
541 /* Both v4l2_lock and vb_queue_lock should be locked when calling this */
542 static void pwc_isoc_cleanup(struct pwc_device *pdev)
543 {
544 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
545
546 pwc_iso_stop(pdev);
547 pwc_iso_free(pdev);
548 usb_set_interface(pdev->udev, 0, 0);
549
550 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
551 }
552
553 /* Must be called with vb_queue_lock hold */
554 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev,
555 enum vb2_buffer_state state)
556 {
557 unsigned long flags = 0;
558
559 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
560 while (!list_empty(&pdev->queued_bufs)) {
561 struct pwc_frame_buf *buf;
562
563 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf,
564 list);
565 list_del(&buf->list);
566 vb2_buffer_done(&buf->vb.vb2_buf, state);
567 }
568 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
569 }
570
571 #ifdef CONFIG_USB_PWC_DEBUG
572 static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
573 {
574 switch(sensor_type) {
575 case 0x00:
576 return "Hyundai CMOS sensor";
577 case 0x20:
578 return "Sony CCD sensor + TDA8787";
579 case 0x2E:
580 return "Sony CCD sensor + Exas 98L59";
581 case 0x2F:
582 return "Sony CCD sensor + ADI 9804";
583 case 0x30:
584 return "Sharp CCD sensor + TDA8787";
585 case 0x3E:
586 return "Sharp CCD sensor + Exas 98L59";
587 case 0x3F:
588 return "Sharp CCD sensor + ADI 9804";
589 case 0x40:
590 return "UPA 1021 sensor";
591 case 0x100:
592 return "VGA sensor";
593 case 0x101:
594 return "PAL MR sensor";
595 default:
596 return "unknown type of sensor";
597 }
598 }
599 #endif
600
601 /***************************************************************************/
602 /* Video4Linux functions */
603
604 static void pwc_video_release(struct v4l2_device *v)
605 {
606 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
607
608 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
609 v4l2_device_unregister(&pdev->v4l2_dev);
610 kfree(pdev->ctrl_buf);
611 kfree(pdev);
612 }
613
614 /***************************************************************************/
615 /* Videobuf2 operations */
616
617 static int queue_setup(struct vb2_queue *vq,
618 unsigned int *nbuffers, unsigned int *nplanes,
619 unsigned int sizes[], struct device *alloc_devs[])
620 {
621 struct pwc_device *pdev = vb2_get_drv_priv(vq);
622 int size;
623
624 if (*nbuffers < MIN_FRAMES)
625 *nbuffers = MIN_FRAMES;
626 else if (*nbuffers > MAX_FRAMES)
627 *nbuffers = MAX_FRAMES;
628
629 *nplanes = 1;
630
631 size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
632 sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
633 pwc_image_sizes[size][1] * 3 / 2);
634
635 return 0;
636 }
637
638 static int buffer_init(struct vb2_buffer *vb)
639 {
640 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
641 struct pwc_frame_buf *buf =
642 container_of(vbuf, struct pwc_frame_buf, vb);
643
644 /* need vmalloc since frame buffer > 128K */
645 buf->data = vzalloc(PWC_FRAME_SIZE);
646 if (buf->data == NULL)
647 return -ENOMEM;
648
649 return 0;
650 }
651
652 static int buffer_prepare(struct vb2_buffer *vb)
653 {
654 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
655
656 /* Don't allow queueing new buffers after device disconnection */
657 if (!pdev->udev)
658 return -ENODEV;
659
660 return 0;
661 }
662
663 static void buffer_finish(struct vb2_buffer *vb)
664 {
665 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
666 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
667 struct pwc_frame_buf *buf =
668 container_of(vbuf, struct pwc_frame_buf, vb);
669
670 if (vb->state == VB2_BUF_STATE_DONE) {
671 /*
672 * Application has called dqbuf and is getting back a buffer
673 * we've filled, take the pwc data we've stored in buf->data
674 * and decompress it into a usable format, storing the result
675 * in the vb2_buffer.
676 */
677 pwc_decompress(pdev, buf);
678 }
679 }
680
681 static void buffer_cleanup(struct vb2_buffer *vb)
682 {
683 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
684 struct pwc_frame_buf *buf =
685 container_of(vbuf, struct pwc_frame_buf, vb);
686
687 vfree(buf->data);
688 }
689
690 static void buffer_queue(struct vb2_buffer *vb)
691 {
692 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
693 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
694 struct pwc_frame_buf *buf =
695 container_of(vbuf, struct pwc_frame_buf, vb);
696 unsigned long flags = 0;
697
698 /* Check the device has not disconnected between prep and queuing */
699 if (!pdev->udev) {
700 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
701 return;
702 }
703
704 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
705 list_add_tail(&buf->list, &pdev->queued_bufs);
706 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
707 }
708
709 static int start_streaming(struct vb2_queue *vq, unsigned int count)
710 {
711 struct pwc_device *pdev = vb2_get_drv_priv(vq);
712 int r;
713
714 if (!pdev->udev)
715 return -ENODEV;
716
717 if (mutex_lock_interruptible(&pdev->v4l2_lock))
718 return -ERESTARTSYS;
719 /* Turn on camera and set LEDS on */
720 pwc_camera_power(pdev, 1);
721 pwc_set_leds(pdev, leds[0], leds[1]);
722
723 r = pwc_isoc_init(pdev);
724 if (r) {
725 /* If we failed turn camera and LEDS back off */
726 pwc_set_leds(pdev, 0, 0);
727 pwc_camera_power(pdev, 0);
728 /* And cleanup any queued bufs!! */
729 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_QUEUED);
730 }
731 mutex_unlock(&pdev->v4l2_lock);
732
733 return r;
734 }
735
736 static void stop_streaming(struct vb2_queue *vq)
737 {
738 struct pwc_device *pdev = vb2_get_drv_priv(vq);
739
740 mutex_lock(&pdev->v4l2_lock);
741 if (pdev->udev) {
742 pwc_set_leds(pdev, 0, 0);
743 pwc_camera_power(pdev, 0);
744 pwc_isoc_cleanup(pdev);
745 }
746
747 pwc_cleanup_queued_bufs(pdev, VB2_BUF_STATE_ERROR);
748 if (pdev->fill_buf)
749 vb2_buffer_done(&pdev->fill_buf->vb.vb2_buf,
750 VB2_BUF_STATE_ERROR);
751 mutex_unlock(&pdev->v4l2_lock);
752 }
753
754 static const struct vb2_ops pwc_vb_queue_ops = {
755 .queue_setup = queue_setup,
756 .buf_init = buffer_init,
757 .buf_prepare = buffer_prepare,
758 .buf_finish = buffer_finish,
759 .buf_cleanup = buffer_cleanup,
760 .buf_queue = buffer_queue,
761 .start_streaming = start_streaming,
762 .stop_streaming = stop_streaming,
763 };
764
765 /***************************************************************************/
766 /* USB functions */
767
768 /* This function gets called when a new device is plugged in or the usb core
769 * is loaded.
770 */
771
772 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
773 {
774 struct usb_device *udev = interface_to_usbdev(intf);
775 struct pwc_device *pdev = NULL;
776 int vendor_id, product_id, type_id;
777 int rc;
778 int features = 0;
779 int compression = 0;
780 int my_power_save = power_save;
781 char serial_number[30], *name;
782
783 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
784 product_id = le16_to_cpu(udev->descriptor.idProduct);
785
786 /* Check if we can handle this device */
787 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
788 vendor_id, product_id,
789 intf->altsetting->desc.bInterfaceNumber);
790
791 /* the interfaces are probed one by one. We are only interested in the
792 video interface (0) now.
793 Interface 1 is the Audio Control, and interface 2 Audio itself.
794 */
795 if (intf->altsetting->desc.bInterfaceNumber > 0)
796 return -ENODEV;
797
798 if (vendor_id == 0x0471) {
799 switch (product_id) {
800 case 0x0302:
801 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
802 name = "Philips 645 webcam";
803 type_id = 645;
804 break;
805 case 0x0303:
806 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
807 name = "Philips 646 webcam";
808 type_id = 646;
809 break;
810 case 0x0304:
811 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
812 name = "Askey VC010 webcam";
813 type_id = 646;
814 break;
815 case 0x0307:
816 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
817 name = "Philips 675 webcam";
818 type_id = 675;
819 break;
820 case 0x0308:
821 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
822 name = "Philips 680 webcam";
823 type_id = 680;
824 break;
825 case 0x030C:
826 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
827 name = "Philips 690 webcam";
828 type_id = 690;
829 break;
830 case 0x0310:
831 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
832 name = "Philips 730 webcam";
833 type_id = 730;
834 break;
835 case 0x0311:
836 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
837 name = "Philips 740 webcam";
838 type_id = 740;
839 break;
840 case 0x0312:
841 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
842 name = "Philips 750 webcam";
843 type_id = 750;
844 break;
845 case 0x0313:
846 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
847 name = "Philips 720K/40 webcam";
848 type_id = 720;
849 break;
850 case 0x0329:
851 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
852 name = "Philips SPC 900NC webcam";
853 type_id = 740;
854 break;
855 case 0x032C:
856 PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
857 name = "Philips SPC 880NC webcam";
858 type_id = 740;
859 break;
860 default:
861 return -ENODEV;
862 }
863 }
864 else if (vendor_id == 0x069A) {
865 switch(product_id) {
866 case 0x0001:
867 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
868 name = "Askey VC010 webcam";
869 type_id = 645;
870 break;
871 default:
872 return -ENODEV;
873 }
874 }
875 else if (vendor_id == 0x046d) {
876 switch(product_id) {
877 case 0x08b0:
878 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
879 name = "Logitech QuickCam Pro 3000";
880 type_id = 740; /* CCD sensor */
881 break;
882 case 0x08b1:
883 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
884 name = "Logitech QuickCam Notebook Pro";
885 type_id = 740; /* CCD sensor */
886 break;
887 case 0x08b2:
888 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
889 name = "Logitech QuickCam Pro 4000";
890 type_id = 740; /* CCD sensor */
891 if (my_power_save == -1)
892 my_power_save = 1;
893 break;
894 case 0x08b3:
895 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
896 name = "Logitech QuickCam Zoom";
897 type_id = 740; /* CCD sensor */
898 break;
899 case 0x08B4:
900 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
901 name = "Logitech QuickCam Zoom";
902 type_id = 740; /* CCD sensor */
903 if (my_power_save == -1)
904 my_power_save = 1;
905 break;
906 case 0x08b5:
907 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
908 name = "Logitech QuickCam Orbit";
909 type_id = 740; /* CCD sensor */
910 if (my_power_save == -1)
911 my_power_save = 1;
912 features |= FEATURE_MOTOR_PANTILT;
913 break;
914 case 0x08b6:
915 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
916 name = "Cisco VT Camera";
917 type_id = 740; /* CCD sensor */
918 break;
919 case 0x08b7:
920 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
921 name = "Logitech ViewPort AV 100";
922 type_id = 740; /* CCD sensor */
923 break;
924 case 0x08b8: /* Where this released? */
925 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
926 name = "Logitech QuickCam (res.)";
927 type_id = 730; /* Assuming CMOS */
928 break;
929 default:
930 return -ENODEV;
931 }
932 }
933 else if (vendor_id == 0x055d) {
934 /* I don't know the difference between the C10 and the C30;
935 I suppose the difference is the sensor, but both cameras
936 work equally well with a type_id of 675
937 */
938 switch(product_id) {
939 case 0x9000:
940 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
941 name = "Samsung MPC-C10";
942 type_id = 675;
943 break;
944 case 0x9001:
945 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
946 name = "Samsung MPC-C30";
947 type_id = 675;
948 break;
949 case 0x9002:
950 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
951 name = "Samsung MPC-C30";
952 type_id = 740;
953 break;
954 default:
955 return -ENODEV;
956 }
957 }
958 else if (vendor_id == 0x041e) {
959 switch(product_id) {
960 case 0x400c:
961 PWC_INFO("Creative Labs Webcam 5 detected.\n");
962 name = "Creative Labs Webcam 5";
963 type_id = 730;
964 if (my_power_save == -1)
965 my_power_save = 1;
966 break;
967 case 0x4011:
968 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
969 name = "Creative Labs Webcam Pro Ex";
970 type_id = 740;
971 break;
972 default:
973 return -ENODEV;
974 }
975 }
976 else if (vendor_id == 0x04cc) {
977 switch(product_id) {
978 case 0x8116:
979 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
980 name = "Sotec Afina Eye";
981 type_id = 730;
982 break;
983 default:
984 return -ENODEV;
985 }
986 }
987 else if (vendor_id == 0x06be) {
988 switch(product_id) {
989 case 0x8116:
990 /* This is essentially the same cam as the Sotec Afina Eye */
991 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
992 name = "AME Co. Afina Eye";
993 type_id = 750;
994 break;
995 default:
996 return -ENODEV;
997 }
998
999 }
1000 else if (vendor_id == 0x0d81) {
1001 switch(product_id) {
1002 case 0x1900:
1003 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1004 name = "Visionite VCS-UC300";
1005 type_id = 740; /* CCD sensor */
1006 break;
1007 case 0x1910:
1008 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1009 name = "Visionite VCS-UM100";
1010 type_id = 730; /* CMOS sensor */
1011 break;
1012 default:
1013 return -ENODEV;
1014 }
1015 }
1016 else
1017 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1018
1019 if (my_power_save == -1)
1020 my_power_save = 0;
1021
1022 memset(serial_number, 0, 30);
1023 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1024 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1025
1026 if (udev->descriptor.bNumConfigurations > 1)
1027 PWC_WARNING("Warning: more than 1 configuration available.\n");
1028
1029 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1030 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1031 if (pdev == NULL) {
1032 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1033 return -ENOMEM;
1034 }
1035 pdev->type = type_id;
1036 pdev->features = features;
1037 pwc_construct(pdev); /* set min/max sizes correct */
1038
1039 mutex_init(&pdev->v4l2_lock);
1040 mutex_init(&pdev->vb_queue_lock);
1041 spin_lock_init(&pdev->queued_bufs_lock);
1042 INIT_LIST_HEAD(&pdev->queued_bufs);
1043
1044 pdev->udev = udev;
1045 pdev->power_save = my_power_save;
1046
1047 /* Init videobuf2 queue structure */
1048 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1049 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1050 pdev->vb_queue.drv_priv = pdev;
1051 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1052 pdev->vb_queue.ops = &pwc_vb_queue_ops;
1053 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1054 pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1055 pdev->vb_queue.lock = &pdev->vb_queue_lock;
1056 rc = vb2_queue_init(&pdev->vb_queue);
1057 if (rc < 0) {
1058 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1059 goto err_free_mem;
1060 }
1061
1062 /* Init video_device structure */
1063 pdev->vdev = pwc_template;
1064 strscpy(pdev->vdev.name, name, sizeof(pdev->vdev.name));
1065 pdev->vdev.queue = &pdev->vb_queue;
1066 video_set_drvdata(&pdev->vdev, pdev);
1067
1068 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1069 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1070
1071 /* Allocate USB command buffers */
1072 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1073 if (!pdev->ctrl_buf) {
1074 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1075 rc = -ENOMEM;
1076 goto err_free_mem;
1077 }
1078
1079 #ifdef CONFIG_USB_PWC_DEBUG
1080 /* Query sensor type */
1081 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1082 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1083 pdev->vdev.name,
1084 pwc_sensor_type_to_string(rc), rc);
1085 }
1086 #endif
1087
1088 /* Set the leds off */
1089 pwc_set_leds(pdev, 0, 0);
1090
1091 /* Setup initial videomode */
1092 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1093 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1094 if (rc)
1095 goto err_free_mem;
1096
1097 /* Register controls (and read default values from camera */
1098 rc = pwc_init_controls(pdev);
1099 if (rc) {
1100 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1101 goto err_free_mem;
1102 }
1103
1104 /* And powerdown the camera until streaming starts */
1105 pwc_camera_power(pdev, 0);
1106
1107 /* Register the v4l2_device structure */
1108 pdev->v4l2_dev.release = pwc_video_release;
1109 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1110 if (rc) {
1111 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1112 goto err_free_controls;
1113 }
1114
1115 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1116 pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1117 pdev->vdev.lock = &pdev->v4l2_lock;
1118 pdev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
1119 V4L2_CAP_READWRITE;
1120
1121 rc = video_register_device(&pdev->vdev, VFL_TYPE_VIDEO, -1);
1122 if (rc < 0) {
1123 PWC_ERROR("Failed to register as video device (%d).\n", rc);
1124 goto err_unregister_v4l2_dev;
1125 }
1126 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1127
1128 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1129 /* register webcam snapshot button input device */
1130 pdev->button_dev = input_allocate_device();
1131 if (!pdev->button_dev) {
1132 rc = -ENOMEM;
1133 goto err_video_unreg;
1134 }
1135
1136 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1137 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1138
1139 pdev->button_dev->name = "PWC snapshot button";
1140 pdev->button_dev->phys = pdev->button_phys;
1141 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1142 pdev->button_dev->dev.parent = &pdev->udev->dev;
1143 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1144 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1145
1146 rc = input_register_device(pdev->button_dev);
1147 if (rc) {
1148 input_free_device(pdev->button_dev);
1149 pdev->button_dev = NULL;
1150 goto err_video_unreg;
1151 }
1152 #endif
1153
1154 return 0;
1155
1156 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1157 err_video_unreg:
1158 video_unregister_device(&pdev->vdev);
1159 #endif
1160 err_unregister_v4l2_dev:
1161 v4l2_device_unregister(&pdev->v4l2_dev);
1162 err_free_controls:
1163 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1164 err_free_mem:
1165 kfree(pdev->ctrl_buf);
1166 kfree(pdev);
1167 return rc;
1168 }
1169
1170 /* The user yanked out the cable... */
1171 static void usb_pwc_disconnect(struct usb_interface *intf)
1172 {
1173 struct v4l2_device *v = usb_get_intfdata(intf);
1174 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1175
1176 mutex_lock(&pdev->vb_queue_lock);
1177 mutex_lock(&pdev->v4l2_lock);
1178 /* No need to keep the urbs around after disconnection */
1179 if (pdev->vb_queue.streaming)
1180 pwc_isoc_cleanup(pdev);
1181 pdev->udev = NULL;
1182
1183 v4l2_device_disconnect(&pdev->v4l2_dev);
1184 video_unregister_device(&pdev->vdev);
1185 mutex_unlock(&pdev->v4l2_lock);
1186 mutex_unlock(&pdev->vb_queue_lock);
1187
1188 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1189 if (pdev->button_dev)
1190 input_unregister_device(pdev->button_dev);
1191 #endif
1192
1193 v4l2_device_put(&pdev->v4l2_dev);
1194 }
1195
1196
1197 /*
1198 * Initialization code & module stuff
1199 */
1200
1201 static unsigned int leds_nargs;
1202
1203 #ifdef CONFIG_USB_PWC_DEBUG
1204 module_param_named(trace, pwc_trace, int, 0644);
1205 #endif
1206 module_param(power_save, int, 0644);
1207 module_param_array(leds, int, &leds_nargs, 0444);
1208
1209 #ifdef CONFIG_USB_PWC_DEBUG
1210 MODULE_PARM_DESC(trace, "For debugging purposes");
1211 #endif
1212 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1213 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1214
1215 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1216 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1217 MODULE_LICENSE("GPL");
1218 MODULE_ALIAS("pwcx");
1219 MODULE_VERSION( PWC_VERSION );
1220
1221 module_usb_driver(pwc_driver);
Kernel DRM miscellaneous fixes and cross-tree changes