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_KERNEL); 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); 1161