SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/gspca/sonixj.c

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