drivers/media/usb/gspca/xirlink

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

DEFINITIONS
