xref: /openbmc/linux/drivers/media/usb/pwc/pwc-if.c (revision 62e59c4e)
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 #define CREATE_TRACE_POINTS
80 #include <trace/events/pwc.h>
81 
82 /* Function prototypes and driver templates */
83 
84 /* hotplug device table support */
85 static const struct usb_device_id pwc_device_table [] = {
86 	{ USB_DEVICE(0x0471, 0x0302) }, /* Philips models */
87 	{ USB_DEVICE(0x0471, 0x0303) },
88 	{ USB_DEVICE(0x0471, 0x0304) },
89 	{ USB_DEVICE(0x0471, 0x0307) },
90 	{ USB_DEVICE(0x0471, 0x0308) },
91 	{ USB_DEVICE(0x0471, 0x030C) },
92 	{ USB_DEVICE(0x0471, 0x0310) },
93 	{ USB_DEVICE(0x0471, 0x0311) }, /* Philips ToUcam PRO II */
94 	{ USB_DEVICE(0x0471, 0x0312) },
95 	{ USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
96 	{ USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC PC Camera */
97 	{ USB_DEVICE(0x0471, 0x032C) }, /* Philips SPC 880NC PC Camera */
98 	{ USB_DEVICE(0x069A, 0x0001) }, /* Askey */
99 	{ USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
100 	{ USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
101 	{ USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */
102 	{ USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */
103 	{ USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */
104 	{ USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */
105 	{ USB_DEVICE(0x046D, 0x08B6) }, /* Cisco VT Camera */
106 	{ USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
107 	{ USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
108 	{ USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
109 	{ USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
110 	{ USB_DEVICE(0x055D, 0x9002) },	/* Samsung SNC-35E (Ver3.0) */
111 	{ USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
112 	{ USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
113 	{ USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
114 	{ USB_DEVICE(0x06BE, 0x8116) }, /* new Afina Eye */
115 	{ USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */
116 	{ USB_DEVICE(0x0d81, 0x1900) },
117 	{ }
118 };
119 MODULE_DEVICE_TABLE(usb, pwc_device_table);
120 
121 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
122 static void usb_pwc_disconnect(struct usb_interface *intf);
123 static void pwc_isoc_cleanup(struct pwc_device *pdev);
124 
125 static struct usb_driver pwc_driver = {
126 	.name =			"Philips webcam",	/* name */
127 	.id_table =		pwc_device_table,
128 	.probe =		usb_pwc_probe,		/* probe() */
129 	.disconnect =		usb_pwc_disconnect,	/* disconnect() */
130 };
131 
132 #define MAX_DEV_HINTS	20
133 #define MAX_ISOC_ERRORS	20
134 
135 #ifdef CONFIG_USB_PWC_DEBUG
136 	int pwc_trace = PWC_DEBUG_LEVEL;
137 #endif
138 static int power_save = -1;
139 static int leds[2] = { 100, 0 };
140 
141 /***/
142 
143 static const struct v4l2_file_operations pwc_fops = {
144 	.owner =	THIS_MODULE,
145 	.open =		v4l2_fh_open,
146 	.release =	vb2_fop_release,
147 	.read =		vb2_fop_read,
148 	.poll =		vb2_fop_poll,
149 	.mmap =		vb2_fop_mmap,
150 	.unlocked_ioctl = video_ioctl2,
151 };
152 static const struct video_device pwc_template = {
153 	.name =		"Philips Webcam",	/* Filled in later */
154 	.release =	video_device_release_empty,
155 	.fops =         &pwc_fops,
156 	.ioctl_ops =	&pwc_ioctl_ops,
157 };
158 
159 /***************************************************************************/
160 /* Private functions */
161 
162 static void *pwc_alloc_urb_buffer(struct device *dev,
163 				  size_t size, dma_addr_t *dma_handle)
164 {
165 	void *buffer = kmalloc(size, GFP_KERNEL);
166 
167 	if (!buffer)
168 		return NULL;
169 
170 	*dma_handle = dma_map_single(dev, buffer, size, DMA_FROM_DEVICE);
171 	if (dma_mapping_error(dev, *dma_handle)) {
172 		kfree(buffer);
173 		return NULL;
174 	}
175 
176 	return buffer;
177 }
178 
179 static void pwc_free_urb_buffer(struct device *dev,
180 				size_t size,
181 				void *buffer,
182 				dma_addr_t dma_handle)
183 {
184 	dma_unmap_single(dev, dma_handle, size, DMA_FROM_DEVICE);
185 	kfree(buffer);
186 }
187 
188 static struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
189 {
190 	unsigned long flags = 0;
191 	struct pwc_frame_buf *buf = NULL;
192 
193 	spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
194 	if (list_empty(&pdev->queued_bufs))
195 		goto leave;
196 
197 	buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
198 	list_del(&buf->list);
199 leave:
200 	spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
201 	return buf;
202 }
203 
204 static void pwc_snapshot_button(struct pwc_device *pdev, int down)
205 {
206 	if (down) {
207 		PWC_TRACE("Snapshot button pressed.\n");
208 	} else {
209 		PWC_TRACE("Snapshot button released.\n");
210 	}
211 
212 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
213 	if (pdev->button_dev) {
214 		input_report_key(pdev->button_dev, KEY_CAMERA, down);
215 		input_sync(pdev->button_dev);
216 	}
217 #endif
218 }
219 
220 static void pwc_frame_complete(struct pwc_device *pdev)
221 {
222 	struct pwc_frame_buf *fbuf = pdev->fill_buf;
223 
224 	/* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
225 	   frames on the USB wire after an exposure change. This conditition is
226 	   however detected  in the cam and a bit is set in the header.
227 	   */
228 	if (pdev->type == 730) {
229 		unsigned char *ptr = (unsigned char *)fbuf->data;
230 
231 		if (ptr[1] == 1 && ptr[0] & 0x10) {
232 			PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
233 			pdev->drop_frames += 2;
234 		}
235 		if ((ptr[0] ^ pdev->vmirror) & 0x01) {
236 			pwc_snapshot_button(pdev, ptr[0] & 0x01);
237 		}
238 		if ((ptr[0] ^ pdev->vmirror) & 0x02) {
239 			if (ptr[0] & 0x02)
240 				PWC_TRACE("Image is mirrored.\n");
241 			else
242 				PWC_TRACE("Image is normal.\n");
243 		}
244 		pdev->vmirror = ptr[0] & 0x03;
245 		/* Sometimes the trailer of the 730 is still sent as a 4 byte packet
246 		   after a short frame; this condition is filtered out specifically. A 4 byte
247 		   frame doesn't make sense anyway.
248 		   So we get either this sequence:
249 		   drop_bit set -> 4 byte frame -> short frame -> good frame
250 		   Or this one:
251 		   drop_bit set -> short frame -> good frame
252 		   So we drop either 3 or 2 frames in all!
253 		   */
254 		if (fbuf->filled == 4)
255 			pdev->drop_frames++;
256 	} else if (pdev->type == 740 || pdev->type == 720) {
257 		unsigned char *ptr = (unsigned char *)fbuf->data;
258 		if ((ptr[0] ^ pdev->vmirror) & 0x01) {
259 			pwc_snapshot_button(pdev, ptr[0] & 0x01);
260 		}
261 		pdev->vmirror = ptr[0] & 0x03;
262 	}
263 
264 	/* In case we were instructed to drop the frame, do so silently. */
265 	if (pdev->drop_frames > 0) {
266 		pdev->drop_frames--;
267 	} else {
268 		/* Check for underflow first */
269 		if (fbuf->filled < pdev->frame_total_size) {
270 			PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes); discarded.\n",
271 				       fbuf->filled);
272 		} else {
273 			fbuf->vb.field = V4L2_FIELD_NONE;
274 			fbuf->vb.sequence = pdev->vframe_count;
275 			vb2_buffer_done(&fbuf->vb.vb2_buf, VB2_BUF_STATE_DONE);
276 			pdev->fill_buf = NULL;
277 			pdev->vsync = 0;
278 		}
279 	} /* !drop_frames */
280 	pdev->vframe_count++;
281 }
282 
283 /* This gets called for the Isochronous pipe (video). This is done in
284  * interrupt time, so it has to be fast, not crash, and not stall. Neat.
285  */
286 static void pwc_isoc_handler(struct urb *urb)
287 {
288 	struct pwc_device *pdev = (struct pwc_device *)urb->context;
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(&urb->dev->dev,
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(&urb->dev->dev,
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->dev,
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->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 	.wait_prepare		= vb2_ops_wait_prepare,
764 	.wait_finish		= vb2_ops_wait_finish,
765 };
766 
767 /***************************************************************************/
768 /* USB functions */
769 
770 /* This function gets called when a new device is plugged in or the usb core
771  * is loaded.
772  */
773 
774 static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
775 {
776 	struct usb_device *udev = interface_to_usbdev(intf);
777 	struct pwc_device *pdev = NULL;
778 	int vendor_id, product_id, type_id;
779 	int rc;
780 	int features = 0;
781 	int compression = 0;
782 	int my_power_save = power_save;
783 	char serial_number[30], *name;
784 
785 	vendor_id = le16_to_cpu(udev->descriptor.idVendor);
786 	product_id = le16_to_cpu(udev->descriptor.idProduct);
787 
788 	/* Check if we can handle this device */
789 	PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
790 		vendor_id, product_id,
791 		intf->altsetting->desc.bInterfaceNumber);
792 
793 	/* the interfaces are probed one by one. We are only interested in the
794 	   video interface (0) now.
795 	   Interface 1 is the Audio Control, and interface 2 Audio itself.
796 	 */
797 	if (intf->altsetting->desc.bInterfaceNumber > 0)
798 		return -ENODEV;
799 
800 	if (vendor_id == 0x0471) {
801 		switch (product_id) {
802 		case 0x0302:
803 			PWC_INFO("Philips PCA645VC USB webcam detected.\n");
804 			name = "Philips 645 webcam";
805 			type_id = 645;
806 			break;
807 		case 0x0303:
808 			PWC_INFO("Philips PCA646VC USB webcam detected.\n");
809 			name = "Philips 646 webcam";
810 			type_id = 646;
811 			break;
812 		case 0x0304:
813 			PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
814 			name = "Askey VC010 webcam";
815 			type_id = 646;
816 			break;
817 		case 0x0307:
818 			PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
819 			name = "Philips 675 webcam";
820 			type_id = 675;
821 			break;
822 		case 0x0308:
823 			PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
824 			name = "Philips 680 webcam";
825 			type_id = 680;
826 			break;
827 		case 0x030C:
828 			PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
829 			name = "Philips 690 webcam";
830 			type_id = 690;
831 			break;
832 		case 0x0310:
833 			PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
834 			name = "Philips 730 webcam";
835 			type_id = 730;
836 			break;
837 		case 0x0311:
838 			PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
839 			name = "Philips 740 webcam";
840 			type_id = 740;
841 			break;
842 		case 0x0312:
843 			PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
844 			name = "Philips 750 webcam";
845 			type_id = 750;
846 			break;
847 		case 0x0313:
848 			PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
849 			name = "Philips 720K/40 webcam";
850 			type_id = 720;
851 			break;
852 		case 0x0329:
853 			PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
854 			name = "Philips SPC 900NC webcam";
855 			type_id = 740;
856 			break;
857 		case 0x032C:
858 			PWC_INFO("Philips SPC 880NC USB webcam detected.\n");
859 			name = "Philips SPC 880NC webcam";
860 			type_id = 740;
861 			break;
862 		default:
863 			return -ENODEV;
864 			break;
865 		}
866 	}
867 	else if (vendor_id == 0x069A) {
868 		switch(product_id) {
869 		case 0x0001:
870 			PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
871 			name = "Askey VC010 webcam";
872 			type_id = 645;
873 			break;
874 		default:
875 			return -ENODEV;
876 			break;
877 		}
878 	}
879 	else if (vendor_id == 0x046d) {
880 		switch(product_id) {
881 		case 0x08b0:
882 			PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
883 			name = "Logitech QuickCam Pro 3000";
884 			type_id = 740; /* CCD sensor */
885 			break;
886 		case 0x08b1:
887 			PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
888 			name = "Logitech QuickCam Notebook Pro";
889 			type_id = 740; /* CCD sensor */
890 			break;
891 		case 0x08b2:
892 			PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
893 			name = "Logitech QuickCam Pro 4000";
894 			type_id = 740; /* CCD sensor */
895 			if (my_power_save == -1)
896 				my_power_save = 1;
897 			break;
898 		case 0x08b3:
899 			PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
900 			name = "Logitech QuickCam Zoom";
901 			type_id = 740; /* CCD sensor */
902 			break;
903 		case 0x08B4:
904 			PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
905 			name = "Logitech QuickCam Zoom";
906 			type_id = 740; /* CCD sensor */
907 			if (my_power_save == -1)
908 				my_power_save = 1;
909 			break;
910 		case 0x08b5:
911 			PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
912 			name = "Logitech QuickCam Orbit";
913 			type_id = 740; /* CCD sensor */
914 			if (my_power_save == -1)
915 				my_power_save = 1;
916 			features |= FEATURE_MOTOR_PANTILT;
917 			break;
918 		case 0x08b6:
919 			PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
920 			name = "Cisco VT Camera";
921 			type_id = 740; /* CCD sensor */
922 			break;
923 		case 0x08b7:
924 			PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
925 			name = "Logitech ViewPort AV 100";
926 			type_id = 740; /* CCD sensor */
927 			break;
928 		case 0x08b8: /* Where this released? */
929 			PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
930 			name = "Logitech QuickCam (res.)";
931 			type_id = 730; /* Assuming CMOS */
932 			break;
933 		default:
934 			return -ENODEV;
935 			break;
936 		}
937 	}
938 	else if (vendor_id == 0x055d) {
939 		/* I don't know the difference between the C10 and the C30;
940 		   I suppose the difference is the sensor, but both cameras
941 		   work equally well with a type_id of 675
942 		 */
943 		switch(product_id) {
944 		case 0x9000:
945 			PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
946 			name = "Samsung MPC-C10";
947 			type_id = 675;
948 			break;
949 		case 0x9001:
950 			PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
951 			name = "Samsung MPC-C30";
952 			type_id = 675;
953 			break;
954 		case 0x9002:
955 			PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
956 			name = "Samsung MPC-C30";
957 			type_id = 740;
958 			break;
959 		default:
960 			return -ENODEV;
961 			break;
962 		}
963 	}
964 	else if (vendor_id == 0x041e) {
965 		switch(product_id) {
966 		case 0x400c:
967 			PWC_INFO("Creative Labs Webcam 5 detected.\n");
968 			name = "Creative Labs Webcam 5";
969 			type_id = 730;
970 			if (my_power_save == -1)
971 				my_power_save = 1;
972 			break;
973 		case 0x4011:
974 			PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
975 			name = "Creative Labs Webcam Pro Ex";
976 			type_id = 740;
977 			break;
978 		default:
979 			return -ENODEV;
980 			break;
981 		}
982 	}
983 	else if (vendor_id == 0x04cc) {
984 		switch(product_id) {
985 		case 0x8116:
986 			PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
987 			name = "Sotec Afina Eye";
988 			type_id = 730;
989 			break;
990 		default:
991 			return -ENODEV;
992 			break;
993 		}
994 	}
995 	else if (vendor_id == 0x06be) {
996 		switch(product_id) {
997 		case 0x8116:
998 			/* This is essentially the same cam as the Sotec Afina Eye */
999 			PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
1000 			name = "AME Co. Afina Eye";
1001 			type_id = 750;
1002 			break;
1003 		default:
1004 			return -ENODEV;
1005 			break;
1006 		}
1007 
1008 	}
1009 	else if (vendor_id == 0x0d81) {
1010 		switch(product_id) {
1011 		case 0x1900:
1012 			PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1013 			name = "Visionite VCS-UC300";
1014 			type_id = 740; /* CCD sensor */
1015 			break;
1016 		case 0x1910:
1017 			PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1018 			name = "Visionite VCS-UM100";
1019 			type_id = 730; /* CMOS sensor */
1020 			break;
1021 		default:
1022 			return -ENODEV;
1023 			break;
1024 		}
1025 	}
1026 	else
1027 		return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1028 
1029 	if (my_power_save == -1)
1030 		my_power_save = 0;
1031 
1032 	memset(serial_number, 0, 30);
1033 	usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1034 	PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1035 
1036 	if (udev->descriptor.bNumConfigurations > 1)
1037 		PWC_WARNING("Warning: more than 1 configuration available.\n");
1038 
1039 	/* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1040 	pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1041 	if (pdev == NULL) {
1042 		PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1043 		return -ENOMEM;
1044 	}
1045 	pdev->type = type_id;
1046 	pdev->features = features;
1047 	pwc_construct(pdev); /* set min/max sizes correct */
1048 
1049 	mutex_init(&pdev->v4l2_lock);
1050 	mutex_init(&pdev->vb_queue_lock);
1051 	spin_lock_init(&pdev->queued_bufs_lock);
1052 	INIT_LIST_HEAD(&pdev->queued_bufs);
1053 
1054 	pdev->udev = udev;
1055 	pdev->power_save = my_power_save;
1056 
1057 	/* Init videobuf2 queue structure */
1058 	pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1059 	pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1060 	pdev->vb_queue.drv_priv = pdev;
1061 	pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1062 	pdev->vb_queue.ops = &pwc_vb_queue_ops;
1063 	pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1064 	pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1065 	rc = vb2_queue_init(&pdev->vb_queue);
1066 	if (rc < 0) {
1067 		PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1068 		goto err_free_mem;
1069 	}
1070 
1071 	/* Init video_device structure */
1072 	pdev->vdev = pwc_template;
1073 	strscpy(pdev->vdev.name, name, sizeof(pdev->vdev.name));
1074 	pdev->vdev.queue = &pdev->vb_queue;
1075 	pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1076 	video_set_drvdata(&pdev->vdev, pdev);
1077 
1078 	pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1079 	PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1080 
1081 	/* Allocate USB command buffers */
1082 	pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1083 	if (!pdev->ctrl_buf) {
1084 		PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1085 		rc = -ENOMEM;
1086 		goto err_free_mem;
1087 	}
1088 
1089 #ifdef CONFIG_USB_PWC_DEBUG
1090 	/* Query sensor type */
1091 	if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1092 		PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1093 				pdev->vdev.name,
1094 				pwc_sensor_type_to_string(rc), rc);
1095 	}
1096 #endif
1097 
1098 	/* Set the leds off */
1099 	pwc_set_leds(pdev, 0, 0);
1100 
1101 	/* Setup initial videomode */
1102 	rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1103 				V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1104 	if (rc)
1105 		goto err_free_mem;
1106 
1107 	/* Register controls (and read default values from camera */
1108 	rc = pwc_init_controls(pdev);
1109 	if (rc) {
1110 		PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1111 		goto err_free_mem;
1112 	}
1113 
1114 	/* And powerdown the camera until streaming starts */
1115 	pwc_camera_power(pdev, 0);
1116 
1117 	/* Register the v4l2_device structure */
1118 	pdev->v4l2_dev.release = pwc_video_release;
1119 	rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1120 	if (rc) {
1121 		PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1122 		goto err_free_controls;
1123 	}
1124 
1125 	pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1126 	pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1127 	pdev->vdev.lock = &pdev->v4l2_lock;
1128 
1129 	rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
1130 	if (rc < 0) {
1131 		PWC_ERROR("Failed to register as video device (%d).\n", rc);
1132 		goto err_unregister_v4l2_dev;
1133 	}
1134 	PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1135 
1136 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1137 	/* register webcam snapshot button input device */
1138 	pdev->button_dev = input_allocate_device();
1139 	if (!pdev->button_dev) {
1140 		rc = -ENOMEM;
1141 		goto err_video_unreg;
1142 	}
1143 
1144 	usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1145 	strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1146 
1147 	pdev->button_dev->name = "PWC snapshot button";
1148 	pdev->button_dev->phys = pdev->button_phys;
1149 	usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1150 	pdev->button_dev->dev.parent = &pdev->udev->dev;
1151 	pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1152 	pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1153 
1154 	rc = input_register_device(pdev->button_dev);
1155 	if (rc) {
1156 		input_free_device(pdev->button_dev);
1157 		pdev->button_dev = NULL;
1158 		goto err_video_unreg;
1159 	}
1160 #endif
1161 
1162 	return 0;
1163 
1164 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1165 err_video_unreg:
1166 	video_unregister_device(&pdev->vdev);
1167 #endif
1168 err_unregister_v4l2_dev:
1169 	v4l2_device_unregister(&pdev->v4l2_dev);
1170 err_free_controls:
1171 	v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1172 err_free_mem:
1173 	kfree(pdev->ctrl_buf);
1174 	kfree(pdev);
1175 	return rc;
1176 }
1177 
1178 /* The user yanked out the cable... */
1179 static void usb_pwc_disconnect(struct usb_interface *intf)
1180 {
1181 	struct v4l2_device *v = usb_get_intfdata(intf);
1182 	struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1183 
1184 	mutex_lock(&pdev->vb_queue_lock);
1185 	mutex_lock(&pdev->v4l2_lock);
1186 	/* No need to keep the urbs around after disconnection */
1187 	if (pdev->vb_queue.streaming)
1188 		pwc_isoc_cleanup(pdev);
1189 	pdev->udev = NULL;
1190 
1191 	v4l2_device_disconnect(&pdev->v4l2_dev);
1192 	video_unregister_device(&pdev->vdev);
1193 	mutex_unlock(&pdev->v4l2_lock);
1194 	mutex_unlock(&pdev->vb_queue_lock);
1195 
1196 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1197 	if (pdev->button_dev)
1198 		input_unregister_device(pdev->button_dev);
1199 #endif
1200 
1201 	v4l2_device_put(&pdev->v4l2_dev);
1202 }
1203 
1204 
1205 /*
1206  * Initialization code & module stuff
1207  */
1208 
1209 static unsigned int leds_nargs;
1210 
1211 #ifdef CONFIG_USB_PWC_DEBUG
1212 module_param_named(trace, pwc_trace, int, 0644);
1213 #endif
1214 module_param(power_save, int, 0644);
1215 module_param_array(leds, int, &leds_nargs, 0444);
1216 
1217 #ifdef CONFIG_USB_PWC_DEBUG
1218 MODULE_PARM_DESC(trace, "For debugging purposes");
1219 #endif
1220 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1221 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1222 
1223 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1224 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1225 MODULE_LICENSE("GPL");
1226 MODULE_ALIAS("pwcx");
1227 MODULE_VERSION( PWC_VERSION );
1228 
1229 module_usb_driver(pwc_driver);
1230