e48a9c62 |
1 | /* |
2 | * Driver for Logitech Quickcam Messenger usb video camera |
3 | * Copyright (C) Jaya Kumar |
4 | * |
5 | * This work was sponsored by CIS(M) Sdn Bhd. |
6 | * History: |
7 | * 05/08/2006 - Jaya Kumar |
8 | * I wrote this based on the konicawc by Simon Evans. |
9 | * - |
10 | * Full credit for reverse engineering and creating an initial |
11 | * working linux driver for the VV6422 goes to the qce-ga project by |
12 | * Tuukka Toivonen, Jochen Hoenicke, Peter McConnell, |
13 | * Cristiano De Michele, Georg Acher, Jean-Frederic Clere as well as |
14 | * others. |
15 | * --- |
16 | * This program is free software; you can redistribute it and/or modify |
17 | * it under the terms of the GNU General Public License as published by |
18 | * the Free Software Foundation; either version 2 of the License, or |
19 | * (at your option) any later version. |
20 | * |
21 | * This program is distributed in the hope that it will be useful, |
22 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
23 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
24 | * GNU General Public License for more details. |
25 | * |
26 | * You should have received a copy of the GNU General Public License |
27 | * along with this program; if not, write to the Free Software |
28 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
29 | * |
30 | */ |
31 | |
32 | #include <linux/kernel.h> |
33 | #include <linux/module.h> |
34 | #include <linux/init.h> |
35 | #include <linux/input.h> |
20c5426f |
36 | #include <linux/usb/input.h> |
e48a9c62 |
37 | |
38 | #include "usbvideo.h" |
39 | #include "quickcam_messenger.h" |
40 | |
41 | /* |
42 | * Version Information |
43 | */ |
44 | |
45 | #ifdef CONFIG_USB_DEBUG |
46 | static int debug; |
47 | #define DEBUG(n, format, arg...) \ |
48 | if (n <= debug) { \ |
49 | printk(KERN_DEBUG __FILE__ ":%s(): " format "\n", __FUNCTION__ , ## arg); \ |
50 | } |
51 | #else |
52 | #define DEBUG(n, arg...) |
53 | static const int debug = 0; |
54 | #endif |
55 | |
56 | #define DRIVER_VERSION "v0.01" |
57 | #define DRIVER_DESC "Logitech Quickcam Messenger USB" |
58 | |
59 | #define USB_LOGITECH_VENDOR_ID 0x046D |
60 | #define USB_QCM_PRODUCT_ID 0x08F0 |
61 | |
62 | #define MAX_CAMERAS 1 |
63 | |
64 | #define MAX_COLOUR 32768 |
65 | #define MAX_HUE 32768 |
66 | #define MAX_BRIGHTNESS 32768 |
67 | #define MAX_CONTRAST 32768 |
68 | #define MAX_WHITENESS 32768 |
69 | |
70 | static int size = SIZE_320X240; |
71 | static int colour = MAX_COLOUR; |
72 | static int hue = MAX_HUE; |
73 | static int brightness = MAX_BRIGHTNESS; |
74 | static int contrast = MAX_CONTRAST; |
75 | static int whiteness = MAX_WHITENESS; |
76 | |
77 | static struct usbvideo *cams; |
78 | |
79 | static struct usb_device_id qcm_table [] = { |
80 | { USB_DEVICE(USB_LOGITECH_VENDOR_ID, USB_QCM_PRODUCT_ID) }, |
81 | { } |
82 | }; |
83 | MODULE_DEVICE_TABLE(usb, qcm_table); |
84 | |
85 | #ifdef CONFIG_INPUT |
86 | static void qcm_register_input(struct qcm *cam, struct usb_device *dev) |
87 | { |
88 | struct input_dev *input_dev; |
89 | |
90 | usb_make_path(dev, cam->input_physname, sizeof(cam->input_physname)); |
91 | strncat(cam->input_physname, "/input0", sizeof(cam->input_physname)); |
92 | |
93 | cam->input = input_dev = input_allocate_device(); |
94 | if (!input_dev) { |
95 | warn("insufficient mem for cam input device"); |
96 | return; |
97 | } |
98 | |
99 | input_dev->name = "QCM button"; |
100 | input_dev->phys = cam->input_physname; |
101 | usb_to_input_id(dev, &input_dev->id); |
102 | input_dev->cdev.dev = &dev->dev; |
103 | |
104 | input_dev->evbit[0] = BIT(EV_KEY); |
105 | input_dev->keybit[LONG(BTN_0)] = BIT(BTN_0); |
106 | |
107 | input_dev->private = cam; |
108 | |
109 | input_register_device(cam->input); |
110 | } |
111 | |
112 | static void qcm_unregister_input(struct qcm *cam) |
113 | { |
114 | if (cam->input) { |
115 | input_unregister_device(cam->input); |
116 | cam->input = NULL; |
117 | } |
118 | } |
119 | |
120 | static void qcm_report_buttonstat(struct qcm *cam) |
121 | { |
122 | if (cam->input) { |
123 | input_report_key(cam->input, BTN_0, cam->button_sts); |
124 | input_sync(cam->input); |
125 | } |
126 | } |
127 | |
7d12e780 |
128 | static void qcm_int_irq(struct urb *urb) |
e48a9c62 |
129 | { |
130 | int ret; |
131 | struct uvd *uvd = urb->context; |
132 | struct qcm *cam; |
133 | |
134 | if (!CAMERA_IS_OPERATIONAL(uvd)) |
135 | return; |
136 | |
137 | if (!uvd->streaming) |
138 | return; |
139 | |
140 | uvd->stats.urb_count++; |
141 | |
142 | if (urb->status < 0) |
143 | uvd->stats.iso_err_count++; |
144 | else { |
145 | if (urb->actual_length > 0 ) { |
146 | cam = (struct qcm *) uvd->user_data; |
147 | if (cam->button_sts_buf == 0x88) |
148 | cam->button_sts = 0x0; |
149 | else if (cam->button_sts_buf == 0x80) |
150 | cam->button_sts = 0x1; |
151 | qcm_report_buttonstat(cam); |
152 | } |
153 | } |
154 | |
155 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
156 | if (ret < 0) |
157 | err("usb_submit_urb error (%d)", ret); |
158 | } |
159 | |
160 | static int qcm_setup_input_int(struct qcm *cam, struct uvd *uvd) |
161 | { |
162 | int errflag; |
163 | usb_fill_int_urb(cam->button_urb, uvd->dev, |
164 | usb_rcvintpipe(uvd->dev, uvd->video_endp + 1), |
165 | &cam->button_sts_buf, |
166 | 1, |
167 | qcm_int_irq, |
168 | uvd, 16); |
169 | |
170 | errflag = usb_submit_urb(cam->button_urb, GFP_KERNEL); |
171 | if (errflag) |
172 | err ("usb_submit_int ret %d", errflag); |
173 | return errflag; |
174 | } |
175 | |
176 | static void qcm_stop_int_data(struct qcm *cam) |
177 | { |
178 | usb_kill_urb(cam->button_urb); |
179 | } |
180 | |
181 | static int qcm_alloc_int_urb(struct qcm *cam) |
182 | { |
183 | cam->button_urb = usb_alloc_urb(0, GFP_KERNEL); |
184 | |
185 | if (!cam->button_urb) |
186 | return -ENOMEM; |
187 | |
188 | return 0; |
189 | } |
190 | |
191 | static void qcm_free_int(struct qcm *cam) |
192 | { |
193 | if (cam->button_urb) |
194 | usb_free_urb(cam->button_urb); |
195 | } |
196 | #endif /* CONFIG_INPUT */ |
197 | |
198 | static int qcm_stv_setb(struct usb_device *dev, u16 reg, u8 val) |
199 | { |
200 | int ret; |
201 | |
202 | /* we'll wait up to 3 slices but no more */ |
203 | ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), |
204 | 0x04, USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE, |
205 | reg, 0, &val, 1, 3*HZ); |
206 | return ret; |
207 | } |
208 | |
209 | static int qcm_stv_setw(struct usb_device *dev, u16 reg, u16 val) |
210 | { |
211 | int ret; |
212 | |
213 | /* we'll wait up to 3 slices but no more */ |
214 | ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), |
215 | 0x04, USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE, |
216 | reg, 0, &val, 2, 3*HZ); |
217 | return ret; |
218 | } |
219 | |
220 | static int qcm_stv_getw(struct usb_device *dev, unsigned short reg, |
221 | __le16 *val) |
222 | { |
223 | int ret; |
224 | |
225 | /* we'll wait up to 3 slices but no more */ |
226 | ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), |
227 | 0x04, USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE, |
228 | reg, 0, val, 2, 3*HZ); |
229 | return ret; |
230 | } |
231 | |
232 | static int qcm_camera_on(struct uvd *uvd) |
233 | { |
234 | int ret; |
235 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, STV_ISO_ENABLE, 0x01)); |
236 | return 0; |
237 | } |
238 | |
239 | static int qcm_camera_off(struct uvd *uvd) |
240 | { |
241 | int ret; |
242 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, STV_ISO_ENABLE, 0x00)); |
243 | return 0; |
244 | } |
245 | |
246 | static void qcm_hsv2rgb(u16 hue, u16 sat, u16 val, u16 *r, u16 *g, u16 *b) |
247 | { |
248 | unsigned int segment, valsat; |
249 | signed int h = (signed int) hue; |
250 | unsigned int s = (sat - 32768) * 2; /* rescale */ |
251 | unsigned int v = val; |
252 | unsigned int p; |
253 | |
254 | /* |
255 | the registers controling gain are 8 bit of which |
256 | we affect only the last 4 bits with our gain. |
257 | we know that if saturation is 0, (unsaturated) then |
258 | we're grayscale (center axis of the colour cone) so |
259 | we set rgb=value. we use a formula obtained from |
260 | wikipedia to map the cone to the RGB plane. it's |
261 | as follows for the human value case of h=0..360, |
262 | s=0..1, v=0..1 |
263 | h_i = h/60 % 6 , f = h/60 - h_i , p = v(1-s) |
264 | q = v(1 - f*s) , t = v(1 - (1-f)s) |
265 | h_i==0 => r=v , g=t, b=p |
266 | h_i==1 => r=q , g=v, b=p |
267 | h_i==2 => r=p , g=v, b=t |
268 | h_i==3 => r=p , g=q, b=v |
269 | h_i==4 => r=t , g=p, b=v |
270 | h_i==5 => r=v , g=p, b=q |
271 | the bottom side (the point) and the stuff just up |
272 | of that is black so we simplify those two cases. |
273 | */ |
274 | if (sat < 32768) { |
275 | /* anything less than this is unsaturated */ |
276 | *r = val; |
277 | *g = val; |
278 | *b = val; |
279 | return; |
280 | } |
281 | if (val <= (0xFFFF/8)) { |
282 | /* anything less than this is black */ |
283 | *r = 0; |
284 | *g = 0; |
285 | *b = 0; |
286 | return; |
287 | } |
288 | |
289 | /* the rest of this code is copying tukkat's |
290 | implementation of the hsv2rgb conversion as taken |
291 | from qc-usb-messenger code. the 10923 is 0xFFFF/6 |
292 | to divide the cone into 6 sectors. */ |
293 | |
294 | segment = (h + 10923) & 0xFFFF; |
295 | segment = segment*3 >> 16; /* 0..2: 0=R, 1=G, 2=B */ |
296 | hue -= segment * 21845; /* -10923..10923 */ |
297 | h = hue; |
298 | h *= 3; |
299 | valsat = v*s >> 16; /* 0..65534 */ |
300 | p = v - valsat; |
301 | if (h >= 0) { |
302 | unsigned int t = v - (valsat * (32769 - h) >> 15); |
303 | switch (segment) { |
304 | case 0: /* R-> */ |
305 | *r = v; |
306 | *g = t; |
307 | *b = p; |
308 | break; |
309 | case 1: /* G-> */ |
310 | *r = p; |
311 | *g = v; |
312 | *b = t; |
313 | break; |
314 | case 2: /* B-> */ |
315 | *r = t; |
316 | *g = p; |
317 | *b = v; |
318 | break; |
319 | } |
320 | } else { |
321 | unsigned int q = v - (valsat * (32769 + h) >> 15); |
322 | switch (segment) { |
323 | case 0: /* ->R */ |
324 | *r = v; |
325 | *g = p; |
326 | *b = q; |
327 | break; |
328 | case 1: /* ->G */ |
329 | *r = q; |
330 | *g = v; |
331 | *b = p; |
332 | break; |
333 | case 2: /* ->B */ |
334 | *r = p; |
335 | *g = q; |
336 | *b = v; |
337 | break; |
338 | } |
339 | } |
340 | } |
341 | |
342 | static int qcm_sensor_set_gains(struct uvd *uvd, u16 hue, |
343 | u16 saturation, u16 value) |
344 | { |
345 | int ret; |
d6144028 |
346 | u16 r=0,g=0,b=0; |
e48a9c62 |
347 | |
348 | /* this code is based on qc-usb-messenger */ |
349 | qcm_hsv2rgb(hue, saturation, value, &r, &g, &b); |
350 | |
351 | r >>= 12; |
352 | g >>= 12; |
353 | b >>= 12; |
354 | |
355 | /* min val is 8 */ |
356 | r = max((u16) 8, r); |
357 | g = max((u16) 8, g); |
358 | b = max((u16) 8, b); |
359 | |
360 | r |= 0x30; |
361 | g |= 0x30; |
362 | b |= 0x30; |
363 | |
364 | /* set the r,g,b gain registers */ |
365 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x0509, r)); |
366 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050A, g)); |
367 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050B, b)); |
368 | |
369 | /* doing as qc-usb did */ |
370 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050C, 0x2A)); |
371 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050D, 0x01)); |
372 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143F, 0x01)); |
373 | |
374 | return 0; |
375 | } |
376 | |
377 | static int qcm_sensor_set_exposure(struct uvd *uvd, int exposure) |
378 | { |
379 | int ret; |
380 | int formedval; |
381 | |
382 | /* calculation was from qc-usb-messenger driver */ |
383 | formedval = ( exposure >> 12 ); |
384 | |
385 | /* max value for formedval is 14 */ |
386 | formedval = min(formedval, 14); |
387 | |
388 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, |
389 | 0x143A, 0xF0 | formedval)); |
390 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143F, 0x01)); |
391 | return 0; |
392 | } |
393 | |
394 | static int qcm_sensor_setlevels(struct uvd *uvd, int brightness, int contrast, |
395 | int hue, int colour) |
396 | { |
397 | int ret; |
398 | /* brightness is exposure, contrast is gain, colour is saturation */ |
399 | CHECK_RET(ret, |
400 | qcm_sensor_set_exposure(uvd, brightness)); |
401 | CHECK_RET(ret, qcm_sensor_set_gains(uvd, hue, colour, contrast)); |
402 | |
403 | return 0; |
404 | } |
405 | |
406 | static int qcm_sensor_setsize(struct uvd *uvd, u8 size) |
407 | { |
408 | int ret; |
409 | |
410 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x1505, size)); |
411 | return 0; |
412 | } |
413 | |
414 | static int qcm_sensor_set_shutter(struct uvd *uvd, int whiteness) |
415 | { |
416 | int ret; |
417 | /* some rescaling as done by the qc-usb-messenger code */ |
418 | if (whiteness > 0xC000) |
419 | whiteness = 0xC000 + (whiteness & 0x3FFF)*8; |
420 | |
421 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143D, |
422 | (whiteness >> 8) & 0xFF)); |
423 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143E, |
424 | (whiteness >> 16) & 0x03)); |
425 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143F, 0x01)); |
426 | |
427 | return 0; |
428 | } |
429 | |
430 | static int qcm_sensor_init(struct uvd *uvd) |
431 | { |
432 | struct qcm *cam = (struct qcm *) uvd->user_data; |
433 | int ret; |
434 | int i; |
435 | |
436 | for (i=0; i < sizeof(regval_table)/sizeof(regval_table[0]) ; i++) { |
437 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, |
438 | regval_table[i].reg, |
439 | regval_table[i].val)); |
440 | } |
441 | |
442 | CHECK_RET(ret, qcm_stv_setw(uvd->dev, 0x15c1, |
443 | cpu_to_le16(ISOC_PACKET_SIZE))); |
444 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x15c3, 0x08)); |
445 | CHECK_RET(ret, ret = qcm_stv_setb(uvd->dev, 0x143f, 0x01)); |
446 | |
447 | CHECK_RET(ret, qcm_stv_setb(uvd->dev, STV_ISO_ENABLE, 0x00)); |
448 | |
449 | CHECK_RET(ret, qcm_sensor_setsize(uvd, camera_sizes[cam->size].cmd)); |
450 | |
451 | CHECK_RET(ret, qcm_sensor_setlevels(uvd, uvd->vpic.brightness, |
452 | uvd->vpic.contrast, uvd->vpic.hue, uvd->vpic.colour)); |
453 | |
454 | CHECK_RET(ret, qcm_sensor_set_shutter(uvd, uvd->vpic.whiteness)); |
455 | CHECK_RET(ret, qcm_sensor_setsize(uvd, camera_sizes[cam->size].cmd)); |
456 | |
457 | return 0; |
458 | } |
459 | |
460 | static int qcm_set_camera_size(struct uvd *uvd) |
461 | { |
462 | int ret; |
463 | struct qcm *cam = (struct qcm *) uvd->user_data; |
464 | |
465 | CHECK_RET(ret, qcm_sensor_setsize(uvd, camera_sizes[cam->size].cmd)); |
466 | cam->width = camera_sizes[cam->size].width; |
467 | cam->height = camera_sizes[cam->size].height; |
468 | uvd->videosize = VIDEOSIZE(cam->width, cam->height); |
469 | |
470 | return 0; |
471 | } |
472 | |
473 | static int qcm_setup_on_open(struct uvd *uvd) |
474 | { |
475 | int ret; |
476 | |
477 | CHECK_RET(ret, qcm_sensor_set_gains(uvd, uvd->vpic.hue, |
478 | uvd->vpic.colour, uvd->vpic.contrast)); |
479 | CHECK_RET(ret, qcm_sensor_set_exposure(uvd, uvd->vpic.brightness)); |
480 | CHECK_RET(ret, qcm_sensor_set_shutter(uvd, uvd->vpic.whiteness)); |
481 | CHECK_RET(ret, qcm_set_camera_size(uvd)); |
482 | CHECK_RET(ret, qcm_camera_on(uvd)); |
483 | return 0; |
484 | } |
485 | |
486 | static void qcm_adjust_picture(struct uvd *uvd) |
487 | { |
488 | int ret; |
489 | struct qcm *cam = (struct qcm *) uvd->user_data; |
490 | |
491 | ret = qcm_camera_off(uvd); |
492 | if (ret) { |
493 | err("can't turn camera off. abandoning pic adjustment"); |
494 | return; |
495 | } |
496 | |
497 | /* if there's been a change in contrast, hue, or |
498 | colour then we need to recalculate hsv in order |
499 | to update gains */ |
500 | if ((cam->contrast != uvd->vpic.contrast) || |
501 | (cam->hue != uvd->vpic.hue) || |
502 | (cam->colour != uvd->vpic.colour)) { |
503 | cam->contrast = uvd->vpic.contrast; |
504 | cam->hue = uvd->vpic.hue; |
505 | cam->colour = uvd->vpic.colour; |
506 | ret = qcm_sensor_set_gains(uvd, cam->hue, cam->colour, |
507 | cam->contrast); |
508 | if (ret) { |
509 | err("can't set gains. abandoning pic adjustment"); |
510 | return; |
511 | } |
512 | } |
513 | |
514 | if (cam->brightness != uvd->vpic.brightness) { |
515 | cam->brightness = uvd->vpic.brightness; |
516 | ret = qcm_sensor_set_exposure(uvd, cam->brightness); |
517 | if (ret) { |
518 | err("can't set exposure. abandoning pic adjustment"); |
519 | return; |
520 | } |
521 | } |
522 | |
523 | if (cam->whiteness != uvd->vpic.whiteness) { |
524 | cam->whiteness = uvd->vpic.whiteness; |
525 | qcm_sensor_set_shutter(uvd, cam->whiteness); |
526 | if (ret) { |
527 | err("can't set shutter. abandoning pic adjustment"); |
528 | return; |
529 | } |
530 | } |
531 | |
532 | ret = qcm_camera_on(uvd); |
533 | if (ret) { |
534 | err("can't reenable camera. pic adjustment failed"); |
535 | return; |
536 | } |
537 | } |
538 | |
539 | static int qcm_process_frame(struct uvd *uvd, u8 *cdata, int framelen) |
540 | { |
541 | int datalen; |
542 | int totaldata; |
543 | struct framehdr { |
544 | __be16 id; |
545 | __be16 len; |
546 | }; |
547 | struct framehdr *fhdr; |
548 | |
549 | totaldata = 0; |
550 | while (framelen) { |
551 | fhdr = (struct framehdr *) cdata; |
552 | datalen = be16_to_cpu(fhdr->len); |
553 | framelen -= 4; |
554 | cdata += 4; |
555 | |
556 | if ((fhdr->id) == cpu_to_be16(0x8001)) { |
557 | RingQueue_Enqueue(&uvd->dp, marker, 4); |
558 | totaldata += 4; |
559 | continue; |
560 | } |
561 | if ((fhdr->id & cpu_to_be16(0xFF00)) == cpu_to_be16(0x0200)) { |
562 | RingQueue_Enqueue(&uvd->dp, cdata, datalen); |
563 | totaldata += datalen; |
564 | } |
565 | framelen -= datalen; |
566 | cdata += datalen; |
567 | } |
568 | return totaldata; |
569 | } |
570 | |
571 | static int qcm_compress_iso(struct uvd *uvd, struct urb *dataurb) |
572 | { |
573 | int totlen; |
574 | int i; |
575 | unsigned char *cdata; |
576 | |
577 | totlen=0; |
578 | for (i = 0; i < dataurb->number_of_packets; i++) { |
579 | int n = dataurb->iso_frame_desc[i].actual_length; |
580 | int st = dataurb->iso_frame_desc[i].status; |
581 | |
582 | cdata = dataurb->transfer_buffer + |
583 | dataurb->iso_frame_desc[i].offset; |
584 | |
585 | if (st < 0) { |
586 | warn("Data error: packet=%d. len=%d. status=%d.", |
587 | i, n, st); |
588 | uvd->stats.iso_err_count++; |
589 | continue; |
590 | } |
591 | if (!n) |
592 | continue; |
593 | |
594 | totlen += qcm_process_frame(uvd, cdata, n); |
595 | } |
596 | return totlen; |
597 | } |
598 | |
599 | static void resubmit_urb(struct uvd *uvd, struct urb *urb) |
600 | { |
601 | int ret; |
602 | |
603 | urb->dev = uvd->dev; |
604 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
605 | if (ret) |
606 | err("usb_submit_urb error (%d)", ret); |
607 | } |
608 | |
7d12e780 |
609 | static void qcm_isoc_irq(struct urb *urb) |
e48a9c62 |
610 | { |
611 | int len; |
612 | struct uvd *uvd = urb->context; |
613 | |
614 | if (!CAMERA_IS_OPERATIONAL(uvd)) |
615 | return; |
616 | |
617 | if (!uvd->streaming) |
618 | return; |
619 | |
620 | uvd->stats.urb_count++; |
621 | |
622 | if (!urb->actual_length) { |
623 | resubmit_urb(uvd, urb); |
624 | return; |
625 | } |
626 | |
627 | len = qcm_compress_iso(uvd, urb); |
628 | resubmit_urb(uvd, urb); |
629 | uvd->stats.urb_length = len; |
630 | uvd->stats.data_count += len; |
631 | if (len) |
632 | RingQueue_WakeUpInterruptible(&uvd->dp); |
633 | } |
634 | |
635 | static int qcm_start_data(struct uvd *uvd) |
636 | { |
637 | struct qcm *cam = (struct qcm *) uvd->user_data; |
638 | int i; |
639 | int errflag; |
640 | int pktsz; |
641 | int err; |
642 | |
643 | pktsz = uvd->iso_packet_len; |
644 | if (!CAMERA_IS_OPERATIONAL(uvd)) { |
645 | err("Camera is not operational"); |
646 | return -EFAULT; |
647 | } |
648 | |
649 | err = usb_set_interface(uvd->dev, uvd->iface, uvd->ifaceAltActive); |
650 | if (err < 0) { |
651 | err("usb_set_interface error"); |
652 | uvd->last_error = err; |
653 | return -EBUSY; |
654 | } |
655 | |
656 | for (i=0; i < USBVIDEO_NUMSBUF; i++) { |
657 | int j, k; |
658 | struct urb *urb = uvd->sbuf[i].urb; |
659 | urb->dev = uvd->dev; |
660 | urb->context = uvd; |
661 | urb->pipe = usb_rcvisocpipe(uvd->dev, uvd->video_endp); |
662 | urb->interval = 1; |
663 | urb->transfer_flags = URB_ISO_ASAP; |
664 | urb->transfer_buffer = uvd->sbuf[i].data; |
665 | urb->complete = qcm_isoc_irq; |
666 | urb->number_of_packets = FRAMES_PER_DESC; |
667 | urb->transfer_buffer_length = pktsz * FRAMES_PER_DESC; |
668 | for (j=k=0; j < FRAMES_PER_DESC; j++, k += pktsz) { |
669 | urb->iso_frame_desc[j].offset = k; |
670 | urb->iso_frame_desc[j].length = pktsz; |
671 | } |
672 | } |
673 | |
674 | uvd->streaming = 1; |
675 | uvd->curframe = -1; |
676 | for (i=0; i < USBVIDEO_NUMSBUF; i++) { |
677 | errflag = usb_submit_urb(uvd->sbuf[i].urb, GFP_KERNEL); |
678 | if (errflag) |
679 | err ("usb_submit_isoc(%d) ret %d", i, errflag); |
680 | } |
681 | |
682 | CHECK_RET(err, qcm_setup_input_int(cam, uvd)); |
683 | CHECK_RET(err, qcm_camera_on(uvd)); |
684 | return 0; |
685 | } |
686 | |
687 | static void qcm_stop_data(struct uvd *uvd) |
688 | { |
689 | struct qcm *cam = (struct qcm *) uvd->user_data; |
690 | int i, j; |
691 | int ret; |
692 | |
693 | if ((uvd == NULL) || (!uvd->streaming) || (uvd->dev == NULL)) |
694 | return; |
695 | |
696 | ret = qcm_camera_off(uvd); |
697 | if (ret) |
698 | warn("couldn't turn the cam off."); |
699 | |
700 | uvd->streaming = 0; |
701 | |
702 | /* Unschedule all of the iso td's */ |
703 | for (i=0; i < USBVIDEO_NUMSBUF; i++) |
704 | usb_kill_urb(uvd->sbuf[i].urb); |
705 | |
706 | qcm_stop_int_data(cam); |
707 | |
708 | if (!uvd->remove_pending) { |
709 | /* Set packet size to 0 */ |
710 | j = usb_set_interface(uvd->dev, uvd->iface, |
711 | uvd->ifaceAltInactive); |
712 | if (j < 0) { |
713 | err("usb_set_interface() error %d.", j); |
714 | uvd->last_error = j; |
715 | } |
716 | } |
717 | } |
718 | |
719 | static void qcm_process_isoc(struct uvd *uvd, struct usbvideo_frame *frame) |
720 | { |
721 | struct qcm *cam = (struct qcm *) uvd->user_data; |
722 | int x; |
723 | struct rgb *rgbL0; |
724 | struct rgb *rgbL1; |
725 | struct bayL0 *bayL0; |
726 | struct bayL1 *bayL1; |
727 | int hor,ver,hordel,verdel; |
728 | assert(frame != NULL); |
729 | |
730 | switch (cam->size) { |
731 | case SIZE_160X120: |
732 | hor = 162; ver = 124; hordel = 1; verdel = 2; |
733 | break; |
734 | case SIZE_320X240: |
735 | default: |
736 | hor = 324; ver = 248; hordel = 2; verdel = 4; |
737 | break; |
738 | } |
739 | |
740 | if (frame->scanstate == ScanState_Scanning) { |
741 | while (RingQueue_GetLength(&uvd->dp) >= |
742 | 4 + (hor*verdel + hordel)) { |
743 | if ((RING_QUEUE_PEEK(&uvd->dp, 0) == 0x00) && |
744 | (RING_QUEUE_PEEK(&uvd->dp, 1) == 0xff) && |
745 | (RING_QUEUE_PEEK(&uvd->dp, 2) == 0x00) && |
746 | (RING_QUEUE_PEEK(&uvd->dp, 3) == 0xff)) { |
747 | frame->curline = 0; |
748 | frame->scanstate = ScanState_Lines; |
749 | frame->frameState = FrameState_Grabbing; |
750 | RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 4); |
751 | /* |
752 | * if we're starting, we need to discard the first |
753 | * 4 lines of y bayer data |
754 | * and the first 2 gr elements of x bayer data |
755 | */ |
756 | RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, |
757 | (hor*verdel + hordel)); |
758 | break; |
759 | } |
760 | RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 1); |
761 | } |
762 | } |
763 | |
764 | if (frame->scanstate == ScanState_Scanning) |
765 | return; |
766 | |
767 | /* now we can start processing bayer data so long as we have at least |
768 | * 2 lines worth of data. this is the simplest demosaicing method that |
769 | * I could think of. I use each 2x2 bayer element without interpolation |
770 | * to generate 4 rgb pixels. |
771 | */ |
772 | while ( frame->curline < cam->height && |
773 | (RingQueue_GetLength(&uvd->dp) >= hor*2)) { |
774 | /* get 2 lines of bayer for demosaicing |
775 | * into 2 lines of RGB */ |
776 | RingQueue_Dequeue(&uvd->dp, cam->scratch, hor*2); |
777 | bayL0 = (struct bayL0 *) cam->scratch; |
778 | bayL1 = (struct bayL1 *) (cam->scratch + hor); |
779 | /* frame->curline is the rgb y line */ |
780 | rgbL0 = (struct rgb *) |
781 | ( frame->data + (cam->width*3*frame->curline)); |
782 | /* w/2 because we're already doing 2 pixels */ |
783 | rgbL1 = rgbL0 + (cam->width/2); |
784 | |
785 | for (x=0; x < cam->width; x+=2) { |
786 | rgbL0->r = bayL0->r; |
787 | rgbL0->g = bayL0->g; |
788 | rgbL0->b = bayL1->b; |
789 | |
790 | rgbL0->r2 = bayL0->r; |
791 | rgbL0->g2 = bayL1->g; |
792 | rgbL0->b2 = bayL1->b; |
793 | |
794 | rgbL1->r = bayL0->r; |
795 | rgbL1->g = bayL1->g; |
796 | rgbL1->b = bayL1->b; |
797 | |
798 | rgbL1->r2 = bayL0->r; |
799 | rgbL1->g2 = bayL1->g; |
800 | rgbL1->b2 = bayL1->b; |
801 | |
802 | rgbL0++; |
803 | rgbL1++; |
804 | |
805 | bayL0++; |
806 | bayL1++; |
807 | } |
808 | |
809 | frame->seqRead_Length += cam->width*3*2; |
810 | frame->curline += 2; |
811 | } |
812 | /* See if we filled the frame */ |
813 | if (frame->curline == cam->height) { |
814 | frame->frameState = FrameState_Done_Hold; |
815 | frame->curline = 0; |
816 | uvd->curframe = -1; |
817 | uvd->stats.frame_num++; |
818 | } |
819 | } |
820 | |
821 | /* taken from konicawc */ |
822 | static int qcm_set_video_mode(struct uvd *uvd, struct video_window *vw) |
823 | { |
824 | int ret; |
825 | int newsize; |
826 | int oldsize; |
827 | int x = vw->width; |
828 | int y = vw->height; |
829 | struct qcm *cam = (struct qcm *) uvd->user_data; |
830 | |
831 | if (x > 0 && y > 0) { |
832 | DEBUG(2, "trying to find size %d,%d", x, y); |
833 | for (newsize = 0; newsize <= MAX_FRAME_SIZE; newsize++) { |
834 | if ((camera_sizes[newsize].width == x) && |
835 | (camera_sizes[newsize].height == y)) |
836 | break; |
837 | } |
838 | } else |
839 | newsize = cam->size; |
840 | |
841 | if (newsize > MAX_FRAME_SIZE) { |
842 | DEBUG(1, "couldn't find size %d,%d", x, y); |
843 | return -EINVAL; |
844 | } |
845 | |
846 | if (newsize == cam->size) { |
847 | DEBUG(1, "Nothing to do"); |
848 | return 0; |
849 | } |
850 | |
851 | qcm_stop_data(uvd); |
852 | |
853 | if (cam->size != newsize) { |
854 | oldsize = cam->size; |
855 | cam->size = newsize; |
856 | ret = qcm_set_camera_size(uvd); |
857 | if (ret) { |
858 | err("Couldn't set camera size, err=%d",ret); |
859 | /* restore the original size */ |
860 | cam->size = oldsize; |
861 | return ret; |
862 | } |
863 | } |
864 | |
865 | /* Flush the input queue and clear any current frame in progress */ |
866 | |
867 | RingQueue_Flush(&uvd->dp); |
868 | if (uvd->curframe != -1) { |
869 | uvd->frame[uvd->curframe].curline = 0; |
870 | uvd->frame[uvd->curframe].seqRead_Length = 0; |
871 | uvd->frame[uvd->curframe].seqRead_Index = 0; |
872 | } |
873 | |
874 | CHECK_RET(ret, qcm_start_data(uvd)); |
875 | return 0; |
876 | } |
877 | |
878 | static int qcm_configure_video(struct uvd *uvd) |
879 | { |
880 | int ret; |
881 | memset(&uvd->vpic, 0, sizeof(uvd->vpic)); |
882 | memset(&uvd->vpic_old, 0x55, sizeof(uvd->vpic_old)); |
883 | |
884 | uvd->vpic.colour = colour; |
885 | uvd->vpic.hue = hue; |
886 | uvd->vpic.brightness = brightness; |
887 | uvd->vpic.contrast = contrast; |
888 | uvd->vpic.whiteness = whiteness; |
889 | uvd->vpic.depth = 24; |
890 | uvd->vpic.palette = VIDEO_PALETTE_RGB24; |
891 | |
892 | memset(&uvd->vcap, 0, sizeof(uvd->vcap)); |
893 | strcpy(uvd->vcap.name, "QCM USB Camera"); |
894 | uvd->vcap.type = VID_TYPE_CAPTURE; |
895 | uvd->vcap.channels = 1; |
896 | uvd->vcap.audios = 0; |
897 | |
898 | uvd->vcap.minwidth = camera_sizes[SIZE_160X120].width; |
899 | uvd->vcap.minheight = camera_sizes[SIZE_160X120].height; |
900 | uvd->vcap.maxwidth = camera_sizes[SIZE_320X240].width; |
901 | uvd->vcap.maxheight = camera_sizes[SIZE_320X240].height; |
902 | |
903 | memset(&uvd->vchan, 0, sizeof(uvd->vchan)); |
904 | uvd->vchan.flags = 0 ; |
905 | uvd->vchan.tuners = 0; |
906 | uvd->vchan.channel = 0; |
907 | uvd->vchan.type = VIDEO_TYPE_CAMERA; |
908 | strcpy(uvd->vchan.name, "Camera"); |
909 | |
910 | CHECK_RET(ret, qcm_sensor_init(uvd)); |
911 | return 0; |
912 | } |
913 | |
914 | static int qcm_probe(struct usb_interface *intf, |
915 | const struct usb_device_id *devid) |
916 | { |
917 | int err; |
918 | struct uvd *uvd; |
919 | struct usb_device *dev = interface_to_usbdev(intf); |
920 | struct qcm *cam; |
921 | size_t buffer_size; |
922 | unsigned char video_ep; |
923 | struct usb_host_interface *interface; |
924 | struct usb_endpoint_descriptor *endpoint; |
925 | int i,j; |
926 | unsigned int ifacenum, ifacenum_inact=0; |
927 | __le16 sensor_id; |
928 | |
929 | /* we don't support multiconfig cams */ |
930 | if (dev->descriptor.bNumConfigurations != 1) |
931 | return -ENODEV; |
932 | |
933 | /* first check for the video interface and not |
934 | * the audio interface */ |
935 | interface = &intf->cur_altsetting[0]; |
936 | if ((interface->desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC) |
937 | || (interface->desc.bInterfaceSubClass != |
938 | USB_CLASS_VENDOR_SPEC)) |
939 | return -ENODEV; |
940 | |
941 | /* |
942 | walk through each endpoint in each setting in the interface |
943 | stop when we find the one that's an isochronous IN endpoint. |
944 | */ |
945 | for (i=0; i < intf->num_altsetting; i++) { |
946 | interface = &intf->cur_altsetting[i]; |
947 | ifacenum = interface->desc.bAlternateSetting; |
948 | /* walk the end points */ |
949 | for (j=0; j < interface->desc.bNumEndpoints; j++) { |
950 | endpoint = &interface->endpoint[j].desc; |
951 | |
952 | if ((endpoint->bEndpointAddress & |
953 | USB_ENDPOINT_DIR_MASK) != USB_DIR_IN) |
954 | continue; /* not input then not good */ |
955 | |
956 | buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); |
957 | if (!buffer_size) { |
958 | ifacenum_inact = ifacenum; |
959 | continue; /* 0 pkt size is not what we want */ |
960 | } |
961 | |
962 | if ((endpoint->bmAttributes & |
963 | USB_ENDPOINT_XFERTYPE_MASK) == |
964 | USB_ENDPOINT_XFER_ISOC) { |
965 | video_ep = endpoint->bEndpointAddress; |
966 | /* break out of the search */ |
967 | goto good_videoep; |
968 | } |
969 | } |
970 | } |
971 | /* failed out since nothing useful was found */ |
972 | err("No suitable endpoint was found\n"); |
973 | return -ENODEV; |
974 | |
975 | good_videoep: |
976 | /* disable isochronous stream before doing anything else */ |
977 | err = qcm_stv_setb(dev, STV_ISO_ENABLE, 0); |
978 | if (err < 0) { |
979 | err("Failed to disable sensor stream"); |
980 | return -EIO; |
981 | } |
982 | |
983 | /* |
984 | Check that this is the same unknown sensor that is known to work. This |
985 | sensor is suspected to be the ST VV6422C001. I'll check the same value |
986 | that the qc-usb driver checks. This value is probably not even the |
987 | sensor ID since it matches the USB dev ID. Oh well. If it doesn't |
988 | match, it's probably a diff sensor so exit and apologize. |
989 | */ |
990 | err = qcm_stv_getw(dev, CMOS_SENSOR_IDREV, &sensor_id); |
991 | if (err < 0) { |
992 | err("Couldn't read sensor values. Err %d\n",err); |
993 | return err; |
994 | } |
995 | if (sensor_id != cpu_to_le16(0x08F0)) { |
996 | err("Sensor ID %x != %x. Unsupported. Sorry\n", |
997 | le16_to_cpu(sensor_id), (0x08F0)); |
998 | return -ENODEV; |
999 | } |
1000 | |
1001 | uvd = usbvideo_AllocateDevice(cams); |
1002 | if (!uvd) |
1003 | return -ENOMEM; |
1004 | |
1005 | cam = (struct qcm *) uvd->user_data; |
1006 | |
1007 | /* buf for doing demosaicing */ |
1008 | cam->scratch = kmalloc(324*2, GFP_KERNEL); |
1009 | if (!cam->scratch) /* uvd freed in dereg */ |
1010 | return -ENOMEM; |
1011 | |
1012 | /* yes, if we fail after here, cam->scratch gets freed |
1013 | by qcm_free_uvd */ |
1014 | |
1015 | err = qcm_alloc_int_urb(cam); |
1016 | if (err < 0) |
1017 | return err; |
1018 | |
1019 | /* yes, if we fail after here, int urb gets freed |
1020 | by qcm_free_uvd */ |
1021 | |
1022 | RESTRICT_TO_RANGE(size, SIZE_160X120, SIZE_320X240); |
1023 | cam->width = camera_sizes[size].width; |
1024 | cam->height = camera_sizes[size].height; |
1025 | cam->size = size; |
1026 | |
1027 | uvd->debug = debug; |
1028 | uvd->flags = 0; |
1029 | uvd->dev = dev; |
1030 | uvd->iface = intf->altsetting->desc.bInterfaceNumber; |
1031 | uvd->ifaceAltActive = ifacenum; |
1032 | uvd->ifaceAltInactive = ifacenum_inact; |
1033 | uvd->video_endp = video_ep; |
1034 | uvd->iso_packet_len = buffer_size; |
1035 | uvd->paletteBits = 1L << VIDEO_PALETTE_RGB24; |
1036 | uvd->defaultPalette = VIDEO_PALETTE_RGB24; |
1037 | uvd->canvas = VIDEOSIZE(320, 240); |
1038 | uvd->videosize = VIDEOSIZE(cam->width, cam->height); |
1039 | err = qcm_configure_video(uvd); |
1040 | if (err) { |
1041 | err("failed to configure video settings"); |
1042 | return err; |
1043 | } |
1044 | |
1045 | err = usbvideo_RegisterVideoDevice(uvd); |
1046 | if (err) { /* the uvd gets freed in Deregister */ |
1047 | err("usbvideo_RegisterVideoDevice() failed."); |
1048 | return err; |
1049 | } |
1050 | |
1051 | uvd->max_frame_size = (320 * 240 * 3); |
1052 | qcm_register_input(cam, dev); |
1053 | usb_set_intfdata(intf, uvd); |
1054 | return 0; |
1055 | } |
1056 | |
1057 | static void qcm_free_uvd(struct uvd *uvd) |
1058 | { |
1059 | struct qcm *cam = (struct qcm *) uvd->user_data; |
1060 | |
1061 | kfree(cam->scratch); |
1062 | qcm_unregister_input(cam); |
1063 | qcm_free_int(cam); |
1064 | } |
1065 | |
1066 | static struct usbvideo_cb qcm_driver = { |
1067 | .probe = qcm_probe, |
1068 | .setupOnOpen = qcm_setup_on_open, |
1069 | .processData = qcm_process_isoc, |
1070 | .setVideoMode = qcm_set_video_mode, |
1071 | .startDataPump = qcm_start_data, |
1072 | .stopDataPump = qcm_stop_data, |
1073 | .adjustPicture = qcm_adjust_picture, |
1074 | .userFree = qcm_free_uvd |
1075 | }; |
1076 | |
1077 | static int __init qcm_init(void) |
1078 | { |
1079 | info(DRIVER_DESC " " DRIVER_VERSION); |
1080 | |
1081 | return usbvideo_register( |
1082 | &cams, |
1083 | MAX_CAMERAS, |
1084 | sizeof(struct qcm), |
1085 | "QCM", |
1086 | &qcm_driver, |
1087 | THIS_MODULE, |
1088 | qcm_table); |
1089 | } |
1090 | |
1091 | static void __exit qcm_exit(void) |
1092 | { |
1093 | usbvideo_Deregister(&cams); |
1094 | } |
1095 | |
1096 | module_param(size, int, 0); |
1097 | MODULE_PARM_DESC(size, "Initial Size 0: 160x120 1: 320x240"); |
1098 | module_param(colour, int, 0); |
1099 | MODULE_PARM_DESC(colour, "Initial colour"); |
1100 | module_param(hue, int, 0); |
1101 | MODULE_PARM_DESC(hue, "Initial hue"); |
1102 | module_param(brightness, int, 0); |
1103 | MODULE_PARM_DESC(brightness, "Initial brightness"); |
1104 | module_param(contrast, int, 0); |
1105 | MODULE_PARM_DESC(contrast, "Initial contrast"); |
1106 | module_param(whiteness, int, 0); |
1107 | MODULE_PARM_DESC(whiteness, "Initial whiteness"); |
1108 | |
1109 | #ifdef CONFIG_USB_DEBUG |
1110 | module_param(debug, int, S_IRUGO | S_IWUSR); |
1111 | MODULE_PARM_DESC(debug, "Debug level: 0-9 (default=0)"); |
1112 | #endif |
1113 | |
1114 | module_init(qcm_init); |
1115 | module_exit(qcm_exit); |
1116 | |
1117 | MODULE_LICENSE("GPL"); |
1118 | MODULE_AUTHOR("Jaya Kumar"); |
1119 | MODULE_DESCRIPTION("QCM USB Camera"); |
1120 | MODULE_SUPPORTED_DEVICE("QCM USB Camera"); |