Quelle  sonixj.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Sonix sn9c102p sn9c105 sn9c120 (jpeg) subdriver
 *
 * Copyright (C) 2009-2011 Jean-François Moine <http://moinejf.free.fr>
 * Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#define MODULE_NAME "sonixj"

#include <linux/input.h>
#include "gspca.h"
#include "jpeg.h"

MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver");
MODULE_LICENSE("GPL");

/* specific webcam descriptor */
struct sd {
 struct gspca_dev gspca_dev; /* !! must be the first item */

 atomic_t avg_lum;
 struct v4l2_ctrl *brightness;
 struct v4l2_ctrl *contrast;
 struct v4l2_ctrl *saturation;
 struct { /* red/blue balance control cluster */
  struct v4l2_ctrl *red_bal;
  struct v4l2_ctrl *blue_bal;
 };
 struct { /* hflip/vflip control cluster */
  struct v4l2_ctrl *vflip;
  struct v4l2_ctrl *hflip;
 };
 struct v4l2_ctrl *gamma;
 struct v4l2_ctrl *illum;
 struct v4l2_ctrl *sharpness;
 struct v4l2_ctrl *freq;
 u32 exposure;

 struct work_struct work;

 u32 pktsz;   /* (used by pkt_scan) */
 u16 npkt;
 s8 nchg;
 s8 short_mark;

 u8 quality;   /* image quality */
#define QUALITY_MIN 25
#define QUALITY_MAX 90
#define QUALITY_DEF 70

 u8 reg01;
 u8 reg17;
 u8 reg18;
 u8 flags;

 s8 ag_cnt;
#define AG_CNT_START 13

 u8 bridge;
#define BRIDGE_SN9C102P 0
#define BRIDGE_SN9C105 1
#define BRIDGE_SN9C110 2
#define BRIDGE_SN9C120 3
 u8 sensor;   /* Type of image sensor chip */
 u8 i2c_addr;

 u8 jpeg_hdr[JPEG_HDR_SZ];
};
enum sensors {
 SENSOR_ADCM1700,
 SENSOR_GC0307,
 SENSOR_HV7131R,
 SENSOR_MI0360,
 SENSOR_MI0360B,
 SENSOR_MO4000,
 SENSOR_MT9V111,
 SENSOR_OM6802,
 SENSOR_OV7630,
 SENSOR_OV7648,
 SENSOR_OV7660,
 SENSOR_PO1030,
 SENSOR_PO2030N,
 SENSOR_SOI768,
 SENSOR_SP80708,
};

static void qual_upd(struct work_struct *work);

/* device flags */
#define F_PDN_INV 0x01 /* inverse pin S_PWR_DN / sn_xxx tables */
#define F_ILLUM  0x02 /* presence of illuminator */

/* sn9c1xx definitions */
/* register 0x01 */
#define S_PWR_DN 0x01 /* sensor power down */
#define S_PDN_INV 0x02 /* inverse pin S_PWR_DN */
#define V_TX_EN  0x04 /* video transfer enable */
#define LED  0x08 /* output to pin LED */
#define SCL_SEL_OD 0x20 /* open-drain mode */
#define SYS_SEL_48M 0x40 /* system clock 0: 24MHz, 1: 48MHz */
/* register 0x17 */
#define MCK_SIZE_MASK 0x1f /* sensor master clock */
#define SEN_CLK_EN 0x20 /* enable sensor clock */
#define DEF_EN  0x80 /* defect pixel by 0: soft, 1: hard */

static const struct v4l2_pix_format cif_mode[] = {
 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  .bytesperline = 352,
  .sizeimage = 352 * 288 * 4 / 8 + 590,
  .colorspace = V4L2_COLORSPACE_JPEG,
  .priv = 0},
};
static const struct v4l2_pix_format vga_mode[] = {
 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  .bytesperline = 160,
  .sizeimage = 160 * 120 * 4 / 8 + 590,
  .colorspace = V4L2_COLORSPACE_JPEG,
  .priv = 2},
 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  .bytesperline = 320,
  .sizeimage = 320 * 240 * 3 / 8 + 590,
  .colorspace = V4L2_COLORSPACE_JPEG,
  .priv = 1},
 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  .bytesperline = 640,
  /* Note 3 / 8 is not large enough, not even 5 / 8 is ?! */
  .sizeimage = 640 * 480 * 3 / 4 + 590,
  .colorspace = V4L2_COLORSPACE_JPEG,
  .priv = 0},
};

static const u8 sn_adcm1700[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x43, 0x60, 0x00, 0x1a, 0x00, 0x00, 0x00,
/* reg8 reg9 rega regb regc regd rege regf */
 0x80, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x05, 0x01, 0x05, 0x16, 0x12, 0x42,
/* reg18 reg19 reg1a reg1b */
 0x06, 0x00, 0x00, 0x00
};

static const u8 sn_gc0307[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x61, 0x62, 0x00, 0x1a, 0x00, 0x00, 0x00,
/* reg8 reg9 rega regb regc regd rege regf */
 0x80, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x03, 0x01, 0x08, 0x28, 0x1e, 0x02,
/* reg18 reg19 reg1a reg1b */
 0x06, 0x00, 0x00, 0x00
};

static const u8 sn_hv7131[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x03, 0x60, 0x00, 0x1a, 0x20, 0x20, 0x20,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x00, 0x01, 0x03, 0x28, 0x1e, 0x41,
/* reg18 reg19 reg1a reg1b */
 0x0a, 0x00, 0x00, 0x00
};

static const u8 sn_mi0360[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x63, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x00, 0x02, 0x0a, 0x28, 0x1e, 0x61,
/* reg18 reg19 reg1a reg1b */
 0x06, 0x00, 0x00, 0x00
};

static const u8 sn_mi0360b[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x61, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x00, 0x02, 0x0a, 0x28, 0x1e, 0x40,
/* reg18 reg19 reg1a reg1b */
 0x06, 0x00, 0x00, 0x00
};

static const u8 sn_mo4000[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x23, 0x60, 0x00, 0x1a, 0x00, 0x20, 0x18,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03,  0x00, 0x0b, 0x0f, 0x14, 0x28, 0x1e, 0x40,
/* reg18 reg19 reg1a reg1b */
 0x08, 0x00, 0x00, 0x00
};

static const u8 sn_mt9v111[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x61, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x00, 0x02, 0x1c, 0x28, 0x1e, 0x40,
/* reg18 reg19 reg1a reg1b */
 0x06, 0x00, 0x00, 0x00
};

static const u8 sn_om6802[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x23, 0x72, 0x00, 0x1a, 0x20, 0x20, 0x19,
/* reg8 reg9 rega regb regc regd rege regf */
 0x80, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x51, 0x01, 0x00, 0x28, 0x1e, 0x40,
/* reg18 reg19 reg1a reg1b */
 0x05, 0x00, 0x00, 0x00
};

static const u8 sn_ov7630[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x21, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x04, 0x01, 0x0a, 0x28, 0x1e, 0xc2,
/* reg18 reg19 reg1a reg1b */
 0x0b, 0x00, 0x00, 0x00
};

static const u8 sn_ov7648[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x63, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x00, 0x01, 0x00, 0x28, 0x1e, 0x00,
/* reg18 reg19 reg1a reg1b */
 0x0b, 0x00, 0x00, 0x00
};

static const u8 sn_ov7660[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x61, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x01, 0x01, 0x08, 0x28, 0x1e, 0x20,
/* reg18 reg19 reg1a reg1b */
 0x07, 0x00, 0x00, 0x00
};

static const u8 sn_po1030[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x21, 0x62, 0x00, 0x1a, 0x20, 0x20, 0x20,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x00, 0x06, 0x06, 0x28, 0x1e, 0x00,
/* reg18 reg19 reg1a reg1b */
 0x07, 0x00, 0x00, 0x00
};

static const u8 sn_po2030n[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x63, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x00, 0x01, 0x14, 0x28, 0x1e, 0x00,
/* reg18 reg19 reg1a reg1b */
 0x07, 0x00, 0x00, 0x00
};

static const u8 sn_soi768[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x21, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x00, 0x01, 0x08, 0x28, 0x1e, 0x00,
/* reg18 reg19 reg1a reg1b */
 0x07, 0x00, 0x00, 0x00
};

static const u8 sn_sp80708[0x1c] = {
/* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
 0x00, 0x63, 0x60, 0x00, 0x1a, 0x20, 0x20, 0x20,
/* reg8 reg9 rega regb regc regd rege regf */
 0x81, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
 0x03, 0x00, 0x00, 0x03, 0x04, 0x28, 0x1e, 0x00,
/* reg18 reg19 reg1a reg1b */
 0x07, 0x00, 0x00, 0x00
};

/* sequence specific to the sensors - !! index = SENSOR_xxx */
static const u8 *sn_tb[] = {
[SENSOR_ADCM1700] = sn_adcm1700,
[SENSOR_GC0307] = sn_gc0307,
[SENSOR_HV7131R] = sn_hv7131,
[SENSOR_MI0360] = sn_mi0360,
[SENSOR_MI0360B] = sn_mi0360b,
[SENSOR_MO4000] = sn_mo4000,
[SENSOR_MT9V111] = sn_mt9v111,
[SENSOR_OM6802] = sn_om6802,
[SENSOR_OV7630] = sn_ov7630,
[SENSOR_OV7648] = sn_ov7648,
[SENSOR_OV7660] = sn_ov7660,
[SENSOR_PO1030] = sn_po1030,
[SENSOR_PO2030N] = sn_po2030n,
[SENSOR_SOI768] = sn_soi768,
[SENSOR_SP80708] = sn_sp80708,
};

