drivers/media/usb/gspca/sq930x.c

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