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