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