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