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