Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * USB IBM C-It Video Camera driver
0004  *
0005  * Supports Xirlink C-It Video Camera, IBM PC Camera,
0006  * IBM NetCamera and Veo Stingray.
0007  *
0008  * Copyright (C) 2010 Hans de Goede <hdegoede@redhat.com>
0009  *
0010  * This driver is based on earlier work of:
0011  *
0012  * (C) Copyright 1999 Johannes Erdfelt
0013  * (C) Copyright 1999 Randy Dunlap
0014  */
0015 
0016 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0017 
0018 #define MODULE_NAME "xirlink-cit"
0019 
0020 #include <linux/input.h>
0021 #include "gspca.h"
0022 
0023 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
0024 MODULE_DESCRIPTION("Xirlink C-IT");
0025 MODULE_LICENSE("GPL");
0026 
0027 /* FIXME we should autodetect this */
0028 static int ibm_netcam_pro;
0029 module_param(ibm_netcam_pro, int, 0);
0030 MODULE_PARM_DESC(ibm_netcam_pro,
0031          "Use IBM Netcamera Pro init sequences for Model 3 cams");
0032 
0033 /* FIXME this should be handled through the V4L2 input selection API */
0034 static int rca_input;
0035 module_param(rca_input, int, 0644);
0036 MODULE_PARM_DESC(rca_input,
0037          "Use rca input instead of ccd sensor on Model 3 cams");
0038 
0039 /* specific webcam descriptor */
0040 struct sd {
0041     struct gspca_dev gspca_dev;     /* !! must be the first item */
0042     struct v4l2_ctrl *lighting;
0043     u8 model;
0044 #define CIT_MODEL0 0 /* bcd version 0.01 cams ie the xvp-500 */
0045 #define CIT_MODEL1 1 /* The model 1 - 4 nomenclature comes from the old */
0046 #define CIT_MODEL2 2 /* ibmcam driver */
0047 #define CIT_MODEL3 3
0048 #define CIT_MODEL4 4
0049 #define CIT_IBM_NETCAM_PRO 5
0050     u8 input_index;
0051     u8 button_state;
0052     u8 stop_on_control_change;
0053     u8 sof_read;
0054     u8 sof_len;
0055 };
0056 
0057 static void sd_stop0(struct gspca_dev *gspca_dev);
0058 
0059 static const struct v4l2_pix_format cif_yuv_mode[] = {
0060     {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
0061         .bytesperline = 176,
0062         .sizeimage = 176 * 144 * 3 / 2 + 4,
0063         .colorspace = V4L2_COLORSPACE_SRGB},
0064     {352, 288, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
0065         .bytesperline = 352,
0066         .sizeimage = 352 * 288 * 3 / 2 + 4,
0067         .colorspace = V4L2_COLORSPACE_SRGB},
0068 };
0069 
0070 static const struct v4l2_pix_format vga_yuv_mode[] = {
0071     {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
0072         .bytesperline = 160,
0073         .sizeimage = 160 * 120 * 3 / 2 + 4,
0074         .colorspace = V4L2_COLORSPACE_SRGB},
0075     {320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
0076         .bytesperline = 320,
0077         .sizeimage = 320 * 240 * 3 / 2 + 4,
0078         .colorspace = V4L2_COLORSPACE_SRGB},
0079     {640, 480, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
0080         .bytesperline = 640,
0081         .sizeimage = 640 * 480 * 3 / 2 + 4,
0082         .colorspace = V4L2_COLORSPACE_SRGB},
0083 };
0084 
0085 static const struct v4l2_pix_format model0_mode[] = {
0086     {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
0087         .bytesperline = 160,
0088         .sizeimage = 160 * 120 * 3 / 2 + 4,
0089         .colorspace = V4L2_COLORSPACE_SRGB},
0090     {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
0091         .bytesperline = 176,
0092         .sizeimage = 176 * 144 * 3 / 2 + 4,
0093         .colorspace = V4L2_COLORSPACE_SRGB},
0094     {320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
0095         .bytesperline = 320,
0096         .sizeimage = 320 * 240 * 3 / 2 + 4,
0097         .colorspace = V4L2_COLORSPACE_SRGB},
0098 };
0099 
0100 static const struct v4l2_pix_format model2_mode[] = {
0101     {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
0102         .bytesperline = 160,
0103         .sizeimage = 160 * 120 * 3 / 2 + 4,
0104         .colorspace = V4L2_COLORSPACE_SRGB},
0105     {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
0106         .bytesperline = 176,
0107         .sizeimage = 176 * 144 * 3 / 2 + 4,
0108         .colorspace = V4L2_COLORSPACE_SRGB},
0109     {320, 240, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
0110         .bytesperline = 320,
0111         .sizeimage = 320 * 240 + 4,
0112         .colorspace = V4L2_COLORSPACE_SRGB},
0113     {352, 288, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
0114         .bytesperline = 352,
0115         .sizeimage = 352 * 288 + 4,
0116         .colorspace = V4L2_COLORSPACE_SRGB},
0117 };
0118 
0119 /*
0120  * 01.01.08 - Added for RCA video in support -LO
0121  * This struct is used to init the Model3 cam to use the RCA video in port
0122  * instead of the CCD sensor.
0123  */
0124 static const u16 rca_initdata[][3] = {
0125     {0, 0x0000, 0x010c},
0126     {0, 0x0006, 0x012c},
0127     {0, 0x0078, 0x012d},
0128     {0, 0x0046, 0x012f},
0129     {0, 0xd141, 0x0124},
0130     {0, 0x0000, 0x0127},
0131     {0, 0xfea8, 0x0124},
0132     {1, 0x0000, 0x0116},
0133     {0, 0x0064, 0x0116},
0134     {1, 0x0000, 0x0115},
0135     {0, 0x0003, 0x0115},
0136     {0, 0x0008, 0x0123},
0137     {0, 0x0000, 0x0117},
0138     {0, 0x0000, 0x0112},
0139     {0, 0x0080, 0x0100},
0140     {0, 0x0000, 0x0100},
0141     {1, 0x0000, 0x0116},
0142     {0, 0x0060, 0x0116},
0143     {0, 0x0002, 0x0112},
0144     {0, 0x0000, 0x0123},
0145     {0, 0x0001, 0x0117},
0146     {0, 0x0040, 0x0108},
0147     {0, 0x0019, 0x012c},
0148     {0, 0x0040, 0x0116},
0149     {0, 0x000a, 0x0115},
0150     {0, 0x000b, 0x0115},
0151     {0, 0x0078, 0x012d},
0152     {0, 0x0046, 0x012f},
0153     {0, 0xd141, 0x0124},
0154     {0, 0x0000, 0x0127},
0155     {0, 0xfea8, 0x0124},
0156     {0, 0x0064, 0x0116},
0157     {0, 0x0000, 0x0115},
0158     {0, 0x0001, 0x0115},
0159     {0, 0xffff, 0x0124},
0160     {0, 0xfff9, 0x0124},
0161     {0, 0x0086, 0x0127},
0162     {0, 0xfff8, 0x0124},
0163     {0, 0xfffd, 0x0124},
0164     {0, 0x00aa, 0x0127},
0165     {0, 0xfff8, 0x0124},
0166     {0, 0xfffd, 0x0124},
0167     {0, 0x0000, 0x0127},
0168     {0, 0xfff8, 0x0124},
0169     {0, 0xfffd, 0x0124},
0170     {0, 0xfffa, 0x0124},
0171     {0, 0xffff, 0x0124},
0172     {0, 0xfff9, 0x0124},
0173     {0, 0x0086, 0x0127},
0174     {0, 0xfff8, 0x0124},
0175     {0, 0xfffd, 0x0124},
0176     {0, 0x00f2, 0x0127},
0177     {0, 0xfff8, 0x0124},
0178     {0, 0xfffd, 0x0124},
0179     {0, 0x000f, 0x0127},
0180     {0, 0xfff8, 0x0124},
0181     {0, 0xfffd, 0x0124},
0182     {0, 0xfffa, 0x0124},
0183     {0, 0xffff, 0x0124},
0184     {0, 0xfff9, 0x0124},
0185     {0, 0x0086, 0x0127},
0186     {0, 0xfff8, 0x0124},
0187     {0, 0xfffd, 0x0124},
0188     {0, 0x00f8, 0x0127},
0189     {0, 0xfff8, 0x0124},
0190     {0, 0xfffd, 0x0124},
0191     {0, 0x00fc, 0x0127},
0192     {0, 0xfff8, 0x0124},
0193     {0, 0xfffd, 0x0124},
0194     {0, 0xfffa, 0x0124},
0195     {0, 0xffff, 0x0124},
0196     {0, 0xfff9, 0x0124},
0197     {0, 0x0086, 0x0127},
0198     {0, 0xfff8, 0x0124},
0199     {0, 0xfffd, 0x0124},
0200     {0, 0x00f9, 0x0127},
0201     {0, 0xfff8, 0x0124},
0202     {0, 0xfffd, 0x0124},
0203     {0, 0x003c, 0x0127},
0204     {0, 0xfff8, 0x0124},
0205     {0, 0xfffd, 0x0124},
0206     {0, 0xfffa, 0x0124},
0207     {0, 0xffff, 0x0124},
0208     {0, 0xfff9, 0x0124},
0209     {0, 0x0086, 0x0127},
0210     {0, 0xfff8, 0x0124},
0211     {0, 0xfffd, 0x0124},
0212     {0, 0x0027, 0x0127},
0213     {0, 0xfff8, 0x0124},
0214     {0, 0xfffd, 0x0124},
0215     {0, 0x0019, 0x0127},
0216     {0, 0xfff8, 0x0124},
0217     {0, 0xfffd, 0x0124},
0218     {0, 0xfffa, 0x0124},
0219     {0, 0xfff9, 0x0124},
0220     {0, 0x0086, 0x0127},
0221     {0, 0xfff8, 0x0124},
0222     {0, 0xfffd, 0x0124},
0223     {0, 0x0037, 0x0127},
0224     {0, 0xfff8, 0x0124},
0225     {0, 0xfffd, 0x0124},
0226     {0, 0x0000, 0x0127},
0227     {0, 0xfff8, 0x0124},
0228     {0, 0xfffd, 0x0124},
0229     {0, 0x0021, 0x0127},
0230     {0, 0xfff8, 0x0124},
0231     {0, 0xfffd, 0x0124},
0232     {0, 0xfffa, 0x0124},
0233     {0, 0xfff9, 0x0124},
0234     {0, 0x0086, 0x0127},
0235     {0, 0xfff8, 0x0124},
0236     {0, 0xfffd, 0x0124},
0237     {0, 0x0038, 0x0127},
0238     {0, 0xfff8, 0x0124},
0239     {0, 0xfffd, 0x0124},
0240     {0, 0x0006, 0x0127},
0241     {0, 0xfff8, 0x0124},
0242     {0, 0xfffd, 0x0124},
0243     {0, 0x0045, 0x0127},
0244     {0, 0xfff8, 0x0124},
0245     {0, 0xfffd, 0x0124},
0246     {0, 0xfffa, 0x0124},
0247     {0, 0xfff9, 0x0124},
0248     {0, 0x0086, 0x0127},
0249     {0, 0xfff8, 0x0124},
0250     {0, 0xfffd, 0x0124},
0251     {0, 0x0037, 0x0127},
0252     {0, 0xfff8, 0x0124},
0253     {0, 0xfffd, 0x0124},
0254     {0, 0x0001, 0x0127},
0255     {0, 0xfff8, 0x0124},
0256     {0, 0xfffd, 0x0124},
0257     {0, 0x002a, 0x0127},
0258     {0, 0xfff8, 0x0124},
0259     {0, 0xfffd, 0x0124},
0260     {0, 0xfffa, 0x0124},
0261     {0, 0xfff9, 0x0124},
0262     {0, 0x0086, 0x0127},
0263     {0, 0xfff8, 0x0124},
0264     {0, 0xfffd, 0x0124},
0265     {0, 0x0038, 0x0127},
0266     {0, 0xfff8, 0x0124},
0267     {0, 0xfffd, 0x0124},
0268     {0, 0x0000, 0x0127},
0269     {0, 0xfff8, 0x0124},
0270     {0, 0xfffd, 0x0124},
0271     {0, 0x000e, 0x0127},
0272     {0, 0xfff8, 0x0124},
0273     {0, 0xfffd, 0x0124},
0274     {0, 0xfffa, 0x0124},
0275     {0, 0xfff9, 0x0124},
0276     {0, 0x0086, 0x0127},
0277     {0, 0xfff8, 0x0124},
0278     {0, 0xfffd, 0x0124},
0279     {0, 0x0037, 0x0127},
0280     {0, 0xfff8, 0x0124},
0281     {0, 0xfffd, 0x0124},
0282     {0, 0x0001, 0x0127},
0283     {0, 0xfff8, 0x0124},
0284     {0, 0xfffd, 0x0124},
0285     {0, 0x002b, 0x0127},
0286     {0, 0xfff8, 0x0124},
0287     {0, 0xfffd, 0x0124},
0288     {0, 0xfffa, 0x0124},
0289     {0, 0xfff9, 0x0124},
0290     {0, 0x0086, 0x0127},
0291     {0, 0xfff8, 0x0124},
0292     {0, 0xfffd, 0x0124},
0293     {0, 0x0038, 0x0127},
0294     {0, 0xfff8, 0x0124},
0295     {0, 0xfffd, 0x0124},
0296     {0, 0x0001, 0x0127},
0297     {0, 0xfff8, 0x0124},
0298     {0, 0xfffd, 0x0124},
0299     {0, 0x00f4, 0x0127},
0300     {0, 0xfff8, 0x0124},
0301     {0, 0xfffd, 0x0124},
0302     {0, 0xfffa, 0x0124},
0303     {0, 0xfff9, 0x0124},
0304     {0, 0x0086, 0x0127},
0305     {0, 0xfff8, 0x0124},
0306     {0, 0xfffd, 0x0124},
0307     {0, 0x0037, 0x0127},
0308     {0, 0xfff8, 0x0124},
0309     {0, 0xfffd, 0x0124},
0310     {0, 0x0001, 0x0127},
0311     {0, 0xfff8, 0x0124},
0312     {0, 0xfffd, 0x0124},
0313     {0, 0x002c, 0x0127},
0314     {0, 0xfff8, 0x0124},
0315     {0, 0xfffd, 0x0124},
0316     {0, 0xfffa, 0x0124},
0317     {0, 0xfff9, 0x0124},
0318     {0, 0x0086, 0x0127},
0319     {0, 0xfff8, 0x0124},
0320     {0, 0xfffd, 0x0124},
0321     {0, 0x0038, 0x0127},
0322     {0, 0xfff8, 0x0124},
0323     {0, 0xfffd, 0x0124},
0324     {0, 0x0001, 0x0127},
0325     {0, 0xfff8, 0x0124},
0326     {0, 0xfffd, 0x0124},
0327     {0, 0x0004, 0x0127},
0328     {0, 0xfff8, 0x0124},
0329     {0, 0xfffd, 0x0124},
0330     {0, 0xfffa, 0x0124},
0331     {0, 0xfff9, 0x0124},
0332     {0, 0x0086, 0x0127},
0333     {0, 0xfff8, 0x0124},
0334     {0, 0xfffd, 0x0124},
0335     {0, 0x0037, 0x0127},
0336     {0, 0xfff8, 0x0124},
0337     {0, 0xfffd, 0x0124},
0338     {0, 0x0001, 0x0127},
0339     {0, 0xfff8, 0x0124},
0340     {0, 0xfffd, 0x0124},
0341     {0, 0x002d, 0x0127},
0342     {0, 0xfff8, 0x0124},
0343     {0, 0xfffd, 0x0124},
0344     {0, 0xfffa, 0x0124},
0345     {0, 0xfff9, 0x0124},
0346     {0, 0x0086, 0x0127},
0347     {0, 0xfff8, 0x0124},
0348     {0, 0xfffd, 0x0124},
0349     {0, 0x0038, 0x0127},
0350     {0, 0xfff8, 0x0124},
0351     {0, 0xfffd, 0x0124},
0352     {0, 0x0000, 0x0127},
0353     {0, 0xfff8, 0x0124},
0354     {0, 0xfffd, 0x0124},
0355     {0, 0x0014, 0x0127},
0356     {0, 0xfff8, 0x0124},
0357     {0, 0xfffd, 0x0124},
0358     {0, 0xfffa, 0x0124},
0359     {0, 0xfff9, 0x0124},
0360     {0, 0x0086, 0x0127},
0361     {0, 0xfff8, 0x0124},
0362     {0, 0xfffd, 0x0124},
0363     {0, 0x0037, 0x0127},
0364     {0, 0xfff8, 0x0124},
0365     {0, 0xfffd, 0x0124},
0366     {0, 0x0001, 0x0127},
0367     {0, 0xfff8, 0x0124},
0368     {0, 0xfffd, 0x0124},
0369     {0, 0x002e, 0x0127},
0370     {0, 0xfff8, 0x0124},
0371     {0, 0xfffd, 0x0124},
0372     {0, 0xfffa, 0x0124},
0373     {0, 0xfff9, 0x0124},
0374     {0, 0x0086, 0x0127},
0375     {0, 0xfff8, 0x0124},
0376     {0, 0xfffd, 0x0124},
0377     {0, 0x0038, 0x0127},
0378     {0, 0xfff8, 0x0124},
0379     {0, 0xfffd, 0x0124},
0380     {0, 0x0003, 0x0127},
0381     {0, 0xfff8, 0x0124},
0382     {0, 0xfffd, 0x0124},
0383     {0, 0x0000, 0x0127},
0384     {0, 0xfff8, 0x0124},
0385     {0, 0xfffd, 0x0124},
0386     {0, 0xfffa, 0x0124},
0387     {0, 0xfff9, 0x0124},
0388     {0, 0x0086, 0x0127},
0389     {0, 0xfff8, 0x0124},
0390     {0, 0xfffd, 0x0124},
0391     {0, 0x0037, 0x0127},
0392     {0, 0xfff8, 0x0124},
0393     {0, 0xfffd, 0x0124},
0394     {0, 0x0001, 0x0127},
0395     {0, 0xfff8, 0x0124},
0396     {0, 0xfffd, 0x0124},
0397     {0, 0x002f, 0x0127},
0398     {0, 0xfff8, 0x0124},
0399     {0, 0xfffd, 0x0124},
0400     {0, 0xfffa, 0x0124},
0401     {0, 0xfff9, 0x0124},
0402     {0, 0x0086, 0x0127},
0403     {0, 0xfff8, 0x0124},
0404     {0, 0xfffd, 0x0124},
0405     {0, 0x0038, 0x0127},
0406     {0, 0xfff8, 0x0124},
0407     {0, 0xfffd, 0x0124},
0408     {0, 0x0003, 0x0127},
0409     {0, 0xfff8, 0x0124},
0410     {0, 0xfffd, 0x0124},
0411     {0, 0x0014, 0x0127},
0412     {0, 0xfff8, 0x0124},
0413     {0, 0xfffd, 0x0124},
0414     {0, 0xfffa, 0x0124},
0415     {0, 0xfff9, 0x0124},
0416     {0, 0x0086, 0x0127},
0417     {0, 0xfff8, 0x0124},
0418     {0, 0xfffd, 0x0124},
0419     {0, 0x0037, 0x0127},
0420     {0, 0xfff8, 0x0124},
0421     {0, 0xfffd, 0x0124},
0422     {0, 0x0001, 0x0127},
0423     {0, 0xfff8, 0x0124},
0424     {0, 0xfffd, 0x0124},
0425     {0, 0x0040, 0x0127},
0426     {0, 0xfff8, 0x0124},
0427     {0, 0xfffd, 0x0124},
0428     {0, 0xfffa, 0x0124},
0429     {0, 0xfff9, 0x0124},
0430     {0, 0x0086, 0x0127},
0431     {0, 0xfff8, 0x0124},
0432     {0, 0xfffd, 0x0124},
0433     {0, 0x0038, 0x0127},
0434     {0, 0xfff8, 0x0124},
0435     {0, 0xfffd, 0x0124},
0436     {0, 0x0000, 0x0127},
0437     {0, 0xfff8, 0x0124},
0438     {0, 0xfffd, 0x0124},
0439     {0, 0x0040, 0x0127},
0440     {0, 0xfff8, 0x0124},
0441     {0, 0xfffd, 0x0124},
0442     {0, 0xfffa, 0x0124},
0443     {0, 0xfff9, 0x0124},
0444     {0, 0x0086, 0x0127},
0445     {0, 0xfff8, 0x0124},
0446     {0, 0xfffd, 0x0124},
0447     {0, 0x0037, 0x0127},
0448     {0, 0xfff8, 0x0124},
0449     {0, 0xfffd, 0x0124},
0450     {0, 0x0001, 0x0127},
0451     {0, 0xfff8, 0x0124},
0452     {0, 0xfffd, 0x0124},
0453     {0, 0x0053, 0x0127},
0454     {0, 0xfff8, 0x0124},
0455     {0, 0xfffd, 0x0124},
0456     {0, 0xfffa, 0x0124},
0457     {0, 0xfff9, 0x0124},
0458     {0, 0x0086, 0x0127},
0459     {0, 0xfff8, 0x0124},
0460     {0, 0xfffd, 0x0124},
0461     {0, 0x0038, 0x0127},
0462     {0, 0xfff8, 0x0124},
0463     {0, 0xfffd, 0x0124},
0464     {0, 0x0000, 0x0127},
0465     {0, 0xfff8, 0x0124},
0466     {0, 0xfffd, 0x0124},
0467     {0, 0x0038, 0x0127},
0468     {0, 0xfff8, 0x0124},
0469     {0, 0xfffd, 0x0124},
0470     {0, 0xfffa, 0x0124},
0471     {0, 0x0000, 0x0101},
0472     {0, 0x00a0, 0x0103},
0473     {0, 0x0078, 0x0105},
0474     {0, 0x0000, 0x010a},
0475     {0, 0x0024, 0x010b},
0476     {0, 0x0028, 0x0119},
0477     {0, 0x0088, 0x011b},
0478     {0, 0x0002, 0x011d},
0479     {0, 0x0003, 0x011e},
0480     {0, 0x0000, 0x0129},
0481     {0, 0x00fc, 0x012b},
0482     {0, 0x0008, 0x0102},
0483     {0, 0x0000, 0x0104},
0484     {0, 0x0008, 0x011a},
0485     {0, 0x0028, 0x011c},
0486     {0, 0x0021, 0x012a},
0487     {0, 0x0000, 0x0118},
0488     {0, 0x0000, 0x0132},
0489     {0, 0x0000, 0x0109},
0490     {0, 0xfff9, 0x0124},
0491     {0, 0x0086, 0x0127},
0492     {0, 0xfff8, 0x0124},
0493     {0, 0xfffd, 0x0124},
0494     {0, 0x0037, 0x0127},
0495     {0, 0xfff8, 0x0124},
0496     {0, 0xfffd, 0x0124},
0497     {0, 0x0001, 0x0127},
0498     {0, 0xfff8, 0x0124},
0499     {0, 0xfffd, 0x0124},
0500     {0, 0x0031, 0x0127},
0501     {0, 0xfff8, 0x0124},
0502     {0, 0xfffd, 0x0124},
0503     {0, 0xfffa, 0x0124},
0504     {0, 0xfff9, 0x0124},
0505     {0, 0x0086, 0x0127},
0506     {0, 0xfff8, 0x0124},
0507     {0, 0xfffd, 0x0124},
0508     {0, 0x0038, 0x0127},
0509     {0, 0xfff8, 0x0124},
0510     {0, 0xfffd, 0x0124},
0511     {0, 0x0000, 0x0127},
0512     {0, 0xfff8, 0x0124},
0513     {0, 0xfffd, 0x0124},
0514     {0, 0x0000, 0x0127},
0515     {0, 0xfff8, 0x0124},
0516     {0, 0xfffd, 0x0124},
0517     {0, 0xfffa, 0x0124},
0518     {0, 0xfff9, 0x0124},
0519     {0, 0x0086, 0x0127},
0520     {0, 0xfff8, 0x0124},
0521     {0, 0xfffd, 0x0124},
0522     {0, 0x0037, 0x0127},
0523     {0, 0xfff8, 0x0124},
0524     {0, 0xfffd, 0x0124},
0525     {0, 0x0001, 0x0127},
0526     {0, 0xfff8, 0x0124},
0527     {0, 0xfffd, 0x0124},
0528     {0, 0x0040, 0x0127},
0529     {0, 0xfff8, 0x0124},
0530     {0, 0xfffd, 0x0124},
0531     {0, 0xfffa, 0x0124},
0532     {0, 0xfff9, 0x0124},
0533     {0, 0x0086, 0x0127},
0534     {0, 0xfff8, 0x0124},
0535     {0, 0xfffd, 0x0124},
0536     {0, 0x0038, 0x0127},
0537     {0, 0xfff8, 0x0124},
0538     {0, 0xfffd, 0x0124},
0539     {0, 0x0000, 0x0127},
0540     {0, 0xfff8, 0x0124},
0541     {0, 0xfffd, 0x0124},
0542     {0, 0x0040, 0x0127},
0543     {0, 0xfff8, 0x0124},
0544     {0, 0xfffd, 0x0124},
0545     {0, 0xfffa, 0x0124},
0546     {0, 0xfff9, 0x0124},
0547     {0, 0x0086, 0x0127},
0548     {0, 0xfff8, 0x0124},
0549     {0, 0xfffd, 0x0124},
0550     {0, 0x0037, 0x0127},
0551     {0, 0xfff8, 0x0124},
0552     {0, 0xfffd, 0x0124},
0553     {0, 0x0000, 0x0127},
0554     {0, 0xfff8, 0x0124},
0555     {0, 0xfffd, 0x0124},
0556     {0, 0x00dc, 0x0127},
0557     {0, 0xfff8, 0x0124},
0558     {0, 0xfffd, 0x0124},
0559     {0, 0xfffa, 0x0124},
0560     {0, 0xfff9, 0x0124},
0561     {0, 0x0086, 0x0127},
0562     {0, 0xfff8, 0x0124},
0563     {0, 0xfffd, 0x0124},
0564     {0, 0x0038, 0x0127},
0565     {0, 0xfff8, 0x0124},
0566     {0, 0xfffd, 0x0124},
0567     {0, 0x0000, 0x0127},
0568     {0, 0xfff8, 0x0124},
0569     {0, 0xfffd, 0x0124},
0570     {0, 0x0000, 0x0127},
0571     {0, 0xfff8, 0x0124},
0572     {0, 0xfffd, 0x0124},
0573     {0, 0xfffa, 0x0124},
0574     {0, 0xfff9, 0x0124},
0575     {0, 0x0086, 0x0127},
0576     {0, 0xfff8, 0x0124},
0577     {0, 0xfffd, 0x0124},
0578     {0, 0x0037, 0x0127},
0579     {0, 0xfff8, 0x0124},
0580     {0, 0xfffd, 0x0124},
0581     {0, 0x0001, 0x0127},
0582     {0, 0xfff8, 0x0124},
0583     {0, 0xfffd, 0x0124},
0584     {0, 0x0032, 0x0127},
0585     {0, 0xfff8, 0x0124},
0586     {0, 0xfffd, 0x0124},
0587     {0, 0xfffa, 0x0124},
0588     {0, 0xfff9, 0x0124},
0589     {0, 0x0086, 0x0127},
0590     {0, 0xfff8, 0x0124},
0591     {0, 0xfffd, 0x0124},
0592     {0, 0x0038, 0x0127},
0593     {0, 0xfff8, 0x0124},
0594     {0, 0xfffd, 0x0124},
0595     {0, 0x0001, 0x0127},
0596     {0, 0xfff8, 0x0124},
0597     {0, 0xfffd, 0x0124},
0598     {0, 0x0020, 0x0127},
0599     {0, 0xfff8, 0x0124},
0600     {0, 0xfffd, 0x0124},
0601     {0, 0xfffa, 0x0124},
0602     {0, 0xfff9, 0x0124},
0603     {0, 0x0086, 0x0127},
0604     {0, 0xfff8, 0x0124},
0605     {0, 0xfffd, 0x0124},
0606     {0, 0x0037, 0x0127},
0607     {0, 0xfff8, 0x0124},
0608     {0, 0xfffd, 0x0124},
0609     {0, 0x0001, 0x0127},
0610     {0, 0xfff8, 0x0124},
0611     {0, 0xfffd, 0x0124},
0612     {0, 0x0040, 0x0127},
0613     {0, 0xfff8, 0x0124},
0614     {0, 0xfffd, 0x0124},
0615     {0, 0xfffa, 0x0124},
0616     {0, 0xfff9, 0x0124},
0617     {0, 0x0086, 0x0127},
0618     {0, 0xfff8, 0x0124},
0619     {0, 0xfffd, 0x0124},
0620     {0, 0x0038, 0x0127},
0621     {0, 0xfff8, 0x0124},
0622     {0, 0xfffd, 0x0124},
0623     {0, 0x0000, 0x0127},
0624     {0, 0xfff8, 0x0124},
0625     {0, 0xfffd, 0x0124},
0626     {0, 0x0040, 0x0127},
0627     {0, 0xfff8, 0x0124},
0628     {0, 0xfffd, 0x0124},
0629     {0, 0xfffa, 0x0124},
0630     {0, 0xfff9, 0x0124},
0631     {0, 0x0086, 0x0127},
0632     {0, 0xfff8, 0x0124},
0633     {0, 0xfffd, 0x0124},
0634     {0, 0x0037, 0x0127},
0635     {0, 0xfff8, 0x0124},
0636     {0, 0xfffd, 0x0124},
0637     {0, 0x0000, 0x0127},
0638     {0, 0xfff8, 0x0124},
0639     {0, 0xfffd, 0x0124},
0640     {0, 0x0030, 0x0127},
0641     {0, 0xfff8, 0x0124},
0642     {0, 0xfffd, 0x0124},
0643     {0, 0xfffa, 0x0124},
0644     {0, 0xfff9, 0x0124},
0645     {0, 0x0086, 0x0127},
0646     {0, 0xfff8, 0x0124},
0647     {0, 0xfffd, 0x0124},
0648     {0, 0x0038, 0x0127},
0649     {0, 0xfff8, 0x0124},
0650     {0, 0xfffd, 0x0124},
0651     {0, 0x0008, 0x0127},
0652     {0, 0xfff8, 0x0124},
0653     {0, 0xfffd, 0x0124},
0654     {0, 0x0000, 0x0127},
0655     {0, 0xfff8, 0x0124},
0656     {0, 0xfffd, 0x0124},
0657     {0, 0xfffa, 0x0124},
0658     {0, 0x0003, 0x0111},
0659 };
0660 
0661 /* TESTME the old ibmcam driver repeats certain commands to Model1 cameras, we
0662    do the same for now (testing needed to see if this is really necessary) */
0663 static const int cit_model1_ntries = 5;
0664 static const int cit_model1_ntries2 = 2;
0665 
0666 static int cit_write_reg(struct gspca_dev *gspca_dev, u16 value, u16 index)
0667 {
0668     struct usb_device *udev = gspca_dev->dev;
0669     int err;
0670 
0671     err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x00,
0672             USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
0673             value, index, NULL, 0, 1000);
0674     if (err < 0)
0675         pr_err("Failed to write a register (index 0x%04X, value 0x%02X, error %d)\n",
0676                index, value, err);
0677 
0678     return 0;
0679 }
0680 
0681 static int cit_read_reg(struct gspca_dev *gspca_dev, u16 index, int verbose)
0682 {
0683     struct usb_device *udev = gspca_dev->dev;
0684     __u8 *buf = gspca_dev->usb_buf;
0685     int res;
0686 
0687     res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01,
0688             USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
0689             0x00, index, buf, 8, 1000);
0690     if (res < 0) {
0691         pr_err("Failed to read a register (index 0x%04X, error %d)\n",
0692                index, res);
0693         return res;
0694     }
0695 
0696     if (verbose)
0697         gspca_dbg(gspca_dev, D_PROBE, "Register %04x value: %02x\n",
0698               index, buf[0]);
0699 
0700     return 0;
0701 }
0702 
0703 /*
0704  * cit_send_FF_04_02()
0705  *
0706  * This procedure sends magic 3-command prefix to the camera.
0707  * The purpose of this prefix is not known.
0708  *
0709  * History:
0710  * 1/2/00   Created.
0711  */
0712 static void cit_send_FF_04_02(struct gspca_dev *gspca_dev)
0713 {
0714     cit_write_reg(gspca_dev, 0x00FF, 0x0127);
0715     cit_write_reg(gspca_dev, 0x0004, 0x0124);
0716     cit_write_reg(gspca_dev, 0x0002, 0x0124);
0717 }
0718 
0719 static void cit_send_00_04_06(struct gspca_dev *gspca_dev)
0720 {
0721     cit_write_reg(gspca_dev, 0x0000, 0x0127);
0722     cit_write_reg(gspca_dev, 0x0004, 0x0124);
0723     cit_write_reg(gspca_dev, 0x0006, 0x0124);
0724 }
0725 
0726 static void cit_send_x_00(struct gspca_dev *gspca_dev, unsigned short x)
0727 {
0728     cit_write_reg(gspca_dev, x,      0x0127);
0729     cit_write_reg(gspca_dev, 0x0000, 0x0124);
0730 }
0731 
0732 static void cit_send_x_00_05(struct gspca_dev *gspca_dev, unsigned short x)
0733 {
0734     cit_send_x_00(gspca_dev, x);
0735     cit_write_reg(gspca_dev, 0x0005, 0x0124);
0736 }
0737 
0738 static void cit_send_x_00_05_02(struct gspca_dev *gspca_dev, unsigned short x)
0739 {
0740     cit_write_reg(gspca_dev, x,      0x0127);
0741     cit_write_reg(gspca_dev, 0x0000, 0x0124);
0742     cit_write_reg(gspca_dev, 0x0005, 0x0124);
0743     cit_write_reg(gspca_dev, 0x0002, 0x0124);
0744 }
0745 
0746 static void cit_send_x_01_00_05(struct gspca_dev *gspca_dev, u16 x)
0747 {
0748     cit_write_reg(gspca_dev, x,      0x0127);
0749     cit_write_reg(gspca_dev, 0x0001, 0x0124);
0750     cit_write_reg(gspca_dev, 0x0000, 0x0124);
0751     cit_write_reg(gspca_dev, 0x0005, 0x0124);
0752 }
0753 
0754 static void cit_send_x_00_05_02_01(struct gspca_dev *gspca_dev, u16 x)
0755 {
0756     cit_write_reg(gspca_dev, x,      0x0127);
0757     cit_write_reg(gspca_dev, 0x0000, 0x0124);
0758     cit_write_reg(gspca_dev, 0x0005, 0x0124);
0759     cit_write_reg(gspca_dev, 0x0002, 0x0124);
0760     cit_write_reg(gspca_dev, 0x0001, 0x0124);
0761 }
0762 
0763 static void cit_send_x_00_05_02_08_01(struct gspca_dev *gspca_dev, u16 x)
0764 {
0765     cit_write_reg(gspca_dev, x,      0x0127);
0766     cit_write_reg(gspca_dev, 0x0000, 0x0124);
0767     cit_write_reg(gspca_dev, 0x0005, 0x0124);
0768     cit_write_reg(gspca_dev, 0x0002, 0x0124);
0769     cit_write_reg(gspca_dev, 0x0008, 0x0124);
0770     cit_write_reg(gspca_dev, 0x0001, 0x0124);
0771 }
0772 
0773 static void cit_Packet_Format1(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
0774 {
0775     cit_send_x_01_00_05(gspca_dev, 0x0088);
0776     cit_send_x_00_05(gspca_dev, fkey);
0777     cit_send_x_00_05_02_08_01(gspca_dev, val);
0778     cit_send_x_00_05(gspca_dev, 0x0088);
0779     cit_send_x_00_05_02_01(gspca_dev, fkey);
0780     cit_send_x_00_05(gspca_dev, 0x0089);
0781     cit_send_x_00(gspca_dev, fkey);
0782     cit_send_00_04_06(gspca_dev);
0783     cit_read_reg(gspca_dev, 0x0126, 0);
0784     cit_send_FF_04_02(gspca_dev);
0785 }
0786 
0787 static void cit_PacketFormat2(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
0788 {
0789     cit_send_x_01_00_05(gspca_dev, 0x0088);
0790     cit_send_x_00_05(gspca_dev, fkey);
0791     cit_send_x_00_05_02(gspca_dev, val);
0792 }
0793 
0794 static void cit_model2_Packet2(struct gspca_dev *gspca_dev)
0795 {
0796     cit_write_reg(gspca_dev, 0x00ff, 0x012d);
0797     cit_write_reg(gspca_dev, 0xfea3, 0x0124);
0798 }
0799 
0800 static void cit_model2_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
0801 {
0802     cit_write_reg(gspca_dev, 0x00aa, 0x012d);
0803     cit_write_reg(gspca_dev, 0x00ff, 0x012e);
0804     cit_write_reg(gspca_dev, v1,     0x012f);
0805     cit_write_reg(gspca_dev, 0x00ff, 0x0130);
0806     cit_write_reg(gspca_dev, 0xc719, 0x0124);
0807     cit_write_reg(gspca_dev, v2,     0x0127);
0808 
0809     cit_model2_Packet2(gspca_dev);
0810 }
0811 
0812 /*
0813  * cit_model3_Packet1()
0814  *
0815  * 00_0078_012d
0816  * 00_0097_012f
0817  * 00_d141_0124
0818  * 00_0096_0127
0819  * 00_fea8_0124
0820  */
0821 static void cit_model3_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
0822 {
0823     cit_write_reg(gspca_dev, 0x0078, 0x012d);
0824     cit_write_reg(gspca_dev, v1,     0x012f);
0825     cit_write_reg(gspca_dev, 0xd141, 0x0124);
0826     cit_write_reg(gspca_dev, v2,     0x0127);
0827     cit_write_reg(gspca_dev, 0xfea8, 0x0124);
0828 }
0829 
0830 static void cit_model4_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
0831 {
0832     cit_write_reg(gspca_dev, 0x00aa, 0x012d);
0833     cit_write_reg(gspca_dev, v1,     0x012f);
0834     cit_write_reg(gspca_dev, 0xd141, 0x0124);
0835     cit_write_reg(gspca_dev, v2,     0x0127);
0836     cit_write_reg(gspca_dev, 0xfea8, 0x0124);
0837 }
0838 
0839 static void cit_model4_BrightnessPacket(struct gspca_dev *gspca_dev, u16 val)
0840 {
0841     cit_write_reg(gspca_dev, 0x00aa, 0x012d);
0842     cit_write_reg(gspca_dev, 0x0026, 0x012f);
0843     cit_write_reg(gspca_dev, 0xd141, 0x0124);
0844     cit_write_reg(gspca_dev, val,    0x0127);
0845     cit_write_reg(gspca_dev, 0x00aa, 0x0130);
0846     cit_write_reg(gspca_dev, 0x82a8, 0x0124);
0847     cit_write_reg(gspca_dev, 0x0038, 0x012d);
0848     cit_write_reg(gspca_dev, 0x0004, 0x012f);
0849     cit_write_reg(gspca_dev, 0xd145, 0x0124);
0850     cit_write_reg(gspca_dev, 0xfffa, 0x0124);
0851 }
0852 
0853 /* this function is called at probe time */
0854 static int sd_config(struct gspca_dev *gspca_dev,
0855              const struct usb_device_id *id)
0856 {
0857     struct sd *sd = (struct sd *) gspca_dev;
0858     struct cam *cam;
0859 
0860     sd->model = id->driver_info;
0861     if (sd->model == CIT_MODEL3 && ibm_netcam_pro)
0862         sd->model = CIT_IBM_NETCAM_PRO;
0863 
0864     cam = &gspca_dev->cam;
0865     switch (sd->model) {
0866     case CIT_MODEL0:
0867         cam->cam_mode = model0_mode;
0868         cam->nmodes = ARRAY_SIZE(model0_mode);
0869         sd->sof_len = 4;
0870         break;
0871     case CIT_MODEL1:
0872         cam->cam_mode = cif_yuv_mode;
0873         cam->nmodes = ARRAY_SIZE(cif_yuv_mode);
0874         sd->sof_len = 4;
0875         break;
0876     case CIT_MODEL2:
0877         cam->cam_mode = model2_mode + 1; /* no 160x120 */
0878         cam->nmodes = 3;
0879         break;
0880     case CIT_MODEL3:
0881         cam->cam_mode = vga_yuv_mode;
0882         cam->nmodes = ARRAY_SIZE(vga_yuv_mode);
0883         sd->stop_on_control_change = 1;
0884         sd->sof_len = 4;
0885         break;
0886     case CIT_MODEL4:
0887         cam->cam_mode = model2_mode;
0888         cam->nmodes = ARRAY_SIZE(model2_mode);
0889         break;
0890     case CIT_IBM_NETCAM_PRO:
0891         cam->cam_mode = vga_yuv_mode;
0892         cam->nmodes = 2; /* no 640 x 480 */
0893         cam->input_flags = V4L2_IN_ST_VFLIP;
0894         sd->stop_on_control_change = 1;
0895         sd->sof_len = 4;
0896         break;
0897     }
0898 
0899     return 0;
0900 }
0901 
0902 static int cit_init_model0(struct gspca_dev *gspca_dev)
0903 {
0904     cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
0905     cit_write_reg(gspca_dev, 0x0001, 0x0112); /* turn on autogain ? */
0906     cit_write_reg(gspca_dev, 0x0000, 0x0400);
0907     cit_write_reg(gspca_dev, 0x0001, 0x0400);
0908     cit_write_reg(gspca_dev, 0x0000, 0x0420);
0909     cit_write_reg(gspca_dev, 0x0001, 0x0420);
0910     cit_write_reg(gspca_dev, 0x000d, 0x0409);
0911     cit_write_reg(gspca_dev, 0x0002, 0x040a);
0912     cit_write_reg(gspca_dev, 0x0018, 0x0405);
0913     cit_write_reg(gspca_dev, 0x0008, 0x0435);
0914     cit_write_reg(gspca_dev, 0x0026, 0x040b);
0915     cit_write_reg(gspca_dev, 0x0007, 0x0437);
0916     cit_write_reg(gspca_dev, 0x0015, 0x042f);
0917     cit_write_reg(gspca_dev, 0x002b, 0x0439);
0918     cit_write_reg(gspca_dev, 0x0026, 0x043a);
0919     cit_write_reg(gspca_dev, 0x0008, 0x0438);
0920     cit_write_reg(gspca_dev, 0x001e, 0x042b);
0921     cit_write_reg(gspca_dev, 0x0041, 0x042c);
0922 
0923     return 0;
0924 }
0925 
0926 static int cit_init_ibm_netcam_pro(struct gspca_dev *gspca_dev)
0927 {
0928     cit_read_reg(gspca_dev, 0x128, 1);
0929     cit_write_reg(gspca_dev, 0x0003, 0x0133);
0930     cit_write_reg(gspca_dev, 0x0000, 0x0117);
0931     cit_write_reg(gspca_dev, 0x0008, 0x0123);
0932     cit_write_reg(gspca_dev, 0x0000, 0x0100);
0933     cit_read_reg(gspca_dev, 0x0116, 0);
0934     cit_write_reg(gspca_dev, 0x0060, 0x0116);
0935     cit_write_reg(gspca_dev, 0x0002, 0x0112);
0936     cit_write_reg(gspca_dev, 0x0000, 0x0133);
0937     cit_write_reg(gspca_dev, 0x0000, 0x0123);
0938     cit_write_reg(gspca_dev, 0x0001, 0x0117);
0939     cit_write_reg(gspca_dev, 0x0040, 0x0108);
0940     cit_write_reg(gspca_dev, 0x0019, 0x012c);
0941     cit_write_reg(gspca_dev, 0x0060, 0x0116);
0942     cit_write_reg(gspca_dev, 0x0002, 0x0115);
0943     cit_write_reg(gspca_dev, 0x000b, 0x0115);
0944 
0945     cit_write_reg(gspca_dev, 0x0078, 0x012d);
0946     cit_write_reg(gspca_dev, 0x0001, 0x012f);
0947     cit_write_reg(gspca_dev, 0xd141, 0x0124);
0948     cit_write_reg(gspca_dev, 0x0079, 0x012d);
0949     cit_write_reg(gspca_dev, 0x00ff, 0x0130);
0950     cit_write_reg(gspca_dev, 0xcd41, 0x0124);
0951     cit_write_reg(gspca_dev, 0xfffa, 0x0124);
0952     cit_read_reg(gspca_dev, 0x0126, 1);
0953 
0954     cit_model3_Packet1(gspca_dev, 0x0000, 0x0000);
0955     cit_model3_Packet1(gspca_dev, 0x0000, 0x0001);
0956     cit_model3_Packet1(gspca_dev, 0x000b, 0x0000);
0957     cit_model3_Packet1(gspca_dev, 0x000c, 0x0008);
0958     cit_model3_Packet1(gspca_dev, 0x000d, 0x003a);
0959     cit_model3_Packet1(gspca_dev, 0x000e, 0x0060);
0960     cit_model3_Packet1(gspca_dev, 0x000f, 0x0060);
0961     cit_model3_Packet1(gspca_dev, 0x0010, 0x0008);
0962     cit_model3_Packet1(gspca_dev, 0x0011, 0x0004);
0963     cit_model3_Packet1(gspca_dev, 0x0012, 0x0028);
0964     cit_model3_Packet1(gspca_dev, 0x0013, 0x0002);
0965     cit_model3_Packet1(gspca_dev, 0x0014, 0x0000);
0966     cit_model3_Packet1(gspca_dev, 0x0015, 0x00fb);
0967     cit_model3_Packet1(gspca_dev, 0x0016, 0x0002);
0968     cit_model3_Packet1(gspca_dev, 0x0017, 0x0037);
0969     cit_model3_Packet1(gspca_dev, 0x0018, 0x0036);
0970     cit_model3_Packet1(gspca_dev, 0x001e, 0x0000);
0971     cit_model3_Packet1(gspca_dev, 0x001f, 0x0008);
0972     cit_model3_Packet1(gspca_dev, 0x0020, 0x00c1);
0973     cit_model3_Packet1(gspca_dev, 0x0021, 0x0034);
0974     cit_model3_Packet1(gspca_dev, 0x0022, 0x0034);
0975     cit_model3_Packet1(gspca_dev, 0x0025, 0x0002);
0976     cit_model3_Packet1(gspca_dev, 0x0028, 0x0022);
0977     cit_model3_Packet1(gspca_dev, 0x0029, 0x000a);
0978     cit_model3_Packet1(gspca_dev, 0x002b, 0x0000);
0979     cit_model3_Packet1(gspca_dev, 0x002c, 0x0000);
0980     cit_model3_Packet1(gspca_dev, 0x002d, 0x00ff);
0981     cit_model3_Packet1(gspca_dev, 0x002e, 0x00ff);
0982     cit_model3_Packet1(gspca_dev, 0x002f, 0x00ff);
0983     cit_model3_Packet1(gspca_dev, 0x0030, 0x00ff);
0984     cit_model3_Packet1(gspca_dev, 0x0031, 0x00ff);
0985     cit_model3_Packet1(gspca_dev, 0x0032, 0x0007);
0986     cit_model3_Packet1(gspca_dev, 0x0033, 0x0005);
0987     cit_model3_Packet1(gspca_dev, 0x0037, 0x0040);
0988     cit_model3_Packet1(gspca_dev, 0x0039, 0x0000);
0989     cit_model3_Packet1(gspca_dev, 0x003a, 0x0000);
0990     cit_model3_Packet1(gspca_dev, 0x003b, 0x0001);
0991     cit_model3_Packet1(gspca_dev, 0x003c, 0x0000);
0992     cit_model3_Packet1(gspca_dev, 0x0040, 0x000c);
0993     cit_model3_Packet1(gspca_dev, 0x0041, 0x00fb);
0994     cit_model3_Packet1(gspca_dev, 0x0042, 0x0002);
0995     cit_model3_Packet1(gspca_dev, 0x0043, 0x0000);
0996     cit_model3_Packet1(gspca_dev, 0x0045, 0x0000);
0997     cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
0998     cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
0999     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         fallthrough;
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         fallthrough;
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);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!