/* default gamma table */
static const u8 gamma_def[17] = {
 0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
 0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
};
/* gamma for sensor ADCM1700 */
static const u8 gamma_spec_0[17] = {
 0x0f, 0x39, 0x5a, 0x74, 0x86, 0x95, 0xa6, 0xb4,
 0xbd, 0xc4, 0xcc, 0xd4, 0xd5, 0xde, 0xe4, 0xed, 0xf5
};
/* gamma for sensors HV7131R and MT9V111 */
static const u8 gamma_spec_1[17] = {
 0x08, 0x3a, 0x52, 0x65, 0x75, 0x83, 0x91, 0x9d,
 0xa9, 0xb4, 0xbe, 0xc8, 0xd2, 0xdb, 0xe4, 0xed, 0xf5
};
/* gamma for sensor GC0307 */
static const u8 gamma_spec_2[17] = {
 0x14, 0x37, 0x50, 0x6a, 0x7c, 0x8d, 0x9d, 0xab,
 0xb5, 0xbf, 0xc2, 0xcb, 0xd1, 0xd6, 0xdb, 0xe1, 0xeb
};
/* gamma for sensor SP80708 */
static const u8 gamma_spec_3[17] = {
 0x0a, 0x2d, 0x4e, 0x68, 0x7d, 0x8f, 0x9f, 0xab,
 0xb7, 0xc2, 0xcc, 0xd3, 0xd8, 0xde, 0xe2, 0xe5, 0xe6
};

/* color matrix and offsets */
static const u8 reg84[] = {
 0x14, 0x00, 0x27, 0x00, 0x07, 0x00, /* YR YG YB gains */
 0xe8, 0x0f, 0xda, 0x0f, 0x40, 0x00, /* UR UG UB */
 0x3e, 0x00, 0xcd, 0x0f, 0xf7, 0x0f, /* VR VG VB */
 0x00, 0x00, 0x00   /* YUV offsets */
};

#define DELAY 0xdd

