drivers/media/usb/gspca/sq930x.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
reg_r
reg_w
reg_wb
i2c_write
ucbus_write
gpio_set
gpio_init
bridge_init
cmos_probe
mt9v111_init
global_init
lz24bp_ppl
setexposure
sd_config
sd_init
send_start
send_stop
sd_isoc_init
sd_start
sd_stopN
sd_dq_callback
sd_pkt_scan
sd_s_ctrl
sd_init_controls
sd_probe
   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * SQ930x subdriver
   4  *
   5  * Copyright (C) 2010 Jean-François Moine <http://moinejf.free.fr>
   6  * Copyright (C) 2006 -2008 Gerard Klaver <gerard at gkall dot hobby dot nl>
   7  * Copyright (C) 2007 Sam Revitch <samr7@cs.washington.edu>
   8  */
   9 
  10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11 
  12 #define MODULE_NAME "sq930x"
  13 
  14 #include "gspca.h"
  15 
  16 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>\n"
  17                 "Gerard Klaver <gerard at gkall dot hobby dot nl\n"
  18                 "Sam Revitch <samr7@cs.washington.edu>");
  19 MODULE_DESCRIPTION("GSPCA/SQ930x USB Camera Driver");
  20 MODULE_LICENSE("GPL");
  21 
  22 /* Structure to hold all of our device specific stuff */
  23 struct sd {
  24         struct gspca_dev gspca_dev;     /* !! must be the first item */
  25 
  26         struct { /* exposure/gain control cluster */
  27                 struct v4l2_ctrl *exposure;
  28                 struct v4l2_ctrl *gain;
  29         };
  30 
  31         u8 do_ctrl;
  32         u8 gpio[2];
  33         u8 sensor;
  34         u8 type;
  35 #define Generic 0
  36 #define Creative_live_motion 1
  37 };
  38 enum sensors {
  39         SENSOR_ICX098BQ,
  40         SENSOR_LZ24BP,
  41         SENSOR_MI0360,
  42         SENSOR_MT9V111,         /* = MI360SOC */
  43         SENSOR_OV7660,
  44         SENSOR_OV9630,
  45 };
  46 
  47 static struct v4l2_pix_format vga_mode[] = {
  48         {320, 240, V4L2_PIX_FMT_SRGGB8, V4L2_FIELD_NONE,
  49                 .bytesperline = 320,
  50                 .sizeimage = 320 * 240,
  51                 .colorspace = V4L2_COLORSPACE_SRGB,
  52                 .priv = 0},
  53         {640, 480, V4L2_PIX_FMT_SRGGB8, V4L2_FIELD_NONE,
  54                 .bytesperline = 640,
  55                 .sizeimage = 640 * 480,
  56                 .colorspace = V4L2_COLORSPACE_SRGB,
  57                 .priv = 1},
  58 };
  59 
  60 /* sq930x registers */
  61 #define SQ930_CTRL_UCBUS_IO     0x0001
  62 #define SQ930_CTRL_I2C_IO       0x0002
  63 #define SQ930_CTRL_GPIO         0x0005
  64 #define SQ930_CTRL_CAP_START    0x0010
  65 #define SQ930_CTRL_CAP_STOP     0x0011
  66 #define SQ930_CTRL_SET_EXPOSURE 0x001d
  67 #define SQ930_CTRL_RESET        0x001e
  68 #define SQ930_CTRL_GET_DEV_INFO 0x001f
  69 
  70 /* gpio 1 (8..15) */
  71 #define SQ930_GPIO_DFL_I2C_SDA  0x0001
  72 #define SQ930_GPIO_DFL_I2C_SCL  0x0002
  73 #define SQ930_GPIO_RSTBAR       0x0004
  74 #define SQ930_GPIO_EXTRA1       0x0040
  75 #define SQ930_GPIO_EXTRA2       0x0080
  76 /* gpio 3 (24..31) */
  77 #define SQ930_GPIO_POWER        0x0200
  78 #define SQ930_GPIO_DFL_LED      0x1000
  79 
  80 struct ucbus_write_cmd {
  81         u16     bw_addr;
  82         u8      bw_data;
  83 };
  84 struct i2c_write_cmd {
  85         u8      reg;
  86         u16     val;
  87 };
  88 
  89 static const struct ucbus_write_cmd icx098bq_start_0[] = {
  90         {0x0354, 0x00}, {0x03fa, 0x00}, {0xf800, 0x02}, {0xf801, 0xce},
  91         {0xf802, 0xc1}, {0xf804, 0x00}, {0xf808, 0x00}, {0xf809, 0x0e},
  92         {0xf80a, 0x01}, {0xf80b, 0xee}, {0xf807, 0x60}, {0xf80c, 0x02},
  93         {0xf80d, 0xf0}, {0xf80e, 0x03}, {0xf80f, 0x0a}, {0xf81c, 0x02},
  94         {0xf81d, 0xf0}, {0xf81e, 0x03}, {0xf81f, 0x0a}, {0xf83a, 0x00},
  95         {0xf83b, 0x10}, {0xf83c, 0x00}, {0xf83d, 0x4e}, {0xf810, 0x04},
  96         {0xf811, 0x00}, {0xf812, 0x02}, {0xf813, 0x10}, {0xf803, 0x00},
  97         {0xf814, 0x01}, {0xf815, 0x18}, {0xf816, 0x00}, {0xf817, 0x48},
  98         {0xf818, 0x00}, {0xf819, 0x25}, {0xf81a, 0x00}, {0xf81b, 0x3c},
  99         {0xf82f, 0x03}, {0xf820, 0xff}, {0xf821, 0x0d}, {0xf822, 0xff},
 100         {0xf823, 0x07}, {0xf824, 0xff}, {0xf825, 0x03}, {0xf826, 0xff},
 101         {0xf827, 0x06}, {0xf828, 0xff}, {0xf829, 0x03}, {0xf82a, 0xff},
 102         {0xf82b, 0x0c}, {0xf82c, 0xfd}, {0xf82d, 0x01}, {0xf82e, 0x00},
 103         {0xf830, 0x00}, {0xf831, 0x47}, {0xf832, 0x00}, {0xf833, 0x00},
 104         {0xf850, 0x00}, {0xf851, 0x00}, {0xf852, 0x00}, {0xf853, 0x24},
 105         {0xf854, 0x00}, {0xf855, 0x18}, {0xf856, 0x00}, {0xf857, 0x3c},
 106         {0xf858, 0x00}, {0xf859, 0x0c}, {0xf85a, 0x00}, {0xf85b, 0x30},
 107         {0xf85c, 0x00}, {0xf85d, 0x0c}, {0xf85e, 0x00}, {0xf85f, 0x30},
 108         {0xf860, 0x00}, {0xf861, 0x48}, {0xf862, 0x01}, {0xf863, 0xdc},
 109         {0xf864, 0xff}, {0xf865, 0x98}, {0xf866, 0xff}, {0xf867, 0xc0},
 110         {0xf868, 0xff}, {0xf869, 0x70}, {0xf86c, 0xff}, {0xf86d, 0x00},
 111         {0xf86a, 0xff}, {0xf86b, 0x48}, {0xf86e, 0xff}, {0xf86f, 0x00},
 112         {0xf870, 0x01}, {0xf871, 0xdb}, {0xf872, 0x01}, {0xf873, 0xfa},
 113         {0xf874, 0x01}, {0xf875, 0xdb}, {0xf876, 0x01}, {0xf877, 0xfa},
 114         {0xf878, 0x0f}, {0xf879, 0x0f}, {0xf87a, 0xff}, {0xf87b, 0xff},
 115         {0xf800, 0x03}
 116 };
 117 static const struct ucbus_write_cmd icx098bq_start_1[] = {
 118         {0xf5f0, 0x00}, {0xf5f1, 0xcd}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
 119         {0xf5f4, 0xc0},
 120         {0xf5f0, 0x49}, {0xf5f1, 0xcd}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
 121         {0xf5f4, 0xc0},
 122         {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
 123         {0xf5f9, 0x00}
 124 };
 125 
 126 static const struct ucbus_write_cmd icx098bq_start_2[] = {
 127         {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x82}, {0xf806, 0x00},
 128         {0xf807, 0x7f}, {0xf800, 0x03},
 129         {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x40}, {0xf806, 0x00},
 130         {0xf807, 0x7f}, {0xf800, 0x03},
 131         {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0xcf}, {0xf806, 0xd0},
 132         {0xf807, 0x7f}, {0xf800, 0x03},
 133         {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x00}, {0xf806, 0x00},
 134         {0xf807, 0x7f}, {0xf800, 0x03}
 135 };
 136 
 137 static const struct ucbus_write_cmd lz24bp_start_0[] = {
 138         {0x0354, 0x00}, {0x03fa, 0x00}, {0xf800, 0x02}, {0xf801, 0xbe},
 139         {0xf802, 0xc6}, {0xf804, 0x00}, {0xf808, 0x00}, {0xf809, 0x06},
 140         {0xf80a, 0x01}, {0xf80b, 0xfe}, {0xf807, 0x84}, {0xf80c, 0x02},
 141         {0xf80d, 0xf7}, {0xf80e, 0x03}, {0xf80f, 0x0b}, {0xf81c, 0x00},
 142         {0xf81d, 0x49}, {0xf81e, 0x03}, {0xf81f, 0x0b}, {0xf83a, 0x00},
 143         {0xf83b, 0x01}, {0xf83c, 0x00}, {0xf83d, 0x6b}, {0xf810, 0x03},
 144         {0xf811, 0x10}, {0xf812, 0x02}, {0xf813, 0x6f}, {0xf803, 0x00},
 145         {0xf814, 0x00}, {0xf815, 0x44}, {0xf816, 0x00}, {0xf817, 0x48},
 146         {0xf818, 0x00}, {0xf819, 0x25}, {0xf81a, 0x00}, {0xf81b, 0x3c},
 147         {0xf82f, 0x03}, {0xf820, 0xff}, {0xf821, 0x0d}, {0xf822, 0xff},
 148         {0xf823, 0x07}, {0xf824, 0xfd}, {0xf825, 0x07}, {0xf826, 0xf0},
 149         {0xf827, 0x0c}, {0xf828, 0xff}, {0xf829, 0x03}, {0xf82a, 0xff},
 150         {0xf82b, 0x0c}, {0xf82c, 0xfc}, {0xf82d, 0x01}, {0xf82e, 0x00},
 151         {0xf830, 0x00}, {0xf831, 0x47}, {0xf832, 0x00}, {0xf833, 0x00},
 152         {0xf850, 0x00}, {0xf851, 0x00}, {0xf852, 0x00}, {0xf853, 0x24},
 153         {0xf854, 0x00}, {0xf855, 0x0c}, {0xf856, 0x00}, {0xf857, 0x30},
 154         {0xf858, 0x00}, {0xf859, 0x18}, {0xf85a, 0x00}, {0xf85b, 0x3c},
 155         {0xf85c, 0x00}, {0xf85d, 0x18}, {0xf85e, 0x00}, {0xf85f, 0x3c},
 156         {0xf860, 0xff}, {0xf861, 0x37}, {0xf862, 0xff}, {0xf863, 0x1d},
 157         {0xf864, 0xff}, {0xf865, 0x98}, {0xf866, 0xff}, {0xf867, 0xc0},
 158         {0xf868, 0x00}, {0xf869, 0x37}, {0xf86c, 0x02}, {0xf86d, 0x1d},
 159         {0xf86a, 0x00}, {0xf86b, 0x37}, {0xf86e, 0x02}, {0xf86f, 0x1d},
 160         {0xf870, 0x01}, {0xf871, 0xc6}, {0xf872, 0x02}, {0xf873, 0x04},
 161         {0xf874, 0x01}, {0xf875, 0xc6}, {0xf876, 0x02}, {0xf877, 0x04},
 162         {0xf878, 0x0f}, {0xf879, 0x0f}, {0xf87a, 0xff}, {0xf87b, 0xff},
 163         {0xf800, 0x03}
 164 };
 165 static const struct ucbus_write_cmd lz24bp_start_1_gen[] = {
 166         {0xf5f0, 0x00}, {0xf5f1, 0xff}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
 167         {0xf5f4, 0xb3},
 168         {0xf5f0, 0x40}, {0xf5f1, 0xff}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
 169         {0xf5f4, 0xb3},
 170         {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
 171         {0xf5f9, 0x00}
 172 };
 173 
 174 static const struct ucbus_write_cmd lz24bp_start_1_clm[] = {
 175         {0xf5f0, 0x00}, {0xf5f1, 0xff}, {0xf5f2, 0x88}, {0xf5f3, 0x88},
 176         {0xf5f4, 0xc0},
 177         {0xf5f0, 0x40}, {0xf5f1, 0xff}, {0xf5f2, 0x88}, {0xf5f3, 0x88},
 178         {0xf5f4, 0xc0},
 179         {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
 180         {0xf5f9, 0x00}
 181 };
 182 
 183 static const struct ucbus_write_cmd lz24bp_start_2[] = {
 184         {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x80}, {0xf806, 0x00},
 185         {0xf807, 0x7f}, {0xf800, 0x03},
 186         {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x4e}, {0xf806, 0x00},
 187         {0xf807, 0x7f}, {0xf800, 0x03},
 188         {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0xc0}, {0xf806, 0x48},
 189         {0xf807, 0x7f}, {0xf800, 0x03},
 190         {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x00}, {0xf806, 0x00},
 191         {0xf807, 0x7f}, {0xf800, 0x03}
 192 };
 193 
 194 static const struct ucbus_write_cmd mi0360_start_0[] = {
 195         {0x0354, 0x00}, {0x03fa, 0x00}, {0xf332, 0xcc}, {0xf333, 0xcc},
 196         {0xf334, 0xcc}, {0xf335, 0xcc}, {0xf33f, 0x00}
 197 };
 198 static const struct i2c_write_cmd mi0360_init_23[] = {
 199         {0x30, 0x0040},         /* reserved - def 0x0005 */
 200         {0x31, 0x0000},         /* reserved - def 0x002a */
 201         {0x34, 0x0100},         /* reserved - def 0x0100 */
 202         {0x3d, 0x068f},         /* reserved - def 0x068f */
 203 };
 204 static const struct i2c_write_cmd mi0360_init_24[] = {
 205         {0x03, 0x01e5},         /* window height */
 206         {0x04, 0x0285},         /* window width */
 207 };
 208 static const struct i2c_write_cmd mi0360_init_25[] = {
 209         {0x35, 0x0020},         /* global gain */
 210         {0x2b, 0x0020},         /* green1 gain */
 211         {0x2c, 0x002a},         /* blue gain */
 212         {0x2d, 0x0028},         /* red gain */
 213         {0x2e, 0x0020},         /* green2 gain */
 214 };
 215 static const struct ucbus_write_cmd mi0360_start_1[] = {
 216         {0xf5f0, 0x11}, {0xf5f1, 0x99}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
 217         {0xf5f4, 0xa6},
 218         {0xf5f0, 0x51}, {0xf5f1, 0x99}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
 219         {0xf5f4, 0xa6},
 220         {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
 221         {0xf5f9, 0x00}
 222 };
 223 static const struct i2c_write_cmd mi0360_start_2[] = {
 224         {0x62, 0x041d},         /* reserved - def 0x0418 */
 225 };
 226 static const struct i2c_write_cmd mi0360_start_3[] = {
 227         {0x05, 0x007b},         /* horiz blanking */
 228 };
 229 static const struct i2c_write_cmd mi0360_start_4[] = {
 230         {0x05, 0x03f5},         /* horiz blanking */
 231 };
 232 
 233 static const struct i2c_write_cmd mt9v111_init_0[] = {
 234         {0x01, 0x0001},         /* select IFP/SOC registers */
 235         {0x06, 0x300c},         /* operating mode control */
 236         {0x08, 0xcc00},         /* output format control (RGB) */
 237         {0x01, 0x0004},         /* select sensor core registers */
 238 };
 239 static const struct i2c_write_cmd mt9v111_init_1[] = {
 240         {0x03, 0x01e5},         /* window height */
 241         {0x04, 0x0285},         /* window width */
 242 };
 243 static const struct i2c_write_cmd mt9v111_init_2[] = {
 244         {0x30, 0x7800},
 245         {0x31, 0x0000},
 246         {0x07, 0x3002},         /* output control */
 247         {0x35, 0x0020},         /* global gain */
 248         {0x2b, 0x0020},         /* green1 gain */
 249         {0x2c, 0x0020},         /* blue gain */
 250         {0x2d, 0x0020},         /* red gain */
 251         {0x2e, 0x0020},         /* green2 gain */
 252 };
 253 static const struct ucbus_write_cmd mt9v111_start_1[] = {
 254         {0xf5f0, 0x11}, {0xf5f1, 0x96}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
 255         {0xf5f4, 0xaa},
 256         {0xf5f0, 0x51}, {0xf5f1, 0x96}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
 257         {0xf5f4, 0xaa},
 258         {0xf5fa, 0x00}, {0xf5f6, 0x0a}, {0xf5f7, 0x0a}, {0xf5f8, 0x0a},
 259         {0xf5f9, 0x0a}
 260 };
 261 static const struct i2c_write_cmd mt9v111_init_3[] = {
 262         {0x62, 0x0405},
 263 };
 264 static const struct i2c_write_cmd mt9v111_init_4[] = {
 265 /*      {0x05, 0x00ce}, */
 266         {0x05, 0x005d},         /* horizontal blanking */
 267 };
 268 
 269 static const struct ucbus_write_cmd ov7660_start_0[] = {
 270         {0x0354, 0x00}, {0x03fa, 0x00}, {0xf332, 0x00}, {0xf333, 0xc0},
 271         {0xf334, 0x39}, {0xf335, 0xe7}, {0xf33f, 0x03}
 272 };
 273 
 274 static const struct ucbus_write_cmd ov9630_start_0[] = {
 275         {0x0354, 0x00}, {0x03fa, 0x00}, {0xf332, 0x00}, {0xf333, 0x00},
 276         {0xf334, 0x3e}, {0xf335, 0xf8}, {0xf33f, 0x03}
 277 };
 278 
 279 /* start parameters indexed by [sensor][mode] */
 280 static const struct cap_s {
 281         u8      cc_sizeid;
 282         u8      cc_bytes[32];
 283 } capconfig[4][2] = {
 284         [SENSOR_ICX098BQ] = {
 285                 {2,                             /* Bayer 320x240 */
 286                   {0x05, 0x1f, 0x20, 0x0e, 0x00, 0x9f, 0x02, 0xee,
 287                    0x01, 0x01, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
 288                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0,
 289                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} },
 290                 {4,                             /* Bayer 640x480 */
 291                   {0x01, 0x1f, 0x20, 0x0e, 0x00, 0x9f, 0x02, 0xee,
 292                    0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
 293                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 294                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} },
 295         },
 296         [SENSOR_LZ24BP] = {
 297                 {2,                             /* Bayer 320x240 */
 298                   {0x05, 0x22, 0x20, 0x0e, 0x00, 0xa2, 0x02, 0xee,
 299                    0x01, 0x01, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
 300                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 301                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} },
 302                 {4,                             /* Bayer 640x480 */
 303                   {0x01, 0x22, 0x20, 0x0e, 0x00, 0xa2, 0x02, 0xee,
 304                    0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
 305                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 306                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} },
 307         },
 308         [SENSOR_MI0360] = {
 309                 {2,                             /* Bayer 320x240 */
 310                   {0x05, 0x02, 0x20, 0x01, 0x20, 0x82, 0x02, 0xe1,
 311                    0x01, 0x01, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
 312                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 313                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} },
 314                 {4,                             /* Bayer 640x480 */
 315                   {0x01, 0x02, 0x20, 0x01, 0x20, 0x82, 0x02, 0xe1,
 316                    0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
 317                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 318                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} },
 319         },
 320         [SENSOR_MT9V111] = {
 321                 {2,                             /* Bayer 320x240 */
 322                   {0x05, 0x02, 0x20, 0x01, 0x20, 0x82, 0x02, 0xe1,
 323                    0x01, 0x01, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
 324                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 325                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} },
 326                 {4,                             /* Bayer 640x480 */
 327                   {0x01, 0x02, 0x20, 0x01, 0x20, 0x82, 0x02, 0xe1,
 328                    0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
 329                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 330                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} },
 331         },
 332 };
 333 
 334 struct sensor_s {
 335         const char *name;
 336         u8 i2c_addr;
 337         u8 i2c_dum;
 338         u8 gpio[5];
 339         u8 cmd_len;
 340         const struct ucbus_write_cmd *cmd;
 341 };
 342 
 343 static const struct sensor_s sensor_tb[] = {
 344         [SENSOR_ICX098BQ] = {
 345                 "icx098bp",
 346                 0x00, 0x00,
 347                 {0,
 348                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
 349                  SQ930_GPIO_DFL_I2C_SDA,
 350                  0,
 351                  SQ930_GPIO_RSTBAR
 352                 },
 353                 8, icx098bq_start_0
 354             },
 355         [SENSOR_LZ24BP] = {
 356                 "lz24bp",
 357                 0x00, 0x00,
 358                 {0,
 359                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
 360                  SQ930_GPIO_DFL_I2C_SDA,
 361                  0,
 362                  SQ930_GPIO_RSTBAR
 363                 },
 364                 8, lz24bp_start_0
 365             },
 366         [SENSOR_MI0360] = {
 367                 "mi0360",
 368                 0x5d, 0x80,
 369                 {SQ930_GPIO_RSTBAR,
 370                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
 371                  SQ930_GPIO_DFL_I2C_SDA,
 372                  0,
 373                  0
 374                 },
 375                 7, mi0360_start_0
 376             },
 377         [SENSOR_MT9V111] = {
 378                 "mt9v111",
 379                 0x5c, 0x7f,
 380                 {SQ930_GPIO_RSTBAR,
 381                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
 382                  SQ930_GPIO_DFL_I2C_SDA,
 383                  0,
 384                  0
 385                 },
 386                 7, mi0360_start_0
 387             },
 388         [SENSOR_OV7660] = {
 389                 "ov7660",
 390                 0x21, 0x00,
 391                 {0,
 392                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
 393                  SQ930_GPIO_DFL_I2C_SDA,
 394                  0,
 395                  SQ930_GPIO_RSTBAR
 396                 },
 397                 7, ov7660_start_0
 398             },
 399         [SENSOR_OV9630] = {
 400                 "ov9630",
 401                 0x30, 0x00,
 402                 {0,
 403                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
 404                  SQ930_GPIO_DFL_I2C_SDA,
 405                  0,
 406                  SQ930_GPIO_RSTBAR
 407                 },
 408                 7, ov9630_start_0
 409             },
 410 };
 411 
 412 static void reg_r(struct gspca_dev *gspca_dev,
 413                 u16 value, int len)
 414 {
 415         int ret;
 416 
 417         if (gspca_dev->usb_err < 0)
 418                 return;
 419         ret = usb_control_msg(gspca_dev->dev,
 420                         usb_rcvctrlpipe(gspca_dev->dev, 0),
 421                         0x0c,
 422                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 423                         value, 0, gspca_dev->usb_buf, len,
 424                         500);
 425         if (ret < 0) {
 426                 pr_err("reg_r %04x failed %d\n", value, ret);
 427                 gspca_dev->usb_err = ret;
 428                 /*
 429                  * Make sure the buffer is zeroed to avoid uninitialized
 430                  * values.
 431                  */
 432                 memset(gspca_dev->usb_buf, 0, USB_BUF_SZ);
 433         }
 434 }
 435 
 436 static void reg_w(struct gspca_dev *gspca_dev, u16 value, u16 index)
 437 {
 438         int ret;
 439 
 440         if (gspca_dev->usb_err < 0)
 441                 return;
 442         gspca_dbg(gspca_dev, D_USBO, "reg_w v: %04x i: %04x\n", value, index);
 443         ret = usb_control_msg(gspca_dev->dev,
 444                         usb_sndctrlpipe(gspca_dev->dev, 0),
 445                         0x0c,                   /* request */
 446                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 447                         value, index, NULL, 0,
 448                         500);
 449         msleep(30);
 450         if (ret < 0) {
 451                 pr_err("reg_w %04x %04x failed %d\n", value, index, ret);
 452                 gspca_dev->usb_err = ret;
 453         }
 454 }
 455 
 456 static void reg_wb(struct gspca_dev *gspca_dev, u16 value, u16 index,
 457                 const u8 *data, int len)
 458 {
 459         int ret;
 460 
 461         if (gspca_dev->usb_err < 0)
 462                 return;
 463         gspca_dbg(gspca_dev, D_USBO, "reg_wb v: %04x i: %04x %02x...%02x\n",
 464                   value, index, *data, data[len - 1]);
 465         memcpy(gspca_dev->usb_buf, data, len);
 466         ret = usb_control_msg(gspca_dev->dev,
 467                         usb_sndctrlpipe(gspca_dev->dev, 0),
 468                         0x0c,                   /* request */
 469                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 470                         value, index, gspca_dev->usb_buf, len,
 471                         1000);
 472         msleep(30);
 473         if (ret < 0) {
 474                 pr_err("reg_wb %04x %04x failed %d\n", value, index, ret);
 475                 gspca_dev->usb_err = ret;
 476         }
 477 }
 478 
 479 static void i2c_write(struct sd *sd,
 480                         const struct i2c_write_cmd *cmd,
 481                         int ncmds)
 482 {
 483         struct gspca_dev *gspca_dev = &sd->gspca_dev;
 484         const struct sensor_s *sensor;
 485         u16 val, idx;
 486         u8 *buf;
 487         int ret;
 488 
 489         if (gspca_dev->usb_err < 0)
 490                 return;
 491 
 492         sensor = &sensor_tb[sd->sensor];
 493 
 494         val = (sensor->i2c_addr << 8) | SQ930_CTRL_I2C_IO;
 495         idx = (cmd->val & 0xff00) | cmd->reg;
 496 
 497         buf = gspca_dev->usb_buf;
 498         *buf++ = sensor->i2c_dum;
 499         *buf++ = cmd->val;
 500 
 501         while (--ncmds > 0) {
 502                 cmd++;
 503                 *buf++ = cmd->reg;
 504                 *buf++ = cmd->val >> 8;
 505                 *buf++ = sensor->i2c_dum;
 506                 *buf++ = cmd->val;
 507         }
 508 
 509         gspca_dbg(gspca_dev, D_USBO, "i2c_w v: %04x i: %04x %02x...%02x\n",
 510                   val, idx, gspca_dev->usb_buf[0], buf[-1]);
 511         ret = usb_control_msg(gspca_dev->dev,
 512                         usb_sndctrlpipe(gspca_dev->dev, 0),
 513                         0x0c,                   /* request */
 514                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 515                         val, idx,
 516                         gspca_dev->usb_buf, buf - gspca_dev->usb_buf,
 517                         500);
 518         if (ret < 0) {
 519                 pr_err("i2c_write failed %d\n", ret);
 520                 gspca_dev->usb_err = ret;
 521         }
 522 }
 523 
 524 static void ucbus_write(struct gspca_dev *gspca_dev,
 525                         const struct ucbus_write_cmd *cmd,
 526                         int ncmds,
 527                         int batchsize)
 528 {
 529         u8 *buf;
 530         u16 val, idx;
 531         int len, ret;
 532 
 533         if (gspca_dev->usb_err < 0)
 534                 return;
 535 
 536         if ((batchsize - 1) * 3 > USB_BUF_SZ) {
 537                 gspca_err(gspca_dev, "Bug: usb_buf overflow\n");
 538                 gspca_dev->usb_err = -ENOMEM;
 539                 return;
 540         }
 541 
 542         for (;;) {
 543                 len = ncmds;
 544                 if (len > batchsize)
 545                         len = batchsize;
 546                 ncmds -= len;
 547 
 548                 val = (cmd->bw_addr << 8) | SQ930_CTRL_UCBUS_IO;
 549                 idx = (cmd->bw_data << 8) | (cmd->bw_addr >> 8);
 550 
 551                 buf = gspca_dev->usb_buf;
 552                 while (--len > 0) {
 553                         cmd++;
 554                         *buf++ = cmd->bw_addr;
 555                         *buf++ = cmd->bw_addr >> 8;
 556                         *buf++ = cmd->bw_data;
 557                 }
 558                 if (buf != gspca_dev->usb_buf)
 559                         gspca_dbg(gspca_dev, D_USBO, "ucbus v: %04x i: %04x %02x...%02x\n",
 560                                   val, idx,
 561                                   gspca_dev->usb_buf[0], buf[-1]);
 562                 else
 563                         gspca_dbg(gspca_dev, D_USBO, "ucbus v: %04x i: %04x\n",
 564                                   val, idx);
 565                 ret = usb_control_msg(gspca_dev->dev,
 566                                 usb_sndctrlpipe(gspca_dev->dev, 0),
 567                                 0x0c,                   /* request */
 568                            USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 569                                 val, idx,
 570                                 gspca_dev->usb_buf, buf - gspca_dev->usb_buf,
 571                                 500);
 572                 if (ret < 0) {
 573                         pr_err("ucbus_write failed %d\n", ret);
 574                         gspca_dev->usb_err = ret;
 575                         return;
 576                 }
 577                 msleep(30);
 578                 if (ncmds <= 0)
 579                         break;
 580                 cmd++;
 581         }
 582 }
 583 
 584 static void gpio_set(struct sd *sd, u16 val, u16 mask)
 585 {
 586         struct gspca_dev *gspca_dev = &sd->gspca_dev;
 587 
 588         if (mask & 0x00ff) {
 589                 sd->gpio[0] &= ~mask;
 590                 sd->gpio[0] |= val;
 591                 reg_w(gspca_dev, 0x0100 | SQ930_CTRL_GPIO,
 592                         ~sd->gpio[0] << 8);
 593         }
 594         mask >>= 8;
 595         val >>= 8;
 596         if (mask) {
 597                 sd->gpio[1] &= ~mask;
 598                 sd->gpio[1] |= val;
 599                 reg_w(gspca_dev, 0x0300 | SQ930_CTRL_GPIO,
 600                         ~sd->gpio[1] << 8);
 601         }
 602 }
 603 
 604 static void gpio_init(struct sd *sd,
 605                         const u8 *gpio)
 606 {
 607         gpio_set(sd, *gpio++, 0x000f);
 608         gpio_set(sd, *gpio++, 0x000f);
 609         gpio_set(sd, *gpio++, 0x000f);
 610         gpio_set(sd, *gpio++, 0x000f);
 611         gpio_set(sd, *gpio, 0x000f);
 612 }
 613 
 614 static void bridge_init(struct sd *sd)
 615 {
 616         static const struct ucbus_write_cmd clkfreq_cmd = {
 617                                 0xf031, 0       /* SQ930_CLKFREQ_60MHZ */
 618         };
 619 
 620         ucbus_write(&sd->gspca_dev, &clkfreq_cmd, 1, 1);
 621 
 622         gpio_set(sd, SQ930_GPIO_POWER, 0xff00);
 623 }
 624 
 625 static void cmos_probe(struct gspca_dev *gspca_dev)
 626 {
 627         struct sd *sd = (struct sd *) gspca_dev;
 628         int i;
 629         const struct sensor_s *sensor;
 630         static const u8 probe_order[] = {
 631 /*              SENSOR_LZ24BP,          (tested as ccd) */
 632                 SENSOR_OV9630,
 633                 SENSOR_MI0360,
 634                 SENSOR_OV7660,
 635                 SENSOR_MT9V111,
 636         };
 637 
 638         for (i = 0; i < ARRAY_SIZE(probe_order); i++) {
 639                 sensor = &sensor_tb[probe_order[i]];
 640                 ucbus_write(&sd->gspca_dev, sensor->cmd, sensor->cmd_len, 8);
 641                 gpio_init(sd, sensor->gpio);
 642                 msleep(100);
 643                 reg_r(gspca_dev, (sensor->i2c_addr << 8) | 0x001c, 1);
 644                 msleep(100);
 645                 if (gspca_dev->usb_buf[0] != 0)
 646                         break;
 647         }
 648         if (i >= ARRAY_SIZE(probe_order)) {
 649                 pr_err("Unknown sensor\n");
 650                 gspca_dev->usb_err = -EINVAL;
 651                 return;
 652         }
 653         sd->sensor = probe_order[i];
 654         switch (sd->sensor) {
 655         case SENSOR_OV7660:
 656         case SENSOR_OV9630:
 657                 pr_err("Sensor %s not yet treated\n",
 658                        sensor_tb[sd->sensor].name);
 659                 gspca_dev->usb_err = -EINVAL;
 660                 break;
 661         }
 662 }
 663 
 664 static void mt9v111_init(struct gspca_dev *gspca_dev)
 665 {
 666         int i, nwait;
 667         static const u8 cmd_001b[] = {
 668                 0x00, 0x3b, 0xf6, 0x01, 0x03, 0x02, 0x00, 0x00,
 669                 0x00, 0x00, 0x00
 670         };
 671         static const u8 cmd_011b[][7] = {
 672                 {0x10, 0x01, 0x66, 0x08, 0x00, 0x00, 0x00},
 673                 {0x01, 0x00, 0x1a, 0x04, 0x00, 0x00, 0x00},
 674                 {0x20, 0x00, 0x10, 0x04, 0x00, 0x00, 0x00},
 675                 {0x02, 0x01, 0xae, 0x01, 0x00, 0x00, 0x00},
 676         };
 677 
 678         reg_wb(gspca_dev, 0x001b, 0x0000, cmd_001b, sizeof cmd_001b);
 679         for (i = 0; i < ARRAY_SIZE(cmd_011b); i++) {
 680                 reg_wb(gspca_dev, 0x001b, 0x0000, cmd_011b[i],
 681                                 ARRAY_SIZE(cmd_011b[0]));
 682                 msleep(400);
 683                 nwait = 20;
 684                 for (;;) {
 685                         reg_r(gspca_dev, 0x031b, 1);
 686                         if (gspca_dev->usb_buf[0] == 0
 687                          || gspca_dev->usb_err != 0)
 688                                 break;
 689                         if (--nwait < 0) {
 690                                 gspca_dbg(gspca_dev, D_PROBE, "mt9v111_init timeout\n");
 691                                 gspca_dev->usb_err = -ETIME;
 692                                 return;
 693                         }
 694                         msleep(50);
 695                 }
 696         }
 697 }
 698 
 699 static void global_init(struct sd *sd, int first_time)
 700 {
 701         switch (sd->sensor) {
 702         case SENSOR_ICX098BQ:
 703                 if (first_time)
 704                         ucbus_write(&sd->gspca_dev,
 705                                         icx098bq_start_0,
 706                                         8, 8);
 707                 gpio_init(sd, sensor_tb[sd->sensor].gpio);
 708                 break;
 709         case SENSOR_LZ24BP:
 710                 if (sd->type != Creative_live_motion)
 711                         gpio_set(sd, SQ930_GPIO_EXTRA1, 0x00ff);
 712                 else
 713                         gpio_set(sd, 0, 0x00ff);
 714                 msleep(50);
 715                 if (first_time)
 716                         ucbus_write(&sd->gspca_dev,
 717                                         lz24bp_start_0,
 718                                         8, 8);
 719                 gpio_init(sd, sensor_tb[sd->sensor].gpio);
 720                 break;
 721         case SENSOR_MI0360:
 722                 if (first_time)
 723                         ucbus_write(&sd->gspca_dev,
 724                                         mi0360_start_0,
 725                                         ARRAY_SIZE(mi0360_start_0),
 726                                         8);
 727                 gpio_init(sd, sensor_tb[sd->sensor].gpio);
 728                 gpio_set(sd, SQ930_GPIO_EXTRA2, SQ930_GPIO_EXTRA2);
 729                 break;
 730         default:
 731 /*      case SENSOR_MT9V111: */
 732                 if (first_time)
 733                         mt9v111_init(&sd->gspca_dev);
 734                 else
 735                         gpio_init(sd, sensor_tb[sd->sensor].gpio);
 736                 break;
 737         }
 738 }
 739 
 740 static void lz24bp_ppl(struct sd *sd, u16 ppl)
 741 {
 742         struct ucbus_write_cmd cmds[2] = {
 743                 {0xf810, ppl >> 8},
 744                 {0xf811, ppl}
 745         };
 746 
 747         ucbus_write(&sd->gspca_dev, cmds, ARRAY_SIZE(cmds), 2);
 748 }
 749 
 750 static void setexposure(struct gspca_dev *gspca_dev, s32 expo, s32 gain)
 751 {
 752         struct sd *sd = (struct sd *) gspca_dev;
 753         int i, integclks, intstartclk, frameclks, min_frclk;
 754         const struct sensor_s *sensor;
 755         u16 cmd;
 756         u8 buf[15];
 757 
 758         integclks = expo;
 759         i = 0;
 760         cmd = SQ930_CTRL_SET_EXPOSURE;
 761 
 762         switch (sd->sensor) {
 763         case SENSOR_ICX098BQ:                   /* ccd */
 764         case SENSOR_LZ24BP:
 765                 min_frclk = sd->sensor == SENSOR_ICX098BQ ? 0x210 : 0x26f;
 766                 if (integclks >= min_frclk) {
 767                         intstartclk = 0;
 768                         frameclks = integclks;
 769                 } else {
 770                         intstartclk = min_frclk - integclks;
 771                         frameclks = min_frclk;
 772                 }
 773                 buf[i++] = intstartclk >> 8;
 774                 buf[i++] = intstartclk;
 775                 buf[i++] = frameclks >> 8;
 776                 buf[i++] = frameclks;
 777                 buf[i++] = gain;
 778                 break;
 779         default:                                /* cmos */
 780 /*      case SENSOR_MI0360: */
 781 /*      case SENSOR_MT9V111: */
 782                 cmd |= 0x0100;
 783                 sensor = &sensor_tb[sd->sensor];
 784                 buf[i++] = sensor->i2c_addr;    /* i2c_slave_addr */
 785                 buf[i++] = 0x08;        /* 2 * ni2c */
 786                 buf[i++] = 0x09;        /* reg = shutter width */
 787                 buf[i++] = integclks >> 8; /* val H */
 788                 buf[i++] = sensor->i2c_dum;
 789                 buf[i++] = integclks;   /* val L */
 790                 buf[i++] = 0x35;        /* reg = global gain */
 791                 buf[i++] = 0x00;        /* val H */
 792                 buf[i++] = sensor->i2c_dum;
 793                 buf[i++] = 0x80 + gain / 2; /* val L */
 794                 buf[i++] = 0x00;
 795                 buf[i++] = 0x00;
 796                 buf[i++] = 0x00;
 797                 buf[i++] = 0x00;
 798                 buf[i++] = 0x83;
 799                 break;
 800         }
 801         reg_wb(gspca_dev, cmd, 0, buf, i);
 802 }
 803 
 804 /* This function is called at probe time just before sd_init */
 805 static int sd_config(struct gspca_dev *gspca_dev,
 806                 const struct usb_device_id *id)
 807 {
 808         struct sd *sd = (struct sd *) gspca_dev;
 809         struct cam *cam = &gspca_dev->cam;
 810 
 811         sd->sensor = id->driver_info >> 8;
 812         sd->type = id->driver_info;
 813 
 814         cam->cam_mode = vga_mode;
 815         cam->nmodes = ARRAY_SIZE(vga_mode);
 816 
 817         cam->bulk = 1;
 818 
 819         return 0;
 820 }
 821 
 822 /* this function is called at probe and resume time */
 823 static int sd_init(struct gspca_dev *gspca_dev)
 824 {
 825         struct sd *sd = (struct sd *) gspca_dev;
 826 
 827         sd->gpio[0] = sd->gpio[1] = 0xff;       /* force gpio rewrite */
 828 
 829 /*fixme: is this needed for icx098bp and mi0360?
 830         if (sd->sensor != SENSOR_LZ24BP)
 831                 reg_w(gspca_dev, SQ930_CTRL_RESET, 0x0000);
 832  */
 833 
 834         reg_r(gspca_dev, SQ930_CTRL_GET_DEV_INFO, 8);
 835         if (gspca_dev->usb_err < 0)
 836                 return gspca_dev->usb_err;
 837 
 838 /* it returns:
 839  * 03 00 12 93 0b f6 c9 00      live! ultra
 840  * 03 00 07 93 0b f6 ca 00      live! ultra for notebook
 841  * 03 00 12 93 0b fe c8 00      Trust WB-3500T
 842  * 02 00 06 93 0b fe c8 00      Joy-IT 318S
 843  * 03 00 12 93 0b f6 cf 00      icam tracer - sensor icx098bq
 844  * 02 00 12 93 0b fe cf 00      ProQ Motion Webcam
 845  *
 846  * byte
 847  * 0: 02 = usb 1.0 (12Mbit) / 03 = usb2.0 (480Mbit)
 848  * 1: 00
 849  * 2: 06 / 07 / 12 = mode webcam? firmware??
 850  * 3: 93 chip = 930b (930b or 930c)
 851  * 4: 0b
 852  * 5: f6 = cdd (icx098bq, lz24bp) / fe or de = cmos (i2c) (other sensors)
 853  * 6: c8 / c9 / ca / cf = mode webcam?, sensor? webcam?
 854  * 7: 00
 855  */
 856         gspca_dbg(gspca_dev, D_PROBE, "info: %*ph\n", 8, gspca_dev->usb_buf);
 857 
 858         bridge_init(sd);
 859 
 860         if (sd->sensor == SENSOR_MI0360) {
 861 
 862                 /* no sensor probe for icam tracer */
 863                 if (gspca_dev->usb_buf[5] == 0xf6)      /* if ccd */
 864                         sd->sensor = SENSOR_ICX098BQ;
 865                 else
 866                         cmos_probe(gspca_dev);
 867         }
 868         if (gspca_dev->usb_err >= 0) {
 869                 gspca_dbg(gspca_dev, D_PROBE, "Sensor %s\n",
 870                           sensor_tb[sd->sensor].name);
 871                 global_init(sd, 1);
 872         }
 873         return gspca_dev->usb_err;
 874 }
 875 
 876 /* send the start/stop commands to the webcam */
 877 static void send_start(struct gspca_dev *gspca_dev)
 878 {
 879         struct sd *sd = (struct sd *) gspca_dev;
 880         const struct cap_s *cap;
 881         int mode;
 882 
 883         mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
 884         cap = &capconfig[sd->sensor][mode];
 885         reg_wb(gspca_dev, 0x0900 | SQ930_CTRL_CAP_START,
 886                         0x0a00 | cap->cc_sizeid,
 887                         cap->cc_bytes, 32);
 888 }
 889 
 890 static void send_stop(struct gspca_dev *gspca_dev)
 891 {
 892         reg_w(gspca_dev, SQ930_CTRL_CAP_STOP, 0);
 893 }
 894 
 895 /* function called at start time before URB creation */
 896 static int sd_isoc_init(struct gspca_dev *gspca_dev)
 897 {
 898         struct sd *sd = (struct sd *) gspca_dev;
 899 
 900         gspca_dev->cam.bulk_nurbs = 1;  /* there must be one URB only */
 901         sd->do_ctrl = 0;
 902         gspca_dev->cam.bulk_size = gspca_dev->pixfmt.width *
 903                         gspca_dev->pixfmt.height + 8;
 904         return 0;
 905 }
 906 
 907 /* start the capture */
 908 static int sd_start(struct gspca_dev *gspca_dev)
 909 {
 910         struct sd *sd = (struct sd *) gspca_dev;
 911         int mode;
 912 
 913         bridge_init(sd);
 914         global_init(sd, 0);
 915         msleep(100);
 916 
 917         switch (sd->sensor) {
 918         case SENSOR_ICX098BQ:
 919                 ucbus_write(gspca_dev, icx098bq_start_0,
 920                                 ARRAY_SIZE(icx098bq_start_0),
 921                                 8);
 922                 ucbus_write(gspca_dev, icx098bq_start_1,
 923                                 ARRAY_SIZE(icx098bq_start_1),
 924                                 5);
 925                 ucbus_write(gspca_dev, icx098bq_start_2,
 926                                 ARRAY_SIZE(icx098bq_start_2),
 927                                 6);
 928                 msleep(50);
 929 
 930                 /* 1st start */
 931                 send_start(gspca_dev);
 932                 gpio_set(sd, SQ930_GPIO_EXTRA2 | SQ930_GPIO_RSTBAR, 0x00ff);
 933                 msleep(70);
 934                 reg_w(gspca_dev, SQ930_CTRL_CAP_STOP, 0x0000);
 935                 gpio_set(sd, 0x7f, 0x00ff);
 936 
 937                 /* 2nd start */
 938                 send_start(gspca_dev);
 939                 gpio_set(sd, SQ930_GPIO_EXTRA2 | SQ930_GPIO_RSTBAR, 0x00ff);
 940                 goto out;
 941         case SENSOR_LZ24BP:
 942                 ucbus_write(gspca_dev, lz24bp_start_0,
 943                                 ARRAY_SIZE(lz24bp_start_0),
 944                                 8);
 945                 if (sd->type != Creative_live_motion)
 946                         ucbus_write(gspca_dev, lz24bp_start_1_gen,
 947                                         ARRAY_SIZE(lz24bp_start_1_gen),
 948                                         5);
 949                 else
 950                         ucbus_write(gspca_dev, lz24bp_start_1_clm,
 951                                         ARRAY_SIZE(lz24bp_start_1_clm),
 952                                         5);
 953                 ucbus_write(gspca_dev, lz24bp_start_2,
 954                                 ARRAY_SIZE(lz24bp_start_2),
 955                                 6);
 956                 mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
 957                 lz24bp_ppl(sd, mode == 1 ? 0x0564 : 0x0310);
 958                 msleep(10);
 959                 break;
 960         case SENSOR_MI0360:
 961                 ucbus_write(gspca_dev, mi0360_start_0,
 962                                 ARRAY_SIZE(mi0360_start_0),
 963                                 8);
 964                 i2c_write(sd, mi0360_init_23,
 965                                 ARRAY_SIZE(mi0360_init_23));
 966                 i2c_write(sd, mi0360_init_24,
 967                                 ARRAY_SIZE(mi0360_init_24));
 968                 i2c_write(sd, mi0360_init_25,
 969                                 ARRAY_SIZE(mi0360_init_25));
 970                 ucbus_write(gspca_dev, mi0360_start_1,
 971                                 ARRAY_SIZE(mi0360_start_1),
 972                                 5);
 973                 i2c_write(sd, mi0360_start_2,
 974                                 ARRAY_SIZE(mi0360_start_2));
 975                 i2c_write(sd, mi0360_start_3,
 976                                 ARRAY_SIZE(mi0360_start_3));
 977 
 978                 /* 1st start */
 979                 send_start(gspca_dev);
 980                 msleep(60);
 981                 send_stop(gspca_dev);
 982 
 983                 i2c_write(sd,
 984                         mi0360_start_4, ARRAY_SIZE(mi0360_start_4));
 985                 break;
 986         default:
 987 /*      case SENSOR_MT9V111: */
 988                 ucbus_write(gspca_dev, mi0360_start_0,
 989                                 ARRAY_SIZE(mi0360_start_0),
 990                                 8);
 991                 i2c_write(sd, mt9v111_init_0,
 992                                 ARRAY_SIZE(mt9v111_init_0));
 993                 i2c_write(sd, mt9v111_init_1,
 994                                 ARRAY_SIZE(mt9v111_init_1));
 995                 i2c_write(sd, mt9v111_init_2,
 996                                 ARRAY_SIZE(mt9v111_init_2));
 997                 ucbus_write(gspca_dev, mt9v111_start_1,
 998                                 ARRAY_SIZE(mt9v111_start_1),
 999                                 5);
1000                 i2c_write(sd, mt9v111_init_3,
1001                                 ARRAY_SIZE(mt9v111_init_3));
1002                 i2c_write(sd, mt9v111_init_4,
1003                                 ARRAY_SIZE(mt9v111_init_4));
1004                 break;
1005         }
1006 
1007         send_start(gspca_dev);
1008 out:
1009         msleep(1000);
1010 
1011         if (sd->sensor == SENSOR_MT9V111)
1012                 gpio_set(sd, SQ930_GPIO_DFL_LED, SQ930_GPIO_DFL_LED);
1013 
1014         sd->do_ctrl = 1;        /* set the exposure */
1015 
1016         return gspca_dev->usb_err;
1017 }
1018 
1019 static void sd_stopN(struct gspca_dev *gspca_dev)
1020 {
1021         struct sd *sd = (struct sd *) gspca_dev;
1022 
1023         if (sd->sensor == SENSOR_MT9V111)
1024                 gpio_set(sd, 0, SQ930_GPIO_DFL_LED);
1025         send_stop(gspca_dev);
1026 }
1027 
1028 /* function called when the application gets a new frame */
1029 /* It sets the exposure if required and restart the bulk transfer. */
1030 static void sd_dq_callback(struct gspca_dev *gspca_dev)
1031 {
1032         struct sd *sd = (struct sd *) gspca_dev;
1033         int ret;
1034 
1035         if (!sd->do_ctrl || gspca_dev->cam.bulk_nurbs != 0)
1036                 return;
1037         sd->do_ctrl = 0;
1038 
1039         setexposure(gspca_dev, v4l2_ctrl_g_ctrl(sd->exposure),
1040                         v4l2_ctrl_g_ctrl(sd->gain));
1041 
1042         gspca_dev->cam.bulk_nurbs = 1;
1043         ret = usb_submit_urb(gspca_dev->urb[0], GFP_KERNEL);
1044         if (ret < 0)
1045                 pr_err("sd_dq_callback() err %d\n", ret);
1046 
1047         /* wait a little time, otherwise the webcam crashes */
1048         msleep(100);
1049 }
1050 
1051 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1052                         u8 *data,               /* isoc packet */
1053                         int len)                /* iso packet length */
1054 {
1055         struct sd *sd = (struct sd *) gspca_dev;
1056 
1057         if (sd->do_ctrl)
1058                 gspca_dev->cam.bulk_nurbs = 0;
1059         gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
1060         gspca_frame_add(gspca_dev, INTER_PACKET, data, len - 8);
1061         gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
1062 }
1063 
1064 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
1065 {
1066         struct gspca_dev *gspca_dev =
1067                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
1068         struct sd *sd = (struct sd *) gspca_dev;
1069 
1070         gspca_dev->usb_err = 0;
1071 
1072         if (!gspca_dev->streaming)
1073                 return 0;
1074 
1075         switch (ctrl->id) {
1076         case V4L2_CID_EXPOSURE:
1077                 setexposure(gspca_dev, ctrl->val, sd->gain->val);
1078                 break;
1079         }
1080         return gspca_dev->usb_err;
1081 }
1082 
1083 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
1084         .s_ctrl = sd_s_ctrl,
1085 };
1086 
1087 static int sd_init_controls(struct gspca_dev *gspca_dev)
1088 {
1089         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
1090         struct sd *sd = (struct sd *) gspca_dev;
1091 
1092         gspca_dev->vdev.ctrl_handler = hdl;
1093         v4l2_ctrl_handler_init(hdl, 2);
1094         sd->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1095                         V4L2_CID_EXPOSURE, 1, 0xfff, 1, 0x356);
1096         sd->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1097                         V4L2_CID_GAIN, 1, 255, 1, 0x8d);
1098 
1099         if (hdl->error) {
1100                 pr_err("Could not initialize controls\n");
1101                 return hdl->error;
1102         }
1103         v4l2_ctrl_cluster(2, &sd->exposure);
1104         return 0;
1105 }
1106 
1107 /* sub-driver description */
1108 static const struct sd_desc sd_desc = {
1109         .name   = MODULE_NAME,
1110         .config = sd_config,
1111         .init   = sd_init,
1112         .init_controls = sd_init_controls,
1113         .isoc_init = sd_isoc_init,
1114         .start  = sd_start,
1115         .stopN  = sd_stopN,
1116         .pkt_scan = sd_pkt_scan,
1117         .dq_callback = sd_dq_callback,
1118 };
1119 
1120 /* Table of supported USB devices */
1121 #define ST(sensor, type) \
1122         .driver_info = (SENSOR_ ## sensor << 8) \
1123                         | (type)
1124 static const struct usb_device_id device_table[] = {
1125         {USB_DEVICE(0x041e, 0x4038), ST(MI0360, 0)},
1126         {USB_DEVICE(0x041e, 0x403c), ST(LZ24BP, 0)},
1127         {USB_DEVICE(0x041e, 0x403d), ST(LZ24BP, 0)},
1128         {USB_DEVICE(0x041e, 0x4041), ST(LZ24BP, Creative_live_motion)},
1129         {USB_DEVICE(0x2770, 0x930b), ST(MI0360, 0)},
1130         {USB_DEVICE(0x2770, 0x930c), ST(MI0360, 0)},
1131         {}
1132 };
1133 MODULE_DEVICE_TABLE(usb, device_table);
1134 
1135 
1136 /* -- device connect -- */
1137 static int sd_probe(struct usb_interface *intf,
1138                 const struct usb_device_id *id)
1139 {
1140         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1141                         THIS_MODULE);
1142 }
1143 
1144 static struct usb_driver sd_driver = {
1145         .name       = MODULE_NAME,
1146         .id_table   = device_table,
1147         .probe      = sd_probe,
1148         .disconnect = gspca_disconnect,
1149 #ifdef CONFIG_PM
1150         .suspend    = gspca_suspend,
1151         .resume     = gspca_resume,
1152         .reset_resume = gspca_resume,
1153 #endif
1154 };
1155 
1156 module_usb_driver(sd_driver);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/media/usb/gspca/sq930x.c

DEFINITIONS
