drivers/media/video/gspca/xirlink_cit.c

   1 /*
   2  * USB IBM C-It Video Camera driver
   3  *
   4  * Supports Xirlink C-It Video Camera, IBM PC Camera,
   5  * IBM NetCamera and Veo Stingray.
   6  *
   7  * Copyright (C) 2010 Hans de Goede <hdegoede@redhat.com>
   8  *
   9  * This driver is based on earlier work of:
  10  *
  11  * (C) Copyright 1999 Johannes Erdfelt
  12  * (C) Copyright 1999 Randy Dunlap
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  27  *
  28  */
  29
  30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  31
  32 #define MODULE_NAME "xirlink-cit"
  33
  34 #include <linux/input.h>
  35 #include "gspca.h"
  36
  37 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
  38 MODULE_DESCRIPTION("Xirlink C-IT");
  39 MODULE_LICENSE("GPL");
  40
  41 /* FIXME we should autodetect this */
  42 static int ibm_netcam_pro;
  43 module_param(ibm_netcam_pro, int, 0);
  44 MODULE_PARM_DESC(ibm_netcam_pro,
  45                  "Use IBM Netcamera Pro init sequences for Model 3 cams");
  46
  47 /* FIXME this should be handled through the V4L2 input selection API */
  48 static int rca_input;
  49 module_param(rca_input, int, 0644);
  50 MODULE_PARM_DESC(rca_input,
  51                  "Use rca input instead of ccd sensor on Model 3 cams");
  52
  53 /* specific webcam descriptor */
  54 struct sd {
  55         struct gspca_dev gspca_dev;             /* !! must be the first item */
  56         u8 model;
  57 #define CIT_MODEL0 0 /* bcd version 0.01 cams ie the xvp-500 */
  58 #define CIT_MODEL1 1 /* The model 1 - 4 nomenclature comes from the old */
  59 #define CIT_MODEL2 2 /* ibmcam driver */
  60 #define CIT_MODEL3 3
  61 #define CIT_MODEL4 4
  62 #define CIT_IBM_NETCAM_PRO 5
  63         u8 input_index;
  64         u8 button_state;
  65         u8 stop_on_control_change;
  66         u8 sof_read;
  67         u8 sof_len;
  68         u8 contrast;
  69         u8 brightness;
  70         u8 hue;
  71         u8 sharpness;
  72         u8 lighting;
  73         u8 hflip;
  74 };
  75
  76 /* V4L2 controls supported by the driver */
  77 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
  78 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
  79 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
  80 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
  81 static int sd_sethue(struct gspca_dev *gspca_dev, __s32 val);
  82 static int sd_gethue(struct gspca_dev *gspca_dev, __s32 *val);
  83 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
  84 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
  85 static int sd_setlighting(struct gspca_dev *gspca_dev, __s32 val);
  86 static int sd_getlighting(struct gspca_dev *gspca_dev, __s32 *val);
  87 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val);
  88 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val);
  89 static void sd_stop0(struct gspca_dev *gspca_dev);
  90
  91 static const struct ctrl sd_ctrls[] = {
  92 #define SD_BRIGHTNESS 0
  93         {
  94             {
  95                 .id      = V4L2_CID_BRIGHTNESS,
  96                 .type    = V4L2_CTRL_TYPE_INTEGER,
  97                 .name    = "Brightness",
  98                 .minimum = 0,
  99                 .maximum = 63,
 100                 .step = 1,
 101 #define BRIGHTNESS_DEFAULT 32
 102                 .default_value = BRIGHTNESS_DEFAULT,
 103                 .flags = 0,
 104             },
 105             .set = sd_setbrightness,
 106             .get = sd_getbrightness,
 107         },
 108 #define SD_CONTRAST 1
 109         {
 110             {
 111                 .id = V4L2_CID_CONTRAST,
 112                 .type = V4L2_CTRL_TYPE_INTEGER,
 113                 .name = "contrast",
 114                 .minimum = 0,
 115                 .maximum = 20,
 116                 .step = 1,
 117 #define CONTRAST_DEFAULT 10
 118                 .default_value = CONTRAST_DEFAULT,
 119                 .flags = 0,
 120             },
 121             .set = sd_setcontrast,
 122             .get = sd_getcontrast,
 123         },
 124 #define SD_HUE 2
 125         {
 126             {
 127                 .id     = V4L2_CID_HUE,
 128                 .type   = V4L2_CTRL_TYPE_INTEGER,
 129                 .name   = "Hue",
 130                 .minimum = 0,
 131                 .maximum = 127,
 132                 .step   = 1,
 133 #define HUE_DEFAULT 63
 134                 .default_value = HUE_DEFAULT,
 135                 .flags = 0,
 136             },
 137             .set = sd_sethue,
 138             .get = sd_gethue,
 139         },
 140 #define SD_SHARPNESS 3
 141         {
 142             {
 143                 .id = V4L2_CID_SHARPNESS,
 144                 .type = V4L2_CTRL_TYPE_INTEGER,
 145                 .name = "Sharpness",
 146                 .minimum = 0,
 147                 .maximum = 6,
 148                 .step = 1,
 149 #define SHARPNESS_DEFAULT 3
 150                 .default_value = SHARPNESS_DEFAULT,
 151                 .flags = 0,
 152             },
 153             .set = sd_setsharpness,
 154             .get = sd_getsharpness,
 155         },
 156 #define SD_LIGHTING 4
 157         {
 158             {
 159                 .id = V4L2_CID_BACKLIGHT_COMPENSATION,
 160                 .type = V4L2_CTRL_TYPE_INTEGER,
 161                 .name = "Lighting",
 162                 .minimum = 0,
 163                 .maximum = 2,
 164                 .step = 1,
 165 #define LIGHTING_DEFAULT 1
 166                 .default_value = LIGHTING_DEFAULT,
 167                 .flags = 0,
 168             },
 169             .set = sd_setlighting,
 170             .get = sd_getlighting,
 171         },
 172 #define SD_HFLIP 5
 173         {
 174             {
 175                 .id      = V4L2_CID_HFLIP,
 176                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 177                 .name    = "Mirror",
 178                 .minimum = 0,
 179                 .maximum = 1,
 180                 .step    = 1,
 181 #define HFLIP_DEFAULT 0
 182                 .default_value = HFLIP_DEFAULT,
 183             },
 184             .set = sd_sethflip,
 185             .get = sd_gethflip,
 186         },
 187 };
 188
 189 static const struct v4l2_pix_format cif_yuv_mode[] = {
 190         {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
 191                 .bytesperline = 176,
 192                 .sizeimage = 176 * 144 * 3 / 2 + 4,
 193                 .colorspace = V4L2_COLORSPACE_SRGB},
 194         {352, 288, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
 195                 .bytesperline = 352,
 196                 .sizeimage = 352 * 288 * 3 / 2 + 4,
 197                 .colorspace = V4L2_COLORSPACE_SRGB},
 198 };
 199
 200 static const struct v4l2_pix_format vga_yuv_mode[] = {
 201         {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
 202                 .bytesperline = 160,
 203                 .sizeimage = 160 * 120 * 3 / 2 + 4,
 204                 .colorspace = V4L2_COLORSPACE_SRGB},
 205         {320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
 206                 .bytesperline = 320,
 207                 .sizeimage = 320 * 240 * 3 / 2 + 4,
 208                 .colorspace = V4L2_COLORSPACE_SRGB},
 209         {640, 480, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
 210                 .bytesperline = 640,
 211                 .sizeimage = 640 * 480 * 3 / 2 + 4,
 212                 .colorspace = V4L2_COLORSPACE_SRGB},
 213 };
 214
 215 static const struct v4l2_pix_format model0_mode[] = {
 216         {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
 217                 .bytesperline = 160,
 218                 .sizeimage = 160 * 120 * 3 / 2 + 4,
 219                 .colorspace = V4L2_COLORSPACE_SRGB},
 220         {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
 221                 .bytesperline = 176,
 222                 .sizeimage = 176 * 144 * 3 / 2 + 4,
 223                 .colorspace = V4L2_COLORSPACE_SRGB},
 224         {320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
 225                 .bytesperline = 320,
 226                 .sizeimage = 320 * 240 * 3 / 2 + 4,
 227                 .colorspace = V4L2_COLORSPACE_SRGB},
 228 };
 229
 230 static const struct v4l2_pix_format model2_mode[] = {
 231         {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
 232                 .bytesperline = 160,
 233                 .sizeimage = 160 * 120 * 3 / 2 + 4,
 234                 .colorspace = V4L2_COLORSPACE_SRGB},
 235         {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
 236                 .bytesperline = 176,
 237                 .sizeimage = 176 * 144 * 3 / 2 + 4,
 238                 .colorspace = V4L2_COLORSPACE_SRGB},
 239         {320, 240, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
 240                 .bytesperline = 320,
 241                 .sizeimage = 320 * 240 + 4,
 242                 .colorspace = V4L2_COLORSPACE_SRGB},
 243         {352, 288, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
 244                 .bytesperline = 352,
 245                 .sizeimage = 352 * 288 + 4,
 246                 .colorspace = V4L2_COLORSPACE_SRGB},
 247 };
 248
 249 /*
 250  * 01.01.08 - Added for RCA video in support -LO
 251  * This struct is used to init the Model3 cam to use the RCA video in port
 252  * instead of the CCD sensor.
 253  */
 254 static const u16 rca_initdata[][3] = {
 255         {0, 0x0000, 0x010c},
 256         {0, 0x0006, 0x012c},
 257         {0, 0x0078, 0x012d},
 258         {0, 0x0046, 0x012f},
 259         {0, 0xd141, 0x0124},
 260         {0, 0x0000, 0x0127},
 261         {0, 0xfea8, 0x0124},
 262         {1, 0x0000, 0x0116},
 263         {0, 0x0064, 0x0116},
 264         {1, 0x0000, 0x0115},
 265         {0, 0x0003, 0x0115},
 266         {0, 0x0008, 0x0123},
 267         {0, 0x0000, 0x0117},
 268         {0, 0x0000, 0x0112},
 269         {0, 0x0080, 0x0100},
 270         {0, 0x0000, 0x0100},
 271         {1, 0x0000, 0x0116},
 272         {0, 0x0060, 0x0116},
 273         {0, 0x0002, 0x0112},
 274         {0, 0x0000, 0x0123},
 275         {0, 0x0001, 0x0117},
 276         {0, 0x0040, 0x0108},
 277         {0, 0x0019, 0x012c},
 278         {0, 0x0040, 0x0116},
 279         {0, 0x000a, 0x0115},
 280         {0, 0x000b, 0x0115},
 281         {0, 0x0078, 0x012d},
 282         {0, 0x0046, 0x012f},
 283         {0, 0xd141, 0x0124},
 284         {0, 0x0000, 0x0127},
 285         {0, 0xfea8, 0x0124},
 286         {0, 0x0064, 0x0116},
 287         {0, 0x0000, 0x0115},
 288         {0, 0x0001, 0x0115},
 289         {0, 0xffff, 0x0124},
 290         {0, 0xfff9, 0x0124},
 291         {0, 0x0086, 0x0127},
 292         {0, 0xfff8, 0x0124},
 293         {0, 0xfffd, 0x0124},
 294         {0, 0x00aa, 0x0127},
 295         {0, 0xfff8, 0x0124},
 296         {0, 0xfffd, 0x0124},
 297         {0, 0x0000, 0x0127},
 298         {0, 0xfff8, 0x0124},
 299         {0, 0xfffd, 0x0124},
 300         {0, 0xfffa, 0x0124},
 301         {0, 0xffff, 0x0124},
 302         {0, 0xfff9, 0x0124},
 303         {0, 0x0086, 0x0127},
 304         {0, 0xfff8, 0x0124},
 305         {0, 0xfffd, 0x0124},
 306         {0, 0x00f2, 0x0127},
 307         {0, 0xfff8, 0x0124},
 308         {0, 0xfffd, 0x0124},
 309         {0, 0x000f, 0x0127},
 310         {0, 0xfff8, 0x0124},
 311         {0, 0xfffd, 0x0124},
 312         {0, 0xfffa, 0x0124},
 313         {0, 0xffff, 0x0124},
 314         {0, 0xfff9, 0x0124},
 315         {0, 0x0086, 0x0127},
 316         {0, 0xfff8, 0x0124},
 317         {0, 0xfffd, 0x0124},
 318         {0, 0x00f8, 0x0127},
 319         {0, 0xfff8, 0x0124},
 320         {0, 0xfffd, 0x0124},
 321         {0, 0x00fc, 0x0127},
 322         {0, 0xfff8, 0x0124},
 323         {0, 0xfffd, 0x0124},
 324         {0, 0xfffa, 0x0124},
 325         {0, 0xffff, 0x0124},
 326         {0, 0xfff9, 0x0124},
 327         {0, 0x0086, 0x0127},
 328         {0, 0xfff8, 0x0124},
 329         {0, 0xfffd, 0x0124},
 330         {0, 0x00f9, 0x0127},
 331         {0, 0xfff8, 0x0124},
 332         {0, 0xfffd, 0x0124},
 333         {0, 0x003c, 0x0127},
 334         {0, 0xfff8, 0x0124},
 335         {0, 0xfffd, 0x0124},
 336         {0, 0xfffa, 0x0124},
 337         {0, 0xffff, 0x0124},
 338         {0, 0xfff9, 0x0124},
 339         {0, 0x0086, 0x0127},
 340         {0, 0xfff8, 0x0124},
 341         {0, 0xfffd, 0x0124},
 342         {0, 0x0027, 0x0127},
 343         {0, 0xfff8, 0x0124},
 344         {0, 0xfffd, 0x0124},
 345         {0, 0x0019, 0x0127},
 346         {0, 0xfff8, 0x0124},
 347         {0, 0xfffd, 0x0124},
 348         {0, 0xfffa, 0x0124},
 349         {0, 0xfff9, 0x0124},
 350         {0, 0x0086, 0x0127},
 351         {0, 0xfff8, 0x0124},
 352         {0, 0xfffd, 0x0124},
 353         {0, 0x0037, 0x0127},
 354         {0, 0xfff8, 0x0124},
 355         {0, 0xfffd, 0x0124},
 356         {0, 0x0000, 0x0127},
 357         {0, 0xfff8, 0x0124},
 358         {0, 0xfffd, 0x0124},
 359         {0, 0x0021, 0x0127},
 360         {0, 0xfff8, 0x0124},
 361         {0, 0xfffd, 0x0124},
 362         {0, 0xfffa, 0x0124},
 363         {0, 0xfff9, 0x0124},
 364         {0, 0x0086, 0x0127},
 365         {0, 0xfff8, 0x0124},
 366         {0, 0xfffd, 0x0124},
 367         {0, 0x0038, 0x0127},
 368         {0, 0xfff8, 0x0124},
 369         {0, 0xfffd, 0x0124},
 370         {0, 0x0006, 0x0127},
 371         {0, 0xfff8, 0x0124},
 372         {0, 0xfffd, 0x0124},
 373         {0, 0x0045, 0x0127},
 374         {0, 0xfff8, 0x0124},
 375         {0, 0xfffd, 0x0124},
 376         {0, 0xfffa, 0x0124},
 377         {0, 0xfff9, 0x0124},
 378         {0, 0x0086, 0x0127},
 379         {0, 0xfff8, 0x0124},
 380         {0, 0xfffd, 0x0124},
 381         {0, 0x0037, 0x0127},
 382         {0, 0xfff8, 0x0124},
 383         {0, 0xfffd, 0x0124},
 384         {0, 0x0001, 0x0127},
 385         {0, 0xfff8, 0x0124},
 386         {0, 0xfffd, 0x0124},
 387         {0, 0x002a, 0x0127},
 388         {0, 0xfff8, 0x0124},
 389         {0, 0xfffd, 0x0124},
 390         {0, 0xfffa, 0x0124},
 391         {0, 0xfff9, 0x0124},
 392         {0, 0x0086, 0x0127},
 393         {0, 0xfff8, 0x0124},
 394         {0, 0xfffd, 0x0124},
 395         {0, 0x0038, 0x0127},
 396         {0, 0xfff8, 0x0124},
 397         {0, 0xfffd, 0x0124},
 398         {0, 0x0000, 0x0127},
 399         {0, 0xfff8, 0x0124},
 400         {0, 0xfffd, 0x0124},
 401         {0, 0x000e, 0x0127},
 402         {0, 0xfff8, 0x0124},
 403         {0, 0xfffd, 0x0124},
 404         {0, 0xfffa, 0x0124},
 405         {0, 0xfff9, 0x0124},
 406         {0, 0x0086, 0x0127},
 407         {0, 0xfff8, 0x0124},
 408         {0, 0xfffd, 0x0124},
 409         {0, 0x0037, 0x0127},
 410         {0, 0xfff8, 0x0124},
 411         {0, 0xfffd, 0x0124},
 412         {0, 0x0001, 0x0127},
 413         {0, 0xfff8, 0x0124},
 414         {0, 0xfffd, 0x0124},
 415         {0, 0x002b, 0x0127},
 416         {0, 0xfff8, 0x0124},
 417         {0, 0xfffd, 0x0124},
 418         {0, 0xfffa, 0x0124},
 419         {0, 0xfff9, 0x0124},
 420         {0, 0x0086, 0x0127},
 421         {0, 0xfff8, 0x0124},
 422         {0, 0xfffd, 0x0124},
 423         {0, 0x0038, 0x0127},
 424         {0, 0xfff8, 0x0124},
 425         {0, 0xfffd, 0x0124},
 426         {0, 0x0001, 0x0127},
 427         {0, 0xfff8, 0x0124},
 428         {0, 0xfffd, 0x0124},
 429         {0, 0x00f4, 0x0127},
 430         {0, 0xfff8, 0x0124},
 431         {0, 0xfffd, 0x0124},
 432         {0, 0xfffa, 0x0124},
 433         {0, 0xfff9, 0x0124},
 434         {0, 0x0086, 0x0127},
 435         {0, 0xfff8, 0x0124},
 436         {0, 0xfffd, 0x0124},
 437         {0, 0x0037, 0x0127},
 438         {0, 0xfff8, 0x0124},
 439         {0, 0xfffd, 0x0124},
 440         {0, 0x0001, 0x0127},
 441         {0, 0xfff8, 0x0124},
 442         {0, 0xfffd, 0x0124},
 443         {0, 0x002c, 0x0127},
 444         {0, 0xfff8, 0x0124},
 445         {0, 0xfffd, 0x0124},
 446         {0, 0xfffa, 0x0124},
 447         {0, 0xfff9, 0x0124},
 448         {0, 0x0086, 0x0127},
 449         {0, 0xfff8, 0x0124},
 450         {0, 0xfffd, 0x0124},
 451         {0, 0x0038, 0x0127},
 452         {0, 0xfff8, 0x0124},
 453         {0, 0xfffd, 0x0124},
 454         {0, 0x0001, 0x0127},
 455         {0, 0xfff8, 0x0124},
 456         {0, 0xfffd, 0x0124},
 457         {0, 0x0004, 0x0127},
 458         {0, 0xfff8, 0x0124},
 459         {0, 0xfffd, 0x0124},
 460         {0, 0xfffa, 0x0124},
 461         {0, 0xfff9, 0x0124},
 462         {0, 0x0086, 0x0127},
 463         {0, 0xfff8, 0x0124},
 464         {0, 0xfffd, 0x0124},
 465         {0, 0x0037, 0x0127},
 466         {0, 0xfff8, 0x0124},
 467         {0, 0xfffd, 0x0124},
 468         {0, 0x0001, 0x0127},
 469         {0, 0xfff8, 0x0124},
 470         {0, 0xfffd, 0x0124},
 471         {0, 0x002d, 0x0127},
 472         {0, 0xfff8, 0x0124},
 473         {0, 0xfffd, 0x0124},
 474         {0, 0xfffa, 0x0124},
 475         {0, 0xfff9, 0x0124},
 476         {0, 0x0086, 0x0127},
 477         {0, 0xfff8, 0x0124},
 478         {0, 0xfffd, 0x0124},
 479         {0, 0x0038, 0x0127},
 480         {0, 0xfff8, 0x0124},
 481         {0, 0xfffd, 0x0124},
 482         {0, 0x0000, 0x0127},
 483         {0, 0xfff8, 0x0124},
 484         {0, 0xfffd, 0x0124},
 485         {0, 0x0014, 0x0127},
 486         {0, 0xfff8, 0x0124},
 487         {0, 0xfffd, 0x0124},
 488         {0, 0xfffa, 0x0124},
 489         {0, 0xfff9, 0x0124},
 490         {0, 0x0086, 0x0127},
 491         {0, 0xfff8, 0x0124},
 492         {0, 0xfffd, 0x0124},
 493         {0, 0x0037, 0x0127},
 494         {0, 0xfff8, 0x0124},
 495         {0, 0xfffd, 0x0124},
 496         {0, 0x0001, 0x0127},
 497         {0, 0xfff8, 0x0124},
 498         {0, 0xfffd, 0x0124},
 499         {0, 0x002e, 0x0127},
 500         {0, 0xfff8, 0x0124},
 501         {0, 0xfffd, 0x0124},
 502         {0, 0xfffa, 0x0124},
 503         {0, 0xfff9, 0x0124},
 504         {0, 0x0086, 0x0127},
 505         {0, 0xfff8, 0x0124},
 506         {0, 0xfffd, 0x0124},
 507         {0, 0x0038, 0x0127},
 508         {0, 0xfff8, 0x0124},
 509         {0, 0xfffd, 0x0124},
 510         {0, 0x0003, 0x0127},
 511         {0, 0xfff8, 0x0124},
 512         {0, 0xfffd, 0x0124},
 513         {0, 0x0000, 0x0127},
 514         {0, 0xfff8, 0x0124},
 515         {0, 0xfffd, 0x0124},
 516         {0, 0xfffa, 0x0124},
 517         {0, 0xfff9, 0x0124},
 518         {0, 0x0086, 0x0127},
 519         {0, 0xfff8, 0x0124},
 520         {0, 0xfffd, 0x0124},
 521         {0, 0x0037, 0x0127},
 522         {0, 0xfff8, 0x0124},
 523         {0, 0xfffd, 0x0124},
 524         {0, 0x0001, 0x0127},
 525         {0, 0xfff8, 0x0124},
 526         {0, 0xfffd, 0x0124},
 527         {0, 0x002f, 0x0127},
 528         {0, 0xfff8, 0x0124},
 529         {0, 0xfffd, 0x0124},
 530         {0, 0xfffa, 0x0124},
 531         {0, 0xfff9, 0x0124},
 532         {0, 0x0086, 0x0127},
 533         {0, 0xfff8, 0x0124},
 534         {0, 0xfffd, 0x0124},
 535         {0, 0x0038, 0x0127},
 536         {0, 0xfff8, 0x0124},
 537         {0, 0xfffd, 0x0124},
 538         {0, 0x0003, 0x0127},
 539         {0, 0xfff8, 0x0124},
 540         {0, 0xfffd, 0x0124},
 541         {0, 0x0014, 0x0127},
 542         {0, 0xfff8, 0x0124},
 543         {0, 0xfffd, 0x0124},
 544         {0, 0xfffa, 0x0124},
 545         {0, 0xfff9, 0x0124},
 546         {0, 0x0086, 0x0127},
 547         {0, 0xfff8, 0x0124},
 548         {0, 0xfffd, 0x0124},
 549         {0, 0x0037, 0x0127},
 550         {0, 0xfff8, 0x0124},
 551         {0, 0xfffd, 0x0124},
 552         {0, 0x0001, 0x0127},
 553         {0, 0xfff8, 0x0124},
 554         {0, 0xfffd, 0x0124},
 555         {0, 0x0040, 0x0127},
 556         {0, 0xfff8, 0x0124},
 557         {0, 0xfffd, 0x0124},
 558         {0, 0xfffa, 0x0124},
 559         {0, 0xfff9, 0x0124},
 560         {0, 0x0086, 0x0127},
 561         {0, 0xfff8, 0x0124},
 562         {0, 0xfffd, 0x0124},
 563         {0, 0x0038, 0x0127},
 564         {0, 0xfff8, 0x0124},
 565         {0, 0xfffd, 0x0124},
 566         {0, 0x0000, 0x0127},
 567         {0, 0xfff8, 0x0124},
 568         {0, 0xfffd, 0x0124},
 569         {0, 0x0040, 0x0127},
 570         {0, 0xfff8, 0x0124},
 571         {0, 0xfffd, 0x0124},
 572         {0, 0xfffa, 0x0124},
 573         {0, 0xfff9, 0x0124},
 574         {0, 0x0086, 0x0127},
 575         {0, 0xfff8, 0x0124},
 576         {0, 0xfffd, 0x0124},
 577         {0, 0x0037, 0x0127},
 578         {0, 0xfff8, 0x0124},
 579         {0, 0xfffd, 0x0124},
 580         {0, 0x0001, 0x0127},
 581         {0, 0xfff8, 0x0124},
 582         {0, 0xfffd, 0x0124},
 583         {0, 0x0053, 0x0127},
 584         {0, 0xfff8, 0x0124},
 585         {0, 0xfffd, 0x0124},
 586         {0, 0xfffa, 0x0124},
 587         {0, 0xfff9, 0x0124},
 588         {0, 0x0086, 0x0127},
 589         {0, 0xfff8, 0x0124},
 590         {0, 0xfffd, 0x0124},
 591         {0, 0x0038, 0x0127},
 592         {0, 0xfff8, 0x0124},
 593         {0, 0xfffd, 0x0124},
 594         {0, 0x0000, 0x0127},
 595         {0, 0xfff8, 0x0124},
 596         {0, 0xfffd, 0x0124},
 597         {0, 0x0038, 0x0127},
 598         {0, 0xfff8, 0x0124},
 599         {0, 0xfffd, 0x0124},
 600         {0, 0xfffa, 0x0124},
 601         {0, 0x0000, 0x0101},
 602         {0, 0x00a0, 0x0103},
 603         {0, 0x0078, 0x0105},
 604         {0, 0x0000, 0x010a},
 605         {0, 0x0024, 0x010b},
 606         {0, 0x0028, 0x0119},
 607         {0, 0x0088, 0x011b},
 608         {0, 0x0002, 0x011d},
 609         {0, 0x0003, 0x011e},
 610         {0, 0x0000, 0x0129},
 611         {0, 0x00fc, 0x012b},
 612         {0, 0x0008, 0x0102},
 613         {0, 0x0000, 0x0104},
 614         {0, 0x0008, 0x011a},
 615         {0, 0x0028, 0x011c},
 616         {0, 0x0021, 0x012a},
 617         {0, 0x0000, 0x0118},
 618         {0, 0x0000, 0x0132},
 619         {0, 0x0000, 0x0109},
 620         {0, 0xfff9, 0x0124},
 621         {0, 0x0086, 0x0127},
 622         {0, 0xfff8, 0x0124},
 623         {0, 0xfffd, 0x0124},
 624         {0, 0x0037, 0x0127},
 625         {0, 0xfff8, 0x0124},
 626         {0, 0xfffd, 0x0124},
 627         {0, 0x0001, 0x0127},
 628         {0, 0xfff8, 0x0124},
 629         {0, 0xfffd, 0x0124},
 630         {0, 0x0031, 0x0127},
 631         {0, 0xfff8, 0x0124},
 632         {0, 0xfffd, 0x0124},
 633         {0, 0xfffa, 0x0124},
 634         {0, 0xfff9, 0x0124},
 635         {0, 0x0086, 0x0127},
 636         {0, 0xfff8, 0x0124},
 637         {0, 0xfffd, 0x0124},
 638         {0, 0x0038, 0x0127},
 639         {0, 0xfff8, 0x0124},
 640         {0, 0xfffd, 0x0124},
 641         {0, 0x0000, 0x0127},
 642         {0, 0xfff8, 0x0124},
 643         {0, 0xfffd, 0x0124},
 644         {0, 0x0000, 0x0127},
 645         {0, 0xfff8, 0x0124},
 646         {0, 0xfffd, 0x0124},
 647         {0, 0xfffa, 0x0124},
 648         {0, 0xfff9, 0x0124},
 649         {0, 0x0086, 0x0127},
 650         {0, 0xfff8, 0x0124},
 651         {0, 0xfffd, 0x0124},
 652         {0, 0x0037, 0x0127},
 653         {0, 0xfff8, 0x0124},
 654         {0, 0xfffd, 0x0124},
 655         {0, 0x0001, 0x0127},
 656         {0, 0xfff8, 0x0124},
 657         {0, 0xfffd, 0x0124},
 658         {0, 0x0040, 0x0127},
 659         {0, 0xfff8, 0x0124},
 660         {0, 0xfffd, 0x0124},
 661         {0, 0xfffa, 0x0124},
 662         {0, 0xfff9, 0x0124},
 663         {0, 0x0086, 0x0127},
 664         {0, 0xfff8, 0x0124},
 665         {0, 0xfffd, 0x0124},
 666         {0, 0x0038, 0x0127},
 667         {0, 0xfff8, 0x0124},
 668         {0, 0xfffd, 0x0124},
 669         {0, 0x0000, 0x0127},
 670         {0, 0xfff8, 0x0124},
 671         {0, 0xfffd, 0x0124},
 672         {0, 0x0040, 0x0127},
 673         {0, 0xfff8, 0x0124},
 674         {0, 0xfffd, 0x0124},
 675         {0, 0xfffa, 0x0124},
 676         {0, 0xfff9, 0x0124},
 677         {0, 0x0086, 0x0127},
 678         {0, 0xfff8, 0x0124},
 679         {0, 0xfffd, 0x0124},
 680         {0, 0x0037, 0x0127},
 681         {0, 0xfff8, 0x0124},
 682         {0, 0xfffd, 0x0124},
 683         {0, 0x0000, 0x0127},
 684         {0, 0xfff8, 0x0124},
 685         {0, 0xfffd, 0x0124},
 686         {0, 0x00dc, 0x0127},
 687         {0, 0xfff8, 0x0124},
 688         {0, 0xfffd, 0x0124},
 689         {0, 0xfffa, 0x0124},
 690         {0, 0xfff9, 0x0124},
 691         {0, 0x0086, 0x0127},
 692         {0, 0xfff8, 0x0124},
 693         {0, 0xfffd, 0x0124},
 694         {0, 0x0038, 0x0127},
 695         {0, 0xfff8, 0x0124},
 696         {0, 0xfffd, 0x0124},
 697         {0, 0x0000, 0x0127},
 698         {0, 0xfff8, 0x0124},
 699         {0, 0xfffd, 0x0124},
 700         {0, 0x0000, 0x0127},
 701         {0, 0xfff8, 0x0124},
 702         {0, 0xfffd, 0x0124},
 703         {0, 0xfffa, 0x0124},
 704         {0, 0xfff9, 0x0124},
 705         {0, 0x0086, 0x0127},
 706         {0, 0xfff8, 0x0124},
 707         {0, 0xfffd, 0x0124},
 708         {0, 0x0037, 0x0127},
 709         {0, 0xfff8, 0x0124},
 710         {0, 0xfffd, 0x0124},
 711         {0, 0x0001, 0x0127},
 712         {0, 0xfff8, 0x0124},
 713         {0, 0xfffd, 0x0124},
 714         {0, 0x0032, 0x0127},
 715         {0, 0xfff8, 0x0124},
 716         {0, 0xfffd, 0x0124},
 717         {0, 0xfffa, 0x0124},
 718         {0, 0xfff9, 0x0124},
 719         {0, 0x0086, 0x0127},
 720         {0, 0xfff8, 0x0124},
 721         {0, 0xfffd, 0x0124},
 722         {0, 0x0038, 0x0127},
 723         {0, 0xfff8, 0x0124},
 724         {0, 0xfffd, 0x0124},
 725         {0, 0x0001, 0x0127},
 726         {0, 0xfff8, 0x0124},
 727         {0, 0xfffd, 0x0124},
 728         {0, 0x0020, 0x0127},
 729         {0, 0xfff8, 0x0124},
 730         {0, 0xfffd, 0x0124},
 731         {0, 0xfffa, 0x0124},
 732         {0, 0xfff9, 0x0124},
 733         {0, 0x0086, 0x0127},
 734         {0, 0xfff8, 0x0124},
 735         {0, 0xfffd, 0x0124},
 736         {0, 0x0037, 0x0127},
 737         {0, 0xfff8, 0x0124},
 738         {0, 0xfffd, 0x0124},
 739         {0, 0x0001, 0x0127},
 740         {0, 0xfff8, 0x0124},
 741         {0, 0xfffd, 0x0124},
 742         {0, 0x0040, 0x0127},
 743         {0, 0xfff8, 0x0124},
 744         {0, 0xfffd, 0x0124},
 745         {0, 0xfffa, 0x0124},
 746         {0, 0xfff9, 0x0124},
 747         {0, 0x0086, 0x0127},
 748         {0, 0xfff8, 0x0124},
 749         {0, 0xfffd, 0x0124},
 750         {0, 0x0038, 0x0127},
 751         {0, 0xfff8, 0x0124},
 752         {0, 0xfffd, 0x0124},
 753         {0, 0x0000, 0x0127},
 754         {0, 0xfff8, 0x0124},
 755         {0, 0xfffd, 0x0124},
 756         {0, 0x0040, 0x0127},
 757         {0, 0xfff8, 0x0124},
 758         {0, 0xfffd, 0x0124},
 759         {0, 0xfffa, 0x0124},
 760         {0, 0xfff9, 0x0124},
 761         {0, 0x0086, 0x0127},
 762         {0, 0xfff8, 0x0124},
 763         {0, 0xfffd, 0x0124},
 764         {0, 0x0037, 0x0127},
 765         {0, 0xfff8, 0x0124},
 766         {0, 0xfffd, 0x0124},
 767         {0, 0x0000, 0x0127},
 768         {0, 0xfff8, 0x0124},
 769         {0, 0xfffd, 0x0124},
 770         {0, 0x0030, 0x0127},
 771         {0, 0xfff8, 0x0124},
 772         {0, 0xfffd, 0x0124},
 773         {0, 0xfffa, 0x0124},
 774         {0, 0xfff9, 0x0124},
 775         {0, 0x0086, 0x0127},
 776         {0, 0xfff8, 0x0124},
 777         {0, 0xfffd, 0x0124},
 778         {0, 0x0038, 0x0127},
 779         {0, 0xfff8, 0x0124},
 780         {0, 0xfffd, 0x0124},
 781         {0, 0x0008, 0x0127},
 782         {0, 0xfff8, 0x0124},
 783         {0, 0xfffd, 0x0124},
 784         {0, 0x0000, 0x0127},
 785         {0, 0xfff8, 0x0124},
 786         {0, 0xfffd, 0x0124},
 787         {0, 0xfffa, 0x0124},
 788         {0, 0x0003, 0x0111},
 789 };
 790
 791 /* TESTME the old ibmcam driver repeats certain commands to Model1 cameras, we
 792    do the same for now (testing needed to see if this is really necessary) */
 793 static const int cit_model1_ntries = 5;
 794 static const int cit_model1_ntries2 = 2;
 795
 796 static int cit_write_reg(struct gspca_dev *gspca_dev, u16 value, u16 index)
 797 {
 798         struct usb_device *udev = gspca_dev->dev;
 799         int err;
 800
 801         err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x00,
 802                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
 803                         value, index, NULL, 0, 1000);
 804         if (err < 0)
 805                 pr_err("Failed to write a register (index 0x%04X, value 0x%02X, error %d)\n",
 806                        index, value, err);
 807
 808         return 0;
 809 }
 810
 811 static int cit_read_reg(struct gspca_dev *gspca_dev, u16 index, int verbose)
 812 {
 813         struct usb_device *udev = gspca_dev->dev;
 814         __u8 *buf = gspca_dev->usb_buf;
 815         int res;
 816
 817         res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01,
 818                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
 819                         0x00, index, buf, 8, 1000);
 820         if (res < 0) {
 821                 pr_err("Failed to read a register (index 0x%04X, error %d)\n",
 822                        index, res);
 823                 return res;
 824         }
 825
 826         if (verbose)
 827                 PDEBUG(D_PROBE, "Register %04x value: %02x", index, buf[0]);
 828
 829         return 0;
 830 }
 831
 832 /*
 833  * cit_send_FF_04_02()
 834  *
 835  * This procedure sends magic 3-command prefix to the camera.
 836  * The purpose of this prefix is not known.
 837  *
 838  * History:
 839  * 1/2/00   Created.
 840  */
 841 static void cit_send_FF_04_02(struct gspca_dev *gspca_dev)
 842 {
 843         cit_write_reg(gspca_dev, 0x00FF, 0x0127);
 844         cit_write_reg(gspca_dev, 0x0004, 0x0124);
 845         cit_write_reg(gspca_dev, 0x0002, 0x0124);
 846 }
 847
 848 static void cit_send_00_04_06(struct gspca_dev *gspca_dev)
 849 {
 850         cit_write_reg(gspca_dev, 0x0000, 0x0127);
 851         cit_write_reg(gspca_dev, 0x0004, 0x0124);
 852         cit_write_reg(gspca_dev, 0x0006, 0x0124);
 853 }
 854
 855 static void cit_send_x_00(struct gspca_dev *gspca_dev, unsigned short x)
 856 {
 857         cit_write_reg(gspca_dev, x,      0x0127);
 858         cit_write_reg(gspca_dev, 0x0000, 0x0124);
 859 }
 860
 861 static void cit_send_x_00_05(struct gspca_dev *gspca_dev, unsigned short x)
 862 {
 863         cit_send_x_00(gspca_dev, x);
 864         cit_write_reg(gspca_dev, 0x0005, 0x0124);
 865 }
 866
 867 static void cit_send_x_00_05_02(struct gspca_dev *gspca_dev, unsigned short x)
 868 {
 869         cit_write_reg(gspca_dev, x,      0x0127);
 870         cit_write_reg(gspca_dev, 0x0000, 0x0124);
 871         cit_write_reg(gspca_dev, 0x0005, 0x0124);
 872         cit_write_reg(gspca_dev, 0x0002, 0x0124);
 873 }
 874
 875 static void cit_send_x_01_00_05(struct gspca_dev *gspca_dev, u16 x)
 876 {
 877         cit_write_reg(gspca_dev, x,      0x0127);
 878         cit_write_reg(gspca_dev, 0x0001, 0x0124);
 879         cit_write_reg(gspca_dev, 0x0000, 0x0124);
 880         cit_write_reg(gspca_dev, 0x0005, 0x0124);
 881 }
 882
 883 static void cit_send_x_00_05_02_01(struct gspca_dev *gspca_dev, u16 x)
 884 {
 885         cit_write_reg(gspca_dev, x,      0x0127);
 886         cit_write_reg(gspca_dev, 0x0000, 0x0124);
 887         cit_write_reg(gspca_dev, 0x0005, 0x0124);
 888         cit_write_reg(gspca_dev, 0x0002, 0x0124);
 889         cit_write_reg(gspca_dev, 0x0001, 0x0124);
 890 }
 891
 892 static void cit_send_x_00_05_02_08_01(struct gspca_dev *gspca_dev, u16 x)
 893 {
 894         cit_write_reg(gspca_dev, x,      0x0127);
 895         cit_write_reg(gspca_dev, 0x0000, 0x0124);
 896         cit_write_reg(gspca_dev, 0x0005, 0x0124);
 897         cit_write_reg(gspca_dev, 0x0002, 0x0124);
 898         cit_write_reg(gspca_dev, 0x0008, 0x0124);
 899         cit_write_reg(gspca_dev, 0x0001, 0x0124);
 900 }
 901
 902 static void cit_Packet_Format1(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
 903 {
 904         cit_send_x_01_00_05(gspca_dev, 0x0088);
 905         cit_send_x_00_05(gspca_dev, fkey);
 906         cit_send_x_00_05_02_08_01(gspca_dev, val);
 907         cit_send_x_00_05(gspca_dev, 0x0088);
 908         cit_send_x_00_05_02_01(gspca_dev, fkey);
 909         cit_send_x_00_05(gspca_dev, 0x0089);
 910         cit_send_x_00(gspca_dev, fkey);
 911         cit_send_00_04_06(gspca_dev);
 912         cit_read_reg(gspca_dev, 0x0126, 0);
 913         cit_send_FF_04_02(gspca_dev);
 914 }
 915
 916 static void cit_PacketFormat2(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
 917 {
 918         cit_send_x_01_00_05(gspca_dev, 0x0088);
 919         cit_send_x_00_05(gspca_dev, fkey);
 920         cit_send_x_00_05_02(gspca_dev, val);
 921 }
 922
 923 static void cit_model2_Packet2(struct gspca_dev *gspca_dev)
 924 {
 925         cit_write_reg(gspca_dev, 0x00ff, 0x012d);
 926         cit_write_reg(gspca_dev, 0xfea3, 0x0124);
 927 }
 928
 929 static void cit_model2_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
 930 {
 931         cit_write_reg(gspca_dev, 0x00aa, 0x012d);
 932         cit_write_reg(gspca_dev, 0x00ff, 0x012e);
 933         cit_write_reg(gspca_dev, v1,     0x012f);
 934         cit_write_reg(gspca_dev, 0x00ff, 0x0130);
 935         cit_write_reg(gspca_dev, 0xc719, 0x0124);
 936         cit_write_reg(gspca_dev, v2,     0x0127);
 937
 938         cit_model2_Packet2(gspca_dev);
 939 }
 940
 941 /*
 942  * cit_model3_Packet1()
 943  *
 944  * 00_0078_012d
 945  * 00_0097_012f
 946  * 00_d141_0124
 947  * 00_0096_0127
 948  * 00_fea8_0124
 949 */
 950 static void cit_model3_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
 951 {
 952         cit_write_reg(gspca_dev, 0x0078, 0x012d);
 953         cit_write_reg(gspca_dev, v1,     0x012f);
 954         cit_write_reg(gspca_dev, 0xd141, 0x0124);
 955         cit_write_reg(gspca_dev, v2,     0x0127);
 956         cit_write_reg(gspca_dev, 0xfea8, 0x0124);
 957 }
 958
 959 static void cit_model4_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
 960 {
 961         cit_write_reg(gspca_dev, 0x00aa, 0x012d);
 962         cit_write_reg(gspca_dev, v1,     0x012f);
 963         cit_write_reg(gspca_dev, 0xd141, 0x0124);
 964         cit_write_reg(gspca_dev, v2,     0x0127);
 965         cit_write_reg(gspca_dev, 0xfea8, 0x0124);
 966 }
 967
 968 static void cit_model4_BrightnessPacket(struct gspca_dev *gspca_dev, u16 val)
 969 {
 970         cit_write_reg(gspca_dev, 0x00aa, 0x012d);
 971         cit_write_reg(gspca_dev, 0x0026, 0x012f);
 972         cit_write_reg(gspca_dev, 0xd141, 0x0124);
 973         cit_write_reg(gspca_dev, val,    0x0127);
 974         cit_write_reg(gspca_dev, 0x00aa, 0x0130);
 975         cit_write_reg(gspca_dev, 0x82a8, 0x0124);
 976         cit_write_reg(gspca_dev, 0x0038, 0x012d);
 977         cit_write_reg(gspca_dev, 0x0004, 0x012f);
 978         cit_write_reg(gspca_dev, 0xd145, 0x0124);
 979         cit_write_reg(gspca_dev, 0xfffa, 0x0124);
 980 }
 981
 982 /* this function is called at probe time */
 983 static int sd_config(struct gspca_dev *gspca_dev,
 984                      const struct usb_device_id *id)
 985 {
 986         struct sd *sd = (struct sd *) gspca_dev;
 987         struct cam *cam;
 988
 989         sd->model = id->driver_info;
 990         if (sd->model == CIT_MODEL3 && ibm_netcam_pro)
 991                 sd->model = CIT_IBM_NETCAM_PRO;
 992
 993         cam = &gspca_dev->cam;
 994         switch (sd->model) {
 995         case CIT_MODEL0:
 996                 cam->cam_mode = model0_mode;
 997                 cam->nmodes = ARRAY_SIZE(model0_mode);
 998                 cam->reverse_alts = 1;
 999                 gspca_dev->ctrl_dis = ~((1 << SD_CONTRAST) | (1 << SD_HFLIP));
1000                 sd->sof_len = 4;
1001                 break;
1002         case CIT_MODEL1:
1003                 cam->cam_mode = cif_yuv_mode;
1004                 cam->nmodes = ARRAY_SIZE(cif_yuv_mode);
1005                 cam->reverse_alts = 1;
1006                 gspca_dev->ctrl_dis = (1 << SD_HUE) | (1 << SD_HFLIP);
1007                 sd->sof_len = 4;
1008                 break;
1009         case CIT_MODEL2:
1010                 cam->cam_mode = model2_mode + 1; /* no 160x120 */
1011                 cam->nmodes = 3;
1012                 gspca_dev->ctrl_dis = (1 << SD_CONTRAST) |
1013                                       (1 << SD_SHARPNESS) |
1014                                       (1 << SD_HFLIP);
1015                 break;
1016         case CIT_MODEL3:
1017                 cam->cam_mode = vga_yuv_mode;
1018                 cam->nmodes = ARRAY_SIZE(vga_yuv_mode);
1019                 gspca_dev->ctrl_dis = (1 << SD_HUE) |
1020                                       (1 << SD_LIGHTING) |
1021                                       (1 << SD_HFLIP);
1022                 sd->stop_on_control_change = 1;
1023                 sd->sof_len = 4;
1024                 break;
1025         case CIT_MODEL4:
1026                 cam->cam_mode = model2_mode;
1027                 cam->nmodes = ARRAY_SIZE(model2_mode);
1028                 gspca_dev->ctrl_dis = (1 << SD_CONTRAST) |
1029                                       (1 << SD_SHARPNESS) |
1030                                       (1 << SD_LIGHTING) |
1031                                       (1 << SD_HFLIP);
1032                 break;
1033         case CIT_IBM_NETCAM_PRO:
1034                 cam->cam_mode = vga_yuv_mode;
1035                 cam->nmodes = 2; /* no 640 x 480 */
1036                 cam->input_flags = V4L2_IN_ST_VFLIP;
1037                 gspca_dev->ctrl_dis = ~(1 << SD_CONTRAST);
1038                 sd->stop_on_control_change = 1;
1039                 sd->sof_len = 4;
1040                 break;
1041         }
1042
1043         sd->brightness = BRIGHTNESS_DEFAULT;
1044         sd->contrast = CONTRAST_DEFAULT;
1045         sd->hue = HUE_DEFAULT;
1046         sd->sharpness = SHARPNESS_DEFAULT;
1047         sd->lighting = LIGHTING_DEFAULT;
1048         sd->hflip = HFLIP_DEFAULT;
1049
1050         return 0;
1051 }
1052
1053 static int cit_init_model0(struct gspca_dev *gspca_dev)
1054 {
1055         cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
1056         cit_write_reg(gspca_dev, 0x0001, 0x0112); /* turn on autogain ? */
1057         cit_write_reg(gspca_dev, 0x0000, 0x0400);
1058         cit_write_reg(gspca_dev, 0x0001, 0x0400);
1059         cit_write_reg(gspca_dev, 0x0000, 0x0420);
1060         cit_write_reg(gspca_dev, 0x0001, 0x0420);
1061         cit_write_reg(gspca_dev, 0x000d, 0x0409);
1062         cit_write_reg(gspca_dev, 0x0002, 0x040a);
1063         cit_write_reg(gspca_dev, 0x0018, 0x0405);
1064         cit_write_reg(gspca_dev, 0x0008, 0x0435);
1065         cit_write_reg(gspca_dev, 0x0026, 0x040b);
1066         cit_write_reg(gspca_dev, 0x0007, 0x0437);
1067         cit_write_reg(gspca_dev, 0x0015, 0x042f);
1068         cit_write_reg(gspca_dev, 0x002b, 0x0439);
1069         cit_write_reg(gspca_dev, 0x0026, 0x043a);
1070         cit_write_reg(gspca_dev, 0x0008, 0x0438);
1071         cit_write_reg(gspca_dev, 0x001e, 0x042b);
1072         cit_write_reg(gspca_dev, 0x0041, 0x042c);
1073
1074         return 0;
1075 }
1076
1077 static int cit_init_ibm_netcam_pro(struct gspca_dev *gspca_dev)
1078 {
1079         cit_read_reg(gspca_dev, 0x128, 1);
1080         cit_write_reg(gspca_dev, 0x0003, 0x0133);
1081         cit_write_reg(gspca_dev, 0x0000, 0x0117);
1082         cit_write_reg(gspca_dev, 0x0008, 0x0123);
1083         cit_write_reg(gspca_dev, 0x0000, 0x0100);
1084         cit_read_reg(gspca_dev, 0x0116, 0);
1085         cit_write_reg(gspca_dev, 0x0060, 0x0116);
1086         cit_write_reg(gspca_dev, 0x0002, 0x0112);
1087         cit_write_reg(gspca_dev, 0x0000, 0x0133);
1088         cit_write_reg(gspca_dev, 0x0000, 0x0123);
1089         cit_write_reg(gspca_dev, 0x0001, 0x0117);
1090         cit_write_reg(gspca_dev, 0x0040, 0x0108);
1091         cit_write_reg(gspca_dev, 0x0019, 0x012c);
1092         cit_write_reg(gspca_dev, 0x0060, 0x0116);
1093         cit_write_reg(gspca_dev, 0x0002, 0x0115);
1094         cit_write_reg(gspca_dev, 0x000b, 0x0115);
1095
1096         cit_write_reg(gspca_dev, 0x0078, 0x012d);
1097         cit_write_reg(gspca_dev, 0x0001, 0x012f);
1098         cit_write_reg(gspca_dev, 0xd141, 0x0124);
1099         cit_write_reg(gspca_dev, 0x0079, 0x012d);
1100         cit_write_reg(gspca_dev, 0x00ff, 0x0130);
1101         cit_write_reg(gspca_dev, 0xcd41, 0x0124);
1102         cit_write_reg(gspca_dev, 0xfffa, 0x0124);
1103         cit_read_reg(gspca_dev, 0x0126, 1);
1104
1105         cit_model3_Packet1(gspca_dev, 0x0000, 0x0000);
1106         cit_model3_Packet1(gspca_dev, 0x0000, 0x0001);
1107         cit_model3_Packet1(gspca_dev, 0x000b, 0x0000);
1108         cit_model3_Packet1(gspca_dev, 0x000c, 0x0008);
1109         cit_model3_Packet1(gspca_dev, 0x000d, 0x003a);
1110         cit_model3_Packet1(gspca_dev, 0x000e, 0x0060);
1111         cit_model3_Packet1(gspca_dev, 0x000f, 0x0060);
1112         cit_model3_Packet1(gspca_dev, 0x0010, 0x0008);
1113         cit_model3_Packet1(gspca_dev, 0x0011, 0x0004);
1114         cit_model3_Packet1(gspca_dev, 0x0012, 0x0028);
1115         cit_model3_Packet1(gspca_dev, 0x0013, 0x0002);
1116         cit_model3_Packet1(gspca_dev, 0x0014, 0x0000);
1117         cit_model3_Packet1(gspca_dev, 0x0015, 0x00fb);
1118         cit_model3_Packet1(gspca_dev, 0x0016, 0x0002);
1119         cit_model3_Packet1(gspca_dev, 0x0017, 0x0037);
1120         cit_model3_Packet1(gspca_dev, 0x0018, 0x0036);
1121         cit_model3_Packet1(gspca_dev, 0x001e, 0x0000);
1122         cit_model3_Packet1(gspca_dev, 0x001f, 0x0008);
1123         cit_model3_Packet1(gspca_dev, 0x0020, 0x00c1);
1124         cit_model3_Packet1(gspca_dev, 0x0021, 0x0034);
1125         cit_model3_Packet1(gspca_dev, 0x0022, 0x0034);
1126         cit_model3_Packet1(gspca_dev, 0x0025, 0x0002);
1127         cit_model3_Packet1(gspca_dev, 0x0028, 0x0022);
1128         cit_model3_Packet1(gspca_dev, 0x0029, 0x000a);
1129         cit_model3_Packet1(gspca_dev, 0x002b, 0x0000);
1130         cit_model3_Packet1(gspca_dev, 0x002c, 0x0000);
1131         cit_model3_Packet1(gspca_dev, 0x002d, 0x00ff);
1132         cit_model3_Packet1(gspca_dev, 0x002e, 0x00ff);
1133         cit_model3_Packet1(gspca_dev, 0x002f, 0x00ff);
1134         cit_model3_Packet1(gspca_dev, 0x0030, 0x00ff);
1135         cit_model3_Packet1(gspca_dev, 0x0031, 0x00ff);
1136         cit_model3_Packet1(gspca_dev, 0x0032, 0x0007);
1137         cit_model3_Packet1(gspca_dev, 0x0033, 0x0005);
1138         cit_model3_Packet1(gspca_dev, 0x0037, 0x0040);
1139         cit_model3_Packet1(gspca_dev, 0x0039, 0x0000);
1140         cit_model3_Packet1(gspca_dev, 0x003a, 0x0000);
1141         cit_model3_Packet1(gspca_dev, 0x003b, 0x0001);
1142         cit_model3_Packet1(gspca_dev, 0x003c, 0x0000);
1143         cit_model3_Packet1(gspca_dev, 0x0040, 0x000c);
1144         cit_model3_Packet1(gspca_dev, 0x0041, 0x00fb);
1145         cit_model3_Packet1(gspca_dev, 0x0042, 0x0002);
1146         cit_model3_Packet1(gspca_dev, 0x0043, 0x0000);
1147         cit_model3_Packet1(gspca_dev, 0x0045, 0x0000);
1148         cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
1149         cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
1150         cit_model3_Packet1(gspca_dev, 0x0048, 0x0000);
1151         cit_model3_Packet1(gspca_dev, 0x0049, 0x0000);
1152         cit_model3_Packet1(gspca_dev, 0x004a, 0x00ff);
1153         cit_model3_Packet1(gspca_dev, 0x004b, 0x00ff);
1154         cit_model3_Packet1(gspca_dev, 0x004c, 0x00ff);
1155         cit_model3_Packet1(gspca_dev, 0x004f, 0x0000);
1156         cit_model3_Packet1(gspca_dev, 0x0050, 0x0000);
1157         cit_model3_Packet1(gspca_dev, 0x0051, 0x0002);
1158         cit_model3_Packet1(gspca_dev, 0x0055, 0x0000);
1159         cit_model3_Packet1(gspca_dev, 0x0056, 0x0000);
1160         cit_model3_Packet1(gspca_dev, 0x0057, 0x0000);
1161         cit_model3_Packet1(gspca_dev, 0x0058, 0x0002);
1162         cit_model3_Packet1(gspca_dev, 0x0059, 0x0000);
1163         cit_model3_Packet1(gspca_dev, 0x005c, 0x0016);
1164         cit_model3_Packet1(gspca_dev, 0x005d, 0x0022);
1165         cit_model3_Packet1(gspca_dev, 0x005e, 0x003c);
1166         cit_model3_Packet1(gspca_dev, 0x005f, 0x0050);
1167         cit_model3_Packet1(gspca_dev, 0x0060, 0x0044);
1168         cit_model3_Packet1(gspca_dev, 0x0061, 0x0005);
1169         cit_model3_Packet1(gspca_dev, 0x006a, 0x007e);
1170         cit_model3_Packet1(gspca_dev, 0x006f, 0x0000);
1171         cit_model3_Packet1(gspca_dev, 0x0072, 0x001b);
1172         cit_model3_Packet1(gspca_dev, 0x0073, 0x0005);
1173         cit_model3_Packet1(gspca_dev, 0x0074, 0x000a);
1174         cit_model3_Packet1(gspca_dev, 0x0075, 0x001b);
1175         cit_model3_Packet1(gspca_dev, 0x0076, 0x002a);
1176         cit_model3_Packet1(gspca_dev, 0x0077, 0x003c);
1177         cit_model3_Packet1(gspca_dev, 0x0078, 0x0050);
1178         cit_model3_Packet1(gspca_dev, 0x007b, 0x0000);
1179         cit_model3_Packet1(gspca_dev, 0x007c, 0x0011);
1180         cit_model3_Packet1(gspca_dev, 0x007d, 0x0024);
1181         cit_model3_Packet1(gspca_dev, 0x007e, 0x0043);
1182         cit_model3_Packet1(gspca_dev, 0x007f, 0x005a);
1183         cit_model3_Packet1(gspca_dev, 0x0084, 0x0020);
1184         cit_model3_Packet1(gspca_dev, 0x0085, 0x0033);
1185         cit_model3_Packet1(gspca_dev, 0x0086, 0x000a);
1186         cit_model3_Packet1(gspca_dev, 0x0087, 0x0030);
1187         cit_model3_Packet1(gspca_dev, 0x0088, 0x0070);
1188         cit_model3_Packet1(gspca_dev, 0x008b, 0x0008);
1189         cit_model3_Packet1(gspca_dev, 0x008f, 0x0000);
1190         cit_model3_Packet1(gspca_dev, 0x0090, 0x0006);
1191         cit_model3_Packet1(gspca_dev, 0x0091, 0x0028);
1192         cit_model3_Packet1(gspca_dev, 0x0092, 0x005a);
1193         cit_model3_Packet1(gspca_dev, 0x0093, 0x0082);
1194         cit_model3_Packet1(gspca_dev, 0x0096, 0x0014);
1195         cit_model3_Packet1(gspca_dev, 0x0097, 0x0020);
1196         cit_model3_Packet1(gspca_dev, 0x0098, 0x0000);
1197         cit_model3_Packet1(gspca_dev, 0x00b0, 0x0046);
1198         cit_model3_Packet1(gspca_dev, 0x00b1, 0x0000);
1199         cit_model3_Packet1(gspca_dev, 0x00b2, 0x0000);
1200         cit_model3_Packet1(gspca_dev, 0x00b3, 0x0004);
1201         cit_model3_Packet1(gspca_dev, 0x00b4, 0x0007);
1202         cit_model3_Packet1(gspca_dev, 0x00b6, 0x0002);
1203         cit_model3_Packet1(gspca_dev, 0x00b7, 0x0004);
1204         cit_model3_Packet1(gspca_dev, 0x00bb, 0x0000);
1205         cit_model3_Packet1(gspca_dev, 0x00bc, 0x0001);
1206         cit_model3_Packet1(gspca_dev, 0x00bd, 0x0000);
1207         cit_model3_Packet1(gspca_dev, 0x00bf, 0x0000);
1208         cit_model3_Packet1(gspca_dev, 0x00c0, 0x00c8);
1209         cit_model3_Packet1(gspca_dev, 0x00c1, 0x0014);
1210         cit_model3_Packet1(gspca_dev, 0x00c2, 0x0001);
1211         cit_model3_Packet1(gspca_dev, 0x00c3, 0x0000);
1212         cit_model3_Packet1(gspca_dev, 0x00c4, 0x0004);
1213         cit_model3_Packet1(gspca_dev, 0x00cb, 0x00bf);
1214         cit_model3_Packet1(gspca_dev, 0x00cc, 0x00bf);
1215         cit_model3_Packet1(gspca_dev, 0x00cd, 0x00bf);
1216         cit_model3_Packet1(gspca_dev, 0x00ce, 0x0000);
1217         cit_model3_Packet1(gspca_dev, 0x00cf, 0x0020);
1218         cit_model3_Packet1(gspca_dev, 0x00d0, 0x0040);
1219         cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf);
1220         cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf);
1221         cit_model3_Packet1(gspca_dev, 0x00d2, 0x00bf);
1222         cit_model3_Packet1(gspca_dev, 0x00d3, 0x00bf);
1223         cit_model3_Packet1(gspca_dev, 0x00ea, 0x0008);
1224         cit_model3_Packet1(gspca_dev, 0x00eb, 0x0000);
1225         cit_model3_Packet1(gspca_dev, 0x00ec, 0x00e8);
1226         cit_model3_Packet1(gspca_dev, 0x00ed, 0x0001);
1227         cit_model3_Packet1(gspca_dev, 0x00ef, 0x0022);
1228         cit_model3_Packet1(gspca_dev, 0x00f0, 0x0000);
1229         cit_model3_Packet1(gspca_dev, 0x00f2, 0x0028);
1230         cit_model3_Packet1(gspca_dev, 0x00f4, 0x0002);
1231         cit_model3_Packet1(gspca_dev, 0x00f5, 0x0000);
1232         cit_model3_Packet1(gspca_dev, 0x00fa, 0x0000);
1233         cit_model3_Packet1(gspca_dev, 0x00fb, 0x0001);
1234         cit_model3_Packet1(gspca_dev, 0x00fc, 0x0000);
1235         cit_model3_Packet1(gspca_dev, 0x00fd, 0x0000);
1236         cit_model3_Packet1(gspca_dev, 0x00fe, 0x0000);
1237         cit_model3_Packet1(gspca_dev, 0x00ff, 0x0000);
1238
1239         cit_model3_Packet1(gspca_dev, 0x00be, 0x0003);
1240         cit_model3_Packet1(gspca_dev, 0x00c8, 0x0000);
1241         cit_model3_Packet1(gspca_dev, 0x00c9, 0x0020);
1242         cit_model3_Packet1(gspca_dev, 0x00ca, 0x0040);
1243         cit_model3_Packet1(gspca_dev, 0x0053, 0x0001);
1244         cit_model3_Packet1(gspca_dev, 0x0082, 0x000e);
1245         cit_model3_Packet1(gspca_dev, 0x0083, 0x0020);
1246         cit_model3_Packet1(gspca_dev, 0x0034, 0x003c);
1247         cit_model3_Packet1(gspca_dev, 0x006e, 0x0055);
1248         cit_model3_Packet1(gspca_dev, 0x0062, 0x0005);
1249         cit_model3_Packet1(gspca_dev, 0x0063, 0x0008);
1250         cit_model3_Packet1(gspca_dev, 0x0066, 0x000a);
1251         cit_model3_Packet1(gspca_dev, 0x0067, 0x0006);
1252         cit_model3_Packet1(gspca_dev, 0x006b, 0x0010);
1253         cit_model3_Packet1(gspca_dev, 0x005a, 0x0001);
1254         cit_model3_Packet1(gspca_dev, 0x005b, 0x000a);
1255         cit_model3_Packet1(gspca_dev, 0x0023, 0x0006);
1256         cit_model3_Packet1(gspca_dev, 0x0026, 0x0004);
1257         cit_model3_Packet1(gspca_dev, 0x0036, 0x0069);
1258         cit_model3_Packet1(gspca_dev, 0x0038, 0x0064);
1259         cit_model3_Packet1(gspca_dev, 0x003d, 0x0003);
1260         cit_model3_Packet1(gspca_dev, 0x003e, 0x0001);
1261         cit_model3_Packet1(gspca_dev, 0x00b8, 0x0014);
1262         cit_model3_Packet1(gspca_dev, 0x00b9, 0x0014);
1263         cit_model3_Packet1(gspca_dev, 0x00e6, 0x0004);
1264         cit_model3_Packet1(gspca_dev, 0x00e8, 0x0001);
1265
1266         return 0;
1267 }
1268
1269 /* this function is called at probe and resume time */
1270 static int sd_init(struct gspca_dev *gspca_dev)
1271 {
1272         struct sd *sd = (struct sd *) gspca_dev;
1273
1274         switch (sd->model) {
1275         case CIT_MODEL0:
1276                 cit_init_model0(gspca_dev);
1277                 sd_stop0(gspca_dev);
1278                 break;
1279         case CIT_MODEL1:
1280         case CIT_MODEL2:
1281         case CIT_MODEL3:
1282         case CIT_MODEL4:
1283                 break; /* All is done in sd_start */
1284         case CIT_IBM_NETCAM_PRO:
1285                 cit_init_ibm_netcam_pro(gspca_dev);
1286                 sd_stop0(gspca_dev);
1287                 break;
1288         }
1289         return 0;
1290 }
1291
1292 static int cit_set_brightness(struct gspca_dev *gspca_dev)
1293 {
1294         struct sd *sd = (struct sd *) gspca_dev;
1295         int i;
1296
1297         switch (sd->model) {
1298         case CIT_MODEL0:
1299         case CIT_IBM_NETCAM_PRO:
1300                 /* No (known) brightness control for these */
1301                 break;
1302         case CIT_MODEL1:
1303                 /* Model 1: Brightness range 0 - 63 */
1304                 cit_Packet_Format1(gspca_dev, 0x0031, sd->brightness);
1305                 cit_Packet_Format1(gspca_dev, 0x0032, sd->brightness);
1306                 cit_Packet_Format1(gspca_dev, 0x0033, sd->brightness);
1307                 break;
1308         case CIT_MODEL2:
1309                 /* Model 2: Brightness range 0x60 - 0xee */
1310                 /* Scale 0 - 63 to 0x60 - 0xee */
1311                 i = 0x60 + sd->brightness * 2254 / 1000;
1312                 cit_model2_Packet1(gspca_dev, 0x001a, i);
1313                 break;
1314         case CIT_MODEL3:
1315                 /* Model 3: Brightness range 'i' in [0x0C..0x3F] */
1316                 i = sd->brightness;
1317                 if (i < 0x0c)
1318                         i = 0x0c;
1319                 cit_model3_Packet1(gspca_dev, 0x0036, i);
1320                 break;
1321         case CIT_MODEL4:
1322                 /* Model 4: Brightness range 'i' in [0x04..0xb4] */
1323                 /* Scale 0 - 63 to 0x04 - 0xb4 */
1324                 i = 0x04 + sd->brightness * 2794 / 1000;
1325                 cit_model4_BrightnessPacket(gspca_dev, i);
1326                 break;
1327         }
1328
1329         return 0;
1330 }
1331
1332 static int cit_set_contrast(struct gspca_dev *gspca_dev)
1333 {
1334         struct sd *sd = (struct sd *) gspca_dev;
1335
1336         switch (sd->model) {
1337         case CIT_MODEL0: {
1338                 int i;
1339                 /* gain 0-15, 0-20 -> 0-15 */
1340                 i = sd->contrast * 1000 / 1333;
1341                 cit_write_reg(gspca_dev, i, 0x0422);
1342                 /* gain 0-31, may not be lower then 0x0422, 0-20 -> 0-31 */
1343                 i = sd->contrast * 2000 / 1333;
1344                 cit_write_reg(gspca_dev, i, 0x0423);
1345                 /* gain 0-127, may not be lower then 0x0423, 0-20 -> 0-63  */
1346                 i = sd->contrast * 4000 / 1333;
1347                 cit_write_reg(gspca_dev, i, 0x0424);
1348                 /* gain 0-127, may not be lower then 0x0424, , 0-20 -> 0-127 */
1349                 i = sd->contrast * 8000 / 1333;
1350                 cit_write_reg(gspca_dev, i, 0x0425);
1351                 break;
1352         }
1353         case CIT_MODEL2:
1354         case CIT_MODEL4:
1355                 /* These models do not have this control. */
1356                 break;
1357         case CIT_MODEL1:
1358         {
1359                 /* Scale 0 - 20 to 15 - 0 */
1360                 int i, new_contrast = (20 - sd->contrast) * 1000 / 1333;
1361                 for (i = 0; i < cit_model1_ntries; i++) {
1362                         cit_Packet_Format1(gspca_dev, 0x0014, new_contrast);
1363                         cit_send_FF_04_02(gspca_dev);
1364                 }
1365                 break;
1366         }
1367         case CIT_MODEL3:
1368         {       /* Preset hardware values */
1369                 static const struct {
1370                         unsigned short cv1;
1371                         unsigned short cv2;
1372                         unsigned short cv3;
1373                 } cv[7] = {
1374                         { 0x05, 0x05, 0x0f },   /* Minimum */
1375                         { 0x04, 0x04, 0x16 },
1376                         { 0x02, 0x03, 0x16 },
1377                         { 0x02, 0x08, 0x16 },
1378                         { 0x01, 0x0c, 0x16 },
1379                         { 0x01, 0x0e, 0x16 },
1380                         { 0x01, 0x10, 0x16 }    /* Maximum */
1381                 };
1382                 int i = sd->contrast / 3;
1383                 cit_model3_Packet1(gspca_dev, 0x0067, cv[i].cv1);
1384                 cit_model3_Packet1(gspca_dev, 0x005b, cv[i].cv2);
1385                 cit_model3_Packet1(gspca_dev, 0x005c, cv[i].cv3);
1386                 break;
1387         }
1388         case CIT_IBM_NETCAM_PRO:
1389                 cit_model3_Packet1(gspca_dev, 0x005b, sd->contrast + 1);
1390                 break;
1391         }
1392         return 0;
1393 }
1394
1395 static int cit_set_hue(struct gspca_dev *gspca_dev)
1396 {
1397         struct sd *sd = (struct sd *) gspca_dev;
1398
1399         switch (sd->model) {
1400         case CIT_MODEL0:
1401         case CIT_MODEL1:
1402         case CIT_IBM_NETCAM_PRO:
1403                 /* No hue control for these models */
1404                 break;
1405         case CIT_MODEL2:
1406                 cit_model2_Packet1(gspca_dev, 0x0024, sd->hue);
1407                 /* cit_model2_Packet1(gspca_dev, 0x0020, sat); */
1408                 break;
1409         case CIT_MODEL3: {
1410                 /* Model 3: Brightness range 'i' in [0x05..0x37] */
1411                 /* TESTME according to the ibmcam driver this does not work */
1412                 if (0) {
1413                         /* Scale 0 - 127 to 0x05 - 0x37 */
1414                         int i = 0x05 + sd->hue * 1000 / 2540;
1415                         cit_model3_Packet1(gspca_dev, 0x007e, i);
1416                 }
1417                 break;
1418         }
1419         case CIT_MODEL4:
1420                 /* HDG: taken from ibmcam, setting the color gains does not
1421                  * really belong here.
1422                  *
1423                  * I am not sure r/g/b_gain variables exactly control gain
1424                  * of those channels. Most likely they subtly change some
1425                  * very internal image processing settings in the camera.
1426                  * In any case, here is what they do, and feel free to tweak:
1427                  *
1428                  * r_gain: seriously affects red gain
1429                  * g_gain: seriously affects green gain
1430                  * b_gain: seriously affects blue gain
1431                  * hue: changes average color from violet (0) to red (0xFF)
1432                  */
1433                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
1434                 cit_write_reg(gspca_dev, 0x001e, 0x012f);
1435                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
1436                 cit_write_reg(gspca_dev,    160, 0x0127);  /* Green gain */
1437                 cit_write_reg(gspca_dev,    160, 0x012e);  /* Red gain */
1438                 cit_write_reg(gspca_dev,    160, 0x0130);  /* Blue gain */
1439                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
1440                 cit_write_reg(gspca_dev, sd->hue, 0x012d); /* Hue */
1441                 cit_write_reg(gspca_dev, 0xf545, 0x0124);
1442                 break;
1443         }
1444         return 0;
1445 }
1446
1447 static int cit_set_sharpness(struct gspca_dev *gspca_dev)
1448 {
1449         struct sd *sd = (struct sd *) gspca_dev;
1450
1451         switch (sd->model) {
1452         case CIT_MODEL0:
1453         case CIT_MODEL2:
1454         case CIT_MODEL4:
1455         case CIT_IBM_NETCAM_PRO:
1456                 /* These models do not have this control */
1457                 break;
1458         case CIT_MODEL1: {
1459                 int i;
1460                 const unsigned short sa[] = {
1461                         0x11, 0x13, 0x16, 0x18, 0x1a, 0x8, 0x0a };
1462
1463                 for (i = 0; i < cit_model1_ntries; i++)
1464                         cit_PacketFormat2(gspca_dev, 0x0013, sa[sd->sharpness]);
1465                 break;
1466         }
1467         case CIT_MODEL3:
1468         {       /*
1469                  * "Use a table of magic numbers.
1470                  *  This setting doesn't really change much.
1471                  *  But that's how Windows does it."
1472                  */
1473                 static const struct {
1474                         unsigned short sv1;
1475                         unsigned short sv2;
1476                         unsigned short sv3;
1477                         unsigned short sv4;
1478                 } sv[7] = {
1479                         { 0x00, 0x00, 0x05, 0x14 },     /* Smoothest */
1480                         { 0x01, 0x04, 0x05, 0x14 },
1481                         { 0x02, 0x04, 0x05, 0x14 },
1482                         { 0x03, 0x04, 0x05, 0x14 },
1483                         { 0x03, 0x05, 0x05, 0x14 },
1484                         { 0x03, 0x06, 0x05, 0x14 },
1485                         { 0x03, 0x07, 0x05, 0x14 }      /* Sharpest */
1486                 };
1487                 cit_model3_Packet1(gspca_dev, 0x0060, sv[sd->sharpness].sv1);
1488                 cit_model3_Packet1(gspca_dev, 0x0061, sv[sd->sharpness].sv2);
1489                 cit_model3_Packet1(gspca_dev, 0x0062, sv[sd->sharpness].sv3);
1490                 cit_model3_Packet1(gspca_dev, 0x0063, sv[sd->sharpness].sv4);
1491                 break;
1492         }
1493         }
1494         return 0;
1495 }
1496
1497 /*
1498  * cit_set_lighting()
1499  *
1500  * Camera model 1:
1501  * We have 3 levels of lighting conditions: 0=Bright, 1=Medium, 2=Low.
1502  *
1503  * Camera model 2:
1504  * We have 16 levels of lighting, 0 for bright light and up to 15 for
1505  * low light. But values above 5 or so are useless because camera is
1506  * not really capable to produce anything worth viewing at such light.
1507  * This setting may be altered only in certain camera state.
1508  *
1509  * Low lighting forces slower FPS.
1510  *
1511  * History:
1512  * 1/5/00   Created.
1513  * 2/20/00  Added support for Model 2 cameras.
1514  */
1515 static void cit_set_lighting(struct gspca_dev *gspca_dev)
1516 {
1517         struct sd *sd = (struct sd *) gspca_dev;
1518
1519         switch (sd->model) {
1520         case CIT_MODEL0:
1521         case CIT_MODEL2:
1522         case CIT_MODEL3:
1523         case CIT_MODEL4:
1524         case CIT_IBM_NETCAM_PRO:
1525                 break;
1526         case CIT_MODEL1: {
1527                 int i;
1528                 for (i = 0; i < cit_model1_ntries; i++)
1529                         cit_Packet_Format1(gspca_dev, 0x0027, sd->lighting);
1530                 break;
1531         }
1532         }
1533 }
1534
1535 static void cit_set_hflip(struct gspca_dev *gspca_dev)
1536 {
1537         struct sd *sd = (struct sd *) gspca_dev;
1538
1539         switch (sd->model) {
1540         case CIT_MODEL0:
1541                 if (sd->hflip)
1542                         cit_write_reg(gspca_dev, 0x0020, 0x0115);
1543                 else
1544                         cit_write_reg(gspca_dev, 0x0040, 0x0115);
1545                 break;
1546         case CIT_MODEL1:
1547         case CIT_MODEL2:
1548         case CIT_MODEL3:
1549         case CIT_MODEL4:
1550         case CIT_IBM_NETCAM_PRO:
1551                 break;
1552         }
1553 }
1554
1555 static int cit_restart_stream(struct gspca_dev *gspca_dev)
1556 {
1557         struct sd *sd = (struct sd *) gspca_dev;
1558
1559         switch (sd->model) {
1560         case CIT_MODEL0:
1561         case CIT_MODEL1:
1562                 cit_write_reg(gspca_dev, 0x0001, 0x0114);
1563                 /* Fall through */
1564         case CIT_MODEL2:
1565         case CIT_MODEL4:
1566                 cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */
1567                 usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe);
1568                 break;
1569         case CIT_MODEL3:
1570         case CIT_IBM_NETCAM_PRO:
1571                 cit_write_reg(gspca_dev, 0x0001, 0x0114);
1572                 cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */
1573                 usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe);
1574                 /* Clear button events from while we were not streaming */
1575                 cit_write_reg(gspca_dev, 0x0001, 0x0113);
1576                 break;
1577         }
1578
1579         sd->sof_read = 0;
1580
1581         return 0;
1582 }
1583
1584 static int cit_get_packet_size(struct gspca_dev *gspca_dev)
1585 {
1586         struct usb_host_interface *alt;
1587         struct usb_interface *intf;
1588
1589         intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
1590         alt = usb_altnum_to_altsetting(intf, gspca_dev->alt);
1591         if (!alt) {
1592                 pr_err("Couldn't get altsetting\n");
1593                 return -EIO;
1594         }
1595
1596         return le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
1597 }
1598
1599 /* Calculate the clockdiv giving us max fps given the available bandwidth */
1600 static int cit_get_clock_div(struct gspca_dev *gspca_dev)
1601 {
1602         int clock_div = 7; /* 0=30 1=25 2=20 3=15 4=12 5=7.5 6=6 7=3fps ?? */
1603         int fps[8] = { 30, 25, 20, 15, 12, 8, 6, 3 };
1604         int packet_size;
1605
1606         packet_size = cit_get_packet_size(gspca_dev);
1607         if (packet_size < 0)
1608                 return packet_size;
1609
1610         while (clock_div > 3 &&
1611                         1000 * packet_size >
1612                         gspca_dev->width * gspca_dev->height *
1613                         fps[clock_div - 1] * 3 / 2)
1614                 clock_div--;
1615
1616         PDEBUG(D_PROBE,
1617                "PacketSize: %d, res: %dx%d -> using clockdiv: %d (%d fps)",
1618                packet_size, gspca_dev->width, gspca_dev->height, clock_div,
1619                fps[clock_div]);
1620
1621         return clock_div;
1622 }
1623
1624 static int cit_start_model0(struct gspca_dev *gspca_dev)
1625 {
1626         const unsigned short compression = 0; /* 0=none, 7=best frame rate */
1627         int clock_div;
1628
1629         clock_div = cit_get_clock_div(gspca_dev);
1630         if (clock_div < 0)
1631                 return clock_div;
1632
1633         cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
1634         cit_write_reg(gspca_dev, 0x0003, 0x0438);
1635         cit_write_reg(gspca_dev, 0x001e, 0x042b);
1636         cit_write_reg(gspca_dev, 0x0041, 0x042c);
1637         cit_write_reg(gspca_dev, 0x0008, 0x0436);
1638         cit_write_reg(gspca_dev, 0x0024, 0x0403);
1639         cit_write_reg(gspca_dev, 0x002c, 0x0404);
1640         cit_write_reg(gspca_dev, 0x0002, 0x0426);
1641         cit_write_reg(gspca_dev, 0x0014, 0x0427);
1642
1643         switch (gspca_dev->width) {
1644         case 160: /* 160x120 */
1645                 cit_write_reg(gspca_dev, 0x0004, 0x010b);
1646                 cit_write_reg(gspca_dev, 0x0001, 0x010a);
1647                 cit_write_reg(gspca_dev, 0x0010, 0x0102);
1648                 cit_write_reg(gspca_dev, 0x00a0, 0x0103);
1649                 cit_write_reg(gspca_dev, 0x0000, 0x0104);
1650                 cit_write_reg(gspca_dev, 0x0078, 0x0105);
1651                 break;
1652
1653         case 176: /* 176x144 */
1654                 cit_write_reg(gspca_dev, 0x0006, 0x010b);
1655                 cit_write_reg(gspca_dev, 0x0000, 0x010a);
1656                 cit_write_reg(gspca_dev, 0x0005, 0x0102);
1657                 cit_write_reg(gspca_dev, 0x00b0, 0x0103);
1658                 cit_write_reg(gspca_dev, 0x0000, 0x0104);
1659                 cit_write_reg(gspca_dev, 0x0090, 0x0105);
1660                 break;
1661
1662         case 320: /* 320x240 */
1663                 cit_write_reg(gspca_dev, 0x0008, 0x010b);
1664                 cit_write_reg(gspca_dev, 0x0004, 0x010a);
1665                 cit_write_reg(gspca_dev, 0x0005, 0x0102);
1666                 cit_write_reg(gspca_dev, 0x00a0, 0x0103);
1667                 cit_write_reg(gspca_dev, 0x0010, 0x0104);
1668                 cit_write_reg(gspca_dev, 0x0078, 0x0105);
1669                 break;
1670         }
1671
1672         cit_write_reg(gspca_dev, compression, 0x0109);
1673         cit_write_reg(gspca_dev, clock_div, 0x0111);
1674
1675         return 0;
1676 }
1677
1678 static int cit_start_model1(struct gspca_dev *gspca_dev)
1679 {
1680         struct sd *sd = (struct sd *) gspca_dev;
1681         int i, clock_div;
1682
1683         clock_div = cit_get_clock_div(gspca_dev);
1684         if (clock_div < 0)
1685                 return clock_div;
1686
1687         cit_read_reg(gspca_dev, 0x0128, 1);
1688         cit_read_reg(gspca_dev, 0x0100, 0);
1689         cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On  */
1690         cit_read_reg(gspca_dev, 0x0100, 0);
1691         cit_write_reg(gspca_dev, 0x81, 0x0100); /* LED Off */
1692         cit_read_reg(gspca_dev, 0x0100, 0);
1693         cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On  */
1694         cit_write_reg(gspca_dev, 0x01, 0x0108);
1695
1696         cit_write_reg(gspca_dev, 0x03, 0x0112);
1697         cit_read_reg(gspca_dev, 0x0115, 0);
1698         cit_write_reg(gspca_dev, 0x06, 0x0115);
1699         cit_read_reg(gspca_dev, 0x0116, 0);
1700         cit_write_reg(gspca_dev, 0x44, 0x0116);
1701         cit_read_reg(gspca_dev, 0x0116, 0);
1702         cit_write_reg(gspca_dev, 0x40, 0x0116);
1703         cit_read_reg(gspca_dev, 0x0115, 0);
1704         cit_write_reg(gspca_dev, 0x0e, 0x0115);
1705         cit_write_reg(gspca_dev, 0x19, 0x012c);
1706
1707         cit_Packet_Format1(gspca_dev, 0x00, 0x1e);
1708         cit_Packet_Format1(gspca_dev, 0x39, 0x0d);
1709         cit_Packet_Format1(gspca_dev, 0x39, 0x09);
1710         cit_Packet_Format1(gspca_dev, 0x3b, 0x00);
1711         cit_Packet_Format1(gspca_dev, 0x28, 0x22);
1712         cit_Packet_Format1(gspca_dev, 0x27, 0x00);
1713         cit_Packet_Format1(gspca_dev, 0x2b, 0x1f);
1714         cit_Packet_Format1(gspca_dev, 0x39, 0x08);
1715
1716         for (i = 0; i < cit_model1_ntries; i++)
1717                 cit_Packet_Format1(gspca_dev, 0x2c, 0x00);
1718
1719         for (i = 0; i < cit_model1_ntries; i++)
1720                 cit_Packet_Format1(gspca_dev, 0x30, 0x14);
1721
1722         cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1723         cit_PacketFormat2(gspca_dev, 0x01, 0xe1);
1724         cit_PacketFormat2(gspca_dev, 0x02, 0xcd);
1725         cit_PacketFormat2(gspca_dev, 0x03, 0xcd);
1726         cit_PacketFormat2(gspca_dev, 0x04, 0xfa);
1727         cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1728         cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1729
1730         cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1731         cit_PacketFormat2(gspca_dev, 0x0a, 0x37);
1732         cit_PacketFormat2(gspca_dev, 0x0b, 0xb8);
1733         cit_PacketFormat2(gspca_dev, 0x0c, 0xf3);
1734         cit_PacketFormat2(gspca_dev, 0x0d, 0xe3);
1735         cit_PacketFormat2(gspca_dev, 0x0e, 0x0d);
1736         cit_PacketFormat2(gspca_dev, 0x0f, 0xf2);
1737         cit_PacketFormat2(gspca_dev, 0x10, 0xd5);
1738         cit_PacketFormat2(gspca_dev, 0x11, 0xba);
1739         cit_PacketFormat2(gspca_dev, 0x12, 0x53);
1740         cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1741         cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1742
1743         cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1744         cit_PacketFormat2(gspca_dev, 0x16, 0x00);
1745         cit_PacketFormat2(gspca_dev, 0x17, 0x28);
1746         cit_PacketFormat2(gspca_dev, 0x18, 0x7d);
1747         cit_PacketFormat2(gspca_dev, 0x19, 0xbe);
1748         cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1749         cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1750
1751         for (i = 0; i < cit_model1_ntries; i++)
1752                 cit_Packet_Format1(gspca_dev, 0x00, 0x18);
1753         for (i = 0; i < cit_model1_ntries; i++)
1754                 cit_Packet_Format1(gspca_dev, 0x13, 0x18);
1755         for (i = 0; i < cit_model1_ntries; i++)
1756                 cit_Packet_Format1(gspca_dev, 0x14, 0x06);
1757
1758         /* TESTME These are handled through controls
1759            KEEP until someone can test leaving this out is ok */
1760         if (0) {
1761                 /* This is default brightness */
1762                 for (i = 0; i < cit_model1_ntries; i++)
1763                         cit_Packet_Format1(gspca_dev, 0x31, 0x37);
1764                 for (i = 0; i < cit_model1_ntries; i++)
1765                         cit_Packet_Format1(gspca_dev, 0x32, 0x46);
1766                 for (i = 0; i < cit_model1_ntries; i++)
1767                         cit_Packet_Format1(gspca_dev, 0x33, 0x55);
1768         }
1769
1770         cit_Packet_Format1(gspca_dev, 0x2e, 0x04);
1771         for (i = 0; i < cit_model1_ntries; i++)
1772                 cit_Packet_Format1(gspca_dev, 0x2d, 0x04);
1773         for (i = 0; i < cit_model1_ntries; i++)
1774                 cit_Packet_Format1(gspca_dev, 0x29, 0x80);
1775         cit_Packet_Format1(gspca_dev, 0x2c, 0x01);
1776         cit_Packet_Format1(gspca_dev, 0x30, 0x17);
1777         cit_Packet_Format1(gspca_dev, 0x39, 0x08);
1778         for (i = 0; i < cit_model1_ntries; i++)
1779                 cit_Packet_Format1(gspca_dev, 0x34, 0x00);
1780
1781         cit_write_reg(gspca_dev, 0x00, 0x0101);
1782         cit_write_reg(gspca_dev, 0x00, 0x010a);
1783
1784         switch (gspca_dev->width) {
1785         case 128: /* 128x96 */
1786                 cit_write_reg(gspca_dev, 0x80, 0x0103);
1787                 cit_write_reg(gspca_dev, 0x60, 0x0105);
1788                 cit_write_reg(gspca_dev, 0x0c, 0x010b);
1789                 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
1790                 cit_write_reg(gspca_dev, 0x0b, 0x011d);
1791                 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
1792                 cit_write_reg(gspca_dev, 0x00, 0x0129);
1793                 break;
1794         case 176: /* 176x144 */
1795                 cit_write_reg(gspca_dev, 0xb0, 0x0103);
1796                 cit_write_reg(gspca_dev, 0x8f, 0x0105);
1797                 cit_write_reg(gspca_dev, 0x06, 0x010b);
1798                 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
1799                 cit_write_reg(gspca_dev, 0x0d, 0x011d);
1800                 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
1801                 cit_write_reg(gspca_dev, 0x03, 0x0129);
1802                 break;
1803         case 352: /* 352x288 */
1804                 cit_write_reg(gspca_dev, 0xb0, 0x0103);
1805                 cit_write_reg(gspca_dev, 0x90, 0x0105);
1806                 cit_write_reg(gspca_dev, 0x02, 0x010b);
1807                 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
1808                 cit_write_reg(gspca_dev, 0x05, 0x011d);
1809                 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
1810                 cit_write_reg(gspca_dev, 0x00, 0x0129);
1811                 break;
1812         }
1813
1814         cit_write_reg(gspca_dev, 0xff, 0x012b);
1815
1816         /* TESTME These are handled through controls
1817            KEEP until someone can test leaving this out is ok */
1818         if (0) {
1819                 /* This is another brightness - don't know why */
1820                 for (i = 0; i < cit_model1_ntries; i++)
1821                         cit_Packet_Format1(gspca_dev, 0x31, 0xc3);
1822                 for (i = 0; i < cit_model1_ntries; i++)
1823                         cit_Packet_Format1(gspca_dev, 0x32, 0xd2);
1824                 for (i = 0; i < cit_model1_ntries; i++)
1825                         cit_Packet_Format1(gspca_dev, 0x33, 0xe1);
1826
1827                 /* Default contrast */
1828                 for (i = 0; i < cit_model1_ntries; i++)
1829                         cit_Packet_Format1(gspca_dev, 0x14, 0x0a);
1830
1831                 /* Default sharpness */
1832                 for (i = 0; i < cit_model1_ntries2; i++)
1833                         cit_PacketFormat2(gspca_dev, 0x13, 0x1a);
1834
1835                 /* Default lighting conditions */
1836                 cit_Packet_Format1(gspca_dev, 0x0027, sd->lighting);
1837         }
1838
1839         /* Assorted init */
1840         switch (gspca_dev->width) {
1841         case 128: /* 128x96 */
1842                 cit_Packet_Format1(gspca_dev, 0x2b, 0x1e);
1843                 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
1844                 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
1845                 cit_write_reg(gspca_dev, 0x36, 0x0102);
1846                 cit_write_reg(gspca_dev, 0x1a, 0x0104);
1847                 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
1848                 cit_write_reg(gspca_dev, 0x2b, 0x011c);
1849                 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
1850                 break;
1851         case 176: /* 176x144 */
1852                 cit_Packet_Format1(gspca_dev, 0x2b, 0x1e);
1853                 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
1854                 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
1855                 cit_write_reg(gspca_dev, 0x04, 0x0102);
1856                 cit_write_reg(gspca_dev, 0x02, 0x0104);
1857                 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
1858                 cit_write_reg(gspca_dev, 0x2b, 0x011c);
1859                 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
1860                 break;
1861         case 352: /* 352x288 */
1862                 cit_Packet_Format1(gspca_dev, 0x2b, 0x1f);
1863                 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
1864                 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
1865                 cit_write_reg(gspca_dev, 0x08, 0x0102);
1866                 cit_write_reg(gspca_dev, 0x01, 0x0104);
1867                 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
1868                 cit_write_reg(gspca_dev, 0x2f, 0x011c);
1869                 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
1870                 break;
1871         }
1872
1873         cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On  */
1874         cit_write_reg(gspca_dev, clock_div, 0x0111);
1875
1876         return 0;
1877 }
1878
1879 static int cit_start_model2(struct gspca_dev *gspca_dev)
1880 {
1881         struct sd *sd = (struct sd *) gspca_dev;
1882         int clock_div = 0;
1883
1884         cit_write_reg(gspca_dev, 0x0000, 0x0100);       /* LED on */
1885         cit_read_reg(gspca_dev, 0x0116, 0);
1886         cit_write_reg(gspca_dev, 0x0060, 0x0116);
1887         cit_write_reg(gspca_dev, 0x0002, 0x0112);
1888         cit_write_reg(gspca_dev, 0x00bc, 0x012c);
1889         cit_write_reg(gspca_dev, 0x0008, 0x012b);
1890         cit_write_reg(gspca_dev, 0x0000, 0x0108);
1891         cit_write_reg(gspca_dev, 0x0001, 0x0133);
1892         cit_write_reg(gspca_dev, 0x0001, 0x0102);
1893         switch (gspca_dev->width) {
1894         case 176: /* 176x144 */
1895                 cit_write_reg(gspca_dev, 0x002c, 0x0103);       /* All except 320x240 */
1896                 cit_write_reg(gspca_dev, 0x0000, 0x0104);       /* Same */
1897                 cit_write_reg(gspca_dev, 0x0024, 0x0105);       /* 176x144, 352x288 */
1898                 cit_write_reg(gspca_dev, 0x00b9, 0x010a);       /* Unique to this mode */
1899                 cit_write_reg(gspca_dev, 0x0038, 0x0119);       /* Unique to this mode */
1900                 /* TESTME HDG: this does not seem right
1901                    (it is 2 for all other resolutions) */
1902                 sd->sof_len = 10;
1903                 break;
1904         case 320: /* 320x240 */
1905                 cit_write_reg(gspca_dev, 0x0028, 0x0103);       /* Unique to this mode */
1906                 cit_write_reg(gspca_dev, 0x0000, 0x0104);       /* Same */
1907                 cit_write_reg(gspca_dev, 0x001e, 0x0105);       /* 320x240, 352x240 */
1908                 cit_write_reg(gspca_dev, 0x0039, 0x010a);       /* All except 176x144 */
1909                 cit_write_reg(gspca_dev, 0x0070, 0x0119);       /* All except 176x144 */
1910                 sd->sof_len = 2;
1911                 break;
1912         /* case VIDEOSIZE_352x240: */
1913                 cit_write_reg(gspca_dev, 0x002c, 0x0103);       /* All except 320x240 */
1914                 cit_write_reg(gspca_dev, 0x0000, 0x0104);       /* Same */
1915                 cit_write_reg(gspca_dev, 0x001e, 0x0105);       /* 320x240, 352x240 */
1916                 cit_write_reg(gspca_dev, 0x0039, 0x010a);       /* All except 176x144 */
1917                 cit_write_reg(gspca_dev, 0x0070, 0x0119);       /* All except 176x144 */
1918                 sd->sof_len = 2;
1919                 break;
1920         case 352: /* 352x288 */
1921                 cit_write_reg(gspca_dev, 0x002c, 0x0103);       /* All except 320x240 */
1922                 cit_write_reg(gspca_dev, 0x0000, 0x0104);       /* Same */
1923                 cit_write_reg(gspca_dev, 0x0024, 0x0105);       /* 176x144, 352x288 */
1924                 cit_write_reg(gspca_dev, 0x0039, 0x010a);       /* All except 176x144 */
1925                 cit_write_reg(gspca_dev, 0x0070, 0x0119);       /* All except 176x144 */
1926                 sd->sof_len = 2;
1927                 break;
1928         }
1929
1930         cit_write_reg(gspca_dev, 0x0000, 0x0100);       /* LED on */
1931
1932         switch (gspca_dev->width) {
1933         case 176: /* 176x144 */
1934                 cit_write_reg(gspca_dev, 0x0050, 0x0111);
1935                 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
1936                 break;
1937         case 320: /* 320x240 */
1938         case 352: /* 352x288 */
1939                 cit_write_reg(gspca_dev, 0x0040, 0x0111);
1940                 cit_write_reg(gspca_dev, 0x00c0, 0x0111);
1941                 break;
1942         }
1943         cit_write_reg(gspca_dev, 0x009b, 0x010f);
1944         cit_write_reg(gspca_dev, 0x00bb, 0x010f);
1945
1946         /*
1947          * Hardware settings, may affect CMOS sensor; not user controls!
1948          * -------------------------------------------------------------
1949          * 0x0004: no effect
1950          * 0x0006: hardware effect
1951          * 0x0008: no effect
1952          * 0x000a: stops video stream, probably important h/w setting
1953          * 0x000c: changes color in hardware manner (not user setting)
1954          * 0x0012: changes number of colors (does not affect speed)
1955          * 0x002a: no effect
1956          * 0x002c: hardware setting (related to scan lines)
1957          * 0x002e: stops video stream, probably important h/w setting
1958          */
1959         cit_model2_Packet1(gspca_dev, 0x000a, 0x005c);
1960         cit_model2_Packet1(gspca_dev, 0x0004, 0x0000);
1961         cit_model2_Packet1(gspca_dev, 0x0006, 0x00fb);
1962         cit_model2_Packet1(gspca_dev, 0x0008, 0x0000);
1963         cit_model2_Packet1(gspca_dev, 0x000c, 0x0009);
1964         cit_model2_Packet1(gspca_dev, 0x0012, 0x000a);
1965         cit_model2_Packet1(gspca_dev, 0x002a, 0x0000);
1966         cit_model2_Packet1(gspca_dev, 0x002c, 0x0000);
1967         cit_model2_Packet1(gspca_dev, 0x002e, 0x0008);
1968
1969         /*
1970          * Function 0x0030 pops up all over the place. Apparently
1971          * it is a hardware control register, with every bit assigned to
1972          * do something.
1973          */
1974         cit_model2_Packet1(gspca_dev, 0x0030, 0x0000);
1975
1976         /*
1977          * Magic control of CMOS sensor. Only lower values like
1978          * 0-3 work, and picture shifts left or right. Don't change.
1979          */
1980         switch (gspca_dev->width) {
1981         case 176: /* 176x144 */
1982                 cit_model2_Packet1(gspca_dev, 0x0014, 0x0002);
1983                 cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */
1984                 cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */
1985                 clock_div = 6;
1986                 break;
1987         case 320: /* 320x240 */
1988                 cit_model2_Packet1(gspca_dev, 0x0014, 0x0009);
1989                 cit_model2_Packet1(gspca_dev, 0x0016, 0x0005); /* Horizontal shift */
1990                 cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Another hardware setting */
1991                 clock_div = 8;
1992                 break;
1993         /* case VIDEOSIZE_352x240: */
1994                 /* This mode doesn't work as Windows programs it; changed to work */
1995                 cit_model2_Packet1(gspca_dev, 0x0014, 0x0009); /* Windows sets this to 8 */
1996                 cit_model2_Packet1(gspca_dev, 0x0016, 0x0003); /* Horizontal shift */
1997                 cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Windows sets this to 0x0045 */
1998                 clock_div = 10;
1999                 break;
2000         case 352: /* 352x288 */
2001                 cit_model2_Packet1(gspca_dev, 0x0014, 0x0003);
2002                 cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */
2003                 cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */
2004                 clock_div = 16;
2005                 break;
2006         }
2007
2008         /* TESTME These are handled through controls
2009            KEEP until someone can test leaving this out is ok */
2010         if (0)
2011                 cit_model2_Packet1(gspca_dev, 0x001a, 0x005a);
2012
2013         /*
2014          * We have our own frame rate setting varying from 0 (slowest) to 6
2015          * (fastest). The camera model 2 allows frame rate in range [0..0x1F]
2016          # where 0 is also the slowest setting. However for all practical
2017          # reasons high settings make no sense because USB is not fast enough
2018          # to support high FPS. Be aware that the picture datastream will be
2019          # severely disrupted if you ask for frame rate faster than allowed
2020          # for the video size - see below:
2021          *
2022          * Allowable ranges (obtained experimentally on OHCI, K6-3, 450 MHz):
2023          * -----------------------------------------------------------------
2024          * 176x144: [6..31]
2025          * 320x240: [8..31]
2026          * 352x240: [10..31]
2027          * 352x288: [16..31] I have to raise lower threshold for stability...
2028          *
2029          * As usual, slower FPS provides better sensitivity.
2030          */
2031         cit_model2_Packet1(gspca_dev, 0x001c, clock_div);
2032
2033         /*
2034          * This setting does not visibly affect pictures; left it here
2035          * because it was present in Windows USB data stream. This function
2036          * does not allow arbitrary values and apparently is a bit mask, to
2037          * be activated only at appropriate time. Don't change it randomly!
2038          */
2039         switch (gspca_dev->width) {
2040         case 176: /* 176x144 */
2041                 cit_model2_Packet1(gspca_dev, 0x0026, 0x00c2);
2042                 break;
2043         case 320: /* 320x240 */
2044                 cit_model2_Packet1(gspca_dev, 0x0026, 0x0044);
2045                 break;
2046         /* case VIDEOSIZE_352x240: */
2047                 cit_model2_Packet1(gspca_dev, 0x0026, 0x0046);
2048                 break;
2049         case 352: /* 352x288 */
2050                 cit_model2_Packet1(gspca_dev, 0x0026, 0x0048);
2051                 break;
2052         }
2053
2054         /* FIXME this cannot be changed while streaming, so we
2055            should report a grabbed flag for this control. */
2056         cit_model2_Packet1(gspca_dev, 0x0028, sd->lighting);
2057         /* color balance rg2 */
2058         cit_model2_Packet1(gspca_dev, 0x001e, 0x002f);
2059         /* saturation */
2060         cit_model2_Packet1(gspca_dev, 0x0020, 0x0034);
2061         /* color balance yb */
2062         cit_model2_Packet1(gspca_dev, 0x0022, 0x00a0);
2063
2064         /* Hardware control command */
2065         cit_model2_Packet1(gspca_dev, 0x0030, 0x0004);
2066
2067         return 0;
2068 }
2069
2070 static int cit_start_model3(struct gspca_dev *gspca_dev)
2071 {
2072         const unsigned short compression = 0; /* 0=none, 7=best frame rate */
2073         int i, clock_div = 0;
2074
2075         /* HDG not in ibmcam driver, added to see if it helps with
2076            auto-detecting between model3 and ibm netcamera pro */
2077         cit_read_reg(gspca_dev, 0x128, 1);
2078
2079         cit_write_reg(gspca_dev, 0x0000, 0x0100);
2080         cit_read_reg(gspca_dev, 0x0116, 0);
2081         cit_write_reg(gspca_dev, 0x0060, 0x0116);
2082         cit_write_reg(gspca_dev, 0x0002, 0x0112);
2083         cit_write_reg(gspca_dev, 0x0000, 0x0123);
2084         cit_write_reg(gspca_dev, 0x0001, 0x0117);
2085         cit_write_reg(gspca_dev, 0x0040, 0x0108);
2086         cit_write_reg(gspca_dev, 0x0019, 0x012c);
2087         cit_write_reg(gspca_dev, 0x0060, 0x0116);
2088         cit_write_reg(gspca_dev, 0x0002, 0x0115);
2089         cit_write_reg(gspca_dev, 0x0003, 0x0115);
2090         cit_read_reg(gspca_dev, 0x0115, 0);
2091         cit_write_reg(gspca_dev, 0x000b, 0x0115);
2092
2093         /* TESTME HDG not in ibmcam driver, added to see if it helps with
2094            auto-detecting between model3 and ibm netcamera pro */
2095         if (0) {
2096                 cit_write_reg(gspca_dev, 0x0078, 0x012d);
2097                 cit_write_reg(gspca_dev, 0x0001, 0x012f);
2098                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2099                 cit_write_reg(gspca_dev, 0x0079, 0x012d);
2100                 cit_write_reg(gspca_dev, 0x00ff, 0x0130);
2101                 cit_write_reg(gspca_dev, 0xcd41, 0x0124);
2102                 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2103                 cit_read_reg(gspca_dev, 0x0126, 1);
2104         }
2105
2106         cit_model3_Packet1(gspca_dev, 0x000a, 0x0040);
2107         cit_model3_Packet1(gspca_dev, 0x000b, 0x00f6);
2108         cit_model3_Packet1(gspca_dev, 0x000c, 0x0002);
2109         cit_model3_Packet1(gspca_dev, 0x000d, 0x0020);
2110         cit_model3_Packet1(gspca_dev, 0x000e, 0x0033);
2111         cit_model3_Packet1(gspca_dev, 0x000f, 0x0007);
2112         cit_model3_Packet1(gspca_dev, 0x0010, 0x0000);
2113         cit_model3_Packet1(gspca_dev, 0x0011, 0x0070);
2114         cit_model3_Packet1(gspca_dev, 0x0012, 0x0030);
2115         cit_model3_Packet1(gspca_dev, 0x0013, 0x0000);
2116         cit_model3_Packet1(gspca_dev, 0x0014, 0x0001);
2117         cit_model3_Packet1(gspca_dev, 0x0015, 0x0001);
2118         cit_model3_Packet1(gspca_dev, 0x0016, 0x0001);
2119         cit_model3_Packet1(gspca_dev, 0x0017, 0x0001);
2120         cit_model3_Packet1(gspca_dev, 0x0018, 0x0000);
2121         cit_model3_Packet1(gspca_dev, 0x001e, 0x00c3);
2122         cit_model3_Packet1(gspca_dev, 0x0020, 0x0000);
2123         cit_model3_Packet1(gspca_dev, 0x0028, 0x0010);
2124         cit_model3_Packet1(gspca_dev, 0x0029, 0x0054);
2125         cit_model3_Packet1(gspca_dev, 0x002a, 0x0013);
2126         cit_model3_Packet1(gspca_dev, 0x002b, 0x0007);
2127         cit_model3_Packet1(gspca_dev, 0x002d, 0x0028);
2128         cit_model3_Packet1(gspca_dev, 0x002e, 0x0000);
2129         cit_model3_Packet1(gspca_dev, 0x0031, 0x0000);
2130         cit_model3_Packet1(gspca_dev, 0x0032, 0x0000);
2131         cit_model3_Packet1(gspca_dev, 0x0033, 0x0000);
2132         cit_model3_Packet1(gspca_dev, 0x0034, 0x0000);
2133         cit_model3_Packet1(gspca_dev, 0x0035, 0x0038);
2134         cit_model3_Packet1(gspca_dev, 0x003a, 0x0001);
2135         cit_model3_Packet1(gspca_dev, 0x003c, 0x001e);
2136         cit_model3_Packet1(gspca_dev, 0x003f, 0x000a);
2137         cit_model3_Packet1(gspca_dev, 0x0041, 0x0000);
2138         cit_model3_Packet1(gspca_dev, 0x0046, 0x003f);
2139         cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
2140         cit_model3_Packet1(gspca_dev, 0x0050, 0x0005);
2141         cit_model3_Packet1(gspca_dev, 0x0052, 0x001a);
2142         cit_model3_Packet1(gspca_dev, 0x0053, 0x0003);
2143         cit_model3_Packet1(gspca_dev, 0x005a, 0x006b);
2144         cit_model3_Packet1(gspca_dev, 0x005d, 0x001e);
2145         cit_model3_Packet1(gspca_dev, 0x005e, 0x0030);
2146         cit_model3_Packet1(gspca_dev, 0x005f, 0x0041);
2147         cit_model3_Packet1(gspca_dev, 0x0064, 0x0008);
2148         cit_model3_Packet1(gspca_dev, 0x0065, 0x0015);
2149         cit_model3_Packet1(gspca_dev, 0x0068, 0x000f);
2150         cit_model3_Packet1(gspca_dev, 0x0079, 0x0000);
2151         cit_model3_Packet1(gspca_dev, 0x007a, 0x0000);
2152         cit_model3_Packet1(gspca_dev, 0x007c, 0x003f);
2153         cit_model3_Packet1(gspca_dev, 0x0082, 0x000f);
2154         cit_model3_Packet1(gspca_dev, 0x0085, 0x0000);
2155         cit_model3_Packet1(gspca_dev, 0x0099, 0x0000);
2156         cit_model3_Packet1(gspca_dev, 0x009b, 0x0023);
2157         cit_model3_Packet1(gspca_dev, 0x009c, 0x0022);
2158         cit_model3_Packet1(gspca_dev, 0x009d, 0x0096);
2159         cit_model3_Packet1(gspca_dev, 0x009e, 0x0096);
2160         cit_model3_Packet1(gspca_dev, 0x009f, 0x000a);
2161
2162         switch (gspca_dev->width) {
2163         case 160:
2164                 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2165                 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2166                 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2167                 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2168                 cit_write_reg(gspca_dev, 0x0024, 0x010b); /* Differs everywhere */
2169                 cit_write_reg(gspca_dev, 0x00a9, 0x0119);
2170                 cit_write_reg(gspca_dev, 0x0016, 0x011b);
2171                 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */
2172                 cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */
2173                 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2174                 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2175                 cit_write_reg(gspca_dev, 0x0018, 0x0102);
2176                 cit_write_reg(gspca_dev, 0x0004, 0x0104);
2177                 cit_write_reg(gspca_dev, 0x0004, 0x011a);
2178                 cit_write_reg(gspca_dev, 0x0028, 0x011c);
2179                 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2180                 cit_write_reg(gspca_dev, 0x0000, 0x0118);
2181                 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2182                 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2183                 cit_write_reg(gspca_dev, compression, 0x0109);
2184                 clock_div = 3;
2185                 break;
2186         case 320:
2187                 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2188                 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2189                 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2190                 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2191                 cit_write_reg(gspca_dev, 0x0028, 0x010b); /* Differs everywhere */
2192                 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same */
2193                 cit_write_reg(gspca_dev, 0x0000, 0x011e);
2194                 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2195                 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2196                 /* 4 commands from 160x120 skipped */
2197                 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2198                 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2199                 cit_write_reg(gspca_dev, compression, 0x0109);
2200                 cit_write_reg(gspca_dev, 0x00d9, 0x0119);
2201                 cit_write_reg(gspca_dev, 0x0006, 0x011b);
2202                 cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
2203                 cit_write_reg(gspca_dev, 0x0010, 0x0104);
2204                 cit_write_reg(gspca_dev, 0x0004, 0x011a);
2205                 cit_write_reg(gspca_dev, 0x003f, 0x011c);
2206                 cit_write_reg(gspca_dev, 0x001c, 0x0118);
2207                 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2208                 clock_div = 5;
2209                 break;
2210         case 640:
2211                 cit_write_reg(gspca_dev, 0x00f0, 0x0105);
2212                 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2213                 cit_write_reg(gspca_dev, 0x0038, 0x010b); /* Differs everywhere */
2214                 cit_write_reg(gspca_dev, 0x00d9, 0x0119); /* Same on 320x240, 640x480 */
2215                 cit_write_reg(gspca_dev, 0x0006, 0x011b); /* Same on 320x240, 640x480 */
2216                 cit_write_reg(gspca_dev, 0x0004, 0x011d); /* NC */
2217                 cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */
2218                 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2219                 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2220                 cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
2221                 cit_write_reg(gspca_dev, 0x0016, 0x0104); /* NC */
2222                 cit_write_reg(gspca_dev, 0x0004, 0x011a); /* Same on 320x240, 640x480 */
2223                 cit_write_reg(gspca_dev, 0x003f, 0x011c); /* Same on 320x240, 640x480 */
2224                 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2225                 cit_write_reg(gspca_dev, 0x001c, 0x0118); /* Same on 320x240, 640x480 */
2226                 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2227                 cit_write_reg(gspca_dev, compression, 0x0109);
2228                 cit_write_reg(gspca_dev, 0x0040, 0x0101);
2229                 cit_write_reg(gspca_dev, 0x0040, 0x0103);
2230                 cit_write_reg(gspca_dev, 0x0000, 0x0132); /* Same on 320x240, 640x480 */
2231                 clock_div = 7;
2232                 break;
2233         }
2234
2235         cit_model3_Packet1(gspca_dev, 0x007e, 0x000e);  /* Hue */
2236         cit_model3_Packet1(gspca_dev, 0x0036, 0x0011);  /* Brightness */
2237         cit_model3_Packet1(gspca_dev, 0x0060, 0x0002);  /* Sharpness */
2238         cit_model3_Packet1(gspca_dev, 0x0061, 0x0004);  /* Sharpness */
2239         cit_model3_Packet1(gspca_dev, 0x0062, 0x0005);  /* Sharpness */
2240         cit_model3_Packet1(gspca_dev, 0x0063, 0x0014);  /* Sharpness */
2241         cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0);  /* Red sharpness */
2242         cit_model3_Packet1(gspca_dev, 0x0097, 0x0096);  /* Blue sharpness */
2243         cit_model3_Packet1(gspca_dev, 0x0067, 0x0001);  /* Contrast */
2244         cit_model3_Packet1(gspca_dev, 0x005b, 0x000c);  /* Contrast */
2245         cit_model3_Packet1(gspca_dev, 0x005c, 0x0016);  /* Contrast */
2246         cit_model3_Packet1(gspca_dev, 0x0098, 0x000b);
2247         cit_model3_Packet1(gspca_dev, 0x002c, 0x0003);  /* Was 1, broke 640x480 */
2248         cit_model3_Packet1(gspca_dev, 0x002f, 0x002a);
2249         cit_model3_Packet1(gspca_dev, 0x0030, 0x0029);
2250         cit_model3_Packet1(gspca_dev, 0x0037, 0x0002);
2251         cit_model3_Packet1(gspca_dev, 0x0038, 0x0059);
2252         cit_model3_Packet1(gspca_dev, 0x003d, 0x002e);
2253         cit_model3_Packet1(gspca_dev, 0x003e, 0x0028);
2254         cit_model3_Packet1(gspca_dev, 0x0078, 0x0005);
2255         cit_model3_Packet1(gspca_dev, 0x007b, 0x0011);
2256         cit_model3_Packet1(gspca_dev, 0x007d, 0x004b);
2257         cit_model3_Packet1(gspca_dev, 0x007f, 0x0022);
2258         cit_model3_Packet1(gspca_dev, 0x0080, 0x000c);
2259         cit_model3_Packet1(gspca_dev, 0x0081, 0x000b);
2260         cit_model3_Packet1(gspca_dev, 0x0083, 0x00fd);
2261         cit_model3_Packet1(gspca_dev, 0x0086, 0x000b);
2262         cit_model3_Packet1(gspca_dev, 0x0087, 0x000b);
2263         cit_model3_Packet1(gspca_dev, 0x007e, 0x000e);
2264         cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0);  /* Red sharpness */
2265         cit_model3_Packet1(gspca_dev, 0x0097, 0x0096);  /* Blue sharpness */
2266         cit_model3_Packet1(gspca_dev, 0x0098, 0x000b);
2267
2268         /* FIXME we should probably use cit_get_clock_div() here (in
2269            combination with isoc negotiation using the programmable isoc size)
2270            like with the IBM netcam pro). */
2271         cit_write_reg(gspca_dev, clock_div, 0x0111); /* Clock Divider */
2272
2273         switch (gspca_dev->width) {
2274         case 160:
2275                 cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */
2276                 cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */
2277                 cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */
2278                 cit_model3_Packet1(gspca_dev, 0x0040, 0x000a);
2279                 cit_model3_Packet1(gspca_dev, 0x0051, 0x000a);
2280                 break;
2281         case 320:
2282                 cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */
2283                 cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */
2284                 cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */
2285                 cit_model3_Packet1(gspca_dev, 0x0040, 0x0008);
2286                 cit_model3_Packet1(gspca_dev, 0x0051, 0x000b);
2287                 break;
2288         case 640:
2289                 cit_model3_Packet1(gspca_dev, 0x001f, 0x0002);  /* !Same */
2290                 cit_model3_Packet1(gspca_dev, 0x0039, 0x003e);  /* !Same */
2291                 cit_model3_Packet1(gspca_dev, 0x0040, 0x0008);
2292                 cit_model3_Packet1(gspca_dev, 0x0051, 0x000a);
2293                 break;
2294         }
2295
2296 /*      if (sd->input_index) { */
2297         if (rca_input) {
2298                 for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) {
2299                         if (rca_initdata[i][0])
2300                                 cit_read_reg(gspca_dev, rca_initdata[i][2], 0);
2301                         else
2302                                 cit_write_reg(gspca_dev, rca_initdata[i][1],
2303                                               rca_initdata[i][2]);
2304                 }
2305         }
2306
2307         return 0;
2308 }
2309
2310 static int cit_start_model4(struct gspca_dev *gspca_dev)
2311 {
2312         struct sd *sd = (struct sd *) gspca_dev;
2313
2314         cit_write_reg(gspca_dev, 0x0000, 0x0100);
2315         cit_write_reg(gspca_dev, 0x00c0, 0x0111);
2316         cit_write_reg(gspca_dev, 0x00bc, 0x012c);
2317         cit_write_reg(gspca_dev, 0x0080, 0x012b);
2318         cit_write_reg(gspca_dev, 0x0000, 0x0108);
2319         cit_write_reg(gspca_dev, 0x0001, 0x0133);
2320         cit_write_reg(gspca_dev, 0x009b, 0x010f);
2321         cit_write_reg(gspca_dev, 0x00bb, 0x010f);
2322         cit_model4_Packet1(gspca_dev, 0x0038, 0x0000);
2323         cit_model4_Packet1(gspca_dev, 0x000a, 0x005c);
2324
2325         cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2326         cit_write_reg(gspca_dev, 0x0004, 0x012f);
2327         cit_write_reg(gspca_dev, 0xd141, 0x0124);
2328         cit_write_reg(gspca_dev, 0x0000, 0x0127);
2329         cit_write_reg(gspca_dev, 0x00fb, 0x012e);
2330         cit_write_reg(gspca_dev, 0x0000, 0x0130);
2331         cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2332         cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2333         cit_write_reg(gspca_dev, 0xd055, 0x0124);
2334         cit_write_reg(gspca_dev, 0x000c, 0x0127);
2335         cit_write_reg(gspca_dev, 0x0009, 0x012e);
2336         cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2337
2338         cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2339         cit_write_reg(gspca_dev, 0x0012, 0x012f);
2340         cit_write_reg(gspca_dev, 0xd141, 0x0124);
2341         cit_write_reg(gspca_dev, 0x0008, 0x0127);
2342         cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2343         cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2344         cit_write_reg(gspca_dev, 0x002a, 0x012d);
2345         cit_write_reg(gspca_dev, 0x0000, 0x012f);
2346         cit_write_reg(gspca_dev, 0xd145, 0x0124);
2347         cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2348         cit_model4_Packet1(gspca_dev, 0x0034, 0x0000);
2349
2350         switch (gspca_dev->width) {
2351         case 128: /* 128x96 */
2352                 cit_write_reg(gspca_dev, 0x0070, 0x0119);
2353                 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2354                 cit_write_reg(gspca_dev, 0x0039, 0x010a);
2355                 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2356                 cit_write_reg(gspca_dev, 0x0028, 0x0103);
2357                 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2358                 cit_write_reg(gspca_dev, 0x001e, 0x0105);
2359                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2360                 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2361                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2362                 cit_write_reg(gspca_dev, 0x000a, 0x0127);
2363                 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2364                 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2365                 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2366                 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2367                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2368                 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2369                 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2370                 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2371                 cit_write_reg(gspca_dev, 0x005a, 0x012d);
2372                 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2373                 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2374                 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2375                 cit_write_reg(gspca_dev, 0x0043, 0x0130);
2376                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2377                 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2378                 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2379                 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2380                 cit_write_reg(gspca_dev, 0x00eb, 0x012e);
2381                 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2382                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2383                 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2384                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2385                 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2386                 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2387                 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2388                 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2389                 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2390                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2391                 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2392                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2393                 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2394                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2395                 cit_write_reg(gspca_dev, 0x0017, 0x0127);
2396                 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2397                 cit_write_reg(gspca_dev, 0x0031, 0x0130);
2398                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2399                 cit_write_reg(gspca_dev, 0x0017, 0x012d);
2400                 cit_write_reg(gspca_dev, 0x0078, 0x012f);
2401                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2402                 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2403                 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2404                 sd->sof_len = 2;
2405                 break;
2406         case 160: /* 160x120 */
2407                 cit_write_reg(gspca_dev, 0x0038, 0x0119);
2408                 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2409                 cit_write_reg(gspca_dev, 0x00b9, 0x010a);
2410                 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2411                 cit_write_reg(gspca_dev, 0x0028, 0x0103);
2412                 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2413                 cit_write_reg(gspca_dev, 0x001e, 0x0105);
2414                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2415                 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2416                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2417                 cit_write_reg(gspca_dev, 0x000b, 0x0127);
2418                 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2419                 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2420                 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2421                 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2422                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2423                 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2424                 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2425                 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2426                 cit_write_reg(gspca_dev, 0x005a, 0x012d);
2427                 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2428                 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2429                 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2430                 cit_write_reg(gspca_dev, 0x0043, 0x0130);
2431                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2432                 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2433                 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2434                 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2435                 cit_write_reg(gspca_dev, 0x00c7, 0x012e);
2436                 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2437                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2438                 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2439                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2440                 cit_write_reg(gspca_dev, 0x0025, 0x0127);
2441                 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2442                 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2443                 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2444                 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2445                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2446                 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2447                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2448                 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2449                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2450                 cit_write_reg(gspca_dev, 0x0048, 0x0127);
2451                 cit_write_reg(gspca_dev, 0x0035, 0x012e);
2452                 cit_write_reg(gspca_dev, 0x00d0, 0x0130);
2453                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2454                 cit_write_reg(gspca_dev, 0x0048, 0x012d);
2455                 cit_write_reg(gspca_dev, 0x0090, 0x012f);
2456                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2457                 cit_write_reg(gspca_dev, 0x0001, 0x0127);
2458                 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2459                 sd->sof_len = 2;
2460                 break;
2461         case 176: /* 176x144 */
2462                 cit_write_reg(gspca_dev, 0x0038, 0x0119);
2463                 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2464                 cit_write_reg(gspca_dev, 0x00b9, 0x010a);
2465                 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2466                 cit_write_reg(gspca_dev, 0x002c, 0x0103);
2467                 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2468                 cit_write_reg(gspca_dev, 0x0024, 0x0105);
2469                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2470                 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2471                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2472                 cit_write_reg(gspca_dev, 0x0007, 0x0127);
2473                 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2474                 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2475                 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2476                 cit_write_reg(gspca_dev, 0x0001, 0x012f);
2477                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2478                 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2479                 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2480                 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2481                 cit_write_reg(gspca_dev, 0x005e, 0x012d);
2482                 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2483                 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2484                 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2485                 cit_write_reg(gspca_dev, 0x0049, 0x0130);
2486                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2487                 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2488                 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2489                 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2490                 cit_write_reg(gspca_dev, 0x00c7, 0x012e);
2491                 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2492                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2493                 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2494                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2495                 cit_write_reg(gspca_dev, 0x0028, 0x0127);
2496                 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2497                 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2498                 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2499                 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2500                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2501                 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2502                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2503                 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2504                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2505                 cit_write_reg(gspca_dev, 0x0010, 0x0127);
2506                 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2507                 cit_write_reg(gspca_dev, 0x002a, 0x0130);
2508                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2509                 cit_write_reg(gspca_dev, 0x0010, 0x012d);
2510                 cit_write_reg(gspca_dev, 0x006d, 0x012f);
2511                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2512                 cit_write_reg(gspca_dev, 0x0001, 0x0127);
2513                 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2514                 /* TESTME HDG: this does not seem right
2515                    (it is 2 for all other resolutions) */
2516                 sd->sof_len = 10;
2517                 break;
2518         case 320: /* 320x240 */
2519                 cit_write_reg(gspca_dev, 0x0070, 0x0119);
2520                 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2521                 cit_write_reg(gspca_dev, 0x0039, 0x010a);
2522                 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2523                 cit_write_reg(gspca_dev, 0x0028, 0x0103);
2524                 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2525                 cit_write_reg(gspca_dev, 0x001e, 0x0105);
2526                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2527                 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2528                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2529                 cit_write_reg(gspca_dev, 0x000a, 0x0127);
2530                 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2531                 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2532                 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2533                 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2534                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2535                 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2536                 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2537                 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2538                 cit_write_reg(gspca_dev, 0x005a, 0x012d);
2539                 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2540                 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2541                 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2542                 cit_write_reg(gspca_dev, 0x0043, 0x0130);
2543                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2544                 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2545                 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2546                 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2547                 cit_write_reg(gspca_dev, 0x00eb, 0x012e);
2548                 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2549                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2550                 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2551                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2552                 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2553                 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2554                 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2555                 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2556                 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2557                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2558                 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2559                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2560                 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2561                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2562                 cit_write_reg(gspca_dev, 0x0017, 0x0127);
2563                 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2564                 cit_write_reg(gspca_dev, 0x0031, 0x0130);
2565                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2566                 cit_write_reg(gspca_dev, 0x0017, 0x012d);
2567                 cit_write_reg(gspca_dev, 0x0078, 0x012f);
2568                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2569                 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2570                 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2571                 sd->sof_len = 2;
2572                 break;
2573         case 352: /* 352x288 */
2574                 cit_write_reg(gspca_dev, 0x0070, 0x0119);
2575                 cit_write_reg(gspca_dev, 0x00c0, 0x0111);
2576                 cit_write_reg(gspca_dev, 0x0039, 0x010a);
2577                 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2578                 cit_write_reg(gspca_dev, 0x002c, 0x0103);
2579                 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2580                 cit_write_reg(gspca_dev, 0x0024, 0x0105);
2581                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2582                 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2583                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2584                 cit_write_reg(gspca_dev, 0x0006, 0x0127);
2585                 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2586                 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2587                 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2588                 cit_write_reg(gspca_dev, 0x0002, 0x012f);
2589                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2590                 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2591                 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2592                 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2593                 cit_write_reg(gspca_dev, 0x005e, 0x012d);
2594                 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2595                 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2596                 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2597                 cit_write_reg(gspca_dev, 0x0049, 0x0130);
2598                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2599                 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2600                 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2601                 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2602                 cit_write_reg(gspca_dev, 0x00cf, 0x012e);
2603                 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2604                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2605                 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2606                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2607                 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2608                 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2609                 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2610                 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2611                 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2612                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2613                 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2614                 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2615                 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2616                 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2617                 cit_write_reg(gspca_dev, 0x0010, 0x0127);
2618                 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2619                 cit_write_reg(gspca_dev, 0x0025, 0x0130);
2620                 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2621                 cit_write_reg(gspca_dev, 0x0010, 0x012d);
2622                 cit_write_reg(gspca_dev, 0x0048, 0x012f);
2623                 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2624                 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2625                 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2626                 sd->sof_len = 2;
2627                 break;
2628         }
2629
2630         cit_model4_Packet1(gspca_dev, 0x0038, 0x0004);
2631
2632         return 0;
2633 }
2634
2635 static int cit_start_ibm_netcam_pro(struct gspca_dev *gspca_dev)
2636 {
2637         const unsigned short compression = 0; /* 0=none, 7=best frame rate */
2638         int i, clock_div;
2639
2640         clock_div = cit_get_clock_div(gspca_dev);
2641         if (clock_div < 0)
2642                 return clock_div;
2643
2644         cit_write_reg(gspca_dev, 0x0003, 0x0133);
2645         cit_write_reg(gspca_dev, 0x0000, 0x0117);
2646         cit_write_reg(gspca_dev, 0x0008, 0x0123);
2647         cit_write_reg(gspca_dev, 0x0000, 0x0100);
2648         cit_write_reg(gspca_dev, 0x0060, 0x0116);
2649         /* cit_write_reg(gspca_dev, 0x0002, 0x0112); see sd_stop0 */
2650         cit_write_reg(gspca_dev, 0x0000, 0x0133);
2651         cit_write_reg(gspca_dev, 0x0000, 0x0123);
2652         cit_write_reg(gspca_dev, 0x0001, 0x0117);
2653         cit_write_reg(gspca_dev, 0x0040, 0x0108);
2654         cit_write_reg(gspca_dev, 0x0019, 0x012c);
2655         cit_write_reg(gspca_dev, 0x0060, 0x0116);
2656         /* cit_write_reg(gspca_dev, 0x000b, 0x0115); see sd_stop0 */
2657
2658         cit_model3_Packet1(gspca_dev, 0x0049, 0x0000);
2659
2660         cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2661         cit_write_reg(gspca_dev, 0x003a, 0x0102); /* Hstart */
2662         cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2663         cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2664         cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2665         cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */
2666         cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2667         cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2668         cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2669
2670         switch (gspca_dev->width) {
2671         case 160: /* 160x120 */
2672                 cit_write_reg(gspca_dev, 0x0024, 0x010b);
2673                 cit_write_reg(gspca_dev, 0x0089, 0x0119);
2674                 cit_write_reg(gspca_dev, 0x000a, 0x011b);
2675                 cit_write_reg(gspca_dev, 0x0003, 0x011e);
2676                 cit_write_reg(gspca_dev, 0x0007, 0x0104);
2677                 cit_write_reg(gspca_dev, 0x0009, 0x011a);
2678                 cit_write_reg(gspca_dev, 0x008b, 0x011c);
2679                 cit_write_reg(gspca_dev, 0x0008, 0x0118);
2680                 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2681                 break;
2682         case 320: /* 320x240 */
2683                 cit_write_reg(gspca_dev, 0x0028, 0x010b);
2684                 cit_write_reg(gspca_dev, 0x00d9, 0x0119);
2685                 cit_write_reg(gspca_dev, 0x0006, 0x011b);
2686                 cit_write_reg(gspca_dev, 0x0000, 0x011e);
2687                 cit_write_reg(gspca_dev, 0x000e, 0x0104);
2688                 cit_write_reg(gspca_dev, 0x0004, 0x011a);
2689                 cit_write_reg(gspca_dev, 0x003f, 0x011c);
2690                 cit_write_reg(gspca_dev, 0x000c, 0x0118);
2691                 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2692                 break;
2693         }
2694
2695         cit_model3_Packet1(gspca_dev, 0x0019, 0x0031);
2696         cit_model3_Packet1(gspca_dev, 0x001a, 0x0003);
2697         cit_model3_Packet1(gspca_dev, 0x001b, 0x0038);
2698         cit_model3_Packet1(gspca_dev, 0x001c, 0x0000);
2699         cit_model3_Packet1(gspca_dev, 0x0024, 0x0001);
2700         cit_model3_Packet1(gspca_dev, 0x0027, 0x0001);
2701         cit_model3_Packet1(gspca_dev, 0x002a, 0x0004);
2702         cit_model3_Packet1(gspca_dev, 0x0035, 0x000b);
2703         cit_model3_Packet1(gspca_dev, 0x003f, 0x0001);
2704         cit_model3_Packet1(gspca_dev, 0x0044, 0x0000);
2705         cit_model3_Packet1(gspca_dev, 0x0054, 0x0000);
2706         cit_model3_Packet1(gspca_dev, 0x00c4, 0x0000);
2707         cit_model3_Packet1(gspca_dev, 0x00e7, 0x0001);
2708         cit_model3_Packet1(gspca_dev, 0x00e9, 0x0001);
2709         cit_model3_Packet1(gspca_dev, 0x00ee, 0x0000);
2710         cit_model3_Packet1(gspca_dev, 0x00f3, 0x00c0);
2711
2712         cit_write_reg(gspca_dev, compression, 0x0109);
2713         cit_write_reg(gspca_dev, clock_div, 0x0111);
2714
2715 /*      if (sd->input_index) { */
2716         if (rca_input) {
2717                 for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) {
2718                         if (rca_initdata[i][0])
2719                                 cit_read_reg(gspca_dev, rca_initdata[i][2], 0);
2720                         else
2721                                 cit_write_reg(gspca_dev, rca_initdata[i][1],
2722                                               rca_initdata[i][2]);
2723                 }
2724         }
2725
2726         return 0;
2727 }
2728
2729 /* -- start the camera -- */
2730 static int sd_start(struct gspca_dev *gspca_dev)
2731 {
2732         struct sd *sd = (struct sd *) gspca_dev;
2733         int packet_size;
2734
2735         packet_size = cit_get_packet_size(gspca_dev);
2736         if (packet_size < 0)
2737                 return packet_size;
2738
2739         switch (sd->model) {
2740         case CIT_MODEL0:
2741                 cit_start_model0(gspca_dev);
2742                 break;
2743         case CIT_MODEL1:
2744                 cit_start_model1(gspca_dev);
2745                 break;
2746         case CIT_MODEL2:
2747                 cit_start_model2(gspca_dev);
2748                 break;
2749         case CIT_MODEL3:
2750                 cit_start_model3(gspca_dev);
2751                 break;
2752         case CIT_MODEL4:
2753                 cit_start_model4(gspca_dev);
2754                 break;
2755         case CIT_IBM_NETCAM_PRO:
2756                 cit_start_ibm_netcam_pro(gspca_dev);
2757                 break;
2758         }
2759
2760         cit_set_brightness(gspca_dev);
2761         cit_set_contrast(gspca_dev);
2762         cit_set_hue(gspca_dev);
2763         cit_set_sharpness(gspca_dev);
2764         cit_set_lighting(gspca_dev);
2765         cit_set_hflip(gspca_dev);
2766
2767         /* Program max isoc packet size */
2768         cit_write_reg(gspca_dev, packet_size >> 8, 0x0106);
2769         cit_write_reg(gspca_dev, packet_size & 0xff, 0x0107);
2770
2771         cit_restart_stream(gspca_dev);
2772
2773         return 0;
2774 }
2775
2776 static int sd_isoc_init(struct gspca_dev *gspca_dev)
2777 {
2778         struct usb_host_interface *alt;
2779         int max_packet_size;
2780
2781         switch (gspca_dev->width) {
2782         case 160:
2783                 max_packet_size = 450;
2784                 break;
2785         case 176:
2786                 max_packet_size = 600;
2787                 break;
2788         default:
2789                 max_packet_size = 1022;
2790                 break;
2791         }
2792
2793         /* Start isoc bandwidth "negotiation" at max isoc bandwidth */
2794         alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
2795         alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(max_packet_size);
2796
2797         return 0;
2798 }
2799
2800 static int sd_isoc_nego(struct gspca_dev *gspca_dev)
2801 {
2802         int ret, packet_size, min_packet_size;
2803         struct usb_host_interface *alt;
2804
2805         switch (gspca_dev->width) {
2806         case 160:
2807                 min_packet_size = 200;
2808                 break;
2809         case 176:
2810                 min_packet_size = 266;
2811                 break;
2812         default:
2813                 min_packet_size = 400;
2814                 break;
2815         }
2816
2817         alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
2818         packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
2819         if (packet_size <= min_packet_size)
2820                 return -EIO;
2821
2822         packet_size -= 100;
2823         if (packet_size < min_packet_size)
2824                 packet_size = min_packet_size;
2825         alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(packet_size);
2826
2827         ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
2828         if (ret < 0)
2829                 pr_err("set alt 1 err %d\n", ret);
2830
2831         return ret;
2832 }
2833
2834 static void sd_stopN(struct gspca_dev *gspca_dev)
2835 {
2836         cit_write_reg(gspca_dev, 0x0000, 0x010c);
2837 }
2838
2839 static void sd_stop0(struct gspca_dev *gspca_dev)
2840 {
2841         struct sd *sd = (struct sd *) gspca_dev;
2842
2843         /* We cannot use gspca_dev->present here as that is not set when
2844            sd_init gets called and we get called from sd_init */
2845         if (!gspca_dev->dev)
2846                 return;
2847
2848         switch (sd->model) {
2849         case CIT_MODEL0:
2850                 /* HDG windows does this, but it causes the cams autogain to
2851                    restart from a gain of 0, which does not look good when
2852                    changing resolutions. */
2853                 /* cit_write_reg(gspca_dev, 0x0000, 0x0112); */
2854                 cit_write_reg(gspca_dev, 0x00c0, 0x0100); /* LED Off */
2855                 break;
2856         case CIT_MODEL1:
2857                 cit_send_FF_04_02(gspca_dev);
2858                 cit_read_reg(gspca_dev, 0x0100, 0);
2859                 cit_write_reg(gspca_dev, 0x81, 0x0100); /* LED Off */
2860                 break;
2861         case CIT_MODEL2:
2862         case CIT_MODEL4:
2863                 cit_model2_Packet1(gspca_dev, 0x0030, 0x0004);
2864
2865                 cit_write_reg(gspca_dev, 0x0080, 0x0100);       /* LED Off */
2866                 cit_write_reg(gspca_dev, 0x0020, 0x0111);
2867                 cit_write_reg(gspca_dev, 0x00a0, 0x0111);
2868
2869                 cit_model2_Packet1(gspca_dev, 0x0030, 0x0002);
2870
2871                 cit_write_reg(gspca_dev, 0x0020, 0x0111);
2872                 cit_write_reg(gspca_dev, 0x0000, 0x0112);
2873                 break;
2874         case CIT_MODEL3:
2875                 cit_write_reg(gspca_dev, 0x0006, 0x012c);
2876                 cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
2877                 cit_read_reg(gspca_dev, 0x0116, 0);
2878                 cit_write_reg(gspca_dev, 0x0064, 0x0116);
2879                 cit_read_reg(gspca_dev, 0x0115, 0);
2880                 cit_write_reg(gspca_dev, 0x0003, 0x0115);
2881                 cit_write_reg(gspca_dev, 0x0008, 0x0123);
2882                 cit_write_reg(gspca_dev, 0x0000, 0x0117);
2883                 cit_write_reg(gspca_dev, 0x0000, 0x0112);
2884                 cit_write_reg(gspca_dev, 0x0080, 0x0100);
2885                 break;
2886         case CIT_IBM_NETCAM_PRO:
2887                 cit_model3_Packet1(gspca_dev, 0x0049, 0x00ff);
2888                 cit_write_reg(gspca_dev, 0x0006, 0x012c);
2889                 cit_write_reg(gspca_dev, 0x0000, 0x0116);
2890                 /* HDG windows does this, but I cannot get the camera
2891                    to restart with this without redoing the entire init
2892                    sequence which makes switching modes really slow */
2893                 /* cit_write_reg(gspca_dev, 0x0006, 0x0115); */
2894                 cit_write_reg(gspca_dev, 0x0008, 0x0123);
2895                 cit_write_reg(gspca_dev, 0x0000, 0x0117);
2896                 cit_write_reg(gspca_dev, 0x0003, 0x0133);
2897                 cit_write_reg(gspca_dev, 0x0000, 0x0111);
2898                 /* HDG windows does this, but I get a green picture when
2899                    restarting the stream after this */
2900                 /* cit_write_reg(gspca_dev, 0x0000, 0x0112); */
2901                 cit_write_reg(gspca_dev, 0x00c0, 0x0100);
2902                 break;
2903         }
2904
2905 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2906         /* If the last button state is pressed, release it now! */
2907         if (sd->button_state) {
2908                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
2909                 input_sync(gspca_dev->input_dev);
2910                 sd->button_state = 0;
2911         }
2912 #endif
2913 }
2914
2915 static u8 *cit_find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
2916 {
2917         struct sd *sd = (struct sd *) gspca_dev;
2918         u8 byte3 = 0, byte4 = 0;
2919         int i;
2920
2921         switch (sd->model) {
2922         case CIT_MODEL0:
2923         case CIT_MODEL1:
2924         case CIT_MODEL3:
2925         case CIT_IBM_NETCAM_PRO:
2926                 switch (gspca_dev->width) {
2927                 case 160: /* 160x120 */
2928                         byte3 = 0x02;
2929                         byte4 = 0x0a;
2930                         break;
2931                 case 176: /* 176x144 */
2932                         byte3 = 0x02;
2933                         byte4 = 0x0e;
2934                         break;
2935                 case 320: /* 320x240 */
2936                         byte3 = 0x02;
2937                         byte4 = 0x08;
2938                         break;
2939                 case 352: /* 352x288 */
2940                         byte3 = 0x02;
2941                         byte4 = 0x00;
2942                         break;
2943                 case 640:
2944                         byte3 = 0x03;
2945                         byte4 = 0x08;
2946                         break;
2947                 }
2948
2949                 /* These have a different byte3 */
2950                 if (sd->model <= CIT_MODEL1)
2951                         byte3 = 0x00;
2952
2953                 for (i = 0; i < len; i++) {
2954                         /* For this model the SOF always starts at offset 0
2955                            so no need to search the entire frame */
2956                         if (sd->model == CIT_MODEL0 && sd->sof_read != i)
2957                                 break;
2958
2959                         switch (sd->sof_read) {
2960                         case 0:
2961                                 if (data[i] == 0x00)
2962                                         sd->sof_read++;
2963                                 break;
2964                         case 1:
2965                                 if (data[i] == 0xff)
2966                                         sd->sof_read++;
2967                                 else if (data[i] == 0x00)
2968                                         sd->sof_read = 1;
2969                                 else
2970                                         sd->sof_read = 0;
2971                                 break;
2972                         case 2:
2973                                 if (data[i] == byte3)
2974                                         sd->sof_read++;
2975                                 else if (data[i] == 0x00)
2976                                         sd->sof_read = 1;
2977                                 else
2978                                         sd->sof_read = 0;
2979                                 break;
2980                         case 3:
2981                                 if (data[i] == byte4) {
2982                                         sd->sof_read = 0;
2983                                         return data + i + (sd->sof_len - 3);
2984                                 }
2985                                 if (byte3 == 0x00 && data[i] == 0xff)
2986                                         sd->sof_read = 2;
2987                                 else if (data[i] == 0x00)
2988                                         sd->sof_read = 1;
2989                                 else
2990                                         sd->sof_read = 0;
2991                                 break;
2992                         }
2993                 }
2994                 break;
2995         case CIT_MODEL2:
2996         case CIT_MODEL4:
2997                 /* TESTME we need to find a longer sof signature to avoid
2998                    false positives */
2999                 for (i = 0; i < len; i++) {
3000                         switch (sd->sof_read) {
3001                         case 0:
3002                                 if (data[i] == 0x00)
3003                                         sd->sof_read++;
3004                                 break;
3005                         case 1:
3006                                 sd->sof_read = 0;
3007                                 if (data[i] == 0xff) {
3008                                         if (i >= 4)
3009                                                 PDEBUG(D_FRAM,
3010                                                        "header found at offset: %d: %02x %02x 00 %02x %02x %02x\n",
3011                                                        i - 1,
3012                                                        data[i - 4],
3013                                                        data[i - 3],
3014                                                        data[i],
3015                                                        data[i + 1],
3016                                                        data[i + 2]);
3017                                         else
3018                                                 PDEBUG(D_FRAM,
3019                                                        "header found at offset: %d: 00 %02x %02x %02x\n",
3020                                                        i - 1,
3021                                                        data[i],
3022                                                        data[i + 1],
3023                                                        data[i + 2]);
3024                                         return data + i + (sd->sof_len - 1);
3025                                 }
3026                                 break;
3027                         }
3028                 }
3029                 break;
3030         }
3031         return NULL;
3032 }
3033
3034 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
3035                         u8 *data, int len)
3036 {
3037         struct sd *sd = (struct sd *) gspca_dev;
3038         unsigned char *sof;
3039
3040         sof = cit_find_sof(gspca_dev, data, len);
3041         if (sof) {
3042                 int n;
3043
3044                 /* finish decoding current frame */
3045                 n = sof - data;
3046                 if (n > sd->sof_len)
3047                         n -= sd->sof_len;
3048                 else
3049                         n = 0;
3050                 gspca_frame_add(gspca_dev, LAST_PACKET,
3051                                 data, n);
3052                 gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
3053                 len -= sof - data;
3054                 data = sof;
3055         }
3056
3057         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
3058 }
3059
3060 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
3061 {
3062         struct sd *sd = (struct sd *) gspca_dev;
3063
3064         sd->brightness = val;
3065         if (gspca_dev->streaming) {
3066                 if (sd->stop_on_control_change)
3067                         sd_stopN(gspca_dev);
3068                 cit_set_brightness(gspca_dev);
3069                 if (sd->stop_on_control_change)
3070                         cit_restart_stream(gspca_dev);
3071         }
3072
3073         return 0;
3074 }
3075
3076 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
3077 {
3078         struct sd *sd = (struct sd *) gspca_dev;
3079
3080         *val = sd->brightness;
3081
3082         return 0;
3083 }
3084
3085 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
3086 {
3087         struct sd *sd = (struct sd *) gspca_dev;
3088
3089         sd->contrast = val;
3090         if (gspca_dev->streaming) {
3091                 if (sd->stop_on_control_change)
3092                         sd_stopN(gspca_dev);
3093                 cit_set_contrast(gspca_dev);
3094                 if (sd->stop_on_control_change)
3095                         cit_restart_stream(gspca_dev);
3096         }
3097
3098         return 0;
3099 }
3100
3101 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
3102 {
3103         struct sd *sd = (struct sd *) gspca_dev;
3104
3105         *val = sd->contrast;
3106
3107         return 0;
3108 }
3109
3110 static int sd_sethue(struct gspca_dev *gspca_dev, __s32 val)
3111 {
3112         struct sd *sd = (struct sd *) gspca_dev;
3113
3114         sd->hue = val;
3115         if (gspca_dev->streaming) {
3116                 if (sd->stop_on_control_change)
3117                         sd_stopN(gspca_dev);
3118                 cit_set_hue(gspca_dev);
3119                 if (sd->stop_on_control_change)
3120                         cit_restart_stream(gspca_dev);
3121         }
3122         return 0;
3123 }
3124
3125 static int sd_gethue(struct gspca_dev *gspca_dev, __s32 *val)
3126 {
3127         struct sd *sd = (struct sd *) gspca_dev;
3128
3129         *val = sd->hue;
3130
3131         return 0;
3132 }
3133
3134 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
3135 {
3136         struct sd *sd = (struct sd *) gspca_dev;
3137
3138         sd->sharpness = val;
3139         if (gspca_dev->streaming) {
3140                 if (sd->stop_on_control_change)
3141                         sd_stopN(gspca_dev);
3142                 cit_set_sharpness(gspca_dev);
3143                 if (sd->stop_on_control_change)
3144                         cit_restart_stream(gspca_dev);
3145         }
3146         return 0;
3147 }
3148
3149 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
3150 {
3151         struct sd *sd = (struct sd *) gspca_dev;
3152
3153         *val = sd->sharpness;
3154
3155         return 0;
3156 }
3157
3158 static int sd_setlighting(struct gspca_dev *gspca_dev, __s32 val)
3159 {
3160         struct sd *sd = (struct sd *) gspca_dev;
3161
3162         sd->lighting = val;
3163         if (gspca_dev->streaming) {
3164                 if (sd->stop_on_control_change)
3165                         sd_stopN(gspca_dev);
3166                 cit_set_lighting(gspca_dev);
3167                 if (sd->stop_on_control_change)
3168                         cit_restart_stream(gspca_dev);
3169         }
3170         return 0;
3171 }
3172
3173 static int sd_getlighting(struct gspca_dev *gspca_dev, __s32 *val)
3174 {
3175         struct sd *sd = (struct sd *) gspca_dev;
3176
3177         *val = sd->lighting;
3178
3179         return 0;
3180 }
3181
3182 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
3183 {
3184         struct sd *sd = (struct sd *) gspca_dev;
3185
3186         sd->hflip = val;
3187         if (gspca_dev->streaming) {
3188                 if (sd->stop_on_control_change)
3189                         sd_stopN(gspca_dev);
3190                 cit_set_hflip(gspca_dev);
3191                 if (sd->stop_on_control_change)
3192                         cit_restart_stream(gspca_dev);
3193         }
3194         return 0;
3195 }
3196
3197 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
3198 {
3199         struct sd *sd = (struct sd *) gspca_dev;
3200
3201         *val = sd->hflip;
3202
3203         return 0;
3204 }
3205
3206 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
3207 static void cit_check_button(struct gspca_dev *gspca_dev)
3208 {
3209         int new_button_state;
3210         struct sd *sd = (struct sd *)gspca_dev;
3211
3212         switch (sd->model) {
3213         case CIT_MODEL3:
3214         case CIT_IBM_NETCAM_PRO:
3215                 break;
3216         default: /* TEST ME unknown if this works on other models too */
3217                 return;
3218         }
3219
3220         /* Read the button state */
3221         cit_read_reg(gspca_dev, 0x0113, 0);
3222         new_button_state = !gspca_dev->usb_buf[0];
3223
3224         /* Tell the cam we've seen the button press, notice that this
3225            is a nop (iow the cam keeps reporting pressed) until the
3226            button is actually released. */
3227         if (new_button_state)
3228                 cit_write_reg(gspca_dev, 0x01, 0x0113);
3229
3230         if (sd->button_state != new_button_state) {
3231                 input_report_key(gspca_dev->input_dev, KEY_CAMERA,
3232                                  new_button_state);
3233                 input_sync(gspca_dev->input_dev);
3234                 sd->button_state = new_button_state;
3235         }
3236 }
3237 #endif
3238
3239 /* sub-driver description */
3240 static const struct sd_desc sd_desc = {
3241         .name = MODULE_NAME,
3242         .ctrls = sd_ctrls,
3243         .nctrls = ARRAY_SIZE(sd_ctrls),
3244         .config = sd_config,
3245         .init = sd_init,
3246         .start = sd_start,
3247         .stopN = sd_stopN,
3248         .stop0 = sd_stop0,
3249         .pkt_scan = sd_pkt_scan,
3250 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
3251         .dq_callback = cit_check_button,
3252         .other_input = 1,
3253 #endif
3254 };
3255
3256 static const struct sd_desc sd_desc_isoc_nego = {
3257         .name = MODULE_NAME,
3258         .ctrls = sd_ctrls,
3259         .nctrls = ARRAY_SIZE(sd_ctrls),
3260         .config = sd_config,
3261         .init = sd_init,
3262         .start = sd_start,
3263         .isoc_init = sd_isoc_init,
3264         .isoc_nego = sd_isoc_nego,
3265         .stopN = sd_stopN,
3266         .stop0 = sd_stop0,
3267         .pkt_scan = sd_pkt_scan,
3268 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
3269         .dq_callback = cit_check_button,
3270         .other_input = 1,
3271 #endif
3272 };
3273
3274 /* -- module initialisation -- */
3275 static const struct usb_device_id device_table[] = {
3276         { USB_DEVICE_VER(0x0545, 0x8080, 0x0001, 0x0001), .driver_info = CIT_MODEL0 },
3277         { USB_DEVICE_VER(0x0545, 0x8080, 0x0002, 0x0002), .driver_info = CIT_MODEL1 },
3278         { USB_DEVICE_VER(0x0545, 0x8080, 0x030a, 0x030a), .driver_info = CIT_MODEL2 },
3279         { USB_DEVICE_VER(0x0545, 0x8080, 0x0301, 0x0301), .driver_info = CIT_MODEL3 },
3280         { USB_DEVICE_VER(0x0545, 0x8002, 0x030a, 0x030a), .driver_info = CIT_MODEL4 },
3281         { USB_DEVICE_VER(0x0545, 0x800c, 0x030a, 0x030a), .driver_info = CIT_MODEL2 },
3282         { USB_DEVICE_VER(0x0545, 0x800d, 0x030a, 0x030a), .driver_info = CIT_MODEL4 },
3283         {}
3284 };
3285 MODULE_DEVICE_TABLE(usb, device_table);
3286
3287 /* -- device connect -- */
3288 static int sd_probe(struct usb_interface *intf,
3289                         const struct usb_device_id *id)
3290 {
3291         const struct sd_desc *desc = &sd_desc;
3292
3293         switch (id->driver_info) {
3294         case CIT_MODEL0:
3295         case CIT_MODEL1:
3296                 if (intf->cur_altsetting->desc.bInterfaceNumber != 2)
3297                         return -ENODEV;
3298                 break;
3299         case CIT_MODEL2:
3300         case CIT_MODEL4:
3301                 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
3302                         return -ENODEV;
3303                 break;
3304         case CIT_MODEL3:
3305                 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
3306                         return -ENODEV;
3307                 /* FIXME this likely applies to all model3 cams and probably
3308                    to other models too. */
3309                 if (ibm_netcam_pro)
3310                         desc = &sd_desc_isoc_nego;
3311                 break;
3312         }
3313
3314         return gspca_dev_probe2(intf, id, desc, sizeof(struct sd), THIS_MODULE);
3315 }
3316
3317 static struct usb_driver sd_driver = {
3318         .name = MODULE_NAME,
3319         .id_table = device_table,
3320         .probe = sd_probe,
3321         .disconnect = gspca_disconnect,
3322 #ifdef CONFIG_PM
3323         .suspend = gspca_suspend,
3324         .resume = gspca_resume,
3325 #endif
3326 };
3327
3328 /* -- module insert / remove -- */
3329 static int __init sd_mod_init(void)
3330 {
3331         return usb_register(&sd_driver);
3332 }
3333 static void __exit sd_mod_exit(void)
3334 {
3335         usb_deregister(&sd_driver);
3336 }
3337
3338 module_init(sd_mod_init);
3339 module_exit(sd_mod_exit);