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