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 
pwc_alloc_urb_buffer(struct usb_device * dev,size_t size,dma_addr_t * dma_handle)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 
pwc_free_urb_buffer(struct usb_device * dev,size_t size,void * buffer,dma_addr_t dma_handle)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 
pwc_get_next_fill_buf(struct pwc_device * pdev)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 
pwc_snapshot_button(struct pwc_device * pdev,int down)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 
pwc_frame_complete(struct pwc_device * pdev)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  */
pwc_isoc_handler(struct urb * urb)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 */
pwc_isoc_init(struct pwc_device * pdev)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 
pwc_iso_stop(struct pwc_device * pdev)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 
pwc_iso_free(struct pwc_device * pdev)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 */
pwc_isoc_cleanup(struct pwc_device * pdev)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 */
pwc_cleanup_queued_bufs(struct pwc_device * pdev,enum vb2_buffer_state state)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
pwc_sensor_type_to_string(unsigned int sensor_type)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 
pwc_video_release(struct v4l2_device * v)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 
queue_setup(struct vb2_queue * vq,unsigned int * nbuffers,unsigned int * nplanes,unsigned int sizes[],struct device * alloc_devs[])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 
buffer_init(struct vb2_buffer * vb)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 
buffer_prepare(struct vb2_buffer * vb)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 
buffer_finish(struct vb2_buffer * vb)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 
buffer_cleanup(struct vb2_buffer * vb)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 
buffer_queue(struct vb2_buffer * vb)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 
start_streaming(struct vb2_queue * vq,unsigned int count)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 
stop_streaming(struct vb2_queue * vq)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 
usb_pwc_probe(struct usb_interface * intf,const struct usb_device_id * id)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 		}
865 	}
866 	else if (vendor_id == 0x069A) {
867 		switch(product_id) {
868 		case 0x0001:
869 			PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
870 			name = "Askey VC010 webcam";
871 			type_id = 645;
872 			break;
873 		default:
874 			return -ENODEV;
875 		}
876 	}
877 	else if (vendor_id == 0x046d) {
878 		switch(product_id) {
879 		case 0x08b0:
880 			PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
881 			name = "Logitech QuickCam Pro 3000";
882 			type_id = 740; /* CCD sensor */
883 			break;
884 		case 0x08b1:
885 			PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
886 			name = "Logitech QuickCam Notebook Pro";
887 			type_id = 740; /* CCD sensor */
888 			break;
889 		case 0x08b2:
890 			PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
891 			name = "Logitech QuickCam Pro 4000";
892 			type_id = 740; /* CCD sensor */
893 			if (my_power_save == -1)
894 				my_power_save = 1;
895 			break;
896 		case 0x08b3:
897 			PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
898 			name = "Logitech QuickCam Zoom";
899 			type_id = 740; /* CCD sensor */
900 			break;
901 		case 0x08B4:
902 			PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
903 			name = "Logitech QuickCam Zoom";
904 			type_id = 740; /* CCD sensor */
905 			if (my_power_save == -1)
906 				my_power_save = 1;
907 			break;
908 		case 0x08b5:
909 			PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
910 			name = "Logitech QuickCam Orbit";
911 			type_id = 740; /* CCD sensor */
912 			if (my_power_save == -1)
913 				my_power_save = 1;
914 			features |= FEATURE_MOTOR_PANTILT;
915 			break;
916 		case 0x08b6:
917 			PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
918 			name = "Cisco VT Camera";
919 			type_id = 740; /* CCD sensor */
920 			break;
921 		case 0x08b7:
922 			PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
923 			name = "Logitech ViewPort AV 100";
924 			type_id = 740; /* CCD sensor */
925 			break;
926 		case 0x08b8: /* Where this released? */
927 			PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
928 			name = "Logitech QuickCam (res.)";
929 			type_id = 730; /* Assuming CMOS */
930 			break;
931 		default:
932 			return -ENODEV;
933 		}
934 	}
935 	else if (vendor_id == 0x055d) {
936 		/* I don't know the difference between the C10 and the C30;
937 		   I suppose the difference is the sensor, but both cameras
938 		   work equally well with a type_id of 675
939 		 */
940 		switch(product_id) {
941 		case 0x9000:
942 			PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
943 			name = "Samsung MPC-C10";
944 			type_id = 675;
945 			break;
946 		case 0x9001:
947 			PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
948 			name = "Samsung MPC-C30";
949 			type_id = 675;
950 			break;
951 		case 0x9002:
952 			PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
953 			name = "Samsung MPC-C30";
954 			type_id = 740;
955 			break;
956 		default:
957 			return -ENODEV;
958 		}
959 	}
960 	else if (vendor_id == 0x041e) {
961 		switch(product_id) {
962 		case 0x400c:
963 			PWC_INFO("Creative Labs Webcam 5 detected.\n");
964 			name = "Creative Labs Webcam 5";
965 			type_id = 730;
966 			if (my_power_save == -1)
967 				my_power_save = 1;
968 			break;
969 		case 0x4011:
970 			PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
971 			name = "Creative Labs Webcam Pro Ex";
972 			type_id = 740;
973 			break;
974 		default:
975 			return -ENODEV;
976 		}
977 	}
978 	else if (vendor_id == 0x04cc) {
979 		switch(product_id) {
980 		case 0x8116:
981 			PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
982 			name = "Sotec Afina Eye";
983 			type_id = 730;
984 			break;
985 		default:
986 			return -ENODEV;
987 		}
988 	}
989 	else if (vendor_id == 0x06be) {
990 		switch(product_id) {
991 		case 0x8116:
992 			/* This is essentially the same cam as the Sotec Afina Eye */
993 			PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
994 			name = "AME Co. Afina Eye";
995 			type_id = 750;
996 			break;
997 		default:
998 			return -ENODEV;
999 		}
1000 
1001 	}
1002 	else if (vendor_id == 0x0d81) {
1003 		switch(product_id) {
1004 		case 0x1900:
1005 			PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
1006 			name = "Visionite VCS-UC300";
1007 			type_id = 740; /* CCD sensor */
1008 			break;
1009 		case 0x1910:
1010 			PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
1011 			name = "Visionite VCS-UM100";
1012 			type_id = 730; /* CMOS sensor */
1013 			break;
1014 		default:
1015 			return -ENODEV;
1016 		}
1017 	}
1018 	else
1019 		return -ENODEV; /* Not any of the know types; but the list keeps growing. */
1020 
1021 	if (my_power_save == -1)
1022 		my_power_save = 0;
1023 
1024 	memset(serial_number, 0, 30);
1025 	usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
1026 	PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
1027 
1028 	if (udev->descriptor.bNumConfigurations > 1)
1029 		PWC_WARNING("Warning: more than 1 configuration available.\n");
1030 
1031 	/* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
1032 	pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
1033 	if (pdev == NULL) {
1034 		PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1035 		return -ENOMEM;
1036 	}
1037 	pdev->type = type_id;
1038 	pdev->features = features;
1039 	pwc_construct(pdev); /* set min/max sizes correct */
1040 
1041 	mutex_init(&pdev->v4l2_lock);
1042 	mutex_init(&pdev->vb_queue_lock);
1043 	spin_lock_init(&pdev->queued_bufs_lock);
1044 	INIT_LIST_HEAD(&pdev->queued_bufs);
1045 
1046 	pdev->udev = udev;
1047 	pdev->power_save = my_power_save;
1048 
1049 	/* Init videobuf2 queue structure */
1050 	pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1051 	pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1052 	pdev->vb_queue.drv_priv = pdev;
1053 	pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1054 	pdev->vb_queue.ops = &pwc_vb_queue_ops;
1055 	pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
1056 	pdev->vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1057 	rc = vb2_queue_init(&pdev->vb_queue);
1058 	if (rc < 0) {
1059 		PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1060 		goto err_free_mem;
1061 	}
1062 
1063 	/* Init video_device structure */
1064 	pdev->vdev = pwc_template;
1065 	strscpy(pdev->vdev.name, name, sizeof(pdev->vdev.name));
1066 	pdev->vdev.queue = &pdev->vb_queue;
1067 	pdev->vdev.queue->lock = &pdev->vb_queue_lock;
1068 	video_set_drvdata(&pdev->vdev, pdev);
1069 
1070 	pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
1071 	PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
1072 
1073 	/* Allocate USB command buffers */
1074 	pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1075 	if (!pdev->ctrl_buf) {
1076 		PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1077 		rc = -ENOMEM;
1078 		goto err_free_mem;
1079 	}
1080 
1081 #ifdef CONFIG_USB_PWC_DEBUG
1082 	/* Query sensor type */
1083 	if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1084 		PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1085 				pdev->vdev.name,
1086 				pwc_sensor_type_to_string(rc), rc);
1087 	}
1088 #endif
1089 
1090 	/* Set the leds off */
1091 	pwc_set_leds(pdev, 0, 0);
1092 
1093 	/* Setup initial videomode */
1094 	rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
1095 				V4L2_PIX_FMT_YUV420, 30, &compression, 1);
1096 	if (rc)
1097 		goto err_free_mem;
1098 
1099 	/* Register controls (and read default values from camera */
1100 	rc = pwc_init_controls(pdev);
1101 	if (rc) {
1102 		PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1103 		goto err_free_mem;
1104 	}
1105 
1106 	/* And powerdown the camera until streaming starts */
1107 	pwc_camera_power(pdev, 0);
1108 
1109 	/* Register the v4l2_device structure */
1110 	pdev->v4l2_dev.release = pwc_video_release;
1111 	rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1112 	if (rc) {
1113 		PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1114 		goto err_free_controls;
1115 	}
1116 
1117 	pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1118 	pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
1119 	pdev->vdev.lock = &pdev->v4l2_lock;
1120 	pdev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
1121 				 V4L2_CAP_READWRITE;
1122 
1123 	rc = video_register_device(&pdev->vdev, VFL_TYPE_VIDEO, -1);
1124 	if (rc < 0) {
1125 		PWC_ERROR("Failed to register as video device (%d).\n", rc);
1126 		goto err_unregister_v4l2_dev;
1127 	}
1128 	PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
1129 
1130 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1131 	/* register webcam snapshot button input device */
1132 	pdev->button_dev = input_allocate_device();
1133 	if (!pdev->button_dev) {
1134 		rc = -ENOMEM;
1135 		goto err_video_unreg;
1136 	}
1137 
1138 	usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1139 	strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1140 
1141 	pdev->button_dev->name = "PWC snapshot button";
1142 	pdev->button_dev->phys = pdev->button_phys;
1143 	usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1144 	pdev->button_dev->dev.parent = &pdev->udev->dev;
1145 	pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
1146 	pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
1147 
1148 	rc = input_register_device(pdev->button_dev);
1149 	if (rc) {
1150 		input_free_device(pdev->button_dev);
1151 		pdev->button_dev = NULL;
1152 		goto err_video_unreg;
1153 	}
1154 #endif
1155 
1156 	return 0;
1157 
1158 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1159 err_video_unreg:
1160 	video_unregister_device(&pdev->vdev);
1161 #endif
1162 err_unregister_v4l2_dev:
1163 	v4l2_device_unregister(&pdev->v4l2_dev);
1164 err_free_controls:
1165 	v4l2_ctrl_handler_free(&pdev->ctrl_handler);
1166 err_free_mem:
1167 	kfree(pdev->ctrl_buf);
1168 	kfree(pdev);
1169 	return rc;
1170 }
1171 
1172 /* The user yanked out the cable... */
usb_pwc_disconnect(struct usb_interface * intf)1173 static void usb_pwc_disconnect(struct usb_interface *intf)
1174 {
1175 	struct v4l2_device *v = usb_get_intfdata(intf);
1176 	struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
1177 
1178 	mutex_lock(&pdev->vb_queue_lock);
1179 	mutex_lock(&pdev->v4l2_lock);
1180 	/* No need to keep the urbs around after disconnection */
1181 	if (pdev->vb_queue.streaming)
1182 		pwc_isoc_cleanup(pdev);
1183 	pdev->udev = NULL;
1184 
1185 	v4l2_device_disconnect(&pdev->v4l2_dev);
1186 	video_unregister_device(&pdev->vdev);
1187 	mutex_unlock(&pdev->v4l2_lock);
1188 	mutex_unlock(&pdev->vb_queue_lock);
1189 
1190 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
1191 	if (pdev->button_dev)
1192 		input_unregister_device(pdev->button_dev);
1193 #endif
1194 
1195 	v4l2_device_put(&pdev->v4l2_dev);
1196 }
1197 
1198 
1199 /*
1200  * Initialization code & module stuff
1201  */
1202 
1203 static unsigned int leds_nargs;
1204 
1205 #ifdef CONFIG_USB_PWC_DEBUG
1206 module_param_named(trace, pwc_trace, int, 0644);
1207 #endif
1208 module_param(power_save, int, 0644);
1209 module_param_array(leds, int, &leds_nargs, 0444);
1210 
1211 #ifdef CONFIG_USB_PWC_DEBUG
1212 MODULE_PARM_DESC(trace, "For debugging purposes");
1213 #endif
1214 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
1215 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
1216 
1217 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1218 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1219 MODULE_LICENSE("GPL");
1220 MODULE_ALIAS("pwcx");
1221 MODULE_VERSION( PWC_VERSION );
1222 
1223 module_usb_driver(pwc_driver);
1224