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

1001                                        5);
1002                else
1003                        ucbus_write(gspca_dev, lz24bp_start_1_clm,
1004                                        ARRAY_SIZE(lz24bp_start_1_clm),
1005                                        5);
1006                ucbus_write(gspca_dev, lz24bp_start_2,
1007                                ARRAY_SIZE(lz24bp_start_2),
1008                                6);
1009                mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
1010                lz24bp_ppl(sd, mode == 1 ? 0x0564 : 0x0310);
1011                msleep(10);
1012                break;
1013        case SENSOR_MI0360:
1014                ucbus_write(gspca_dev, mi0360_start_0,
1015                                ARRAY_SIZE(mi0360_start_0),
1016                                8);
1017                i2c_write(sd, mi0360_init_23,
1018                                ARRAY_SIZE(mi0360_init_23));
1019                i2c_write(sd, mi0360_init_24,
1020                                ARRAY_SIZE(mi0360_init_24));
1021                i2c_write(sd, mi0360_init_25,
1022                                ARRAY_SIZE(mi0360_init_25));
1023                ucbus_write(gspca_dev, mi0360_start_1,
1024                                ARRAY_SIZE(mi0360_start_1),
1025                                5);
1026                i2c_write(sd, mi0360_start_2,
1027                                ARRAY_SIZE(mi0360_start_2));
1028                i2c_write(sd, mi0360_start_3,
1029                                ARRAY_SIZE(mi0360_start_3));
1030
1031                /* 1st start */
1032                send_start(gspca_dev);
1033                msleep(60);
1034                send_stop(gspca_dev);
1035
1036                i2c_write(sd,
1037                        mi0360_start_4, ARRAY_SIZE(mi0360_start_4));
1038                break;
1039        default:
1040/*      case SENSOR_MT9V111: */
1041                ucbus_write(gspca_dev, mi0360_start_0,
1042                                ARRAY_SIZE(mi0360_start_0),
1043                                8);
1044                i2c_write(sd, mt9v111_init_0,
1045                                ARRAY_SIZE(mt9v111_init_0));
1046                i2c_write(sd, mt9v111_init_1,
1047                                ARRAY_SIZE(mt9v111_init_1));
1048                i2c_write(sd, mt9v111_init_2,
1049                                ARRAY_SIZE(mt9v111_init_2));
1050                ucbus_write(gspca_dev, mt9v111_start_1,
1051                                ARRAY_SIZE(mt9v111_start_1),
1052                                5);
1053                i2c_write(sd, mt9v111_init_3,
1054                                ARRAY_SIZE(mt9v111_init_3));
1055                i2c_write(sd, mt9v111_init_4,
1056                                ARRAY_SIZE(mt9v111_init_4));
1057                break;
1058        }
1059
1060        send_start(gspca_dev);
1061out:
1062        msleep(1000);
1063
1064        if (sd->sensor == SENSOR_MT9V111)
1065                gpio_set(sd, SQ930_GPIO_DFL_LED, SQ930_GPIO_DFL_LED);
1066
1067        sd->do_ctrl = 1;        /* set the exposure */
1068
1069        return gspca_dev->usb_err;
1070}
1071
1072static void sd_stopN(struct gspca_dev *gspca_dev)
1073{
1074        struct sd *sd = (struct sd *) gspca_dev;
1075
1076        if (sd->sensor == SENSOR_MT9V111)
1077                gpio_set(sd, 0, SQ930_GPIO_DFL_LED);
1078        send_stop(gspca_dev);
1079}
1080
1081/* function called when the application gets a new frame */
1082/* It sets the exposure if required and restart the bulk transfer. */
1083static void sd_dq_callback(struct gspca_dev *gspca_dev)
1084{
1085        struct sd *sd = (struct sd *) gspca_dev;
1086        int ret;
1087
1088        if (!sd->do_ctrl || gspca_dev->cam.bulk_nurbs != 0)
1089                return;
1090        sd->do_ctrl = 0;
1091
1092        setexposure(gspca_dev);
1093
1094        gspca_dev->cam.bulk_nurbs = 1;
1095        ret = usb_submit_urb(gspca_dev->urb[0], GFP_ATOMIC);
1096        if (ret < 0)
1097                pr_err("sd_dq_callback() err %d\n", ret);
1098
1099        /* wait a little time, otherwise the webcam crashes */
1100        msleep(100);
1101}
1102
1103static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1104                        u8 *data,               /* isoc packet */
1105                        int len)                /* iso packet length */
1106{
1107        struct sd *sd = (struct sd *) gspca_dev;
1108
1109        if (sd->do_ctrl)
1110                gspca_dev->cam.bulk_nurbs = 0;
1111        gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
1112        gspca_frame_add(gspca_dev, INTER_PACKET, data, len - 8);
1113        gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
1114}
1115
1116static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
1117{
1118        struct sd *sd = (struct sd *) gspca_dev;
1119
1120        sd->gain = val;
1121        if (gspca_dev->streaming)
1122                sd->do_ctrl = 1;
1123        return 0;
1124}
1125
1126static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1127{
1128        struct sd *sd = (struct sd *) gspca_dev;
1129
1130        *val = sd->gain;
1131        return 0;
1132}
1133static int sd_setexpo(struct gspca_dev *gspca_dev, __s32 val)
1134{
1135        struct sd *sd = (struct sd *) gspca_dev;
1136
1137        sd->expo = val;
1138        if (gspca_dev->streaming)
1139                sd->do_ctrl = 1;
1140        return 0;
1141}
1142
1143static int sd_getexpo(struct gspca_dev *gspca_dev, __s32 *val)
1144{
1145        struct sd *sd = (struct sd *) gspca_dev;
1146
1147        *val = sd->expo;
1148        return 0;
1149}
1150
1151/* sub-driver description */
1152static const struct sd_desc sd_desc = {
1153        .name   = MODULE_NAME,
1154        .ctrls = sd_ctrls,
1155        .nctrls = ARRAY_SIZE(sd_ctrls),
1156        .config = sd_config,
1157        .init   = sd_init,
1158        .isoc_init = sd_isoc_init,
1159        .start  = sd_start,
1160        .stopN  = sd_stopN,
1161        .pkt_scan = sd_pkt_scan,
1162        .dq_callback = sd_dq_callback,
1163};
1164
1165/* Table of supported USB devices */
1166#define ST(sensor, type) \
1167        .driver_info = (SENSOR_ ## sensor << 8) \
1168                        | (type)
1169static const struct usb_device_id device_table[] = {
1170        {USB_DEVICE(0x041e, 0x4038), ST(MI0360, 0)},
1171        {USB_DEVICE(0x041e, 0x403c), ST(LZ24BP, 0)},
1172        {USB_DEVICE(0x041e, 0x403d), ST(LZ24BP, 0)},
1173        {USB_DEVICE(0x041e, 0x4041), ST(LZ24BP, Creative_live_motion)},
1174        {USB_DEVICE(0x2770, 0x930b), ST(MI0360, 0)},
1175        {USB_DEVICE(0x2770, 0x930c), ST(MI0360, 0)},
1176        {}
1177};
1178MODULE_DEVICE_TABLE(usb, device_table);
1179
1180
1181/* -- device connect -- */
1182static int sd_probe(struct usb_interface *intf,
1183                const struct usb_device_id *id)
1184{
1185        return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1186                        THIS_MODULE);
1187}
1188
1189static struct usb_driver sd_driver = {
1190        .name       = MODULE_NAME,
1191        .id_table   = device_table,
1192        .probe      = sd_probe,
1193        .disconnect = gspca_disconnect,
1194#ifdef CONFIG_PM
1195        .suspend    = gspca_suspend,
1196        .resume     = gspca_resume,
1197#endif
1198};
1199
1200module_usb_driver(sd_driver);
1201
Hosted by Missing Link Electronics. The original LXR software by the LXR community, this experimental version by lxr@linux.no.