Pileus Git - ~andy/linux/blob - drivers/media/video/gspca/sonixj.c

   1 /*
   2  *              Sonix sn9c102p sn9c105 sn9c120 (jpeg) library
   3  *              Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr
   4  *
   5  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21
  22 #define MODULE_NAME "sonixj"
  23
  24 #include "gspca.h"
  25 #include "jpeg.h"
  26
  27 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
  28 MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver");
  29 MODULE_LICENSE("GPL");
  30
  31 /* specific webcam descriptor */
  32 struct sd {
  33         struct gspca_dev gspca_dev;     /* !! must be the first item */
  34
  35         atomic_t avg_lum;
  36         unsigned int exposure;
  37
  38         unsigned short brightness;
  39         unsigned char contrast;
  40         unsigned char colors;
  41         unsigned char autogain;
  42         __u8 vflip;                     /* ov7630 only */
  43
  44         signed char ag_cnt;
  45 #define AG_CNT_START 13
  46
  47         char qindex;
  48         unsigned char bridge;
  49 #define BRIDGE_SN9C102P 0
  50 #define BRIDGE_SN9C105 1
  51 #define BRIDGE_SN9C110 2
  52 #define BRIDGE_SN9C120 3
  53 #define BRIDGE_SN9C325 4
  54         char sensor;                    /* Type of image sensor chip */
  55 #define SENSOR_HV7131R 0
  56 #define SENSOR_MI0360 1
  57 #define SENSOR_MO4000 2
  58 #define SENSOR_OM6802 3
  59 #define SENSOR_OV7630 4
  60 #define SENSOR_OV7648 5
  61 #define SENSOR_OV7660 6
  62         unsigned char i2c_base;
  63 };
  64
  65 /* V4L2 controls supported by the driver */
  66 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
  67 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
  68 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
  69 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
  70 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
  71 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
  72 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
  73 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
  74 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
  75 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
  76
  77 static struct ctrl sd_ctrls[] = {
  78         {
  79             {
  80                 .id      = V4L2_CID_BRIGHTNESS,
  81                 .type    = V4L2_CTRL_TYPE_INTEGER,
  82                 .name    = "Brightness",
  83                 .minimum = 0,
  84 #define BRIGHTNESS_MAX 0xffff
  85                 .maximum = BRIGHTNESS_MAX,
  86                 .step    = 1,
  87 #define BRIGHTNESS_DEF 0x7fff
  88                 .default_value = BRIGHTNESS_DEF,
  89             },
  90             .set = sd_setbrightness,
  91             .get = sd_getbrightness,
  92         },
  93         {
  94             {
  95                 .id      = V4L2_CID_CONTRAST,
  96                 .type    = V4L2_CTRL_TYPE_INTEGER,
  97                 .name    = "Contrast",
  98                 .minimum = 0,
  99 #define CONTRAST_MAX 127
 100                 .maximum = CONTRAST_MAX,
 101                 .step    = 1,
 102 #define CONTRAST_DEF 63
 103                 .default_value = CONTRAST_DEF,
 104             },
 105             .set = sd_setcontrast,
 106             .get = sd_getcontrast,
 107         },
 108         {
 109             {
 110                 .id      = V4L2_CID_SATURATION,
 111                 .type    = V4L2_CTRL_TYPE_INTEGER,
 112                 .name    = "Color",
 113                 .minimum = 0,
 114                 .maximum = 64,
 115                 .step    = 1,
 116 #define COLOR_DEF 32
 117                 .default_value = COLOR_DEF,
 118             },
 119             .set = sd_setcolors,
 120             .get = sd_getcolors,
 121         },
 122 #define AUTOGAIN_IDX 3
 123         {
 124             {
 125                 .id      = V4L2_CID_AUTOGAIN,
 126                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 127                 .name    = "Auto Gain",
 128                 .minimum = 0,
 129                 .maximum = 1,
 130                 .step    = 1,
 131 #define AUTOGAIN_DEF 1
 132                 .default_value = AUTOGAIN_DEF,
 133             },
 134             .set = sd_setautogain,
 135             .get = sd_getautogain,
 136         },
 137 /* ov7630 only */
 138 #define VFLIP_IDX 4
 139         {
 140             {
 141                 .id      = V4L2_CID_VFLIP,
 142                 .type    = V4L2_CTRL_TYPE_BOOLEAN,
 143                 .name    = "Vflip",
 144                 .minimum = 0,
 145                 .maximum = 1,
 146                 .step    = 1,
 147 #define VFLIP_DEF 1
 148                 .default_value = VFLIP_DEF,
 149             },
 150             .set = sd_setvflip,
 151             .get = sd_getvflip,
 152         },
 153 };
 154
 155 static struct v4l2_pix_format vga_mode[] = {
 156         {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 157                 .bytesperline = 160,
 158                 .sizeimage = 160 * 120 * 4 / 8 + 590,
 159                 .colorspace = V4L2_COLORSPACE_JPEG,
 160                 .priv = 2},
 161         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 162                 .bytesperline = 320,
 163                 .sizeimage = 320 * 240 * 3 / 8 + 590,
 164                 .colorspace = V4L2_COLORSPACE_JPEG,
 165                 .priv = 1},
 166         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 167                 .bytesperline = 640,
 168                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 169                 .colorspace = V4L2_COLORSPACE_JPEG,
 170                 .priv = 0},
 171 };
 172
 173 /*Data from sn9c102p+hv71331r */
 174 static const __u8 sn_hv7131[] = {
 175 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 176         0x00,   0x03,   0x64,   0x00,   0x1a,   0x20,   0x20,   0x20,
 177 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 178         0xa1,   0x11,   0x02,   0x09,   0x00,   0x00,   0x00,   0x10,
 179 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 180         0x03,   0x00,   0x00,   0x01,   0x03,   0x28,   0x1e,   0x41,
 181 /*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
 182         0x0a,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00
 183 };
 184
 185 static const __u8 sn_mi0360[] = {
 186 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 187         0x00,   0x61,   0x44,   0x00,   0x1a,   0x20,   0x20,   0x20,
 188 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 189         0xb1,   0x5d,   0x07,   0x00,   0x00,   0x00,   0x00,   0x10,
 190 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 191         0x03,   0x00,   0x00,   0x02,   0x0a,   0x28,   0x1e,   0x61,
 192 /*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
 193         0x06,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00
 194 };
 195
 196 static const __u8 sn_mo4000[] = {
 197 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 198         0x12,   0x23,   0x60,   0x00,   0x1a,   0x00,   0x20,   0x18,
 199 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 200         0x81,   0x21,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
 201 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 202         0x03,    0x00,  0x0b,   0x0f,   0x14,   0x28,   0x1e,   0x40,
 203 /*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
 204         0x08,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00
 205 };
 206
 207 static const __u8 sn_om6802[] = {
 208 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 209         0x00,   0x23,   0x72,   0x00,   0x1a,   0x34,   0x27,   0x20,
 210 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 211         0x80,   0x34,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
 212 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 213         0x03,   0x00,   0x51,   0x01,   0x00,   0x28,   0x1e,   0x40,
 214 /*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
 215         0x05,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
 216         0x08,   0x22,   0x44,   0x63,   0x7d,   0x92,   0xa3,   0xaf,
 217         0xbc,   0xc4,   0xcd,   0xd5,   0xdc,   0xe1,   0xe8,   0xef,
 218         0xf7
 219 };
 220
 221 static const __u8 sn_ov7630[] = {
 222 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 223         0x00,   0x21,   0x40,   0x00,   0x1a,   0x20,   0x1f,   0x20,
 224 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 225         0xa1,   0x21,   0x76,   0x21,   0x00,   0x00,   0x00,   0x10,
 226 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 227         0x03,   0x00,   0x04,   0x01,   0x0a,   0x28,   0x1e,   0xc2,
 228 /*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
 229         0x0b,   0x00,   0x00,   0x00,   0x00,   0x00
 230 };
 231
 232 static const __u8 sn_ov7648[] = {
 233 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 234         0x00,   0x21,   0x62,   0x00,   0x1a,   0x20,   0x20,   0x20,
 235 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 236         0xa1,   0x6e,   0x18,   0x65,   0x00,   0x00,   0x00,   0x10,
 237 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 238         0x03,   0x00,   0x00,   0x06,   0x06,   0x28,   0x1e,   0x82,
 239 /*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
 240         0x07,   0x00,   0x00,   0x00,   0x00,   0x00
 241 };
 242
 243 static const __u8 sn_ov7660[]   = {
 244 /*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
 245         0x00,   0x61,   0x40,   0x00,   0x1a,   0x20,   0x20,   0x20,
 246 /*      reg8    reg9    rega    regb    regc    regd    rege    regf */
 247         0x81,   0x21,   0x07,   0x00,   0x00,   0x00,   0x00,   0x10,
 248 /*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
 249         0x03,   0x00,   0x01,   0x01,   0x08,   0x28,   0x1e,   0x20,
 250 /*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
 251         0x07,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
 252 };
 253
 254 /* sequence specific to the sensors - !! index = SENSOR_xxx */
 255 static const __u8 *sn_tb[] = {
 256         sn_hv7131,
 257         sn_mi0360,
 258         sn_mo4000,
 259         sn_om6802,
 260         sn_ov7630,
 261         sn_ov7648,
 262         sn_ov7660
 263 };
 264
 265 static const __u8 gamma_def[] = {
 266         0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
 267         0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
 268 };
 269
 270 /* color matrix and offsets */
 271 static const __u8 reg84[] = {
 272         0x14, 0x00, 0x27, 0x00, 0x07, 0x00,     /* YR YG YB gains */
 273         0xe8, 0x0f, 0xda, 0x0f, 0x40, 0x00,     /* UR UG UB */
 274         0x3e, 0x00, 0xcd, 0x0f, 0xf7, 0x0f,     /* VR VG VB */
 275         0x00, 0x00, 0x00                        /* YUV offsets */
 276 };
 277 static const __u8 hv7131r_sensor_init[][8] = {
 278         {0xC1, 0x11, 0x01, 0x08, 0x01, 0x00, 0x00, 0x10},
 279         {0xB1, 0x11, 0x34, 0x17, 0x7F, 0x00, 0x00, 0x10},
 280         {0xD1, 0x11, 0x40, 0xFF, 0x7F, 0x7F, 0x7F, 0x10},
 281         {0x91, 0x11, 0x44, 0x00, 0x00, 0x00, 0x00, 0x10},
 282         {0xD1, 0x11, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 283         {0xD1, 0x11, 0x14, 0x01, 0xE2, 0x02, 0x82, 0x10},
 284         {0x91, 0x11, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
 285
 286         {0xA1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 287         {0xA1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 288         {0xC1, 0x11, 0x25, 0x00, 0x61, 0xA8, 0x00, 0x10},
 289         {0xA1, 0x11, 0x30, 0x22, 0x00, 0x00, 0x00, 0x10},
 290         {0xC1, 0x11, 0x31, 0x20, 0x2E, 0x20, 0x00, 0x10},
 291         {0xC1, 0x11, 0x25, 0x00, 0xC3, 0x50, 0x00, 0x10},
 292         {0xA1, 0x11, 0x30, 0x07, 0x00, 0x00, 0x00, 0x10}, /* gain14 */
 293         {0xC1, 0x11, 0x31, 0x10, 0x10, 0x10, 0x00, 0x10}, /* r g b 101a10 */
 294
 295         {0xA1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 296         {0xA1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
 297         {0xA1, 0x11, 0x21, 0xD0, 0x00, 0x00, 0x00, 0x10},
 298         {0xA1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 299         {0xA1, 0x11, 0x23, 0x09, 0x00, 0x00, 0x00, 0x10},
 300
 301         {0xA1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 302         {0xA1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
 303         {0xA1, 0x11, 0x21, 0xD0, 0x00, 0x00, 0x00, 0x10},
 304         {0xA1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 305         {0xA1, 0x11, 0x23, 0x10, 0x00, 0x00, 0x00, 0x10},
 306         {}
 307 };
 308 static const __u8 mi0360_sensor_init[][8] = {
 309         {0xB1, 0x5D, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
 310         {0xB1, 0x5D, 0x0D, 0x00, 0x01, 0x00, 0x00, 0x10},
 311         {0xB1, 0x5D, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x10},
 312         {0xD1, 0x5D, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
 313         {0xD1, 0x5D, 0x03, 0x01, 0xE2, 0x02, 0x82, 0x10},
 314         {0xD1, 0x5D, 0x05, 0x00, 0x09, 0x00, 0x53, 0x10},
 315         {0xB1, 0x5D, 0x0D, 0x00, 0x02, 0x00, 0x00, 0x10},
 316         {0xD1, 0x5D, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x10},
 317         {0xD1, 0x5D, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x10},
 318         {0xD1, 0x5D, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x10},
 319         {0xD1, 0x5D, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 320         {0xD1, 0x5D, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
 321         {0xD1, 0x5D, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
 322         {0xD1, 0x5D, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
 323         {0xD1, 0x5D, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
 324         {0xD1, 0x5D, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x10},
 325         {0xD1, 0x5D, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x10},
 326         {0xB1, 0x5D, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
 327         {0xD1, 0x5D, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
 328         {0xD1, 0x5D, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 329         {0xD1, 0x5D, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
 330         {0xD1, 0x5D, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
 331         {0xD1, 0x5D, 0x2F, 0xF7, 0xB0, 0x00, 0x04, 0x10},
 332         {0xD1, 0x5D, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
 333         {0xD1, 0x5D, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
 334         {0xB1, 0x5D, 0x3D, 0x06, 0x8F, 0x00, 0x00, 0x10},
 335         {0xD1, 0x5D, 0x40, 0x01, 0xE0, 0x00, 0xD1, 0x10},
 336         {0xB1, 0x5D, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
 337         {0xD1, 0x5D, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
 338         {0xD1, 0x5D, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x10},
 339         {0xD1, 0x5D, 0x5C, 0x00, 0x00, 0x00, 0x00, 0x10},
 340         {0xD1, 0x5D, 0x5E, 0x00, 0x00, 0xA3, 0x1D, 0x10},
 341         {0xB1, 0x5D, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},
 342
 343         {0xB1, 0x5D, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
 344         {0xB1, 0x5D, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
 345         {0xB1, 0x5D, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
 346         {0xD1, 0x5D, 0x2B, 0x00, 0xA0, 0x00, 0xB0, 0x10},
 347         {0xD1, 0x5D, 0x2D, 0x00, 0xA0, 0x00, 0xA0, 0x10},
 348
 349         {0xB1, 0x5D, 0x0A, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor clck ?2 */
 350         {0xB1, 0x5D, 0x06, 0x00, 0x30, 0x00, 0x00, 0x10},
 351         {0xB1, 0x5D, 0x05, 0x00, 0x0A, 0x00, 0x00, 0x10},
 352         {0xB1, 0x5D, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10}, /* exposure 2 */
 353
 354         {0xD1, 0x5D, 0x2B, 0x00, 0xB9, 0x00, 0xE3, 0x10},
 355         {0xD1, 0x5D, 0x2D, 0x00, 0x5f, 0x00, 0xB9, 0x10}, /* 42 */
 356 /*      {0xB1, 0x5D, 0x35, 0x00, 0x67, 0x00, 0x00, 0x10}, * gain orig */
 357 /*      {0xB1, 0x5D, 0x35, 0x00, 0x20, 0x00, 0x00, 0x10}, * gain */
 358         {0xB1, 0x5D, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10}, /* update */
 359         {0xB1, 0x5D, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
 360         {}
 361 };
 362 static const __u8 mo4000_sensor_init[][8] = {
 363         {0xa1, 0x21, 0x01, 0x02, 0x00, 0x00, 0x00, 0x10},
 364         {0xa1, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10},
 365         {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
 366         {0xa1, 0x21, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
 367         {0xa1, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
 368         {0xa1, 0x21, 0x05, 0x04, 0x00, 0x00, 0x00, 0x10},
 369         {0xa1, 0x21, 0x06, 0x80, 0x00, 0x00, 0x00, 0x10},
 370         {0xa1, 0x21, 0x06, 0x81, 0x00, 0x00, 0x00, 0x10},
 371         {0xa1, 0x21, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
 372         {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
 373         {0xa1, 0x21, 0x11, 0x20, 0x00, 0x00, 0x00, 0x10},
 374         {0xa1, 0x21, 0x11, 0x30, 0x00, 0x00, 0x00, 0x10},
 375         {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
 376         {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
 377         {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
 378         {0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 379         {0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10},
 380         {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10},
 381         {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
 382         {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
 383         {}
 384 };
 385 static __u8 om6802_sensor_init[][8] = {
 386         {0xa0, 0x34, 0x90, 0x05, 0x00, 0x00, 0x00, 0x10},
 387         {0xa0, 0x34, 0x49, 0x85, 0x00, 0x00, 0x00, 0x10},
 388         {0xa0, 0x34, 0x5a, 0xc0, 0x00, 0x00, 0x00, 0x10},
 389         {0xa0, 0x34, 0xdd, 0x18, 0x00, 0x00, 0x00, 0x10},
 390 /*      {0xa0, 0x34, 0xfb, 0x11, 0x00, 0x00, 0x00, 0x10}, */
 391         {0xa0, 0x34, 0xf0, 0x04, 0x00, 0x00, 0x00, 0x10},
 392                                         /* white balance & auto-exposure */
 393 /*      {0xa0, 0x34, 0xf1, 0x02, 0x00, 0x00, 0x00, 0x10},
 394                                                          * set color mode */
 395 /*      {0xa0, 0x34, 0xfe, 0x5b, 0x00, 0x00, 0x00, 0x10},
 396                                                  * max AGC value in AE */
 397 /*      {0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10},
 398                                                          * preset AGC */
 399 /*      {0xa0, 0x34, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x10},
 400                                                  * preset brightness */
 401 /*      {0xa0, 0x34, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x10},
 402                                                          * preset contrast */
 403 /*      {0xa0, 0x34, 0xe8, 0x31, 0x00, 0x00, 0x00, 0x10},
 404                                                          * preset gamma */
 405         {0xa0, 0x34, 0xe9, 0x0f, 0x00, 0x00, 0x00, 0x10},
 406                                         /* luminance mode (0x4f = AE) */
 407         {0xa0, 0x34, 0xe4, 0xff, 0x00, 0x00, 0x00, 0x10},
 408                                                         /* preset shutter */
 409 /*      {0xa0, 0x34, 0xef, 0x00, 0x00, 0x00, 0x00, 0x10},
 410                                                          * auto frame rate */
 411 /*      {0xa0, 0x34, 0xfb, 0xee, 0x00, 0x00, 0x00, 0x10}, */
 412
 413 /*      {0xa0, 0x34, 0x71, 0x84, 0x00, 0x00, 0x00, 0x10}, */
 414 /*      {0xa0, 0x34, 0x72, 0x05, 0x00, 0x00, 0x00, 0x10}, */
 415 /*      {0xa0, 0x34, 0x68, 0x80, 0x00, 0x00, 0x00, 0x10}, */
 416 /*      {0xa0, 0x34, 0x69, 0x01, 0x00, 0x00, 0x00, 0x10}, */
 417         {}
 418 };
 419 static const __u8 ov7630_sensor_init[][8] = {
 420         {0xa1, 0x21, 0x76, 0x01, 0x00, 0x00, 0x00, 0x10},
 421         {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
 422 /* win: delay 20ms */
 423         {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 424         {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
 425 /* win: delay 20ms */
 426         {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 427 /* win: i2c_r from 00 to 80 */
 428         {0xd1, 0x21, 0x03, 0x80, 0x10, 0x20, 0x80, 0x10},
 429         {0xb1, 0x21, 0x0c, 0x20, 0x20, 0x00, 0x00, 0x10},
 430         {0xd1, 0x21, 0x11, 0x00, 0x48, 0xc0, 0x00, 0x10},
 431         {0xb1, 0x21, 0x15, 0x80, 0x03, 0x00, 0x00, 0x10},
 432         {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
 433         {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
 434         {0xd1, 0x21, 0x1f, 0x00, 0x80, 0x80, 0x80, 0x10},
 435         {0xd1, 0x21, 0x23, 0xde, 0x10, 0x8a, 0xa0, 0x10},
 436         {0xc1, 0x21, 0x27, 0xca, 0xa2, 0x74, 0x00, 0x10},
 437         {0xd1, 0x21, 0x2a, 0x88, 0x00, 0x88, 0x01, 0x10},
 438         {0xc1, 0x21, 0x2e, 0x80, 0x00, 0x18, 0x00, 0x10},
 439         {0xa1, 0x21, 0x21, 0x08, 0x00, 0x00, 0x00, 0x10},
 440         {0xa1, 0x21, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 441         {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
 442         {0xb1, 0x21, 0x32, 0xc2, 0x08, 0x00, 0x00, 0x10},
 443         {0xb1, 0x21, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x10},
 444         {0xd1, 0x21, 0x60, 0x05, 0x40, 0x12, 0x57, 0x10},
 445         {0xa1, 0x21, 0x64, 0x73, 0x00, 0x00, 0x00, 0x10},
 446         {0xd1, 0x21, 0x65, 0x00, 0x55, 0x01, 0xac, 0x10},
 447         {0xa1, 0x21, 0x69, 0x38, 0x00, 0x00, 0x00, 0x10},
 448         {0xd1, 0x21, 0x6f, 0x1f, 0x01, 0x00, 0x10, 0x10},
 449         {0xd1, 0x21, 0x73, 0x50, 0x20, 0x02, 0x01, 0x10},
 450         {0xd1, 0x21, 0x77, 0xf3, 0x90, 0x98, 0x98, 0x10},
 451         {0xc1, 0x21, 0x7b, 0x00, 0x4c, 0xf7, 0x00, 0x10},
 452         {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
 453         {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
 454 /* */
 455         {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 456         {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 457 /*fixme: + 0x12, 0x04*/
 458 /*      {0xa1, 0x21, 0x75, 0x82, 0x00, 0x00, 0x00, 0x10},  * COMN
 459                                                          * set by setvflip */
 460         {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
 461         {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
 462         {0xb1, 0x21, 0x01, 0x80, 0x80, 0x00, 0x00, 0x10},
 463 /* */
 464         {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
 465         {0xa1, 0x21, 0x2a, 0x88, 0x00, 0x00, 0x00, 0x10},
 466         {0xa1, 0x21, 0x2b, 0x34, 0x00, 0x00, 0x00, 0x10},
 467 /* */
 468         {0xa1, 0x21, 0x10, 0x83, 0x00, 0x00, 0x00, 0x10},
 469 /*      {0xb1, 0x21, 0x01, 0x88, 0x70, 0x00, 0x00, 0x10}, */
 470         {}
 471 };
 472 static const __u8 ov7660_sensor_init[][8] = {
 473         {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset SCCB */
 474 /*              (delay 20ms) */
 475         {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
 476                                                 /* Outformat = rawRGB */
 477         {0xa1, 0x21, 0x13, 0xb8, 0x00, 0x00, 0x00, 0x10}, /* init COM8 */
 478         {0xd1, 0x21, 0x00, 0x01, 0x74, 0x74, 0x00, 0x10},
 479                                                 /* GAIN BLUE RED VREF */
 480         {0xd1, 0x21, 0x04, 0x00, 0x7d, 0x62, 0x00, 0x10},
 481                                                 /* COM 1 BAVE GEAVE AECHH */
 482         {0xb1, 0x21, 0x08, 0x83, 0x01, 0x00, 0x00, 0x10}, /* RAVE COM2 */
 483         {0xd1, 0x21, 0x0c, 0x00, 0x08, 0x04, 0x4f, 0x10}, /* COM 3 4 5 6 */
 484         {0xd1, 0x21, 0x10, 0x7f, 0x40, 0x05, 0xff, 0x10},
 485                                                 /* AECH CLKRC COM7 COM8 */
 486         {0xc1, 0x21, 0x14, 0x2c, 0x00, 0x02, 0x00, 0x10}, /* COM9 COM10 */
 487         {0xd1, 0x21, 0x17, 0x10, 0x60, 0x02, 0x7b, 0x10},
 488                                                 /* HSTART HSTOP VSTRT VSTOP */
 489         {0xa1, 0x21, 0x1b, 0x02, 0x00, 0x00, 0x00, 0x10}, /* PSHFT */
 490         {0xb1, 0x21, 0x1e, 0x01, 0x0e, 0x00, 0x00, 0x10}, /* MVFP LAEC */
 491         {0xd1, 0x21, 0x20, 0x07, 0x07, 0x07, 0x07, 0x10},
 492                                         /* BOS GBOS GROS ROS (BGGR offset) */
 493 /*      {0xd1, 0x21, 0x24, 0x68, 0x58, 0xd4, 0x80, 0x10}, */
 494         {0xd1, 0x21, 0x24, 0x78, 0x68, 0xd4, 0x80, 0x10},
 495                                                 /* AEW AEB VPT BBIAS */
 496         {0xd1, 0x21, 0x28, 0x80, 0x30, 0x00, 0x00, 0x10},
 497                                                 /* GbBIAS RSVD EXHCH EXHCL */
 498         {0xd1, 0x21, 0x2c, 0x80, 0x00, 0x00, 0x62, 0x10},
 499                                                 /* RBIAS ADVFL ASDVFH YAVE */
 500         {0xc1, 0x21, 0x30, 0x08, 0x30, 0xb4, 0x00, 0x10},
 501                                                 /* HSYST HSYEN HREF */
 502         {0xd1, 0x21, 0x33, 0x00, 0x07, 0x84, 0x00, 0x10}, /* reserved */
 503         {0xd1, 0x21, 0x37, 0x0c, 0x02, 0x43, 0x00, 0x10},
 504                                                 /* ADC ACOM OFON TSLB */
 505         {0xd1, 0x21, 0x3b, 0x02, 0x6c, 0x19, 0x0e, 0x10},
 506                                                 /* COM11 COM12 COM13 COM14 */
 507         {0xd1, 0x21, 0x3f, 0x41, 0xc1, 0x22, 0x08, 0x10},
 508                                                 /* EDGE COM15 COM16 COM17 */
 509         {0xd1, 0x21, 0x43, 0xf0, 0x10, 0x78, 0xa8, 0x10}, /* reserved */
 510         {0xd1, 0x21, 0x47, 0x60, 0x80, 0x00, 0x00, 0x10}, /* reserved */
 511         {0xd1, 0x21, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* reserved */
 512         {0xd1, 0x21, 0x4f, 0x46, 0x36, 0x0f, 0x17, 0x10}, /* MTX 1 2 3 4 */
 513         {0xd1, 0x21, 0x53, 0x7f, 0x96, 0x40, 0x40, 0x10}, /* MTX 5 6 7 8 */
 514         {0xb1, 0x21, 0x57, 0x40, 0x0f, 0x00, 0x00, 0x10}, /* MTX9 MTXS */
 515         {0xd1, 0x21, 0x59, 0xba, 0x9a, 0x22, 0xb9, 0x10}, /* reserved */
 516         {0xd1, 0x21, 0x5d, 0x9b, 0x10, 0xf0, 0x05, 0x10}, /* reserved */
 517         {0xa1, 0x21, 0x61, 0x60, 0x00, 0x00, 0x00, 0x10}, /* reserved */
 518         {0xd1, 0x21, 0x62, 0x00, 0x00, 0x50, 0x30, 0x10},
 519                                                 /* LCC1 LCC2 LCC3 LCC4 */
 520         {0xa1, 0x21, 0x66, 0x00, 0x00, 0x00, 0x00, 0x10}, /* LCC5 */
 521         {0xd1, 0x21, 0x67, 0x80, 0x7a, 0x90, 0x80, 0x10}, /* MANU */
 522         {0xa1, 0x21, 0x6b, 0x0a, 0x00, 0x00, 0x00, 0x10},
 523                                         /* band gap reference [0:3] DBLV */
 524         {0xd1, 0x21, 0x6c, 0x30, 0x48, 0x80, 0x74, 0x10}, /* gamma curve */
 525         {0xd1, 0x21, 0x70, 0x64, 0x60, 0x5c, 0x58, 0x10}, /* gamma curve */
 526         {0xd1, 0x21, 0x74, 0x54, 0x4c, 0x40, 0x38, 0x10}, /* gamma curve */
 527         {0xd1, 0x21, 0x78, 0x34, 0x30, 0x2f, 0x2b, 0x10}, /* gamma curve */
 528         {0xd1, 0x21, 0x7c, 0x03, 0x07, 0x17, 0x34, 0x10}, /* gamma curve */
 529         {0xd1, 0x21, 0x80, 0x41, 0x4d, 0x58, 0x63, 0x10}, /* gamma curve */
 530         {0xd1, 0x21, 0x84, 0x6e, 0x77, 0x87, 0x95, 0x10}, /* gamma curve */
 531         {0xc1, 0x21, 0x88, 0xaf, 0xc7, 0xdf, 0x00, 0x10}, /* gamma curve */
 532         {0xc1, 0x21, 0x8b, 0x99, 0x99, 0xcf, 0x00, 0x10}, /* reserved */
 533         {0xb1, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x10}, /* DM_LNL/H */
 534 /****** (some exchanges in the win trace) ******/
 535         {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10}, /* MVFP */
 536                                                 /* bits[3..0]reserved */
 537         {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10},
 538         {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
 539                                                 /* VREF vertical frame ctrl */
 540         {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
 541         {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10}, /* AECH 0x20 */
 542         {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFL */
 543         {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFH */
 544         {0xa1, 0x21, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x10}, /* GAIN */
 545 /*      {0xb1, 0x21, 0x01, 0x78, 0x78, 0x00, 0x00, 0x10}, * BLUE */
 546 /****** (some exchanges in the win trace) ******/
 547         {0xa1, 0x21, 0x93, 0x00, 0x00, 0x00, 0x00, 0x10},/* dummy line hight */
 548         {0xa1, 0x21, 0x92, 0x25, 0x00, 0x00, 0x00, 0x10}, /* dummy line low */
 549         {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCH */
 550         {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCL */
 551 /*      {0xa1, 0x21, 0x02, 0x90, 0x00, 0x00, 0x00, 0x10},  * RED */
 552 /****** (some exchanges in the win trace) ******/
 553 /******!! startsensor KO if changed !!****/
 554         {0xa1, 0x21, 0x93, 0x01, 0x00, 0x00, 0x00, 0x10},
 555         {0xa1, 0x21, 0x92, 0xff, 0x00, 0x00, 0x00, 0x10},
 556         {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
 557         {0xa1, 0x21, 0x2b, 0xc3, 0x00, 0x00, 0x00, 0x10},
 558         {}
 559 };
 560 /*        reg 0x04        reg 0x07                 reg 0x10 */
 561 /* expo = (COM1 & 0x02) | ((AECHH & 0x2f) << 10) | (AECh << 2) */
 562
 563 static const __u8 ov7648_sensor_init[][8] = {
 564         {0xC1, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00},
 565         {0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00},
 566         {0xC1, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00},
 567         {0xA1, 0x6E, 0x3F, 0x20, 0x00, 0x00, 0x00, 0x10},
 568         {0xA1, 0x6E, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x10},
 569         {0xA1, 0x6E, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x10},
 570         {0xD1, 0x6E, 0x04, 0x02, 0xB1, 0x02, 0x39, 0x10},
 571         {0xD1, 0x6E, 0x08, 0x00, 0x01, 0x00, 0x00, 0x10},
 572         {0xD1, 0x6E, 0x0C, 0x02, 0x7F, 0x01, 0xE0, 0x10},
 573         {0xD1, 0x6E, 0x12, 0x03, 0x02, 0x00, 0x03, 0x10},
 574         {0xD1, 0x6E, 0x16, 0x85, 0x40, 0x4A, 0x40, 0x10},
 575         {0xC1, 0x6E, 0x1A, 0x00, 0x80, 0x00, 0x00, 0x10},
 576         {0xD1, 0x6E, 0x1D, 0x08, 0x03, 0x00, 0x00, 0x10},
 577         {0xD1, 0x6E, 0x23, 0x00, 0xB0, 0x00, 0x94, 0x10},
 578         {0xD1, 0x6E, 0x27, 0x58, 0x00, 0x00, 0x00, 0x10},
 579         {0xD1, 0x6E, 0x2D, 0x14, 0x35, 0x61, 0x84, 0x10},
 580         {0xD1, 0x6E, 0x31, 0xA2, 0xBD, 0xD8, 0xFF, 0x10},
 581         {0xD1, 0x6E, 0x35, 0x06, 0x1E, 0x12, 0x02, 0x10},
 582         {0xD1, 0x6E, 0x39, 0xAA, 0x53, 0x37, 0xD5, 0x10},
 583         {0xA1, 0x6E, 0x3D, 0xF2, 0x00, 0x00, 0x00, 0x10},
 584         {0xD1, 0x6E, 0x3E, 0x00, 0x00, 0x80, 0x03, 0x10},
 585         {0xD1, 0x6E, 0x42, 0x03, 0x00, 0x00, 0x00, 0x10},
 586         {0xC1, 0x6E, 0x46, 0x00, 0x80, 0x80, 0x00, 0x10},
 587         {0xD1, 0x6E, 0x4B, 0x02, 0xEF, 0x08, 0xCD, 0x10},
 588         {0xD1, 0x6E, 0x4F, 0x00, 0xD0, 0x00, 0xA0, 0x10},
 589         {0xD1, 0x6E, 0x53, 0x01, 0xAA, 0x01, 0x40, 0x10},
 590         {0xD1, 0x6E, 0x5A, 0x50, 0x04, 0x30, 0x03, 0x10},
 591         {0xA1, 0x6E, 0x5E, 0x00, 0x00, 0x00, 0x00, 0x10},
 592         {0xD1, 0x6E, 0x5F, 0x10, 0x40, 0xFF, 0x00, 0x10},
 593   /*    {0xD1, 0x6E, 0x63, 0x40, 0x40, 0x00, 0x00, 0x10},
 594         {0xD1, 0x6E, 0x67, 0x00, 0x00, 0x00, 0x00, 0x10},
 595  * This is currently setting a
 596  * blue tint, and some things more , i leave it here for future test if
 597  * somene is having problems with color on this sensor
 598         {0xD1, 0x6E, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x10},
 599         {0xD1, 0x6E, 0x6F, 0x00, 0x00, 0x00, 0x00, 0x10},
 600         {0xC1, 0x6E, 0x73, 0x10, 0x80, 0xEB, 0x00, 0x10},
 601         {0xA1, 0x6E, 0x1E, 0x03, 0x00, 0x00, 0x00, 0x10},
 602         {0xA1, 0x6E, 0x15, 0x01, 0x00, 0x00, 0x00, 0x10},
 603         {0xC1, 0x6E, 0x16, 0x40, 0x40, 0x40, 0x00, 0x10},
 604         {0xA1, 0x6E, 0x1D, 0x08, 0x00, 0x00, 0x00, 0x10},
 605         {0xA1, 0x6E, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
 606         {0xA1, 0x6E, 0x07, 0xB5, 0x00, 0x00, 0x00, 0x10},
 607         {0xA1, 0x6E, 0x18, 0x6B, 0x00, 0x00, 0x00, 0x10},
 608         {0xA1, 0x6E, 0x1D, 0x08, 0x00, 0x00, 0x00, 0x10},
 609         {0xA1, 0x6E, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
 610         {0xA1, 0x6E, 0x07, 0xB8, 0x00, 0x00, 0x00, 0x10},  */
 611         {0xC1, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00},
 612         {0xA1, 0x6E, 0x06, 0x03, 0x00, 0x00, 0x00, 0x10}, /* Bright... */
 613         {0xA1, 0x6E, 0x07, 0x66, 0x00, 0x00, 0x00, 0x10}, /* B.. */
 614         {0xC1, 0x6E, 0x1A, 0x03, 0x65, 0x90, 0x00, 0x10}, /* Bright/Witen....*/
 615 /*      {0xC1, 0x6E, 0x16, 0x45, 0x40, 0x60, 0x00, 0x10},  * Bright/Witene */
 616         {}
 617 };
 618
 619 static const __u8 qtable4[] = {
 620         0x06, 0x04, 0x04, 0x06, 0x04, 0x04, 0x06, 0x06, 0x06, 0x06, 0x08, 0x06,
 621         0x06, 0x08, 0x0A, 0x11,
 622         0x0A, 0x0A, 0x08, 0x08, 0x0A, 0x15, 0x0F, 0x0F, 0x0C, 0x11, 0x19, 0x15,
 623         0x19, 0x19, 0x17, 0x15,
 624         0x17, 0x17, 0x1B, 0x1D, 0x25, 0x21, 0x1B, 0x1D, 0x23, 0x1D, 0x17, 0x17,
 625         0x21, 0x2E, 0x21, 0x23,
 626         0x27, 0x29, 0x2C, 0x2C, 0x2C, 0x19, 0x1F, 0x30, 0x32, 0x2E, 0x29, 0x32,
 627         0x25, 0x29, 0x2C, 0x29,
 628         0x06, 0x08, 0x08, 0x0A, 0x08, 0x0A, 0x13, 0x0A, 0x0A, 0x13, 0x29, 0x1B,
 629         0x17, 0x1B, 0x29, 0x29,
 630         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
 631         0x29, 0x29, 0x29, 0x29,
 632         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
 633         0x29, 0x29, 0x29, 0x29,
 634         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
 635         0x29, 0x29, 0x29, 0x29
 636 };
 637
 638 /* read <len> bytes to gspca_dev->usb_buf */
 639 static void reg_r(struct gspca_dev *gspca_dev,
 640                   __u16 value, int len)
 641 {
 642 #ifdef GSPCA_DEBUG
 643         if (len > USB_BUF_SZ) {
 644                 err("reg_r: buffer overflow");
 645                 return;
 646         }
 647 #endif
 648         usb_control_msg(gspca_dev->dev,
 649                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 650                         0,
 651                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 652                         value, 0,
 653                         gspca_dev->usb_buf, len,
 654                         500);
 655         PDEBUG(D_USBI, "reg_r [%02x] -> %02x", value, gspca_dev->usb_buf[0]);
 656 }
 657
 658 static void reg_w1(struct gspca_dev *gspca_dev,
 659                    __u16 value,
 660                    __u8 data)
 661 {
 662         PDEBUG(D_USBO, "reg_w1 [%02x] = %02x", value, data);
 663         gspca_dev->usb_buf[0] = data;
 664         usb_control_msg(gspca_dev->dev,
 665                         usb_sndctrlpipe(gspca_dev->dev, 0),
 666                         0x08,
 667                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 668                         value,
 669                         0,
 670                         gspca_dev->usb_buf, 1,
 671                         500);
 672 }
 673 static void reg_w(struct gspca_dev *gspca_dev,
 674                           __u16 value,
 675                           const __u8 *buffer,
 676                           int len)
 677 {
 678         PDEBUG(D_USBO, "reg_w [%02x] = %02x %02x ..",
 679                 value, buffer[0], buffer[1]);
 680 #ifdef GSPCA_DEBUG
 681         if (len > USB_BUF_SZ) {
 682                 err("reg_w: buffer overflow");
 683                 return;
 684         }
 685 #endif
 686         memcpy(gspca_dev->usb_buf, buffer, len);
 687         usb_control_msg(gspca_dev->dev,
 688                         usb_sndctrlpipe(gspca_dev->dev, 0),
 689                         0x08,
 690                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 691                         value, 0,
 692                         gspca_dev->usb_buf, len,
 693                         500);
 694 }
 695
 696 /* I2C write 1 byte */
 697 static void i2c_w1(struct gspca_dev *gspca_dev, __u8 reg, __u8 val)
 698 {
 699         struct sd *sd = (struct sd *) gspca_dev;
 700
 701         PDEBUG(D_USBO, "i2c_w2 [%02x] = %02x", reg, val);
 702         gspca_dev->usb_buf[0] = 0x81 | (2 << 4);        /* = a1 */
 703         gspca_dev->usb_buf[1] = sd->i2c_base;
 704         gspca_dev->usb_buf[2] = reg;
 705         gspca_dev->usb_buf[3] = val;
 706         gspca_dev->usb_buf[4] = 0;
 707         gspca_dev->usb_buf[5] = 0;
 708         gspca_dev->usb_buf[6] = 0;
 709         gspca_dev->usb_buf[7] = 0x10;
 710         usb_control_msg(gspca_dev->dev,
 711                         usb_sndctrlpipe(gspca_dev->dev, 0),
 712                         0x08,
 713                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 714                         0x08,                   /* value = i2c */
 715                         0,
 716                         gspca_dev->usb_buf, 8,
 717                         500);
 718 }
 719
 720 /* I2C write 8 bytes */
 721 static void i2c_w8(struct gspca_dev *gspca_dev,
 722                    const __u8 *buffer)
 723 {
 724         memcpy(gspca_dev->usb_buf, buffer, 8);
 725         usb_control_msg(gspca_dev->dev,
 726                         usb_sndctrlpipe(gspca_dev->dev, 0),
 727                         0x08,
 728                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 729                         0x08, 0,                /* value, index */
 730                         gspca_dev->usb_buf, 8,
 731                         500);
 732         msleep(2);
 733 }
 734
 735 /* read 5 bytes in gspca_dev->usb_buf */
 736 static void i2c_r5(struct gspca_dev *gspca_dev, __u8 reg)
 737 {
 738         struct sd *sd = (struct sd *) gspca_dev;
 739         __u8 mode[8];
 740
 741         mode[0] = 0x81 | 0x10;
 742         mode[1] = sd->i2c_base;
 743         mode[2] = reg;
 744         mode[3] = 0;
 745         mode[4] = 0;
 746         mode[5] = 0;
 747         mode[6] = 0;
 748         mode[7] = 0x10;
 749         i2c_w8(gspca_dev, mode);
 750         msleep(2);
 751         mode[0] = 0x81 | (5 << 4) | 0x02;
 752         mode[2] = 0;
 753         i2c_w8(gspca_dev, mode);
 754         msleep(2);
 755         reg_r(gspca_dev, 0x0a, 5);
 756 }
 757
 758 static int probesensor(struct gspca_dev *gspca_dev)
 759 {
 760         struct sd *sd = (struct sd *) gspca_dev;
 761
 762         i2c_w1(gspca_dev, 0x02, 0);                     /* sensor wakeup */
 763         msleep(10);
 764         reg_w1(gspca_dev, 0x02, 0x66);                  /* Gpio on */
 765         msleep(10);
 766         i2c_r5(gspca_dev, 0);                           /* read sensor id */
 767         if (gspca_dev->usb_buf[0] == 0x02
 768             && gspca_dev->usb_buf[1] == 0x09
 769             && gspca_dev->usb_buf[2] == 0x01
 770             && gspca_dev->usb_buf[3] == 0x00
 771             && gspca_dev->usb_buf[4] == 0x00) {
 772                 PDEBUG(D_PROBE, "Find Sensor sn9c102P HV7131R");
 773                 sd->sensor = SENSOR_HV7131R;
 774                 return SENSOR_HV7131R;
 775         }
 776         PDEBUG(D_PROBE, "Find Sensor 0x%02x 0x%02x 0x%02x",
 777                 gspca_dev->usb_buf[0], gspca_dev->usb_buf[1],
 778                 gspca_dev->usb_buf[2]);
 779         PDEBUG(D_PROBE, "Sensor sn9c102P Not found");
 780         return -ENODEV;
 781 }
 782
 783 static int configure_gpio(struct gspca_dev *gspca_dev,
 784                           const __u8 *sn9c1xx)
 785 {
 786         struct sd *sd = (struct sd *) gspca_dev;
 787         const __u8 *reg9a;
 788         static const __u8 reg9a_def[] =
 789                 {0x08, 0x40, 0x20, 0x10, 0x00, 0x04};
 790         static const __u8 reg9a_sn9c325[] =
 791                 {0x0a, 0x40, 0x38, 0x30, 0x00, 0x20};
 792         static const __u8 regd4[] = {0x60, 0x00, 0x00};
 793
 794         reg_w1(gspca_dev, 0xf1, 0x00);
 795         reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
 796
 797         /* configure gpio */
 798         reg_w(gspca_dev, 0x01, &sn9c1xx[1], 2);
 799         reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2);
 800         reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 5);      /* jfm len was 3 */
 801         switch (sd->bridge) {
 802         case BRIDGE_SN9C325:
 803                 reg9a = reg9a_sn9c325;
 804                 break;
 805         default:
 806                 reg9a = reg9a_def;
 807                 break;
 808         }
 809         reg_w(gspca_dev, 0x9a, reg9a, 6);
 810
 811         reg_w(gspca_dev, 0xd4, regd4, sizeof regd4); /*fixme:jfm was 60 only*/
 812
 813         reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
 814
 815         switch (sd->sensor) {
 816         case SENSOR_OM6802:
 817                 reg_w1(gspca_dev, 0x02, 0x71);
 818                 reg_w1(gspca_dev, 0x01, 0x42);
 819                 reg_w1(gspca_dev, 0x17, 0x64);
 820                 reg_w1(gspca_dev, 0x01, 0x42);
 821                 break;
 822 /*jfm: from win trace */
 823         case SENSOR_OV7630:
 824                 reg_w1(gspca_dev, 0x01, 0x61);
 825                 reg_w1(gspca_dev, 0x17, 0xe2);
 826                 reg_w1(gspca_dev, 0x01, 0x60);
 827                 reg_w1(gspca_dev, 0x01, 0x40);
 828                 break;
 829         case SENSOR_OV7648:
 830                 reg_w1(gspca_dev, 0x01, 0x43);
 831                 reg_w1(gspca_dev, 0x17, 0xae);
 832                 reg_w1(gspca_dev, 0x01, 0x42);
 833                 break;
 834 /*jfm: from win trace */
 835         case SENSOR_OV7660:
 836                 reg_w1(gspca_dev, 0x01, 0x61);
 837                 reg_w1(gspca_dev, 0x17, 0x20);
 838                 reg_w1(gspca_dev, 0x01, 0x60);
 839                 reg_w1(gspca_dev, 0x01, 0x40);
 840                 break;
 841         default:
 842                 reg_w1(gspca_dev, 0x01, 0x43);
 843                 reg_w1(gspca_dev, 0x17, 0x61);
 844                 reg_w1(gspca_dev, 0x01, 0x42);
 845                 if (sd->sensor == SENSOR_HV7131R) {
 846                         if (probesensor(gspca_dev) < 0)
 847                                 return -ENODEV;
 848                 }
 849                 break;
 850         }
 851         return 0;
 852 }
 853
 854 static void hv7131R_InitSensor(struct gspca_dev *gspca_dev)
 855 {
 856         int i = 0;
 857         static const __u8 SetSensorClk[] =      /* 0x08 Mclk */
 858                 { 0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10 };
 859
 860         while (hv7131r_sensor_init[i][0]) {
 861                 i2c_w8(gspca_dev, hv7131r_sensor_init[i]);
 862                 i++;
 863         }
 864         i2c_w8(gspca_dev, SetSensorClk);
 865 }
 866
 867 static void mi0360_InitSensor(struct gspca_dev *gspca_dev)
 868 {
 869         int i = 0;
 870
 871         while (mi0360_sensor_init[i][0]) {
 872                 i2c_w8(gspca_dev, mi0360_sensor_init[i]);
 873                 i++;
 874         }
 875 }
 876
 877 static void mo4000_InitSensor(struct gspca_dev *gspca_dev)
 878 {
 879         int i = 0;
 880
 881         while (mo4000_sensor_init[i][0]) {
 882                 i2c_w8(gspca_dev, mo4000_sensor_init[i]);
 883                 i++;
 884         }
 885 }
 886
 887 static void om6802_InitSensor(struct gspca_dev *gspca_dev)
 888 {
 889         int i = 0;
 890
 891         while (om6802_sensor_init[i][0]) {
 892                 i2c_w8(gspca_dev, om6802_sensor_init[i]);
 893                 i++;
 894         }
 895 }
 896
 897 static void ov7630_InitSensor(struct gspca_dev *gspca_dev)
 898 {
 899         int i = 0;
 900
 901         i2c_w8(gspca_dev, ov7630_sensor_init[i]);       /* 76 01 */
 902         i++;
 903         i2c_w8(gspca_dev, ov7630_sensor_init[i]);       /* 12 c8 (RGB+SRST) */
 904         i++;
 905         msleep(20);
 906         i2c_w8(gspca_dev, ov7630_sensor_init[i]);       /* 12 48 */
 907         i++;
 908         i2c_w8(gspca_dev, ov7630_sensor_init[i]);       /* 12 c8 */
 909         i++;
 910         msleep(20);
 911         i2c_w8(gspca_dev, ov7630_sensor_init[i]);       /* 12 48 */
 912         i++;
 913 /*jfm:win i2c_r from 00 to 80*/
 914
 915         while (ov7630_sensor_init[i][0]) {
 916                 i2c_w8(gspca_dev, ov7630_sensor_init[i]);
 917                 i++;
 918         }
 919 }
 920
 921 static void ov7648_InitSensor(struct gspca_dev *gspca_dev)
 922 {
 923         int i = 0;
 924
 925         while (ov7648_sensor_init[i][0]) {
 926                 i2c_w8(gspca_dev, ov7648_sensor_init[i]);
 927                 i++;
 928         }
 929 }
 930
 931 static void ov7660_InitSensor(struct gspca_dev *gspca_dev)
 932 {
 933         int i = 0;
 934
 935         i2c_w8(gspca_dev, ov7660_sensor_init[i]);       /* reset SCCB */
 936         i++;
 937         msleep(20);
 938         while (ov7660_sensor_init[i][0]) {
 939                 i2c_w8(gspca_dev, ov7660_sensor_init[i]);
 940                 i++;
 941         }
 942 }
 943
 944 /* this function is called at probe time */
 945 static int sd_config(struct gspca_dev *gspca_dev,
 946                         const struct usb_device_id *id)
 947 {
 948         struct sd *sd = (struct sd *) gspca_dev;
 949         struct cam *cam;
 950
 951         cam = &gspca_dev->cam;
 952         cam->epaddr = 0x01;
 953         cam->cam_mode = vga_mode;
 954         cam->nmodes = ARRAY_SIZE(vga_mode);
 955
 956         sd->bridge = id->driver_info >> 16;
 957         sd->sensor = id->driver_info >> 8;
 958         sd->i2c_base = id->driver_info;
 959
 960         sd->qindex = 4;                 /* set the quantization table */
 961         sd->brightness = BRIGHTNESS_DEF;
 962         sd->contrast = CONTRAST_DEF;
 963         sd->colors = COLOR_DEF;
 964         sd->autogain = AUTOGAIN_DEF;
 965         sd->ag_cnt = -1;
 966
 967         switch (sd->sensor) {
 968         case SENSOR_OV7630:
 969         case SENSOR_OV7648:
 970         case SENSOR_OV7660:
 971                 gspca_dev->ctrl_dis = (1 << AUTOGAIN_IDX);
 972                 break;
 973         }
 974         if (sd->sensor != SENSOR_OV7630)
 975                 gspca_dev->ctrl_dis |= (1 << VFLIP_IDX);
 976
 977         return 0;
 978 }
 979
 980 /* this function is called at probe and resume time */
 981 static int sd_init(struct gspca_dev *gspca_dev)
 982 {
 983         struct sd *sd = (struct sd *) gspca_dev;
 984 /*      const __u8 *sn9c1xx; */
 985         __u8 regGpio[] = { 0x29, 0x74 };
 986         __u8 regF1;
 987
 988         /* setup a selector by bridge */
 989         reg_w1(gspca_dev, 0xf1, 0x01);
 990         reg_r(gspca_dev, 0x00, 1);
 991         reg_w1(gspca_dev, 0xf1, gspca_dev->usb_buf[0]);
 992         reg_r(gspca_dev, 0x00, 1);              /* get sonix chip id */
 993         regF1 = gspca_dev->usb_buf[0];
 994         PDEBUG(D_PROBE, "Sonix chip id: %02x", regF1);
 995         switch (sd->bridge) {
 996         case BRIDGE_SN9C102P:
 997                 if (regF1 != 0x11)
 998                         return -ENODEV;
 999                 reg_w1(gspca_dev, 0x02, regGpio[1]);
1000                 break;
1001         case BRIDGE_SN9C105:
1002                 if (regF1 != 0x11)
1003                         return -ENODEV;
1004                 reg_w(gspca_dev, 0x01, regGpio, 2);
1005                 break;
1006         case BRIDGE_SN9C120:
1007                 if (regF1 != 0x12)
1008                         return -ENODEV;
1009                 regGpio[1] = 0x70;
1010                 reg_w(gspca_dev, 0x01, regGpio, 2);
1011                 break;
1012         default:
1013 /*      case BRIDGE_SN9C110: */
1014 /*      case BRIDGE_SN9C325: */
1015                 if (regF1 != 0x12)
1016                         return -ENODEV;
1017                 reg_w1(gspca_dev, 0x02, 0x62);
1018                 break;
1019         }
1020
1021         reg_w1(gspca_dev, 0xf1, 0x01);
1022
1023         return 0;
1024 }
1025
1026 static unsigned int setexposure(struct gspca_dev *gspca_dev,
1027                                 unsigned int expo)
1028 {
1029         struct sd *sd = (struct sd *) gspca_dev;
1030         static const __u8 doit[] =              /* update sensor */
1031                 { 0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };
1032         static const __u8 sensorgo[] =          /* sensor on */
1033                 { 0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };
1034         static const __u8 gainMo[] =
1035                 { 0xa1, 0x21, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1d };
1036
1037         switch (sd->sensor) {
1038         case SENSOR_HV7131R: {
1039                 __u8 Expodoit[] =
1040                         { 0xc1, 0x11, 0x25, 0x07, 0x27, 0xc0, 0x00, 0x16 };
1041
1042                 Expodoit[3] = expo >> 16;
1043                 Expodoit[4] = expo >> 8;
1044                 Expodoit[5] = expo;
1045                 i2c_w8(gspca_dev, Expodoit);
1046                 break;
1047             }
1048         case SENSOR_MI0360: {
1049                 __u8 expoMi[] =  /* exposure 0x0635 -> 4 fp/s 0x10 */
1050                         { 0xb1, 0x5d, 0x09, 0x06, 0x35, 0x00, 0x00, 0x16 };
1051
1052                 if (expo > 0x0635)
1053                         expo = 0x0635;
1054                 else if (expo < 0x0001)
1055                         expo = 0x0001;
1056                 expoMi[3] = expo >> 8;
1057                 expoMi[4] = expo;
1058                 i2c_w8(gspca_dev, expoMi);
1059                 i2c_w8(gspca_dev, doit);
1060                 i2c_w8(gspca_dev, sensorgo);
1061                 break;
1062             }
1063         case SENSOR_MO4000: {
1064                 __u8 expoMof[] =
1065                         { 0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10 };
1066                 __u8 expoMo10[] =
1067                         { 0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10 };
1068
1069                 if (expo > 0x1fff)
1070                         expo = 0x1fff;
1071                 else if (expo < 0x0001)
1072                         expo = 0x0001;
1073                 expoMof[3] = (expo & 0x03fc) >> 2;
1074                 i2c_w8(gspca_dev, expoMof);
1075                 expoMo10[3] = ((expo & 0x1c00) >> 10)
1076                                 | ((expo & 0x0003) << 4);
1077                 i2c_w8(gspca_dev, expoMo10);
1078                 i2c_w8(gspca_dev, gainMo);
1079                 PDEBUG(D_CONF, "set exposure %d",
1080                         ((expoMo10[3] & 0x07) << 10)
1081                         | (expoMof[3] << 2)
1082                         | ((expoMo10[3] & 0x30) >> 4));
1083                 break;
1084             }
1085         case SENSOR_OM6802: {
1086                 __u8 gainOm[] =
1087                         { 0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10 };
1088
1089                 if (expo > 0x03ff)
1090                         expo = 0x03ff;
1091                  if (expo < 0x0001)
1092                         expo = 0x0001;
1093                 gainOm[3] = expo >> 2;
1094                 i2c_w8(gspca_dev, gainOm);
1095                 reg_w1(gspca_dev, 0x96, (expo >> 5) & 0x1f);
1096                 PDEBUG(D_CONF, "set exposure %d", gainOm[3]);
1097                 break;
1098             }
1099         }
1100         return expo;
1101 }
1102
1103 /* this function is used for sensors o76xx only */
1104 static void setbrightcont(struct gspca_dev *gspca_dev)
1105 {
1106         struct sd *sd = (struct sd *) gspca_dev;
1107         int val;
1108         __u8 reg84_full[0x15];
1109
1110         memcpy(reg84_full, reg84, sizeof reg84_full);
1111         val = sd->contrast * 0x30 / CONTRAST_MAX + 0x10;        /* 10..40 */
1112         reg84_full[0] = (val + 1) / 2;          /* red */
1113         reg84_full[2] = val;                    /* green */
1114         reg84_full[4] = (val + 1) / 5;          /* blue */
1115         val = (sd->brightness - BRIGHTNESS_DEF) * 0x10
1116                         / BRIGHTNESS_MAX;
1117         reg84_full[0x12] = val & 0x1f;          /* 5:0 signed value */
1118         reg_w(gspca_dev, 0x84, reg84_full, sizeof reg84_full);
1119 }
1120
1121 /* sensor != ov76xx */
1122 static void setbrightness(struct gspca_dev *gspca_dev)
1123 {
1124         struct sd *sd = (struct sd *) gspca_dev;
1125         unsigned int expo;
1126         __u8 k2;
1127
1128         k2 = sd->brightness >> 10;
1129         switch (sd->sensor) {
1130         case SENSOR_HV7131R:
1131                 expo = sd->brightness << 4;
1132                 if (expo > 0x002dc6c0)
1133                         expo = 0x002dc6c0;
1134                 else if (expo < 0x02a0)
1135                         expo = 0x02a0;
1136                 sd->exposure = setexposure(gspca_dev, expo);
1137                 break;
1138         case SENSOR_MI0360:
1139         case SENSOR_MO4000:
1140                 expo = sd->brightness >> 4;
1141                 sd->exposure = setexposure(gspca_dev, expo);
1142                 break;
1143         case SENSOR_OM6802:
1144                 expo = sd->brightness >> 6;
1145                 sd->exposure = setexposure(gspca_dev, expo);
1146                 k2 = sd->brightness >> 11;
1147                 break;
1148         }
1149
1150         reg_w1(gspca_dev, 0x96, k2);
1151 }
1152
1153 /* sensor != ov76xx */
1154 static void setcontrast(struct gspca_dev *gspca_dev)
1155 {
1156         struct sd *sd = (struct sd *) gspca_dev;
1157         __u8 k2;
1158         __u8 contrast[] = { 0x00, 0x00, 0x28, 0x00, 0x07, 0x00 };
1159
1160         k2 = sd->contrast;
1161         contrast[2] = k2;
1162         contrast[0] = (k2 + 1) >> 1;
1163         contrast[4] = (k2 + 1) / 5;
1164         reg_w(gspca_dev, 0x84, contrast, 6);
1165 }
1166
1167 static void setcolors(struct gspca_dev *gspca_dev)
1168 {
1169         struct sd *sd = (struct sd *) gspca_dev;
1170         __u8 blue, red;
1171
1172         if (sd->colors >= 32) {
1173                 red = 32 + (sd->colors - 32) / 2;
1174                 blue = 64 - sd->colors;
1175         } else {
1176                 red = sd->colors;
1177                 blue = 32 + (32 - sd->colors) / 2;
1178         }
1179         reg_w1(gspca_dev, 0x05, red);
1180 /*      reg_w1(gspca_dev, 0x07, 32); */
1181         reg_w1(gspca_dev, 0x06, blue);
1182 }
1183
1184 static void setautogain(struct gspca_dev *gspca_dev)
1185 {
1186         struct sd *sd = (struct sd *) gspca_dev;
1187
1188         if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
1189                 return;
1190         if (sd->autogain)
1191                 sd->ag_cnt = AG_CNT_START;
1192         else
1193                 sd->ag_cnt = -1;
1194 }
1195
1196 static void setvflip(struct sd *sd)
1197 {
1198         if (sd->sensor != SENSOR_OV7630)
1199                 return;
1200         i2c_w1(&sd->gspca_dev, 0x75,                    /* COMN */
1201                 sd->vflip ? 0x82 : 0x02);
1202 }
1203
1204 /* -- start the camera -- */
1205 static int sd_start(struct gspca_dev *gspca_dev)
1206 {
1207         struct sd *sd = (struct sd *) gspca_dev;
1208         int i;
1209         __u8 reg1, reg17, reg18;
1210         const __u8 *sn9c1xx;
1211         int mode;
1212         static const __u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
1213         static const __u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
1214         static const __u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd };    /* MI0360 */
1215         static const __u8 CE_ov76xx[] =
1216                                 { 0x32, 0xdd, 0x32, 0xdd };
1217
1218         sn9c1xx = sn_tb[(int) sd->sensor];
1219         configure_gpio(gspca_dev, sn9c1xx);
1220
1221         reg_w1(gspca_dev, 0x15, sn9c1xx[0x15]);
1222         reg_w1(gspca_dev, 0x16, sn9c1xx[0x16]);
1223         reg_w1(gspca_dev, 0x12, sn9c1xx[0x12]);
1224         reg_w1(gspca_dev, 0x13, sn9c1xx[0x13]);
1225         reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
1226         reg_w1(gspca_dev, 0xd2, 0x6a);          /* DC29 */
1227         reg_w1(gspca_dev, 0xd3, 0x50);
1228         reg_w1(gspca_dev, 0xc6, 0x00);
1229         reg_w1(gspca_dev, 0xc7, 0x00);
1230         reg_w1(gspca_dev, 0xc8, 0x50);
1231         reg_w1(gspca_dev, 0xc9, 0x3c);
1232         reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
1233         switch (sd->sensor) {
1234         case SENSOR_OV7630:
1235                 reg17 = 0xe2;
1236                 break;
1237         case SENSOR_OV7648:
1238                 reg17 = 0xae;
1239                 break;
1240 /*jfm: from win trace */
1241         case SENSOR_OV7660:
1242                 reg17 = 0xa0;
1243                 break;
1244         default:
1245                 reg17 = 0x60;
1246                 break;
1247         }
1248         reg_w1(gspca_dev, 0x17, reg17);
1249         reg_w1(gspca_dev, 0x05, sn9c1xx[5]);
1250         reg_w1(gspca_dev, 0x07, sn9c1xx[7]);
1251         reg_w1(gspca_dev, 0x06, sn9c1xx[6]);
1252         reg_w1(gspca_dev, 0x14, sn9c1xx[0x14]);
1253         reg_w(gspca_dev, 0x20, gamma_def, sizeof gamma_def);
1254         for (i = 0; i < 8; i++)
1255                 reg_w(gspca_dev, 0x84, reg84, sizeof reg84);
1256         switch (sd->sensor) {
1257         case SENSOR_OV7660:
1258                 reg_w1(gspca_dev, 0x9a, 0x05);
1259                 break;
1260         default:
1261                 reg_w1(gspca_dev, 0x9a, 0x08);
1262                 reg_w1(gspca_dev, 0x99, 0x59);
1263                 break;
1264         }
1265
1266         mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
1267         if (mode)
1268                 reg1 = 0x46;    /* 320 clk 48Mhz */
1269         else
1270                 reg1 = 0x06;    /* 640 clk 24Mz */
1271         reg17 = 0x61;
1272         switch (sd->sensor) {
1273         case SENSOR_HV7131R:
1274                 hv7131R_InitSensor(gspca_dev);
1275                 break;
1276         case SENSOR_MI0360:
1277                 mi0360_InitSensor(gspca_dev);
1278                 break;
1279         case SENSOR_MO4000:
1280                 mo4000_InitSensor(gspca_dev);
1281                 if (mode) {
1282 /*                      reg1 = 0x46;     * 320 clk 48Mhz 60fp/s */
1283                         reg1 = 0x06;    /* clk 24Mz */
1284                 } else {
1285                         reg17 = 0x22;   /* 640 MCKSIZE */
1286 /*                      reg1 = 0x06;     * 640 clk 24Mz (done) */
1287                 }
1288                 break;
1289         case SENSOR_OM6802:
1290                 om6802_InitSensor(gspca_dev);
1291                 reg17 = 0x64;           /* 640 MCKSIZE */
1292                 break;
1293         case SENSOR_OV7630:
1294                 ov7630_InitSensor(gspca_dev);
1295                 setvflip(sd);
1296                 reg17 = 0xe2;
1297                 reg1 = 0x44;
1298                 break;
1299         case SENSOR_OV7648:
1300                 ov7648_InitSensor(gspca_dev);
1301                 reg17 = 0xa2;
1302                 reg1 = 0x44;
1303 /*              if (mode)
1304                         ;                * 320x2...
1305                 else
1306                         ;                * 640x... */
1307                 break;
1308         default:
1309 /*      case SENSOR_OV7660: */
1310                 ov7660_InitSensor(gspca_dev);
1311                 if (mode) {
1312 /*                      reg17 = 0x21;    * 320 */
1313 /*                      reg1 = 0x44; */
1314 /*                      reg1 = 0x46;    (done) */
1315                 } else {
1316                         reg17 = 0xa2;   /* 640 */
1317                         reg1 = 0x44;
1318                 }
1319                 break;
1320         }
1321         reg_w(gspca_dev, 0xc0, C0, 6);
1322         reg_w(gspca_dev, 0xca, CA, 4);
1323         switch (sd->sensor) {
1324         case SENSOR_OV7630:
1325         case SENSOR_OV7648:
1326         case SENSOR_OV7660:
1327                 reg_w(gspca_dev, 0xce, CE_ov76xx, 4);
1328                 break;
1329         default:
1330                 reg_w(gspca_dev, 0xce, CE, 4);
1331                                         /* ?? {0x1e, 0xdd, 0x2d, 0xe7} */
1332                 break;
1333         }
1334
1335         /* here change size mode 0 -> VGA; 1 -> CIF */
1336         reg18 = sn9c1xx[0x18] | (mode << 4);
1337         reg_w1(gspca_dev, 0x18, reg18 | 0x40);
1338
1339         reg_w(gspca_dev, 0x100, qtable4, 0x40);
1340         reg_w(gspca_dev, 0x140, qtable4 + 0x40, 0x40);
1341
1342         reg_w1(gspca_dev, 0x18, reg18);
1343
1344         reg_w1(gspca_dev, 0x17, reg17);
1345         switch (sd->sensor) {
1346         case SENSOR_HV7131R:
1347         case SENSOR_MI0360:
1348         case SENSOR_MO4000:
1349         case SENSOR_OM6802:
1350                 setbrightness(gspca_dev);
1351                 setcontrast(gspca_dev);
1352                 break;
1353         default:                        /* OV76xx */
1354                 setbrightcont(gspca_dev);
1355                 break;
1356         }
1357         setautogain(gspca_dev);
1358         reg_w1(gspca_dev, 0x01, reg1);
1359         return 0;
1360 }
1361
1362 static void sd_stopN(struct gspca_dev *gspca_dev)
1363 {
1364         struct sd *sd = (struct sd *) gspca_dev;
1365         static const __u8 stophv7131[] =
1366                 { 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 };
1367         static const __u8 stopmi0360[] =
1368                 { 0xb1, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10 };
1369         __u8 data;
1370         const __u8 *sn9c1xx;
1371
1372         data = 0x0b;
1373         switch (sd->sensor) {
1374         case SENSOR_HV7131R:
1375                 i2c_w8(gspca_dev, stophv7131);
1376                 data = 0x2b;
1377                 break;
1378         case SENSOR_MI0360:
1379                 i2c_w8(gspca_dev, stopmi0360);
1380                 data = 0x29;
1381                 break;
1382         case SENSOR_OV7630:
1383         case SENSOR_OV7648:
1384                 data = 0x29;
1385                 break;
1386         default:
1387 /*      case SENSOR_MO4000: */
1388 /*      case SENSOR_OV7660: */
1389                 break;
1390         }
1391         sn9c1xx = sn_tb[(int) sd->sensor];
1392         reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
1393         reg_w1(gspca_dev, 0x17, sn9c1xx[0x17]);
1394         reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
1395         reg_w1(gspca_dev, 0x01, data);
1396         reg_w1(gspca_dev, 0xf1, 0x00);
1397 }
1398
1399 static void do_autogain(struct gspca_dev *gspca_dev)
1400 {
1401         struct sd *sd = (struct sd *) gspca_dev;
1402         int delta;
1403         int expotimes;
1404         __u8 luma_mean = 130;
1405         __u8 luma_delta = 20;
1406
1407         /* Thanks S., without your advice, autobright should not work :) */
1408         if (sd->ag_cnt < 0)
1409                 return;
1410         if (--sd->ag_cnt >= 0)
1411                 return;
1412         sd->ag_cnt = AG_CNT_START;
1413
1414         delta = atomic_read(&sd->avg_lum);
1415         PDEBUG(D_FRAM, "mean lum %d", delta);
1416         if (delta < luma_mean - luma_delta ||
1417             delta > luma_mean + luma_delta) {
1418                 switch (sd->sensor) {
1419                 case SENSOR_HV7131R:
1420                         expotimes = sd->exposure >> 8;
1421                         expotimes += (luma_mean - delta) >> 4;
1422                         if (expotimes < 0)
1423                                 expotimes = 0;
1424                         sd->exposure = setexposure(gspca_dev,
1425                                         (unsigned int) (expotimes << 8));
1426                         break;
1427                 default:
1428 /*              case SENSOR_MO4000: */
1429 /*              case SENSOR_MI0360: */
1430 /*              case SENSOR_OM6802: */
1431                         expotimes = sd->exposure;
1432                         expotimes += (luma_mean - delta) >> 6;
1433                         if (expotimes < 0)
1434                                 expotimes = 0;
1435                         sd->exposure = setexposure(gspca_dev,
1436                                                    (unsigned int) expotimes);
1437                         setcolors(gspca_dev);
1438                         break;
1439                 }
1440         }
1441 }
1442
1443 /* scan the URB packets */
1444 /* This function is run at interrupt level. */
1445 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1446                         struct gspca_frame *frame,      /* target */
1447                         __u8 *data,                     /* isoc packet */
1448                         int len)                        /* iso packet length */
1449 {
1450         struct sd *sd = (struct sd *) gspca_dev;
1451         int sof, avg_lum;
1452
1453         sof = len - 64;
1454         if (sof >= 0 && data[sof] == 0xff && data[sof + 1] == 0xd9) {
1455
1456                 /* end of frame */
1457                 gspca_frame_add(gspca_dev, LAST_PACKET,
1458                                 frame, data, sof + 2);
1459                 if (sd->ag_cnt < 0)
1460                         return;
1461 /* w1 w2 w3 */
1462 /* w4 w5 w6 */
1463 /* w7 w8 */
1464 /* w4 */
1465                 avg_lum = ((data[sof + 29] << 8) | data[sof + 30]) >> 6;
1466 /* w6 */
1467                 avg_lum += ((data[sof + 33] << 8) | data[sof + 34]) >> 6;
1468 /* w2 */
1469                 avg_lum += ((data[sof + 25] << 8) | data[sof + 26]) >> 6;
1470 /* w8 */
1471                 avg_lum += ((data[sof + 37] << 8) | data[sof + 38]) >> 6;
1472 /* w5 */
1473                 avg_lum += ((data[sof + 31] << 8) | data[sof + 32]) >> 4;
1474                 avg_lum >>= 4;
1475                 atomic_set(&sd->avg_lum, avg_lum);
1476                 return;
1477         }
1478         if (gspca_dev->last_packet_type == LAST_PACKET) {
1479
1480                 /* put the JPEG 422 header */
1481                 jpeg_put_header(gspca_dev, frame, sd->qindex, 0x21);
1482         }
1483         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
1484 }
1485
1486 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1487 {
1488         struct sd *sd = (struct sd *) gspca_dev;
1489
1490         sd->brightness = val;
1491         if (gspca_dev->streaming) {
1492                 switch (sd->sensor) {
1493                 case SENSOR_HV7131R:
1494                 case SENSOR_MI0360:
1495                 case SENSOR_MO4000:
1496                 case SENSOR_OM6802:
1497                         setbrightness(gspca_dev);
1498                         break;
1499                 default:                        /* OV76xx */
1500                         setbrightcont(gspca_dev);
1501                         break;
1502                 }
1503         }
1504         return 0;
1505 }
1506
1507 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1508 {
1509         struct sd *sd = (struct sd *) gspca_dev;
1510
1511         *val = sd->brightness;
1512         return 0;
1513 }
1514
1515 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1516 {
1517         struct sd *sd = (struct sd *) gspca_dev;
1518
1519         sd->contrast = val;
1520         if (gspca_dev->streaming) {
1521                 switch (sd->sensor) {
1522                 case SENSOR_HV7131R:
1523                 case SENSOR_MI0360:
1524                 case SENSOR_MO4000:
1525                 case SENSOR_OM6802:
1526                         setcontrast(gspca_dev);
1527                         break;
1528                 default:                        /* OV76xx */
1529                         setbrightcont(gspca_dev);
1530                         break;
1531                 }
1532         }
1533         return 0;
1534 }
1535
1536 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1537 {
1538         struct sd *sd = (struct sd *) gspca_dev;
1539
1540         *val = sd->contrast;
1541         return 0;
1542 }
1543
1544 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1545 {
1546         struct sd *sd = (struct sd *) gspca_dev;
1547
1548         sd->colors = val;
1549         if (gspca_dev->streaming)
1550                 setcolors(gspca_dev);
1551         return 0;
1552 }
1553
1554 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1555 {
1556         struct sd *sd = (struct sd *) gspca_dev;
1557
1558         *val = sd->colors;
1559         return 0;
1560 }
1561
1562 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1563 {
1564         struct sd *sd = (struct sd *) gspca_dev;
1565
1566         sd->autogain = val;
1567         if (gspca_dev->streaming)
1568                 setautogain(gspca_dev);
1569         return 0;
1570 }
1571
1572 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1573 {
1574         struct sd *sd = (struct sd *) gspca_dev;
1575
1576         *val = sd->autogain;
1577         return 0;
1578 }
1579
1580 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
1581 {
1582         struct sd *sd = (struct sd *) gspca_dev;
1583
1584         sd->vflip = val;
1585         setvflip(sd);
1586         return 0;
1587 }
1588
1589 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
1590 {
1591         struct sd *sd = (struct sd *) gspca_dev;
1592
1593         *val = sd->vflip;
1594         return 0;
1595 }
1596
1597 /* sub-driver description */
1598 static const struct sd_desc sd_desc = {
1599         .name = MODULE_NAME,
1600         .ctrls = sd_ctrls,
1601         .nctrls = ARRAY_SIZE(sd_ctrls),
1602         .config = sd_config,
1603         .init = sd_init,
1604         .start = sd_start,
1605         .stopN = sd_stopN,
1606         .pkt_scan = sd_pkt_scan,
1607         .dq_callback = do_autogain,
1608 };
1609
1610 /* -- module initialisation -- */
1611 #define BSI(bridge, sensor, i2c_addr) \
1612         .driver_info = (BRIDGE_ ## bridge << 16) \
1613                         | (SENSOR_ ## sensor << 8) \
1614                         | (i2c_addr)
1615 static const __devinitdata struct usb_device_id device_table[] = {
1616 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1617         {USB_DEVICE(0x0458, 0x7025), BSI(SN9C120, MI0360, 0x5d)},
1618         {USB_DEVICE(0x0458, 0x702e), BSI(SN9C120, OV7660, 0x21)},
1619         {USB_DEVICE(0x045e, 0x00f5), BSI(SN9C105, OV7660, 0x21)},
1620         {USB_DEVICE(0x045e, 0x00f7), BSI(SN9C105, OV7660, 0x21)},
1621         {USB_DEVICE(0x0471, 0x0327), BSI(SN9C105, MI0360, 0x5d)},
1622         {USB_DEVICE(0x0471, 0x0328), BSI(SN9C105, MI0360, 0x5d)},
1623 #endif
1624         {USB_DEVICE(0x0471, 0x0330), BSI(SN9C105, MI0360, 0x5d)},
1625         {USB_DEVICE(0x0c45, 0x6040), BSI(SN9C102P, HV7131R, 0x11)},
1626 /* bw600.inf:
1627         {USB_DEVICE(0x0c45, 0x6040), BSI(SN9C102P, MI0360, 0x5d)}, */
1628 /*      {USB_DEVICE(0x0c45, 0x603a), BSI(SN9C102P, OV7648, 0x??)}, */
1629 /*      {USB_DEVICE(0x0c45, 0x607a), BSI(SN9C102P, OV7648, 0x??)}, */
1630         {USB_DEVICE(0x0c45, 0x607c), BSI(SN9C102P, HV7131R, 0x11)},
1631 /*      {USB_DEVICE(0x0c45, 0x607e), BSI(SN9C102P, OV7630, 0x??)}, */
1632         {USB_DEVICE(0x0c45, 0x60c0), BSI(SN9C105, MI0360, 0x5d)},
1633 /*      {USB_DEVICE(0x0c45, 0x60c8), BSI(SN9C105, OM6801, 0x??)}, */
1634 /*      {USB_DEVICE(0x0c45, 0x60cc), BSI(SN9C105, HV7131GP, 0x??)}, */
1635         {USB_DEVICE(0x0c45, 0x60ec), BSI(SN9C105, MO4000, 0x21)},
1636 /*      {USB_DEVICE(0x0c45, 0x60ef), BSI(SN9C105, ICM105C, 0x??)}, */
1637 /*      {USB_DEVICE(0x0c45, 0x60fa), BSI(SN9C105, OV7648, 0x??)}, */
1638         {USB_DEVICE(0x0c45, 0x60fb), BSI(SN9C105, OV7660, 0x21)},
1639         {USB_DEVICE(0x0c45, 0x60fc), BSI(SN9C105, HV7131R, 0x11)},
1640 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1641         {USB_DEVICE(0x0c45, 0x60fe), BSI(SN9C105, OV7630, 0x21)},
1642 #endif
1643 /*      {USB_DEVICE(0x0c45, 0x6108), BSI(SN9C120, OM6801, 0x??)}, */
1644 /*      {USB_DEVICE(0x0c45, 0x6122), BSI(SN9C110, ICM105C, 0x??)}, */
1645 /*      {USB_DEVICE(0x0c45, 0x6123), BSI(SN9C110, SanyoCCD, 0x??)}, */
1646         {USB_DEVICE(0x0c45, 0x6128), BSI(SN9C110, OM6802, 0x21)}, /*sn9c325?*/
1647 /*bw600.inf:*/
1648         {USB_DEVICE(0x0c45, 0x612a), BSI(SN9C110, OV7648, 0x21)}, /*sn9c325?*/
1649         {USB_DEVICE(0x0c45, 0x612c), BSI(SN9C110, MO4000, 0x21)},
1650         {USB_DEVICE(0x0c45, 0x612e), BSI(SN9C110, OV7630, 0x21)},
1651 /*      {USB_DEVICE(0x0c45, 0x612f), BSI(SN9C110, ICM105C, 0x??)}, */
1652 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1653         {USB_DEVICE(0x0c45, 0x6130), BSI(SN9C120, MI0360, 0x5d)},
1654 #endif
1655         {USB_DEVICE(0x0c45, 0x6138), BSI(SN9C120, MO4000, 0x21)},
1656 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1657 /*      {USB_DEVICE(0x0c45, 0x613a), BSI(SN9C120, OV7648, 0x??)}, */
1658         {USB_DEVICE(0x0c45, 0x613b), BSI(SN9C120, OV7660, 0x21)},
1659         {USB_DEVICE(0x0c45, 0x613c), BSI(SN9C120, HV7131R, 0x11)},
1660 /*      {USB_DEVICE(0x0c45, 0x613e), BSI(SN9C120, OV7630, 0x??)}, */
1661 #endif
1662         {USB_DEVICE(0x0c45, 0x6143), BSI(SN9C120, MI0360, 0x5d)},
1663         {}
1664 };
1665 MODULE_DEVICE_TABLE(usb, device_table);
1666
1667 /* -- device connect -- */
1668 static int sd_probe(struct usb_interface *intf,
1669                     const struct usb_device_id *id)
1670 {
1671         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1672                                 THIS_MODULE);
1673 }
1674
1675 static struct usb_driver sd_driver = {
1676         .name = MODULE_NAME,
1677         .id_table = device_table,
1678         .probe = sd_probe,
1679         .disconnect = gspca_disconnect,
1680 #ifdef CONFIG_PM
1681         .suspend = gspca_suspend,
1682         .resume = gspca_resume,
1683 #endif
1684 };
1685
1686 /* -- module insert / remove -- */
1687 static int __init sd_mod_init(void)
1688 {
1689         if (usb_register(&sd_driver) < 0)
1690                 return -1;
1691         info("registered");
1692         return 0;
1693 }
1694 static void __exit sd_mod_exit(void)
1695 {
1696         usb_deregister(&sd_driver);
1697         info("deregistered");
1698 }
1699
1700 module_init(sd_mod_init);
1701 module_exit(sd_mod_exit);