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