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