blob: 77bbf788965953bbc67f8fa8b3ab18ccbe5806d8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* Linux driver for Philips webcam
2 USB and Video4Linux interface part.
3 (C) 1999-2004 Nemosoft Unv.
Luc Saillard2b455db2006-04-24 10:29:46 -03004 (C) 2004-2006 Luc Saillard (luc@saillard.org)
Hans de Goede6eba9352011-06-26 06:49:59 -03005 (C) 2011 Hans de Goede <hdegoede@redhat.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006
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
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -030029/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 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
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -030033 is thus not distributed in source form. The binary pwcx.o module
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 contains the code that falls under the NDA.
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -030035
36 In case you're wondering: 'pwc' stands for "Philips WebCam", but
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 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).
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -030040
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 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 *
Hans de Goede9a7b2d12011-06-06 14:43:39 -030044 vdev: struct video_device (member of pwc_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 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
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -030057 - Pham Thanh Nam: webcam snapshot button as an event input device
Linus Torvalds1da177e2005-04-16 15:20:36 -070058*/
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>
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -030066#ifdef CONFIG_USB_PWC_INPUT_EVDEV
67#include <linux/usb/input.h>
68#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <linux/vmalloc.h>
70#include <asm/io.h>
Andy Shevchenko2d8d7762009-09-24 07:58:09 -030071#include <linux/kernel.h> /* simple_strtol() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73#include "pwc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#include "pwc-kiara.h"
75#include "pwc-timon.h"
Luc Saillard2b455db2006-04-24 10:29:46 -030076#include "pwc-dec23.h"
77#include "pwc-dec1.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79/* Function prototypes and driver templates */
80
81/* hotplug device table support */
Luc Saillard2b455db2006-04-24 10:29:46 -030082static const struct usb_device_id pwc_device_table [] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 { 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) },
Luc Saillard2b455db2006-04-24 10:29:46 -030090 { USB_DEVICE(0x0471, 0x0311) }, /* Philips ToUcam PRO II */
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 { USB_DEVICE(0x0471, 0x0312) },
92 { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
Luc Saillard2b455db2006-04-24 10:29:46 -030093 { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC PC Camera */
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 { 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 */
Mauro Carvalho Chehab6b1ce3c2007-03-21 16:35:28 -0300101 { USB_DEVICE(0x046D, 0x08B6) }, /* Cisco VT Camera */
102 { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech ViewPort AV 100 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
Luc Saillard2b455db2006-04-24 10:29:46 -0300104 { 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) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 { 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};
115MODULE_DEVICE_TABLE(usb, pwc_device_table);
116
117static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);
118static void usb_pwc_disconnect(struct usb_interface *intf);
Hans de Goede885fe182011-06-06 15:33:44 -0300119static void pwc_isoc_cleanup(struct pwc_device *pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
121static struct usb_driver pwc_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 .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
Trent Piepho05ad3902007-01-30 23:26:01 -0300131#ifdef CONFIG_USB_PWC_DEBUG
Michael Krufkyb930e1d2007-08-27 18:16:54 -0300132 int pwc_trace = PWC_DEBUG_LEVEL;
Luc Saillard2b455db2006-04-24 10:29:46 -0300133#endif
Hans de Goede3b4d0ec2011-06-26 03:51:19 -0300134static int power_save = -1;
Hans de Goedec24e1372012-01-10 17:51:12 -0300135static int leds[2] = { 100, 0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
137/***/
138
Hans Verkuilbec436612008-12-30 06:58:20 -0300139static const struct v4l2_file_operations pwc_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 .owner = THIS_MODULE,
Hans de Goede76ae8532011-07-19 07:14:22 -0300141 .open = v4l2_fh_open,
Hans Verkuil2e43dec2012-07-02 05:51:58 -0300142 .release = vb2_fop_release,
143 .read = vb2_fop_read,
144 .poll = vb2_fop_poll,
145 .mmap = vb2_fop_mmap,
Hans Verkuilafa38522011-01-22 06:34:55 -0300146 .unlocked_ioctl = video_ioctl2,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147};
148static struct video_device pwc_template = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 .name = "Philips Webcam", /* Filled in later */
Hans de Goede76ae8532011-07-19 07:14:22 -0300150 .release = video_device_release_empty,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 .fops = &pwc_fops,
Hans de Goede9a7b2d12011-06-06 14:43:39 -0300152 .ioctl_ops = &pwc_ioctl_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153};
154
155/***************************************************************************/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156/* Private functions */
157
Mauro Carvalho Chehab0dc6eb92012-10-27 14:26:35 -0300158static struct pwc_frame_buf *pwc_get_next_fill_buf(struct pwc_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159{
Hans de Goede885fe182011-06-06 15:33:44 -0300160 unsigned long flags = 0;
161 struct pwc_frame_buf *buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Hans de Goede885fe182011-06-06 15:33:44 -0300163 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
164 if (list_empty(&pdev->queued_bufs))
165 goto leave;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Hans de Goede885fe182011-06-06 15:33:44 -0300167 buf = list_entry(pdev->queued_bufs.next, struct pwc_frame_buf, list);
168 list_del(&buf->list);
169leave:
170 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
171 return buf;
Luc Saillard2b455db2006-04-24 10:29:46 -0300172}
173
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -0300174static void pwc_snapshot_button(struct pwc_device *pdev, int down)
175{
176 if (down) {
177 PWC_TRACE("Snapshot button pressed.\n");
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -0300178 } else {
179 PWC_TRACE("Snapshot button released.\n");
180 }
181
182#ifdef CONFIG_USB_PWC_INPUT_EVDEV
183 if (pdev->button_dev) {
Lennart Poetteringbcd3e4b2009-06-11 11:19:33 -0300184 input_report_key(pdev->button_dev, KEY_CAMERA, down);
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -0300185 input_sync(pdev->button_dev);
186 }
187#endif
188}
189
Hans de Goede885fe182011-06-06 15:33:44 -0300190static void pwc_frame_complete(struct pwc_device *pdev)
Luc Saillard2b455db2006-04-24 10:29:46 -0300191{
Hans de Goede885fe182011-06-06 15:33:44 -0300192 struct pwc_frame_buf *fbuf = pdev->fill_buf;
Luc Saillard2b455db2006-04-24 10:29:46 -0300193
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;
Luc Saillard2b455db2006-04-24 10:29:46 -0300204 }
205 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -0300206 pwc_snapshot_button(pdev, ptr[0] & 0x01);
Luc Saillard2b455db2006-04-24 10:29:46 -0300207 }
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++;
Hans de Goede885fe182011-06-06 15:33:44 -0300226 } else if (pdev->type == 740 || pdev->type == 720) {
Luc Saillard2b455db2006-04-24 10:29:46 -0300227 unsigned char *ptr = (unsigned char *)fbuf->data;
228 if ((ptr[0] ^ pdev->vmirror) & 0x01) {
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -0300229 pwc_snapshot_button(pdev, ptr[0] & 0x01);
Luc Saillard2b455db2006-04-24 10:29:46 -0300230 }
231 pdev->vmirror = ptr[0] & 0x03;
232 }
233
Hans de Goede885fe182011-06-06 15:33:44 -0300234 /* In case we were instructed to drop the frame, do so silently. */
235 if (pdev->drop_frames > 0) {
Luc Saillard2b455db2006-04-24 10:29:46 -0300236 pdev->drop_frames--;
Hans de Goede885fe182011-06-06 15:33:44 -0300237 } else {
Luc Saillard2b455db2006-04-24 10:29:46 -0300238 /* 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);
Hans de Goede885fe182011-06-06 15:33:44 -0300242 } 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;
Luc Saillard2b455db2006-04-24 10:29:46 -0300248 }
249 } /* !drop_frames */
250 pdev->vframe_count++;
Luc Saillard2b455db2006-04-24 10:29:46 -0300251}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
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 */
David Howells7d12e782006-10-05 14:55:46 +0100256static void pwc_isoc_handler(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257{
Hans de Goede885fe182011-06-06 15:33:44 -0300258 struct pwc_device *pdev = (struct pwc_device *)urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 int i, fst, flen;
Hans de Goede885fe182011-06-06 15:33:44 -0300260 unsigned char *iso_buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
Hans de Goede885fe182011-06-06 15:33:44 -0300262 if (urb->status == -ENOENT || urb->status == -ECONNRESET ||
263 urb->status == -ESHUTDOWN) {
Luc Saillard2b455db2006-04-24 10:29:46 -0300264 PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 return;
266 }
Hans de Goede885fe182011-06-06 15:33:44 -0300267
268 if (pdev->fill_buf == NULL)
269 pdev->fill_buf = pwc_get_next_fill_buf(pdev);
270
271 if (urb->status != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 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;
Pete Zaitcev38e2bfc2006-09-18 22:49:02 -0700281 case -ETIME: errmsg = "Device does not respond"; break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 }
Hans de Goede885fe182011-06-06 15:33:44 -0300283 PWC_ERROR("pwc_isoc_handler() called with status %d [%s].\n",
284 urb->status, errmsg);
285 /* Give up after a number of contiguous errors */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
287 {
Hans de Goede885fe182011-06-06 15:33:44 -0300288 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 }
Hans de Goede885fe182011-06-06 15:33:44 -0300295 pdev->vsync = 0; /* Drop the current frame */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 goto handler_end;
297 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
299 /* Reset ISOC error counter. We did get here, after all. */
300 pdev->visoc_errors = 0;
301
302 /* vsync: 0 = don't copy data
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300303 1 = sync-hunt
304 2 = synched
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 */
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;
Hans de Goede885fe182011-06-06 15:33:44 -0300311 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Hans de Goede885fe182011-06-06 15:33:44 -0300318 if (pdev->vsync == 1) {
Sakari Ailus8e6057b2012-09-15 15:14:42 -0300319 v4l2_get_timestamp(
320 &fbuf->vb.v4l2_buf.timestamp);
Hans de Goede885fe182011-06-06 15:33:44 -0300321 pdev->vsync = 2;
Luc Saillard2b455db2006-04-24 10:29:46 -0300322 }
323
Hans de Goede885fe182011-06-06 15:33:44 -0300324 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 }
Hans de Goede885fe182011-06-06 15:33:44 -0300335 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 }
348
349handler_end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 i = usb_submit_urb(urb, GFP_ATOMIC);
351 if (i != 0)
Luc Saillard2b455db2006-04-24 10:29:46 -0300352 PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353}
354
Hans de Goedeceede9f2012-05-09 04:43:12 -0300355/* Both v4l2_lock and vb_queue_lock should be locked when calling this */
Hans de Goede885fe182011-06-06 15:33:44 -0300356static int pwc_isoc_init(struct pwc_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357{
358 struct usb_device *udev;
359 struct urb *urb;
360 int i, j, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 struct usb_interface *intf;
362 struct usb_host_interface *idesc = NULL;
Hans de Goede5bbe18d2012-01-04 18:48:05 -0300363 int compression = 0; /* 0..3 = uncompressed..high */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 pdev->vsync = 0;
Hans de Goede6eba9352011-06-26 06:49:59 -0300366 pdev->vlast_packet_size = 0;
Hans de Goede885fe182011-06-06 15:33:44 -0300367 pdev->fill_buf = NULL;
368 pdev->vframe_count = 0;
Hans de Goede6eba9352011-06-26 06:49:59 -0300369 pdev->visoc_errors = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 udev = pdev->udev;
371
Hans de Goede5bbe18d2012-01-04 18:48:05 -0300372retry:
373 /* We first try with low compression and then retry with a higher
374 compression setting if there is not enough bandwidth. */
Hans de Goede938d5b92012-01-10 13:14:46 -0300375 ret = pwc_set_video_mode(pdev, pdev->width, pdev->height, pdev->pixfmt,
376 pdev->vframes, &compression, 1);
Hans de Goede5bbe18d2012-01-04 18:48:05 -0300377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 /* Get the current alternate interface, adjust packet size */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 intf = usb_ifnum_to_if(udev, 0);
380 if (intf)
381 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 if (!idesc)
Hans de Goedec2464122011-06-06 15:25:18 -0300383 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385 /* Search video endpoint */
386 pdev->vmax_packet_size = -1;
Luc Saillard2b455db2006-04-24 10:29:46 -0300387 for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 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 }
Luc Saillard2b455db2006-04-24 10:29:46 -0300392 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300393
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
Luc Saillard2b455db2006-04-24 10:29:46 -0300395 PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
Steven Cole093cf722005-05-03 19:07:24 -0600396 return -ENFILE; /* Odd error, that should be noticeable */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 }
398
399 /* Set alternate interface */
Luc Saillard2b455db2006-04-24 10:29:46 -0300400 PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
Hans de Goede5bbe18d2012-01-04 18:48:05 -0300402 if (ret == -ENOSPC && compression < 3) {
403 compression++;
404 goto retry;
405 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 if (ret < 0)
407 return ret;
408
Hans de Goede04613c52011-06-26 13:57:15 -0300409 /* Allocate and init Isochronuous urbs */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 for (i = 0; i < MAX_ISO_BUFS; i++) {
411 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
412 if (urb == NULL) {
Luc Saillard2b455db2006-04-24 10:29:46 -0300413 PWC_ERROR("Failed to allocate urb %d\n", i);
Hans de Goede6eba9352011-06-26 06:49:59 -0300414 pwc_isoc_cleanup(pdev);
415 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 }
Hans de Goede04613c52011-06-26 13:57:15 -0300417 pdev->urbs[i] = urb;
Luc Saillard2b455db2006-04-24 10:29:46 -0300418 PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
420 urb->interval = 1; // devik
421 urb->dev = udev;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300422 urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
Hans de Goede04613c52011-06-26 13:57:15 -0300423 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);
Hans de Goede04613c52011-06-26 13:57:15 -0300430 pwc_isoc_cleanup(pdev);
431 return -ENOMEM;
432 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300433 urb->transfer_buffer_length = ISO_BUFFER_SIZE;
434 urb->complete = pwc_isoc_handler;
435 urb->context = pdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 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++) {
Hans de Goede04613c52011-06-26 13:57:15 -0300446 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
Hans de Goede5bbe18d2012-01-04 18:48:05 -0300447 if (ret == -ENOSPC && compression < 3) {
448 compression++;
Hans de Goede5bbe18d2012-01-04 18:48:05 -0300449 pwc_isoc_cleanup(pdev);
450 goto retry;
451 }
Hans de Goede622d9f52010-11-16 12:32:09 -0300452 if (ret) {
Luc Saillard2b455db2006-04-24 10:29:46 -0300453 PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
Hans de Goede622d9f52010-11-16 12:32:09 -0300454 pwc_isoc_cleanup(pdev);
455 return ret;
456 }
Hans de Goede04613c52011-06-26 13:57:15 -0300457 PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->urbs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 }
459
460 /* All is done... */
Luc Saillard2b455db2006-04-24 10:29:46 -0300461 PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 return 0;
463}
464
Oliver Neukum0b67f5c2007-09-26 10:19:01 -0300465static void pwc_iso_stop(struct pwc_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{
467 int i;
468
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 /* Unlinking ISOC buffers one by one */
470 for (i = 0; i < MAX_ISO_BUFS; i++) {
Hans de Goede04613c52011-06-26 13:57:15 -0300471 if (pdev->urbs[i]) {
472 PWC_DEBUG_MEMORY("Unlinking URB %p\n", pdev->urbs[i]);
473 usb_kill_urb(pdev->urbs[i]);
Oliver Neukum0b67f5c2007-09-26 10:19:01 -0300474 }
475 }
476}
477
478static 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++) {
Hans de Goede04613c52011-06-26 13:57:15 -0300484 if (pdev->urbs[i]) {
Luc Saillard2b455db2006-04-24 10:29:46 -0300485 PWC_DEBUG_MEMORY("Freeing URB\n");
Hans de Goede04613c52011-06-26 13:57:15 -0300486 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 }
495 }
Oliver Neukum0b67f5c2007-09-26 10:19:01 -0300496}
497
Hans de Goedeceede9f2012-05-09 04:43:12 -0300498/* Both v4l2_lock and vb_queue_lock should be locked when calling this */
Hans de Goede885fe182011-06-06 15:33:44 -0300499static void pwc_isoc_cleanup(struct pwc_device *pdev)
Oliver Neukum0b67f5c2007-09-26 10:19:01 -0300500{
501 PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
Hans de Goedec2464122011-06-06 15:25:18 -0300502
Oliver Neukum0b67f5c2007-09-26 10:19:01 -0300503 pwc_iso_stop(pdev);
504 pwc_iso_free(pdev);
Hans de Goedeb824bb42011-06-25 17:39:19 -0300505 usb_set_interface(pdev->udev, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Luc Saillard2b455db2006-04-24 10:29:46 -0300507 PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508}
509
Hans de Goedeceede9f2012-05-09 04:43:12 -0300510/* Must be called with vb_queue_lock hold */
Hans de Goede885fe182011-06-06 15:33:44 -0300511static void pwc_cleanup_queued_bufs(struct pwc_device *pdev)
512{
Hans de Goedec20d78c2011-10-09 09:16:46 -0300513 unsigned long flags = 0;
514
515 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
Hans de Goede885fe182011-06-06 15:33:44 -0300516 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 }
Hans de Goedec20d78c2011-10-09 09:16:46 -0300524 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
Hans de Goede885fe182011-06-06 15:33:44 -0300525}
526
Trent Piepho05ad3902007-01-30 23:26:01 -0300527#ifdef CONFIG_USB_PWC_DEBUG
Luc Saillard2b455db2006-04-24 10:29:46 -0300528static 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:
Trent Piepho657de3c2006-06-20 00:30:57 -0300552 return "unknown type of sensor";
Luc Saillard2b455db2006-04-24 10:29:46 -0300553 }
554}
555#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
557/***************************************************************************/
558/* Video4Linux functions */
559
Hans de Goede76ae8532011-07-19 07:14:22 -0300560static void pwc_video_release(struct v4l2_device *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561{
Hans de Goede76ae8532011-07-19 07:14:22 -0300562 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
Dmitry Torokhov89dec012009-08-14 02:22:52 -0300563
Hans de Goede6c9cac82011-06-26 12:52:01 -0300564 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
Hans de Goedeceede9f2012-05-09 04:43:12 -0300565 v4l2_device_unregister(&pdev->v4l2_dev);
Hans de Goede24be6892012-01-10 17:02:04 -0300566 kfree(pdev->ctrl_buf);
Dmitry Torokhov89dec012009-08-14 02:22:52 -0300567 kfree(pdev);
Oliver Neukum85237f22007-08-21 07:10:42 +0200568}
569
Hans de Goede885fe182011-06-06 15:33:44 -0300570/***************************************************************************/
571/* Videobuf2 operations */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
Guennadi Liakhovetskifc714e702011-08-24 10:30:21 -0300573static 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[])
Hans de Goede885fe182011-06-06 15:33:44 -0300576{
577 struct pwc_device *pdev = vb2_get_drv_priv(vq);
Hans de Goede795e6eb2012-01-04 16:58:44 -0300578 int size;
Luc Saillard2b455db2006-04-24 10:29:46 -0300579
Hans de Goede885fe182011-06-06 15:33:44 -0300580 if (*nbuffers < MIN_FRAMES)
581 *nbuffers = MIN_FRAMES;
582 else if (*nbuffers > MAX_FRAMES)
583 *nbuffers = MAX_FRAMES;
584
585 *nplanes = 1;
586
Hans de Goede795e6eb2012-01-04 16:58:44 -0300587 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);
Hans de Goede885fe182011-06-06 15:33:44 -0300590
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 return 0;
592}
593
Hans de Goede885fe182011-06-06 15:33:44 -0300594static 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
606static 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 */
Hans de Goedeb824bb42011-06-25 17:39:19 -0300611 if (!pdev->udev)
612 return -ENODEV;
Hans de Goede885fe182011-06-06 15:33:44 -0300613
614 return 0;
615}
616
617static int 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 /*
623 * Application has called dqbuf and is getting back a buffer we've
624 * filled, take the pwc data we've stored in buf->data and decompress
625 * it into a usable format, storing the result in the vb2_buffer
626 */
627 return pwc_decompress(pdev, buf);
628}
629
630static void buffer_cleanup(struct vb2_buffer *vb)
631{
632 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
633
634 vfree(buf->data);
635}
636
637static void buffer_queue(struct vb2_buffer *vb)
638{
639 struct pwc_device *pdev = vb2_get_drv_priv(vb->vb2_queue);
640 struct pwc_frame_buf *buf = container_of(vb, struct pwc_frame_buf, vb);
641 unsigned long flags = 0;
642
Hans de Goedec20d78c2011-10-09 09:16:46 -0300643 /* Check the device has not disconnected between prep and queuing */
Hans de Goedeceede9f2012-05-09 04:43:12 -0300644 if (!pdev->udev) {
Hans de Goedec20d78c2011-10-09 09:16:46 -0300645 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
Hans de Goedeceede9f2012-05-09 04:43:12 -0300646 return;
647 }
648
649 spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
650 list_add_tail(&buf->list, &pdev->queued_bufs);
Hans de Goede885fe182011-06-06 15:33:44 -0300651 spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
652}
653
Marek Szyprowskibd323e22011-08-29 08:51:49 -0300654static int start_streaming(struct vb2_queue *vq, unsigned int count)
Hans de Goede885fe182011-06-06 15:33:44 -0300655{
656 struct pwc_device *pdev = vb2_get_drv_priv(vq);
Hans de Goedec20d78c2011-10-09 09:16:46 -0300657 int r;
Hans de Goede885fe182011-06-06 15:33:44 -0300658
Hans de Goedeceede9f2012-05-09 04:43:12 -0300659 if (!pdev->udev)
660 return -ENODEV;
Hans de Goedeb824bb42011-06-25 17:39:19 -0300661
Hans Verkuil2e43dec2012-07-02 05:51:58 -0300662 if (mutex_lock_interruptible(&pdev->v4l2_lock))
663 return -ERESTARTSYS;
Hans de Goede6eba9352011-06-26 06:49:59 -0300664 /* Turn on camera and set LEDS on */
665 pwc_camera_power(pdev, 1);
Hans de Goedec24e1372012-01-10 17:51:12 -0300666 pwc_set_leds(pdev, leds[0], leds[1]);
Hans de Goede6eba9352011-06-26 06:49:59 -0300667
Hans de Goedec20d78c2011-10-09 09:16:46 -0300668 r = pwc_isoc_init(pdev);
Hans de Goede5bbe18d2012-01-04 18:48:05 -0300669 if (r) {
670 /* If we failed turn camera and LEDS back off */
671 pwc_set_leds(pdev, 0, 0);
672 pwc_camera_power(pdev, 0);
673 /* And cleanup any queued bufs!! */
674 pwc_cleanup_queued_bufs(pdev);
675 }
Hans Verkuil2e43dec2012-07-02 05:51:58 -0300676 mutex_unlock(&pdev->v4l2_lock);
Hans de Goedeceede9f2012-05-09 04:43:12 -0300677
Hans de Goedec20d78c2011-10-09 09:16:46 -0300678 return r;
Hans de Goede885fe182011-06-06 15:33:44 -0300679}
680
681static int stop_streaming(struct vb2_queue *vq)
682{
683 struct pwc_device *pdev = vb2_get_drv_priv(vq);
684
Hans Verkuil2e43dec2012-07-02 05:51:58 -0300685 if (mutex_lock_interruptible(&pdev->v4l2_lock))
686 return -ERESTARTSYS;
Hans de Goede6eba9352011-06-26 06:49:59 -0300687 if (pdev->udev) {
688 pwc_set_leds(pdev, 0, 0);
689 pwc_camera_power(pdev, 0);
Hans de Goedeb824bb42011-06-25 17:39:19 -0300690 pwc_isoc_cleanup(pdev);
Hans de Goede6eba9352011-06-26 06:49:59 -0300691 }
Hans de Goedec20d78c2011-10-09 09:16:46 -0300692
Hans de Goede885fe182011-06-06 15:33:44 -0300693 pwc_cleanup_queued_bufs(pdev);
Hans Verkuil2e43dec2012-07-02 05:51:58 -0300694 mutex_unlock(&pdev->v4l2_lock);
Hans de Goede885fe182011-06-06 15:33:44 -0300695
696 return 0;
697}
698
Hans de Goede885fe182011-06-06 15:33:44 -0300699static struct vb2_ops pwc_vb_queue_ops = {
700 .queue_setup = queue_setup,
701 .buf_init = buffer_init,
702 .buf_prepare = buffer_prepare,
703 .buf_finish = buffer_finish,
704 .buf_cleanup = buffer_cleanup,
705 .buf_queue = buffer_queue,
706 .start_streaming = start_streaming,
707 .stop_streaming = stop_streaming,
Hans Verkuil2e43dec2012-07-02 05:51:58 -0300708 .wait_prepare = vb2_ops_wait_prepare,
709 .wait_finish = vb2_ops_wait_finish,
Hans de Goede885fe182011-06-06 15:33:44 -0300710};
711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712/***************************************************************************/
713/* USB functions */
714
715/* This function gets called when a new device is plugged in or the usb core
716 * is loaded.
717 */
718
719static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id)
720{
721 struct usb_device *udev = interface_to_usbdev(intf);
722 struct pwc_device *pdev = NULL;
723 int vendor_id, product_id, type_id;
Hans de Goedea081c342012-01-10 17:47:25 -0300724 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 int features = 0;
Hans de Goede5bbe18d2012-01-04 18:48:05 -0300726 int compression = 0;
Hans de Goede3b4d0ec2011-06-26 03:51:19 -0300727 int my_power_save = power_save;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 char serial_number[30], *name;
729
Luc Saillard2b455db2006-04-24 10:29:46 -0300730 vendor_id = le16_to_cpu(udev->descriptor.idVendor);
731 product_id = le16_to_cpu(udev->descriptor.idProduct);
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 /* Check if we can handle this device */
Luc Saillard2b455db2006-04-24 10:29:46 -0300734 PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
735 vendor_id, product_id,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 intf->altsetting->desc.bInterfaceNumber);
737
738 /* the interfaces are probed one by one. We are only interested in the
739 video interface (0) now.
740 Interface 1 is the Audio Control, and interface 2 Audio itself.
741 */
742 if (intf->altsetting->desc.bInterfaceNumber > 0)
743 return -ENODEV;
744
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 if (vendor_id == 0x0471) {
746 switch (product_id) {
747 case 0x0302:
Luc Saillard2b455db2006-04-24 10:29:46 -0300748 PWC_INFO("Philips PCA645VC USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 name = "Philips 645 webcam";
750 type_id = 645;
751 break;
752 case 0x0303:
Luc Saillard2b455db2006-04-24 10:29:46 -0300753 PWC_INFO("Philips PCA646VC USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 name = "Philips 646 webcam";
755 type_id = 646;
756 break;
757 case 0x0304:
Luc Saillard2b455db2006-04-24 10:29:46 -0300758 PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 name = "Askey VC010 webcam";
760 type_id = 646;
761 break;
762 case 0x0307:
Luc Saillard2b455db2006-04-24 10:29:46 -0300763 PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 name = "Philips 675 webcam";
765 type_id = 675;
766 break;
767 case 0x0308:
Luc Saillard2b455db2006-04-24 10:29:46 -0300768 PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 name = "Philips 680 webcam";
770 type_id = 680;
771 break;
772 case 0x030C:
Luc Saillard2b455db2006-04-24 10:29:46 -0300773 PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 name = "Philips 690 webcam";
775 type_id = 690;
776 break;
777 case 0x0310:
Luc Saillard2b455db2006-04-24 10:29:46 -0300778 PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 name = "Philips 730 webcam";
780 type_id = 730;
781 break;
782 case 0x0311:
Luc Saillard2b455db2006-04-24 10:29:46 -0300783 PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 name = "Philips 740 webcam";
785 type_id = 740;
786 break;
787 case 0x0312:
Luc Saillard2b455db2006-04-24 10:29:46 -0300788 PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 name = "Philips 750 webcam";
790 type_id = 750;
791 break;
792 case 0x0313:
Luc Saillard2b455db2006-04-24 10:29:46 -0300793 PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 name = "Philips 720K/40 webcam";
795 type_id = 720;
796 break;
Luc Saillard2b455db2006-04-24 10:29:46 -0300797 case 0x0329:
798 PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
799 name = "Philips SPC 900NC webcam";
Luc Saillard9ee6d782007-04-22 23:54:36 -0300800 type_id = 740;
Luc Saillard2b455db2006-04-24 10:29:46 -0300801 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 default:
803 return -ENODEV;
804 break;
805 }
806 }
807 else if (vendor_id == 0x069A) {
808 switch(product_id) {
809 case 0x0001:
Luc Saillard2b455db2006-04-24 10:29:46 -0300810 PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 name = "Askey VC010 webcam";
812 type_id = 645;
813 break;
814 default:
815 return -ENODEV;
816 break;
817 }
818 }
819 else if (vendor_id == 0x046d) {
820 switch(product_id) {
821 case 0x08b0:
Luc Saillard2b455db2006-04-24 10:29:46 -0300822 PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 name = "Logitech QuickCam Pro 3000";
824 type_id = 740; /* CCD sensor */
825 break;
826 case 0x08b1:
Luc Saillard2b455db2006-04-24 10:29:46 -0300827 PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 name = "Logitech QuickCam Notebook Pro";
829 type_id = 740; /* CCD sensor */
830 break;
831 case 0x08b2:
Luc Saillard2b455db2006-04-24 10:29:46 -0300832 PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 name = "Logitech QuickCam Pro 4000";
834 type_id = 740; /* CCD sensor */
Hans de Goede51886df2011-07-03 15:52:54 -0300835 if (my_power_save == -1)
836 my_power_save = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 break;
838 case 0x08b3:
Luc Saillard2b455db2006-04-24 10:29:46 -0300839 PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 name = "Logitech QuickCam Zoom";
841 type_id = 740; /* CCD sensor */
842 break;
843 case 0x08B4:
Luc Saillard2b455db2006-04-24 10:29:46 -0300844 PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 name = "Logitech QuickCam Zoom";
846 type_id = 740; /* CCD sensor */
Hans de Goede3b4d0ec2011-06-26 03:51:19 -0300847 if (my_power_save == -1)
848 my_power_save = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 break;
850 case 0x08b5:
Luc Saillard2b455db2006-04-24 10:29:46 -0300851 PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 name = "Logitech QuickCam Orbit";
853 type_id = 740; /* CCD sensor */
Hans de Goede51886df2011-07-03 15:52:54 -0300854 if (my_power_save == -1)
855 my_power_save = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 features |= FEATURE_MOTOR_PANTILT;
857 break;
858 case 0x08b6:
Jean Tourrilhesa63e1572007-03-21 16:29:16 -0300859 PWC_INFO("Logitech/Cisco VT Camera webcam detected.\n");
860 name = "Cisco VT Camera";
861 type_id = 740; /* CCD sensor */
862 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 case 0x08b7:
Mauro Carvalho Chehab6b1ce3c2007-03-21 16:35:28 -0300864 PWC_INFO("Logitech ViewPort AV 100 webcam detected.\n");
865 name = "Logitech ViewPort AV 100";
866 type_id = 740; /* CCD sensor */
867 break;
868 case 0x08b8: /* Where this released? */
Luc Saillard2b455db2006-04-24 10:29:46 -0300869 PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 name = "Logitech QuickCam (res.)";
871 type_id = 730; /* Assuming CMOS */
872 break;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300873 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 return -ENODEV;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300875 break;
876 }
877 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 else if (vendor_id == 0x055d) {
879 /* I don't know the difference between the C10 and the C30;
880 I suppose the difference is the sensor, but both cameras
881 work equally well with a type_id of 675
882 */
883 switch(product_id) {
884 case 0x9000:
Luc Saillard2b455db2006-04-24 10:29:46 -0300885 PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 name = "Samsung MPC-C10";
887 type_id = 675;
888 break;
889 case 0x9001:
Luc Saillard2b455db2006-04-24 10:29:46 -0300890 PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 name = "Samsung MPC-C30";
892 type_id = 675;
893 break;
Luc Saillard2b455db2006-04-24 10:29:46 -0300894 case 0x9002:
895 PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
896 name = "Samsung MPC-C30";
897 type_id = 740;
898 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 default:
900 return -ENODEV;
901 break;
902 }
903 }
904 else if (vendor_id == 0x041e) {
905 switch(product_id) {
906 case 0x400c:
Luc Saillard2b455db2006-04-24 10:29:46 -0300907 PWC_INFO("Creative Labs Webcam 5 detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 name = "Creative Labs Webcam 5";
909 type_id = 730;
Hans de Goede51886df2011-07-03 15:52:54 -0300910 if (my_power_save == -1)
911 my_power_save = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 break;
913 case 0x4011:
Luc Saillard2b455db2006-04-24 10:29:46 -0300914 PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 name = "Creative Labs Webcam Pro Ex";
916 type_id = 740;
917 break;
918 default:
919 return -ENODEV;
920 break;
921 }
922 }
923 else if (vendor_id == 0x04cc) {
924 switch(product_id) {
925 case 0x8116:
Luc Saillard2b455db2006-04-24 10:29:46 -0300926 PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 name = "Sotec Afina Eye";
928 type_id = 730;
929 break;
930 default:
931 return -ENODEV;
932 break;
933 }
934 }
935 else if (vendor_id == 0x06be) {
936 switch(product_id) {
937 case 0x8116:
938 /* This is essentially the same cam as the Sotec Afina Eye */
Luc Saillard2b455db2006-04-24 10:29:46 -0300939 PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 name = "AME Co. Afina Eye";
941 type_id = 750;
942 break;
943 default:
944 return -ENODEV;
945 break;
946 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300947
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 }
949 else if (vendor_id == 0x0d81) {
950 switch(product_id) {
951 case 0x1900:
Luc Saillard2b455db2006-04-24 10:29:46 -0300952 PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 name = "Visionite VCS-UC300";
954 type_id = 740; /* CCD sensor */
955 break;
956 case 0x1910:
Luc Saillard2b455db2006-04-24 10:29:46 -0300957 PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 name = "Visionite VCS-UM100";
959 type_id = 730; /* CMOS sensor */
960 break;
961 default:
962 return -ENODEV;
963 break;
964 }
965 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300966 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 return -ENODEV; /* Not any of the know types; but the list keeps growing. */
968
Hans de Goede3b4d0ec2011-06-26 03:51:19 -0300969 if (my_power_save == -1)
970 my_power_save = 0;
971
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 memset(serial_number, 0, 30);
973 usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
Luc Saillard2b455db2006-04-24 10:29:46 -0300974 PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975
976 if (udev->descriptor.bNumConfigurations > 1)
Luc Saillard2b455db2006-04-24 10:29:46 -0300977 PWC_WARNING("Warning: more than 1 configuration available.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
979 /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
Eric Sesterhenn80b6ca42006-02-27 21:29:43 +0100980 pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 if (pdev == NULL) {
Luc Saillard2b455db2006-04-24 10:29:46 -0300982 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 return -ENOMEM;
984 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 pdev->type = type_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 pdev->features = features;
Hans de Goede3b4d0ec2011-06-26 03:51:19 -0300987 pwc_construct(pdev); /* set min/max sizes correct */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
Hans de Goedeceede9f2012-05-09 04:43:12 -0300989 mutex_init(&pdev->v4l2_lock);
990 mutex_init(&pdev->vb_queue_lock);
Hans de Goede885fe182011-06-06 15:33:44 -0300991 spin_lock_init(&pdev->queued_bufs_lock);
992 INIT_LIST_HEAD(&pdev->queued_bufs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
994 pdev->udev = udev;
Hans de Goede3b4d0ec2011-06-26 03:51:19 -0300995 pdev->power_save = my_power_save;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996
Hans de Goede885fe182011-06-06 15:33:44 -0300997 /* Init videobuf2 queue structure */
Hans de Goede885fe182011-06-06 15:33:44 -0300998 pdev->vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
999 pdev->vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1000 pdev->vb_queue.drv_priv = pdev;
1001 pdev->vb_queue.buf_struct_size = sizeof(struct pwc_frame_buf);
1002 pdev->vb_queue.ops = &pwc_vb_queue_ops;
1003 pdev->vb_queue.mem_ops = &vb2_vmalloc_memops;
Kamil Debski6aa69f92013-01-25 06:29:57 -03001004 pdev->vb_queue.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
Mauro Carvalho Chehabeda94712012-10-27 14:26:25 -03001005 rc = vb2_queue_init(&pdev->vb_queue);
1006 if (rc < 0) {
1007 PWC_ERROR("Oops, could not initialize vb2 queue.\n");
1008 goto err_free_mem;
1009 }
Hans de Goede885fe182011-06-06 15:33:44 -03001010
Hans de Goede9a7b2d12011-06-06 14:43:39 -03001011 /* Init video_device structure */
Ezequiel Garcia5c2edef2012-10-23 15:57:08 -03001012 pdev->vdev = pwc_template;
Hans de Goede9a7b2d12011-06-06 14:43:39 -03001013 strcpy(pdev->vdev.name, name);
Hans Verkuil2e43dec2012-07-02 05:51:58 -03001014 pdev->vdev.queue = &pdev->vb_queue;
1015 pdev->vdev.queue->lock = &pdev->vb_queue_lock;
Hans de Goede76ae8532011-07-19 07:14:22 -03001016 set_bit(V4L2_FL_USE_FH_PRIO, &pdev->vdev.flags);
Hans de Goede9a7b2d12011-06-06 14:43:39 -03001017 video_set_drvdata(&pdev->vdev, pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018
1019 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
Luc Saillard2b455db2006-04-24 10:29:46 -03001020 PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021
Hans de Goede24be6892012-01-10 17:02:04 -03001022 /* Allocate USB command buffers */
1023 pdev->ctrl_buf = kmalloc(sizeof(pdev->cmd_buf), GFP_KERNEL);
1024 if (!pdev->ctrl_buf) {
1025 PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
1026 rc = -ENOMEM;
1027 goto err_free_mem;
1028 }
1029
Hans de Goede6eba9352011-06-26 06:49:59 -03001030#ifdef CONFIG_USB_PWC_DEBUG
1031 /* Query sensor type */
1032 if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
1033 PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
1034 pdev->vdev.name,
1035 pwc_sensor_type_to_string(rc), rc);
1036 }
1037#endif
1038
Luc Saillard2b455db2006-04-24 10:29:46 -03001039 /* Set the leds off */
1040 pwc_set_leds(pdev, 0, 0);
Hans de Goede6eba9352011-06-26 06:49:59 -03001041
1042 /* Setup intial videomode */
Hans de Goeded167a852012-01-10 13:01:41 -03001043 rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT,
Hans de Goede938d5b92012-01-10 13:14:46 -03001044 V4L2_PIX_FMT_YUV420, 30, &compression, 1);
Hans de Goede6eba9352011-06-26 06:49:59 -03001045 if (rc)
1046 goto err_free_mem;
1047
Hans de Goede6c9cac82011-06-26 12:52:01 -03001048 /* Register controls (and read default values from camera */
1049 rc = pwc_init_controls(pdev);
1050 if (rc) {
1051 PWC_ERROR("Failed to register v4l2 controls (%d).\n", rc);
1052 goto err_free_mem;
1053 }
1054
Hans de Goede6eba9352011-06-26 06:49:59 -03001055 /* And powerdown the camera until streaming starts */
Luc Saillard2b455db2006-04-24 10:29:46 -03001056 pwc_camera_power(pdev, 0);
1057
Hans de Goede76ae8532011-07-19 07:14:22 -03001058 /* Register the v4l2_device structure */
1059 pdev->v4l2_dev.release = pwc_video_release;
1060 rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
1061 if (rc) {
1062 PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
1063 goto err_free_controls;
1064 }
1065
1066 pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
1067 pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
Hans de Goedeceede9f2012-05-09 04:43:12 -03001068 pdev->vdev.lock = &pdev->v4l2_lock;
1069
Hans de Goedea081c342012-01-10 17:47:25 -03001070 rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, -1);
Hans Verkuil479567c2010-09-12 17:05:11 -03001071 if (rc < 0) {
1072 PWC_ERROR("Failed to register as video device (%d).\n", rc);
Hans de Goede76ae8532011-07-19 07:14:22 -03001073 goto err_unregister_v4l2_dev;
Hans Verkuil479567c2010-09-12 17:05:11 -03001074 }
Hans de Goede9a7b2d12011-06-06 14:43:39 -03001075 PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
Hans Verkuil479567c2010-09-12 17:05:11 -03001076
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -03001077#ifdef CONFIG_USB_PWC_INPUT_EVDEV
1078 /* register webcam snapshot button input device */
1079 pdev->button_dev = input_allocate_device();
1080 if (!pdev->button_dev) {
1081 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
Dmitry Torokhov89dec012009-08-14 02:22:52 -03001082 rc = -ENOMEM;
Dmitry Torokhov89dec012009-08-14 02:22:52 -03001083 goto err_video_unreg;
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -03001084 }
1085
Dmitry Torokhov89dec012009-08-14 02:22:52 -03001086 usb_make_path(udev, pdev->button_phys, sizeof(pdev->button_phys));
1087 strlcat(pdev->button_phys, "/input0", sizeof(pdev->button_phys));
1088
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -03001089 pdev->button_dev->name = "PWC snapshot button";
Dmitry Torokhov89dec012009-08-14 02:22:52 -03001090 pdev->button_dev->phys = pdev->button_phys;
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -03001091 usb_to_input_id(pdev->udev, &pdev->button_dev->id);
1092 pdev->button_dev->dev.parent = &pdev->udev->dev;
1093 pdev->button_dev->evbit[0] = BIT_MASK(EV_KEY);
Lennart Poetteringbcd3e4b2009-06-11 11:19:33 -03001094 pdev->button_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -03001095
1096 rc = input_register_device(pdev->button_dev);
1097 if (rc) {
1098 input_free_device(pdev->button_dev);
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -03001099 pdev->button_dev = NULL;
Dmitry Torokhov89dec012009-08-14 02:22:52 -03001100 goto err_video_unreg;
Nam Phạm Thànhe32a7ecc2009-01-12 02:50:17 -03001101 }
1102#endif
1103
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 return 0;
Jeff Garzikc12e3be2006-10-13 07:17:32 -03001105
Dmitry Torokhov89dec012009-08-14 02:22:52 -03001106err_video_unreg:
Hans de Goede9a7b2d12011-06-06 14:43:39 -03001107 video_unregister_device(&pdev->vdev);
Hans de Goede76ae8532011-07-19 07:14:22 -03001108err_unregister_v4l2_dev:
1109 v4l2_device_unregister(&pdev->v4l2_dev);
Hans de Goede6c9cac82011-06-26 12:52:01 -03001110err_free_controls:
1111 v4l2_ctrl_handler_free(&pdev->ctrl_handler);
Dmitry Torokhov89dec012009-08-14 02:22:52 -03001112err_free_mem:
Hans de Goede24be6892012-01-10 17:02:04 -03001113 kfree(pdev->ctrl_buf);
Dmitry Torokhov89dec012009-08-14 02:22:52 -03001114 kfree(pdev);
Jeff Garzikc12e3be2006-10-13 07:17:32 -03001115 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116}
1117
Dmitry Torokhov89dec012009-08-14 02:22:52 -03001118/* The user yanked out the cable... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119static void usb_pwc_disconnect(struct usb_interface *intf)
1120{
Hans de Goede76ae8532011-07-19 07:14:22 -03001121 struct v4l2_device *v = usb_get_intfdata(intf);
1122 struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
Hans de Goedeceede9f2012-05-09 04:43:12 -03001124 mutex_lock(&pdev->vb_queue_lock);
Hans Verkuil2e43dec2012-07-02 05:51:58 -03001125 mutex_lock(&pdev->v4l2_lock);
Hans de Goede9a7b2d12011-06-06 14:43:39 -03001126 /* No need to keep the urbs around after disconnection */
Hans de Goedeceede9f2012-05-09 04:43:12 -03001127 if (pdev->vb_queue.streaming)
1128 pwc_isoc_cleanup(pdev);
Hans de Goedeb824bb42011-06-25 17:39:19 -03001129 pdev->udev = NULL;
Hans de Goedec20d78c2011-10-09 09:16:46 -03001130 pwc_cleanup_queued_bufs(pdev);
1131
Hans de Goedeceede9f2012-05-09 04:43:12 -03001132 v4l2_device_disconnect(&pdev->v4l2_dev);
Hans de Goede9a7b2d12011-06-06 14:43:39 -03001133 video_unregister_device(&pdev->vdev);
Hans de Goedeceede9f2012-05-09 04:43:12 -03001134 mutex_unlock(&pdev->v4l2_lock);
Ezequiel Garcia0ab61192012-07-15 03:00:33 -03001135 mutex_unlock(&pdev->vb_queue_lock);
Hans de Goede9a7b2d12011-06-06 14:43:39 -03001136
1137#ifdef CONFIG_USB_PWC_INPUT_EVDEV
1138 if (pdev->button_dev)
1139 input_unregister_device(pdev->button_dev);
1140#endif
Hans de Goede76ae8532011-07-19 07:14:22 -03001141
1142 v4l2_device_put(&pdev->v4l2_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143}
1144
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001146/*
1147 * Initialization code & module stuff
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 */
1149
Al Viro64a6f952007-10-14 19:35:30 +01001150static unsigned int leds_nargs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Trent Piepho05ad3902007-01-30 23:26:01 -03001152#ifdef CONFIG_USB_PWC_DEBUG
Luc Saillard2b455db2006-04-24 10:29:46 -03001153module_param_named(trace, pwc_trace, int, 0644);
1154#endif
Hans de Goede3b4d0ec2011-06-26 03:51:19 -03001155module_param(power_save, int, 0644);
Luc Saillard2b455db2006-04-24 10:29:46 -03001156module_param_array(leds, int, &leds_nargs, 0444);
Luc Saillard2b455db2006-04-24 10:29:46 -03001157
Andrea Odetti4315c412009-12-10 16:26:10 -03001158#ifdef CONFIG_USB_PWC_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159MODULE_PARM_DESC(trace, "For debugging purposes");
Andrea Odetti4315c412009-12-10 16:26:10 -03001160#endif
Hans de Goede3b4d0ec2011-06-26 03:51:19 -03001161MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
1164MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
1165MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
1166MODULE_LICENSE("GPL");
Luc Saillard2b455db2006-04-24 10:29:46 -03001167MODULE_ALIAS("pwcx");
1168MODULE_VERSION( PWC_VERSION );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
Hans de Goedeceede9f2012-05-09 04:43:12 -03001170module_usb_driver(pwc_driver);