1
2
3
4
5
6
7
8
9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11#define MODULE_NAME "sonixj"
12
13#include <linux/input.h>
14#include "gspca.h"
15#include "jpeg.h"
16
17MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
18MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver");
19MODULE_LICENSE("GPL");
20
21
22struct sd {
23 struct gspca_dev gspca_dev;
24
25 atomic_t avg_lum;
26 struct v4l2_ctrl *brightness;
27 struct v4l2_ctrl *contrast;
28 struct v4l2_ctrl *saturation;
29 struct {
30 struct v4l2_ctrl *red_bal;
31 struct v4l2_ctrl *blue_bal;
32 };
33 struct {
34 struct v4l2_ctrl *vflip;
35 struct v4l2_ctrl *hflip;
36 };
37 struct v4l2_ctrl *gamma;
38 struct v4l2_ctrl *illum;
39 struct v4l2_ctrl *sharpness;
40 struct v4l2_ctrl *freq;
41 u32 exposure;
42
43 struct work_struct work;
44
45 u32 pktsz;
46 u16 npkt;
47 s8 nchg;
48 s8 short_mark;
49
50 u8 quality;
51#define QUALITY_MIN 25
52#define QUALITY_MAX 90
53#define QUALITY_DEF 70
54
55 u8 reg01;
56 u8 reg17;
57 u8 reg18;
58 u8 flags;
59
60 s8 ag_cnt;
61#define AG_CNT_START 13
62
63 u8 bridge;
64#define BRIDGE_SN9C102P 0
65#define BRIDGE_SN9C105 1
66#define BRIDGE_SN9C110 2
67#define BRIDGE_SN9C120 3
68 u8 sensor;
69 u8 i2c_addr;
70
71 u8 jpeg_hdr[JPEG_HDR_SZ];
72};
73enum sensors {
74 SENSOR_ADCM1700,
75 SENSOR_GC0307,
76 SENSOR_HV7131R,
77 SENSOR_MI0360,
78 SENSOR_MI0360B,
79 SENSOR_MO4000,
80 SENSOR_MT9V111,
81 SENSOR_OM6802,
82 SENSOR_OV7630,
83 SENSOR_OV7648,
84 SENSOR_OV7660,
85 SENSOR_PO1030,
86 SENSOR_PO2030N,
87 SENSOR_SOI768,
88 SENSOR_SP80708,
89};
90
91static void qual_upd(struct work_struct *work);
92
93
94#define F_PDN_INV 0x01
95#define F_ILLUM 0x02
96
97
98
99#define S_PWR_DN 0x01
100#define S_PDN_INV 0x02
101#define V_TX_EN 0x04
102#define LED 0x08
103#define SCL_SEL_OD 0x20
104#define SYS_SEL_48M 0x40
105
106#define MCK_SIZE_MASK 0x1f
107#define SEN_CLK_EN 0x20
108#define DEF_EN 0x80
109
110static const struct v4l2_pix_format cif_mode[] = {
111 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
112 .bytesperline = 352,
113 .sizeimage = 352 * 288 * 4 / 8 + 590,
114 .colorspace = V4L2_COLORSPACE_JPEG,
115 .priv = 0},
116};
117static const struct v4l2_pix_format vga_mode[] = {
118 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
119 .bytesperline = 160,
120 .sizeimage = 160 * 120 * 4 / 8 + 590,
121 .colorspace = V4L2_COLORSPACE_JPEG,
122 .priv = 2},
123 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
124 .bytesperline = 320,
125 .sizeimage = 320 * 240 * 3 / 8 + 590,
126 .colorspace = V4L2_COLORSPACE_JPEG,
127 .priv = 1},
128 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
129 .bytesperline = 640,
130
131 .sizeimage = 640 * 480 * 3 / 4 + 590,
132 .colorspace = V4L2_COLORSPACE_JPEG,
133 .priv = 0},
134};
135
136static const u8 sn_adcm1700[0x1c] = {
137
138 0x00, 0x43, 0x60, 0x00, 0x1a, 0x00, 0x00, 0x00,
139
140 0x80, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
141
142 0x03, 0x00, 0x05, 0x01, 0x05, 0x16, 0x12, 0x42,
143
144 0x06, 0x00, 0x00, 0x00
145};
146
147static const u8 sn_gc0307[0x1c] = {
148
149 0x00, 0x61, 0x62, 0x00, 0x1a, 0x00, 0x00, 0x00,
150
151 0x80, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
152
153 0x03, 0x00, 0x03, 0x01, 0x08, 0x28, 0x1e, 0x02,
154
155 0x06, 0x00, 0x00, 0x00
156};
157
158static const u8 sn_hv7131[0x1c] = {
159
160 0x00, 0x03, 0x60, 0x00, 0x1a, 0x20, 0x20, 0x20,
161
162 0x81, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
163
164 0x03, 0x00, 0x00, 0x01, 0x03, 0x28, 0x1e, 0x41,
165
166 0x0a, 0x00, 0x00, 0x00
167};
168
169static const u8 sn_mi0360[0x1c] = {
170
171 0x00, 0x63, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
172
173 0x81, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
174
175 0x03, 0x00, 0x00, 0x02, 0x0a, 0x28, 0x1e, 0x61,
176
177 0x06, 0x00, 0x00, 0x00
178};
179
180static const u8 sn_mi0360b[0x1c] = {
181
182 0x00, 0x61, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
183
184 0x81, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
185
186 0x03, 0x00, 0x00, 0x02, 0x0a, 0x28, 0x1e, 0x40,
187
188 0x06, 0x00, 0x00, 0x00
189};
190
191static const u8 sn_mo4000[0x1c] = {
192
193 0x00, 0x23, 0x60, 0x00, 0x1a, 0x00, 0x20, 0x18,
194
195 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
196
197 0x03, 0x00, 0x0b, 0x0f, 0x14, 0x28, 0x1e, 0x40,
198
199 0x08, 0x00, 0x00, 0x00
200};
201
202static const u8 sn_mt9v111[0x1c] = {
203
204 0x00, 0x61, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
205
206 0x81, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
207
208 0x03, 0x00, 0x00, 0x02, 0x1c, 0x28, 0x1e, 0x40,
209
210 0x06, 0x00, 0x00, 0x00
211};
212
213static const u8 sn_om6802[0x1c] = {
214
215 0x00, 0x23, 0x72, 0x00, 0x1a, 0x20, 0x20, 0x19,
216
217 0x80, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
218
219 0x03, 0x00, 0x51, 0x01, 0x00, 0x28, 0x1e, 0x40,
220
221 0x05, 0x00, 0x00, 0x00
222};
223
224static const u8 sn_ov7630[0x1c] = {
225
226 0x00, 0x21, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
227
228 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
229
230 0x03, 0x00, 0x04, 0x01, 0x0a, 0x28, 0x1e, 0xc2,
231
232 0x0b, 0x00, 0x00, 0x00
233};
234
235static const u8 sn_ov7648[0x1c] = {
236
237 0x00, 0x63, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
238
239 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
240
241 0x03, 0x00, 0x00, 0x01, 0x00, 0x28, 0x1e, 0x00,
242
243 0x0b, 0x00, 0x00, 0x00
244};
245
246static const u8 sn_ov7660[0x1c] = {
247
248 0x00, 0x61, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
249
250 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
251
252 0x03, 0x00, 0x01, 0x01, 0x08, 0x28, 0x1e, 0x20,
253
254 0x07, 0x00, 0x00, 0x00
255};
256
257static const u8 sn_po1030[0x1c] = {
258
259 0x00, 0x21, 0x62, 0x00, 0x1a, 0x20, 0x20, 0x20,
260
261 0x81, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
262
263 0x03, 0x00, 0x00, 0x06, 0x06, 0x28, 0x1e, 0x00,
264
265 0x07, 0x00, 0x00, 0x00
266};
267
268static const u8 sn_po2030n[0x1c] = {
269
270 0x00, 0x63, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
271
272 0x81, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
273
274 0x03, 0x00, 0x00, 0x01, 0x14, 0x28, 0x1e, 0x00,
275
276 0x07, 0x00, 0x00, 0x00
277};
278
279static const u8 sn_soi768[0x1c] = {
280
281 0x00, 0x21, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
282
283 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
284
285 0x03, 0x00, 0x00, 0x01, 0x08, 0x28, 0x1e, 0x00,
286
287 0x07, 0x00, 0x00, 0x00
288};
289
290static const u8 sn_sp80708[0x1c] = {
291
292 0x00, 0x63, 0x60, 0x00, 0x1a, 0x20, 0x20, 0x20,
293
294 0x81, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
295
296 0x03, 0x00, 0x00, 0x03, 0x04, 0x28, 0x1e, 0x00,
297
298 0x07, 0x00, 0x00, 0x00
299};
300
301
302static const u8 *sn_tb[] = {
303[SENSOR_ADCM1700] = sn_adcm1700,
304[SENSOR_GC0307] = sn_gc0307,
305[SENSOR_HV7131R] = sn_hv7131,
306[SENSOR_MI0360] = sn_mi0360,
307[SENSOR_MI0360B] = sn_mi0360b,
308[SENSOR_MO4000] = sn_mo4000,
309[SENSOR_MT9V111] = sn_mt9v111,
310[SENSOR_OM6802] = sn_om6802,
311[SENSOR_OV7630] = sn_ov7630,
312[SENSOR_OV7648] = sn_ov7648,
313[SENSOR_OV7660] = sn_ov7660,
314[SENSOR_PO1030] = sn_po1030,
315[SENSOR_PO2030N] = sn_po2030n,
316[SENSOR_SOI768] = sn_soi768,
317[SENSOR_SP80708] = sn_sp80708,
318};
319
320
321static const u8 gamma_def[17] = {
322 0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
323 0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
324};
325
326static const u8 gamma_spec_0[17] = {
327 0x0f, 0x39, 0x5a, 0x74, 0x86, 0x95, 0xa6, 0xb4,
328 0xbd, 0xc4, 0xcc, 0xd4, 0xd5, 0xde, 0xe4, 0xed, 0xf5
329};
330
331static const u8 gamma_spec_1[17] = {
332 0x08, 0x3a, 0x52, 0x65, 0x75, 0x83, 0x91, 0x9d,
333 0xa9, 0xb4, 0xbe, 0xc8, 0xd2, 0xdb, 0xe4, 0xed, 0xf5
334};
335
336static const u8 gamma_spec_2[17] = {
337 0x14, 0x37, 0x50, 0x6a, 0x7c, 0x8d, 0x9d, 0xab,
338 0xb5, 0xbf, 0xc2, 0xcb, 0xd1, 0xd6, 0xdb, 0xe1, 0xeb
339};
340
341static const u8 gamma_spec_3[17] = {
342 0x0a, 0x2d, 0x4e, 0x68, 0x7d, 0x8f, 0x9f, 0xab,
343 0xb7, 0xc2, 0xcc, 0xd3, 0xd8, 0xde, 0xe2, 0xe5, 0xe6
344};
345
346
347static const u8 reg84[] = {
348 0x14, 0x00, 0x27, 0x00, 0x07, 0x00,
349 0xe8, 0x0f, 0xda, 0x0f, 0x40, 0x00,
350 0x3e, 0x00, 0xcd, 0x0f, 0xf7, 0x0f,
351 0x00, 0x00, 0x00
352};
353
354#define DELAY 0xdd
355
356static const u8 adcm1700_sensor_init[][8] = {
357 {0xa0, 0x51, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x10},
358 {0xb0, 0x51, 0x04, 0x08, 0x00, 0x00, 0x00, 0x10},
359 {DELAY, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
360 {0xb0, 0x51, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
361 {DELAY, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
362 {0xb0, 0x51, 0x0c, 0xe0, 0x2e, 0x00, 0x00, 0x10},
363 {0xb0, 0x51, 0x10, 0x02, 0x02, 0x00, 0x00, 0x10},
364 {0xb0, 0x51, 0x14, 0x0e, 0x0e, 0x00, 0x00, 0x10},
365 {0xb0, 0x51, 0x1c, 0x00, 0x80, 0x00, 0x00, 0x10},
366 {0xb0, 0x51, 0x20, 0x01, 0x00, 0x00, 0x00, 0x10},
367 {DELAY, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
368 {0xb0, 0x51, 0x04, 0x04, 0x00, 0x00, 0x00, 0x10},
369 {DELAY, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
370 {0xb0, 0x51, 0x04, 0x01, 0x00, 0x00, 0x00, 0x10},
371 {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
372 {0xb0, 0x51, 0x14, 0x01, 0x00, 0x00, 0x00, 0x10},
373 {0xb0, 0x51, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
374 {}
375};
376static const u8 adcm1700_sensor_param1[][8] = {
377 {0xb0, 0x51, 0x26, 0xf9, 0x01, 0x00, 0x00, 0x10},
378 {0xd0, 0x51, 0x1e, 0x8e, 0x8e, 0x8e, 0x8e, 0x10},
379
380 {0xa0, 0x51, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x10},
381 {0xb0, 0x51, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10},
382 {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
383 {0xb0, 0x51, 0x32, 0x00, 0x72, 0x00, 0x00, 0x10},
384 {0xd0, 0x51, 0x1e, 0xbe, 0xd7, 0xe8, 0xbe, 0x10},
385
386 {0xa0, 0x51, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x10},
387 {0xb0, 0x51, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10},
388 {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
389 {0xb0, 0x51, 0x32, 0x00, 0xa2, 0x00, 0x00, 0x10},
390 {}
391};
392static const u8 gc0307_sensor_init[][8] = {
393 {0xa0, 0x21, 0x43, 0x00, 0x00, 0x00, 0x00, 0x10},
394 {0xa0, 0x21, 0x44, 0xa2, 0x00, 0x00, 0x00, 0x10},
395 {0xa0, 0x21, 0x01, 0x6a, 0x00, 0x00, 0x00, 0x10},
396 {0xa0, 0x21, 0x02, 0x70, 0x00, 0x00, 0x00, 0x10},
397 {0xa0, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
398 {0xa0, 0x21, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
399 {0xa0, 0x21, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x10},
400 {0xa0, 0x21, 0x11, 0x05, 0x00, 0x00, 0x00, 0x10},
401 {0xa0, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
402 {0xa0, 0x21, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10},
403 {0xa0, 0x21, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10},
404 {0xa0, 0x21, 0x08, 0x02, 0x00, 0x00, 0x00, 0x10},
405 {0xa0, 0x21, 0x09, 0x01, 0x00, 0x00, 0x00, 0x10},
406 {0xa0, 0x21, 0x0a, 0xe8, 0x00, 0x00, 0x00, 0x10},
407 {0xa0, 0x21, 0x0b, 0x02, 0x00, 0x00, 0x00, 0x10},
408 {0xa0, 0x21, 0x0c, 0x80, 0x00, 0x00, 0x00, 0x10},
409 {0xa0, 0x21, 0x0d, 0x22, 0x00, 0x00, 0x00, 0x10},
410 {0xa0, 0x21, 0x0e, 0x02, 0x00, 0x00, 0x00, 0x10},
411 {0xa0, 0x21, 0x0f, 0xb2, 0x00, 0x00, 0x00, 0x10},
412 {0xa0, 0x21, 0x12, 0x70, 0x00, 0x00, 0x00, 0x10},
413 {DELAY, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
414 {0xa0, 0x21, 0x13, 0x00, 0x00, 0x00, 0x00, 0x10},
415 {0xa0, 0x21, 0x15, 0xb8, 0x00, 0x00, 0x00, 0x10},
416 {0xa0, 0x21, 0x16, 0x13, 0x00, 0x00, 0x00, 0x10},
417 {0xa0, 0x21, 0x17, 0x52, 0x00, 0x00, 0x00, 0x10},
418 {0xa0, 0x21, 0x18, 0x50, 0x00, 0x00, 0x00, 0x10},
419 {0xa0, 0x21, 0x1e, 0x0d, 0x00, 0x00, 0x00, 0x10},
420 {0xa0, 0x21, 0x1f, 0x32, 0x00, 0x00, 0x00, 0x10},
421 {0xa0, 0x21, 0x61, 0x90, 0x00, 0x00, 0x00, 0x10},
422 {0xa0, 0x21, 0x63, 0x70, 0x00, 0x00, 0x00, 0x10},
423 {0xa0, 0x21, 0x65, 0x98, 0x00, 0x00, 0x00, 0x10},
424 {0xa0, 0x21, 0x67, 0x90, 0x00, 0x00, 0x00, 0x10},
425 {0xa0, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
426 {0xa0, 0x21, 0x04, 0x96, 0x00, 0x00, 0x00, 0x10},
427 {0xa0, 0x21, 0x45, 0x27, 0x00, 0x00, 0x00, 0x10},
428 {0xa0, 0x21, 0x47, 0x2c, 0x00, 0x00, 0x00, 0x10},
429 {0xa0, 0x21, 0x43, 0x47, 0x00, 0x00, 0x00, 0x10},
430 {0xa0, 0x21, 0x44, 0xd8, 0x00, 0x00, 0x00, 0x10},
431 {}
432};
433static const u8 gc0307_sensor_param1[][8] = {
434 {0xa0, 0x21, 0x68, 0x13, 0x00, 0x00, 0x00, 0x10},
435 {0xd0, 0x21, 0x61, 0x80, 0x00, 0x80, 0x00, 0x10},
436 {0xc0, 0x21, 0x65, 0x80, 0x00, 0x80, 0x00, 0x10},
437 {0xc0, 0x21, 0x63, 0xa0, 0x00, 0xa6, 0x00, 0x10},
438
439 {0xa0, 0x21, 0x01, 0x6e, 0x00, 0x00, 0x00, 0x10},
440 {0xa0, 0x21, 0x02, 0x88, 0x00, 0x00, 0x00, 0x10},
441 {}
442};
443
444static const u8 hv7131r_sensor_init[][8] = {
445 {0xc1, 0x11, 0x01, 0x08, 0x01, 0x00, 0x00, 0x10},
446 {0xb1, 0x11, 0x34, 0x17, 0x7f, 0x00, 0x00, 0x10},
447 {0xd1, 0x11, 0x40, 0xff, 0x7f, 0x7f, 0x7f, 0x10},
448
449 {0xd1, 0x11, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
450 {0xd1, 0x11, 0x14, 0x01, 0xe2, 0x02, 0x82, 0x10},
451
452
453 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
454 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
455 {0xc1, 0x11, 0x25, 0x00, 0x61, 0xa8, 0x00, 0x10},
456 {0xa1, 0x11, 0x30, 0x22, 0x00, 0x00, 0x00, 0x10},
457 {0xc1, 0x11, 0x31, 0x20, 0x2e, 0x20, 0x00, 0x10},
458 {0xc1, 0x11, 0x25, 0x00, 0xc3, 0x50, 0x00, 0x10},
459 {0xa1, 0x11, 0x30, 0x07, 0x00, 0x00, 0x00, 0x10},
460 {0xc1, 0x11, 0x31, 0x10, 0x10, 0x10, 0x00, 0x10},
461
462 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
463 {0xa1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
464 {0xa1, 0x11, 0x21, 0xd0, 0x00, 0x00, 0x00, 0x10},
465 {0xa1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
466 {0xa1, 0x11, 0x23, 0x09, 0x00, 0x00, 0x00, 0x10},
467
468 {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
469 {0xa1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
470 {0xa1, 0x11, 0x21, 0xd0, 0x00, 0x00, 0x00, 0x10},
471 {0xa1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
472 {0xa1, 0x11, 0x23, 0x10, 0x00, 0x00, 0x00, 0x10},
473 {0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10},
474
475 {}
476};
477static const u8 mi0360_sensor_init[][8] = {
478 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
479 {0xb1, 0x5d, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
480 {0xb1, 0x5d, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
481 {0xd1, 0x5d, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
482 {0xd1, 0x5d, 0x03, 0x01, 0xe2, 0x02, 0x82, 0x10},
483 {0xd1, 0x5d, 0x05, 0x00, 0x09, 0x00, 0x53, 0x10},
484 {0xb1, 0x5d, 0x0d, 0x00, 0x02, 0x00, 0x00, 0x10},
485 {0xd1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
486 {0xd1, 0x5d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10},
487 {0xd1, 0x5d, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
488 {0xd1, 0x5d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
489 {0xd1, 0x5d, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
490 {0xd1, 0x5d, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
491 {0xd1, 0x5d, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
492 {0xd1, 0x5d, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
493 {0xd1, 0x5d, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x10},
494 {0xd1, 0x5d, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
495 {0xb1, 0x5d, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
496 {0xd1, 0x5d, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
497 {0xd1, 0x5d, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
498 {0xd1, 0x5d, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
499 {0xd1, 0x5d, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
500 {0xd1, 0x5d, 0x2f, 0xf7, 0xb0, 0x00, 0x04, 0x10},
501 {0xd1, 0x5d, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
502 {0xd1, 0x5d, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
503 {0xb1, 0x5d, 0x3d, 0x06, 0x8f, 0x00, 0x00, 0x10},
504 {0xd1, 0x5d, 0x40, 0x01, 0xe0, 0x00, 0xd1, 0x10},
505 {0xb1, 0x5d, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
506 {0xd1, 0x5d, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
507 {0xd1, 0x5d, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x10},
508 {0xd1, 0x5d, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x10},
509 {0xd1, 0x5d, 0x5e, 0x00, 0x00, 0xa3, 0x1d, 0x10},
510 {0xb1, 0x5d, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},
511
512 {0xb1, 0x5d, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
513 {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
514 {0xb1, 0x5d, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
515 {0xd1, 0x5d, 0x2b, 0x00, 0xa0, 0x00, 0xb0, 0x10},
516 {0xd1, 0x5d, 0x2d, 0x00, 0xa0, 0x00, 0xa0, 0x10},
517
518 {0xb1, 0x5d, 0x0a, 0x00, 0x02, 0x00, 0x00, 0x10},
519 {0xb1, 0x5d, 0x06, 0x00, 0x30, 0x00, 0x00, 0x10},
520 {0xb1, 0x5d, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x10},
521 {0xb1, 0x5d, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10},
522
523 {0xd1, 0x5d, 0x2b, 0x00, 0xb9, 0x00, 0xe3, 0x10},
524 {0xd1, 0x5d, 0x2d, 0x00, 0x5f, 0x00, 0xb9, 0x10},
525
526
527 {0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10},
528 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
529 {}
530};
531static const u8 mi0360b_sensor_init[][8] = {
532 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
533 {0xb1, 0x5d, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
534 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
535 {0xb1, 0x5d, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
536 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
537 {0xd1, 0x5d, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
538 {0xd1, 0x5d, 0x03, 0x01, 0xe2, 0x02, 0x82, 0x10},
539 {0xd1, 0x5d, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
540 {0xb1, 0x5d, 0x0d, 0x00, 0x02, 0x00, 0x00, 0x10},
541 {0xd1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
542 {0xd1, 0x5d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10},
543 {0xd1, 0x5d, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
544 {0xd1, 0x5d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
545 {0xd1, 0x5d, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
546 {0xd1, 0x5d, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
547 {0xd1, 0x5d, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
548 {0xd1, 0x5d, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
549 {0xd1, 0x5d, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x10},
550 {0xd1, 0x5d, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
551 {0xb1, 0x5d, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
552 {0xd1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
553 {0xd1, 0x5d, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
554 {0xd1, 0x5d, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
555 {0xd1, 0x5d, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
556 {0xd1, 0x5d, 0x2f, 0xf7, 0xb0, 0x00, 0x04, 0x10},
557 {0xd1, 0x5d, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
558 {0xd1, 0x5d, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
559 {0xb1, 0x5d, 0x3d, 0x06, 0x8f, 0x00, 0x00, 0x10},
560 {0xd1, 0x5d, 0x40, 0x01, 0xe0, 0x00, 0xd1, 0x10},
561 {0xb1, 0x5d, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
562 {0xd1, 0x5d, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
563 {0xd1, 0x5d, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x10},
564 {0xd1, 0x5d, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x10},
565 {0xd1, 0x5d, 0x5e, 0x00, 0x00, 0xa3, 0x1d, 0x10},
566 {0xb1, 0x5d, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},
567
568 {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
569 {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
570 {0xb1, 0x5d, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
571 {0xd1, 0x5d, 0x2b, 0x00, 0x33, 0x00, 0xa0, 0x10},
572 {0xd1, 0x5d, 0x2d, 0x00, 0xa0, 0x00, 0x33, 0x10},
573 {}
574};
575static const u8 mi0360b_sensor_param1[][8] = {
576 {0xb1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
577 {0xb1, 0x5d, 0x06, 0x00, 0x53, 0x00, 0x00, 0x10},
578 {0xb1, 0x5d, 0x05, 0x00, 0x09, 0x00, 0x00, 0x10},
579 {0xb1, 0x5d, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10},
580
581 {0xd1, 0x5d, 0x2b, 0x00, 0xd1, 0x01, 0xc9, 0x10},
582 {0xd1, 0x5d, 0x2d, 0x00, 0xed, 0x00, 0xd1, 0x10},
583 {0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10},
584 {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
585 {}
586};
587static const u8 mo4000_sensor_init[][8] = {
588 {0xa1, 0x21, 0x01, 0x02, 0x00, 0x00, 0x00, 0x10},
589 {0xa1, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10},
590 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
591 {0xa1, 0x21, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
592 {0xa1, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
593 {0xa1, 0x21, 0x05, 0x04, 0x00, 0x00, 0x00, 0x10},
594 {0xa1, 0x21, 0x06, 0x80, 0x00, 0x00, 0x00, 0x10},
595 {0xa1, 0x21, 0x06, 0x81, 0x00, 0x00, 0x00, 0x10},
596 {0xa1, 0x21, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
597 {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
598 {0xa1, 0x21, 0x11, 0x20, 0x00, 0x00, 0x00, 0x10},
599 {0xa1, 0x21, 0x11, 0x30, 0x00, 0x00, 0x00, 0x10},
600 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
601 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
602 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
603 {0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
604 {0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10},
605 {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10},
606 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
607 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
608 {}
609};
610static const u8 mt9v111_sensor_init[][8] = {
611 {0xb1, 0x5c, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
612 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
613 {0xb1, 0x5c, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
614 {0xb1, 0x5c, 0x01, 0x00, 0x01, 0x00, 0x00, 0x10},
615 {0xb1, 0x5c, 0x08, 0x04, 0x80, 0x00, 0x00, 0x10},
616 {0xb1, 0x5c, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10},
617 {0xb1, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10},
618 {0xb1, 0x5c, 0x08, 0x00, 0x08, 0x00, 0x00, 0x10},
619 {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10},
620 {0xb1, 0x5c, 0x03, 0x01, 0xe7, 0x00, 0x00, 0x10},
621 {0xb1, 0x5c, 0x04, 0x02, 0x87, 0x00, 0x00, 0x10},
622 {0xb1, 0x5c, 0x07, 0x30, 0x02, 0x00, 0x00, 0x10},
623 {0xb1, 0x5c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10},
624 {0xb1, 0x5c, 0x12, 0x00, 0xb0, 0x00, 0x00, 0x10},
625 {0xb1, 0x5c, 0x13, 0x00, 0x7c, 0x00, 0x00, 0x10},
626 {0xb1, 0x5c, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x10},
627 {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
628 {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
629 {}
630};
631static const u8 mt9v111_sensor_param1[][8] = {
632 {0xd1, 0x5c, 0x2b, 0x00, 0x33, 0x00, 0xad, 0x10},
633 {0xd1, 0x5c, 0x2d, 0x00, 0xad, 0x00, 0x33, 0x10},
634 {0xb1, 0x5c, 0x06, 0x00, 0x40, 0x00, 0x00, 0x10},
635 {0xb1, 0x5c, 0x05, 0x00, 0x09, 0x00, 0x00, 0x10},
636 {0xb1, 0x5c, 0x35, 0x01, 0xc0, 0x00, 0x00, 0x10},
637 {}
638};
639static const u8 om6802_init0[2][8] = {
640
641 {0xa0, 0x34, 0x29, 0x0e, 0x00, 0x00, 0x00, 0x10},
642 {0xa0, 0x34, 0x23, 0xb0, 0x00, 0x00, 0x00, 0x10},
643};
644static const u8 om6802_sensor_init[][8] = {
645 {0xa0, 0x34, 0xdf, 0x6d, 0x00, 0x00, 0x00, 0x10},
646
647 {0xa0, 0x34, 0xdd, 0x18, 0x00, 0x00, 0x00, 0x10},
648
649 {0xa0, 0x34, 0x5a, 0xc0, 0x00, 0x00, 0x00, 0x10},
650
651 {0xa0, 0x34, 0xf0, 0x04, 0x00, 0x00, 0x00, 0x10},
652
653
654
655
656
657
658
659
660
661
662
663
664
665 {0xa0, 0x34, 0xe9, 0x0f, 0x00, 0x00, 0x00, 0x10},
666
667 {0xa0, 0x34, 0xe4, 0xff, 0x00, 0x00, 0x00, 0x10},
668
669
670
671
672 {0xa0, 0x34, 0x5d, 0x80, 0x00, 0x00, 0x00, 0x10},
673 {}
674};
675static const u8 om6802_sensor_param1[][8] = {
676 {0xa0, 0x34, 0x71, 0x84, 0x00, 0x00, 0x00, 0x10},
677 {0xa0, 0x34, 0x72, 0x05, 0x00, 0x00, 0x00, 0x10},
678 {0xa0, 0x34, 0x68, 0x80, 0x00, 0x00, 0x00, 0x10},
679 {0xa0, 0x34, 0x69, 0x01, 0x00, 0x00, 0x00, 0x10},
680 {}
681};
682static const u8 ov7630_sensor_init[][8] = {
683 {0xa1, 0x21, 0x76, 0x01, 0x00, 0x00, 0x00, 0x10},
684 {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
685 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
686 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
687 {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
688 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
689 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
690
691 {0xd1, 0x21, 0x03, 0x80, 0x10, 0x20, 0x80, 0x10},
692 {0xb1, 0x21, 0x0c, 0x20, 0x20, 0x00, 0x00, 0x10},
693
694
695 {0xd1, 0x21, 0x11, 0x01, 0x48, 0xc3, 0x00, 0x10},
696 {0xb1, 0x21, 0x15, 0x80, 0x03, 0x00, 0x00, 0x10},
697 {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
698 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
699 {0xd1, 0x21, 0x1f, 0x00, 0x80, 0x80, 0x80, 0x10},
700 {0xd1, 0x21, 0x23, 0xde, 0x10, 0x8a, 0xa0, 0x10},
701 {0xc1, 0x21, 0x27, 0xca, 0xa2, 0x74, 0x00, 0x10},
702 {0xd1, 0x21, 0x2a, 0x88, 0x00, 0x88, 0x01, 0x10},
703 {0xc1, 0x21, 0x2e, 0x80, 0x00, 0x18, 0x00, 0x10},
704 {0xa1, 0x21, 0x21, 0x08, 0x00, 0x00, 0x00, 0x10},
705 {0xa1, 0x21, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
706 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
707 {0xb1, 0x21, 0x32, 0xc2, 0x08, 0x00, 0x00, 0x10},
708 {0xb1, 0x21, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x10},
709 {0xd1, 0x21, 0x60, 0x05, 0x40, 0x12, 0x57, 0x10},
710 {0xa1, 0x21, 0x64, 0x73, 0x00, 0x00, 0x00, 0x10},
711 {0xd1, 0x21, 0x65, 0x00, 0x55, 0x01, 0xac, 0x10},
712 {0xa1, 0x21, 0x69, 0x38, 0x00, 0x00, 0x00, 0x10},
713 {0xd1, 0x21, 0x6f, 0x1f, 0x01, 0x00, 0x10, 0x10},
714 {0xd1, 0x21, 0x73, 0x50, 0x20, 0x02, 0x01, 0x10},
715 {0xd1, 0x21, 0x77, 0xf3, 0x90, 0x98, 0x98, 0x10},
716 {0xc1, 0x21, 0x7b, 0x00, 0x4c, 0xf7, 0x00, 0x10},
717 {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
718 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
719 {}
720};
721static const u8 ov7630_sensor_param1[][8] = {
722 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
723 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
724
725
726
727 {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
728 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
729 {0xb1, 0x21, 0x01, 0x80, 0x80, 0x00, 0x00, 0x10},
730
731
732
733
734 {0xa1, 0x21, 0x10, 0x83, 0x00, 0x00, 0x00, 0x10},
735
736 {}
737};
738
739static const u8 ov7648_sensor_init[][8] = {
740 {0xa1, 0x21, 0x76, 0x00, 0x00, 0x00, 0x00, 0x10},
741 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
742 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
743 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
744 {0xd1, 0x21, 0x03, 0xa4, 0x30, 0x88, 0x00, 0x10},
745 {0xb1, 0x21, 0x11, 0x80, 0x08, 0x00, 0x00, 0x10},
746 {0xc1, 0x21, 0x13, 0xa0, 0x04, 0x84, 0x00, 0x10},
747 {0xd1, 0x21, 0x17, 0x1a, 0x02, 0xba, 0xf4, 0x10},
748 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
749 {0xd1, 0x21, 0x1f, 0x41, 0xc0, 0x80, 0x80, 0x10},
750 {0xd1, 0x21, 0x23, 0xde, 0xa0, 0x80, 0x32, 0x10},
751 {0xd1, 0x21, 0x27, 0xfe, 0xa0, 0x00, 0x91, 0x10},
752 {0xd1, 0x21, 0x2b, 0x00, 0x88, 0x85, 0x80, 0x10},
753 {0xc1, 0x21, 0x2f, 0x9c, 0x00, 0xc4, 0x00, 0x10},
754 {0xd1, 0x21, 0x60, 0xa6, 0x60, 0x88, 0x12, 0x10},
755 {0xd1, 0x21, 0x64, 0x88, 0x00, 0x00, 0x94, 0x10},
756 {0xd1, 0x21, 0x68, 0x7a, 0x0c, 0x00, 0x00, 0x10},
757 {0xd1, 0x21, 0x6c, 0x11, 0x33, 0x22, 0x00, 0x10},
758 {0xd1, 0x21, 0x70, 0x11, 0x00, 0x10, 0x50, 0x10},
759 {0xd1, 0x21, 0x74, 0x20, 0x06, 0x00, 0xb5, 0x10},
760 {0xd1, 0x21, 0x78, 0x8a, 0x00, 0x00, 0x00, 0x10},
761 {0xb1, 0x21, 0x7c, 0x00, 0x43, 0x00, 0x00, 0x10},
762
763 {0xd1, 0x21, 0x21, 0x86, 0x00, 0xde, 0xa0, 0x10},
764
765
766
767 {}
768};
769static const u8 ov7648_sensor_param1[][8] = {
770
771
772
773 {0xa1, 0x21, 0x19, 0x02, 0x00, 0x00, 0x00, 0x10},
774 {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
775
776
777
778
779 {0xa1, 0x21, 0x11, 0x81, 0x00, 0x00, 0x00, 0x10},
780
781
782
783
784
785
786 {}
787};
788
789static const u8 ov7660_sensor_init[][8] = {
790 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
791 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
792 {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
793
794 {0xa1, 0x21, 0x13, 0xb8, 0x00, 0x00, 0x00, 0x10},
795 {0xd1, 0x21, 0x00, 0x01, 0x74, 0x92, 0x00, 0x10},
796
797 {0xd1, 0x21, 0x04, 0x00, 0x7d, 0x62, 0x00, 0x10},
798
799 {0xb1, 0x21, 0x08, 0x83, 0x01, 0x00, 0x00, 0x10},
800 {0xd1, 0x21, 0x0c, 0x00, 0x08, 0x04, 0x4f, 0x10},
801 {0xd1, 0x21, 0x10, 0x7f, 0x40, 0x05, 0xff, 0x10},
802
803 {0xc1, 0x21, 0x14, 0x2c, 0x00, 0x02, 0x00, 0x10},
804 {0xd1, 0x21, 0x17, 0x10, 0x60, 0x02, 0x7b, 0x10},
805
806 {0xa1, 0x21, 0x1b, 0x02, 0x00, 0x00, 0x00, 0x10},
807 {0xb1, 0x21, 0x1e, 0x01, 0x0e, 0x00, 0x00, 0x10},
808 {0xd1, 0x21, 0x20, 0x07, 0x07, 0x07, 0x07, 0x10},
809
810
811 {0xd1, 0x21, 0x24, 0x78, 0x68, 0xd4, 0x80, 0x10},
812
813 {0xd1, 0x21, 0x28, 0x80, 0x30, 0x00, 0x00, 0x10},
814
815 {0xd1, 0x21, 0x2c, 0x80, 0x00, 0x00, 0x62, 0x10},
816
817 {0xc1, 0x21, 0x30, 0x08, 0x30, 0xb4, 0x00, 0x10},
818
819 {0xd1, 0x21, 0x33, 0x00, 0x07, 0x84, 0x00, 0x10},
820 {0xd1, 0x21, 0x37, 0x0c, 0x02, 0x43, 0x00, 0x10},
821
822 {0xd1, 0x21, 0x3b, 0x02, 0x6c, 0x19, 0x0e, 0x10},
823
824 {0xd1, 0x21, 0x3f, 0x41, 0xc1, 0x22, 0x08, 0x10},
825
826 {0xd1, 0x21, 0x43, 0xf0, 0x10, 0x78, 0xa8, 0x10},
827 {0xd1, 0x21, 0x47, 0x60, 0x80, 0x00, 0x00, 0x10},
828 {0xd1, 0x21, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x10},
829 {0xd1, 0x21, 0x4f, 0x46, 0x36, 0x0f, 0x17, 0x10},
830 {0xd1, 0x21, 0x53, 0x7f, 0x96, 0x40, 0x40, 0x10},
831 {0xb1, 0x21, 0x57, 0x40, 0x0f, 0x00, 0x00, 0x10},
832 {0xd1, 0x21, 0x59, 0xba, 0x9a, 0x22, 0xb9, 0x10},
833 {0xd1, 0x21, 0x5d, 0x9b, 0x10, 0xf0, 0x05, 0x10},
834 {0xa1, 0x21, 0x61, 0x60, 0x00, 0x00, 0x00, 0x10},
835 {0xd1, 0x21, 0x62, 0x00, 0x00, 0x50, 0x30, 0x10},
836
837 {0xa1, 0x21, 0x66, 0x00, 0x00, 0x00, 0x00, 0x10},
838 {0xd1, 0x21, 0x67, 0x80, 0x7a, 0x90, 0x80, 0x10},
839 {0xa1, 0x21, 0x6b, 0x0a, 0x00, 0x00, 0x00, 0x10},
840
841 {0xd1, 0x21, 0x6c, 0x30, 0x48, 0x80, 0x74, 0x10},
842 {0xd1, 0x21, 0x70, 0x64, 0x60, 0x5c, 0x58, 0x10},
843 {0xd1, 0x21, 0x74, 0x54, 0x4c, 0x40, 0x38, 0x10},
844 {0xd1, 0x21, 0x78, 0x34, 0x30, 0x2f, 0x2b, 0x10},
845 {0xd1, 0x21, 0x7c, 0x03, 0x07, 0x17, 0x34, 0x10},
846 {0xd1, 0x21, 0x80, 0x41, 0x4d, 0x58, 0x63, 0x10},
847 {0xd1, 0x21, 0x84, 0x6e, 0x77, 0x87, 0x95, 0x10},
848 {0xc1, 0x21, 0x88, 0xaf, 0xc7, 0xdf, 0x00, 0x10},
849 {0xc1, 0x21, 0x8b, 0x99, 0x99, 0xcf, 0x00, 0x10},
850 {0xb1, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x10},
851
852 {0xa1, 0x21, 0xa1, 0x00, 0x00, 0x00, 0x00, 0x10},
853 {}
854};
855static const u8 ov7660_sensor_param1[][8] = {
856 {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10},
857
858 {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10},
859 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
860
861 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
862 {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10},
863 {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10},
864 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
865 {0xa1, 0x21, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x10},
866
867
868
869 {0xa1, 0x21, 0x93, 0x00, 0x00, 0x00, 0x00, 0x10},
870 {0xa1, 0x21, 0x92, 0x25, 0x00, 0x00, 0x00, 0x10},
871 {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
872 {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10},
873
874
875
876
877 {0xa1, 0x21, 0x93, 0x01, 0x00, 0x00, 0x00, 0x10},
878 {0xa1, 0x21, 0x92, 0xff, 0x00, 0x00, 0x00, 0x10},
879 {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
880 {0xa1, 0x21, 0x2b, 0xc3, 0x00, 0x00, 0x00, 0x10},
881 {}
882};
883
884static const u8 po1030_sensor_init[][8] = {
885
886 {0xa1, 0x6e, 0x3f, 0x20, 0x00, 0x00, 0x00, 0x10},
887 {DELAY, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
888 {0xa1, 0x6e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x10},
889 {0xa1, 0x6e, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x10},
890 {0xd1, 0x6e, 0x04, 0x02, 0xb1, 0x02, 0x39, 0x10},
891 {0xd1, 0x6e, 0x08, 0x00, 0x01, 0x00, 0x00, 0x10},
892 {0xd1, 0x6e, 0x0c, 0x02, 0x7f, 0x01, 0xe0, 0x10},
893 {0xd1, 0x6e, 0x12, 0x03, 0x02, 0x00, 0x03, 0x10},
894 {0xd1, 0x6e, 0x16, 0x85, 0x40, 0x4a, 0x40, 0x10},
895 {0xc1, 0x6e, 0x1a, 0x00, 0x80, 0x00, 0x00, 0x10},
896 {0xd1, 0x6e, 0x1d, 0x08, 0x03, 0x00, 0x00, 0x10},
897 {0xd1, 0x6e, 0x23, 0x00, 0xb0, 0x00, 0x94, 0x10},
898 {0xd1, 0x6e, 0x27, 0x58, 0x00, 0x00, 0x00, 0x10},
899 {0xb1, 0x6e, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10},
900 {0xd1, 0x6e, 0x2d, 0x14, 0x35, 0x61, 0x84, 0x10},
901 {0xd1, 0x6e, 0x31, 0xa2, 0xbd, 0xd8, 0xff, 0x10},
902 {0xd1, 0x6e, 0x35, 0x06, 0x1e, 0x12, 0x02, 0x10},
903 {0xd1, 0x6e, 0x39, 0xaa, 0x53, 0x37, 0xd5, 0x10},
904 {0xa1, 0x6e, 0x3d, 0xf2, 0x00, 0x00, 0x00, 0x10},
905 {0xd1, 0x6e, 0x3e, 0x00, 0x00, 0x80, 0x03, 0x10},
906 {0xd1, 0x6e, 0x42, 0x03, 0x00, 0x00, 0x00, 0x10},
907 {0xc1, 0x6e, 0x46, 0x00, 0x80, 0x80, 0x00, 0x10},
908 {0xd1, 0x6e, 0x4b, 0x02, 0xef, 0x08, 0xcd, 0x10},
909 {0xd1, 0x6e, 0x4f, 0x00, 0xd0, 0x00, 0xa0, 0x10},
910 {0xd1, 0x6e, 0x53, 0x01, 0xaa, 0x01, 0x40, 0x10},
911 {0xd1, 0x6e, 0x5a, 0x50, 0x04, 0x30, 0x03, 0x10},
912 {0xa1, 0x6e, 0x5e, 0x00, 0x00, 0x00, 0x00, 0x10},
913 {0xd1, 0x6e, 0x5f, 0x10, 0x40, 0xff, 0x00, 0x10},
914
915 {0xd1, 0x6e, 0x63, 0x40, 0x40, 0x00, 0x00, 0x10},
916 {0xd1, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x10},
917 {0xd1, 0x6e, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x10},
918 {0xd1, 0x6e, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x10},
919 {0xc1, 0x6e, 0x73, 0x10, 0x80, 0xeb, 0x00, 0x10},
920 {}
921};
922static const u8 po1030_sensor_param1[][8] = {
923
924 {0xa1, 0x6e, 0x1e, 0x03, 0x00, 0x00, 0x00, 0x10},
925 {0xa1, 0x6e, 0x1e, 0x03, 0x00, 0x00, 0x00, 0x10},
926
927 {0xc1, 0x6e, 0x1a, 0x02, 0xd4, 0xa4, 0x00, 0x10},
928 {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10},
929 {0xc1, 0x6e, 0x16, 0x40, 0x40, 0x40, 0x00, 0x10},
930
931 {0xa1, 0x6e, 0x1d, 0x08, 0x00, 0x00, 0x00, 0x10},
932 {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
933 {0xa1, 0x6e, 0x07, 0xd5, 0x00, 0x00, 0x00, 0x10},
934
935 {}
936};
937
938static const u8 po2030n_sensor_init[][8] = {
939 {0xa1, 0x6e, 0x1e, 0x1a, 0x00, 0x00, 0x00, 0x10},
940 {0xa1, 0x6e, 0x1f, 0x99, 0x00, 0x00, 0x00, 0x10},
941 {DELAY, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
942 {0xa1, 0x6e, 0x1e, 0x0a, 0x00, 0x00, 0x00, 0x10},
943 {0xa1, 0x6e, 0x1f, 0x19, 0x00, 0x00, 0x00, 0x10},
944 {DELAY, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
945 {0xa1, 0x6e, 0x20, 0x44, 0x00, 0x00, 0x00, 0x10},
946 {0xa1, 0x6e, 0x04, 0x03, 0x00, 0x00, 0x00, 0x10},
947 {0xa1, 0x6e, 0x05, 0x70, 0x00, 0x00, 0x00, 0x10},
948 {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
949 {0xa1, 0x6e, 0x07, 0x25, 0x00, 0x00, 0x00, 0x10},
950 {0xd1, 0x6e, 0x08, 0x00, 0xd0, 0x00, 0x08, 0x10},
951 {0xd1, 0x6e, 0x0c, 0x03, 0x50, 0x01, 0xe8, 0x10},
952 {0xd1, 0x6e, 0x1d, 0x20, 0x0a, 0x19, 0x44, 0x10},
953 {0xd1, 0x6e, 0x21, 0x00, 0x00, 0x00, 0x00, 0x10},
954 {0xd1, 0x6e, 0x25, 0x00, 0x00, 0x00, 0x00, 0x10},
955 {0xd1, 0x6e, 0x29, 0x00, 0x00, 0x00, 0x00, 0x10},
956 {0xd1, 0x6e, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10},
957 {0xd1, 0x6e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
958 {0xd1, 0x6e, 0x35, 0x00, 0x00, 0x00, 0x00, 0x10},
959 {0xd1, 0x6e, 0x39, 0x00, 0x00, 0x00, 0x00, 0x10},
960 {0xd1, 0x6e, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x10},
961 {0xd1, 0x6e, 0x41, 0x00, 0x00, 0x00, 0x00, 0x10},
962 {0xd1, 0x6e, 0x45, 0x00, 0x00, 0x00, 0x00, 0x10},
963 {0xd1, 0x6e, 0x49, 0x00, 0x00, 0x00, 0x00, 0x10},
964 {0xd1, 0x6e, 0x4d, 0x00, 0x00, 0x00, 0xed, 0x10},
965 {0xd1, 0x6e, 0x51, 0x17, 0x4a, 0x2f, 0xc0, 0x10},
966 {0xd1, 0x6e, 0x55, 0x00, 0x00, 0x00, 0x00, 0x10},
967 {0xd1, 0x6e, 0x59, 0x00, 0x00, 0x00, 0x00, 0x10},
968 {0xd1, 0x6e, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x10},
969 {0xd1, 0x6e, 0x61, 0x00, 0x00, 0x00, 0x00, 0x10},
970 {0xd1, 0x6e, 0x65, 0x00, 0x00, 0x00, 0x00, 0x10},
971 {0xd1, 0x6e, 0x69, 0x00, 0x00, 0x00, 0x00, 0x10},
972 {0xd1, 0x6e, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x10},
973 {0xd1, 0x6e, 0x71, 0x00, 0x00, 0x00, 0x00, 0x10},
974 {0xd1, 0x6e, 0x75, 0x00, 0x00, 0x00, 0x00, 0x10},
975 {0xd1, 0x6e, 0x79, 0x00, 0x00, 0x00, 0x00, 0x10},
976 {0xd1, 0x6e, 0x7d, 0x00, 0x00, 0x00, 0x00, 0x10},
977 {0xd1, 0x6e, 0x81, 0x00, 0x00, 0x00, 0x00, 0x10},
978 {0xd1, 0x6e, 0x85, 0x00, 0x00, 0x00, 0x08, 0x10},
979 {0xd1, 0x6e, 0x89, 0x01, 0xe8, 0x00, 0x01, 0x10},
980 {0xa1, 0x6e, 0x8d, 0x00, 0x00, 0x00, 0x00, 0x10},
981 {0xd1, 0x6e, 0x21, 0x00, 0x00, 0x00, 0x00, 0x10},
982 {0xd1, 0x6e, 0x25, 0x00, 0x00, 0x00, 0x01, 0x10},
983 {0xd1, 0x6e, 0x29, 0xe6, 0x00, 0xbd, 0x03, 0x10},
984 {0xd1, 0x6e, 0x2d, 0x41, 0x38, 0x68, 0x40, 0x10},
985 {0xd1, 0x6e, 0x31, 0x2b, 0x00, 0x36, 0x00, 0x10},
986 {0xd1, 0x6e, 0x35, 0x30, 0x30, 0x08, 0x00, 0x10},
987 {0xd1, 0x6e, 0x39, 0x00, 0x00, 0x33, 0x06, 0x10},
988 {0xb1, 0x6e, 0x3d, 0x06, 0x02, 0x00, 0x00, 0x10},
989 {}
990};
991static const u8 po2030n_sensor_param1[][8] = {
992 {0xa1, 0x6e, 0x1a, 0x01, 0x00, 0x00, 0x00, 0x10},
993 {DELAY, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
994 {0xa1, 0x6e, 0x1b, 0xf4, 0x00, 0x00, 0x00, 0x10},
995 {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10},
996 {0xd1, 0x6e, 0x16, 0x40, 0x40, 0x40, 0x40, 0x10},
997
998 {0xa1, 0x6e, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x10},
999 {0xa1, 0x6e, 0x04, 0x03, 0x00, 0x00, 0x00, 0x10},
1000 {0xa1, 0x6e, 0x05, 0x6f, 0x00, 0x00, 0x00, 0x10},
1001 {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
1002 {0xa1, 0x6e, 0x07, 0x25, 0x00, 0x00, 0x00, 0x10},
1003 {}
1004};
1005
1006static const u8 soi768_sensor_init[][8] = {
1007 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
1008 {DELAY, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
1009 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
1010 {0xa1, 0x21, 0x13, 0x80, 0x00, 0x00, 0x00, 0x10},
1011 {0xa1, 0x21, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x10},
1012 {0xa1, 0x21, 0x19, 0x00, 0x00, 0x00, 0x00, 0x10},
1013 {}
1014};
1015static const u8 soi768_sensor_param1[][8] = {
1016 {0xa1, 0x21, 0x10, 0x10, 0x00, 0x00, 0x00, 0x10},
1017 {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10},
1018 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
1019 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1020 {0xb1, 0x21, 0x01, 0x7f, 0x7f, 0x00, 0x00, 0x10},
1021
1022
1023
1024 {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10},
1025
1026 {0xa1, 0x21, 0x02, 0x8d, 0x00, 0x00, 0x00, 0x10},
1027
1028 {0xa1, 0x21, 0x00, 0x07, 0x00, 0x00, 0x00, 0x10},
1029
1030 {0xa1, 0x21, 0x10, 0x3f, 0x00, 0x00, 0x00, 0x10},
1031 {0xa1, 0x21, 0x04, 0x06, 0x00, 0x00, 0x00, 0x10},
1032 {0xb1, 0x21, 0x2d, 0x63, 0x03, 0x00, 0x00, 0x10},
1033
1034 {}
1035};
1036
1037static const u8 sp80708_sensor_init[][8] = {
1038 {0xa1, 0x18, 0x06, 0xf9, 0x00, 0x00, 0x00, 0x10},
1039 {0xa1, 0x18, 0x09, 0x1f, 0x00, 0x00, 0x00, 0x10},
1040 {0xa1, 0x18, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
1041 {0xa1, 0x18, 0x0d, 0xc0, 0x00, 0x00, 0x00, 0x10},
1042 {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
1043 {0xa1, 0x18, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x10},
1044 {0xa1, 0x18, 0x10, 0x40, 0x00, 0x00, 0x00, 0x10},
1045 {0xa1, 0x18, 0x11, 0x4e, 0x00, 0x00, 0x00, 0x10},
1046 {0xa1, 0x18, 0x12, 0x53, 0x00, 0x00, 0x00, 0x10},
1047 {0xa1, 0x18, 0x15, 0x80, 0x00, 0x00, 0x00, 0x10},
1048 {0xa1, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x10},
1049 {0xa1, 0x18, 0x19, 0x18, 0x00, 0x00, 0x00, 0x10},
1050 {0xa1, 0x18, 0x1a, 0x10, 0x00, 0x00, 0x00, 0x10},
1051 {0xa1, 0x18, 0x1b, 0x10, 0x00, 0x00, 0x00, 0x10},
1052 {0xa1, 0x18, 0x1c, 0x28, 0x00, 0x00, 0x00, 0x10},
1053 {0xa1, 0x18, 0x1d, 0x02, 0x00, 0x00, 0x00, 0x10},
1054 {0xa1, 0x18, 0x1e, 0x10, 0x00, 0x00, 0x00, 0x10},
1055 {0xa1, 0x18, 0x26, 0x04, 0x00, 0x00, 0x00, 0x10},
1056 {0xa1, 0x18, 0x27, 0x1e, 0x00, 0x00, 0x00, 0x10},
1057 {0xa1, 0x18, 0x28, 0x5a, 0x00, 0x00, 0x00, 0x10},
1058 {0xa1, 0x18, 0x29, 0x28, 0x00, 0x00, 0x00, 0x10},
1059 {0xa1, 0x18, 0x2a, 0x78, 0x00, 0x00, 0x00, 0x10},
1060 {0xa1, 0x18, 0x2b, 0x01, 0x00, 0x00, 0x00, 0x10},
1061 {0xa1, 0x18, 0x2c, 0xf7, 0x00, 0x00, 0x00, 0x10},
1062 {0xa1, 0x18, 0x2d, 0x2d, 0x00, 0x00, 0x00, 0x10},
1063 {0xa1, 0x18, 0x2e, 0xd5, 0x00, 0x00, 0x00, 0x10},
1064 {0xa1, 0x18, 0x39, 0x42, 0x00, 0x00, 0x00, 0x10},
1065 {0xa1, 0x18, 0x3a, 0x67, 0x00, 0x00, 0x00, 0x10},
1066 {0xa1, 0x18, 0x3b, 0x87, 0x00, 0x00, 0x00, 0x10},
1067 {0xa1, 0x18, 0x3c, 0xa3, 0x00, 0x00, 0x00, 0x10},
1068 {0xa1, 0x18, 0x3d, 0xb0, 0x00, 0x00, 0x00, 0x10},
1069 {0xa1, 0x18, 0x3e, 0xbc, 0x00, 0x00, 0x00, 0x10},
1070 {0xa1, 0x18, 0x3f, 0xc8, 0x00, 0x00, 0x00, 0x10},
1071 {0xa1, 0x18, 0x40, 0xd4, 0x00, 0x00, 0x00, 0x10},
1072 {0xa1, 0x18, 0x41, 0xdf, 0x00, 0x00, 0x00, 0x10},
1073 {0xa1, 0x18, 0x42, 0xea, 0x00, 0x00, 0x00, 0x10},
1074 {0xa1, 0x18, 0x43, 0xf5, 0x00, 0x00, 0x00, 0x10},
1075 {0xa1, 0x18, 0x45, 0x80, 0x00, 0x00, 0x00, 0x10},
1076 {0xa1, 0x18, 0x46, 0x60, 0x00, 0x00, 0x00, 0x10},
1077 {0xa1, 0x18, 0x47, 0x50, 0x00, 0x00, 0x00, 0x10},
1078 {0xa1, 0x18, 0x48, 0x30, 0x00, 0x00, 0x00, 0x10},
1079 {0xa1, 0x18, 0x49, 0x01, 0x00, 0x00, 0x00, 0x10},
1080 {0xa1, 0x18, 0x4d, 0xae, 0x00, 0x00, 0x00, 0x10},
1081 {0xa1, 0x18, 0x4e, 0x03, 0x00, 0x00, 0x00, 0x10},
1082 {0xa1, 0x18, 0x4f, 0x66, 0x00, 0x00, 0x00, 0x10},
1083 {0xa1, 0x18, 0x50, 0x1c, 0x00, 0x00, 0x00, 0x10},
1084 {0xa1, 0x18, 0x44, 0x10, 0x00, 0x00, 0x00, 0x10},
1085 {0xa1, 0x18, 0x4a, 0x30, 0x00, 0x00, 0x00, 0x10},
1086 {0xa1, 0x18, 0x51, 0x80, 0x00, 0x00, 0x00, 0x10},
1087 {0xa1, 0x18, 0x52, 0x80, 0x00, 0x00, 0x00, 0x10},
1088 {0xa1, 0x18, 0x53, 0x80, 0x00, 0x00, 0x00, 0x10},
1089 {0xa1, 0x18, 0x54, 0x80, 0x00, 0x00, 0x00, 0x10},
1090 {0xa1, 0x18, 0x55, 0x80, 0x00, 0x00, 0x00, 0x10},
1091 {0xa1, 0x18, 0x56, 0x80, 0x00, 0x00, 0x00, 0x10},
1092 {0xa1, 0x18, 0x57, 0xe0, 0x00, 0x00, 0x00, 0x10},
1093 {0xa1, 0x18, 0x58, 0xc0, 0x00, 0x00, 0x00, 0x10},
1094 {0xa1, 0x18, 0x59, 0xab, 0x00, 0x00, 0x00, 0x10},
1095 {0xa1, 0x18, 0x5a, 0xa0, 0x00, 0x00, 0x00, 0x10},
1096 {0xa1, 0x18, 0x5b, 0x99, 0x00, 0x00, 0x00, 0x10},
1097 {0xa1, 0x18, 0x5c, 0x90, 0x00, 0x00, 0x00, 0x10},
1098 {0xa1, 0x18, 0x5e, 0x24, 0x00, 0x00, 0x00, 0x10},
1099 {0xa1, 0x18, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x10},
1100 {0xa1, 0x18, 0x60, 0x00, 0x00, 0x00, 0x00, 0x10},
1101 {0xa1, 0x18, 0x61, 0x73, 0x00, 0x00, 0x00, 0x10},
1102 {0xa1, 0x18, 0x63, 0x42, 0x00, 0x00, 0x00, 0x10},
1103 {0xa1, 0x18, 0x64, 0x42, 0x00, 0x00, 0x00, 0x10},
1104 {0xa1, 0x18, 0x65, 0x42, 0x00, 0x00, 0x00, 0x10},
1105 {0xa1, 0x18, 0x66, 0x24, 0x00, 0x00, 0x00, 0x10},
1106 {0xa1, 0x18, 0x67, 0x24, 0x00, 0x00, 0x00, 0x10},
1107 {0xa1, 0x18, 0x68, 0x08, 0x00, 0x00, 0x00, 0x10},
1108 {0xa1, 0x18, 0x2f, 0xc9, 0x00, 0x00, 0x00, 0x10},
1109 {}
1110};
1111static const u8 sp80708_sensor_param1[][8] = {
1112 {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
1113 {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
1114 {0xa1, 0x18, 0x03, 0x01, 0x00, 0x00, 0x00, 0x10},
1115 {0xa1, 0x18, 0x04, 0xa4, 0x00, 0x00, 0x00, 0x10},
1116 {0xa1, 0x18, 0x14, 0x3f, 0x00, 0x00, 0x00, 0x10},
1117 {0xa1, 0x18, 0x5d, 0x80, 0x00, 0x00, 0x00, 0x10},
1118 {0xb1, 0x18, 0x11, 0x40, 0x40, 0x00, 0x00, 0x10},
1119 {}
1120};
1121
1122static const u8 (*sensor_init[])[8] = {
1123[SENSOR_ADCM1700] = adcm1700_sensor_init,
1124[SENSOR_GC0307] = gc0307_sensor_init,
1125[SENSOR_HV7131R] = hv7131r_sensor_init,
1126[SENSOR_MI0360] = mi0360_sensor_init,
1127[SENSOR_MI0360B] = mi0360b_sensor_init,
1128[SENSOR_MO4000] = mo4000_sensor_init,
1129[SENSOR_MT9V111] = mt9v111_sensor_init,
1130[SENSOR_OM6802] = om6802_sensor_init,
1131[SENSOR_OV7630] = ov7630_sensor_init,
1132[SENSOR_OV7648] = ov7648_sensor_init,
1133[SENSOR_OV7660] = ov7660_sensor_init,
1134[SENSOR_PO1030] = po1030_sensor_init,
1135[SENSOR_PO2030N] = po2030n_sensor_init,
1136[SENSOR_SOI768] = soi768_sensor_init,
1137[SENSOR_SP80708] = sp80708_sensor_init,
1138};
1139
1140
1141static void reg_r(struct gspca_dev *gspca_dev,
1142 u16 value, int len)
1143{
1144 int ret;
1145
1146 if (gspca_dev->usb_err < 0)
1147 return;
1148 if (len > USB_BUF_SZ) {
1149 gspca_err(gspca_dev, "reg_r: buffer overflow\n");
1150 return;
1151 }
1152
1153 ret = usb_control_msg(gspca_dev->dev,
1154 usb_rcvctrlpipe(gspca_dev->dev, 0),
1155 0,
1156 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1157 value, 0,
1158 gspca_dev->usb_buf, len,
1159 500);
1160 gspca_dbg(gspca_dev, D_USBI, "reg_r [%02x] -> %02x\n",
1161 value, gspca_dev->usb_buf[0]);
1162 if (ret < 0) {
1163 pr_err("reg_r err %d\n", ret);
1164 gspca_dev->usb_err = ret;
1165 }
1166}
1167
1168static void reg_w1(struct gspca_dev *gspca_dev,
1169 u16 value,
1170 u8 data)
1171{
1172 int ret;
1173
1174 if (gspca_dev->usb_err < 0)
1175 return;
1176 gspca_dbg(gspca_dev, D_USBO, "reg_w1 [%04x] = %02x\n", value, data);
1177 gspca_dev->usb_buf[0] = data;
1178 ret = usb_control_msg(gspca_dev->dev,
1179 usb_sndctrlpipe(gspca_dev->dev, 0),
1180 0x08,
1181 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1182 value,
1183 0,
1184 gspca_dev->usb_buf, 1,
1185 500);
1186 if (ret < 0) {
1187 pr_err("reg_w1 err %d\n", ret);
1188 gspca_dev->usb_err = ret;
1189 }
1190}
1191static void reg_w(struct gspca_dev *gspca_dev,
1192 u16 value,
1193 const u8 *buffer,
1194 int len)
1195{
1196 int ret;
1197
1198 if (gspca_dev->usb_err < 0)
1199 return;
1200 gspca_dbg(gspca_dev, D_USBO, "reg_w [%04x] = %02x %02x ..\n",
1201 value, buffer[0], buffer[1]);
1202
1203 if (len > USB_BUF_SZ) {
1204 gspca_err(gspca_dev, "reg_w: buffer overflow\n");
1205 return;
1206 }
1207
1208 memcpy(gspca_dev->usb_buf, buffer, len);
1209 ret = usb_control_msg(gspca_dev->dev,
1210 usb_sndctrlpipe(gspca_dev->dev, 0),
1211 0x08,
1212 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1213 value, 0,
1214 gspca_dev->usb_buf, len,
1215 500);
1216 if (ret < 0) {
1217 pr_err("reg_w err %d\n", ret);
1218 gspca_dev->usb_err = ret;
1219 }
1220}
1221
1222
1223static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
1224{
1225 struct sd *sd = (struct sd *) gspca_dev;
1226 int ret;
1227
1228 if (gspca_dev->usb_err < 0)
1229 return;
1230 gspca_dbg(gspca_dev, D_USBO, "i2c_w1 [%02x] = %02x\n", reg, val);
1231 switch (sd->sensor) {
1232 case SENSOR_ADCM1700:
1233 case SENSOR_OM6802:
1234 case SENSOR_GC0307:
1235 gspca_dev->usb_buf[0] = 0x80 | (2 << 4);
1236 break;
1237 default:
1238 gspca_dev->usb_buf[0] = 0x81 | (2 << 4);
1239 break;
1240 }
1241 gspca_dev->usb_buf[1] = sd->i2c_addr;
1242 gspca_dev->usb_buf[2] = reg;
1243 gspca_dev->usb_buf[3] = val;
1244 gspca_dev->usb_buf[4] = 0;
1245 gspca_dev->usb_buf[5] = 0;
1246 gspca_dev->usb_buf[6] = 0;
1247 gspca_dev->usb_buf[7] = 0x10;
1248 ret = usb_control_msg(gspca_dev->dev,
1249 usb_sndctrlpipe(gspca_dev->dev, 0),
1250 0x08,
1251 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1252 0x08,
1253 0,
1254 gspca_dev->usb_buf, 8,
1255 500);
1256 msleep(2);
1257 if (ret < 0) {
1258 pr_err("i2c_w1 err %d\n", ret);
1259 gspca_dev->usb_err = ret;
1260 }
1261}
1262
1263
1264static void i2c_w8(struct gspca_dev *gspca_dev,
1265 const u8 *buffer)
1266{
1267 int ret;
1268
1269 if (gspca_dev->usb_err < 0)
1270 return;
1271 gspca_dbg(gspca_dev, D_USBO, "i2c_w8 [%02x] = %02x ..\n",
1272 buffer[2], buffer[3]);
1273 memcpy(gspca_dev->usb_buf, buffer, 8);
1274 ret = usb_control_msg(gspca_dev->dev,
1275 usb_sndctrlpipe(gspca_dev->dev, 0),
1276 0x08,
1277 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1278 0x08, 0,
1279 gspca_dev->usb_buf, 8,
1280 500);
1281 msleep(2);
1282 if (ret < 0) {
1283 pr_err("i2c_w8 err %d\n", ret);
1284 gspca_dev->usb_err = ret;
1285 }
1286}
1287
1288
1289static void i2c_r(struct gspca_dev *gspca_dev, u8 reg, int len)
1290{
1291 struct sd *sd = (struct sd *) gspca_dev;
1292 u8 mode[8];
1293
1294 switch (sd->sensor) {
1295 case SENSOR_ADCM1700:
1296 case SENSOR_OM6802:
1297 case SENSOR_GC0307:
1298 mode[0] = 0x80 | 0x10;
1299 break;
1300 default:
1301 mode[0] = 0x81 | 0x10;
1302 break;
1303 }
1304 mode[1] = sd->i2c_addr;
1305 mode[2] = reg;
1306 mode[3] = 0;
1307 mode[4] = 0;
1308 mode[5] = 0;
1309 mode[6] = 0;
1310 mode[7] = 0x10;
1311 i2c_w8(gspca_dev, mode);
1312 msleep(2);
1313 mode[0] = (mode[0] & 0x81) | (len << 4) | 0x02;
1314 mode[2] = 0;
1315 i2c_w8(gspca_dev, mode);
1316 msleep(2);
1317 reg_r(gspca_dev, 0x0a, 5);
1318}
1319
1320static void i2c_w_seq(struct gspca_dev *gspca_dev,
1321 const u8 (*data)[8])
1322{
1323 while ((*data)[0] != 0) {
1324 if ((*data)[0] != DELAY)
1325 i2c_w8(gspca_dev, *data);
1326 else
1327 msleep((*data)[1]);
1328 data++;
1329 }
1330}
1331
1332
1333
1334static void hv7131r_probe(struct gspca_dev *gspca_dev)
1335{
1336 i2c_w1(gspca_dev, 0x02, 0);
1337 msleep(10);
1338 reg_w1(gspca_dev, 0x02, 0x66);
1339 msleep(10);
1340 i2c_r(gspca_dev, 0, 5);
1341 if (gspca_dev->usb_buf[0] == 0x02
1342 && gspca_dev->usb_buf[1] == 0x09
1343 && gspca_dev->usb_buf[2] == 0x01) {
1344 gspca_dbg(gspca_dev, D_PROBE, "Sensor HV7131R found\n");
1345 return;
1346 }
1347 pr_warn("Erroneous HV7131R ID 0x%02x 0x%02x 0x%02x\n",
1348 gspca_dev->usb_buf[0], gspca_dev->usb_buf[1],
1349 gspca_dev->usb_buf[2]);
1350}
1351
1352static void mi0360_probe(struct gspca_dev *gspca_dev)
1353{
1354 struct sd *sd = (struct sd *) gspca_dev;
1355 int i, j;
1356 u16 val = 0;
1357 static const u8 probe_tb[][4][8] = {
1358 {
1359 {0xb0, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
1360 {0x90, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1361 {0xa2, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1362 {0xb0, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10}
1363 },
1364 {
1365 {0xb0, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10},
1366 {0x90, 0x5c, 0x36, 0x00, 0x00, 0x00, 0x00, 0x10},
1367 {0xa2, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
1368 {}
1369 },
1370 };
1371
1372 for (i = 0; i < ARRAY_SIZE(probe_tb); i++) {
1373 reg_w1(gspca_dev, 0x17, 0x62);
1374 reg_w1(gspca_dev, 0x01, 0x08);
1375 for (j = 0; j < 3; j++)
1376 i2c_w8(gspca_dev, probe_tb[i][j]);
1377 msleep(2);
1378 reg_r(gspca_dev, 0x0a, 5);
1379 val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
1380 if (probe_tb[i][3][0] != 0)
1381 i2c_w8(gspca_dev, probe_tb[i][3]);
1382 reg_w1(gspca_dev, 0x01, 0x29);
1383 reg_w1(gspca_dev, 0x17, 0x42);
1384 if (val != 0xffff)
1385 break;
1386 }
1387 if (gspca_dev->usb_err < 0)
1388 return;
1389 switch (val) {
1390 case 0x8221:
1391 gspca_dbg(gspca_dev, D_PROBE, "Sensor mi0360b\n");
1392 sd->sensor = SENSOR_MI0360B;
1393 break;
1394 case 0x823a:
1395 gspca_dbg(gspca_dev, D_PROBE, "Sensor mt9v111\n");
1396 sd->sensor = SENSOR_MT9V111;
1397 break;
1398 case 0x8243:
1399 gspca_dbg(gspca_dev, D_PROBE, "Sensor mi0360\n");
1400 break;
1401 default:
1402 gspca_dbg(gspca_dev, D_PROBE, "Unknown sensor %04x - forced to mi0360\n",
1403 val);
1404 break;
1405 }
1406}
1407
1408static void ov7630_probe(struct gspca_dev *gspca_dev)
1409{
1410 struct sd *sd = (struct sd *) gspca_dev;
1411 u16 val;
1412
1413
1414 reg_w1(gspca_dev, 0x17, 0x62);
1415 reg_w1(gspca_dev, 0x01, 0x08);
1416 sd->i2c_addr = 0x21;
1417 i2c_r(gspca_dev, 0x0a, 2);
1418 val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
1419 reg_w1(gspca_dev, 0x01, 0x29);
1420 reg_w1(gspca_dev, 0x17, 0x42);
1421 if (gspca_dev->usb_err < 0)
1422 return;
1423 if (val == 0x7628) {
1424 sd->sensor = SENSOR_SOI768;
1425
1426 gspca_dev->cam.input_flags =
1427 V4L2_IN_ST_VFLIP | V4L2_IN_ST_HFLIP;
1428 gspca_dbg(gspca_dev, D_PROBE, "Sensor soi768\n");
1429 return;
1430 }
1431 gspca_dbg(gspca_dev, D_PROBE, "Sensor ov%04x\n", val);
1432}
1433
1434static void ov7648_probe(struct gspca_dev *gspca_dev)
1435{
1436 struct sd *sd = (struct sd *) gspca_dev;
1437 u16 val;
1438
1439
1440 reg_w1(gspca_dev, 0x17, 0x62);
1441 reg_w1(gspca_dev, 0x01, 0x08);
1442 sd->i2c_addr = 0x21;
1443 i2c_r(gspca_dev, 0x0a, 2);
1444 val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
1445 reg_w1(gspca_dev, 0x01, 0x29);
1446 reg_w1(gspca_dev, 0x17, 0x42);
1447 if ((val & 0xff00) == 0x7600) {
1448 gspca_dbg(gspca_dev, D_PROBE, "Sensor ov%04x\n", val);
1449 return;
1450 }
1451
1452
1453 reg_w1(gspca_dev, 0x17, 0x62);
1454 reg_w1(gspca_dev, 0x01, 0x08);
1455 sd->i2c_addr = 0x6e;
1456 i2c_r(gspca_dev, 0x00, 2);
1457 val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
1458 reg_w1(gspca_dev, 0x01, 0x29);
1459 reg_w1(gspca_dev, 0x17, 0x42);
1460 if (gspca_dev->usb_err < 0)
1461 return;
1462 if (val == 0x1030) {
1463 gspca_dbg(gspca_dev, D_PROBE, "Sensor po1030\n");
1464 sd->sensor = SENSOR_PO1030;
1465 return;
1466 }
1467 pr_err("Unknown sensor %04x\n", val);
1468}
1469
1470
1471static void po2030n_probe(struct gspca_dev *gspca_dev)
1472{
1473 struct sd *sd = (struct sd *) gspca_dev;
1474 u16 val;
1475
1476
1477 reg_w1(gspca_dev, 0x17, 0x62);
1478 reg_w1(gspca_dev, 0x01, 0x08);
1479 reg_w1(gspca_dev, 0x02, 0x22);
1480 sd->i2c_addr = 0x21;
1481 i2c_r(gspca_dev, 0x00, 1);
1482 val = gspca_dev->usb_buf[4];
1483 reg_w1(gspca_dev, 0x01, 0x29);
1484 reg_w1(gspca_dev, 0x17, 0x42);
1485 if (val == 0x99) {
1486 gspca_dbg(gspca_dev, D_PROBE, "Sensor gc0307\n");
1487 sd->sensor = SENSOR_GC0307;
1488 return;
1489 }
1490
1491
1492 reg_w1(gspca_dev, 0x17, 0x62);
1493 reg_w1(gspca_dev, 0x01, 0x0a);
1494 sd->i2c_addr = 0x6e;
1495 i2c_r(gspca_dev, 0x00, 2);
1496 val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
1497 reg_w1(gspca_dev, 0x01, 0x29);
1498 reg_w1(gspca_dev, 0x17, 0x42);
1499 if (gspca_dev->usb_err < 0)
1500 return;
1501 if (val == 0x2030) {
1502 gspca_dbg(gspca_dev, D_PROBE, "Sensor po2030n\n");
1503
1504 } else {
1505 pr_err("Unknown sensor ID %04x\n", val);
1506 }
1507}
1508
1509
1510static int sd_config(struct gspca_dev *gspca_dev,
1511 const struct usb_device_id *id)
1512{
1513 struct sd *sd = (struct sd *) gspca_dev;
1514 struct cam *cam;
1515
1516 sd->bridge = id->driver_info >> 16;
1517 sd->sensor = id->driver_info >> 8;
1518 sd->flags = id->driver_info;
1519
1520 cam = &gspca_dev->cam;
1521 if (sd->sensor == SENSOR_ADCM1700) {
1522 cam->cam_mode = cif_mode;
1523 cam->nmodes = ARRAY_SIZE(cif_mode);
1524 } else {
1525 cam->cam_mode = vga_mode;
1526 cam->nmodes = ARRAY_SIZE(vga_mode);
1527 }
1528 cam->npkt = 24;
1529
1530 sd->ag_cnt = -1;
1531 sd->quality = QUALITY_DEF;
1532
1533 INIT_WORK(&sd->work, qual_upd);
1534
1535 return 0;
1536}
1537
1538
1539static int sd_init(struct gspca_dev *gspca_dev)
1540{
1541 struct sd *sd = (struct sd *) gspca_dev;
1542 const u8 *sn9c1xx;
1543 u8 regGpio[] = { 0x29, 0x70 };
1544 u8 regF1;
1545
1546
1547 reg_w1(gspca_dev, 0xf1, 0x01);
1548 reg_r(gspca_dev, 0x00, 1);
1549 reg_w1(gspca_dev, 0xf1, 0x00);
1550 reg_r(gspca_dev, 0x00, 1);
1551 regF1 = gspca_dev->usb_buf[0];
1552 if (gspca_dev->usb_err < 0)
1553 return gspca_dev->usb_err;
1554 gspca_dbg(gspca_dev, D_PROBE, "Sonix chip id: %02x\n", regF1);
1555 if (gspca_dev->audio)
1556 regGpio[1] |= 0x04;
1557 switch (sd->bridge) {
1558 case BRIDGE_SN9C102P:
1559 case BRIDGE_SN9C105:
1560 if (regF1 != 0x11)
1561 return -ENODEV;
1562 break;
1563 default:
1564
1565
1566 if (regF1 != 0x12)
1567 return -ENODEV;
1568 }
1569
1570 switch (sd->sensor) {
1571 case SENSOR_MI0360:
1572 mi0360_probe(gspca_dev);
1573 break;
1574 case SENSOR_OV7630:
1575 ov7630_probe(gspca_dev);
1576 break;
1577 case SENSOR_OV7648:
1578 ov7648_probe(gspca_dev);
1579 break;
1580 case SENSOR_PO2030N:
1581 po2030n_probe(gspca_dev);
1582 break;
1583 }
1584
1585 switch (sd->bridge) {
1586 case BRIDGE_SN9C102P:
1587 reg_w1(gspca_dev, 0x02, regGpio[1]);
1588 break;
1589 default:
1590 reg_w(gspca_dev, 0x01, regGpio, 2);
1591 break;
1592 }
1593
1594
1595
1596 reg_w1(gspca_dev, 0xf1, 0x00);
1597
1598
1599 sn9c1xx = sn_tb[sd->sensor];
1600 sd->i2c_addr = sn9c1xx[9];
1601
1602 return gspca_dev->usb_err;
1603}
1604
1605static int sd_s_ctrl(struct v4l2_ctrl *ctrl);
1606
1607static const struct v4l2_ctrl_ops sd_ctrl_ops = {
1608 .s_ctrl = sd_s_ctrl,
1609};
1610
1611
1612static int sd_init_controls(struct gspca_dev *gspca_dev)
1613{
1614 struct sd *sd = (struct sd *) gspca_dev;
1615 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
1616
1617 gspca_dev->vdev.ctrl_handler = hdl;
1618 v4l2_ctrl_handler_init(hdl, 14);
1619
1620 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1621 V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
1622#define CONTRAST_MAX 127
1623 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1624 V4L2_CID_CONTRAST, 0, CONTRAST_MAX, 1, 20);
1625#define COLORS_DEF 25
1626 sd->saturation = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1627 V4L2_CID_SATURATION, 0, 40, 1, COLORS_DEF);
1628 sd->red_bal = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1629 V4L2_CID_RED_BALANCE, 24, 40, 1, 32);
1630 sd->blue_bal = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1631 V4L2_CID_BLUE_BALANCE, 24, 40, 1, 32);
1632#define GAMMA_DEF 20
1633 sd->gamma = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1634 V4L2_CID_GAMMA, 0, 40, 1, GAMMA_DEF);
1635
1636 if (sd->sensor == SENSOR_OM6802)
1637 sd->sharpness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1638 V4L2_CID_SHARPNESS, 0, 255, 1, 16);
1639 else
1640 sd->sharpness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1641 V4L2_CID_SHARPNESS, 0, 255, 1, 90);
1642
1643 if (sd->flags & F_ILLUM)
1644 sd->illum = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1645 V4L2_CID_ILLUMINATORS_1, 0, 1, 1, 0);
1646
1647 if (sd->sensor == SENSOR_PO2030N) {
1648 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1649 V4L2_CID_EXPOSURE, 500, 1500, 1, 1024);
1650 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1651 V4L2_CID_GAIN, 4, 49, 1, 15);
1652 sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1653 V4L2_CID_HFLIP, 0, 1, 1, 0);
1654 }
1655
1656 if (sd->sensor != SENSOR_ADCM1700 && sd->sensor != SENSOR_OV7660 &&
1657 sd->sensor != SENSOR_PO1030 && sd->sensor != SENSOR_SOI768 &&
1658 sd->sensor != SENSOR_SP80708)
1659 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1660 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1661
1662 if (sd->sensor == SENSOR_HV7131R || sd->sensor == SENSOR_OV7630 ||
1663 sd->sensor == SENSOR_OV7648 || sd->sensor == SENSOR_PO2030N)
1664 sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1665 V4L2_CID_VFLIP, 0, 1, 1, 0);
1666
1667 if (sd->sensor == SENSOR_OV7630 || sd->sensor == SENSOR_OV7648 ||
1668 sd->sensor == SENSOR_OV7660)
1669 sd->freq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
1670 V4L2_CID_POWER_LINE_FREQUENCY,
1671 V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0,
1672 V4L2_CID_POWER_LINE_FREQUENCY_50HZ);
1673
1674 if (hdl->error) {
1675 pr_err("Could not initialize controls\n");
1676 return hdl->error;
1677 }
1678
1679 v4l2_ctrl_cluster(2, &sd->red_bal);
1680 if (sd->sensor == SENSOR_PO2030N) {
1681 v4l2_ctrl_cluster(2, &sd->vflip);
1682 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
1683 }
1684
1685 return 0;
1686}
1687
1688static u32 expo_adjust(struct gspca_dev *gspca_dev,
1689 u32 expo)
1690{
1691 struct sd *sd = (struct sd *) gspca_dev;
1692
1693 switch (sd->sensor) {
1694 case SENSOR_GC0307: {
1695 int a, b;
1696
1697
1698 a = 19 + expo * 25 / 256;
1699 i2c_w1(gspca_dev, 0x68, a);
1700 a -= 12;
1701 b = a * a * 4;
1702 i2c_w1(gspca_dev, 0x03, b >> 8);
1703 i2c_w1(gspca_dev, 0x04, b);
1704 break;
1705 }
1706 case SENSOR_HV7131R: {
1707 u8 Expodoit[] =
1708 { 0xc1, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x16 };
1709
1710 Expodoit[3] = expo >> 16;
1711 Expodoit[4] = expo >> 8;
1712 Expodoit[5] = expo;
1713 i2c_w8(gspca_dev, Expodoit);
1714 break;
1715 }
1716 case SENSOR_MI0360:
1717 case SENSOR_MI0360B: {
1718 u8 expoMi[] =
1719 { 0xb1, 0x5d, 0x09, 0x00, 0x00, 0x00, 0x00, 0x16 };
1720 static const u8 doit[] =
1721 { 0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };
1722 static const u8 sensorgo[] =
1723 { 0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };
1724
1725 if (expo > 0x0635)
1726 expo = 0x0635;
1727 else if (expo < 0x0001)
1728 expo = 0x0001;
1729 expoMi[3] = expo >> 8;
1730 expoMi[4] = expo;
1731 i2c_w8(gspca_dev, expoMi);
1732 i2c_w8(gspca_dev, doit);
1733 i2c_w8(gspca_dev, sensorgo);
1734 break;
1735 }
1736 case SENSOR_MO4000: {
1737 u8 expoMof[] =
1738 { 0xa1, 0x21, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x10 };
1739 u8 expoMo10[] =
1740 { 0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10 };
1741 static const u8 gainMo[] =
1742 { 0xa1, 0x21, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1d };
1743
1744 if (expo > 0x1fff)
1745 expo = 0x1fff;
1746 else if (expo < 0x0001)
1747 expo = 0x0001;
1748 expoMof[3] = (expo & 0x03fc) >> 2;
1749 i2c_w8(gspca_dev, expoMof);
1750 expoMo10[3] = ((expo & 0x1c00) >> 10)
1751 | ((expo & 0x0003) << 4);
1752 i2c_w8(gspca_dev, expoMo10);
1753 i2c_w8(gspca_dev, gainMo);
1754 gspca_dbg(gspca_dev, D_FRAM, "set exposure %d\n",
1755 ((expoMo10[3] & 0x07) << 10)
1756 | (expoMof[3] << 2)
1757 | ((expoMo10[3] & 0x30) >> 4));
1758 break;
1759 }
1760 case SENSOR_MT9V111: {
1761 u8 expo_c1[] =
1762 { 0xb1, 0x5c, 0x09, 0x00, 0x00, 0x00, 0x00, 0x10 };
1763
1764 if (expo > 0x0390)
1765 expo = 0x0390;
1766 else if (expo < 0x0060)
1767 expo = 0x0060;
1768 expo_c1[3] = expo >> 8;
1769 expo_c1[4] = expo;
1770 i2c_w8(gspca_dev, expo_c1);
1771 break;
1772 }
1773 case SENSOR_OM6802: {
1774 u8 gainOm[] =
1775 { 0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10 };
1776
1777
1778 if (expo > 0x03ff)
1779 expo = 0x03ff;
1780 if (expo < 0x0001)
1781 expo = 0x0001;
1782 gainOm[3] = expo >> 2;
1783 i2c_w8(gspca_dev, gainOm);
1784 reg_w1(gspca_dev, 0x96, expo >> 5);
1785 gspca_dbg(gspca_dev, D_FRAM, "set exposure %d\n", gainOm[3]);
1786 break;
1787 }
1788 }
1789 return expo;
1790}
1791
1792static void setbrightness(struct gspca_dev *gspca_dev)
1793{
1794 struct sd *sd = (struct sd *) gspca_dev;
1795 unsigned int expo;
1796 int brightness = sd->brightness->val;
1797 u8 k2;
1798
1799 k2 = (brightness - 0x80) >> 2;
1800 switch (sd->sensor) {
1801 case SENSOR_ADCM1700:
1802 if (k2 > 0x1f)
1803 k2 = 0;
1804 break;
1805 case SENSOR_HV7131R:
1806 expo = brightness << 12;
1807 if (expo > 0x002dc6c0)
1808 expo = 0x002dc6c0;
1809 else if (expo < 0x02a0)
1810 expo = 0x02a0;
1811 sd->exposure = expo_adjust(gspca_dev, expo);
1812 break;
1813 case SENSOR_MI0360:
1814 case SENSOR_MO4000:
1815 expo = brightness << 4;
1816 sd->exposure = expo_adjust(gspca_dev, expo);
1817 break;
1818 case SENSOR_MI0360B:
1819 expo = brightness << 2;
1820 sd->exposure = expo_adjust(gspca_dev, expo);
1821 break;
1822 case SENSOR_GC0307:
1823 expo = brightness;
1824 sd->exposure = expo_adjust(gspca_dev, expo);
1825 return;
1826 case SENSOR_MT9V111:
1827 expo = brightness << 2;
1828 sd->exposure = expo_adjust(gspca_dev, expo);
1829 return;
1830 case SENSOR_OM6802:
1831 expo = brightness << 2;
1832 sd->exposure = expo_adjust(gspca_dev, expo);
1833 return;
1834 }
1835
1836 reg_w1(gspca_dev, 0x96, k2);
1837}
1838
1839static void setcontrast(struct gspca_dev *gspca_dev)
1840{
1841 struct sd *sd = (struct sd *) gspca_dev;
1842 u8 k2;
1843 u8 contrast[6];
1844
1845 k2 = sd->contrast->val * 37 / (CONTRAST_MAX + 1)
1846 + 37;
1847 contrast[0] = (k2 + 1) / 2;
1848 contrast[1] = 0;
1849 contrast[2] = k2;
1850 contrast[3] = 0;
1851 contrast[4] = k2 / 5;
1852 contrast[5] = 0;
1853 reg_w(gspca_dev, 0x84, contrast, sizeof contrast);
1854}
1855
1856static void setcolors(struct gspca_dev *gspca_dev)
1857{
1858 struct sd *sd = (struct sd *) gspca_dev;
1859 int i, v, colors;
1860 const s16 *uv;
1861 u8 reg8a[12];
1862 static const s16 uv_com[6] = {
1863 -24, -38, 64,
1864 62, -51, -9
1865 };
1866 static const s16 uv_mi0360b[6] = {
1867 -20, -38, 64,
1868 60, -51, -9
1869 };
1870
1871 colors = sd->saturation->val;
1872 if (sd->sensor == SENSOR_MI0360B)
1873 uv = uv_mi0360b;
1874 else
1875 uv = uv_com;
1876 for (i = 0; i < 6; i++) {
1877 v = uv[i] * colors / COLORS_DEF;
1878 reg8a[i * 2] = v;
1879 reg8a[i * 2 + 1] = (v >> 8) & 0x0f;
1880 }
1881 reg_w(gspca_dev, 0x8a, reg8a, sizeof reg8a);
1882}
1883
1884static void setredblue(struct gspca_dev *gspca_dev)
1885{
1886 struct sd *sd = (struct sd *) gspca_dev;
1887
1888 if (sd->sensor == SENSOR_PO2030N) {
1889 u8 rg1b[] =
1890 {0xc1, 0x6e, 0x16, 0x00, 0x40, 0x00, 0x00, 0x10};
1891
1892
1893 rg1b[3] = sd->red_bal->val * 2;
1894 rg1b[5] = sd->blue_bal->val * 2;
1895 i2c_w8(gspca_dev, rg1b);
1896 return;
1897 }
1898 reg_w1(gspca_dev, 0x05, sd->red_bal->val);
1899
1900 reg_w1(gspca_dev, 0x06, sd->blue_bal->val);
1901}
1902
1903static void setgamma(struct gspca_dev *gspca_dev)
1904{
1905 struct sd *sd = (struct sd *) gspca_dev;
1906 int i, val;
1907 u8 gamma[17];
1908 const u8 *gamma_base;
1909 static const u8 delta[17] = {
1910 0x00, 0x14, 0x1c, 0x1c, 0x1c, 0x1c, 0x1b, 0x1a,
1911 0x18, 0x13, 0x10, 0x0e, 0x08, 0x07, 0x04, 0x02, 0x00
1912 };
1913
1914 switch (sd->sensor) {
1915 case SENSOR_ADCM1700:
1916 gamma_base = gamma_spec_0;
1917 break;
1918 case SENSOR_HV7131R:
1919 case SENSOR_MI0360B:
1920 case SENSOR_MT9V111:
1921 gamma_base = gamma_spec_1;
1922 break;
1923 case SENSOR_GC0307:
1924 gamma_base = gamma_spec_2;
1925 break;
1926 case SENSOR_SP80708:
1927 gamma_base = gamma_spec_3;
1928 break;
1929 default:
1930 gamma_base = gamma_def;
1931 break;
1932 }
1933
1934 val = sd->gamma->val;
1935 for (i = 0; i < sizeof gamma; i++)
1936 gamma[i] = gamma_base[i]
1937 + delta[i] * (val - GAMMA_DEF) / 32;
1938 reg_w(gspca_dev, 0x20, gamma, sizeof gamma);
1939}
1940
1941static void setexposure(struct gspca_dev *gspca_dev)
1942{
1943 struct sd *sd = (struct sd *) gspca_dev;
1944
1945 if (sd->sensor == SENSOR_PO2030N) {
1946 u8 rexpo[] =
1947 {0xa1, 0x6e, 0x1a, 0x00, 0x40, 0x00, 0x00, 0x10};
1948
1949 rexpo[3] = gspca_dev->exposure->val >> 8;
1950 i2c_w8(gspca_dev, rexpo);
1951 msleep(6);
1952 rexpo[2] = 0x1b;
1953 rexpo[3] = gspca_dev->exposure->val;
1954 i2c_w8(gspca_dev, rexpo);
1955 }
1956}
1957
1958static void setautogain(struct gspca_dev *gspca_dev)
1959{
1960 struct sd *sd = (struct sd *) gspca_dev;
1961
1962 switch (sd->sensor) {
1963 case SENSOR_OV7630:
1964 case SENSOR_OV7648: {
1965 u8 comb;
1966
1967 if (sd->sensor == SENSOR_OV7630)
1968 comb = 0xc0;
1969 else
1970 comb = 0xa0;
1971 if (gspca_dev->autogain->val)
1972 comb |= 0x03;
1973 i2c_w1(&sd->gspca_dev, 0x13, comb);
1974 return;
1975 }
1976 }
1977 if (gspca_dev->autogain->val)
1978 sd->ag_cnt = AG_CNT_START;
1979 else
1980 sd->ag_cnt = -1;
1981}
1982
1983static void setgain(struct gspca_dev *gspca_dev)
1984{
1985 struct sd *sd = (struct sd *) gspca_dev;
1986
1987 if (sd->sensor == SENSOR_PO2030N) {
1988 u8 rgain[] =
1989 {0xa1, 0x6e, 0x15, 0x00, 0x40, 0x00, 0x00, 0x15};
1990
1991 rgain[3] = gspca_dev->gain->val;
1992 i2c_w8(gspca_dev, rgain);
1993 }
1994}
1995
1996static void sethvflip(struct gspca_dev *gspca_dev)
1997{
1998 struct sd *sd = (struct sd *) gspca_dev;
1999 u8 comn;
2000
2001 switch (sd->sensor) {
2002 case SENSOR_HV7131R:
2003 comn = 0x18;
2004 if (sd->vflip->val)
2005 comn |= 0x01;
2006 i2c_w1(gspca_dev, 0x01, comn);
2007 break;
2008 case SENSOR_OV7630:
2009 comn = 0x02;
2010 if (!sd->vflip->val)
2011 comn |= 0x80;
2012 i2c_w1(gspca_dev, 0x75, comn);
2013 break;
2014 case SENSOR_OV7648:
2015 comn = 0x06;
2016 if (sd->vflip->val)
2017 comn |= 0x80;
2018 i2c_w1(gspca_dev, 0x75, comn);
2019 break;
2020 case SENSOR_PO2030N:
2021
2022
2023
2024
2025
2026
2027
2028
2029 comn = 0x0a;
2030 if (sd->hflip->val)
2031 comn |= 0x80;
2032 if (sd->vflip->val)
2033 comn |= 0x40;
2034 i2c_w1(&sd->gspca_dev, 0x1e, comn);
2035 break;
2036 }
2037}
2038
2039static void setsharpness(struct gspca_dev *gspca_dev)
2040{
2041 struct sd *sd = (struct sd *) gspca_dev;
2042
2043 reg_w1(gspca_dev, 0x99, sd->sharpness->val);
2044}
2045
2046static void setillum(struct gspca_dev *gspca_dev)
2047{
2048 struct sd *sd = (struct sd *) gspca_dev;
2049
2050 switch (sd->sensor) {
2051 case SENSOR_ADCM1700:
2052 reg_w1(gspca_dev, 0x02,
2053 sd->illum->val ? 0x64 : 0x60);
2054 break;
2055 case SENSOR_MT9V111:
2056 reg_w1(gspca_dev, 0x02,
2057 sd->illum->val ? 0x77 : 0x74);
2058
2059
2060
2061 break;
2062 }
2063}
2064
2065static void setfreq(struct gspca_dev *gspca_dev)
2066{
2067 struct sd *sd = (struct sd *) gspca_dev;
2068
2069 if (sd->sensor == SENSOR_OV7660) {
2070 u8 com8;
2071
2072 com8 = 0xdf;
2073 switch (sd->freq->val) {
2074 case 0:
2075 i2c_w1(gspca_dev, 0x13, com8 | 0x20);
2076 break;
2077 case 1:
2078 i2c_w1(gspca_dev, 0x13, com8);
2079 i2c_w1(gspca_dev, 0x3b, 0x0a);
2080 break;
2081 case 2:
2082 i2c_w1(gspca_dev, 0x13, com8);
2083 i2c_w1(gspca_dev, 0x3b, 0x02);
2084 break;
2085 }
2086 } else {
2087 u8 reg2a = 0, reg2b = 0, reg2d = 0;
2088
2089
2090 switch (sd->sensor) {
2091 case SENSOR_OV7630:
2092 reg2a = 0x08;
2093 reg2d = 0x01;
2094 break;
2095 case SENSOR_OV7648:
2096 reg2a = 0x11;
2097 reg2d = 0x81;
2098 break;
2099 }
2100
2101 switch (sd->freq->val) {
2102 case 0:
2103 break;
2104 case 1:
2105 reg2a |= 0x80;
2106 reg2b = 0xac;
2107 reg2d |= 0x04;
2108 break;
2109 case 2:
2110 reg2a |= 0x80;
2111 reg2d |= 0x04;
2112 break;
2113 }
2114 i2c_w1(gspca_dev, 0x2a, reg2a);
2115 i2c_w1(gspca_dev, 0x2b, reg2b);
2116 i2c_w1(gspca_dev, 0x2d, reg2d);
2117 }
2118}
2119
2120static void setjpegqual(struct gspca_dev *gspca_dev)
2121{
2122 struct sd *sd = (struct sd *) gspca_dev;
2123
2124 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
2125#if USB_BUF_SZ < 64
2126#error "No room enough in usb_buf for quantization table"
2127#endif
2128 memcpy(gspca_dev->usb_buf, &sd->jpeg_hdr[JPEG_QT0_OFFSET], 64);
2129 usb_control_msg(gspca_dev->dev,
2130 usb_sndctrlpipe(gspca_dev->dev, 0),
2131 0x08,
2132 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
2133 0x0100, 0,
2134 gspca_dev->usb_buf, 64,
2135 500);
2136 memcpy(gspca_dev->usb_buf, &sd->jpeg_hdr[JPEG_QT1_OFFSET], 64);
2137 usb_control_msg(gspca_dev->dev,
2138 usb_sndctrlpipe(gspca_dev->dev, 0),
2139 0x08,
2140 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
2141 0x0140, 0,
2142 gspca_dev->usb_buf, 64,
2143 500);
2144
2145 sd->reg18 ^= 0x40;
2146 reg_w1(gspca_dev, 0x18, sd->reg18);
2147}
2148
2149
2150
2151static void qual_upd(struct work_struct *work)
2152{
2153 struct sd *sd = container_of(work, struct sd, work);
2154 struct gspca_dev *gspca_dev = &sd->gspca_dev;
2155
2156
2157 mutex_lock(&gspca_dev->usb_lock);
2158 gspca_dbg(gspca_dev, D_STREAM, "qual_upd %d%%\n", sd->quality);
2159 gspca_dev->usb_err = 0;
2160 setjpegqual(gspca_dev);
2161 mutex_unlock(&gspca_dev->usb_lock);
2162}
2163
2164
2165static int sd_start(struct gspca_dev *gspca_dev)
2166{
2167 struct sd *sd = (struct sd *) gspca_dev;
2168 int i;
2169 u8 reg01, reg17;
2170 u8 reg0102[2];
2171 const u8 *sn9c1xx;
2172 const u8 (*init)[8];
2173 const u8 *reg9a;
2174 int mode;
2175 static const u8 reg9a_def[] =
2176 {0x00, 0x40, 0x20, 0x00, 0x00, 0x00};
2177 static const u8 reg9a_spec[] =
2178 {0x00, 0x40, 0x38, 0x30, 0x00, 0x20};
2179 static const u8 regd4[] = {0x60, 0x00, 0x00};
2180 static const u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
2181 static const u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
2182 static const u8 CA_adcm1700[] =
2183 { 0x14, 0xec, 0x0a, 0xf6 };
2184 static const u8 CA_po2030n[] =
2185 { 0x1e, 0xe2, 0x14, 0xec };
2186 static const u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd };
2187 static const u8 CE_gc0307[] =
2188 { 0x32, 0xce, 0x2d, 0xd3 };
2189 static const u8 CE_ov76xx[] =
2190 { 0x32, 0xdd, 0x32, 0xdd };
2191 static const u8 CE_po2030n[] =
2192 { 0x14, 0xe7, 0x1e, 0xdd };
2193
2194
2195 jpeg_define(sd->jpeg_hdr, gspca_dev->pixfmt.height,
2196 gspca_dev->pixfmt.width,
2197 0x21);
2198
2199
2200 sn9c1xx = sn_tb[sd->sensor];
2201
2202
2203
2204 reg01 = sn9c1xx[1];
2205 if (sd->flags & F_PDN_INV)
2206 reg01 ^= S_PDN_INV;
2207 reg_w1(gspca_dev, 0x01, reg01);
2208
2209
2210 reg0102[0] = reg01;
2211 reg0102[1] = sn9c1xx[2];
2212 if (gspca_dev->audio)
2213 reg0102[1] |= 0x04;
2214 reg_w(gspca_dev, 0x01, reg0102, 2);
2215 reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2);
2216 reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 5);
2217 switch (sd->sensor) {
2218 case SENSOR_GC0307:
2219 case SENSOR_OV7660:
2220 case SENSOR_PO1030:
2221 case SENSOR_PO2030N:
2222 case SENSOR_SOI768:
2223 case SENSOR_SP80708:
2224 reg9a = reg9a_spec;
2225 break;
2226 default:
2227 reg9a = reg9a_def;
2228 break;
2229 }
2230 reg_w(gspca_dev, 0x9a, reg9a, 6);
2231
2232 reg_w(gspca_dev, 0xd4, regd4, sizeof regd4);
2233
2234 reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
2235
2236 reg17 = sn9c1xx[0x17];
2237 switch (sd->sensor) {
2238 case SENSOR_GC0307:
2239 msleep(50);
2240 break;
2241 case SENSOR_OM6802:
2242 msleep(10);
2243 reg_w1(gspca_dev, 0x02, 0x73);
2244 reg17 |= SEN_CLK_EN;
2245 reg_w1(gspca_dev, 0x17, reg17);
2246 reg_w1(gspca_dev, 0x01, 0x22);
2247 msleep(100);
2248 reg01 = SCL_SEL_OD | S_PDN_INV;
2249 reg17 &= ~MCK_SIZE_MASK;
2250 reg17 |= 0x04;
2251 break;
2252 }
2253 reg01 |= SYS_SEL_48M;
2254 reg_w1(gspca_dev, 0x01, reg01);
2255 reg17 |= SEN_CLK_EN;
2256 reg_w1(gspca_dev, 0x17, reg17);
2257 reg01 &= ~S_PWR_DN;
2258 reg_w1(gspca_dev, 0x01, reg01);
2259 reg01 &= ~SCL_SEL_OD;
2260 reg_w1(gspca_dev, 0x01, reg01);
2261
2262 switch (sd->sensor) {
2263 case SENSOR_HV7131R:
2264 hv7131r_probe(gspca_dev);
2265 break;
2266 case SENSOR_OM6802:
2267 msleep(10);
2268 reg_w1(gspca_dev, 0x01, reg01);
2269 i2c_w8(gspca_dev, om6802_init0[0]);
2270 i2c_w8(gspca_dev, om6802_init0[1]);
2271 msleep(15);
2272 reg_w1(gspca_dev, 0x02, 0x71);
2273 msleep(150);
2274 break;
2275 case SENSOR_SP80708:
2276 msleep(100);
2277 reg_w1(gspca_dev, 0x02, 0x62);
2278 break;
2279 }
2280
2281
2282 i2c_w_seq(gspca_dev, sensor_init[sd->sensor]);
2283
2284 reg_w1(gspca_dev, 0x15, sn9c1xx[0x15]);
2285 reg_w1(gspca_dev, 0x16, sn9c1xx[0x16]);
2286 reg_w1(gspca_dev, 0x12, sn9c1xx[0x12]);
2287 reg_w1(gspca_dev, 0x13, sn9c1xx[0x13]);
2288 reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
2289 if (sd->sensor == SENSOR_ADCM1700) {
2290 reg_w1(gspca_dev, 0xd2, 0x3a);
2291 reg_w1(gspca_dev, 0xd3, 0x30);
2292 } else {
2293 reg_w1(gspca_dev, 0xd2, 0x6a);
2294 reg_w1(gspca_dev, 0xd3, 0x50);
2295 }
2296 reg_w1(gspca_dev, 0xc6, 0x00);
2297 reg_w1(gspca_dev, 0xc7, 0x00);
2298 if (sd->sensor == SENSOR_ADCM1700) {
2299 reg_w1(gspca_dev, 0xc8, 0x2c);
2300 reg_w1(gspca_dev, 0xc9, 0x24);
2301 } else {
2302 reg_w1(gspca_dev, 0xc8, 0x50);
2303 reg_w1(gspca_dev, 0xc9, 0x3c);
2304 }
2305 reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
2306 switch (sd->sensor) {
2307 case SENSOR_OM6802:
2308
2309 break;
2310 default:
2311 reg17 |= DEF_EN;
2312 break;
2313 }
2314 reg_w1(gspca_dev, 0x17, reg17);
2315
2316 reg_w1(gspca_dev, 0x05, 0x00);
2317 reg_w1(gspca_dev, 0x07, 0x00);
2318 reg_w1(gspca_dev, 0x06, 0x00);
2319 reg_w1(gspca_dev, 0x14, sn9c1xx[0x14]);
2320
2321 setgamma(gspca_dev);
2322
2323
2324 for (i = 0; i < 8; i++)
2325 reg_w(gspca_dev, 0x84, reg84, sizeof reg84);
2326 switch (sd->sensor) {
2327 case SENSOR_ADCM1700:
2328 case SENSOR_OV7660:
2329 case SENSOR_SP80708:
2330 reg_w1(gspca_dev, 0x9a, 0x05);
2331 break;
2332 case SENSOR_GC0307:
2333 case SENSOR_MT9V111:
2334 case SENSOR_MI0360B:
2335 reg_w1(gspca_dev, 0x9a, 0x07);
2336 break;
2337 case SENSOR_OV7630:
2338 case SENSOR_OV7648:
2339 reg_w1(gspca_dev, 0x9a, 0x0a);
2340 break;
2341 case SENSOR_PO2030N:
2342 case SENSOR_SOI768:
2343 reg_w1(gspca_dev, 0x9a, 0x06);
2344 break;
2345 default:
2346 reg_w1(gspca_dev, 0x9a, 0x08);
2347 break;
2348 }
2349 setsharpness(gspca_dev);
2350
2351 reg_w(gspca_dev, 0x84, reg84, sizeof reg84);
2352 reg_w1(gspca_dev, 0x05, 0x20);
2353 reg_w1(gspca_dev, 0x07, 0x20);
2354 reg_w1(gspca_dev, 0x06, 0x20);
2355
2356 init = NULL;
2357 mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
2358 reg01 |= SYS_SEL_48M | V_TX_EN;
2359 reg17 &= ~MCK_SIZE_MASK;
2360 reg17 |= 0x02;
2361 switch (sd->sensor) {
2362 case SENSOR_ADCM1700:
2363 init = adcm1700_sensor_param1;
2364 break;
2365 case SENSOR_GC0307:
2366 init = gc0307_sensor_param1;
2367 break;
2368 case SENSOR_HV7131R:
2369 case SENSOR_MI0360:
2370 if (!mode)
2371 reg01 &= ~SYS_SEL_48M;
2372 reg17 &= ~MCK_SIZE_MASK;
2373 reg17 |= 0x01;
2374 break;
2375 case SENSOR_MI0360B:
2376 init = mi0360b_sensor_param1;
2377 break;
2378 case SENSOR_MO4000:
2379 if (mode) {
2380 reg01 &= ~SYS_SEL_48M;
2381 reg17 &= ~MCK_SIZE_MASK;
2382 reg17 |= 0x01;
2383 }
2384 break;
2385 case SENSOR_MT9V111:
2386 init = mt9v111_sensor_param1;
2387 break;
2388 case SENSOR_OM6802:
2389 init = om6802_sensor_param1;
2390 if (!mode) {
2391 reg17 &= ~MCK_SIZE_MASK;
2392 reg17 |= 0x04;
2393 } else {
2394 reg01 &= ~SYS_SEL_48M;
2395 reg17 &= ~MCK_SIZE_MASK;
2396 reg17 |= 0x02;
2397 }
2398 break;
2399 case SENSOR_OV7630:
2400 init = ov7630_sensor_param1;
2401 break;
2402 case SENSOR_OV7648:
2403 init = ov7648_sensor_param1;
2404 reg17 &= ~MCK_SIZE_MASK;
2405 reg17 |= 0x01;
2406 break;
2407 case SENSOR_OV7660:
2408 init = ov7660_sensor_param1;
2409 break;
2410 case SENSOR_PO1030:
2411 init = po1030_sensor_param1;
2412 break;
2413 case SENSOR_PO2030N:
2414 init = po2030n_sensor_param1;
2415 break;
2416 case SENSOR_SOI768:
2417 init = soi768_sensor_param1;
2418 break;
2419 case SENSOR_SP80708:
2420 init = sp80708_sensor_param1;
2421 break;
2422 }
2423
2424
2425 if (init != NULL) {
2426 i2c_w_seq(gspca_dev, init);
2427
2428 }
2429
2430 reg_w(gspca_dev, 0xc0, C0, 6);
2431 switch (sd->sensor) {
2432 case SENSOR_ADCM1700:
2433 case SENSOR_GC0307:
2434 case SENSOR_SOI768:
2435 reg_w(gspca_dev, 0xca, CA_adcm1700, 4);
2436 break;
2437 case SENSOR_PO2030N:
2438 reg_w(gspca_dev, 0xca, CA_po2030n, 4);
2439 break;
2440 default:
2441 reg_w(gspca_dev, 0xca, CA, 4);
2442 break;
2443 }
2444 switch (sd->sensor) {
2445 case SENSOR_ADCM1700:
2446 case SENSOR_OV7630:
2447 case SENSOR_OV7648:
2448 case SENSOR_OV7660:
2449 case SENSOR_SOI768:
2450 reg_w(gspca_dev, 0xce, CE_ov76xx, 4);
2451 break;
2452 case SENSOR_GC0307:
2453 reg_w(gspca_dev, 0xce, CE_gc0307, 4);
2454 break;
2455 case SENSOR_PO2030N:
2456 reg_w(gspca_dev, 0xce, CE_po2030n, 4);
2457 break;
2458 default:
2459 reg_w(gspca_dev, 0xce, CE, 4);
2460
2461 break;
2462 }
2463
2464
2465 sd->reg18 = sn9c1xx[0x18] | (mode << 4) | 0x40;
2466 reg_w1(gspca_dev, 0x18, sd->reg18);
2467 setjpegqual(gspca_dev);
2468
2469 reg_w1(gspca_dev, 0x17, reg17);
2470 reg_w1(gspca_dev, 0x01, reg01);
2471 sd->reg01 = reg01;
2472 sd->reg17 = reg17;
2473
2474 sd->pktsz = sd->npkt = 0;
2475 sd->nchg = sd->short_mark = 0;
2476
2477 return gspca_dev->usb_err;
2478}
2479
2480static void sd_stopN(struct gspca_dev *gspca_dev)
2481{
2482 struct sd *sd = (struct sd *) gspca_dev;
2483 static const u8 stophv7131[] =
2484 { 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 };
2485 static const u8 stopmi0360[] =
2486 { 0xb1, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10 };
2487 static const u8 stopov7648[] =
2488 { 0xa1, 0x21, 0x76, 0x20, 0x00, 0x00, 0x00, 0x10 };
2489 static const u8 stopsoi768[] =
2490 { 0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10 };
2491 u8 reg01;
2492 u8 reg17;
2493
2494 reg01 = sd->reg01;
2495 reg17 = sd->reg17 & ~SEN_CLK_EN;
2496 switch (sd->sensor) {
2497 case SENSOR_ADCM1700:
2498 case SENSOR_GC0307:
2499 case SENSOR_PO2030N:
2500 case SENSOR_SP80708:
2501 reg01 |= LED;
2502 reg_w1(gspca_dev, 0x01, reg01);
2503 reg01 &= ~(LED | V_TX_EN);
2504 reg_w1(gspca_dev, 0x01, reg01);
2505
2506 break;
2507 case SENSOR_HV7131R:
2508 reg01 &= ~V_TX_EN;
2509 reg_w1(gspca_dev, 0x01, reg01);
2510 i2c_w8(gspca_dev, stophv7131);
2511 break;
2512 case SENSOR_MI0360:
2513 case SENSOR_MI0360B:
2514 reg01 &= ~V_TX_EN;
2515 reg_w1(gspca_dev, 0x01, reg01);
2516
2517 i2c_w8(gspca_dev, stopmi0360);
2518 break;
2519 case SENSOR_MT9V111:
2520 case SENSOR_OM6802:
2521 case SENSOR_PO1030:
2522 reg01 &= ~V_TX_EN;
2523 reg_w1(gspca_dev, 0x01, reg01);
2524 break;
2525 case SENSOR_OV7630:
2526 case SENSOR_OV7648:
2527 reg01 &= ~V_TX_EN;
2528 reg_w1(gspca_dev, 0x01, reg01);
2529 i2c_w8(gspca_dev, stopov7648);
2530 break;
2531 case SENSOR_OV7660:
2532 reg01 &= ~V_TX_EN;
2533 reg_w1(gspca_dev, 0x01, reg01);
2534 break;
2535 case SENSOR_SOI768:
2536 i2c_w8(gspca_dev, stopsoi768);
2537 break;
2538 }
2539
2540 reg01 |= SCL_SEL_OD;
2541 reg_w1(gspca_dev, 0x01, reg01);
2542 reg01 |= S_PWR_DN;
2543 reg_w1(gspca_dev, 0x01, reg01);
2544 reg_w1(gspca_dev, 0x17, reg17);
2545 reg01 &= ~SYS_SEL_48M;
2546 reg_w1(gspca_dev, 0x01, reg01);
2547 reg01 |= LED;
2548 reg_w1(gspca_dev, 0x01, reg01);
2549
2550
2551}
2552
2553
2554
2555static void sd_stop0(struct gspca_dev *gspca_dev)
2556{
2557 struct sd *sd = (struct sd *) gspca_dev;
2558
2559 mutex_unlock(&gspca_dev->usb_lock);
2560 flush_work(&sd->work);
2561 mutex_lock(&gspca_dev->usb_lock);
2562}
2563
2564static void do_autogain(struct gspca_dev *gspca_dev)
2565{
2566 struct sd *sd = (struct sd *) gspca_dev;
2567 int delta;
2568 int expotimes;
2569 u8 luma_mean = 130;
2570 u8 luma_delta = 20;
2571
2572
2573 if (sd->ag_cnt < 0)
2574 return;
2575 if (--sd->ag_cnt >= 0)
2576 return;
2577 sd->ag_cnt = AG_CNT_START;
2578
2579 delta = atomic_read(&sd->avg_lum);
2580 gspca_dbg(gspca_dev, D_FRAM, "mean lum %d\n", delta);
2581
2582 if (sd->sensor == SENSOR_PO2030N) {
2583 gspca_expo_autogain(gspca_dev, delta, luma_mean, luma_delta,
2584 15, 1024);
2585 return;
2586 }
2587
2588 if (delta < luma_mean - luma_delta ||
2589 delta > luma_mean + luma_delta) {
2590 switch (sd->sensor) {
2591 case SENSOR_GC0307:
2592 expotimes = sd->exposure;
2593 expotimes += (luma_mean - delta) >> 6;
2594 if (expotimes < 0)
2595 expotimes = 0;
2596 sd->exposure = expo_adjust(gspca_dev,
2597 (unsigned int) expotimes);
2598 break;
2599 case SENSOR_HV7131R:
2600 expotimes = sd->exposure >> 8;
2601 expotimes += (luma_mean - delta) >> 4;
2602 if (expotimes < 0)
2603 expotimes = 0;
2604 sd->exposure = expo_adjust(gspca_dev,
2605 (unsigned int) (expotimes << 8));
2606 break;
2607 case SENSOR_OM6802:
2608 case SENSOR_MT9V111:
2609 expotimes = sd->exposure;
2610 expotimes += (luma_mean - delta) >> 2;
2611 if (expotimes < 0)
2612 expotimes = 0;
2613 sd->exposure = expo_adjust(gspca_dev,
2614 (unsigned int) expotimes);
2615 setredblue(gspca_dev);
2616 break;
2617 default:
2618
2619
2620
2621 expotimes = sd->exposure;
2622 expotimes += (luma_mean - delta) >> 6;
2623 if (expotimes < 0)
2624 expotimes = 0;
2625 sd->exposure = expo_adjust(gspca_dev,
2626 (unsigned int) expotimes);
2627 setredblue(gspca_dev);
2628 break;
2629 }
2630 }
2631}
2632
2633
2634static void set_lum(struct sd *sd,
2635 u8 *data)
2636{
2637 int avg_lum;
2638
2639
2640
2641
2642
2643 avg_lum = (data[27] << 8) + data[28]
2644
2645 + (data[31] << 8) + data[32]
2646
2647 + (data[23] << 8) + data[24]
2648
2649 + (data[35] << 8) + data[36]
2650
2651 + (data[29] << 10) + (data[30] << 2);
2652 avg_lum >>= 10;
2653 atomic_set(&sd->avg_lum, avg_lum);
2654}
2655
2656
2657
2658static void sd_pkt_scan(struct gspca_dev *gspca_dev,
2659 u8 *data,
2660 int len)
2661{
2662 struct sd *sd = (struct sd *) gspca_dev;
2663 int i, new_qual;
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682 sd->npkt++;
2683 sd->pktsz += len;
2684
2685
2686
2687
2688
2689
2690 i = sd->short_mark;
2691 if (i != 0) {
2692 sd->short_mark = 0;
2693 if (i < 0
2694 && data[0] == 0xff
2695 && data[1] == 0x00)
2696 goto marker_found;
2697 if (data[0] == 0xff && data[1] == 0xff) {
2698 i = 0;
2699 goto marker_found;
2700 }
2701 len -= i;
2702 if (len <= 0)
2703 return;
2704 data += i;
2705 }
2706
2707
2708 for (i = len - 1; --i >= 0; ) {
2709 if (data[i] != 0xff) {
2710 i--;
2711 continue;
2712 }
2713 if (data[i + 1] == 0xff) {
2714
2715
2716 if (i + 2 >= len || data[i + 2] == 0x00)
2717 goto marker_found;
2718 }
2719 }
2720
2721
2722
2723 if (data[len - 1] == 0xff)
2724 sd->short_mark = -1;
2725 if (gspca_dev->last_packet_type == LAST_PACKET)
2726 gspca_frame_add(gspca_dev, FIRST_PACKET,
2727 sd->jpeg_hdr, JPEG_HDR_SZ);
2728 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
2729 return;
2730
2731
2732
2733marker_found:
2734 new_qual = 0;
2735 if (i > 2) {
2736 if (data[i - 2] != 0xff || data[i - 1] != 0xd9) {
2737 gspca_dev->last_packet_type = DISCARD_PACKET;
2738 new_qual = -3;
2739 }
2740 } else if (i + 6 < len) {
2741 if (data[i + 6] & 0x08) {
2742 gspca_dev->last_packet_type = DISCARD_PACKET;
2743 new_qual = -5;
2744 }
2745 }
2746
2747 gspca_frame_add(gspca_dev, LAST_PACKET, data, i);
2748
2749
2750 if (new_qual == 0) {
2751 int r;
2752
2753 r = (sd->pktsz * 100) /
2754 (sd->npkt *
2755 gspca_dev->urb[0]->iso_frame_desc[0].length);
2756 if (r >= 85)
2757 new_qual = -3;
2758 else if (r < 75)
2759 new_qual = 2;
2760 }
2761 if (new_qual != 0) {
2762 sd->nchg += new_qual;
2763 if (sd->nchg < -6 || sd->nchg >= 12) {
2764 sd->nchg = 0;
2765 new_qual += sd->quality;
2766 if (new_qual < QUALITY_MIN)
2767 new_qual = QUALITY_MIN;
2768 else if (new_qual > QUALITY_MAX)
2769 new_qual = QUALITY_MAX;
2770 if (new_qual != sd->quality) {
2771 sd->quality = new_qual;
2772 schedule_work(&sd->work);
2773 }
2774 }
2775 } else {
2776 sd->nchg = 0;
2777 }
2778 sd->pktsz = sd->npkt = 0;
2779
2780
2781
2782 if (i + 62 > len) {
2783 sd->short_mark = i + 62 - len;
2784 return;
2785 }
2786 if (sd->ag_cnt >= 0)
2787 set_lum(sd, data + i);
2788
2789
2790 i += 62;
2791 if (i < len) {
2792 data += i;
2793 len -= i;
2794 gspca_frame_add(gspca_dev, FIRST_PACKET,
2795 sd->jpeg_hdr, JPEG_HDR_SZ);
2796 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
2797 }
2798}
2799
2800static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
2801{
2802 struct gspca_dev *gspca_dev =
2803 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
2804
2805 gspca_dev->usb_err = 0;
2806
2807 if (!gspca_dev->streaming)
2808 return 0;
2809
2810 switch (ctrl->id) {
2811 case V4L2_CID_BRIGHTNESS:
2812 setbrightness(gspca_dev);
2813 break;
2814 case V4L2_CID_CONTRAST:
2815 setcontrast(gspca_dev);
2816 break;
2817 case V4L2_CID_SATURATION:
2818 setcolors(gspca_dev);
2819 break;
2820 case V4L2_CID_RED_BALANCE:
2821 setredblue(gspca_dev);
2822 break;
2823 case V4L2_CID_GAMMA:
2824 setgamma(gspca_dev);
2825 break;
2826 case V4L2_CID_AUTOGAIN:
2827 setautogain(gspca_dev);
2828 setexposure(gspca_dev);
2829 setgain(gspca_dev);
2830 break;
2831 case V4L2_CID_VFLIP:
2832 sethvflip(gspca_dev);
2833 break;
2834 case V4L2_CID_SHARPNESS:
2835 setsharpness(gspca_dev);
2836 break;
2837 case V4L2_CID_ILLUMINATORS_1:
2838 setillum(gspca_dev);
2839 break;
2840 case V4L2_CID_POWER_LINE_FREQUENCY:
2841 setfreq(gspca_dev);
2842 break;
2843 default:
2844 return -EINVAL;
2845 }
2846 return gspca_dev->usb_err;
2847}
2848
2849#if IS_ENABLED(CONFIG_INPUT)
2850static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
2851 u8 *data,
2852 int len)
2853{
2854 int ret = -EINVAL;
2855
2856 if (len == 1 && data[0] == 1) {
2857 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
2858 input_sync(gspca_dev->input_dev);
2859 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
2860 input_sync(gspca_dev->input_dev);
2861 ret = 0;
2862 }
2863
2864 return ret;
2865}
2866#endif
2867
2868
2869static const struct sd_desc sd_desc = {
2870 .name = MODULE_NAME,
2871 .config = sd_config,
2872 .init = sd_init,
2873 .init_controls = sd_init_controls,
2874 .start = sd_start,
2875 .stopN = sd_stopN,
2876 .stop0 = sd_stop0,
2877 .pkt_scan = sd_pkt_scan,
2878 .dq_callback = do_autogain,
2879#if IS_ENABLED(CONFIG_INPUT)
2880 .int_pkt_scan = sd_int_pkt_scan,
2881#endif
2882};
2883
2884
2885#define BS(bridge, sensor) \
2886 .driver_info = (BRIDGE_ ## bridge << 16) \
2887 | (SENSOR_ ## sensor << 8)
2888#define BSF(bridge, sensor, flags) \
2889 .driver_info = (BRIDGE_ ## bridge << 16) \
2890 | (SENSOR_ ## sensor << 8) \
2891 | (flags)
2892static const struct usb_device_id device_table[] = {
2893 {USB_DEVICE(0x0458, 0x7025), BSF(SN9C120, MI0360B, F_PDN_INV)},
2894 {USB_DEVICE(0x0458, 0x702e), BS(SN9C120, OV7660)},
2895 {USB_DEVICE(0x045e, 0x00f5), BSF(SN9C105, OV7660, F_PDN_INV)},
2896 {USB_DEVICE(0x045e, 0x00f7), BSF(SN9C105, OV7660, F_PDN_INV)},
2897 {USB_DEVICE(0x0471, 0x0327), BS(SN9C105, MI0360)},
2898 {USB_DEVICE(0x0471, 0x0328), BS(SN9C105, MI0360)},
2899 {USB_DEVICE(0x0471, 0x0330), BS(SN9C105, MI0360)},
2900 {USB_DEVICE(0x06f8, 0x3004), BS(SN9C105, OV7660)},
2901 {USB_DEVICE(0x06f8, 0x3008), BS(SN9C105, OV7660)},
2902
2903 {USB_DEVICE(0x0c45, 0x6040), BS(SN9C102P, HV7131R)},
2904
2905
2906 {USB_DEVICE(0x0c45, 0x607c), BS(SN9C102P, HV7131R)},
2907
2908 {USB_DEVICE(0x0c45, 0x60c0), BSF(SN9C105, MI0360, F_ILLUM)},
2909
2910
2911
2912
2913 {USB_DEVICE(0x0c45, 0x60ce), BS(SN9C105, SP80708)},
2914 {USB_DEVICE(0x0c45, 0x60ec), BS(SN9C105, MO4000)},
2915
2916
2917
2918 {USB_DEVICE(0x0c45, 0x60fb), BS(SN9C105, OV7660)},
2919 {USB_DEVICE(0x0c45, 0x60fc), BS(SN9C105, HV7131R)},
2920 {USB_DEVICE(0x0c45, 0x60fe), BS(SN9C105, OV7630)},
2921 {USB_DEVICE(0x0c45, 0x6100), BS(SN9C120, MI0360)},
2922 {USB_DEVICE(0x0c45, 0x6102), BS(SN9C120, PO2030N)},
2923
2924 {USB_DEVICE(0x0c45, 0x610a), BS(SN9C120, OV7648)},
2925 {USB_DEVICE(0x0c45, 0x610b), BS(SN9C120, OV7660)},
2926 {USB_DEVICE(0x0c45, 0x610c), BS(SN9C120, HV7131R)},
2927 {USB_DEVICE(0x0c45, 0x610e), BS(SN9C120, OV7630)},
2928
2929
2930
2931 {USB_DEVICE(0x0c45, 0x6128), BS(SN9C120, OM6802)},
2932
2933 {USB_DEVICE(0x0c45, 0x612a), BS(SN9C120, OV7648)},
2934 {USB_DEVICE(0x0c45, 0x612b), BS(SN9C110, ADCM1700)},
2935 {USB_DEVICE(0x0c45, 0x612c), BS(SN9C110, MO4000)},
2936 {USB_DEVICE(0x0c45, 0x612e), BS(SN9C110, OV7630)},
2937
2938 {USB_DEVICE(0x0c45, 0x6130), BS(SN9C120, MI0360)},
2939
2940
2941 {USB_DEVICE(0x0c45, 0x6138), BS(SN9C120, MO4000)},
2942 {USB_DEVICE(0x0c45, 0x613a), BS(SN9C120, OV7648)},
2943 {USB_DEVICE(0x0c45, 0x613b), BS(SN9C120, OV7660)},
2944 {USB_DEVICE(0x0c45, 0x613c), BS(SN9C120, HV7131R)},
2945 {USB_DEVICE(0x0c45, 0x613e), BS(SN9C120, OV7630)},
2946 {USB_DEVICE(0x0c45, 0x6142), BS(SN9C120, PO2030N)},
2947
2948 {USB_DEVICE(0x0c45, 0x6143), BS(SN9C120, SP80708)},
2949 {USB_DEVICE(0x0c45, 0x6148), BS(SN9C120, OM6802)},
2950 {USB_DEVICE(0x0c45, 0x614a), BSF(SN9C120, ADCM1700, F_ILLUM)},
2951
2952 {}
2953};
2954MODULE_DEVICE_TABLE(usb, device_table);
2955
2956
2957static int sd_probe(struct usb_interface *intf,
2958 const struct usb_device_id *id)
2959{
2960 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
2961 THIS_MODULE);
2962}
2963
2964static struct usb_driver sd_driver = {
2965 .name = MODULE_NAME,
2966 .id_table = device_table,
2967 .probe = sd_probe,
2968 .disconnect = gspca_disconnect,
2969#ifdef CONFIG_PM
2970 .suspend = gspca_suspend,
2971 .resume = gspca_resume,
2972 .reset_resume = gspca_resume,
2973#endif
2974};
2975
2976module_usb_driver(sd_driver);
2977