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>
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
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.
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
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #define MODULE_NAME "sq930x"
29 MODULE_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>");
32 MODULE_DESCRIPTION("GSPCA/SQ930x USB Camera Driver");
33 MODULE_LICENSE("GPL");
35 /* Structure to hold all of our device specific stuff */
37 struct gspca_dev gspca_dev
; /* !! must be the first item */
47 #define Creative_live_motion 1
53 SENSOR_MT9V111
, /* = MI360SOC */
58 static int sd_setexpo(struct gspca_dev
*gspca_dev
, __s32 val
);
59 static int sd_getexpo(struct gspca_dev
*gspca_dev
, __s32
*val
);
60 static int sd_setgain(struct gspca_dev
*gspca_dev
, __s32 val
);
61 static int sd_getgain(struct gspca_dev
*gspca_dev
, __s32
*val
);
63 static const struct ctrl sd_ctrls
[] = {
66 .id
= V4L2_CID_EXPOSURE
,
67 .type
= V4L2_CTRL_TYPE_INTEGER
,
72 #define EXPO_DEF 0x0356
73 .default_value
= EXPO_DEF
,
81 .type
= V4L2_CTRL_TYPE_INTEGER
,
87 .default_value
= GAIN_DEF
,
94 static struct v4l2_pix_format vga_mode
[] = {
95 {320, 240, V4L2_PIX_FMT_SRGGB8
, V4L2_FIELD_NONE
,
97 .sizeimage
= 320 * 240,
98 .colorspace
= V4L2_COLORSPACE_SRGB
,
100 {640, 480, V4L2_PIX_FMT_SRGGB8
, V4L2_FIELD_NONE
,
102 .sizeimage
= 640 * 480,
103 .colorspace
= V4L2_COLORSPACE_SRGB
,
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
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
127 struct ucbus_write_cmd
{
131 struct i2c_write_cmd
{
136 static 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},
164 static const struct ucbus_write_cmd icx098bq_start_1
[] = {
165 {0xf5f0, 0x00}, {0xf5f1, 0xcd}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
167 {0xf5f0, 0x49}, {0xf5f1, 0xcd}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
169 {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
173 static 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}
184 static 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},
212 static const struct ucbus_write_cmd lz24bp_start_1_gen
[] = {
213 {0xf5f0, 0x00}, {0xf5f1, 0xff}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
215 {0xf5f0, 0x40}, {0xf5f1, 0xff}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
217 {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
221 static const struct ucbus_write_cmd lz24bp_start_1_clm
[] = {
222 {0xf5f0, 0x00}, {0xf5f1, 0xff}, {0xf5f2, 0x88}, {0xf5f3, 0x88},
224 {0xf5f0, 0x40}, {0xf5f1, 0xff}, {0xf5f2, 0x88}, {0xf5f3, 0x88},
226 {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
230 static 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}
241 static const struct ucbus_write_cmd mi0360_start_0
[] = {
242 {0x0354, 0x00}, {0x03fa, 0x00}, {0xf332, 0xcc}, {0xf333, 0xcc},
243 {0xf334, 0xcc}, {0xf335, 0xcc}, {0xf33f, 0x00}
245 static 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 */
251 static const struct i2c_write_cmd mi0360_init_24
[] = {
252 {0x03, 0x01e5}, /* window height */
253 {0x04, 0x0285}, /* window width */
255 static 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 */
262 static const struct ucbus_write_cmd mi0360_start_1
[] = {
263 {0xf5f0, 0x11}, {0xf5f1, 0x99}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
265 {0xf5f0, 0x51}, {0xf5f1, 0x99}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
267 {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
270 static const struct i2c_write_cmd mi0360_start_2
[] = {
271 {0x62, 0x041d}, /* reserved - def 0x0418 */
273 static const struct i2c_write_cmd mi0360_start_3
[] = {
274 {0x05, 0x007b}, /* horiz blanking */
276 static const struct i2c_write_cmd mi0360_start_4
[] = {
277 {0x05, 0x03f5}, /* horiz blanking */
280 static 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 */
286 static const struct i2c_write_cmd mt9v111_init_1
[] = {
287 {0x03, 0x01e5}, /* window height */
288 {0x04, 0x0285}, /* window width */
290 static const struct i2c_write_cmd mt9v111_init_2
[] = {
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 */
300 static const struct ucbus_write_cmd mt9v111_start_1
[] = {
301 {0xf5f0, 0x11}, {0xf5f1, 0x96}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
303 {0xf5f0, 0x51}, {0xf5f1, 0x96}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
305 {0xf5fa, 0x00}, {0xf5f6, 0x0a}, {0xf5f7, 0x0a}, {0xf5f8, 0x0a},
308 static const struct i2c_write_cmd mt9v111_init_3
[] = {
311 static const struct i2c_write_cmd mt9v111_init_4
[] = {
312 /* {0x05, 0x00ce}, */
313 {0x05, 0x005d}, /* horizontal blanking */
316 static const struct ucbus_write_cmd ov7660_start_0
[] = {
317 {0x0354, 0x00}, {0x03fa, 0x00}, {0xf332, 0x00}, {0xf333, 0xc0},
318 {0xf334, 0x39}, {0xf335, 0xe7}, {0xf33f, 0x03}
321 static const struct ucbus_write_cmd ov9630_start_0
[] = {
322 {0x0354, 0x00}, {0x03fa, 0x00}, {0xf332, 0x00}, {0xf333, 0x00},
323 {0xf334, 0x3e}, {0xf335, 0xf8}, {0xf33f, 0x03}
326 /* start parameters indexed by [sensor][mode] */
327 static const struct cap_s
{
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} },
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} },
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} },
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} },
387 const struct ucbus_write_cmd
*cmd
;
390 static const struct sensor_s sensor_tb
[] = {
391 [SENSOR_ICX098BQ
] = {
395 SQ930_GPIO_DFL_I2C_SDA
| SQ930_GPIO_DFL_I2C_SCL
,
396 SQ930_GPIO_DFL_I2C_SDA
,
406 SQ930_GPIO_DFL_I2C_SDA
| SQ930_GPIO_DFL_I2C_SCL
,
407 SQ930_GPIO_DFL_I2C_SDA
,
417 SQ930_GPIO_DFL_I2C_SDA
| SQ930_GPIO_DFL_I2C_SCL
,
418 SQ930_GPIO_DFL_I2C_SDA
,
428 SQ930_GPIO_DFL_I2C_SDA
| SQ930_GPIO_DFL_I2C_SCL
,
429 SQ930_GPIO_DFL_I2C_SDA
,
439 SQ930_GPIO_DFL_I2C_SDA
| SQ930_GPIO_DFL_I2C_SCL
,
440 SQ930_GPIO_DFL_I2C_SDA
,
450 SQ930_GPIO_DFL_I2C_SDA
| SQ930_GPIO_DFL_I2C_SCL
,
451 SQ930_GPIO_DFL_I2C_SDA
,
459 static void reg_r(struct gspca_dev
*gspca_dev
,
464 if (gspca_dev
->usb_err
< 0)
466 ret
= usb_control_msg(gspca_dev
->dev
,
467 usb_rcvctrlpipe(gspca_dev
->dev
, 0),
469 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
470 value
, 0, gspca_dev
->usb_buf
, len
,
473 pr_err("reg_r %04x failed %d\n", value
, ret
);
474 gspca_dev
->usb_err
= ret
;
478 static void reg_w(struct gspca_dev
*gspca_dev
, u16 value
, u16 index
)
482 if (gspca_dev
->usb_err
< 0)
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),
488 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
489 value
, index
, NULL
, 0,
493 pr_err("reg_w %04x %04x failed %d\n", value
, index
, ret
);
494 gspca_dev
->usb_err
= ret
;
498 static void reg_wb(struct gspca_dev
*gspca_dev
, u16 value
, u16 index
,
499 const u8
*data
, int len
)
503 if (gspca_dev
->usb_err
< 0)
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),
511 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
512 value
, index
, gspca_dev
->usb_buf
, len
,
516 pr_err("reg_wb %04x %04x failed %d\n", value
, index
, ret
);
517 gspca_dev
->usb_err
= ret
;
521 static void i2c_write(struct sd
*sd
,
522 const struct i2c_write_cmd
*cmd
,
525 struct gspca_dev
*gspca_dev
= &sd
->gspca_dev
;
526 const struct sensor_s
*sensor
;
531 if (gspca_dev
->usb_err
< 0)
534 sensor
= &sensor_tb
[sd
->sensor
];
536 val
= (sensor
->i2c_addr
<< 8) | SQ930_CTRL_I2C_IO
;
537 idx
= (cmd
->val
& 0xff00) | cmd
->reg
;
539 buf
= gspca_dev
->usb_buf
;
540 *buf
++ = sensor
->i2c_dum
;
543 while (--ncmds
> 0) {
546 *buf
++ = cmd
->val
>> 8;
547 *buf
++ = sensor
->i2c_dum
;
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),
556 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
558 gspca_dev
->usb_buf
, buf
- gspca_dev
->usb_buf
,
561 pr_err("i2c_write failed %d\n", ret
);
562 gspca_dev
->usb_err
= ret
;
566 static void ucbus_write(struct gspca_dev
*gspca_dev
,
567 const struct ucbus_write_cmd
*cmd
,
575 if (gspca_dev
->usb_err
< 0)
579 if ((batchsize
- 1) * 3 > USB_BUF_SZ
) {
580 pr_err("Bug: usb_buf overflow\n");
581 gspca_dev
->usb_err
= -ENOMEM
;
592 val
= (cmd
->bw_addr
<< 8) | SQ930_CTRL_UCBUS_IO
;
593 idx
= (cmd
->bw_data
<< 8) | (cmd
->bw_addr
>> 8);
595 buf
= gspca_dev
->usb_buf
;
598 *buf
++ = cmd
->bw_addr
;
599 *buf
++ = cmd
->bw_addr
>> 8;
600 *buf
++ = cmd
->bw_data
;
602 if (buf
!= gspca_dev
->usb_buf
)
603 PDEBUG(D_USBO
, "ucbus v: %04x i: %04x %02x...%02x",
605 gspca_dev
->usb_buf
[0], buf
[-1]);
607 PDEBUG(D_USBO
, "ucbus v: %04x i: %04x",
609 ret
= usb_control_msg(gspca_dev
->dev
,
610 usb_sndctrlpipe(gspca_dev
->dev
, 0),
612 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
614 gspca_dev
->usb_buf
, buf
- gspca_dev
->usb_buf
,
617 pr_err("ucbus_write failed %d\n", ret
);
618 gspca_dev
->usb_err
= ret
;
628 static void gpio_set(struct sd
*sd
, u16 val
, u16 mask
)
630 struct gspca_dev
*gspca_dev
= &sd
->gspca_dev
;
633 sd
->gpio
[0] &= ~mask
;
635 reg_w(gspca_dev
, 0x0100 | SQ930_CTRL_GPIO
,
641 sd
->gpio
[1] &= ~mask
;
643 reg_w(gspca_dev
, 0x0300 | SQ930_CTRL_GPIO
,
648 static void gpio_init(struct sd
*sd
,
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);
658 static void bridge_init(struct sd
*sd
)
660 static const struct ucbus_write_cmd clkfreq_cmd
= {
661 0xf031, 0 /* SQ930_CLKFREQ_60MHZ */
664 ucbus_write(&sd
->gspca_dev
, &clkfreq_cmd
, 1, 1);
666 gpio_set(sd
, SQ930_GPIO_POWER
, 0xff00);
669 static void cmos_probe(struct gspca_dev
*gspca_dev
)
671 struct sd
*sd
= (struct sd
*) gspca_dev
;
673 const struct sensor_s
*sensor
;
674 static const u8 probe_order
[] = {
675 /* SENSOR_LZ24BP, (tested as ccd) */
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
);
687 reg_r(gspca_dev
, (sensor
->i2c_addr
<< 8) | 0x001c, 1);
689 if (gspca_dev
->usb_buf
[0] != 0)
692 if (i
>= ARRAY_SIZE(probe_order
)) {
693 pr_err("Unknown sensor\n");
694 gspca_dev
->usb_err
= -EINVAL
;
697 sd
->sensor
= probe_order
[i
];
698 switch (sd
->sensor
) {
701 pr_err("Sensor %s not yet treated\n",
702 sensor_tb
[sd
->sensor
].name
);
703 gspca_dev
->usb_err
= -EINVAL
;
708 static void mt9v111_init(struct gspca_dev
*gspca_dev
)
711 static const u8 cmd_001b
[] = {
712 0x00, 0x3b, 0xf6, 0x01, 0x03, 0x02, 0x00, 0x00,
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},
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]));
729 reg_r(gspca_dev
, 0x031b, 1);
730 if (gspca_dev
->usb_buf
[0] == 0
731 || gspca_dev
->usb_err
!= 0)
734 PDEBUG(D_PROBE
, "mt9v111_init timeout");
735 gspca_dev
->usb_err
= -ETIME
;
743 static void global_init(struct sd
*sd
, int first_time
)
745 switch (sd
->sensor
) {
746 case SENSOR_ICX098BQ
:
748 ucbus_write(&sd
->gspca_dev
,
751 gpio_init(sd
, sensor_tb
[sd
->sensor
].gpio
);
754 if (sd
->type
!= Creative_live_motion
)
755 gpio_set(sd
, SQ930_GPIO_EXTRA1
, 0x00ff);
757 gpio_set(sd
, 0, 0x00ff);
760 ucbus_write(&sd
->gspca_dev
,
763 gpio_init(sd
, sensor_tb
[sd
->sensor
].gpio
);
767 ucbus_write(&sd
->gspca_dev
,
769 ARRAY_SIZE(mi0360_start_0
),
771 gpio_init(sd
, sensor_tb
[sd
->sensor
].gpio
);
772 gpio_set(sd
, SQ930_GPIO_EXTRA2
, SQ930_GPIO_EXTRA2
);
775 /* case SENSOR_MT9V111: */
777 mt9v111_init(&sd
->gspca_dev
);
779 gpio_init(sd
, sensor_tb
[sd
->sensor
].gpio
);
784 static void lz24bp_ppl(struct sd
*sd
, u16 ppl
)
786 struct ucbus_write_cmd cmds
[2] = {
791 ucbus_write(&sd
->gspca_dev
, cmds
, ARRAY_SIZE(cmds
), 2);
794 static void setexposure(struct gspca_dev
*gspca_dev
)
796 struct sd
*sd
= (struct sd
*) gspca_dev
;
797 int i
, integclks
, intstartclk
, frameclks
, min_frclk
;
798 const struct sensor_s
*sensor
;
802 integclks
= sd
->expo
;
804 cmd
= SQ930_CTRL_SET_EXPOSURE
;
806 switch (sd
->sensor
) {
807 case SENSOR_ICX098BQ
: /* ccd */
809 min_frclk
= sd
->sensor
== SENSOR_ICX098BQ
? 0x210 : 0x26f;
810 if (integclks
>= min_frclk
) {
812 frameclks
= integclks
;
814 intstartclk
= min_frclk
- integclks
;
815 frameclks
= min_frclk
;
817 buf
[i
++] = intstartclk
>> 8;
818 buf
[i
++] = intstartclk
;
819 buf
[i
++] = frameclks
>> 8;
820 buf
[i
++] = frameclks
;
824 /* case SENSOR_MI0360: */
825 /* case SENSOR_MT9V111: */
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 */
845 reg_wb(gspca_dev
, cmd
, 0, buf
, i
);
848 /* This function is called at probe time just before sd_init */
849 static int sd_config(struct gspca_dev
*gspca_dev
,
850 const struct usb_device_id
*id
)
852 struct sd
*sd
= (struct sd
*) gspca_dev
;
853 struct cam
*cam
= &gspca_dev
->cam
;
855 sd
->sensor
= id
->driver_info
>> 8;
856 sd
->type
= id
->driver_info
;
858 cam
->cam_mode
= vga_mode
;
859 cam
->nmodes
= ARRAY_SIZE(vga_mode
);
869 /* this function is called at probe and resume time */
870 static int sd_init(struct gspca_dev
*gspca_dev
)
872 struct sd
*sd
= (struct sd
*) gspca_dev
;
874 sd
->gpio
[0] = sd
->gpio
[1] = 0xff; /* force gpio rewrite */
876 /*fixme: is this needed for icx098bp and mi0360?
877 if (sd->sensor != SENSOR_LZ24BP)
878 reg_w(gspca_dev, SQ930_CTRL_RESET, 0x0000);
881 reg_r(gspca_dev
, SQ930_CTRL_GET_DEV_INFO
, 8);
882 if (gspca_dev
->usb_err
< 0)
883 return gspca_dev
->usb_err
;
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
894 * 0: 02 = usb 1.0 (12Mbit) / 03 = usb2.0 (480Mbit)
896 * 2: 06 / 07 / 12 = mode webcam? firmware??
897 * 3: 93 chip = 930b (930b or 930c)
899 * 5: f6 = cdd (icx098bq, lz24bp) / fe or de = cmos (i2c) (other sensors)
900 * 6: c8 / c9 / ca / cf = mode webcam?, sensor? webcam?
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]);
915 if (sd
->sensor
== SENSOR_MI0360
) {
917 /* no sensor probe for icam tracer */
918 if (gspca_dev
->usb_buf
[5] == 0xf6) /* if ccd */
919 sd
->sensor
= SENSOR_ICX098BQ
;
921 cmos_probe(gspca_dev
);
923 if (gspca_dev
->usb_err
>= 0) {
924 PDEBUG(D_PROBE
, "Sensor %s", sensor_tb
[sd
->sensor
].name
);
927 return gspca_dev
->usb_err
;
930 /* send the start/stop commands to the webcam */
931 static void send_start(struct gspca_dev
*gspca_dev
)
933 struct sd
*sd
= (struct sd
*) gspca_dev
;
934 const struct cap_s
*cap
;
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
,
944 static void send_stop(struct gspca_dev
*gspca_dev
)
946 reg_w(gspca_dev
, SQ930_CTRL_CAP_STOP
, 0);
949 /* function called at start time before URB creation */
950 static int sd_isoc_init(struct gspca_dev
*gspca_dev
)
952 struct sd
*sd
= (struct sd
*) gspca_dev
;
954 gspca_dev
->cam
.bulk_nurbs
= 1; /* there must be one URB only */
956 gspca_dev
->cam
.bulk_size
= gspca_dev
->width
* gspca_dev
->height
+ 8;
960 /* start the capture */
961 static int sd_start(struct gspca_dev
*gspca_dev
)
963 struct sd
*sd
= (struct sd
*) gspca_dev
;
970 switch (sd
->sensor
) {
971 case SENSOR_ICX098BQ
:
972 ucbus_write(gspca_dev
, icx098bq_start_0
,
973 ARRAY_SIZE(icx098bq_start_0
),
975 ucbus_write(gspca_dev
, icx098bq_start_1
,
976 ARRAY_SIZE(icx098bq_start_1
),
978 ucbus_write(gspca_dev
, icx098bq_start_2
,
979 ARRAY_SIZE(icx098bq_start_2
),
984 send_start(gspca_dev
);
985 gpio_set(sd
, SQ930_GPIO_EXTRA2
| SQ930_GPIO_RSTBAR
, 0x00ff);
987 reg_w(gspca_dev
, SQ930_CTRL_CAP_STOP
, 0x0000);
988 gpio_set(sd
, 0x7f, 0x00ff);
991 send_start(gspca_dev
);
992 gpio_set(sd
, SQ930_GPIO_EXTRA2
| SQ930_GPIO_RSTBAR
, 0x00ff);
995 ucbus_write(gspca_dev
, lz24bp_start_0
,
996 ARRAY_SIZE(lz24bp_start_0
),
998 if (sd
->type
!= Creative_live_motion
)
999 ucbus_write(gspca_dev
, lz24bp_start_1_gen
,
1000 ARRAY_SIZE(lz24bp_start_1_gen
),
1003 ucbus_write(gspca_dev
, lz24bp_start_1_clm
,
1004 ARRAY_SIZE(lz24bp_start_1_clm
),
1006 ucbus_write(gspca_dev
, lz24bp_start_2
,
1007 ARRAY_SIZE(lz24bp_start_2
),
1009 mode
= gspca_dev
->cam
.cam_mode
[gspca_dev
->curr_mode
].priv
;
1010 lz24bp_ppl(sd
, mode
== 1 ? 0x0564 : 0x0310);
1014 ucbus_write(gspca_dev
, mi0360_start_0
,
1015 ARRAY_SIZE(mi0360_start_0
),
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
),
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
));
1032 send_start(gspca_dev
);
1034 send_stop(gspca_dev
);
1037 mi0360_start_4
, ARRAY_SIZE(mi0360_start_4
));
1040 /* case SENSOR_MT9V111: */
1041 ucbus_write(gspca_dev
, mi0360_start_0
,
1042 ARRAY_SIZE(mi0360_start_0
),
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
),
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
));
1060 send_start(gspca_dev
);
1064 if (sd
->sensor
== SENSOR_MT9V111
)
1065 gpio_set(sd
, SQ930_GPIO_DFL_LED
, SQ930_GPIO_DFL_LED
);
1067 sd
->do_ctrl
= 1; /* set the exposure */
1069 return gspca_dev
->usb_err
;
1072 static void sd_stopN(struct gspca_dev
*gspca_dev
)
1074 struct sd
*sd
= (struct sd
*) gspca_dev
;
1076 if (sd
->sensor
== SENSOR_MT9V111
)
1077 gpio_set(sd
, 0, SQ930_GPIO_DFL_LED
);
1078 send_stop(gspca_dev
);
1081 /* function called when the application gets a new frame */
1082 /* It sets the exposure if required and restart the bulk transfer. */
1083 static void sd_dq_callback(struct gspca_dev
*gspca_dev
)
1085 struct sd
*sd
= (struct sd
*) gspca_dev
;
1088 if (!sd
->do_ctrl
|| gspca_dev
->cam
.bulk_nurbs
!= 0)
1092 setexposure(gspca_dev
);
1094 gspca_dev
->cam
.bulk_nurbs
= 1;
1095 ret
= usb_submit_urb(gspca_dev
->urb
[0], GFP_ATOMIC
);
1097 pr_err("sd_dq_callback() err %d\n", ret
);
1099 /* wait a little time, otherwise the webcam crashes */
1103 static void sd_pkt_scan(struct gspca_dev
*gspca_dev
,
1104 u8
*data
, /* isoc packet */
1105 int len
) /* iso packet length */
1107 struct sd
*sd
= (struct sd
*) gspca_dev
;
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);
1116 static int sd_setgain(struct gspca_dev
*gspca_dev
, __s32 val
)
1118 struct sd
*sd
= (struct sd
*) gspca_dev
;
1121 if (gspca_dev
->streaming
)
1126 static int sd_getgain(struct gspca_dev
*gspca_dev
, __s32
*val
)
1128 struct sd
*sd
= (struct sd
*) gspca_dev
;
1133 static int sd_setexpo(struct gspca_dev
*gspca_dev
, __s32 val
)
1135 struct sd
*sd
= (struct sd
*) gspca_dev
;
1138 if (gspca_dev
->streaming
)
1143 static int sd_getexpo(struct gspca_dev
*gspca_dev
, __s32
*val
)
1145 struct sd
*sd
= (struct sd
*) gspca_dev
;
1151 /* sub-driver description */
1152 static const struct sd_desc sd_desc
= {
1153 .name
= MODULE_NAME
,
1155 .nctrls
= ARRAY_SIZE(sd_ctrls
),
1156 .config
= sd_config
,
1158 .isoc_init
= sd_isoc_init
,
1161 .pkt_scan
= sd_pkt_scan
,
1162 .dq_callback
= sd_dq_callback
,
1165 /* Table of supported USB devices */
1166 #define ST(sensor, type) \
1167 .driver_info = (SENSOR_ ## sensor << 8) \
1169 static 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)},
1178 MODULE_DEVICE_TABLE(usb
, device_table
);
1181 /* -- device connect -- */
1182 static int sd_probe(struct usb_interface
*intf
,
1183 const struct usb_device_id
*id
)
1185 return gspca_dev_probe(intf
, id
, &sd_desc
, sizeof(struct sd
),
1189 static struct usb_driver sd_driver
= {
1190 .name
= MODULE_NAME
,
1191 .id_table
= device_table
,
1193 .disconnect
= gspca_disconnect
,
1195 .suspend
= gspca_suspend
,
1196 .resume
= gspca_resume
,
1200 /* -- module insert / remove -- */
1201 static int __init
sd_mod_init(void)
1203 return usb_register(&sd_driver
);
1205 static void __exit
sd_mod_exit(void)
1207 usb_deregister(&sd_driver
);
1210 module_init(sd_mod_init
);
1211 module_exit(sd_mod_exit
);