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