Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/media/usb/gspca/sq930x.c

  1 /*
  2  * SQ930x subdriver
  3  *
  4  * Copyright (C) 2010 Jean-Fran├žois Moine <http://moinejf.free.fr>
  5  * Copyright (C) 2006 -2008 Gerard Klaver <gerard at gkall dot hobby dot nl>
  6  * Copyright (C) 2007 Sam Revitch <samr7@cs.washington.edu>
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License as published by
 10  * the Free Software Foundation; either version 2 of the License, or
 11  * any later version.
 12  *
 13  * This program is distributed in the hope that it will be useful,
 14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 16  * GNU General Public License for more details.
 17  *
 18  * You should have received a copy of the GNU General Public License
 19  * along with this program; if not, write to the Free Software
 20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 21  */
 22 
 23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 24 
 25 #define MODULE_NAME "sq930x"
 26 
 27 #include "gspca.h"
 28 
 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");
 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 
 44         u8 do_ctrl;
 45         u8 gpio[2];
 46         u8 sensor;
 47         u8 type;
 48 #define Generic 0
 49 #define Creative_live_motion 1
 50 };
 51 enum sensors {
 52         SENSOR_ICX098BQ,
 53         SENSOR_LZ24BP,
 54         SENSOR_MI0360,
 55         SENSOR_MT9V111,         /* = MI360SOC */
 56         SENSOR_OV7660,
 57         SENSOR_OV9630,
 58 };
 59 
 60 static struct v4l2_pix_format vga_mode[] = {
 61         {320, 240, V4L2_PIX_FMT_SRGGB8, V4L2_FIELD_NONE,
 62                 .bytesperline = 320,
 63                 .sizeimage = 320 * 240,
 64                 .colorspace = V4L2_COLORSPACE_SRGB,
 65                 .priv = 0},
 66         {640, 480, V4L2_PIX_FMT_SRGGB8, V4L2_FIELD_NONE,
 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 
 93 struct ucbus_write_cmd {
 94         u16     bw_addr;
 95         u8      bw_data;
 96 };
 97 struct i2c_write_cmd {
 98         u8      reg;
 99         u16     val;
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;
349         u8 i2c_addr;
350         u8 i2c_dum;
351         u8 gpio[5];
352         u8 cmd_len;
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,
361                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
362                  SQ930_GPIO_DFL_I2C_SDA,
363                  0,
364                  SQ930_GPIO_RSTBAR
365                 },
366                 8, icx098bq_start_0
367             },
368         [SENSOR_LZ24BP] = {
369                 "lz24bp",
370                 0x00, 0x00,
371                 {0,
372                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
373                  SQ930_GPIO_DFL_I2C_SDA,
374                  0,
375                  SQ930_GPIO_RSTBAR
376                 },
377                 8, lz24bp_start_0
378             },
379         [SENSOR_MI0360] = {
380                 "mi0360",
381                 0x5d, 0x80,
382                 {SQ930_GPIO_RSTBAR,
383                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
384                  SQ930_GPIO_DFL_I2C_SDA,
385                  0,
386                  0
387                 },
388                 7, mi0360_start_0
389             },
390         [SENSOR_MT9V111] = {
391                 "mt9v111",
392                 0x5c, 0x7f,
393                 {SQ930_GPIO_RSTBAR,
394                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
395                  SQ930_GPIO_DFL_I2C_SDA,
396                  0,
397                  0
398                 },
399                 7, mi0360_start_0
400             },
401         [SENSOR_OV7660] = {
402                 "ov7660",
403                 0x21, 0x00,
404                 {0,
405                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
406                  SQ930_GPIO_DFL_I2C_SDA,
407                  0,
408                  SQ930_GPIO_RSTBAR
409                 },
410                 7, ov7660_start_0
411             },
412         [SENSOR_OV9630] = {
413                 "ov9630",
414                 0x30, 0x00,
415                 {0,
416                  SQ930_GPIO_DFL_I2C_SDA | SQ930_GPIO_DFL_I2C_SCL,
417                  SQ930_GPIO_DFL_I2C_SDA,
418                  0,
419                  SQ930_GPIO_RSTBAR
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,
435                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
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 */
454                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
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 */
477                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
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 */
522                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
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         if ((batchsize - 1) * 3 > USB_BUF_SZ) {
545                 PERR("Bug: usb_buf overflow\n");
546                 gspca_dev->usb_err = -ENOMEM;
547                 return;
548         }
549 
550         for (;;) {
551                 len = ncmds;
552                 if (len > batchsize)
553                         len = batchsize;
554                 ncmds -= len;
555 
556                 val = (cmd->bw_addr << 8) | SQ930_CTRL_UCBUS_IO;
557                 idx = (cmd->bw_data << 8) | (cmd->bw_addr >> 8);
558 
559                 buf = gspca_dev->usb_buf;
560                 while (--len > 0) {
561                         cmd++;
562                         *buf++ = cmd->bw_addr;
563                         *buf++ = cmd->bw_addr >> 8;
564                         *buf++ = cmd->bw_data;
565                 }
566                 if (buf != gspca_dev->usb_buf)
567                         PDEBUG(D_USBO, "ucbus v: %04x i: %04x %02x...%02x",
568                                         val, idx,
569                                         gspca_dev->usb_buf[0], buf[-1]);
570                 else
571                         PDEBUG(D_USBO, "ucbus v: %04x i: %04x",
572                                         val, idx);
573                 ret = usb_control_msg(gspca_dev->dev,
574                                 usb_sndctrlpipe(gspca_dev->dev, 0),
575                                 0x0c,                   /* request */
576                            USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
577                                 val, idx,
578                                 gspca_dev->usb_buf, buf - gspca_dev->usb_buf,
579                                 500);
580                 if (ret < 0) {
581                         pr_err("ucbus_write failed %d\n", ret);
582                         gspca_dev->usb_err = ret;
583                         return;
584                 }
585                 msleep(30);
586                 if (ncmds <= 0)
587                         break;
588                 cmd++;
589         }
590 }
591 
592 static void gpio_set(struct sd *sd, u16 val, u16 mask)
593 {
594         struct gspca_dev *gspca_dev = &sd->gspca_dev;
595 
596         if (mask & 0x00ff) {
597                 sd->gpio[0] &= ~mask;
598                 sd->gpio[0] |= val;
599                 reg_w(gspca_dev, 0x0100 | SQ930_CTRL_GPIO,
600                         ~sd->gpio[0] << 8);
601         }
602         mask >>= 8;
603         val >>= 8;
604         if (mask) {
605                 sd->gpio[1] &= ~mask;
606                 sd->gpio[1] |= val;
607                 reg_w(gspca_dev, 0x0300 | SQ930_CTRL_GPIO,
608                         ~sd->gpio[1] << 8);
609         }
610 }
611 
612 static void gpio_init(struct sd *sd,
613                         const u8 *gpio)
614 {
615         gpio_set(sd, *gpio++, 0x000f);
616         gpio_set(sd, *gpio++, 0x000f);
617         gpio_set(sd, *gpio++, 0x000f);
618         gpio_set(sd, *gpio++, 0x000f);
619         gpio_set(sd, *gpio, 0x000f);
620 }
621 
622 static void bridge_init(struct sd *sd)
623 {
624         static const struct ucbus_write_cmd clkfreq_cmd = {
625                                 0xf031, 0       /* SQ930_CLKFREQ_60MHZ */
626         };
627 
628         ucbus_write(&sd->gspca_dev, &clkfreq_cmd, 1, 1);
629 
630         gpio_set(sd, SQ930_GPIO_POWER, 0xff00);
631 }
632 
633 static void cmos_probe(struct gspca_dev *gspca_dev)
634 {
635         struct sd *sd = (struct sd *) gspca_dev;
636         int i;
637         const struct sensor_s *sensor;
638         static const u8 probe_order[] = {
639 /*              SENSOR_LZ24BP,          (tested as ccd) */
640                 SENSOR_OV9630,
641                 SENSOR_MI0360,
642                 SENSOR_OV7660,
643                 SENSOR_MT9V111,
644         };
645 
646         for (i = 0; i < ARRAY_SIZE(probe_order); i++) {
647                 sensor = &sensor_tb[probe_order[i]];
648                 ucbus_write(&sd->gspca_dev, sensor->cmd, sensor->cmd_len, 8);
649                 gpio_init(sd, sensor->gpio);
650                 msleep(100);
651                 reg_r(gspca_dev, (sensor->i2c_addr << 8) | 0x001c, 1);
652                 msleep(100);
653                 if (gspca_dev->usb_buf[0] != 0)
654                         break;
655         }
656         if (i >= ARRAY_SIZE(probe_order)) {
657                 pr_err("Unknown sensor\n");
658                 gspca_dev->usb_err = -EINVAL;
659                 return;
660         }
661         sd->sensor = probe_order[i];
662         switch (sd->sensor) {
663         case SENSOR_OV7660:
664         case SENSOR_OV9630:
665                 pr_err("Sensor %s not yet treated\n",
666                        sensor_tb[sd->sensor].name);
667                 gspca_dev->usb_err = -EINVAL;
668                 break;
669         }
670 }
671 
672 static void mt9v111_init(struct gspca_dev *gspca_dev)
673 {
674         int i, nwait;
675         static const u8 cmd_001b[] = {
676                 0x00, 0x3b, 0xf6, 0x01, 0x03, 0x02, 0x00, 0x00,
677                 0x00, 0x00, 0x00
678         };
679         static const u8 cmd_011b[][7] = {
680                 {0x10, 0x01, 0x66, 0x08, 0x00, 0x00, 0x00},
681                 {0x01, 0x00, 0x1a, 0x04, 0x00, 0x00, 0x00},
682                 {0x20, 0x00, 0x10, 0x04, 0x00, 0x00, 0x00},
683                 {0x02, 0x01, 0xae, 0x01, 0x00, 0x00, 0x00},
684         };
685 
686         reg_wb(gspca_dev, 0x001b, 0x0000, cmd_001b, sizeof cmd_001b);
687         for (i = 0; i < ARRAY_SIZE(cmd_011b); i++) {
688                 reg_wb(gspca_dev, 0x001b, 0x0000, cmd_011b[i],
689                                 ARRAY_SIZE(cmd_011b[0]));
690                 msleep(400);
691                 nwait = 20;
692                 for (;;) {
693                         reg_r(gspca_dev, 0x031b, 1);
694                         if (gspca_dev->usb_buf[0] == 0
695                          || gspca_dev->usb_err != 0)
696                                 break;
697                         if (--nwait < 0) {
698                                 PDEBUG(D_PROBE, "mt9v111_init timeout");
699                                 gspca_dev->usb_err = -ETIME;
700                                 return;
701                         }
702                         msleep(50);
703                 }
704         }
705 }
706 
707 static void global_init(struct sd *sd, int first_time)
708 {
709         switch (sd->sensor) {
710         case SENSOR_ICX098BQ:
711                 if (first_time)
712                         ucbus_write(&sd->gspca_dev,
713                                         icx098bq_start_0,
714                                         8, 8);
715                 gpio_init(sd, sensor_tb[sd->sensor].gpio);
716                 break;
717         case SENSOR_LZ24BP:
718                 if (sd->type != Creative_live_motion)
719                         gpio_set(sd, SQ930_GPIO_EXTRA1, 0x00ff);
720                 else
721                         gpio_set(sd, 0, 0x00ff);
722                 msleep(50);
723                 if (first_time)
724                         ucbus_write(&sd->gspca_dev,
725                                         lz24bp_start_0,
726                                         8, 8);
727                 gpio_init(sd, sensor_tb[sd->sensor].gpio);
728                 break;
729         case SENSOR_MI0360:
730                 if (first_time)
731                         ucbus_write(&sd->gspca_dev,
732                                         mi0360_start_0,
733                                         ARRAY_SIZE(mi0360_start_0),
734                                         8);
735                 gpio_init(sd, sensor_tb[sd->sensor].gpio);
736                 gpio_set(sd, SQ930_GPIO_EXTRA2, SQ930_GPIO_EXTRA2);
737                 break;
738         default:
739 /*      case SENSOR_MT9V111: */
740                 if (first_time)
741                         mt9v111_init(&sd->gspca_dev);
742                 else
743                         gpio_init(sd, sensor_tb[sd->sensor].gpio);
744                 break;
745         }
746 }
747 
748 static void lz24bp_ppl(struct sd *sd, u16 ppl)
749 {
750         struct ucbus_write_cmd cmds[2] = {
751                 {0xf810, ppl >> 8},
752                 {0xf811, ppl}
753         };
754 
755         ucbus_write(&sd->gspca_dev, cmds, ARRAY_SIZE(cmds), 2);
756 }
757 
758 static void setexposure(struct gspca_dev *gspca_dev, s32 expo, s32 gain)
759 {
760         struct sd *sd = (struct sd *) gspca_dev;
761         int i, integclks, intstartclk, frameclks, min_frclk;
762         const struct sensor_s *sensor;
763         u16 cmd;
764         u8 buf[15];
765 
766         integclks = expo;
767         i = 0;
768         cmd = SQ930_CTRL_SET_EXPOSURE;
769 
770         switch (sd->sensor) {
771         case SENSOR_ICX098BQ:                   /* ccd */
772         case SENSOR_LZ24BP:
773                 min_frclk = sd->sensor == SENSOR_ICX098BQ ? 0x210 : 0x26f;
774                 if (integclks >= min_frclk) {
775                         intstartclk = 0;
776                         frameclks = integclks;
777                 } else {
778                         intstartclk = min_frclk - integclks;
779                         frameclks = min_frclk;
780                 }
781                 buf[i++] = intstartclk >> 8;
782                 buf[i++] = intstartclk;
783                 buf[i++] = frameclks >> 8;
784                 buf[i++] = frameclks;
785                 buf[i++] = gain;
786                 break;
787         default:                                /* cmos */
788 /*      case SENSOR_MI0360: */
789 /*      case SENSOR_MT9V111: */
790                 cmd |= 0x0100;
791                 sensor = &sensor_tb[sd->sensor];
792                 buf[i++] = sensor->i2c_addr;    /* i2c_slave_addr */
793                 buf[i++] = 0x08;        /* 2 * ni2c */
794                 buf[i++] = 0x09;        /* reg = shutter width */
795                 buf[i++] = integclks >> 8; /* val H */
796                 buf[i++] = sensor->i2c_dum;
797                 buf[i++] = integclks;   /* val L */
798                 buf[i++] = 0x35;        /* reg = global gain */
799                 buf[i++] = 0x00;        /* val H */
800                 buf[i++] = sensor->i2c_dum;
801                 buf[i++] = 0x80 + gain / 2; /* val L */
802                 buf[i++] = 0x00;
803                 buf[i++] = 0x00;
804                 buf[i++] = 0x00;
805                 buf[i++] = 0x00;
806                 buf[i++] = 0x83;
807                 break;
808         }
809         reg_wb(gspca_dev, cmd, 0, buf, i);
810 }
811 
812 /* This function is called at probe time just before sd_init */
813 static int sd_config(struct gspca_dev *gspca_dev,
814                 const struct usb_device_id *id)
815 {
816         struct sd *sd = (struct sd *) gspca_dev;
817         struct cam *cam = &gspca_dev->cam;
818 
819         sd->sensor = id->driver_info >> 8;
820         sd->type = id->driver_info;
821 
822         cam->cam_mode = vga_mode;
823         cam->nmodes = ARRAY_SIZE(vga_mode);
824 
825         cam->bulk = 1;
826 
827         return 0;
828 }
829 
830 /* this function is called at probe and resume time */
831 static int sd_init(struct gspca_dev *gspca_dev)
832 {
833         struct sd *sd = (struct sd *) gspca_dev;
834 
835         sd->gpio[0] = sd->gpio[1] = 0xff;       /* force gpio rewrite */
836 
837 /*fixme: is this needed for icx098bp and mi0360?
838         if (sd->sensor != SENSOR_LZ24BP)
839                 reg_w(gspca_dev, SQ930_CTRL_RESET, 0x0000);
840  */
841 
842         reg_r(gspca_dev, SQ930_CTRL_GET_DEV_INFO, 8);
843         if (gspca_dev->usb_err < 0)
844                 return gspca_dev->usb_err;
845 
846 /* it returns:
847  * 03 00 12 93 0b f6 c9 00      live! ultra
848  * 03 00 07 93 0b f6 ca 00      live! ultra for notebook
849  * 03 00 12 93 0b fe c8 00      Trust WB-3500T
850  * 02 00 06 93 0b fe c8 00      Joy-IT 318S
851  * 03 00 12 93 0b f6 cf 00      icam tracer - sensor icx098bq
852  * 02 00 12 93 0b fe cf 00      ProQ Motion Webcam
853  *
854  * byte
855  * 0: 02 = usb 1.0 (12Mbit) / 03 = usb2.0 (480Mbit)
856  * 1: 00
857  * 2: 06 / 07 / 12 = mode webcam? firmware??
858  * 3: 93 chip = 930b (930b or 930c)
859  * 4: 0b
860  * 5: f6 = cdd (icx098bq, lz24bp) / fe or de = cmos (i2c) (other sensors)
861  * 6: c8 / c9 / ca / cf = mode webcam?, sensor? webcam?
862  * 7: 00
863  */
864         PDEBUG(D_PROBE, "info: %*ph", 8, gspca_dev->usb_buf);
865 
866         bridge_init(sd);
867 
868         if (sd->sensor == SENSOR_MI0360) {
869 
870                 /* no sensor probe for icam tracer */
871                 if (gspca_dev->usb_buf[5] == 0xf6)      /* if ccd */
872                         sd->sensor = SENSOR_ICX098BQ;
873                 else
874                         cmos_probe(gspca_dev);
875         }
876         if (gspca_dev->usb_err >= 0) {
877                 PDEBUG(D_PROBE, "Sensor %s", sensor_tb[sd->sensor].name);
878                 global_init(sd, 1);
879         }
880         return gspca_dev->usb_err;
881 }
882 
883 /* send the start/stop commands to the webcam */
884 static void send_start(struct gspca_dev *gspca_dev)
885 {
886         struct sd *sd = (struct sd *) gspca_dev;
887         const struct cap_s *cap;
888         int mode;
889 
890         mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
891         cap = &capconfig[sd->sensor][mode];
892         reg_wb(gspca_dev, 0x0900 | SQ930_CTRL_CAP_START,
893                         0x0a00 | cap->cc_sizeid,
894                         cap->cc_bytes, 32);
895 }
896 
897 static void send_stop(struct gspca_dev *gspca_dev)
898 {
899         reg_w(gspca_dev, SQ930_CTRL_CAP_STOP, 0);
900 }
901 
902 /* function called at start time before URB creation */
903 static int sd_isoc_init(struct gspca_dev *gspca_dev)
904 {
905         struct sd *sd = (struct sd *) gspca_dev;
906 
907         gspca_dev->cam.bulk_nurbs = 1;  /* there must be one URB only */
908         sd->do_ctrl = 0;
909         gspca_dev->cam.bulk_size = gspca_dev->pixfmt.width *
910                         gspca_dev->pixfmt.height + 8;
911         return 0;
912 }
913 
914 /* start the capture */
915 static int sd_start(struct gspca_dev *gspca_dev)
916 {
917         struct sd *sd = (struct sd *) gspca_dev;
918         int mode;
919 
920         bridge_init(sd);
921         global_init(sd, 0);
922         msleep(100);
923 
924         switch (sd->sensor) {
925         case SENSOR_ICX098BQ:
926                 ucbus_write(gspca_dev, icx098bq_start_0,
927                                 ARRAY_SIZE(icx098bq_start_0),
928                                 8);
929                 ucbus_write(gspca_dev, icx098bq_start_1,
930                                 ARRAY_SIZE(icx098bq_start_1),
931                                 5);
932                 ucbus_write(gspca_dev, icx098bq_start_2,
933                                 ARRAY_SIZE(icx098bq_start_2),
934                                 6);
935                 msleep(50);
936 
937                 /* 1st start */
938                 send_start(gspca_dev);
939                 gpio_set(sd, SQ930_GPIO_EXTRA2 | SQ930_GPIO_RSTBAR, 0x00ff);
940                 msleep(70);
941                 reg_w(gspca_dev, SQ930_CTRL_CAP_STOP, 0x0000);
942                 gpio_set(sd, 0x7f, 0x00ff);
943 
944                 /* 2nd start */
945                 send_start(gspca_dev);
946                 gpio_set(sd, SQ930_GPIO_EXTRA2 | SQ930_GPIO_RSTBAR, 0x00ff);
947                 goto out;
948         case SENSOR_LZ24BP:
949                 ucbus_write(gspca_dev, lz24bp_start_0,
950                                 ARRAY_SIZE(lz24bp_start_0),
951                                 8);
952                 if (sd->type != Creative_live_motion)
953                         ucbus_write(gspca_dev, lz24bp_start_1_gen,
954                                         ARRAY_SIZE(lz24bp_start_1_gen),
955                                         5);
956                 else
957                         ucbus_write(gspca_dev, lz24bp_start_1_clm,
958                                         ARRAY_SIZE(lz24bp_start_1_clm),
959                                         5);
960                 ucbus_write(gspca_dev, lz24bp_start_2,
961                                 ARRAY_SIZE(lz24bp_start_2),
962                                 6);
963                 mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
964                 lz24bp_ppl(sd, mode == 1 ? 0x0564 : 0x0310);
965                 msleep(10);
966                 break;
967         case SENSOR_MI0360:
968                 ucbus_write(gspca_dev, mi0360_start_0,
969                                 ARRAY_SIZE(mi0360_start_0),
970                                 8);
971                 i2c_write(sd, mi0360_init_23,
972                                 ARRAY_SIZE(mi0360_init_23));
973                 i2c_write(sd, mi0360_init_24,
974                                 ARRAY_SIZE(mi0360_init_24));
975                 i2c_write(sd, mi0360_init_25,
976                                 ARRAY_SIZE(mi0360_init_25));
977                 ucbus_write(gspca_dev, mi0360_start_1,
978                                 ARRAY_SIZE(mi0360_start_1),
979                                 5);
980                 i2c_write(sd, mi0360_start_2,
981                                 ARRAY_SIZE(mi0360_start_2));
982                 i2c_write(sd, mi0360_start_3,
983                                 ARRAY_SIZE(mi0360_start_3));
984 
985                 /* 1st start */
986                 send_start(gspca_dev);
987                 msleep(60);
988                 send_stop(gspca_dev);
989 
990                 i2c_write(sd,
991                         mi0360_start_4, ARRAY_SIZE(mi0360_start_4));
992                 break;
993         default:
994 /*      case SENSOR_MT9V111: */
995                 ucbus_write(gspca_dev, mi0360_start_0,
996                                 ARRAY_SIZE(mi0360_start_0),
997                                 8);
998                 i2c_write(sd, mt9v111_init_0,
999                                 ARRAY_SIZE(mt9v111_init_0));
1000                 i2c_write(sd, mt9v111_init_1,
1001                                 ARRAY_SIZE(mt9v111_init_1));
1002                 i2c_write(sd, mt9v111_init_2,
1003                                 ARRAY_SIZE(mt9v111_init_2));
1004                 ucbus_write(gspca_dev, mt9v111_start_1,
1005                                 ARRAY_SIZE(mt9v111_start_1),
1006                                 5);
1007                 i2c_write(sd, mt9v111_init_3,
1008                                 ARRAY_SIZE(mt9v111_init_3));
1009                 i2c_write(sd, mt9v111_init_4,
1010                                 ARRAY_SIZE(mt9v111_init_4));
1011                 break;
1012         }
1013 
1014         send_start(gspca_dev);
1015 out:
1016         msleep(1000);
1017 
1018         if (sd->sensor == SENSOR_MT9V111)
1019                 gpio_set(sd, SQ930_GPIO_DFL_LED, SQ930_GPIO_DFL_LED);
1020 
1021         sd->do_ctrl = 1;        /* set the exposure */
1022 
1023         return gspca_dev->usb_err;
1024 }
1025 
1026 static void sd_stopN(struct gspca_dev *gspca_dev)
1027 {
1028         struct sd *sd = (struct sd *) gspca_dev;
1029 
1030         if (sd->sensor == SENSOR_MT9V111)
1031                 gpio_set(sd, 0, SQ930_GPIO_DFL_LED);
1032         send_stop(gspca_dev);
1033 }
1034 
1035 /* function called when the application gets a new frame */
1036 /* It sets the exposure if required and restart the bulk transfer. */
1037 static void sd_dq_callback(struct gspca_dev *gspca_dev)
1038 {
1039         struct sd *sd = (struct sd *) gspca_dev;
1040         int ret;
1041 
1042         if (!sd->do_ctrl || gspca_dev->cam.bulk_nurbs != 0)
1043                 return;
1044         sd->do_ctrl = 0;
1045 
1046         setexposure(gspca_dev, v4l2_ctrl_g_ctrl(sd->exposure),
1047                         v4l2_ctrl_g_ctrl(sd->gain));
1048 
1049         gspca_dev->cam.bulk_nurbs = 1;
1050         ret = usb_submit_urb(gspca_dev->urb[0], GFP_ATOMIC);
1051         if (ret < 0)
1052                 pr_err("sd_dq_callback() err %d\n", ret);
1053 
1054         /* wait a little time, otherwise the webcam crashes */
1055         msleep(100);
1056 }
1057 
1058 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1059                         u8 *data,               /* isoc packet */
1060                         int len)                /* iso packet length */
1061 {
1062         struct sd *sd = (struct sd *) gspca_dev;
1063 
1064         if (sd->do_ctrl)
1065                 gspca_dev->cam.bulk_nurbs = 0;
1066         gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
1067         gspca_frame_add(gspca_dev, INTER_PACKET, data, len - 8);
1068         gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
1069 }
1070 
1071 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
1072 {
1073         struct gspca_dev *gspca_dev =
1074                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
1075         struct sd *sd = (struct sd *) gspca_dev;
1076 
1077         gspca_dev->usb_err = 0;
1078 
1079         if (!gspca_dev->streaming)
1080                 return 0;
1081 
1082         switch (ctrl->id) {
1083         case V4L2_CID_EXPOSURE:
1084                 setexposure(gspca_dev, ctrl->val, sd->gain->val);
1085                 break;
1086         }
1087         return gspca_dev->usb_err;
1088 }
1089 
1090 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
1091         .s_ctrl = sd_s_ctrl,
1092 };
1093 
1094 static int sd_init_controls(struct gspca_dev *gspca_dev)
1095 {
1096         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
1097         struct sd *sd = (struct sd *) gspca_dev;
1098 
1099         gspca_dev->vdev.ctrl_handler = hdl;
1100         v4l2_ctrl_handler_init(hdl, 2);
1101         sd->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1102                         V4L2_CID_EXPOSURE, 1, 0xfff, 1, 0x356);
1103         sd->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1104                         V4L2_CID_GAIN, 1, 255, 1, 0x8d);
1105 
1106         if (hdl->error) {
1107                 pr_err("Could not initialize controls\n");
1108                 return hdl->error;
1109         }
1110         v4l2_ctrl_cluster(2, &sd->exposure);
1111         return 0;
1112 }
1113 
1114 /* sub-driver description */
1115 static const struct sd_desc sd_desc = {
1116         .name   = MODULE_NAME,
1117         .config = sd_config,
1118         .init   = sd_init,
1119         .init_controls = sd_init_controls,
1120         .isoc_init = sd_isoc_init,
1121         .start  = sd_start,
1122         .stopN  = sd_stopN,
1123         .pkt_scan = sd_pkt_scan,
1124         .dq_callback = sd_dq_callback,
1125 };
1126 
1127 /* Table of supported USB devices */
1128 #define ST(sensor, type) \
1129         .driver_info = (SENSOR_ ## sensor << 8) \
1130                         | (type)
1131 static const struct usb_device_id device_table[] = {
1132         {USB_DEVICE(0x041e, 0x4038), ST(MI0360, 0)},
1133         {USB_DEVICE(0x041e, 0x403c), ST(LZ24BP, 0)},
1134         {USB_DEVICE(0x041e, 0x403d), ST(LZ24BP, 0)},
1135         {USB_DEVICE(0x041e, 0x4041), ST(LZ24BP, Creative_live_motion)},
1136         {USB_DEVICE(0x2770, 0x930b), ST(MI0360, 0)},
1137         {USB_DEVICE(0x2770, 0x930c), ST(MI0360, 0)},
1138         {}
1139 };
1140 MODULE_DEVICE_TABLE(usb, device_table);
1141 
1142 
1143 /* -- device connect -- */
1144 static int sd_probe(struct usb_interface *intf,
1145                 const struct usb_device_id *id)
1146 {
1147         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1148                         THIS_MODULE);
1149 }
1150 
1151 static struct usb_driver sd_driver = {
1152         .name       = MODULE_NAME,
1153         .id_table   = device_table,
1154         .probe      = sd_probe,
1155         .disconnect = gspca_disconnect,
1156 #ifdef CONFIG_PM
1157         .suspend    = gspca_suspend,
1158         .resume     = gspca_resume,
1159         .reset_resume = gspca_resume,
1160 #endif
1161 };
1162 
1163 module_usb_driver(sd_driver);
1164 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us