static const u8 adcm1700_sensor_init[][8] = {
 {0xa0, 0x51, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x04, 0x08, 0x00, 0x00, 0x00, 0x10}, /* reset */
 {DELAY, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 {0xb0, 0x51, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
 {DELAY, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 {0xb0, 0x51, 0x0c, 0xe0, 0x2e, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x10, 0x02, 0x02, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x14, 0x0e, 0x0e, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x1c, 0x00, 0x80, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x20, 0x01, 0x00, 0x00, 0x00, 0x10},
 {DELAY, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 {0xb0, 0x51, 0x04, 0x04, 0x00, 0x00, 0x00, 0x10},
 {DELAY, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 {0xb0, 0x51, 0x04, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x14, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
 {}
};
static const u8 adcm1700_sensor_param1[][8] = {
 {0xb0, 0x51, 0x26, 0xf9, 0x01, 0x00, 0x00, 0x10}, /* exposure? */
 {0xd0, 0x51, 0x1e, 0x8e, 0x8e, 0x8e, 0x8e, 0x10},

 {0xa0, 0x51, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x32, 0x00, 0x72, 0x00, 0x00, 0x10},
 {0xd0, 0x51, 0x1e, 0xbe, 0xd7, 0xe8, 0xbe, 0x10}, /* exposure? */

 {0xa0, 0x51, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
 {0xb0, 0x51, 0x32, 0x00, 0xa2, 0x00, 0x00, 0x10},
 {}
};
static const u8 gc0307_sensor_init[][8] = {
 {0xa0, 0x21, 0x43, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x44, 0xa2, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x01, 0x6a, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x02, 0x70, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x11, 0x05, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x08, 0x02, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x09, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x0a, 0xe8, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x0b, 0x02, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x0c, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x0d, 0x22, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x0e, 0x02, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x0f, 0xb2, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x12, 0x70, 0x00, 0x00, 0x00, 0x10},
 {DELAY, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 10ms*/
 {0xa0, 0x21, 0x13, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x15, 0xb8, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x16, 0x13, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x17, 0x52, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x18, 0x50, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x1e, 0x0d, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x1f, 0x32, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x61, 0x90, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x63, 0x70, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x65, 0x98, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x67, 0x90, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x04, 0x96, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x45, 0x27, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x47, 0x2c, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x43, 0x47, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x44, 0xd8, 0x00, 0x00, 0x00, 0x10},
 {}
};
static const u8 gc0307_sensor_param1[][8] = {
 {0xa0, 0x21, 0x68, 0x13, 0x00, 0x00, 0x00, 0x10},
 {0xd0, 0x21, 0x61, 0x80, 0x00, 0x80, 0x00, 0x10},
 {0xc0, 0x21, 0x65, 0x80, 0x00, 0x80, 0x00, 0x10},
 {0xc0, 0x21, 0x63, 0xa0, 0x00, 0xa6, 0x00, 0x10},
/*param3*/
 {0xa0, 0x21, 0x01, 0x6e, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x21, 0x02, 0x88, 0x00, 0x00, 0x00, 0x10},
 {}
};

static const u8 hv7131r_sensor_init[][8] = {
 {0xc1, 0x11, 0x01, 0x08, 0x01, 0x00, 0x00, 0x10},
 {0xb1, 0x11, 0x34, 0x17, 0x7f, 0x00, 0x00, 0x10},
 {0xd1, 0x11, 0x40, 0xff, 0x7f, 0x7f, 0x7f, 0x10},
/* {0x91, 0x11, 0x44, 0x00, 0x00, 0x00, 0x00, 0x10}, */
 {0xd1, 0x11, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x11, 0x14, 0x01, 0xe2, 0x02, 0x82, 0x10},
/* {0x91, 0x11, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10}, */

 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 {0xc1, 0x11, 0x25, 0x00, 0x61, 0xa8, 0x00, 0x10},
 {0xa1, 0x11, 0x30, 0x22, 0x00, 0x00, 0x00, 0x10},
 {0xc1, 0x11, 0x31, 0x20, 0x2e, 0x20, 0x00, 0x10},
 {0xc1, 0x11, 0x25, 0x00, 0xc3, 0x50, 0x00, 0x10},
 {0xa1, 0x11, 0x30, 0x07, 0x00, 0x00, 0x00, 0x10}, /* gain14 */
 {0xc1, 0x11, 0x31, 0x10, 0x10, 0x10, 0x00, 0x10}, /* r g b 101a10 */

 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x11, 0x21, 0xd0, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x11, 0x23, 0x09, 0x00, 0x00, 0x00, 0x10},

 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x11, 0x21, 0xd0, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x11, 0x23, 0x10, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10},
       /* set sensor clock */
 {}
};
static const u8 mi0360_sensor_init[][8] = {
 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
 {0xd1, 0x5d, 0x03, 0x01, 0xe2, 0x02, 0x82, 0x10},
 {0xd1, 0x5d, 0x05, 0x00, 0x09, 0x00, 0x53, 0x10},
 {0xb1, 0x5d, 0x0d, 0x00, 0x02, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
 {0xd1, 0x5d, 0x2f, 0xf7, 0xb0, 0x00, 0x04, 0x10},
 {0xd1, 0x5d, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
 {0xb1, 0x5d, 0x3d, 0x06, 0x8f, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x40, 0x01, 0xe0, 0x00, 0xd1, 0x10},
 {0xb1, 0x5d, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
 {0xd1, 0x5d, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x5e, 0x00, 0x00, 0xa3, 0x1d, 0x10},
 {0xb1, 0x5d, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},

 {0xb1, 0x5d, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x2b, 0x00, 0xa0, 0x00, 0xb0, 0x10},
 {0xd1, 0x5d, 0x2d, 0x00, 0xa0, 0x00, 0xa0, 0x10},

 {0xb1, 0x5d, 0x0a, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor clck ?2 */
 {0xb1, 0x5d, 0x06, 0x00, 0x30, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10}, /* exposure 2 */

 {0xd1, 0x5d, 0x2b, 0x00, 0xb9, 0x00, 0xe3, 0x10},
 {0xd1, 0x5d, 0x2d, 0x00, 0x5f, 0x00, 0xb9, 0x10}, /* 42 */
/* {0xb1, 0x5d, 0x35, 0x00, 0x67, 0x00, 0x00, 0x10}, * gain orig */
/* {0xb1, 0x5d, 0x35, 0x00, 0x20, 0x00, 0x00, 0x10}, * gain */
 {0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10}, /* update */
 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
 {}
};
static const u8 mi0360b_sensor_init[][8] = {
 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 20ms*/
 {0xb1, 0x5d, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 20ms*/
 {0xd1, 0x5d, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
 {0xd1, 0x5d, 0x03, 0x01, 0xe2, 0x02, 0x82, 0x10},
 {0xd1, 0x5d, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x0d, 0x00, 0x02, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
 {0xd1, 0x5d, 0x2f, 0xf7, 0xb0, 0x00, 0x04, 0x10},
 {0xd1, 0x5d, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
 {0xb1, 0x5d, 0x3d, 0x06, 0x8f, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x40, 0x01, 0xe0, 0x00, 0xd1, 0x10},
 {0xb1, 0x5d, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
 {0xd1, 0x5d, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x5e, 0x00, 0x00, 0xa3, 0x1d, 0x10},
 {0xb1, 0x5d, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},

 {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
 {0xd1, 0x5d, 0x2b, 0x00, 0x33, 0x00, 0xa0, 0x10},
 {0xd1, 0x5d, 0x2d, 0x00, 0xa0, 0x00, 0x33, 0x10},
 {}
};
static const u8 mi0360b_sensor_param1[][8] = {
 {0xb1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x06, 0x00, 0x53, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x05, 0x00, 0x09, 0x00, 0x00, 0x10},
 {0xb1, 0x5d, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10}, /* exposure 2 */

 {0xd1, 0x5d, 0x2b, 0x00, 0xd1, 0x01, 0xc9, 0x10},
 {0xd1, 0x5d, 0x2d, 0x00, 0xed, 0x00, 0xd1, 0x10},
 {0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10}, /* update */
 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
 {}
};
static const u8 mo4000_sensor_init[][8] = {
 {0xa1, 0x21, 0x01, 0x02, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x05, 0x04, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x06, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x06, 0x81, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x11, 0x20, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x11, 0x30, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
 {}
};
static const u8 mt9v111_sensor_init[][8] = {
 {0xb1, 0x5c, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10}, /* reset? */
 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
 {0xb1, 0x5c, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x5c, 0x01, 0x00, 0x01, 0x00, 0x00, 0x10}, /* IFP select */
 {0xb1, 0x5c, 0x08, 0x04, 0x80, 0x00, 0x00, 0x10}, /* output fmt ctrl */
 {0xb1, 0x5c, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10}, /* op mode ctrl */
 {0xb1, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10}, /* sensor select */
 {0xb1, 0x5c, 0x08, 0x00, 0x08, 0x00, 0x00, 0x10}, /* row start */
 {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10}, /* col start */
 {0xb1, 0x5c, 0x03, 0x01, 0xe7, 0x00, 0x00, 0x10}, /* window height */
 {0xb1, 0x5c, 0x04, 0x02, 0x87, 0x00, 0x00, 0x10}, /* window width */
 {0xb1, 0x5c, 0x07, 0x30, 0x02, 0x00, 0x00, 0x10}, /* output ctrl */
 {0xb1, 0x5c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10}, /* shutter delay */
 {0xb1, 0x5c, 0x12, 0x00, 0xb0, 0x00, 0x00, 0x10}, /* zoom col start */
 {0xb1, 0x5c, 0x13, 0x00, 0x7c, 0x00, 0x00, 0x10}, /* zoom row start */
 {0xb1, 0x5c, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* digital zoom */
 {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10}, /* read mode */
 {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
 {}
};
static const u8 mt9v111_sensor_param1[][8] = {
 {0xd1, 0x5c, 0x2b, 0x00, 0x33, 0x00, 0xad, 0x10}, /* G1 and B gains */
 {0xd1, 0x5c, 0x2d, 0x00, 0xad, 0x00, 0x33, 0x10}, /* R and G2 gains */
 {0xb1, 0x5c, 0x06, 0x00, 0x40, 0x00, 0x00, 0x10}, /* vert blanking */
 {0xb1, 0x5c, 0x05, 0x00, 0x09, 0x00, 0x00, 0x10}, /* horiz blanking */
 {0xb1, 0x5c, 0x35, 0x01, 0xc0, 0x00, 0x00, 0x10}, /* global gain */
 {}
};
static const u8 om6802_init0[2][8] = {
/*fixme: variable*/
 {0xa0, 0x34, 0x29, 0x0e, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x34, 0x23, 0xb0, 0x00, 0x00, 0x00, 0x10},
};
static const u8 om6802_sensor_init[][8] = {
 {0xa0, 0x34, 0xdf, 0x6d, 0x00, 0x00, 0x00, 0x10},
      /* factory mode */
 {0xa0, 0x34, 0xdd, 0x18, 0x00, 0x00, 0x00, 0x10},
      /* output raw RGB */
 {0xa0, 0x34, 0x5a, 0xc0, 0x00, 0x00, 0x00, 0x10},
/* {0xa0, 0x34, 0xfb, 0x11, 0x00, 0x00, 0x00, 0x10}, */
 {0xa0, 0x34, 0xf0, 0x04, 0x00, 0x00, 0x00, 0x10},
  /* auto-exposure speed (0) / white balance mode (auto RGB) */
/* {0xa0, 0x34, 0xf1, 0x02, 0x00, 0x00, 0x00, 0x10},
 * set color mode */
/* {0xa0, 0x34, 0xfe, 0x5b, 0x00, 0x00, 0x00, 0x10},
 * max AGC value in AE */
/* {0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10},
 * preset AGC */
/* {0xa0, 0x34, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x10},
 * preset brightness */
/* {0xa0, 0x34, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x10},
 * preset contrast */
/* {0xa0, 0x34, 0xe8, 0x31, 0x00, 0x00, 0x00, 0x10},
 * preset gamma */
 {0xa0, 0x34, 0xe9, 0x0f, 0x00, 0x00, 0x00, 0x10},
    /* luminance mode (0x4f -> AutoExpo on) */
 {0xa0, 0x34, 0xe4, 0xff, 0x00, 0x00, 0x00, 0x10},
       /* preset shutter */
/* {0xa0, 0x34, 0xef, 0x00, 0x00, 0x00, 0x00, 0x10},
 * auto frame rate */
/* {0xa0, 0x34, 0xfb, 0xee, 0x00, 0x00, 0x00, 0x10}, */
 {0xa0, 0x34, 0x5d, 0x80, 0x00, 0x00, 0x00, 0x10},
 {}
};
static const u8 om6802_sensor_param1[][8] = {
 {0xa0, 0x34, 0x71, 0x84, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x34, 0x72, 0x05, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x34, 0x68, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa0, 0x34, 0x69, 0x01, 0x00, 0x00, 0x00, 0x10},
 {}
};
static const u8 ov7630_sensor_init[][8] = {
 {0xa1, 0x21, 0x76, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
/* win: i2c_r from 00 to 80 */
 {0xd1, 0x21, 0x03, 0x80, 0x10, 0x20, 0x80, 0x10},
 {0xb1, 0x21, 0x0c, 0x20, 0x20, 0x00, 0x00, 0x10},
/* HDG: 0x11 was 0x00 change to 0x01 for better exposure (15 fps instead of 30)
0x13 was 0xc0 change to 0xc3 for auto gain and exposure */
 {0xd1, 0x21, 0x11, 0x01, 0x48, 0xc3, 0x00, 0x10},
 {0xb1, 0x21, 0x15, 0x80, 0x03, 0x00, 0x00, 0x10},
 {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x21, 0x1f, 0x00, 0x80, 0x80, 0x80, 0x10},
 {0xd1, 0x21, 0x23, 0xde, 0x10, 0x8a, 0xa0, 0x10},
 {0xc1, 0x21, 0x27, 0xca, 0xa2, 0x74, 0x00, 0x10},
 {0xd1, 0x21, 0x2a, 0x88, 0x00, 0x88, 0x01, 0x10},
 {0xc1, 0x21, 0x2e, 0x80, 0x00, 0x18, 0x00, 0x10},
 {0xa1, 0x21, 0x21, 0x08, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x21, 0x32, 0xc2, 0x08, 0x00, 0x00, 0x10},
 {0xb1, 0x21, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x21, 0x60, 0x05, 0x40, 0x12, 0x57, 0x10},
 {0xa1, 0x21, 0x64, 0x73, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x21, 0x65, 0x00, 0x55, 0x01, 0xac, 0x10},
 {0xa1, 0x21, 0x69, 0x38, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x21, 0x6f, 0x1f, 0x01, 0x00, 0x10, 0x10},
 {0xd1, 0x21, 0x73, 0x50, 0x20, 0x02, 0x01, 0x10},
 {0xd1, 0x21, 0x77, 0xf3, 0x90, 0x98, 0x98, 0x10},
 {0xc1, 0x21, 0x7b, 0x00, 0x4c, 0xf7, 0x00, 0x10},
 {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
 {}
};
static const u8 ov7630_sensor_param1[][8] = {
 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
/*fixme: + 0x12, 0x04*/
/* {0xa1, 0x21, 0x75, 0x82, 0x00, 0x00, 0x00, 0x10},  * COMN
 * set by setvflip */
 {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x21, 0x01, 0x80, 0x80, 0x00, 0x00, 0x10},
/* */
/* {0xa1, 0x21, 0x2a, 0x88, 0x00, 0x00, 0x00, 0x10}, * set by setfreq */
/* {0xa1, 0x21, 0x2b, 0x34, 0x00, 0x00, 0x00, 0x10}, * set by setfreq */
/* */
 {0xa1, 0x21, 0x10, 0x83, 0x00, 0x00, 0x00, 0x10},
/* {0xb1, 0x21, 0x01, 0x88, 0x70, 0x00, 0x00, 0x10}, */
 {}
};

static const u8 ov7648_sensor_init[][8] = {
 {0xa1, 0x21, 0x76, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset */
 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x21, 0x03, 0xa4, 0x30, 0x88, 0x00, 0x10},
 {0xb1, 0x21, 0x11, 0x80, 0x08, 0x00, 0x00, 0x10},
 {0xc1, 0x21, 0x13, 0xa0, 0x04, 0x84, 0x00, 0x10},
 {0xd1, 0x21, 0x17, 0x1a, 0x02, 0xba, 0xf4, 0x10},
 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x21, 0x1f, 0x41, 0xc0, 0x80, 0x80, 0x10},
 {0xd1, 0x21, 0x23, 0xde, 0xa0, 0x80, 0x32, 0x10},
 {0xd1, 0x21, 0x27, 0xfe, 0xa0, 0x00, 0x91, 0x10},
 {0xd1, 0x21, 0x2b, 0x00, 0x88, 0x85, 0x80, 0x10},
 {0xc1, 0x21, 0x2f, 0x9c, 0x00, 0xc4, 0x00, 0x10},
 {0xd1, 0x21, 0x60, 0xa6, 0x60, 0x88, 0x12, 0x10},
 {0xd1, 0x21, 0x64, 0x88, 0x00, 0x00, 0x94, 0x10},
 {0xd1, 0x21, 0x68, 0x7a, 0x0c, 0x00, 0x00, 0x10},
 {0xd1, 0x21, 0x6c, 0x11, 0x33, 0x22, 0x00, 0x10},
 {0xd1, 0x21, 0x70, 0x11, 0x00, 0x10, 0x50, 0x10},
 {0xd1, 0x21, 0x74, 0x20, 0x06, 0x00, 0xb5, 0x10},
 {0xd1, 0x21, 0x78, 0x8a, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x21, 0x7c, 0x00, 0x43, 0x00, 0x00, 0x10},

 {0xd1, 0x21, 0x21, 0x86, 0x00, 0xde, 0xa0, 0x10},
/* {0xd1, 0x21, 0x25, 0x80, 0x32, 0xfe, 0xa0, 0x10}, jfm done */
/* {0xd1, 0x21, 0x29, 0x00, 0x91, 0x00, 0x88, 0x10}, jfm done */
/* {0xb1, 0x21, 0x2d, 0x85, 0x00, 0x00, 0x00, 0x10}, set by setfreq */
 {}
};
static const u8 ov7648_sensor_param1[][8] = {
/* {0xa1, 0x21, 0x12, 0x08, 0x00, 0x00, 0x00, 0x10}, jfm done */
/* {0xa1, 0x21, 0x75, 0x06, 0x00, 0x00, 0x00, 0x10},   * COMN
 * set by setvflip */
 {0xa1, 0x21, 0x19, 0x02, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
/* {0xa1, 0x21, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
/* {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},  * GAIN - def */
/* {0xb1, 0x21, 0x01, 0x6c, 0x6c, 0x00, 0x00, 0x10},  * B R - def: 80 */
/*...*/
 {0xa1, 0x21, 0x11, 0x81, 0x00, 0x00, 0x00, 0x10}, /* CLKRC */
/* {0xa1, 0x21, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
/* {0xa1, 0x21, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
/* {0xa1, 0x21, 0x2a, 0x91, 0x00, 0x00, 0x00, 0x10}, jfm done */
/* {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
/* {0xb1, 0x21, 0x01, 0x64, 0x84, 0x00, 0x00, 0x10},  * B R - def: 80 */

 {}
};

static const u8 ov7660_sensor_init[][8] = {
 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset SCCB */
 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
 {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
      /* Outformat = rawRGB */
 {0xa1, 0x21, 0x13, 0xb8, 0x00, 0x00, 0x00, 0x10}, /* init COM8 */
 {0xd1, 0x21, 0x00, 0x01, 0x74, 0x92, 0x00, 0x10},
      /* GAIN BLUE RED VREF */
 {0xd1, 0x21, 0x04, 0x00, 0x7d, 0x62, 0x00, 0x10},
      /* COM 1 BAVE GEAVE AECHH */
 {0xb1, 0x21, 0x08, 0x83, 0x01, 0x00, 0x00, 0x10}, /* RAVE COM2 */
 {0xd1, 0x21, 0x0c, 0x00, 0x08, 0x04, 0x4f, 0x10}, /* COM 3 4 5 6 */
 {0xd1, 0x21, 0x10, 0x7f, 0x40, 0x05, 0xff, 0x10},
      /* AECH CLKRC COM7 COM8 */
 {0xc1, 0x21, 0x14, 0x2c, 0x00, 0x02, 0x00, 0x10}, /* COM9 COM10 */
 {0xd1, 0x21, 0x17, 0x10, 0x60, 0x02, 0x7b, 0x10},
      /* HSTART HSTOP VSTRT VSTOP */
 {0xa1, 0x21, 0x1b, 0x02, 0x00, 0x00, 0x00, 0x10}, /* PSHFT */
 {0xb1, 0x21, 0x1e, 0x01, 0x0e, 0x00, 0x00, 0x10}, /* MVFP LAEC */
 {0xd1, 0x21, 0x20, 0x07, 0x07, 0x07, 0x07, 0x10},
     /* BOS GBOS GROS ROS (BGGR offset) */
/* {0xd1, 0x21, 0x24, 0x68, 0x58, 0xd4, 0x80, 0x10}, */
 {0xd1, 0x21, 0x24, 0x78, 0x68, 0xd4, 0x80, 0x10},
      /* AEW AEB VPT BBIAS */
 {0xd1, 0x21, 0x28, 0x80, 0x30, 0x00, 0x00, 0x10},
      /* GbBIAS RSVD EXHCH EXHCL */
 {0xd1, 0x21, 0x2c, 0x80, 0x00, 0x00, 0x62, 0x10},
      /* RBIAS ADVFL ASDVFH YAVE */
 {0xc1, 0x21, 0x30, 0x08, 0x30, 0xb4, 0x00, 0x10},
      /* HSYST HSYEN HREF */
 {0xd1, 0x21, 0x33, 0x00, 0x07, 0x84, 0x00, 0x10}, /* reserved */
 {0xd1, 0x21, 0x37, 0x0c, 0x02, 0x43, 0x00, 0x10},
      /* ADC ACOM OFON TSLB */
 {0xd1, 0x21, 0x3b, 0x02, 0x6c, 0x19, 0x0e, 0x10},
      /* COM11 COM12 COM13 COM14 */
 {0xd1, 0x21, 0x3f, 0x41, 0xc1, 0x22, 0x08, 0x10},
      /* EDGE COM15 COM16 COM17 */
 {0xd1, 0x21, 0x43, 0xf0, 0x10, 0x78, 0xa8, 0x10}, /* reserved */
 {0xd1, 0x21, 0x47, 0x60, 0x80, 0x00, 0x00, 0x10}, /* reserved */
 {0xd1, 0x21, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* reserved */
 {0xd1, 0x21, 0x4f, 0x46, 0x36, 0x0f, 0x17, 0x10}, /* MTX 1 2 3 4 */
 {0xd1, 0x21, 0x53, 0x7f, 0x96, 0x40, 0x40, 0x10}, /* MTX 5 6 7 8 */
 {0xb1, 0x21, 0x57, 0x40, 0x0f, 0x00, 0x00, 0x10}, /* MTX9 MTXS */
 {0xd1, 0x21, 0x59, 0xba, 0x9a, 0x22, 0xb9, 0x10}, /* reserved */
 {0xd1, 0x21, 0x5d, 0x9b, 0x10, 0xf0, 0x05, 0x10}, /* reserved */
 {0xa1, 0x21, 0x61, 0x60, 0x00, 0x00, 0x00, 0x10}, /* reserved */
 {0xd1, 0x21, 0x62, 0x00, 0x00, 0x50, 0x30, 0x10},
      /* LCC1 LCC2 LCC3 LCC4 */
 {0xa1, 0x21, 0x66, 0x00, 0x00, 0x00, 0x00, 0x10}, /* LCC5 */
 {0xd1, 0x21, 0x67, 0x80, 0x7a, 0x90, 0x80, 0x10}, /* MANU */
 {0xa1, 0x21, 0x6b, 0x0a, 0x00, 0x00, 0x00, 0x10},
     /* band gap reference [0:3] DBLV */
 {0xd1, 0x21, 0x6c, 0x30, 0x48, 0x80, 0x74, 0x10}, /* gamma curve */
 {0xd1, 0x21, 0x70, 0x64, 0x60, 0x5c, 0x58, 0x10}, /* gamma curve */
 {0xd1, 0x21, 0x74, 0x54, 0x4c, 0x40, 0x38, 0x10}, /* gamma curve */
 {0xd1, 0x21, 0x78, 0x34, 0x30, 0x2f, 0x2b, 0x10}, /* gamma curve */
 {0xd1, 0x21, 0x7c, 0x03, 0x07, 0x17, 0x34, 0x10}, /* gamma curve */
 {0xd1, 0x21, 0x80, 0x41, 0x4d, 0x58, 0x63, 0x10}, /* gamma curve */
 {0xd1, 0x21, 0x84, 0x6e, 0x77, 0x87, 0x95, 0x10}, /* gamma curve */
 {0xc1, 0x21, 0x88, 0xaf, 0xc7, 0xdf, 0x00, 0x10}, /* gamma curve */
 {0xc1, 0x21, 0x8b, 0x99, 0x99, 0xcf, 0x00, 0x10}, /* reserved */
 {0xb1, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x10}, /* DM_LNL/H */
/* not in all ms-win traces*/
 {0xa1, 0x21, 0xa1, 0x00, 0x00, 0x00, 0x00, 0x10},
 {}
};
static const u8 ov7660_sensor_param1[][8] = {
 {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10}, /* MVFP */
      /* bits[3..0]reserved */
 {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
      /* VREF vertical frame ctrl */
 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10}, /* AECH 0x20 */
 {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFL */
 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFH */
 {0xa1, 0x21, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x10}, /* GAIN */
/* {0xb1, 0x21, 0x01, 0x78, 0x78, 0x00, 0x00, 0x10}, * BLUE */
/****** (some exchanges in the win trace) ******/
/*fixme:param2*/
 {0xa1, 0x21, 0x93, 0x00, 0x00, 0x00, 0x00, 0x10},/* dummy line hight */
 {0xa1, 0x21, 0x92, 0x25, 0x00, 0x00, 0x00, 0x10}, /* dummy line low */
 {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCH */
 {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCL */
/* {0xa1, 0x21, 0x02, 0x90, 0x00, 0x00, 0x00, 0x10},  * RED */
/****** (some exchanges in the win trace) ******/
/******!! startsensor KO if changed !!****/
/*fixme: param3*/
 {0xa1, 0x21, 0x93, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x92, 0xff, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x2b, 0xc3, 0x00, 0x00, 0x00, 0x10},
 {}
};

static const u8 po1030_sensor_init[][8] = {
/* the sensor registers are described in m5602/m5602_po1030.h */
 {0xa1, 0x6e, 0x3f, 0x20, 0x00, 0x00, 0x00, 0x10}, /* sensor reset */
 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
 {0xa1, 0x6e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x04, 0x02, 0xb1, 0x02, 0x39, 0x10},
 {0xd1, 0x6e, 0x08, 0x00, 0x01, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x0c, 0x02, 0x7f, 0x01, 0xe0, 0x10},
 {0xd1, 0x6e, 0x12, 0x03, 0x02, 0x00, 0x03, 0x10},
 {0xd1, 0x6e, 0x16, 0x85, 0x40, 0x4a, 0x40, 0x10}, /* r/g1/b/g2 gains */
 {0xc1, 0x6e, 0x1a, 0x00, 0x80, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x1d, 0x08, 0x03, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x23, 0x00, 0xb0, 0x00, 0x94, 0x10},
 {0xd1, 0x6e, 0x27, 0x58, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x6e, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x2d, 0x14, 0x35, 0x61, 0x84, 0x10}, /* gamma corr */
 {0xd1, 0x6e, 0x31, 0xa2, 0xbd, 0xd8, 0xff, 0x10},
 {0xd1, 0x6e, 0x35, 0x06, 0x1e, 0x12, 0x02, 0x10}, /* color matrix */
 {0xd1, 0x6e, 0x39, 0xaa, 0x53, 0x37, 0xd5, 0x10},
 {0xa1, 0x6e, 0x3d, 0xf2, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x3e, 0x00, 0x00, 0x80, 0x03, 0x10},
 {0xd1, 0x6e, 0x42, 0x03, 0x00, 0x00, 0x00, 0x10},
 {0xc1, 0x6e, 0x46, 0x00, 0x80, 0x80, 0x00, 0x10},
 {0xd1, 0x6e, 0x4b, 0x02, 0xef, 0x08, 0xcd, 0x10},
 {0xd1, 0x6e, 0x4f, 0x00, 0xd0, 0x00, 0xa0, 0x10},
 {0xd1, 0x6e, 0x53, 0x01, 0xaa, 0x01, 0x40, 0x10},
 {0xd1, 0x6e, 0x5a, 0x50, 0x04, 0x30, 0x03, 0x10}, /* raw rgb bayer */
 {0xa1, 0x6e, 0x5e, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x5f, 0x10, 0x40, 0xff, 0x00, 0x10},

 {0xd1, 0x6e, 0x63, 0x40, 0x40, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xc1, 0x6e, 0x73, 0x10, 0x80, 0xeb, 0x00, 0x10},
 {}
};
static const u8 po1030_sensor_param1[][8] = {
/* from ms-win traces - these values change with auto gain/expo/wb.. */
 {0xa1, 0x6e, 0x1e, 0x03, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x1e, 0x03, 0x00, 0x00, 0x00, 0x10},
/* mean values */
 {0xc1, 0x6e, 0x1a, 0x02, 0xd4, 0xa4, 0x00, 0x10}, /* integlines */
 {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10}, /* global gain */
 {0xc1, 0x6e, 0x16, 0x40, 0x40, 0x40, 0x00, 0x10}, /* r/g1/b gains */

 {0xa1, 0x6e, 0x1d, 0x08, 0x00, 0x00, 0x00, 0x10}, /* control1 */
 {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10}, /* frameheight */
 {0xa1, 0x6e, 0x07, 0xd5, 0x00, 0x00, 0x00, 0x10},
/* {0xc1, 0x6e, 0x16, 0x49, 0x40, 0x45, 0x00, 0x10}, */
 {}
};

static const u8 po2030n_sensor_init[][8] = {
 {0xa1, 0x6e, 0x1e, 0x1a, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x1f, 0x99, 0x00, 0x00, 0x00, 0x10},
 {DELAY, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 10ms */
 {0xa1, 0x6e, 0x1e, 0x0a, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x1f, 0x19, 0x00, 0x00, 0x00, 0x10},
 {DELAY, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 10ms */
 {0xa1, 0x6e, 0x20, 0x44, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x04, 0x03, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x05, 0x70, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x07, 0x25, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x08, 0x00, 0xd0, 0x00, 0x08, 0x10},
 {0xd1, 0x6e, 0x0c, 0x03, 0x50, 0x01, 0xe8, 0x10},
 {0xd1, 0x6e, 0x1d, 0x20, 0x0a, 0x19, 0x44, 0x10},
 {0xd1, 0x6e, 0x21, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x25, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x29, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x35, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x39, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x41, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x45, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x49, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x4d, 0x00, 0x00, 0x00, 0xed, 0x10},
 {0xd1, 0x6e, 0x51, 0x17, 0x4a, 0x2f, 0xc0, 0x10},
 {0xd1, 0x6e, 0x55, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x59, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x61, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x65, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x69, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x71, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x75, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x79, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x7d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x81, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x85, 0x00, 0x00, 0x00, 0x08, 0x10},
 {0xd1, 0x6e, 0x89, 0x01, 0xe8, 0x00, 0x01, 0x10},
 {0xa1, 0x6e, 0x8d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x21, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x25, 0x00, 0x00, 0x00, 0x01, 0x10},
 {0xd1, 0x6e, 0x29, 0xe6, 0x00, 0xbd, 0x03, 0x10},
 {0xd1, 0x6e, 0x2d, 0x41, 0x38, 0x68, 0x40, 0x10},
 {0xd1, 0x6e, 0x31, 0x2b, 0x00, 0x36, 0x00, 0x10},
 {0xd1, 0x6e, 0x35, 0x30, 0x30, 0x08, 0x00, 0x10},
 {0xd1, 0x6e, 0x39, 0x00, 0x00, 0x33, 0x06, 0x10},
 {0xb1, 0x6e, 0x3d, 0x06, 0x02, 0x00, 0x00, 0x10},
 {}
};
static const u8 po2030n_sensor_param1[][8] = {
 {0xa1, 0x6e, 0x1a, 0x01, 0x00, 0x00, 0x00, 0x10},
 {DELAY, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 8ms */
 {0xa1, 0x6e, 0x1b, 0xf4, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10},
 {0xd1, 0x6e, 0x16, 0x40, 0x40, 0x40, 0x40, 0x10}, /* RGBG gains */
/*param2*/
 {0xa1, 0x6e, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x04, 0x03, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x05, 0x6f, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x6e, 0x07, 0x25, 0x00, 0x00, 0x00, 0x10},
 {}
};

static const u8 soi768_sensor_init[][8] = {
 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset */
 {DELAY, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 96ms */
 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x13, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x19, 0x00, 0x00, 0x00, 0x00, 0x10},
 {}
};
static const u8 soi768_sensor_param1[][8] = {
 {0xa1, 0x21, 0x10, 0x10, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x21, 0x01, 0x7f, 0x7f, 0x00, 0x00, 0x10},
/* */
/* {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10}, */
/* {0xa1, 0x21, 0x2d, 0x25, 0x00, 0x00, 0x00, 0x10}, */
 {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10},
/* {0xb1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10}, */
 {0xa1, 0x21, 0x02, 0x8d, 0x00, 0x00, 0x00, 0x10},
/* the next sequence should be used for auto gain */
 {0xa1, 0x21, 0x00, 0x07, 0x00, 0x00, 0x00, 0x10},
   /* global gain ? : 07 - change with 0x15 at the end */
 {0xa1, 0x21, 0x10, 0x3f, 0x00, 0x00, 0x00, 0x10}, /* ???? : 063f */
 {0xa1, 0x21, 0x04, 0x06, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x21, 0x2d, 0x63, 0x03, 0x00, 0x00, 0x10},
   /* exposure ? : 0200 - change with 0x1e at the end */
 {}
};

static const u8 sp80708_sensor_init[][8] = {
 {0xa1, 0x18, 0x06, 0xf9, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x09, 0x1f, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x0d, 0xc0, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x10, 0x40, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x11, 0x4e, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x12, 0x53, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x15, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x19, 0x18, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x1a, 0x10, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x1b, 0x10, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x1c, 0x28, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x1d, 0x02, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x1e, 0x10, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x26, 0x04, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x27, 0x1e, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x28, 0x5a, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x29, 0x28, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x2a, 0x78, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x2b, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x2c, 0xf7, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x2d, 0x2d, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x2e, 0xd5, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x39, 0x42, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x3a, 0x67, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x3b, 0x87, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x3c, 0xa3, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x3d, 0xb0, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x3e, 0xbc, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x3f, 0xc8, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x40, 0xd4, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x41, 0xdf, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x42, 0xea, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x43, 0xf5, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x45, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x46, 0x60, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x47, 0x50, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x48, 0x30, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x49, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x4d, 0xae, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x4e, 0x03, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x4f, 0x66, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x50, 0x1c, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x44, 0x10, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x4a, 0x30, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x51, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x52, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x53, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x54, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x55, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x56, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x57, 0xe0, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x58, 0xc0, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x59, 0xab, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x5a, 0xa0, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x5b, 0x99, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x5c, 0x90, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x5e, 0x24, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x60, 0x00, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x61, 0x73, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x63, 0x42, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x64, 0x42, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x65, 0x42, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x66, 0x24, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x67, 0x24, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x68, 0x08, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x2f, 0xc9, 0x00, 0x00, 0x00, 0x10},
 {}
};
static const u8 sp80708_sensor_param1[][8] = {
 {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x03, 0x01, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x04, 0xa4, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x14, 0x3f, 0x00, 0x00, 0x00, 0x10},
 {0xa1, 0x18, 0x5d, 0x80, 0x00, 0x00, 0x00, 0x10},
 {0xb1, 0x18, 0x11, 0x40, 0x40, 0x00, 0x00, 0x10},
 {}
};

static const u8 (*sensor_init[])[8] = {
[SENSOR_ADCM1700] = adcm1700_sensor_init,
[SENSOR_GC0307] = gc0307_sensor_init,
[SENSOR_HV7131R] = hv7131r_sensor_init,
[SENSOR_MI0360] = mi0360_sensor_init,
[SENSOR_MI0360B] = mi0360b_sensor_init,
[SENSOR_MO4000] = mo4000_sensor_init,
[SENSOR_MT9V111] = mt9v111_sensor_init,
[SENSOR_OM6802] = om6802_sensor_init,
[SENSOR_OV7630] = ov7630_sensor_init,
[SENSOR_OV7648] = ov7648_sensor_init,
[SENSOR_OV7660] = ov7660_sensor_init,
[SENSOR_PO1030] = po1030_sensor_init,
[SENSOR_PO2030N] = po2030n_sensor_init,
[SENSOR_SOI768] = soi768_sensor_init,
[SENSOR_SP80708] = sp80708_sensor_init,
};

/* read <len> bytes to gspca_dev->usb_buf */
static void reg_r(struct gspca_dev *gspca_dev,
    u16 value, int len)
{
 int ret;

 if (gspca_dev->usb_err < 0)
  return;
 if (len > USB_BUF_SZ) {
  gspca_err(gspca_dev, "reg_r: buffer overflow\n");
  return;
 }

 ret = usb_control_msg(gspca_dev->dev,
   usb_rcvctrlpipe(gspca_dev->dev, 0),
   0,
   USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
   value, 0,
   gspca_dev->usb_buf, len,
   500);
 gspca_dbg(gspca_dev, D_USBI, "reg_r [%02x] -> %02x\n",
    value, gspca_dev->usb_buf[0]);
 if (ret < 0) {
  pr_err("reg_r err %d\n", ret);
  gspca_dev->usb_err = ret;
  /*
 * Make sure the buffer is zeroed to avoid uninitialized
 * values.
 */
  memset(gspca_dev->usb_buf, 0, USB_BUF_SZ);
 }
}

static void reg_w1(struct gspca_dev *gspca_dev,
     u16 value,
     u8 data)
{
 int ret;

 if (gspca_dev->usb_err < 0)
  return;
 gspca_dbg(gspca_dev, D_USBO, "reg_w1 [%04x] = %02x\n", value, data);
 gspca_dev->usb_buf[0] = data;
 ret = usb_control_msg(gspca_dev->dev,
   usb_sndctrlpipe(gspca_dev->dev, 0),
   0x08,
   USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
   value,
   0,
   gspca_dev->usb_buf, 1,
   500);
 if (ret < 0) {
  pr_err("reg_w1 err %d\n", ret);
  gspca_dev->usb_err = ret;
 }
}
static void reg_w(struct gspca_dev *gspca_dev,
     u16 value,
     const u8 *buffer,
     int len)
{
 int ret;

 if (gspca_dev->usb_err < 0)
  return;
 gspca_dbg(gspca_dev, D_USBO, "reg_w [%04x] = %02x %02x ..\n",
    value, buffer[0], buffer[1]);

 if (len > USB_BUF_SZ) {
  gspca_err(gspca_dev, "reg_w: buffer overflow\n");
  return;
 }

 memcpy(gspca_dev->usb_buf, buffer, len);
 ret = usb_control_msg(gspca_dev->dev,
   usb_sndctrlpipe(gspca_dev->dev, 0),
   0x08,
   USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
   value, 0,
   gspca_dev->usb_buf, len,
   500);
 if (ret < 0) {
  pr_err("reg_w err %d\n", ret);
  gspca_dev->usb_err = ret;
 }
}

/* I2C write 1 byte */
static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
{
 struct sd *sd = (struct sd *) gspca_dev;
 int ret;

 if (gspca_dev->usb_err < 0)
  return;
 gspca_dbg(gspca_dev, D_USBO, "i2c_w1 [%02x] = %02x\n", reg, val);
 switch (sd->sensor) {
 case SENSOR_ADCM1700:
 case SENSOR_OM6802:
 case SENSOR_GC0307:  /* i2c command = a0 (100 kHz) */
  gspca_dev->usb_buf[0] = 0x80 | (2 << 4);
  break;
 default:   /* i2c command = a1 (400 kHz) */
  gspca_dev->usb_buf[0] = 0x81 | (2 << 4);
  break;
 }
 gspca_dev->usb_buf[1] = sd->i2c_addr;
 gspca_dev->usb_buf[2] = reg;
 gspca_dev->usb_buf[3] = val;
 gspca_dev->usb_buf[4] = 0;
 gspca_dev->usb_buf[5] = 0;
 gspca_dev->usb_buf[6] = 0;
 gspca_dev->usb_buf[7] = 0x10;
 ret = usb_control_msg(gspca_dev->dev,
   usb_sndctrlpipe(gspca_dev->dev, 0),
   0x08,
   USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
   0x08,   /* value = i2c */
   0,
   gspca_dev->usb_buf, 8,
   500);
 msleep(2);
 if (ret < 0) {
  pr_err("i2c_w1 err %d\n", ret);
  gspca_dev->usb_err = ret;
 }
}

/* I2C write 8 bytes */
static void i2c_w8(struct gspca_dev *gspca_dev,
     const u8 *buffer)
{
 int ret;

 if (gspca_dev->usb_err < 0)
  return;
 gspca_dbg(gspca_dev, D_USBO, "i2c_w8 [%02x] = %02x ..\n",
    buffer[2], buffer[3]);
 memcpy(gspca_dev->usb_buf, buffer, 8);
 ret = usb_control_msg(gspca_dev->dev,
   usb_sndctrlpipe(gspca_dev->dev, 0),
   0x08,
   USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
   0x08, 0,  /* value, index */
   gspca_dev->usb_buf, 8,
   500);
 msleep(2);
 if (ret < 0) {
  pr_err("i2c_w8 err %d\n", ret);
  gspca_dev->usb_err = ret;
 }
}

/* sensor read 'len' (1..5) bytes in gspca_dev->usb_buf */
static void i2c_r(struct gspca_dev *gspca_dev, u8 reg, int len)
{
 struct sd *sd = (struct sd *) gspca_dev;
 u8 mode[8];

 switch (sd->sensor) {
 case SENSOR_ADCM1700:
 case SENSOR_OM6802:
 case SENSOR_GC0307:  /* i2c command = a0 (100 kHz) */
  mode[0] = 0x80 | 0x10;
  break;
 default:   /* i2c command = 91 (400 kHz) */
  mode[0] = 0x81 | 0x10;
  break;
 }
 mode[1] = sd->i2c_addr;
 mode[2] = reg;
 mode[3] = 0;
 mode[4] = 0;
 mode[5] = 0;
 mode[6] = 0;
 mode[7] = 0x10;
 i2c_w8(gspca_dev, mode);
 msleep(2);
 mode[0] = (mode[0] & 0x81) | (len << 4) | 0x02;
 mode[2] = 0;
 i2c_w8(gspca_dev, mode);
 msleep(2);
 reg_r(gspca_dev, 0x0a, 5);
}

static void i2c_w_seq(struct gspca_dev *gspca_dev,
   const u8 (*data)[8])
{
 while ((*data)[0] != 0) {
  if ((*data)[0] != DELAY)
   i2c_w8(gspca_dev, *data);
  else
   msleep((*data)[1]);
  data++;
 }
}

/* check the ID of the hv7131 sensor */
/* this sequence is needed because it activates the sensor */
static void hv7131r_probe(struct gspca_dev *gspca_dev)
{
 i2c_w1(gspca_dev, 0x02, 0);  /* sensor wakeup */
 msleep(10);
 reg_w1(gspca_dev, 0x02, 0x66);  /* Gpio on */
 msleep(10);
 i2c_r(gspca_dev, 0, 5);   /* read sensor id */
 if (gspca_dev->usb_buf[0] == 0x02 /* chip ID (02 is R) */
     && gspca_dev->usb_buf[1] == 0x09
     && gspca_dev->usb_buf[2] == 0x01) {
  gspca_dbg(gspca_dev, D_PROBE, "Sensor HV7131R found\n");
  return;
 }
 pr_warn("Erroneous HV7131R ID 0x%02x 0x%02x 0x%02x\n",
  gspca_dev->usb_buf[0], gspca_dev->usb_buf[1],
  gspca_dev->usb_buf[2]);
}

static void mi0360_probe(struct gspca_dev *gspca_dev)
{
 struct sd *sd = (struct sd *) gspca_dev;
 int i, j;
 u16 val = 0;
 static const u8 probe_tb[][4][8] = {
     {     /* mi0360 */
  {0xb0, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
  {0x90, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
  {0xa2, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
  {0xb0, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10}
     },
     {     /* mt9v111 */
  {0xb0, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10},
  {0x90, 0x5c, 0x36, 0x00, 0x00, 0x00, 0x00, 0x10},
  {0xa2, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
  {}
     },
 };

 for (i = 0; i < ARRAY_SIZE(probe_tb); i++) {
  reg_w1(gspca_dev, 0x17, 0x62);
  reg_w1(gspca_dev, 0x01, 0x08);
  for (j = 0; j < 3; j++)
   i2c_w8(gspca_dev, probe_tb[i][j]);
  msleep(2);
  reg_r(gspca_dev, 0x0a, 5);
  val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
  if (probe_tb[i][3][0] != 0)
   i2c_w8(gspca_dev, probe_tb[i][3]);
  reg_w1(gspca_dev, 0x01, 0x29);
  reg_w1(gspca_dev, 0x17, 0x42);
  if (val != 0xffff)
   break;
 }
 if (gspca_dev->usb_err < 0)
  return;
 switch (val) {
 case 0x8221:
  gspca_dbg(gspca_dev, D_PROBE, "Sensor mi0360b\n");
  sd->sensor = SENSOR_MI0360B;
  break;
 case 0x823a:
  gspca_dbg(gspca_dev, D_PROBE, "Sensor mt9v111\n");
  sd->sensor = SENSOR_MT9V111;
  break;
 case 0x8243:
  gspca_dbg(gspca_dev, D_PROBE, "Sensor mi0360\n");
  break;
 default:
  gspca_dbg(gspca_dev, D_PROBE, "Unknown sensor %04x - forced to mi0360\n",
     val);
  break;
 }
}

static void ov7630_probe(struct gspca_dev *gspca_dev)
{
 struct sd *sd = (struct sd *) gspca_dev;
 u16 val;

 /* check ov76xx */
 reg_w1(gspca_dev, 0x17, 0x62);
 reg_w1(gspca_dev, 0x01, 0x08);
 sd->i2c_addr = 0x21;
 i2c_r(gspca_dev, 0x0a, 2);
 val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
 reg_w1(gspca_dev, 0x01, 0x29);
 reg_w1(gspca_dev, 0x17, 0x42);
 if (gspca_dev->usb_err < 0)
  return;
 if (val == 0x7628) {   /* soi768 */
  sd->sensor = SENSOR_SOI768;
/*fixme: only valid for 0c45:613e?*/
  gspca_dev->cam.input_flags =
    V4L2_IN_ST_VFLIP | V4L2_IN_ST_HFLIP;
  gspca_dbg(gspca_dev, D_PROBE, "Sensor soi768\n");
  return;
 }
 gspca_dbg(gspca_dev, D_PROBE, "Sensor ov%04x\n", val);
}

static void ov7648_probe(struct gspca_dev *gspca_dev)
{
 struct sd *sd = (struct sd *) gspca_dev;
 u16 val;

 /* check ov76xx */
 reg_w1(gspca_dev, 0x17, 0x62);
 reg_w1(gspca_dev, 0x01, 0x08);
 sd->i2c_addr = 0x21;
 i2c_r(gspca_dev, 0x0a, 2);
 val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
 reg_w1(gspca_dev, 0x01, 0x29);
 reg_w1(gspca_dev, 0x17, 0x42);
 if ((val & 0xff00) == 0x7600) {  /* ov76xx */
  gspca_dbg(gspca_dev, D_PROBE, "Sensor ov%04x\n", val);
  return;
 }

 /* check po1030 */
 reg_w1(gspca_dev, 0x17, 0x62);
 reg_w1(gspca_dev, 0x01, 0x08);
 sd->i2c_addr = 0x6e;
 i2c_r(gspca_dev, 0x00, 2);
 val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
 reg_w1(gspca_dev, 0x01, 0x29);
 reg_w1(gspca_dev, 0x17, 0x42);
 if (gspca_dev->usb_err < 0)
  return;
 if (val == 0x1030) {   /* po1030 */
  gspca_dbg(gspca_dev, D_PROBE, "Sensor po1030\n");
  sd->sensor = SENSOR_PO1030;
  return;
 }
 pr_err("Unknown sensor %04x\n", val);
}

/* 0c45:6142 sensor may be po2030n, gc0305 or gc0307 */
static void po2030n_probe(struct gspca_dev *gspca_dev)
{
 struct sd *sd = (struct sd *) gspca_dev;
 u16 val;

 /* check gc0307 */
 reg_w1(gspca_dev, 0x17, 0x62);
 reg_w1(gspca_dev, 0x01, 0x08);
 reg_w1(gspca_dev, 0x02, 0x22);
 sd->i2c_addr = 0x21;
 i2c_r(gspca_dev, 0x00, 1);
 val = gspca_dev->usb_buf[4];
 reg_w1(gspca_dev, 0x01, 0x29);  /* reset */
 reg_w1(gspca_dev, 0x17, 0x42);
 if (val == 0x99) {   /* gc0307 (?) */
  gspca_dbg(gspca_dev, D_PROBE, "Sensor gc0307\n");
  sd->sensor = SENSOR_GC0307;
  return;
 }

 /* check po2030n */
 reg_w1(gspca_dev, 0x17, 0x62);
 reg_w1(gspca_dev, 0x01, 0x0a);
 sd->i2c_addr = 0x6e;
 i2c_r(gspca_dev, 0x00, 2);
 val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
 reg_w1(gspca_dev, 0x01, 0x29);
 reg_w1(gspca_dev, 0x17, 0x42);
 if (gspca_dev->usb_err < 0)
  return;
 if (val == 0x2030) {
  gspca_dbg(gspca_dev, D_PROBE, "Sensor po2030n\n");
/* sd->sensor = SENSOR_PO2030N; */
 } else {
  pr_err("Unknown sensor ID %04x\n", val);
 }
}

/* this function is called at probe time */
static int sd_config(struct gspca_dev *gspca_dev,
   const struct usb_device_id *id)
{
 struct sd *sd = (struct sd *) gspca_dev;
 struct cam *cam;

 sd->bridge = id->driver_info >> 16;
 sd->sensor = id->driver_info >> 8;
 sd->flags = id->driver_info;

 cam = &gspca_dev->cam;
 if (sd->sensor == SENSOR_ADCM1700) {
  cam->cam_mode = cif_mode;
  cam->nmodes = ARRAY_SIZE(cif_mode);
 } else {
  cam->cam_mode = vga_mode;
  cam->nmodes = ARRAY_SIZE(vga_mode);
 }
 cam->npkt = 24;   /* 24 packets per ISOC message */

 sd->ag_cnt = -1;
 sd->quality = QUALITY_DEF;

 INIT_WORK(&sd->work, qual_upd);

 return 0;
}

/* this function is called at probe and resume time */
static int sd_init(struct gspca_dev *gspca_dev)
{
 struct sd *sd = (struct sd *) gspca_dev;
 const u8 *sn9c1xx;
 u8 regGpio[] = { 0x29, 0x70 };  /* no audio */
 u8 regF1;

 /* setup a selector by bridge */
 reg_w1(gspca_dev, 0xf1, 0x01);
 reg_r(gspca_dev, 0x00, 1);
 reg_w1(gspca_dev, 0xf1, 0x00);
 reg_r(gspca_dev, 0x00, 1);  /* get sonix chip id */
 regF1 = gspca_dev->usb_buf[0];
 if (gspca_dev->usb_err < 0)
  return gspca_dev->usb_err;
 gspca_dbg(gspca_dev, D_PROBE, "Sonix chip id: %02x\n", regF1);
 if (gspca_dev->audio)
  regGpio[1] |= 0x04;  /* with audio */
 switch (sd->bridge) {
 case BRIDGE_SN9C102P:
 case BRIDGE_SN9C105:
  if (regF1 != 0x11)
   return -ENODEV;
  break;
 default:
/* case BRIDGE_SN9C110: */
/* case BRIDGE_SN9C120: */
  if (regF1 != 0x12)
   return -ENODEV;
 }

 switch (sd->sensor) {
 case SENSOR_MI0360:
  mi0360_probe(gspca_dev);
  break;
 case SENSOR_OV7630:
  ov7630_probe(gspca_dev);
  break;
 case SENSOR_OV7648:
  ov7648_probe(gspca_dev);
  break;
 case SENSOR_PO2030N:
  po2030n_probe(gspca_dev);
  break;
 }

 switch (sd->bridge) {
 case BRIDGE_SN9C102P:
  reg_w1(gspca_dev, 0x02, regGpio[1]);
  break;
 default:
  reg_w(gspca_dev, 0x01, regGpio, 2);
  break;
 }

 /* Note we do not disable the sensor clock here (power saving mode),
   as that also disables the button on the cam. */
 reg_w1(gspca_dev, 0xf1, 0x00);

 /* set the i2c address */
 sn9c1xx = sn_tb[sd->sensor];
 sd->i2c_addr = sn9c1xx[9];

 return gspca_dev->usb_err;
}

static int sd_s_ctrl(struct v4l2_ctrl *ctrl);

static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 .s_ctrl = sd_s_ctrl,
};

/* this function is called at probe time */
static int sd_init_controls(struct gspca_dev *gspca_dev)
{
 struct sd *sd = (struct sd *) gspca_dev;
 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;

 gspca_dev->vdev.ctrl_handler = hdl;
 v4l2_ctrl_handler_init(hdl, 14);

 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
#define CONTRAST_MAX 127
 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_CONTRAST, 0, CONTRAST_MAX, 1, 20);
#define COLORS_DEF 25
 sd->saturation = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_SATURATION, 0, 40, 1, COLORS_DEF);
 sd->red_bal = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_RED_BALANCE, 24, 40, 1, 32);
 sd->blue_bal = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_BLUE_BALANCE, 24, 40, 1, 32);
#define GAMMA_DEF 20
 sd->gamma = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_GAMMA, 0, 40, 1, GAMMA_DEF);

 if (sd->sensor == SENSOR_OM6802)
  sd->sharpness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_SHARPNESS, 0, 255, 1, 16);
 else
  sd->sharpness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_SHARPNESS, 0, 255, 1, 90);

 if (sd->flags & F_ILLUM)
  sd->illum = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_ILLUMINATORS_1, 0, 1, 1, 0);

 if (sd->sensor == SENSOR_PO2030N) {
  gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_EXPOSURE, 500, 1500, 1, 1024);
  gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_GAIN, 4, 49, 1, 15);
  sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_HFLIP, 0, 1, 1, 0);
 }

 if (sd->sensor != SENSOR_ADCM1700 && sd->sensor != SENSOR_OV7660 &&
     sd->sensor != SENSOR_PO1030 && sd->sensor != SENSOR_SOI768 &&
     sd->sensor != SENSOR_SP80708)
  gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_AUTOGAIN, 0, 1, 1, 1);

 if (sd->sensor == SENSOR_HV7131R || sd->sensor == SENSOR_OV7630 ||
     sd->sensor == SENSOR_OV7648 || sd->sensor == SENSOR_PO2030N)
  sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
   V4L2_CID_VFLIP, 0, 1, 1, 0);

 if (sd->sensor == SENSOR_OV7630 || sd->sensor == SENSOR_OV7648 ||
     sd->sensor == SENSOR_OV7660)
  sd->freq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
   V4L2_CID_POWER_LINE_FREQUENCY,
   V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0,
   V4L2_CID_POWER_LINE_FREQUENCY_50HZ);

 if (hdl->error) {
  pr_err("Could not initialize controls\n");
  return hdl->error;
 }

 v4l2_ctrl_cluster(2, &sd->red_bal);
 if (sd->sensor == SENSOR_PO2030N) {
  v4l2_ctrl_cluster(2, &sd->vflip);
  v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
 }

 return 0;
}

static u32 expo_adjust(struct gspca_dev *gspca_dev,
   u32 expo)
{
 struct sd *sd = (struct sd *) gspca_dev;

 switch (sd->sensor) {
 case SENSOR_GC0307: {
  int a, b;

  /* expo = 0..255 -> a = 19..43 */
  a = 19 + expo * 25 / 256;
  i2c_w1(gspca_dev, 0x68, a);
  a -= 12;
  b = a * a * 4;   /* heuristic */
  i2c_w1(gspca_dev, 0x03, b >> 8);
  i2c_w1(gspca_dev, 0x04, b);
  break;
     }
 case SENSOR_HV7131R: {
  u8 Expodoit[] =
   { 0xc1, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x16 };

  Expodoit[3] = expo >> 16;
  Expodoit[4] = expo >> 8;
  Expodoit[5] = expo;
  i2c_w8(gspca_dev, Expodoit);
  break;
     }
 case SENSOR_MI0360:
 case SENSOR_MI0360B: {
  u8 expoMi[] =  /* exposure 0x0635 -> 4 fp/s 0x10 */
   { 0xb1, 0x5d, 0x09, 0x00, 0x00, 0x00, 0x00, 0x16 };
  static const u8 doit[] =  /* update sensor */
   { 0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };
  static const u8 sensorgo[] =  /* sensor on */
   { 0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };

  if (expo > 0x0635)
   expo = 0x0635;
  else if (expo < 0x0001)
   expo = 0x0001;
  expoMi[3] = expo >> 8;
  expoMi[4] = expo;
  i2c_w8(gspca_dev, expoMi);
  i2c_w8(gspca_dev, doit);
  i2c_w8(gspca_dev, sensorgo);
  break;
     }
 case SENSOR_MO4000: {
  u8 expoMof[] =
   { 0xa1, 0x21, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x10 };
  u8 expoMo10[] =
   { 0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10 };
  static const u8 gainMo[] =
   { 0xa1, 0x21, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1d };

  if (expo > 0x1fff)
   expo = 0x1fff;
  else if (expo < 0x0001)
   expo = 0x0001;
  expoMof[3] = (expo & 0x03fc) >> 2;
  i2c_w8(gspca_dev, expoMof);
  expoMo10[3] = ((expo & 0x1c00) >> 10)
    | ((expo & 0x0003) << 4);
  i2c_w8(gspca_dev, expoMo10);
  i2c_w8(gspca_dev, gainMo);
  gspca_dbg(gspca_dev, D_FRAM, "set exposure %d\n",
     ((expoMo10[3] & 0x07) << 10)
     | (expoMof[3] << 2)
     | ((expoMo10[3] & 0x30) >> 4));
  break;
     }
 case SENSOR_MT9V111: {
  u8 expo_c1[] =
   { 0xb1, 0x5c, 0x09, 0x00, 0x00, 0x00, 0x00, 0x10 };

  if (expo > 0x0390)
   expo = 0x0390;
  else if (expo < 0x0060)
   expo = 0x0060;
  expo_c1[3] = expo >> 8;
  expo_c1[4] = expo;
  i2c_w8(gspca_dev, expo_c1);
  break;
     }
 case SENSOR_OM6802: {
  u8 gainOm[] =
   { 0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10 };
    /* preset AGC - works when AutoExpo = off */

  if (expo > 0x03ff)
   expo = 0x03ff;
  if (expo < 0x0001)
   expo = 0x0001;
  gainOm[3] = expo >> 2;
  i2c_w8(gspca_dev, gainOm);
  reg_w1(gspca_dev, 0x96, expo >> 5);
  gspca_dbg(gspca_dev, D_FRAM, "set exposure %d\n", gainOm[3]);
  break;
     }
 }
 return expo;
}

static void setbrightness(struct gspca_dev *gspca_dev)
{
 struct sd *sd = (struct sd *) gspca_dev;
 unsigned int expo;
 int brightness = sd->brightness->val;
 u8 k2;

 k2 = (brightness - 0x80) >> 2;
 switch (sd->sensor) {
 case SENSOR_ADCM1700:
  if (k2 > 0x1f)
   k2 = 0;  /* only positive Y offset */
  break;
 case SENSOR_HV7131R:
  expo = brightness << 12;
  if (expo > 0x002dc6c0)
   expo = 0x002dc6c0;
  else if (expo < 0x02a0)
   expo = 0x02a0;
  sd->exposure = expo_adjust(gspca_dev, expo);
  break;
 case SENSOR_MI0360:
 case SENSOR_MO4000:
  expo = brightness << 4;
  sd->exposure = expo_adjust(gspca_dev, expo);
  break;
 case SENSOR_MI0360B:
  expo = brightness << 2;
  sd->exposure = expo_adjust(gspca_dev, expo);
  break;
 case SENSOR_GC0307:
  expo = brightness;
  sd->exposure = expo_adjust(gspca_dev, expo);
  return;   /* don't set the Y offset */
 case SENSOR_MT9V111:
--> --------------------

--> maximum size reached

--> --------------------