?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added 2.6.29.6 aldebaran kernel
[nao-ulib.git] / kernel / 2.6.29.6-aldebaran-rt / drivers / media / video / gspca / sonixj.c
blob3373b8d9d2a88fa92c8ec40feb5d4d207d9b17ab
1 /*
2 * Sonix sn9c102p sn9c105 sn9c120 (jpeg) library
3 * Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr
4 *
5 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #define MODULE_NAME "sonixj"
23
24 #include "gspca.h"
25 #include "jpeg.h"
26
27 #define V4L2_CID_INFRARED (V4L2_CID_PRIVATE_BASE + 0)
28
29 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
30 MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver");
31 MODULE_LICENSE("GPL");
32
33 /* specific webcam descriptor */
34 struct sd {
35 struct gspca_dev gspca_dev; /* !! must be the first item */
36
37 atomic_t avg_lum;
38 unsigned int exposure;
39
40 __u16 brightness;
41 __u8 contrast;
42 __u8 colors;
43 __u8 autogain;
44 __u8 blue;
45 __u8 red;
46 __u8 vflip; /* ov7630 only */
47 __u8 infrared; /* mi0360 only */
48
49 __s8 ag_cnt;
50 #define AG_CNT_START 13
51
52 __u8 qindex;
53 __u8 bridge;
54 #define BRIDGE_SN9C102P 0
55 #define BRIDGE_SN9C105 1
56 #define BRIDGE_SN9C110 2
57 #define BRIDGE_SN9C120 3
58 #define BRIDGE_SN9C325 4
59 __u8 sensor; /* Type of image sensor chip */
60 #define SENSOR_HV7131R 0
61 #define SENSOR_MI0360 1
62 #define SENSOR_MO4000 2
63 #define SENSOR_OM6802 3
64 #define SENSOR_OV7630 4
65 #define SENSOR_OV7648 5
66 #define SENSOR_OV7660 6
67 __u8 i2c_base;
68 };
69
70 /* V4L2 controls supported by the driver */
71 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
72 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
73 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
74 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
75 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
76 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
77 static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val);
78 static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val);
79 static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val);
80 static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val);
81 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
82 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
83 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
84 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
85 static int sd_setinfrared(struct gspca_dev *gspca_dev, __s32 val);
86 static int sd_getinfrared(struct gspca_dev *gspca_dev, __s32 *val);
87
88 static struct ctrl sd_ctrls[] = {
89 {
90 {
91 .id = V4L2_CID_BRIGHTNESS,
92 .type = V4L2_CTRL_TYPE_INTEGER,
93 .name = "Brightness",
94 .minimum = 0,
95 #define BRIGHTNESS_MAX 0xffff
96 .maximum = BRIGHTNESS_MAX,
97 .step = 1,
98 #define BRIGHTNESS_DEF 0x8000
99 .default_value = BRIGHTNESS_DEF,
100 },
101 .set = sd_setbrightness,
102 .get = sd_getbrightness,
103 },
104 {
105 {
106 .id = V4L2_CID_CONTRAST,
107 .type = V4L2_CTRL_TYPE_INTEGER,
108 .name = "Contrast",
109 .minimum = 0,
110 #define CONTRAST_MAX 127
111 .maximum = CONTRAST_MAX,
112 .step = 1,
113 #define CONTRAST_DEF 63
114 .default_value = CONTRAST_DEF,
115 },
116 .set = sd_setcontrast,
117 .get = sd_getcontrast,
118 },
119 {
120 {
121 .id = V4L2_CID_SATURATION,
122 .type = V4L2_CTRL_TYPE_INTEGER,
123 .name = "Color",
124 .minimum = 0,
125 .maximum = 40,
126 .step = 1,
127 #define COLOR_DEF 32
128 .default_value = COLOR_DEF,
129 },
130 .set = sd_setcolors,
131 .get = sd_getcolors,
132 },
133 {
134 {
135 .id = V4L2_CID_BLUE_BALANCE,
136 .type = V4L2_CTRL_TYPE_INTEGER,
137 .name = "Blue Balance",
138 .minimum = 24,
139 .maximum = 40,
140 .step = 1,
141 #define BLUE_BALANCE_DEF 32
142 .default_value = BLUE_BALANCE_DEF,
143 },
144 .set = sd_setblue_balance,
145 .get = sd_getblue_balance,
146 },
147 {
148 {
149 .id = V4L2_CID_RED_BALANCE,
150 .type = V4L2_CTRL_TYPE_INTEGER,
151 .name = "Red Balance",
152 .minimum = 24,
153 .maximum = 40,
154 .step = 1,
155 #define RED_BALANCE_DEF 32
156 .default_value = RED_BALANCE_DEF,
157 },
158 .set = sd_setred_balance,
159 .get = sd_getred_balance,
160 },
161 #define AUTOGAIN_IDX 5
162 {
163 {
164 .id = V4L2_CID_AUTOGAIN,
165 .type = V4L2_CTRL_TYPE_BOOLEAN,
166 .name = "Auto Gain",
167 .minimum = 0,
168 .maximum = 1,
169 .step = 1,
170 #define AUTOGAIN_DEF 1
171 .default_value = AUTOGAIN_DEF,
172 },
173 .set = sd_setautogain,
174 .get = sd_getautogain,
175 },
176 /* ov7630 only */
177 #define VFLIP_IDX 6
178 {
179 {
180 .id = V4L2_CID_VFLIP,
181 .type = V4L2_CTRL_TYPE_BOOLEAN,
182 .name = "Vflip",
183 .minimum = 0,
184 .maximum = 1,
185 .step = 1,
186 #define VFLIP_DEF 1
187 .default_value = VFLIP_DEF,
188 },
189 .set = sd_setvflip,
190 .get = sd_getvflip,
191 },
192 /* mi0360 only */
193 #define INFRARED_IDX 7
194 {
195 {
196 .id = V4L2_CID_INFRARED,
197 .type = V4L2_CTRL_TYPE_BOOLEAN,
198 .name = "Infrared",
199 .minimum = 0,
200 .maximum = 1,
201 .step = 1,
202 #define INFRARED_DEF 0
203 .default_value = INFRARED_DEF,
204 },
205 .set = sd_setinfrared,
206 .get = sd_getinfrared,
207 },
208 };
209
210 /* table of the disabled controls */
211 static __u32 ctrl_dis[] = {
212 (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
213 /* SENSOR_HV7131R 0 */
214 (1 << VFLIP_IDX),
215 /* SENSOR_MI0360 1 */
216 (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
217 /* SENSOR_MO4000 2 */
218 (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
219 /* SENSOR_OM6802 3 */
220 (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX),
221 /* SENSOR_OV7630 4 */
222 (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
223 /* SENSOR_OV7648 5 */
224 (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
225 /* SENSOR_OV7660 6 */
226 };
227
228 static const struct v4l2_pix_format vga_mode[] = {
229 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
230 .bytesperline = 160,
231 .sizeimage = 160 * 120 * 4 / 8 + 590,
232 .colorspace = V4L2_COLORSPACE_JPEG,
233 .priv = 2},
234 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
235 .bytesperline = 320,
236 .sizeimage = 320 * 240 * 3 / 8 + 590,
237 .colorspace = V4L2_COLORSPACE_JPEG,
238 .priv = 1},
239 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
240 .bytesperline = 640,
241 .sizeimage = 640 * 480 * 3 / 8 + 590,
242 .colorspace = V4L2_COLORSPACE_JPEG,
243 .priv = 0},
244 };
245
246 /*Data from sn9c102p+hv71331r */
247 static const __u8 sn_hv7131[] = {
248 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
249 0x00, 0x03, 0x64, 0x00, 0x1a, 0x20, 0x20, 0x20,
250 /* reg8 reg9 rega regb regc regd rege regf */
251 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10,
252 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
253 0x03, 0x00, 0x00, 0x01, 0x03, 0x28, 0x1e, 0x41,
254 /* reg18 reg19 reg1a reg1b reg1c reg1d reg1e reg1f */
255 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
256 };
257
258 static const __u8 sn_mi0360[] = {
259 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
260 0x00, 0x61, 0x44, 0x00, 0x1a, 0x20, 0x20, 0x20,
261 /* reg8 reg9 rega regb regc regd rege regf */
262 0xb1, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10,
263 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
264 0x03, 0x00, 0x00, 0x02, 0x0a, 0x28, 0x1e, 0x61,
265 /* reg18 reg19 reg1a reg1b reg1c reg1d reg1e reg1f */
266 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
267 };
268
269 static const __u8 sn_mo4000[] = {
270 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
271 0x12, 0x23, 0x60, 0x00, 0x1a, 0x00, 0x20, 0x18,
272 /* reg8 reg9 rega regb regc regd rege regf */
273 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
274 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
275 0x03, 0x00, 0x0b, 0x0f, 0x14, 0x28, 0x1e, 0x40,
276 /* reg18 reg19 reg1a reg1b reg1c reg1d reg1e reg1f */
277 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
278 };
279
280 static const __u8 sn_om6802[] = {
281 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
282 0x00, 0x23, 0x72, 0x00, 0x1a, 0x34, 0x27, 0x20,
283 /* reg8 reg9 rega regb regc regd rege regf */
284 0x80, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
285 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
286 0x03, 0x00, 0x51, 0x01, 0x00, 0x28, 0x1e, 0x40,
287 /* reg18 reg19 reg1a reg1b reg1c reg1d reg1e reg1f */
288 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
289 0x08, 0x22, 0x44, 0x63, 0x7d, 0x92, 0xa3, 0xaf,
290 0xbc, 0xc4, 0xcd, 0xd5, 0xdc, 0xe1, 0xe8, 0xef,
291 0xf7
292 };
293
294 static const __u8 sn_ov7630[] = {
295 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
296 0x00, 0x21, 0x40, 0x00, 0x1a, 0x20, 0x1f, 0x20,
297 /* reg8 reg9 rega regb regc regd rege regf */
298 0xa1, 0x21, 0x76, 0x21, 0x00, 0x00, 0x00, 0x10,
299 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
300 0x03, 0x00, 0x04, 0x01, 0x0a, 0x28, 0x1e, 0xc2,
301 /* reg18 reg19 reg1a reg1b reg1c reg1d reg1e reg1f */
302 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00
303 };
304
305 static const __u8 sn_ov7648[] = {
306 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
307 0x00, 0x63, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
308 /* reg8 reg9 rega regb regc regd rege regf */
309 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
310 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
311 0x03, 0x00, 0x00, 0x01, 0x00, 0x28, 0x1e, 0x00,
312 /* reg18 reg19 reg1a reg1b reg1c reg1d reg1e reg1f */
313 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00
314 };
315
316 static const __u8 sn_ov7660[] = {
317 /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
318 0x00, 0x61, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
319 /* reg8 reg9 rega regb regc regd rege regf */
320 0x81, 0x21, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10,
321 /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
322 0x03, 0x00, 0x01, 0x01, 0x08, 0x28, 0x1e, 0x20,
323 /* reg18 reg19 reg1a reg1b reg1c reg1d reg1e reg1f */
324 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
325 };
326
327 /* sequence specific to the sensors - !! index = SENSOR_xxx */
328 static const __u8 *sn_tb[] = {
329 sn_hv7131,
330 sn_mi0360,
331 sn_mo4000,
332 sn_om6802,
333 sn_ov7630,
334 sn_ov7648,
335 sn_ov7660
336 };
337
338 static const __u8 gamma_def[] = {
339 0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
340 0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
341 };
342
343 /* color matrix and offsets */
344 static const __u8 reg84[] = {
345 0x14, 0x00, 0x27, 0x00, 0x07, 0x00, /* YR YG YB gains */
346 0xe8, 0x0f, 0xda, 0x0f, 0x40, 0x00, /* UR UG UB */
347 0x3e, 0x00, 0xcd, 0x0f, 0xf7, 0x0f, /* VR VG VB */
348 0x00, 0x00, 0x00 /* YUV offsets */
349 };
350 static const __u8 hv7131r_sensor_init[][8] = {
351 {0xC1, 0x11, 0x01, 0x08, 0x01, 0x00, 0x00, 0x10},
352 {0xB1, 0x11, 0x34, 0x17, 0x7F, 0x00, 0x00, 0x10},
353 {0xD1, 0x11, 0x40, 0xFF, 0x7F, 0x7F, 0x7F, 0x10},
354 {0x91, 0x11, 0x44, 0x00, 0x00, 0x00, 0x00, 0x10},
355 {0xD1, 0x11, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
356 {0xD1, 0x11, 0x14, 0x01, 0xE2, 0x02, 0x82, 0x10},
357 {0x91, 0x11, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
358
359 {0xA1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
360 {0xA1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
361 {0xC1, 0x11, 0x25, 0x00, 0x61, 0xA8, 0x00, 0x10},
362 {0xA1, 0x11, 0x30, 0x22, 0x00, 0x00, 0x00, 0x10},
363 {0xC1, 0x11, 0x31, 0x20, 0x2E, 0x20, 0x00, 0x10},
364 {0xC1, 0x11, 0x25, 0x00, 0xC3, 0x50, 0x00, 0x10},
365 {0xA1, 0x11, 0x30, 0x07, 0x00, 0x00, 0x00, 0x10}, /* gain14 */
366 {0xC1, 0x11, 0x31, 0x10, 0x10, 0x10, 0x00, 0x10}, /* r g b 101a10 */
367
368 {0xA1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
369 {0xA1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
370 {0xA1, 0x11, 0x21, 0xD0, 0x00, 0x00, 0x00, 0x10},
371 {0xA1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
372 {0xA1, 0x11, 0x23, 0x09, 0x00, 0x00, 0x00, 0x10},
373
374 {0xA1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
375 {0xA1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
376 {0xA1, 0x11, 0x21, 0xD0, 0x00, 0x00, 0x00, 0x10},
377 {0xA1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
378 {0xA1, 0x11, 0x23, 0x10, 0x00, 0x00, 0x00, 0x10},
379 {}
380 };
381 static const __u8 mi0360_sensor_init[][8] = {
382 {0xB1, 0x5D, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
383 {0xB1, 0x5D, 0x0D, 0x00, 0x01, 0x00, 0x00, 0x10},
384 {0xB1, 0x5D, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x10},
385 {0xD1, 0x5D, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
386 {0xD1, 0x5D, 0x03, 0x01, 0xE2, 0x02, 0x82, 0x10},
387 {0xD1, 0x5D, 0x05, 0x00, 0x09, 0x00, 0x53, 0x10},
388 {0xB1, 0x5D, 0x0D, 0x00, 0x02, 0x00, 0x00, 0x10},
389 {0xD1, 0x5D, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x10},
390 {0xD1, 0x5D, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x10},
391 {0xD1, 0x5D, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x10},
392 {0xD1, 0x5D, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
393 {0xD1, 0x5D, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
394 {0xD1, 0x5D, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
395 {0xD1, 0x5D, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
396 {0xD1, 0x5D, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
397 {0xD1, 0x5D, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x10},
398 {0xD1, 0x5D, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x10},
399 {0xB1, 0x5D, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
400 {0xD1, 0x5D, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
401 {0xD1, 0x5D, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
402 {0xD1, 0x5D, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
403 {0xD1, 0x5D, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
404 {0xD1, 0x5D, 0x2F, 0xF7, 0xB0, 0x00, 0x04, 0x10},
405 {0xD1, 0x5D, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
406 {0xD1, 0x5D, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
407 {0xB1, 0x5D, 0x3D, 0x06, 0x8F, 0x00, 0x00, 0x10},
408 {0xD1, 0x5D, 0x40, 0x01, 0xE0, 0x00, 0xD1, 0x10},
409 {0xB1, 0x5D, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
410 {0xD1, 0x5D, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
411 {0xD1, 0x5D, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x10},
412 {0xD1, 0x5D, 0x5C, 0x00, 0x00, 0x00, 0x00, 0x10},
413 {0xD1, 0x5D, 0x5E, 0x00, 0x00, 0xA3, 0x1D, 0x10},
414 {0xB1, 0x5D, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},
415
416 {0xB1, 0x5D, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
417 {0xB1, 0x5D, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
418 {0xB1, 0x5D, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
419 {0xD1, 0x5D, 0x2B, 0x00, 0xA0, 0x00, 0xB0, 0x10},
420 {0xD1, 0x5D, 0x2D, 0x00, 0xA0, 0x00, 0xA0, 0x10},
421
422 {0xB1, 0x5D, 0x0A, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor clck ?2 */
423 {0xB1, 0x5D, 0x06, 0x00, 0x30, 0x00, 0x00, 0x10},
424 {0xB1, 0x5D, 0x05, 0x00, 0x0A, 0x00, 0x00, 0x10},
425 {0xB1, 0x5D, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10}, /* exposure 2 */
426
427 {0xD1, 0x5D, 0x2B, 0x00, 0xB9, 0x00, 0xE3, 0x10},
428 {0xD1, 0x5D, 0x2D, 0x00, 0x5f, 0x00, 0xB9, 0x10}, /* 42 */
429 /* {0xB1, 0x5D, 0x35, 0x00, 0x67, 0x00, 0x00, 0x10}, * gain orig */
430 /* {0xB1, 0x5D, 0x35, 0x00, 0x20, 0x00, 0x00, 0x10}, * gain */
431 {0xB1, 0x5D, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10}, /* update */
432 {0xB1, 0x5D, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
433 {}
434 };
435 static const __u8 mo4000_sensor_init[][8] = {
436 {0xa1, 0x21, 0x01, 0x02, 0x00, 0x00, 0x00, 0x10},
437 {0xa1, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10},
438 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
439 {0xa1, 0x21, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
440 {0xa1, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
441 {0xa1, 0x21, 0x05, 0x04, 0x00, 0x00, 0x00, 0x10},
442 {0xa1, 0x21, 0x06, 0x80, 0x00, 0x00, 0x00, 0x10},
443 {0xa1, 0x21, 0x06, 0x81, 0x00, 0x00, 0x00, 0x10},
444 {0xa1, 0x21, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
445 {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
446 {0xa1, 0x21, 0x11, 0x20, 0x00, 0x00, 0x00, 0x10},
447 {0xa1, 0x21, 0x11, 0x30, 0x00, 0x00, 0x00, 0x10},
448 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
449 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
450 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
451 {0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
452 {0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10},
453 {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10},
454 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
455 {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
456 {}
457 };
458 static __u8 om6802_sensor_init[][8] = {
459 {0xa0, 0x34, 0x90, 0x05, 0x00, 0x00, 0x00, 0x10},
460 {0xa0, 0x34, 0x49, 0x85, 0x00, 0x00, 0x00, 0x10},
461 {0xa0, 0x34, 0x5a, 0xc0, 0x00, 0x00, 0x00, 0x10},
462 {0xa0, 0x34, 0xdd, 0x18, 0x00, 0x00, 0x00, 0x10},
463 /* {0xa0, 0x34, 0xfb, 0x11, 0x00, 0x00, 0x00, 0x10}, */
464 {0xa0, 0x34, 0xf0, 0x04, 0x00, 0x00, 0x00, 0x10},
465 /* white balance & auto-exposure */
466 /* {0xa0, 0x34, 0xf1, 0x02, 0x00, 0x00, 0x00, 0x10},
467 * set color mode */
468 /* {0xa0, 0x34, 0xfe, 0x5b, 0x00, 0x00, 0x00, 0x10},
469 * max AGC value in AE */
470 /* {0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10},
471 * preset AGC */
472 /* {0xa0, 0x34, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x10},
473 * preset brightness */
474 /* {0xa0, 0x34, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x10},
475 * preset contrast */
476 /* {0xa0, 0x34, 0xe8, 0x31, 0x00, 0x00, 0x00, 0x10},
477 * preset gamma */
478 {0xa0, 0x34, 0xe9, 0x0f, 0x00, 0x00, 0x00, 0x10},
479 /* luminance mode (0x4f = AE) */
480 {0xa0, 0x34, 0xe4, 0xff, 0x00, 0x00, 0x00, 0x10},
481 /* preset shutter */
482 /* {0xa0, 0x34, 0xef, 0x00, 0x00, 0x00, 0x00, 0x10},
483 * auto frame rate */
484 /* {0xa0, 0x34, 0xfb, 0xee, 0x00, 0x00, 0x00, 0x10}, */
485
486 /* {0xa0, 0x34, 0x71, 0x84, 0x00, 0x00, 0x00, 0x10}, */
487 /* {0xa0, 0x34, 0x72, 0x05, 0x00, 0x00, 0x00, 0x10}, */
488 /* {0xa0, 0x34, 0x68, 0x80, 0x00, 0x00, 0x00, 0x10}, */
489 /* {0xa0, 0x34, 0x69, 0x01, 0x00, 0x00, 0x00, 0x10}, */
490 {}
491 };
492 static const __u8 ov7630_sensor_init[][8] = {
493 {0xa1, 0x21, 0x76, 0x01, 0x00, 0x00, 0x00, 0x10},
494 {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
495 /* win: delay 20ms */
496 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
497 {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
498 /* win: delay 20ms */
499 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
500 /* win: i2c_r from 00 to 80 */
501 {0xd1, 0x21, 0x03, 0x80, 0x10, 0x20, 0x80, 0x10},
502 {0xb1, 0x21, 0x0c, 0x20, 0x20, 0x00, 0x00, 0x10},
503 {0xd1, 0x21, 0x11, 0x00, 0x48, 0xc0, 0x00, 0x10},
504 {0xb1, 0x21, 0x15, 0x80, 0x03, 0x00, 0x00, 0x10},
505 {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
506 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
507 {0xd1, 0x21, 0x1f, 0x00, 0x80, 0x80, 0x80, 0x10},
508 {0xd1, 0x21, 0x23, 0xde, 0x10, 0x8a, 0xa0, 0x10},
509 {0xc1, 0x21, 0x27, 0xca, 0xa2, 0x74, 0x00, 0x10},
510 {0xd1, 0x21, 0x2a, 0x88, 0x00, 0x88, 0x01, 0x10},
511 {0xc1, 0x21, 0x2e, 0x80, 0x00, 0x18, 0x00, 0x10},
512 {0xa1, 0x21, 0x21, 0x08, 0x00, 0x00, 0x00, 0x10},
513 {0xa1, 0x21, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
514 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
515 {0xb1, 0x21, 0x32, 0xc2, 0x08, 0x00, 0x00, 0x10},
516 {0xb1, 0x21, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x10},
517 {0xd1, 0x21, 0x60, 0x05, 0x40, 0x12, 0x57, 0x10},
518 {0xa1, 0x21, 0x64, 0x73, 0x00, 0x00, 0x00, 0x10},
519 {0xd1, 0x21, 0x65, 0x00, 0x55, 0x01, 0xac, 0x10},
520 {0xa1, 0x21, 0x69, 0x38, 0x00, 0x00, 0x00, 0x10},
521 {0xd1, 0x21, 0x6f, 0x1f, 0x01, 0x00, 0x10, 0x10},
522 {0xd1, 0x21, 0x73, 0x50, 0x20, 0x02, 0x01, 0x10},
523 {0xd1, 0x21, 0x77, 0xf3, 0x90, 0x98, 0x98, 0x10},
524 {0xc1, 0x21, 0x7b, 0x00, 0x4c, 0xf7, 0x00, 0x10},
525 {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
526 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
527 /* */
528 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
529 {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
530 /*fixme: + 0x12, 0x04*/
531 /* {0xa1, 0x21, 0x75, 0x82, 0x00, 0x00, 0x00, 0x10}, * COMN
532 * set by setvflip */
533 {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
534 {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
535 {0xb1, 0x21, 0x01, 0x80, 0x80, 0x00, 0x00, 0x10},
536 /* */
537 {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
538 {0xa1, 0x21, 0x2a, 0x88, 0x00, 0x00, 0x00, 0x10},
539 {0xa1, 0x21, 0x2b, 0x34, 0x00, 0x00, 0x00, 0x10},
540 /* */
541 {0xa1, 0x21, 0x10, 0x83, 0x00, 0x00, 0x00, 0x10},
542 /* {0xb1, 0x21, 0x01, 0x88, 0x70, 0x00, 0x00, 0x10}, */
543 {}
544 };
545
546 static const __u8 ov7648_sensor_init[][8] = {
547 {0xa1, 0x21, 0x76, 0x00, 0x00, 0x00, 0x00, 0x10},
548 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset */
549 {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
550 {0xd1, 0x21, 0x03, 0xa4, 0x30, 0x88, 0x00, 0x10},
551 {0xb1, 0x21, 0x11, 0x80, 0x08, 0x00, 0x00, 0x10},
552 {0xc1, 0x21, 0x13, 0xa0, 0x04, 0x84, 0x00, 0x10},
553 {0xd1, 0x21, 0x17, 0x1a, 0x02, 0xba, 0xf4, 0x10},
554 {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
555 {0xd1, 0x21, 0x1f, 0x41, 0xc0, 0x80, 0x80, 0x10},
556 {0xd1, 0x21, 0x23, 0xde, 0xa0, 0x80, 0x32, 0x10},
557 {0xd1, 0x21, 0x27, 0xfe, 0xa0, 0x00, 0x91, 0x10},
558 {0xd1, 0x21, 0x2b, 0x00, 0x88, 0x85, 0x80, 0x10},
559 {0xc1, 0x21, 0x2f, 0x9c, 0x00, 0xc4, 0x00, 0x10},
560 {0xd1, 0x21, 0x60, 0xa6, 0x60, 0x88, 0x12, 0x10},
561 {0xd1, 0x21, 0x64, 0x88, 0x00, 0x00, 0x94, 0x10},
562 {0xd1, 0x21, 0x68, 0x7a, 0x0c, 0x00, 0x00, 0x10},
563 {0xd1, 0x21, 0x6c, 0x11, 0x33, 0x22, 0x00, 0x10},
564 {0xd1, 0x21, 0x70, 0x11, 0x00, 0x10, 0x50, 0x10},
565 {0xd1, 0x21, 0x74, 0x20, 0x06, 0x00, 0xb5, 0x10},
566 {0xd1, 0x21, 0x78, 0x8a, 0x00, 0x00, 0x00, 0x10},
567 {0xb1, 0x21, 0x7c, 0x00, 0x43, 0x00, 0x00, 0x10},
568
569 {0xd1, 0x21, 0x21, 0x86, 0x00, 0xde, 0xa0, 0x10},
570 /* {0xd1, 0x21, 0x25, 0x80, 0x32, 0xfe, 0xa0, 0x10}, jfm done */
571 /* {0xd1, 0x21, 0x29, 0x00, 0x91, 0x00, 0x88, 0x10}, jfm done */
572 {0xb1, 0x21, 0x2d, 0x85, 0x00, 0x00, 0x00, 0x10},
573 /*...*/
574 /* {0xa1, 0x21, 0x12, 0x08, 0x00, 0x00, 0x00, 0x10}, jfm done */
575 /* {0xa1, 0x21, 0x75, 0x06, 0x00, 0x00, 0x00, 0x10}, jfm done */
576 {0xa1, 0x21, 0x19, 0x02, 0x00, 0x00, 0x00, 0x10},
577 {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
578 /* {0xa1, 0x21, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
579 /* {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10}, * GAIN - def */
580 /* {0xb1, 0x21, 0x01, 0x6c, 0x6c, 0x00, 0x00, 0x10}, * B R - def: 80 */
581 /*...*/
582 {0xa1, 0x21, 0x11, 0x81, 0x00, 0x00, 0x00, 0x10}, /* CLKRC */
583 /* {0xa1, 0x21, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
584 /* {0xa1, 0x21, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
585 /* {0xa1, 0x21, 0x2a, 0x91, 0x00, 0x00, 0x00, 0x10}, jfm done */
586 /* {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
587 /* {0xb1, 0x21, 0x01, 0x64, 0x84, 0x00, 0x00, 0x10}, * B R - def: 80 */
588
589 {}
590 };
591
592 static const __u8 ov7660_sensor_init[][8] = {
593 {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset SCCB */
594 /* (delay 20ms) */
595 {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
596 /* Outformat = rawRGB */
597 {0xa1, 0x21, 0x13, 0xb8, 0x00, 0x00, 0x00, 0x10}, /* init COM8 */
598 {0xd1, 0x21, 0x00, 0x01, 0x74, 0x74, 0x00, 0x10},
599 /* GAIN BLUE RED VREF */
600 {0xd1, 0x21, 0x04, 0x00, 0x7d, 0x62, 0x00, 0x10},
601 /* COM 1 BAVE GEAVE AECHH */
602 {0xb1, 0x21, 0x08, 0x83, 0x01, 0x00, 0x00, 0x10}, /* RAVE COM2 */
603 {0xd1, 0x21, 0x0c, 0x00, 0x08, 0x04, 0x4f, 0x10}, /* COM 3 4 5 6 */
604 {0xd1, 0x21, 0x10, 0x7f, 0x40, 0x05, 0xff, 0x10},
605 /* AECH CLKRC COM7 COM8 */
606 {0xc1, 0x21, 0x14, 0x2c, 0x00, 0x02, 0x00, 0x10}, /* COM9 COM10 */
607 {0xd1, 0x21, 0x17, 0x10, 0x60, 0x02, 0x7b, 0x10},
608 /* HSTART HSTOP VSTRT VSTOP */
609 {0xa1, 0x21, 0x1b, 0x02, 0x00, 0x00, 0x00, 0x10}, /* PSHFT */
610 {0xb1, 0x21, 0x1e, 0x01, 0x0e, 0x00, 0x00, 0x10}, /* MVFP LAEC */
611 {0xd1, 0x21, 0x20, 0x07, 0x07, 0x07, 0x07, 0x10},
612 /* BOS GBOS GROS ROS (BGGR offset) */
613 /* {0xd1, 0x21, 0x24, 0x68, 0x58, 0xd4, 0x80, 0x10}, */
614 {0xd1, 0x21, 0x24, 0x78, 0x68, 0xd4, 0x80, 0x10},
615 /* AEW AEB VPT BBIAS */
616 {0xd1, 0x21, 0x28, 0x80, 0x30, 0x00, 0x00, 0x10},
617 /* GbBIAS RSVD EXHCH EXHCL */
618 {0xd1, 0x21, 0x2c, 0x80, 0x00, 0x00, 0x62, 0x10},
619 /* RBIAS ADVFL ASDVFH YAVE */
620 {0xc1, 0x21, 0x30, 0x08, 0x30, 0xb4, 0x00, 0x10},
621 /* HSYST HSYEN HREF */
622 {0xd1, 0x21, 0x33, 0x00, 0x07, 0x84, 0x00, 0x10}, /* reserved */
623 {0xd1, 0x21, 0x37, 0x0c, 0x02, 0x43, 0x00, 0x10},
624 /* ADC ACOM OFON TSLB */
625 {0xd1, 0x21, 0x3b, 0x02, 0x6c, 0x19, 0x0e, 0x10},
626 /* COM11 COM12 COM13 COM14 */
627 {0xd1, 0x21, 0x3f, 0x41, 0xc1, 0x22, 0x08, 0x10},
628 /* EDGE COM15 COM16 COM17 */
629 {0xd1, 0x21, 0x43, 0xf0, 0x10, 0x78, 0xa8, 0x10}, /* reserved */
630 {0xd1, 0x21, 0x47, 0x60, 0x80, 0x00, 0x00, 0x10}, /* reserved */
631 {0xd1, 0x21, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* reserved */
632 {0xd1, 0x21, 0x4f, 0x46, 0x36, 0x0f, 0x17, 0x10}, /* MTX 1 2 3 4 */
633 {0xd1, 0x21, 0x53, 0x7f, 0x96, 0x40, 0x40, 0x10}, /* MTX 5 6 7 8 */
634 {0xb1, 0x21, 0x57, 0x40, 0x0f, 0x00, 0x00, 0x10}, /* MTX9 MTXS */
635 {0xd1, 0x21, 0x59, 0xba, 0x9a, 0x22, 0xb9, 0x10}, /* reserved */
636 {0xd1, 0x21, 0x5d, 0x9b, 0x10, 0xf0, 0x05, 0x10}, /* reserved */
637 {0xa1, 0x21, 0x61, 0x60, 0x00, 0x00, 0x00, 0x10}, /* reserved */
638 {0xd1, 0x21, 0x62, 0x00, 0x00, 0x50, 0x30, 0x10},
639 /* LCC1 LCC2 LCC3 LCC4 */
640 {0xa1, 0x21, 0x66, 0x00, 0x00, 0x00, 0x00, 0x10}, /* LCC5 */
641 {0xd1, 0x21, 0x67, 0x80, 0x7a, 0x90, 0x80, 0x10}, /* MANU */
642 {0xa1, 0x21, 0x6b, 0x0a, 0x00, 0x00, 0x00, 0x10},
643 /* band gap reference [0:3] DBLV */
644 {0xd1, 0x21, 0x6c, 0x30, 0x48, 0x80, 0x74, 0x10}, /* gamma curve */
645 {0xd1, 0x21, 0x70, 0x64, 0x60, 0x5c, 0x58, 0x10}, /* gamma curve */
646 {0xd1, 0x21, 0x74, 0x54, 0x4c, 0x40, 0x38, 0x10}, /* gamma curve */
647 {0xd1, 0x21, 0x78, 0x34, 0x30, 0x2f, 0x2b, 0x10}, /* gamma curve */
648 {0xd1, 0x21, 0x7c, 0x03, 0x07, 0x17, 0x34, 0x10}, /* gamma curve */
649 {0xd1, 0x21, 0x80, 0x41, 0x4d, 0x58, 0x63, 0x10}, /* gamma curve */
650 {0xd1, 0x21, 0x84, 0x6e, 0x77, 0x87, 0x95, 0x10}, /* gamma curve */
651 {0xc1, 0x21, 0x88, 0xaf, 0xc7, 0xdf, 0x00, 0x10}, /* gamma curve */
652 {0xc1, 0x21, 0x8b, 0x99, 0x99, 0xcf, 0x00, 0x10}, /* reserved */
653 {0xb1, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x10}, /* DM_LNL/H */
654 /****** (some exchanges in the win trace) ******/
655 {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10}, /* MVFP */
656 /* bits[3..0]reserved */
657 {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10},
658 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
659 /* VREF vertical frame ctrl */
660 {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
661 {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10}, /* AECH 0x20 */
662 {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFL */
663 {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFH */
664 {0xa1, 0x21, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x10}, /* GAIN */
665 /* {0xb1, 0x21, 0x01, 0x78, 0x78, 0x00, 0x00, 0x10}, * BLUE */
666 /****** (some exchanges in the win trace) ******/
667 {0xa1, 0x21, 0x93, 0x00, 0x00, 0x00, 0x00, 0x10},/* dummy line hight */
668 {0xa1, 0x21, 0x92, 0x25, 0x00, 0x00, 0x00, 0x10}, /* dummy line low */
669 {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCH */
670 {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCL */
671 /* {0xa1, 0x21, 0x02, 0x90, 0x00, 0x00, 0x00, 0x10}, * RED */
672 /****** (some exchanges in the win trace) ******/
673 /******!! startsensor KO if changed !!****/
674 {0xa1, 0x21, 0x93, 0x01, 0x00, 0x00, 0x00, 0x10},
675 {0xa1, 0x21, 0x92, 0xff, 0x00, 0x00, 0x00, 0x10},
676 {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
677 {0xa1, 0x21, 0x2b, 0xc3, 0x00, 0x00, 0x00, 0x10},
678 {}
679 };
680
681 static const __u8 qtable4[] = {
682 0x06, 0x04, 0x04, 0x06, 0x04, 0x04, 0x06, 0x06, 0x06, 0x06, 0x08, 0x06,
683 0x06, 0x08, 0x0A, 0x11,
684 0x0A, 0x0A, 0x08, 0x08, 0x0A, 0x15, 0x0F, 0x0F, 0x0C, 0x11, 0x19, 0x15,
685 0x19, 0x19, 0x17, 0x15,
686 0x17, 0x17, 0x1B, 0x1D, 0x25, 0x21, 0x1B, 0x1D, 0x23, 0x1D, 0x17, 0x17,
687 0x21, 0x2E, 0x21, 0x23,
688 0x27, 0x29, 0x2C, 0x2C, 0x2C, 0x19, 0x1F, 0x30, 0x32, 0x2E, 0x29, 0x32,
689 0x25, 0x29, 0x2C, 0x29,
690 0x06, 0x08, 0x08, 0x0A, 0x08, 0x0A, 0x13, 0x0A, 0x0A, 0x13, 0x29, 0x1B,
691 0x17, 0x1B, 0x29, 0x29,
692 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
693 0x29, 0x29, 0x29, 0x29,
694 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
695 0x29, 0x29, 0x29, 0x29,
696 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
697 0x29, 0x29, 0x29, 0x29
698 };
699
700 /* read <len> bytes to gspca_dev->usb_buf */
701 static void reg_r(struct gspca_dev *gspca_dev,
702 __u16 value, int len)
703 {
704 #ifdef GSPCA_DEBUG
705 if (len > USB_BUF_SZ) {
706 err("reg_r: buffer overflow");
707 return;
708 }
709 #endif
710 usb_control_msg(gspca_dev->dev,
711 usb_rcvctrlpipe(gspca_dev->dev, 0),
712 0,
713 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
714 value, 0,
715 gspca_dev->usb_buf, len,
716 500);
717 PDEBUG(D_USBI, "reg_r [%02x] -> %02x", value, gspca_dev->usb_buf[0]);
718 }
719
720 static void reg_w1(struct gspca_dev *gspca_dev,
721 __u16 value,
722 __u8 data)
723 {
724 PDEBUG(D_USBO, "reg_w1 [%02x] = %02x", value, data);
725 gspca_dev->usb_buf[0] = data;
726 usb_control_msg(gspca_dev->dev,
727 usb_sndctrlpipe(gspca_dev->dev, 0),
728 0x08,
729 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
730 value,
731 0,
732 gspca_dev->usb_buf, 1,
733 500);
734 }
735 static void reg_w(struct gspca_dev *gspca_dev,
736 __u16 value,
737 const __u8 *buffer,
738 int len)
739 {
740 PDEBUG(D_USBO, "reg_w [%02x] = %02x %02x ..",
741 value, buffer[0], buffer[1]);
742 #ifdef GSPCA_DEBUG
743 if (len > USB_BUF_SZ) {
744 err("reg_w: buffer overflow");
745 return;
746 }
747 #endif
748 memcpy(gspca_dev->usb_buf, buffer, len);
749 usb_control_msg(gspca_dev->dev,
750 usb_sndctrlpipe(gspca_dev->dev, 0),
751 0x08,
752 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
753 value, 0,
754 gspca_dev->usb_buf, len,
755 500);
756 }
757
758 /* I2C write 1 byte */
759 static void i2c_w1(struct gspca_dev *gspca_dev, __u8 reg, __u8 val)
760 {
761 struct sd *sd = (struct sd *) gspca_dev;
762
763 PDEBUG(D_USBO, "i2c_w2 [%02x] = %02x", reg, val);
764 gspca_dev->usb_buf[0] = 0x81 | (2 << 4); /* = a1 */
765 gspca_dev->usb_buf[1] = sd->i2c_base;
766 gspca_dev->usb_buf[2] = reg;
767 gspca_dev->usb_buf[3] = val;
768 gspca_dev->usb_buf[4] = 0;
769 gspca_dev->usb_buf[5] = 0;
770 gspca_dev->usb_buf[6] = 0;
771 gspca_dev->usb_buf[7] = 0x10;
772 usb_control_msg(gspca_dev->dev,
773 usb_sndctrlpipe(gspca_dev->dev, 0),
774 0x08,
775 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
776 0x08, /* value = i2c */
777 0,
778 gspca_dev->usb_buf, 8,
779 500);
780 }
781
782 /* I2C write 8 bytes */
783 static void i2c_w8(struct gspca_dev *gspca_dev,
784 const __u8 *buffer)
785 {
786 memcpy(gspca_dev->usb_buf, buffer, 8);
787 usb_control_msg(gspca_dev->dev,
788 usb_sndctrlpipe(gspca_dev->dev, 0),
789 0x08,
790 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
791 0x08, 0, /* value, index */
792 gspca_dev->usb_buf, 8,
793 500);
794 msleep(2);
795 }
796
797 /* read 5 bytes in gspca_dev->usb_buf */
798 static void i2c_r5(struct gspca_dev *gspca_dev, __u8 reg)
799 {
800 struct sd *sd = (struct sd *) gspca_dev;
801 __u8 mode[8];
802
803 mode[0] = 0x81 | 0x10;
804 mode[1] = sd->i2c_base;
805 mode[2] = reg;
806 mode[3] = 0;
807 mode[4] = 0;
808 mode[5] = 0;
809 mode[6] = 0;
810 mode[7] = 0x10;
811 i2c_w8(gspca_dev, mode);
812 msleep(2);
813 mode[0] = 0x81 | (5 << 4) | 0x02;
814 mode[2] = 0;
815 i2c_w8(gspca_dev, mode);
816 msleep(2);
817 reg_r(gspca_dev, 0x0a, 5);
818 }
819
820 static int probesensor(struct gspca_dev *gspca_dev)
821 {
822 i2c_w1(gspca_dev, 0x02, 0); /* sensor wakeup */
823 msleep(10);
824 reg_w1(gspca_dev, 0x02, 0x66); /* Gpio on */
825 msleep(10);
826 i2c_r5(gspca_dev, 0); /* read sensor id */
827 if (gspca_dev->usb_buf[0] == 0x02
828 && gspca_dev->usb_buf[1] == 0x09
829 && gspca_dev->usb_buf[2] == 0x01
830 && gspca_dev->usb_buf[3] == 0x00
831 && gspca_dev->usb_buf[4] == 0x00) {
832 PDEBUG(D_PROBE, "Find Sensor sn9c102P HV7131R");
833 return 0;
834 }
835 PDEBUG(D_PROBE, "Find Sensor 0x%02x 0x%02x 0x%02x",
836 gspca_dev->usb_buf[0], gspca_dev->usb_buf[1],
837 gspca_dev->usb_buf[2]);
838 PDEBUG(D_PROBE, "Sensor sn9c102P Not found");
839 return -ENODEV;
840 }
841
842 static int configure_gpio(struct gspca_dev *gspca_dev,
843 const __u8 *sn9c1xx)
844 {
845 struct sd *sd = (struct sd *) gspca_dev;
846 const __u8 *reg9a;
847 static const __u8 reg9a_def[] =
848 {0x08, 0x40, 0x20, 0x10, 0x00, 0x04};
849 static const __u8 reg9a_sn9c325[] =
850 {0x0a, 0x40, 0x38, 0x30, 0x00, 0x20};
851 static const __u8 regd4[] = {0x60, 0x00, 0x00};
852
853 reg_w1(gspca_dev, 0xf1, 0x00);
854 reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
855
856 /* configure gpio */
857 reg_w(gspca_dev, 0x01, &sn9c1xx[1], 2);
858 reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2);
859 reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 5); /* jfm len was 3 */
860 switch (sd->bridge) {
861 case BRIDGE_SN9C325:
862 reg9a = reg9a_sn9c325;
863 break;
864 default:
865 reg9a = reg9a_def;
866 break;
867 }
868 reg_w(gspca_dev, 0x9a, reg9a, 6);
869
870 reg_w(gspca_dev, 0xd4, regd4, sizeof regd4); /*fixme:jfm was 60 only*/
871
872 reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
873
874 switch (sd->sensor) {
875 case SENSOR_OM6802:
876 reg_w1(gspca_dev, 0x02, 0x71);
877 reg_w1(gspca_dev, 0x01, 0x42);
878 reg_w1(gspca_dev, 0x17, 0x64);
879 reg_w1(gspca_dev, 0x01, 0x42);
880 break;
881 /*jfm: from win trace */
882 case SENSOR_OV7630:
883 reg_w1(gspca_dev, 0x01, 0x61);
884 reg_w1(gspca_dev, 0x17, 0xe2);
885 reg_w1(gspca_dev, 0x01, 0x60);
886 reg_w1(gspca_dev, 0x01, 0x40);
887 break;
888 case SENSOR_OV7648:
889 reg_w1(gspca_dev, 0x01, 0x63);
890 reg_w1(gspca_dev, 0x17, 0x20);
891 reg_w1(gspca_dev, 0x01, 0x42);
892 break;
893 /*jfm: from win trace */
894 case SENSOR_OV7660:
895 if (sd->bridge == BRIDGE_SN9C120) {
896 reg_w1(gspca_dev, 0x01, 0x61);
897 reg_w1(gspca_dev, 0x17, 0x20);
898 reg_w1(gspca_dev, 0x01, 0x60);
899 reg_w1(gspca_dev, 0x01, 0x40);
900 break;
901 }
902 /* fall thru */
903 default:
904 reg_w1(gspca_dev, 0x01, 0x43);
905 reg_w1(gspca_dev, 0x17, 0x61);
906 reg_w1(gspca_dev, 0x01, 0x42);
907 if (sd->sensor == SENSOR_HV7131R) {
908 if (probesensor(gspca_dev) < 0)
909 return -ENODEV;
910 }
911 break;
912 }
913 return 0;
914 }
915
916 static void hv7131R_InitSensor(struct gspca_dev *gspca_dev)
917 {
918 int i = 0;
919 static const __u8 SetSensorClk[] = /* 0x08 Mclk */
920 { 0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10 };
921
922 while (hv7131r_sensor_init[i][0]) {
923 i2c_w8(gspca_dev, hv7131r_sensor_init[i]);
924 i++;
925 }
926 i2c_w8(gspca_dev, SetSensorClk);
927 }
928
929 static void mi0360_InitSensor(struct gspca_dev *gspca_dev)
930 {
931 int i = 0;
932
933 while (mi0360_sensor_init[i][0]) {
934 i2c_w8(gspca_dev, mi0360_sensor_init[i]);
935 i++;
936 }
937 }
938
939 static void mo4000_InitSensor(struct gspca_dev *gspca_dev)
940 {
941 int i = 0;
942
943 while (mo4000_sensor_init[i][0]) {
944 i2c_w8(gspca_dev, mo4000_sensor_init[i]);
945 i++;
946 }
947 }
948
949 static void om6802_InitSensor(struct gspca_dev *gspca_dev)
950 {
951 int i = 0;
952
953 while (om6802_sensor_init[i][0]) {
954 i2c_w8(gspca_dev, om6802_sensor_init[i]);
955 i++;
956 }
957 }
958
959 static void ov7630_InitSensor(struct gspca_dev *gspca_dev)
960 {
961 int i = 0;
962
963 i2c_w8(gspca_dev, ov7630_sensor_init[i]); /* 76 01 */
964 i++;
965 i2c_w8(gspca_dev, ov7630_sensor_init[i]); /* 12 c8 (RGB+SRST) */
966 i++;
967 msleep(20);
968 i2c_w8(gspca_dev, ov7630_sensor_init[i]); /* 12 48 */
969 i++;
970 i2c_w8(gspca_dev, ov7630_sensor_init[i]); /* 12 c8 */
971 i++;
972 msleep(20);
973 i2c_w8(gspca_dev, ov7630_sensor_init[i]); /* 12 48 */
974 i++;
975 /*jfm:win i2c_r from 00 to 80*/
976
977 while (ov7630_sensor_init[i][0]) {
978 i2c_w8(gspca_dev, ov7630_sensor_init[i]);
979 i++;
980 }
981 }
982
983 static void ov7648_InitSensor(struct gspca_dev *gspca_dev)
984 {
985 int i = 0;
986
987 i2c_w8(gspca_dev, ov7648_sensor_init[i]);
988 i++;
989 /* win: dble reset */
990 i2c_w8(gspca_dev, ov7648_sensor_init[i]); /* reset */
991 i++;
992 msleep(20);
993 /* win: i2c reg read 00..7f */
994 while (ov7648_sensor_init[i][0]) {
995 i2c_w8(gspca_dev, ov7648_sensor_init[i]);
996 i++;
997 }
998 }
999
1000 static void ov7660_InitSensor(struct gspca_dev *gspca_dev)
1001 {
1002 int i = 0;
1003
1004 i2c_w8(gspca_dev, ov7660_sensor_init[i]); /* reset SCCB */
1005 i++;
1006 msleep(20);
1007 while (ov7660_sensor_init[i][0]) {
1008 i2c_w8(gspca_dev, ov7660_sensor_init[i]);
1009 i++;
1010 }
1011 }
1012
1013 /* this function is called at probe time */
1014 static int sd_config(struct gspca_dev *gspca_dev,
1015 const struct usb_device_id *id)
1016 {
1017 struct sd *sd = (struct sd *) gspca_dev;
1018 struct cam *cam;
1019
1020 cam = &gspca_dev->cam;
1021 cam->epaddr = 0x01;
1022 cam->cam_mode = vga_mode;
1023 cam->nmodes = ARRAY_SIZE(vga_mode);
1024
1025 sd->bridge = id->driver_info >> 16;
1026 sd->sensor = id->driver_info >> 8;
1027 sd->i2c_base = id->driver_info;
1028
1029 sd->qindex = 4; /* set the quantization table */
1030 sd->brightness = BRIGHTNESS_DEF;
1031 sd->contrast = CONTRAST_DEF;
1032 sd->colors = COLOR_DEF;
1033 sd->blue = BLUE_BALANCE_DEF;
1034 sd->red = RED_BALANCE_DEF;
1035 sd->autogain = AUTOGAIN_DEF;
1036 sd->ag_cnt = -1;
1037 sd->vflip = VFLIP_DEF;
1038 sd->infrared = INFRARED_DEF;
1039
1040 gspca_dev->ctrl_dis = ctrl_dis[sd->sensor];
1041 return 0;
1042 }
1043
1044 /* this function is called at probe and resume time */
1045 static int sd_init(struct gspca_dev *gspca_dev)
1046 {
1047 struct sd *sd = (struct sd *) gspca_dev;
1048 __u8 regGpio[] = { 0x29, 0x74 };
1049 __u8 regF1;
1050
1051 /* setup a selector by bridge */
1052 reg_w1(gspca_dev, 0xf1, 0x01);
1053 reg_r(gspca_dev, 0x00, 1);
1054 reg_w1(gspca_dev, 0xf1, gspca_dev->usb_buf[0]);
1055 reg_r(gspca_dev, 0x00, 1); /* get sonix chip id */
1056 regF1 = gspca_dev->usb_buf[0];
1057 PDEBUG(D_PROBE, "Sonix chip id: %02x", regF1);
1058 switch (sd->bridge) {
1059 case BRIDGE_SN9C102P:
1060 if (regF1 != 0x11)
1061 return -ENODEV;
1062 reg_w1(gspca_dev, 0x02, regGpio[1]);
1063 break;
1064 case BRIDGE_SN9C105:
1065 if (regF1 != 0x11)
1066 return -ENODEV;
1067 reg_w(gspca_dev, 0x01, regGpio, 2);
1068 break;
1069 case BRIDGE_SN9C120:
1070 if (regF1 != 0x12)
1071 return -ENODEV;
1072 regGpio[1] = 0x70;
1073 reg_w(gspca_dev, 0x01, regGpio, 2);
1074 break;
1075 default:
1076 /* case BRIDGE_SN9C110: */
1077 /* case BRIDGE_SN9C325: */
1078 if (regF1 != 0x12)
1079 return -ENODEV;
1080 reg_w1(gspca_dev, 0x02, 0x62);
1081 break;
1082 }
1083
1084 reg_w1(gspca_dev, 0xf1, 0x01);
1085
1086 return 0;
1087 }
1088
1089 static unsigned int setexposure(struct gspca_dev *gspca_dev,
1090 unsigned int expo)
1091 {
1092 struct sd *sd = (struct sd *) gspca_dev;
1093 static const __u8 doit[] = /* update sensor */
1094 { 0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };
1095 static const __u8 sensorgo[] = /* sensor on */
1096 { 0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };
1097 static const __u8 gainMo[] =
1098 { 0xa1, 0x21, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1d };
1099
1100 switch (sd->sensor) {
1101 case SENSOR_HV7131R: {
1102 __u8 Expodoit[] =
1103 { 0xc1, 0x11, 0x25, 0x07, 0x27, 0xc0, 0x00, 0x16 };
1104
1105 Expodoit[3] = expo >> 16;
1106 Expodoit[4] = expo >> 8;
1107 Expodoit[5] = expo;
1108 i2c_w8(gspca_dev, Expodoit);
1109 break;
1110 }
1111 case SENSOR_MI0360: {
1112 __u8 expoMi[] = /* exposure 0x0635 -> 4 fp/s 0x10 */
1113 { 0xb1, 0x5d, 0x09, 0x06, 0x35, 0x00, 0x00, 0x16 };
1114
1115 if (expo > 0x0635)
1116 expo = 0x0635;
1117 else if (expo < 0x0001)
1118 expo = 0x0001;
1119 expoMi[3] = expo >> 8;
1120 expoMi[4] = expo;
1121 i2c_w8(gspca_dev, expoMi);
1122 i2c_w8(gspca_dev, doit);
1123 i2c_w8(gspca_dev, sensorgo);
1124 break;
1125 }
1126 case SENSOR_MO4000: {
1127 __u8 expoMof[] =
1128 { 0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10 };
1129 __u8 expoMo10[] =
1130 { 0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10 };
1131
1132 if (expo > 0x1fff)
1133 expo = 0x1fff;
1134 else if (expo < 0x0001)
1135 expo = 0x0001;
1136 expoMof[3] = (expo & 0x03fc) >> 2;
1137 i2c_w8(gspca_dev, expoMof);
1138 expoMo10[3] = ((expo & 0x1c00) >> 10)
1139 | ((expo & 0x0003) << 4);
1140 i2c_w8(gspca_dev, expoMo10);
1141 i2c_w8(gspca_dev, gainMo);
1142 PDEBUG(D_CONF, "set exposure %d",
1143 ((expoMo10[3] & 0x07) << 10)
1144 | (expoMof[3] << 2)
1145 | ((expoMo10[3] & 0x30) >> 4));
1146 break;
1147 }
1148 case SENSOR_OM6802: {
1149 __u8 gainOm[] =
1150 { 0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10 };
1151
1152 if (expo > 0x03ff)
1153 expo = 0x03ff;
1154 if (expo < 0x0001)
1155 expo = 0x0001;
1156 gainOm[3] = expo >> 2;
1157 i2c_w8(gspca_dev, gainOm);
1158 reg_w1(gspca_dev, 0x96, (expo >> 5) & 0x1f);
1159 PDEBUG(D_CONF, "set exposure %d", gainOm[3]);
1160 break;
1161 }
1162 }
1163 return expo;
1164 }
1165
1166 static void setbrightness(struct gspca_dev *gspca_dev)
1167 {
1168 struct sd *sd = (struct sd *) gspca_dev;
1169 unsigned int expo;
1170 __u8 k2;
1171
1172 k2 = ((int) sd->brightness - 0x8000) >> 10;
1173 switch (sd->sensor) {
1174 case SENSOR_HV7131R:
1175 expo = sd->brightness << 4;
1176 if (expo > 0x002dc6c0)
1177 expo = 0x002dc6c0;
1178 else if (expo < 0x02a0)
1179 expo = 0x02a0;
1180 sd->exposure = setexposure(gspca_dev, expo);
1181 break;
1182 case SENSOR_MI0360:
1183 case SENSOR_MO4000:
1184 expo = sd->brightness >> 4;
1185 sd->exposure = setexposure(gspca_dev, expo);
1186 break;
1187 case SENSOR_OM6802:
1188 expo = sd->brightness >> 6;
1189 sd->exposure = setexposure(gspca_dev, expo);
1190 k2 = sd->brightness >> 11;
1191 break;
1192 }
1193
1194 reg_w1(gspca_dev, 0x96, k2); /* color matrix Y offset */
1195 }
1196
1197 static void setcontrast(struct gspca_dev *gspca_dev)
1198 {
1199 struct sd *sd = (struct sd *) gspca_dev;
1200 __u8 k2;
1201 __u8 contrast[6];
1202
1203 k2 = sd->contrast * 0x30 / (CONTRAST_MAX + 1) + 0x10; /* 10..40 */
1204 contrast[0] = (k2 + 1) / 2; /* red */
1205 contrast[1] = 0;
1206 contrast[2] = k2; /* green */
1207 contrast[3] = 0;
1208 contrast[4] = (k2 + 1) / 5; /* blue */
1209 contrast[5] = 0;
1210 reg_w(gspca_dev, 0x84, contrast, sizeof contrast);
1211 }
1212
1213 static void setcolors(struct gspca_dev *gspca_dev)
1214 {
1215 struct sd *sd = (struct sd *) gspca_dev;
1216 int i, v;
1217 __u8 reg8a[12]; /* U & V gains */
1218 static __s16 uv[6] = { /* same as reg84 in signed decimal */
1219 -24, -38, 64, /* UR UG UB */
1220 62, -51, -9 /* VR VG VB */
1221 };
1222 for (i = 0; i < 6; i++) {
1223 v = uv[i] * sd->colors / COLOR_DEF;
1224 reg8a[i * 2] = v;
1225 reg8a[i * 2 + 1] = (v >> 8) & 0x0f;
1226 }
1227 reg_w(gspca_dev, 0x8a, reg8a, sizeof reg8a);
1228 }
1229
1230 static void setredblue(struct gspca_dev *gspca_dev)
1231 {
1232 struct sd *sd = (struct sd *) gspca_dev;
1233
1234 reg_w1(gspca_dev, 0x05, sd->red);
1235 /* reg_w1(gspca_dev, 0x07, 32); */
1236 reg_w1(gspca_dev, 0x06, sd->blue);
1237 }
1238
1239 static void setautogain(struct gspca_dev *gspca_dev)
1240 {
1241 struct sd *sd = (struct sd *) gspca_dev;
1242
1243 if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
1244 return;
1245 if (sd->autogain)
1246 sd->ag_cnt = AG_CNT_START;
1247 else
1248 sd->ag_cnt = -1;
1249 }
1250
1251 static void setvflip(struct sd *sd)
1252 {
1253 i2c_w1(&sd->gspca_dev, 0x75, /* COMN */
1254 sd->vflip ? 0x82 : 0x02);
1255 }
1256
1257 static void setinfrared(struct sd *sd)
1258 {
1259 /*fixme: different sequence for StarCam Clip and StarCam 370i */
1260 /* Clip */
1261 i2c_w1(&sd->gspca_dev, 0x02, /* gpio */
1262 sd->infrared ? 0x66 : 0x64);
1263 }
1264
1265 /* -- start the camera -- */
1266 static int sd_start(struct gspca_dev *gspca_dev)
1267 {
1268 struct sd *sd = (struct sd *) gspca_dev;
1269 int i;
1270 __u8 reg1, reg17, reg18;
1271 const __u8 *sn9c1xx;
1272 int mode;
1273 static const __u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
1274 static const __u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
1275 static const __u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd }; /* MI0360 */
1276 static const __u8 CE_ov76xx[] =
1277 { 0x32, 0xdd, 0x32, 0xdd };
1278
1279 sn9c1xx = sn_tb[(int) sd->sensor];
1280 configure_gpio(gspca_dev, sn9c1xx);
1281
1282 reg_w1(gspca_dev, 0x15, sn9c1xx[0x15]);
1283 reg_w1(gspca_dev, 0x16, sn9c1xx[0x16]);
1284 reg_w1(gspca_dev, 0x12, sn9c1xx[0x12]);
1285 reg_w1(gspca_dev, 0x13, sn9c1xx[0x13]);
1286 reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
1287 reg_w1(gspca_dev, 0xd2, 0x6a); /* DC29 */
1288 reg_w1(gspca_dev, 0xd3, 0x50);
1289 reg_w1(gspca_dev, 0xc6, 0x00);
1290 reg_w1(gspca_dev, 0xc7, 0x00);
1291 reg_w1(gspca_dev, 0xc8, 0x50);
1292 reg_w1(gspca_dev, 0xc9, 0x3c);
1293 reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
1294 switch (sd->sensor) {
1295 case SENSOR_OV7630:
1296 reg17 = 0xe2;
1297 break;
1298 case SENSOR_OV7648:
1299 reg17 = 0x20;
1300 break;
1301 /*jfm: from win trace */
1302 case SENSOR_OV7660:
1303 if (sd->bridge == BRIDGE_SN9C120) {
1304 reg17 = 0xa0;
1305 break;
1306 }
1307 /* fall thru */
1308 default:
1309 reg17 = 0x60;
1310 break;
1311 }
1312 reg_w1(gspca_dev, 0x17, reg17);
1313 /* set reg1 was here */
1314 reg_w1(gspca_dev, 0x05, sn9c1xx[5]); /* red */
1315 reg_w1(gspca_dev, 0x07, sn9c1xx[7]); /* green */
1316 reg_w1(gspca_dev, 0x06, sn9c1xx[6]); /* blue */
1317 reg_w1(gspca_dev, 0x14, sn9c1xx[0x14]);
1318 reg_w(gspca_dev, 0x20, gamma_def, sizeof gamma_def);
1319 for (i = 0; i < 8; i++)
1320 reg_w(gspca_dev, 0x84, reg84, sizeof reg84);
1321 switch (sd->sensor) {
1322 case SENSOR_OV7648:
1323 reg_w1(gspca_dev, 0x9a, 0x0a);
1324 reg_w1(gspca_dev, 0x99, 0x60);
1325 break;
1326 case SENSOR_OV7660:
1327 if (sd->bridge == BRIDGE_SN9C120) {
1328 reg_w1(gspca_dev, 0x9a, 0x05);
1329 break;
1330 }
1331 /* fall thru */
1332 default:
1333 reg_w1(gspca_dev, 0x9a, 0x08);
1334 reg_w1(gspca_dev, 0x99, 0x59);
1335 break;
1336 }
1337
1338 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
1339 if (mode)
1340 reg1 = 0x46; /* 320x240: clk 48Mhz, video trf enable */
1341 else
1342 reg1 = 0x06; /* 640x480: clk 24Mhz, video trf enable */
1343 reg17 = 0x61; /* 0x:20: enable sensor clock */
1344 switch (sd->sensor) {
1345 case SENSOR_HV7131R:
1346 hv7131R_InitSensor(gspca_dev);
1347 break;
1348 case SENSOR_MI0360:
1349 mi0360_InitSensor(gspca_dev);
1350 break;
1351 case SENSOR_MO4000:
1352 mo4000_InitSensor(gspca_dev);
1353 if (mode) {
1354 /* reg1 = 0x46; * 320 clk 48Mhz 60fp/s */
1355 reg1 = 0x06; /* clk 24Mz */
1356 } else {
1357 reg17 = 0x22; /* 640 MCKSIZE */
1358 /* reg1 = 0x06; * 640 clk 24Mz (done) */
1359 }
1360 break;
1361 case SENSOR_OM6802:
1362 om6802_InitSensor(gspca_dev);
1363 reg17 = 0x64; /* 640 MCKSIZE */
1364 break;
1365 case SENSOR_OV7630:
1366 ov7630_InitSensor(gspca_dev);
1367 setvflip(sd);
1368 reg17 = 0xe2;
1369 reg1 = 0x44;
1370 break;
1371 case SENSOR_OV7648:
1372 ov7648_InitSensor(gspca_dev);
1373 reg17 = 0x21;
1374 /* reg1 = 0x42; * 42 - 46? */
1375 break;
1376 default:
1377 /* case SENSOR_OV7660: */
1378 ov7660_InitSensor(gspca_dev);
1379 if (sd->bridge == BRIDGE_SN9C120) {
1380 if (mode) { /* 320x240 - 160x120 */
1381 reg17 = 0xa2;
1382 reg1 = 0x44; /* 48 Mhz, video trf eneble */
1383 }
1384 } else {
1385 reg17 = 0x22;
1386 reg1 = 0x06; /* 24 Mhz, video trf eneble
1387 * inverse power down */
1388 }
1389 break;
1390 }
1391 reg_w(gspca_dev, 0xc0, C0, 6);
1392 reg_w(gspca_dev, 0xca, CA, 4);
1393 switch (sd->sensor) {
1394 case SENSOR_OV7630:
1395 case SENSOR_OV7648:
1396 case SENSOR_OV7660:
1397 reg_w(gspca_dev, 0xce, CE_ov76xx, 4);
1398 break;
1399 default:
1400 reg_w(gspca_dev, 0xce, CE, 4);
1401 /* ?? {0x1e, 0xdd, 0x2d, 0xe7} */
1402 break;
1403 }
1404
1405 /* here change size mode 0 -> VGA; 1 -> CIF */
1406 reg18 = sn9c1xx[0x18] | (mode << 4);
1407 reg_w1(gspca_dev, 0x18, reg18 | 0x40);
1408
1409 reg_w(gspca_dev, 0x100, qtable4, 0x40);
1410 reg_w(gspca_dev, 0x140, qtable4 + 0x40, 0x40);
1411
1412 reg_w1(gspca_dev, 0x18, reg18);
1413
1414 reg_w1(gspca_dev, 0x17, reg17);
1415 reg_w1(gspca_dev, 0x01, reg1);
1416 switch (sd->sensor) {
1417 case SENSOR_MI0360:
1418 setinfrared(sd);
1419 break;
1420 case SENSOR_OV7630:
1421 setvflip(sd);
1422 break;
1423 }
1424 setbrightness(gspca_dev);
1425 setcontrast(gspca_dev);
1426 setautogain(gspca_dev);
1427 return 0;
1428 }
1429
1430 static void sd_stopN(struct gspca_dev *gspca_dev)
1431 {
1432 struct sd *sd = (struct sd *) gspca_dev;
1433 static const __u8 stophv7131[] =
1434 { 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 };
1435 static const __u8 stopmi0360[] =
1436 { 0xb1, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10 };
1437 static const __u8 stopov7648[] =
1438 { 0xa1, 0x21, 0x76, 0x20, 0x00, 0x00, 0x00, 0x10 };
1439 __u8 data;
1440 const __u8 *sn9c1xx;
1441
1442 data = 0x0b;
1443 switch (sd->sensor) {
1444 case SENSOR_HV7131R:
1445 i2c_w8(gspca_dev, stophv7131);
1446 data = 0x2b;
1447 break;
1448 case SENSOR_MI0360:
1449 i2c_w8(gspca_dev, stopmi0360);
1450 data = 0x29;
1451 break;
1452 case SENSOR_OV7648:
1453 i2c_w8(gspca_dev, stopov7648);
1454 /* fall thru */
1455 case SENSOR_OV7630:
1456 data = 0x29;
1457 break;
1458 default:
1459 /* case SENSOR_MO4000: */
1460 /* case SENSOR_OV7660: */
1461 break;
1462 }
1463 sn9c1xx = sn_tb[(int) sd->sensor];
1464 reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
1465 reg_w1(gspca_dev, 0x17, sn9c1xx[0x17]);
1466 reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
1467 reg_w1(gspca_dev, 0x01, data);
1468 reg_w1(gspca_dev, 0xf1, 0x00);
1469 }
1470
1471 static void do_autogain(struct gspca_dev *gspca_dev)
1472 {
1473 struct sd *sd = (struct sd *) gspca_dev;
1474 int delta;
1475 int expotimes;
1476 __u8 luma_mean = 130;
1477 __u8 luma_delta = 20;
1478
1479 /* Thanks S., without your advice, autobright should not work :) */
1480 if (sd->ag_cnt < 0)
1481 return;
1482 if (--sd->ag_cnt >= 0)
1483 return;
1484 sd->ag_cnt = AG_CNT_START;
1485
1486 delta = atomic_read(&sd->avg_lum);
1487 PDEBUG(D_FRAM, "mean lum %d", delta);
1488 if (delta < luma_mean - luma_delta ||
1489 delta > luma_mean + luma_delta) {
1490 switch (sd->sensor) {
1491 case SENSOR_HV7131R:
1492 expotimes = sd->exposure >> 8;
1493 expotimes += (luma_mean - delta) >> 4;
1494 if (expotimes < 0)
1495 expotimes = 0;
1496 sd->exposure = setexposure(gspca_dev,
1497 (unsigned int) (expotimes << 8));
1498 break;
1499 default:
1500 /* case SENSOR_MO4000: */
1501 /* case SENSOR_MI0360: */
1502 /* case SENSOR_OM6802: */
1503 expotimes = sd->exposure;
1504 expotimes += (luma_mean - delta) >> 6;
1505 if (expotimes < 0)
1506 expotimes = 0;
1507 sd->exposure = setexposure(gspca_dev,
1508 (unsigned int) expotimes);
1509 setredblue(gspca_dev);
1510 break;
1511 }
1512 }
1513 }
1514
1515 /* scan the URB packets */
1516 /* This function is run at interrupt level. */
1517 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1518 struct gspca_frame *frame, /* target */
1519 __u8 *data, /* isoc packet */
1520 int len) /* iso packet length */
1521 {
1522 struct sd *sd = (struct sd *) gspca_dev;
1523 int sof, avg_lum;
1524
1525 sof = len - 64;
1526 if (sof >= 0 && data[sof] == 0xff && data[sof + 1] == 0xd9) {
1527
1528 /* end of frame */
1529 gspca_frame_add(gspca_dev, LAST_PACKET,
1530 frame, data, sof + 2);
1531 if (sd->ag_cnt < 0)
1532 return;
1533 /* w1 w2 w3 */
1534 /* w4 w5 w6 */
1535 /* w7 w8 */
1536 /* w4 */
1537 avg_lum = ((data[sof + 29] << 8) | data[sof + 30]) >> 6;
1538 /* w6 */
1539 avg_lum += ((data[sof + 33] << 8) | data[sof + 34]) >> 6;
1540 /* w2 */
1541 avg_lum += ((data[sof + 25] << 8) | data[sof + 26]) >> 6;
1542 /* w8 */
1543 avg_lum += ((data[sof + 37] << 8) | data[sof + 38]) >> 6;
1544 /* w5 */
1545 avg_lum += ((data[sof + 31] << 8) | data[sof + 32]) >> 4;
1546 avg_lum >>= 4;
1547 atomic_set(&sd->avg_lum, avg_lum);
1548 return;
1549 }
1550 if (gspca_dev->last_packet_type == LAST_PACKET) {
1551
1552 /* put the JPEG 422 header */
1553 jpeg_put_header(gspca_dev, frame, sd->qindex, 0x21);
1554 }
1555 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
1556 }
1557
1558 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1559 {
1560 struct sd *sd = (struct sd *) gspca_dev;
1561
1562 sd->brightness = val;
1563 if (gspca_dev->streaming)
1564 setbrightness(gspca_dev);
1565 return 0;
1566 }
1567
1568 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1569 {
1570 struct sd *sd = (struct sd *) gspca_dev;
1571
1572 *val = sd->brightness;
1573 return 0;
1574 }
1575
1576 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1577 {
1578 struct sd *sd = (struct sd *) gspca_dev;
1579
1580 sd->contrast = val;
1581 if (gspca_dev->streaming)
1582 setcontrast(gspca_dev);
1583 return 0;
1584 }
1585
1586 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1587 {
1588 struct sd *sd = (struct sd *) gspca_dev;
1589
1590 *val = sd->contrast;
1591 return 0;
1592 }
1593
1594 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1595 {
1596 struct sd *sd = (struct sd *) gspca_dev;
1597
1598 sd->colors = val;
1599 if (gspca_dev->streaming)
1600 setcolors(gspca_dev);
1601 return 0;
1602 }
1603
1604 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1605 {
1606 struct sd *sd = (struct sd *) gspca_dev;
1607
1608 *val = sd->colors;
1609 return 0;
1610 }
1611
1612 static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val)
1613 {
1614 struct sd *sd = (struct sd *) gspca_dev;
1615
1616 sd->blue = val;
1617 if (gspca_dev->streaming)
1618 setredblue(gspca_dev);
1619 return 0;
1620 }
1621
1622 static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val)
1623 {
1624 struct sd *sd = (struct sd *) gspca_dev;
1625
1626 *val = sd->blue;
1627 return 0;
1628 }
1629
1630 static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val)
1631 {
1632 struct sd *sd = (struct sd *) gspca_dev;
1633
1634 sd->red = val;
1635 if (gspca_dev->streaming)
1636 setredblue(gspca_dev);
1637 return 0;
1638 }
1639
1640 static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val)
1641 {
1642 struct sd *sd = (struct sd *) gspca_dev;
1643
1644 *val = sd->red;
1645 return 0;
1646 }
1647
1648 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1649 {
1650 struct sd *sd = (struct sd *) gspca_dev;
1651
1652 sd->autogain = val;
1653 if (gspca_dev->streaming)
1654 setautogain(gspca_dev);
1655 return 0;
1656 }
1657
1658 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1659 {
1660 struct sd *sd = (struct sd *) gspca_dev;
1661
1662 *val = sd->autogain;
1663 return 0;
1664 }
1665
1666 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
1667 {
1668 struct sd *sd = (struct sd *) gspca_dev;
1669
1670 sd->vflip = val;
1671 if (gspca_dev->streaming)
1672 setvflip(sd);
1673 return 0;
1674 }
1675
1676 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
1677 {
1678 struct sd *sd = (struct sd *) gspca_dev;
1679
1680 *val = sd->vflip;
1681 return 0;
1682 }
1683
1684 static int sd_setinfrared(struct gspca_dev *gspca_dev, __s32 val)
1685 {
1686 struct sd *sd = (struct sd *) gspca_dev;
1687
1688 sd->infrared = val;
1689 if (gspca_dev->streaming)
1690 setinfrared(sd);
1691 return 0;
1692 }
1693
1694 static int sd_getinfrared(struct gspca_dev *gspca_dev, __s32 *val)
1695 {
1696 struct sd *sd = (struct sd *) gspca_dev;
1697
1698 *val = sd->infrared;
1699 return 0;
1700 }
1701
1702 /* sub-driver description */
1703 static const struct sd_desc sd_desc = {
1704 .name = MODULE_NAME,
1705 .ctrls = sd_ctrls,
1706 .nctrls = ARRAY_SIZE(sd_ctrls),
1707 .config = sd_config,
1708 .init = sd_init,
1709 .start = sd_start,
1710 .stopN = sd_stopN,
1711 .pkt_scan = sd_pkt_scan,
1712 .dq_callback = do_autogain,
1713 };
1714
1715 /* -- module initialisation -- */
1716 #define BSI(bridge, sensor, i2c_addr) \
1717 .driver_info = (BRIDGE_ ## bridge << 16) \
1718 | (SENSOR_ ## sensor << 8) \
1719 | (i2c_addr)
1720 static const __devinitdata struct usb_device_id device_table[] = {
1721 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1722 {USB_DEVICE(0x0458, 0x7025), BSI(SN9C120, MI0360, 0x5d)},
1723 {USB_DEVICE(0x0458, 0x702e), BSI(SN9C120, OV7660, 0x21)},
1724 #endif
1725 {USB_DEVICE(0x045e, 0x00f5), BSI(SN9C105, OV7660, 0x21)},
1726 {USB_DEVICE(0x045e, 0x00f7), BSI(SN9C105, OV7660, 0x21)},
1727 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1728 {USB_DEVICE(0x0471, 0x0327), BSI(SN9C105, MI0360, 0x5d)},
1729 #endif
1730 {USB_DEVICE(0x0471, 0x0328), BSI(SN9C105, MI0360, 0x5d)},
1731 {USB_DEVICE(0x0471, 0x0330), BSI(SN9C105, MI0360, 0x5d)},
1732 {USB_DEVICE(0x06f8, 0x3004), BSI(SN9C105, OV7660, 0x21)},
1733 {USB_DEVICE(0x0c45, 0x6040), BSI(SN9C102P, HV7131R, 0x11)},
1734 /* bw600.inf:
1735 {USB_DEVICE(0x0c45, 0x6040), BSI(SN9C102P, MI0360, 0x5d)}, */
1736 /* {USB_DEVICE(0x0c45, 0x603a), BSI(SN9C102P, OV7648, 0x??)}, */
1737 /* {USB_DEVICE(0x0c45, 0x607a), BSI(SN9C102P, OV7648, 0x??)}, */
1738 {USB_DEVICE(0x0c45, 0x607c), BSI(SN9C102P, HV7131R, 0x11)},
1739 /* {USB_DEVICE(0x0c45, 0x607e), BSI(SN9C102P, OV7630, 0x??)}, */
1740 {USB_DEVICE(0x0c45, 0x60c0), BSI(SN9C105, MI0360, 0x5d)},
1741 /* {USB_DEVICE(0x0c45, 0x60c8), BSI(SN9C105, OM6801, 0x??)}, */
1742 /* {USB_DEVICE(0x0c45, 0x60cc), BSI(SN9C105, HV7131GP, 0x??)}, */
1743 {USB_DEVICE(0x0c45, 0x60ec), BSI(SN9C105, MO4000, 0x21)},
1744 /* {USB_DEVICE(0x0c45, 0x60ef), BSI(SN9C105, ICM105C, 0x??)}, */
1745 /* {USB_DEVICE(0x0c45, 0x60fa), BSI(SN9C105, OV7648, 0x??)}, */
1746 {USB_DEVICE(0x0c45, 0x60fb), BSI(SN9C105, OV7660, 0x21)},
1747 {USB_DEVICE(0x0c45, 0x60fc), BSI(SN9C105, HV7131R, 0x11)},
1748 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1749 {USB_DEVICE(0x0c45, 0x60fe), BSI(SN9C105, OV7630, 0x21)},
1750 #endif
1751 /* {USB_DEVICE(0x0c45, 0x6108), BSI(SN9C120, OM6801, 0x??)}, */
1752 /* {USB_DEVICE(0x0c45, 0x6122), BSI(SN9C110, ICM105C, 0x??)}, */
1753 /* {USB_DEVICE(0x0c45, 0x6123), BSI(SN9C110, SanyoCCD, 0x??)}, */
1754 {USB_DEVICE(0x0c45, 0x6128), BSI(SN9C110, OM6802, 0x21)}, /*sn9c325?*/
1755 /*bw600.inf:*/
1756 {USB_DEVICE(0x0c45, 0x612a), BSI(SN9C120, OV7648, 0x21)}, /*sn9c110?*/
1757 {USB_DEVICE(0x0c45, 0x612c), BSI(SN9C110, MO4000, 0x21)},
1758 {USB_DEVICE(0x0c45, 0x612e), BSI(SN9C110, OV7630, 0x21)},
1759 /* {USB_DEVICE(0x0c45, 0x612f), BSI(SN9C110, ICM105C, 0x??)}, */
1760 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1761 {USB_DEVICE(0x0c45, 0x6130), BSI(SN9C120, MI0360, 0x5d)},
1762 #endif
1763 {USB_DEVICE(0x0c45, 0x6138), BSI(SN9C120, MO4000, 0x21)},
1764 {USB_DEVICE(0x0c45, 0x613a), BSI(SN9C120, OV7648, 0x21)},
1765 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1766 {USB_DEVICE(0x0c45, 0x613b), BSI(SN9C120, OV7660, 0x21)},
1767 {USB_DEVICE(0x0c45, 0x613c), BSI(SN9C120, HV7131R, 0x11)},
1768 /* {USB_DEVICE(0x0c45, 0x613e), BSI(SN9C120, OV7630, 0x??)}, */
1769 #endif
1770 {USB_DEVICE(0x0c45, 0x6143), BSI(SN9C120, MI0360, 0x5d)},
1771 {}
1772 };
1773 MODULE_DEVICE_TABLE(usb, device_table);
1774
1775 /* -- device connect -- */
1776 static int sd_probe(struct usb_interface *intf,
1777 const struct usb_device_id *id)
1778 {
1779 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1780 THIS_MODULE);
1781 }
1782
1783 static struct usb_driver sd_driver = {
1784 .name = MODULE_NAME,
1785 .id_table = device_table,
1786 .probe = sd_probe,
1787 .disconnect = gspca_disconnect,
1788 #ifdef CONFIG_PM
1789 .suspend = gspca_suspend,
1790 .resume = gspca_resume,
1791 #endif
1792 };
1793
1794 /* -- module insert / remove -- */
1795 static int __init sd_mod_init(void)
1796 {
1797 if (usb_register(&sd_driver) < 0)
1798 return -1;
1799 info("registered");
1800 return 0;
1801 }
1802 static void __exit sd_mod_exit(void)
1803 {
1804 usb_deregister(&sd_driver);
1805 info("deregistered");
1806 }
1807
1808 module_init(sd_mod_init);
1809 module_exit(sd_mod_exit);
Nao low-level kernelspace/userspace library that runs on our robots, Nao-Team HTWK