CoCalc -- vc032x.c

GitHub Repository: awilliam/linux-vfio
Path: blob/master/drivers/media/video/gspca/vc032x.c
¹⁷⁶⁰² views
1
/*
2
 * Z-star vc0321 library
3
 *
4
 * Copyright (C) 2009-2010 Jean-François Moine <http://moinejf.free.fr>
5
 * Copyright (C) 2006 Koninski Artur [email protected]
6
 * Copyright (C) 2006 Michel Xhaard
7
 *
8
 * This program is free software; you can redistribute it and/or modify
9
 * it under the terms of the GNU General Public License as published by
10
 * the Free Software Foundation; either version 2 of the License, or
11
 * any later version.
12
 *
13
 * This program is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
 * GNU General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU General Public License
19
 * along with this program; if not, write to the Free Software
20
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
 */
22

23
#define MODULE_NAME "vc032x"
24

25
#include "gspca.h"
26

27
MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
28
MODULE_DESCRIPTION("GSPCA/VC032X USB Camera Driver");
29
MODULE_LICENSE("GPL");
30

31
/* specific webcam descriptor */
32
struct sd {
33
	struct gspca_dev gspca_dev;	/* !! must be the first item */
34

35
	u8 brightness;
36
	u8 contrast;
37
	u8 colors;
38
	u8 hflip;
39
	u8 vflip;
40
	u8 lightfreq;
41
	s8 sharpness;
42
	u16 exposure;
43
	u8 gain;
44
	u8 autogain;
45
	u8 backlight;
46

47
	u8 image_offset;
48

49
	u8 bridge;
50
	u8 sensor;
51
	u8 flags;
52
#define FL_SAMSUNG 0x01		/* SamsungQ1 (2 sensors) */
53
#define FL_HFLIP 0x02		/* mirrored by default */
54
#define FL_VFLIP 0x04		/* vertical flipped by default */
55
};
56
enum bridges {
57
	BRIDGE_VC0321,
58
	BRIDGE_VC0323,
59
};
60
enum sensors {
61
	SENSOR_HV7131R,
62
	SENSOR_MI0360,
63
	SENSOR_MI1310_SOC,
64
	SENSOR_MI1320,
65
	SENSOR_MI1320_SOC,
66
	SENSOR_OV7660,
67
	SENSOR_OV7670,
68
	SENSOR_PO1200,
69
	SENSOR_PO3130NC,
70
	SENSOR_POxxxx,
71
	NSENSORS
72
};
73

74
/* V4L2 controls supported by the driver */
75
static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
76
static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
77
static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
78
static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
79
static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
80
static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
81
static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val);
82
static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val);
83
static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
84
static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
85
static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
86
static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
87
static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
88
static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
89
static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
90
static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
91
static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
92
static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
93
static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
94
static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
95
static int sd_setbacklight(struct gspca_dev *gspca_dev, __s32 val);
96
static int sd_getbacklight(struct gspca_dev *gspca_dev, __s32 *val);
97

98
static const struct ctrl sd_ctrls[] = {
99
#define BRIGHTNESS_IDX 0
100
	{
101
	    {
102
		.id      = V4L2_CID_BRIGHTNESS,
103
		.type    = V4L2_CTRL_TYPE_INTEGER,
104
		.name    = "Brightness",
105
		.minimum = 0,
106
		.maximum = 255,
107
		.step    = 1,
108
#define BRIGHTNESS_DEF 128
109
		.default_value = BRIGHTNESS_DEF,
110
	    },
111
	    .set = sd_setbrightness,
112
	    .get = sd_getbrightness,
113
	},
114
#define CONTRAST_IDX 1
115
	{
116
	    {
117
		.id      = V4L2_CID_CONTRAST,
118
		.type    = V4L2_CTRL_TYPE_INTEGER,
119
		.name    = "Contrast",
120
		.minimum = 0,
121
		.maximum = 255,
122
		.step    = 1,
123
#define CONTRAST_DEF 127
124
		.default_value = CONTRAST_DEF,
125
	    },
126
	    .set = sd_setcontrast,
127
	    .get = sd_getcontrast,
128
	},
129
#define COLORS_IDX 2
130
	{
131
	    {
132
		.id      = V4L2_CID_SATURATION,
133
		.type    = V4L2_CTRL_TYPE_INTEGER,
134
		.name    = "Saturation",
135
		.minimum = 1,
136
		.maximum = 127,
137
		.step    = 1,
138
#define COLOR_DEF 63
139
		.default_value = COLOR_DEF,
140
	    },
141
	    .set = sd_setcolors,
142
	    .get = sd_getcolors,
143
	},
144
/* next 2 controls work with some sensors only */
145
#define HFLIP_IDX 3
146
	{
147
	    {
148
		.id      = V4L2_CID_HFLIP,
149
		.type    = V4L2_CTRL_TYPE_BOOLEAN,
150
		.name    = "Mirror",
151
		.minimum = 0,
152
		.maximum = 1,
153
		.step    = 1,
154
#define HFLIP_DEF 0
155
		.default_value = HFLIP_DEF,
156
	    },
157
	    .set = sd_sethflip,
158
	    .get = sd_gethflip,
159
	},
160
#define VFLIP_IDX 4
161
	{
162
	    {
163
		.id      = V4L2_CID_VFLIP,
164
		.type    = V4L2_CTRL_TYPE_BOOLEAN,
165
		.name    = "Vflip",
166
		.minimum = 0,
167
		.maximum = 1,
168
		.step    = 1,
169
#define VFLIP_DEF 0
170
		.default_value = VFLIP_DEF,
171
	    },
172
	    .set = sd_setvflip,
173
	    .get = sd_getvflip,
174
	},
175
#define LIGHTFREQ_IDX 5
176
	{
177
	    {
178
		.id	 = V4L2_CID_POWER_LINE_FREQUENCY,
179
		.type    = V4L2_CTRL_TYPE_MENU,
180
		.name    = "Light frequency filter",
181
		.minimum = 0,
182
		.maximum = 2,	/* 0: No, 1: 50Hz, 2:60Hz */
183
		.step    = 1,
184
#define FREQ_DEF 1
185
		.default_value = FREQ_DEF,
186
	    },
187
	    .set = sd_setfreq,
188
	    .get = sd_getfreq,
189
	},
190
#define SHARPNESS_IDX 6
191
	{
192
	 {
193
	  .id = V4L2_CID_SHARPNESS,
194
	  .type = V4L2_CTRL_TYPE_INTEGER,
195
	  .name = "Sharpness",
196
	  .minimum = -1,
197
	  .maximum = 2,
198
	  .step = 1,
199
#define SHARPNESS_DEF -1
200
	  .default_value = SHARPNESS_DEF,
201
	  },
202
	 .set = sd_setsharpness,
203
	 .get = sd_getsharpness,
204
	 },
205
#define GAIN_IDX 7
206
	{
207
	    {
208
		.id      = V4L2_CID_GAIN,
209
		.type    = V4L2_CTRL_TYPE_INTEGER,
210
		.name    = "Gain",
211
		.minimum = 0,
212
		.maximum = 78,
213
		.step    = 1,
214
#define GAIN_DEF 0
215
		.default_value = GAIN_DEF,
216
	    },
217
	    .set = sd_setgain,
218
	    .get = sd_getgain,
219
	},
220
#define EXPOSURE_IDX 8
221
	{
222
		{
223
			.id = V4L2_CID_EXPOSURE,
224
			.type = V4L2_CTRL_TYPE_INTEGER,
225
			.name = "Exposure",
226
#define EXPOSURE_DEF 450
227
			.minimum = 0,
228
			.maximum = 4095,
229
			.step = 1,
230
			.default_value = EXPOSURE_DEF,
231
		},
232
		.set = sd_setexposure,
233
		.get = sd_getexposure,
234
	},
235
#define AUTOGAIN_IDX 9
236
	{
237
		{
238
			.id = V4L2_CID_AUTOGAIN,
239
			.type = V4L2_CTRL_TYPE_BOOLEAN,
240
			.name = "Automatic Gain and Exposure",
241
			.minimum = 0,
242
			.maximum = 1,
243
			.step = 1,
244
#define AUTOGAIN_DEF 1
245
			.default_value = AUTOGAIN_DEF,
246
		},
247
		.set = sd_setautogain,
248
		.get = sd_getautogain,
249
	},
250
#define BACKLIGHT_IDX 10
251
	{
252
		{
253
			.id = V4L2_CID_BACKLIGHT_COMPENSATION,
254
			.type = V4L2_CTRL_TYPE_BOOLEAN,
255
			.name = "Backlight Compensation",
256
			.minimum = 0,
257
			.maximum = 15,
258
			.step = 1,
259
#define BACKLIGHT_DEF 15
260
			.default_value = BACKLIGHT_DEF,
261
		},
262
		.set = sd_setbacklight,
263
		.get = sd_getbacklight,
264
	},
265
};
266

267
/* table of the disabled controls */
268
static u32 ctrl_dis[NSENSORS] = {
269
    [SENSOR_HV7131R] =
270
	(1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
271
		| (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX)
272
		| (1 << SHARPNESS_IDX)
273
		| (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
274
		| (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
275
    [SENSOR_MI0360] =
276
	(1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
277
		| (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX)
278
		| (1 << SHARPNESS_IDX)
279
		| (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
280
		| (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
281
    [SENSOR_MI1310_SOC] =
282
	(1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
283
		| (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX)
284
		| (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
285
		| (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
286
    [SENSOR_MI1320] =
287
	(1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
288
		| (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX)
289
		| (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
290
		| (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
291
    [SENSOR_MI1320_SOC] =
292
	(1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
293
		| (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX)
294
		| (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
295
		| (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
296
    [SENSOR_OV7660] =
297
	(1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
298
		| (1 << LIGHTFREQ_IDX) | (1 << SHARPNESS_IDX)
299
		| (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
300
		| (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
301
    [SENSOR_OV7670] =
302
	(1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
303
		| (1 << SHARPNESS_IDX)
304
		| (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
305
		| (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
306
    [SENSOR_PO1200] =
307
	(1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
308
		| (1 << LIGHTFREQ_IDX)
309
		| (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
310
		| (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
311
    [SENSOR_PO3130NC] =
312
	(1 << BRIGHTNESS_IDX) | (1 << CONTRAST_IDX) | (1 << COLORS_IDX)
313
		| (1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX)
314
		| (1 << SHARPNESS_IDX)
315
		| (1 << GAIN_IDX) | (1 << EXPOSURE_IDX)
316
		| (1 << AUTOGAIN_IDX) | (1 << BACKLIGHT_IDX),
317
    [SENSOR_POxxxx] =
318
	(1 << HFLIP_IDX) | (1 << VFLIP_IDX) | (1 << LIGHTFREQ_IDX),
319
};
320

321
static const struct v4l2_pix_format vc0321_mode[] = {
322
	{320, 240, V4L2_PIX_FMT_YVYU, V4L2_FIELD_NONE,
323
		.bytesperline = 320,
324
		.sizeimage = 320 * 240 * 2,
325
		.colorspace = V4L2_COLORSPACE_SRGB,
326
		.priv = 1},
327
	{640, 480, V4L2_PIX_FMT_YVYU, V4L2_FIELD_NONE,
328
		.bytesperline = 640,
329
		.sizeimage = 640 * 480 * 2,
330
		.colorspace = V4L2_COLORSPACE_SRGB,
331
		.priv = 0},
332
};
333
static const struct v4l2_pix_format vc0323_mode[] = {
334
	{320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
335
		.bytesperline = 320,
336
		.sizeimage = 320 * 240 * 3 / 8 + 590,
337
		.colorspace = V4L2_COLORSPACE_JPEG,
338
		.priv = 1},
339
	{640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
340
		.bytesperline = 640,
341
		.sizeimage = 640 * 480 * 3 / 8 + 590,
342
		.colorspace = V4L2_COLORSPACE_JPEG,
343
		.priv = 0},
344
	{1280, 960, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, /* mi1310_soc only */
345
		.bytesperline = 1280,
346
		.sizeimage = 1280 * 960 * 3 / 8 + 590,
347
		.colorspace = V4L2_COLORSPACE_JPEG,
348
		.priv = 2},
349
};
350
static const struct v4l2_pix_format bi_mode[] = {
351
	{320, 240, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
352
		.bytesperline = 320,
353
		.sizeimage = 320 * 240 * 2,
354
		.colorspace = V4L2_COLORSPACE_SRGB,
355
		.priv = 2},
356
	{640, 480, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
357
		.bytesperline = 640,
358
		.sizeimage = 640 * 480 * 2,
359
		.colorspace = V4L2_COLORSPACE_SRGB,
360
		.priv = 1},
361
	{1280, 1024, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
362
		.bytesperline = 1280,
363
		.sizeimage = 1280 * 1024 * 2,
364
		.colorspace = V4L2_COLORSPACE_SRGB,
365
		.priv = 0},
366
};
367
static const struct v4l2_pix_format svga_mode[] = {
368
	{800, 600, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
369
		.bytesperline = 800,
370
		.sizeimage = 800 * 600 * 1 / 4 + 590,
371
		.colorspace = V4L2_COLORSPACE_JPEG,
372
		.priv = 0},
373
};
374

375
/* OV7660/7670 registers */
376
#define OV7660_REG_MVFP 0x1e
377
#define OV7660_MVFP_MIRROR	0x20
378
#define OV7660_MVFP_VFLIP	0x10
379

380
static const u8 mi0360_matrix[9] = {
381
	0x50, 0xf8, 0xf8, 0xf5, 0x50, 0xfb, 0xff, 0xf1, 0x50
382
};
383

384
static const u8 mi0360_initVGA_JPG[][4] = {
385
	{0xb0, 0x03, 0x19, 0xcc},
386
	{0xb0, 0x04, 0x02, 0xcc},
387
	{0xb3, 0x00, 0x24, 0xcc},
388
	{0xb3, 0x00, 0x25, 0xcc},
389
	{0xb3, 0x08, 0x01, 0xcc},
390
	{0xb3, 0x09, 0x0c, 0xcc},
391
	{0xb3, 0x05, 0x01, 0xcc},
392
	{0xb3, 0x06, 0x03, 0xcc},
393
	{0xb3, 0x03, 0x0a, 0xcc},
394
	{0xb3, 0x20, 0x00, 0xcc},
395
	{0xb3, 0x21, 0x00, 0xcc},
396
	{0xb3, 0x22, 0x01, 0xcc},
397
	{0xb3, 0x23, 0xe0, 0xcc},
398
	{0xb3, 0x04, 0x05, 0xcc},
399
	{0xb3, 0x14, 0x00, 0xcc},
400
	{0xb3, 0x15, 0x00, 0xcc},
401
	{0xb3, 0x16, 0x02, 0xcc},
402
	{0xb3, 0x17, 0x7f, 0xcc},
403
	{0xb3, 0x35, 0xdd, 0xcc},	/* i2c add: 5d */
404
	{0xb3, 0x34, 0x02, 0xcc},
405
	{0xb3, 0x00, 0x25, 0xcc},
406
	{0xbc, 0x00, 0x71, 0xcc},
407
	{0xb8, 0x00, 0x13, 0xcc},
408
	{0xb8, 0x27, 0x20, 0xcc},
409
	{0xb8, 0x2c, 0x50, 0xcc},
410
	{0xb8, 0x2d, 0xf8, 0xcc},
411
	{0xb8, 0x2e, 0xf8, 0xcc},
412
	{0xb8, 0x2f, 0xf8, 0xcc},
413
	{0xb8, 0x30, 0x50, 0xcc},
414
	{0xb8, 0x31, 0xf8, 0xcc},
415
	{0xb8, 0x32, 0xf8, 0xcc},
416
	{0xb8, 0x33, 0xf8, 0xcc},
417
	{0xb8, 0x34, 0x50, 0xcc},
418
	{0xb8, 0x35, 0x00, 0xcc},
419
	{0xb8, 0x36, 0x00, 0xcc},
420
	{0xb8, 0x37, 0x00, 0xcc},
421
	{0xb8, 0x01, 0x79, 0xcc},
422
	{0xb8, 0x08, 0xe0, 0xcc},
423
	{0xb3, 0x01, 0x41, 0xcc},
424
	{0xb8, 0x01, 0x79, 0xcc},
425
	{0xb8, 0x14, 0x18, 0xcc},
426
	{0xb8, 0xb2, 0x0a, 0xcc},
427
	{0xb8, 0xb4, 0x0a, 0xcc},
428
	{0xb8, 0xb5, 0x0a, 0xcc},
429
	{0xb8, 0xfe, 0x00, 0xcc},
430
	{0xb8, 0xff, 0x28, 0xcc},
431
	{0xb9, 0x00, 0x28, 0xcc},
432
	{0xb9, 0x01, 0x28, 0xcc},
433
	{0xb9, 0x02, 0x28, 0xcc},
434
	{0xb9, 0x03, 0x00, 0xcc},
435
	{0xb9, 0x04, 0x00, 0xcc},
436
	{0xb9, 0x05, 0x3c, 0xcc},
437
	{0xb9, 0x06, 0x3c, 0xcc},
438
	{0xb9, 0x07, 0x3c, 0xcc},
439
	{0xb9, 0x08, 0x3c, 0xcc},
440
	{0xb8, 0x8e, 0x00, 0xcc},
441
	{0xb8, 0x8f, 0xff, 0xcc},
442
	{0xb8, 0x81, 0x09, 0xcc},
443
	{0x31, 0x00, 0x00, 0xbb},
444
	{0x09, 0x01, 0xc7, 0xbb},
445
	{0x34, 0x01, 0x00, 0xbb},
446
	{0x2b, 0x00, 0x28, 0xbb},
447
	{0x2c, 0x00, 0x30, 0xbb},
448
	{0x2d, 0x00, 0x30, 0xbb},
449
	{0x2e, 0x00, 0x28, 0xbb},
450
	{0x62, 0x04, 0x11, 0xbb},
451
	{0x03, 0x01, 0xe0, 0xbb},
452
	{0x2c, 0x00, 0x2c, 0xbb},
453
	{0x20, 0xd0, 0x00, 0xbb},
454
	{0x01, 0x00, 0x08, 0xbb},
455
	{0x06, 0x00, 0x10, 0xbb},
456
	{0x05, 0x00, 0x20, 0xbb},
457
	{0x20, 0x00, 0x00, 0xbb},
458
	{0xb6, 0x00, 0x00, 0xcc},
459
	{0xb6, 0x03, 0x02, 0xcc},
460
	{0xb6, 0x02, 0x80, 0xcc},
461
	{0xb6, 0x05, 0x01, 0xcc},
462
	{0xb6, 0x04, 0xe0, 0xcc},
463
	{0xb6, 0x12, 0x78, 0xcc},
464
	{0xb6, 0x18, 0x02, 0xcc},
465
	{0xb6, 0x17, 0x58, 0xcc},
466
	{0xb6, 0x16, 0x00, 0xcc},
467
	{0xb6, 0x22, 0x12, 0xcc},
468
	{0xb6, 0x23, 0x0b, 0xcc},
469
	{0xb3, 0x02, 0x02, 0xcc},
470
	{0xbf, 0xc0, 0x39, 0xcc},
471
	{0xbf, 0xc1, 0x04, 0xcc},
472
	{0xbf, 0xcc, 0x10, 0xcc},
473
	{0xb9, 0x12, 0x00, 0xcc},
474
	{0xb9, 0x13, 0x0a, 0xcc},
475
	{0xb9, 0x14, 0x0a, 0xcc},
476
	{0xb9, 0x15, 0x0a, 0xcc},
477
	{0xb9, 0x16, 0x0a, 0xcc},
478
	{0xb9, 0x18, 0x00, 0xcc},
479
	{0xb9, 0x19, 0x0f, 0xcc},
480
	{0xb9, 0x1a, 0x0f, 0xcc},
481
	{0xb9, 0x1b, 0x0f, 0xcc},
482
	{0xb9, 0x1c, 0x0f, 0xcc},
483
	{0xb8, 0x8e, 0x00, 0xcc},
484
	{0xb8, 0x8f, 0xff, 0xcc},
485
	{0xb6, 0x12, 0xf8, 0xcc},
486
	{0xb8, 0x0c, 0x20, 0xcc},
487
	{0xb8, 0x0d, 0x70, 0xcc},
488
	{0xb6, 0x13, 0x13, 0xcc},
489
	{0x35, 0x00, 0x60, 0xbb},
490
	{0xb3, 0x5c, 0x01, 0xcc},
491
	{}
492
};
493
static const u8 mi0360_initQVGA_JPG[][4] = {
494
	{0xb0, 0x03, 0x19, 0xcc},
495
	{0xb0, 0x04, 0x02, 0xcc},
496
	{0xb3, 0x00, 0x24, 0xcc},
497
	{0xb3, 0x00, 0x25, 0xcc},
498
	{0xb3, 0x08, 0x01, 0xcc},
499
	{0xb3, 0x09, 0x0c, 0xcc},
500
	{0xb3, 0x05, 0x01, 0xcc},
501
	{0xb3, 0x06, 0x03, 0xcc},
502
	{0xb3, 0x03, 0x0a, 0xcc},
503
	{0xb3, 0x20, 0x00, 0xcc},
504
	{0xb3, 0x21, 0x00, 0xcc},
505
	{0xb3, 0x22, 0x01, 0xcc},
506
	{0xb3, 0x23, 0xe0, 0xcc},
507
	{0xb3, 0x04, 0x05, 0xcc},
508
	{0xb3, 0x14, 0x00, 0xcc},
509
	{0xb3, 0x15, 0x00, 0xcc},
510
	{0xb3, 0x16, 0x02, 0xcc},
511
	{0xb3, 0x17, 0x7f, 0xcc},
512
	{0xb3, 0x35, 0xdd, 0xcc},
513
	{0xb3, 0x34, 0x02, 0xcc},
514
	{0xb3, 0x00, 0x25, 0xcc},
515
	{0xbc, 0x00, 0xd1, 0xcc},
516
	{0xb8, 0x00, 0x13, 0xcc},
517
	{0xb8, 0x27, 0x20, 0xcc},
518
	{0xb8, 0x2c, 0x50, 0xcc},
519
	{0xb8, 0x2d, 0xf8, 0xcc},
520
	{0xb8, 0x2e, 0xf8, 0xcc},
521
	{0xb8, 0x2f, 0xf8, 0xcc},
522
	{0xb8, 0x30, 0x50, 0xcc},
523
	{0xb8, 0x31, 0xf8, 0xcc},
524
	{0xb8, 0x32, 0xf8, 0xcc},
525
	{0xb8, 0x33, 0xf8, 0xcc},
526
	{0xb8, 0x34, 0x50, 0xcc},
527
	{0xb8, 0x35, 0x00, 0xcc},
528
	{0xb8, 0x36, 0x00, 0xcc},
529
	{0xb8, 0x37, 0x00, 0xcc},
530
	{0xb8, 0x01, 0x79, 0xcc},
531
	{0xb8, 0x08, 0xe0, 0xcc},
532
	{0xb3, 0x01, 0x41, 0xcc},
533
	{0xb8, 0x01, 0x79, 0xcc},
534
	{0xb8, 0x14, 0x18, 0xcc},
535
	{0xb8, 0xb2, 0x0a, 0xcc},
536
	{0xb8, 0xb4, 0x0a, 0xcc},
537
	{0xb8, 0xb5, 0x0a, 0xcc},
538
	{0xb8, 0xfe, 0x00, 0xcc},
539
	{0xb8, 0xff, 0x28, 0xcc},
540
	{0xb9, 0x00, 0x28, 0xcc},
541
	{0xb9, 0x01, 0x28, 0xcc},
542
	{0xb9, 0x02, 0x28, 0xcc},
543
	{0xb9, 0x03, 0x00, 0xcc},
544
	{0xb9, 0x04, 0x00, 0xcc},
545
	{0xb9, 0x05, 0x3c, 0xcc},
546
	{0xb9, 0x06, 0x3c, 0xcc},
547
	{0xb9, 0x07, 0x3c, 0xcc},
548
	{0xb9, 0x08, 0x3c, 0xcc},
549
	{0xb8, 0x8e, 0x00, 0xcc},
550
	{0xb8, 0x8f, 0xff, 0xcc},
551
	{0xb8, 0x81, 0x09, 0xcc},
552
	{0x31, 0x00, 0x00, 0xbb},
553
	{0x09, 0x01, 0xc7, 0xbb},
554
	{0x34, 0x01, 0x00, 0xbb},
555
	{0x2b, 0x00, 0x28, 0xbb},
556
	{0x2c, 0x00, 0x30, 0xbb},
557
	{0x2d, 0x00, 0x30, 0xbb},
558
	{0x2e, 0x00, 0x28, 0xbb},
559
	{0x62, 0x04, 0x11, 0xbb},
560
	{0x03, 0x01, 0xe0, 0xbb},
561
	{0x2c, 0x00, 0x2c, 0xbb},
562
	{0x20, 0xd0, 0x00, 0xbb},
563
	{0x01, 0x00, 0x08, 0xbb},
564
	{0x06, 0x00, 0x10, 0xbb},
565
	{0x05, 0x00, 0x20, 0xbb},
566
	{0x20, 0x00, 0x00, 0xbb},
567
	{0xb6, 0x00, 0x00, 0xcc},
568
	{0xb6, 0x03, 0x01, 0xcc},
569
	{0xb6, 0x02, 0x40, 0xcc},
570
	{0xb6, 0x05, 0x00, 0xcc},
571
	{0xb6, 0x04, 0xf0, 0xcc},
572
	{0xb6, 0x12, 0x78, 0xcc},
573
	{0xb6, 0x18, 0x00, 0xcc},
574
	{0xb6, 0x17, 0x96, 0xcc},
575
	{0xb6, 0x16, 0x00, 0xcc},
576
	{0xb6, 0x22, 0x12, 0xcc},
577
	{0xb6, 0x23, 0x0b, 0xcc},
578
	{0xb3, 0x02, 0x02, 0xcc},
579
	{0xbf, 0xc0, 0x39, 0xcc},
580
	{0xbf, 0xc1, 0x04, 0xcc},
581
	{0xbf, 0xcc, 0x10, 0xcc},
582
	{0xb9, 0x12, 0x00, 0xcc},
583
	{0xb9, 0x13, 0x0a, 0xcc},
584
	{0xb9, 0x14, 0x0a, 0xcc},
585
	{0xb9, 0x15, 0x0a, 0xcc},
586
	{0xb9, 0x16, 0x0a, 0xcc},
587
	{0xb9, 0x18, 0x00, 0xcc},
588
	{0xb9, 0x19, 0x0f, 0xcc},
589
	{0xb9, 0x1a, 0x0f, 0xcc},
590
	{0xb9, 0x1b, 0x0f, 0xcc},
591
	{0xb9, 0x1c, 0x0f, 0xcc},
592
	{0xb8, 0x8e, 0x00, 0xcc},
593
	{0xb8, 0x8f, 0xff, 0xcc},
594
	{0xb6, 0x12, 0xf8, 0xcc},
595
	{0xb6, 0x13, 0x13, 0xcc},
596
	{0xbc, 0x02, 0x18, 0xcc},
597
	{0xbc, 0x03, 0x50, 0xcc},
598
	{0xbc, 0x04, 0x18, 0xcc},
599
	{0xbc, 0x05, 0x00, 0xcc},
600
	{0xbc, 0x06, 0x00, 0xcc},
601
	{0xbc, 0x08, 0x30, 0xcc},
602
	{0xbc, 0x09, 0x40, 0xcc},
603
	{0xbc, 0x0a, 0x10, 0xcc},
604
	{0xb8, 0x0c, 0x20, 0xcc},
605
	{0xb8, 0x0d, 0x70, 0xcc},
606
	{0xbc, 0x0b, 0x00, 0xcc},
607
	{0xbc, 0x0c, 0x00, 0xcc},
608
	{0x35, 0x00, 0xef, 0xbb},
609
	{0xb3, 0x5c, 0x01, 0xcc},
610
	{}
611
};
612

613
static const u8 mi1310_socinitVGA_JPG[][4] = {
614
	{0xb0, 0x03, 0x19, 0xcc},
615
	{0xb0, 0x04, 0x02, 0xcc},
616
	{0xb3, 0x00, 0x64, 0xcc},
617
	{0xb3, 0x00, 0x65, 0xcc},
618
	{0xb3, 0x05, 0x00, 0xcc},
619
	{0xb3, 0x06, 0x00, 0xcc},
620
	{0xb3, 0x08, 0x01, 0xcc},
621
	{0xb3, 0x09, 0x0c, 0xcc},
622
	{0xb3, 0x34, 0x02, 0xcc},
623
	{0xb3, 0x35, 0xdd, 0xcc},	/* i2c add: 5d */
624
	{0xb3, 0x02, 0x00, 0xcc},
625
	{0xb3, 0x03, 0x0a, 0xcc},
626
	{0xb3, 0x04, 0x05, 0xcc},
627
	{0xb3, 0x20, 0x00, 0xcc},
628
	{0xb3, 0x21, 0x00, 0xcc},
629
	{0xb3, 0x22, 0x03, 0xcc},
630
	{0xb3, 0x23, 0xc0, 0xcc},
631
	{0xb3, 0x14, 0x00, 0xcc},
632
	{0xb3, 0x15, 0x00, 0xcc},
633
	{0xb3, 0x16, 0x04, 0xcc},
634
	{0xb3, 0x17, 0xff, 0xcc},
635
	{0xb3, 0x00, 0x65, 0xcc},
636
	{0xb8, 0x00, 0x00, 0xcc},
637
	{0xbc, 0x00, 0xd0, 0xcc},
638
	{0xbc, 0x01, 0x01, 0xcc},
639
	{0xf0, 0x00, 0x02, 0xbb},
640
	{0xc8, 0x9f, 0x0b, 0xbb},
641
	{0x5b, 0x00, 0x01, 0xbb},
642
	{0x2f, 0xde, 0x20, 0xbb},
643
	{0xf0, 0x00, 0x00, 0xbb},
644
	{0x20, 0x03, 0x02, 0xbb},	/* h/v flip */
645
	{0xf0, 0x00, 0x01, 0xbb},
646
	{0x05, 0x00, 0x07, 0xbb},
647
	{0x34, 0x00, 0x00, 0xbb},
648
	{0x35, 0xff, 0x00, 0xbb},
649
	{0xdc, 0x07, 0x02, 0xbb},
650
	{0xdd, 0x3c, 0x18, 0xbb},
651
	{0xde, 0x92, 0x6d, 0xbb},
652
	{0xdf, 0xcd, 0xb1, 0xbb},
653
	{0xe0, 0xff, 0xe7, 0xbb},
654
	{0x06, 0xf0, 0x0d, 0xbb},
655
	{0x06, 0x70, 0x0e, 0xbb},
656
	{0x4c, 0x00, 0x01, 0xbb},
657
	{0x4d, 0x00, 0x01, 0xbb},
658
	{0xf0, 0x00, 0x02, 0xbb},
659
	{0x2e, 0x0c, 0x55, 0xbb},
660
	{0x21, 0xb6, 0x6e, 0xbb},
661
	{0x36, 0x30, 0x10, 0xbb},
662
	{0x37, 0x00, 0xc1, 0xbb},
663
	{0xf0, 0x00, 0x00, 0xbb},
664
	{0x07, 0x00, 0x84, 0xbb},
665
	{0x08, 0x02, 0x4a, 0xbb},
666
	{0x05, 0x01, 0x10, 0xbb},
667
	{0x06, 0x00, 0x39, 0xbb},
668
	{0xf0, 0x00, 0x02, 0xbb},
669
	{0x58, 0x02, 0x67, 0xbb},
670
	{0x57, 0x02, 0x00, 0xbb},
671
	{0x5a, 0x02, 0x67, 0xbb},
672
	{0x59, 0x02, 0x00, 0xbb},
673
	{0x5c, 0x12, 0x0d, 0xbb},
674
	{0x5d, 0x16, 0x11, 0xbb},
675
	{0x39, 0x06, 0x18, 0xbb},
676
	{0x3a, 0x06, 0x18, 0xbb},
677
	{0x3b, 0x06, 0x18, 0xbb},
678
	{0x3c, 0x06, 0x18, 0xbb},
679
	{0x64, 0x7b, 0x5b, 0xbb},
680
	{0xf0, 0x00, 0x02, 0xbb},
681
	{0x36, 0x30, 0x10, 0xbb},
682
	{0x37, 0x00, 0xc0, 0xbb},
683
	{0xbc, 0x0e, 0x00, 0xcc},
684
	{0xbc, 0x0f, 0x05, 0xcc},
685
	{0xbc, 0x10, 0xc0, 0xcc},
686
	{0xbc, 0x11, 0x03, 0xcc},
687
	{0xb6, 0x00, 0x00, 0xcc},
688
	{0xb6, 0x03, 0x02, 0xcc},
689
	{0xb6, 0x02, 0x80, 0xcc},
690
	{0xb6, 0x05, 0x01, 0xcc},
691
	{0xb6, 0x04, 0xe0, 0xcc},
692
	{0xb6, 0x12, 0xf8, 0xcc},
693
	{0xb6, 0x13, 0x25, 0xcc},
694
	{0xb6, 0x18, 0x02, 0xcc},
695
	{0xb6, 0x17, 0x58, 0xcc},
696
	{0xb6, 0x16, 0x00, 0xcc},
697
	{0xb6, 0x22, 0x12, 0xcc},
698
	{0xb6, 0x23, 0x0b, 0xcc},
699
	{0xbf, 0xc0, 0x39, 0xcc},
700
	{0xbf, 0xc1, 0x04, 0xcc},
701
	{0xbf, 0xcc, 0x00, 0xcc},
702
	{0xbc, 0x02, 0x18, 0xcc},
703
	{0xbc, 0x03, 0x50, 0xcc},
704
	{0xbc, 0x04, 0x18, 0xcc},
705
	{0xbc, 0x05, 0x00, 0xcc},
706
	{0xbc, 0x06, 0x00, 0xcc},
707
	{0xbc, 0x08, 0x30, 0xcc},
708
	{0xbc, 0x09, 0x40, 0xcc},
709
	{0xbc, 0x0a, 0x10, 0xcc},
710
	{0xbc, 0x0b, 0x00, 0xcc},
711
	{0xbc, 0x0c, 0x00, 0xcc},
712
	{0xb3, 0x5c, 0x01, 0xcc},
713
	{0xf0, 0x00, 0x01, 0xbb},
714
	{0x80, 0x00, 0x03, 0xbb},
715
	{0x81, 0xc7, 0x14, 0xbb},
716
	{0x82, 0xeb, 0xe8, 0xbb},
717
	{0x83, 0xfe, 0xf4, 0xbb},
718
	{0x84, 0xcd, 0x10, 0xbb},
719
	{0x85, 0xf3, 0xee, 0xbb},
720
	{0x86, 0xff, 0xf1, 0xbb},
721
	{0x87, 0xcd, 0x10, 0xbb},
722
	{0x88, 0xf3, 0xee, 0xbb},
723
	{0x89, 0x01, 0xf1, 0xbb},
724
	{0x8a, 0xe5, 0x17, 0xbb},
725
	{0x8b, 0xe8, 0xe2, 0xbb},
726
	{0x8c, 0xf7, 0xed, 0xbb},
727
	{0x8d, 0x00, 0xff, 0xbb},
728
	{0x8e, 0xec, 0x10, 0xbb},
729
	{0x8f, 0xf0, 0xed, 0xbb},
730
	{0x90, 0xf9, 0xf2, 0xbb},
731
	{0x91, 0x00, 0x00, 0xbb},
732
	{0x92, 0xe9, 0x0d, 0xbb},
733
	{0x93, 0xf4, 0xf2, 0xbb},
734
	{0x94, 0xfb, 0xf5, 0xbb},
735
	{0x95, 0x00, 0xff, 0xbb},
736
	{0xb6, 0x0f, 0x08, 0xbb},
737
	{0xb7, 0x3d, 0x16, 0xbb},
738
	{0xb8, 0x0c, 0x04, 0xbb},
739
	{0xb9, 0x1c, 0x07, 0xbb},
740
	{0xba, 0x0a, 0x03, 0xbb},
741
	{0xbb, 0x1b, 0x09, 0xbb},
742
	{0xbc, 0x17, 0x0d, 0xbb},
743
	{0xbd, 0x23, 0x1d, 0xbb},
744
	{0xbe, 0x00, 0x28, 0xbb},
745
	{0xbf, 0x11, 0x09, 0xbb},
746
	{0xc0, 0x16, 0x15, 0xbb},
747
	{0xc1, 0x00, 0x1b, 0xbb},
748
	{0xc2, 0x0e, 0x07, 0xbb},
749
	{0xc3, 0x14, 0x10, 0xbb},
750
	{0xc4, 0x00, 0x17, 0xbb},
751
	{0x06, 0x74, 0x8e, 0xbb},
752
	{0xf0, 0x00, 0x01, 0xbb},
753
	{0x06, 0xf4, 0x8e, 0xbb},
754
	{0x00, 0x00, 0x50, 0xdd},
755
	{0x06, 0x74, 0x8e, 0xbb},
756
	{0xf0, 0x00, 0x02, 0xbb},
757
	{0x24, 0x50, 0x20, 0xbb},
758
	{0xf0, 0x00, 0x02, 0xbb},
759
	{0x34, 0x0c, 0x50, 0xbb},
760
	{0xb3, 0x01, 0x41, 0xcc},
761
	{0xf0, 0x00, 0x00, 0xbb},
762
	{0x03, 0x03, 0xc0, 0xbb},
763
	{},
764
};
765
static const u8 mi1310_socinitQVGA_JPG[][4] = {
766
	{0xb0, 0x03, 0x19, 0xcc},	{0xb0, 0x04, 0x02, 0xcc},
767
	{0xb3, 0x00, 0x64, 0xcc},	{0xb3, 0x00, 0x65, 0xcc},
768
	{0xb3, 0x05, 0x00, 0xcc},	{0xb3, 0x06, 0x00, 0xcc},
769
	{0xb3, 0x08, 0x01, 0xcc},	{0xb3, 0x09, 0x0c, 0xcc},
770
	{0xb3, 0x34, 0x02, 0xcc},	{0xb3, 0x35, 0xdd, 0xcc},
771
	{0xb3, 0x02, 0x00, 0xcc},	{0xb3, 0x03, 0x0a, 0xcc},
772
	{0xb3, 0x04, 0x05, 0xcc},	{0xb3, 0x20, 0x00, 0xcc},
773
	{0xb3, 0x21, 0x00, 0xcc},	{0xb3, 0x22, 0x03, 0xcc},
774
	{0xb3, 0x23, 0xc0, 0xcc},	{0xb3, 0x14, 0x00, 0xcc},
775
	{0xb3, 0x15, 0x00, 0xcc},	{0xb3, 0x16, 0x04, 0xcc},
776
	{0xb3, 0x17, 0xff, 0xcc},	{0xb3, 0x00, 0x65, 0xcc},
777
	{0xb8, 0x00, 0x00, 0xcc},	{0xbc, 0x00, 0xf0, 0xcc},
778
	{0xbc, 0x01, 0x01, 0xcc},	{0xf0, 0x00, 0x02, 0xbb},
779
	{0xc8, 0x9f, 0x0b, 0xbb},	{0x5b, 0x00, 0x01, 0xbb},
780
	{0x2f, 0xde, 0x20, 0xbb},	{0xf0, 0x00, 0x00, 0xbb},
781
	{0x20, 0x03, 0x02, 0xbb},	/* h/v flip */
782
	{0xf0, 0x00, 0x01, 0xbb},
783
	{0x05, 0x00, 0x07, 0xbb},	{0x34, 0x00, 0x00, 0xbb},
784
	{0x35, 0xff, 0x00, 0xbb},	{0xdc, 0x07, 0x02, 0xbb},
785
	{0xdd, 0x3c, 0x18, 0xbb},	{0xde, 0x92, 0x6d, 0xbb},
786
	{0xdf, 0xcd, 0xb1, 0xbb},	{0xe0, 0xff, 0xe7, 0xbb},
787
	{0x06, 0xf0, 0x0d, 0xbb},	{0x06, 0x70, 0x0e, 0xbb},
788
	{0x4c, 0x00, 0x01, 0xbb},	{0x4d, 0x00, 0x01, 0xbb},
789
	{0xf0, 0x00, 0x02, 0xbb},	{0x2e, 0x0c, 0x55, 0xbb},
790
	{0x21, 0xb6, 0x6e, 0xbb},	{0x36, 0x30, 0x10, 0xbb},
791
	{0x37, 0x00, 0xc1, 0xbb},	{0xf0, 0x00, 0x00, 0xbb},
792
	{0x07, 0x00, 0x84, 0xbb},	{0x08, 0x02, 0x4a, 0xbb},
793
	{0x05, 0x01, 0x10, 0xbb},	{0x06, 0x00, 0x39, 0xbb},
794
	{0xf0, 0x00, 0x02, 0xbb},	{0x58, 0x02, 0x67, 0xbb},
795
	{0x57, 0x02, 0x00, 0xbb},	{0x5a, 0x02, 0x67, 0xbb},
796
	{0x59, 0x02, 0x00, 0xbb},	{0x5c, 0x12, 0x0d, 0xbb},
797
	{0x5d, 0x16, 0x11, 0xbb},	{0x39, 0x06, 0x18, 0xbb},
798
	{0x3a, 0x06, 0x18, 0xbb},	{0x3b, 0x06, 0x18, 0xbb},
799
	{0x3c, 0x06, 0x18, 0xbb},	{0x64, 0x7b, 0x5b, 0xbb},
800
	{0xf0, 0x00, 0x02, 0xbb},	{0x36, 0x30, 0x10, 0xbb},
801
	{0x37, 0x00, 0xc0, 0xbb},	{0xbc, 0x0e, 0x00, 0xcc},
802
	{0xbc, 0x0f, 0x05, 0xcc},	{0xbc, 0x10, 0xc0, 0xcc},
803
	{0xbc, 0x11, 0x03, 0xcc},	{0xb6, 0x00, 0x00, 0xcc},
804
	{0xb6, 0x03, 0x01, 0xcc},	{0xb6, 0x02, 0x40, 0xcc},
805
	{0xb6, 0x05, 0x00, 0xcc},	{0xb6, 0x04, 0xf0, 0xcc},
806
	{0xb6, 0x12, 0xf8, 0xcc},	{0xb6, 0x13, 0x25, 0xcc},
807
	{0xb6, 0x18, 0x00, 0xcc},	{0xb6, 0x17, 0x96, 0xcc},
808
	{0xb6, 0x16, 0x00, 0xcc},	{0xb6, 0x22, 0x12, 0xcc},
809
	{0xb6, 0x23, 0x0b, 0xcc},	{0xbf, 0xc0, 0x39, 0xcc},
810
	{0xbf, 0xc1, 0x04, 0xcc},	{0xbf, 0xcc, 0x00, 0xcc},
811
	{0xb3, 0x5c, 0x01, 0xcc},	{0xf0, 0x00, 0x01, 0xbb},
812
	{0x80, 0x00, 0x03, 0xbb},	{0x81, 0xc7, 0x14, 0xbb},
813
	{0x82, 0xeb, 0xe8, 0xbb},	{0x83, 0xfe, 0xf4, 0xbb},
814
	{0x84, 0xcd, 0x10, 0xbb},	{0x85, 0xf3, 0xee, 0xbb},
815
	{0x86, 0xff, 0xf1, 0xbb},	{0x87, 0xcd, 0x10, 0xbb},
816
	{0x88, 0xf3, 0xee, 0xbb},	{0x89, 0x01, 0xf1, 0xbb},
817
	{0x8a, 0xe5, 0x17, 0xbb},	{0x8b, 0xe8, 0xe2, 0xbb},
818
	{0x8c, 0xf7, 0xed, 0xbb},	{0x8d, 0x00, 0xff, 0xbb},
819
	{0x8e, 0xec, 0x10, 0xbb},	{0x8f, 0xf0, 0xed, 0xbb},
820
	{0x90, 0xf9, 0xf2, 0xbb},	{0x91, 0x00, 0x00, 0xbb},
821
	{0x92, 0xe9, 0x0d, 0xbb},	{0x93, 0xf4, 0xf2, 0xbb},
822
	{0x94, 0xfb, 0xf5, 0xbb},	{0x95, 0x00, 0xff, 0xbb},
823
	{0xb6, 0x0f, 0x08, 0xbb},	{0xb7, 0x3d, 0x16, 0xbb},
824
	{0xb8, 0x0c, 0x04, 0xbb},	{0xb9, 0x1c, 0x07, 0xbb},
825
	{0xba, 0x0a, 0x03, 0xbb},	{0xbb, 0x1b, 0x09, 0xbb},
826
	{0xbc, 0x17, 0x0d, 0xbb},	{0xbd, 0x23, 0x1d, 0xbb},
827
	{0xbe, 0x00, 0x28, 0xbb},	{0xbf, 0x11, 0x09, 0xbb},
828
	{0xc0, 0x16, 0x15, 0xbb},	{0xc1, 0x00, 0x1b, 0xbb},
829
	{0xc2, 0x0e, 0x07, 0xbb},	{0xc3, 0x14, 0x10, 0xbb},
830
	{0xc4, 0x00, 0x17, 0xbb},	{0x06, 0x74, 0x8e, 0xbb},
831
	{0xf0, 0x00, 0x01, 0xbb},	{0x06, 0xf4, 0x8e, 0xbb},
832
	{0x00, 0x00, 0x50, 0xdd},	{0x06, 0x74, 0x8e, 0xbb},
833
	{0xf0, 0x00, 0x02, 0xbb},	{0x24, 0x50, 0x20, 0xbb},
834
	{0xf0, 0x00, 0x02, 0xbb},	{0x34, 0x0c, 0x50, 0xbb},
835
	{0xb3, 0x01, 0x41, 0xcc},	{0xf0, 0x00, 0x00, 0xbb},
836
	{0x03, 0x03, 0xc0, 0xbb},
837
	{},
838
};
839
static const u8 mi1310_soc_InitSXGA_JPG[][4] = {
840
	{0xb0, 0x03, 0x19, 0xcc},
841
	{0xb0, 0x04, 0x02, 0xcc},
842
	{0xb3, 0x00, 0x64, 0xcc},
843
	{0xb3, 0x00, 0x65, 0xcc},
844
	{0xb3, 0x05, 0x00, 0xcc},
845
	{0xb3, 0x06, 0x00, 0xcc},
846
	{0xb3, 0x08, 0x01, 0xcc},
847
	{0xb3, 0x09, 0x0c, 0xcc},
848
	{0xb3, 0x34, 0x02, 0xcc},
849
	{0xb3, 0x35, 0xdd, 0xcc},
850
	{0xb3, 0x02, 0x00, 0xcc},
851
	{0xb3, 0x03, 0x0a, 0xcc},
852
	{0xb3, 0x04, 0x0d, 0xcc},
853
	{0xb3, 0x20, 0x00, 0xcc},
854
	{0xb3, 0x21, 0x00, 0xcc},
855
	{0xb3, 0x22, 0x03, 0xcc},
856
	{0xb3, 0x23, 0xc0, 0xcc},
857
	{0xb3, 0x14, 0x00, 0xcc},
858
	{0xb3, 0x15, 0x00, 0xcc},
859
	{0xb3, 0x16, 0x04, 0xcc},
860
	{0xb3, 0x17, 0xff, 0xcc},
861
	{0xb3, 0x00, 0x65, 0xcc},
862
	{0xb8, 0x00, 0x00, 0xcc},
863
	{0xbc, 0x00, 0x70, 0xcc},
864
	{0xbc, 0x01, 0x01, 0xcc},
865
	{0xf0, 0x00, 0x02, 0xbb},
866
	{0xc8, 0x9f, 0x0b, 0xbb},
867
	{0x5b, 0x00, 0x01, 0xbb},
868
	{0xf0, 0x00, 0x00, 0xbb},
869
	{0x20, 0x03, 0x02, 0xbb},	/* h/v flip */
870
	{0xf0, 0x00, 0x01, 0xbb},
871
	{0x05, 0x00, 0x07, 0xbb},
872
	{0x34, 0x00, 0x00, 0xbb},
873
	{0x35, 0xff, 0x00, 0xbb},
874
	{0xdc, 0x07, 0x02, 0xbb},
875
	{0xdd, 0x3c, 0x18, 0xbb},
876
	{0xde, 0x92, 0x6d, 0xbb},
877
	{0xdf, 0xcd, 0xb1, 0xbb},
878
	{0xe0, 0xff, 0xe7, 0xbb},
879
	{0x06, 0xf0, 0x0d, 0xbb},
880
	{0x06, 0x70, 0x0e, 0xbb},
881
	{0x4c, 0x00, 0x01, 0xbb},
882
	{0x4d, 0x00, 0x01, 0xbb},
883
	{0xf0, 0x00, 0x02, 0xbb},
884
	{0x2e, 0x0c, 0x60, 0xbb},
885
	{0x21, 0xb6, 0x6e, 0xbb},
886
	{0x37, 0x01, 0x40, 0xbb},
887
	{0xf0, 0x00, 0x00, 0xbb},
888
	{0x07, 0x00, 0x84, 0xbb},
889
	{0x08, 0x02, 0x4a, 0xbb},
890
	{0x05, 0x01, 0x10, 0xbb},
891
	{0x06, 0x00, 0x39, 0xbb},
892
	{0xf0, 0x00, 0x02, 0xbb},
893
	{0x58, 0x02, 0x67, 0xbb},
894
	{0x57, 0x02, 0x00, 0xbb},
895
	{0x5a, 0x02, 0x67, 0xbb},
896
	{0x59, 0x02, 0x00, 0xbb},
897
	{0x5c, 0x12, 0x0d, 0xbb},
898
	{0x5d, 0x16, 0x11, 0xbb},
899
	{0x39, 0x06, 0x18, 0xbb},
900
	{0x3a, 0x06, 0x18, 0xbb},
901
	{0x3b, 0x06, 0x18, 0xbb},
902
	{0x3c, 0x06, 0x18, 0xbb},
903
	{0x64, 0x7b, 0x5b, 0xbb},
904
	{0xb6, 0x00, 0x00, 0xcc},
905
	{0xb6, 0x03, 0x05, 0xcc},
906
	{0xb6, 0x02, 0x00, 0xcc},
907
	{0xb6, 0x05, 0x03, 0xcc},
908
	{0xb6, 0x04, 0xc0, 0xcc},
909
	{0xb6, 0x12, 0xf8, 0xcc},
910
	{0xb6, 0x13, 0x29, 0xcc},
911
	{0xb6, 0x18, 0x09, 0xcc},
912
	{0xb6, 0x17, 0x60, 0xcc},
913
	{0xb6, 0x16, 0x00, 0xcc},
914
	{0xb6, 0x22, 0x12, 0xcc},
915
	{0xb6, 0x23, 0x0b, 0xcc},
916
	{0xbf, 0xc0, 0x39, 0xcc},
917
	{0xbf, 0xc1, 0x04, 0xcc},
918
	{0xbf, 0xcc, 0x00, 0xcc},
919
	{0xb3, 0x01, 0x41, 0xcc},
920
	{0x00, 0x00, 0x80, 0xdd},
921
	{0xf0, 0x00, 0x02, 0xbb},
922
	{0x00, 0x00, 0x10, 0xdd},
923
	{0x22, 0xa0, 0x78, 0xbb},
924
	{0x23, 0xa0, 0x78, 0xbb},
925
	{0x24, 0x7f, 0x00, 0xbb},
926
	{0x28, 0xea, 0x02, 0xbb},
927
	{0x29, 0x86, 0x7a, 0xbb},
928
	{0x5e, 0x52, 0x4c, 0xbb},
929
	{0x5f, 0x20, 0x24, 0xbb},
930
	{0x60, 0x00, 0x02, 0xbb},
931
	{0x02, 0x00, 0xee, 0xbb},
932
	{0x03, 0x39, 0x23, 0xbb},
933
	{0x04, 0x07, 0x24, 0xbb},
934
	{0x09, 0x00, 0xc0, 0xbb},
935
	{0x0a, 0x00, 0x79, 0xbb},
936
	{0x0b, 0x00, 0x04, 0xbb},
937
	{0x0c, 0x00, 0x5c, 0xbb},
938
	{0x0d, 0x00, 0xd9, 0xbb},
939
	{0x0e, 0x00, 0x53, 0xbb},
940
	{0x0f, 0x00, 0x21, 0xbb},
941
	{0x10, 0x00, 0xa4, 0xbb},
942
	{0x11, 0x00, 0xe5, 0xbb},
943
	{0x15, 0x00, 0x00, 0xbb},
944
	{0x16, 0x00, 0x00, 0xbb},
945
	{0x17, 0x00, 0x00, 0xbb},
946
	{0x18, 0x00, 0x00, 0xbb},
947
	{0x19, 0x00, 0x00, 0xbb},
948
	{0x1a, 0x00, 0x00, 0xbb},
949
	{0x1b, 0x00, 0x00, 0xbb},
950
	{0x1c, 0x00, 0x00, 0xbb},
951
	{0x1d, 0x00, 0x00, 0xbb},
952
	{0x1e, 0x00, 0x00, 0xbb},
953
	{0xf0, 0x00, 0x01, 0xbb},
954
	{0x00, 0x00, 0x20, 0xdd},
955
	{0x06, 0xf0, 0x8e, 0xbb},
956
	{0x00, 0x00, 0x80, 0xdd},
957
	{0x06, 0x70, 0x8e, 0xbb},
958
	{0xf0, 0x00, 0x02, 0xbb},
959
	{0x00, 0x00, 0x20, 0xdd},
960
	{0x5e, 0x6a, 0x53, 0xbb},
961
	{0x5f, 0x40, 0x2c, 0xbb},
962
	{0xf0, 0x00, 0x01, 0xbb},
963
	{0x00, 0x00, 0x20, 0xdd},
964
	{0x58, 0x00, 0x00, 0xbb},
965
	{0x53, 0x09, 0x03, 0xbb},
966
	{0x54, 0x31, 0x18, 0xbb},
967
	{0x55, 0x8b, 0x5f, 0xbb},
968
	{0x56, 0xc0, 0xa9, 0xbb},
969
	{0x57, 0xe0, 0xd2, 0xbb},
970
	{0xe1, 0x00, 0x00, 0xbb},
971
	{0xdc, 0x09, 0x03, 0xbb},
972
	{0xdd, 0x31, 0x18, 0xbb},
973
	{0xde, 0x8b, 0x5f, 0xbb},
974
	{0xdf, 0xc0, 0xa9, 0xbb},
975
	{0xe0, 0xe0, 0xd2, 0xbb},
976
	{0xb3, 0x5c, 0x01, 0xcc},
977
	{0xf0, 0x00, 0x01, 0xbb},
978
	{0x06, 0xf0, 0x8e, 0xbb},
979
	{0xf0, 0x00, 0x02, 0xbb},
980
	{0x2f, 0xde, 0x20, 0xbb},
981
	{0xf0, 0x00, 0x02, 0xbb},
982
	{0x24, 0x50, 0x20, 0xbb},
983
	{0xbc, 0x0e, 0x00, 0xcc},
984
	{0xbc, 0x0f, 0x05, 0xcc},
985
	{0xbc, 0x10, 0xc0, 0xcc},
986
	{0xf0, 0x00, 0x02, 0xbb},
987
	{0x34, 0x0c, 0x50, 0xbb},
988
	{0xbc, 0x11, 0x03, 0xcc},
989
	{0xf0, 0x00, 0x01, 0xbb},
990
	{0x80, 0x00, 0x03, 0xbb},
991
	{0x81, 0xc7, 0x14, 0xbb},
992
	{0x82, 0xeb, 0xe8, 0xbb},
993
	{0x83, 0xfe, 0xf4, 0xbb},
994
	{0x84, 0xcd, 0x10, 0xbb},
995
	{0x85, 0xf3, 0xee, 0xbb},
996
	{0x86, 0xff, 0xf1, 0xbb},
997
	{0x87, 0xcd, 0x10, 0xbb},
998
	{0x88, 0xf3, 0xee, 0xbb},
999
	{0x89, 0x01, 0xf1, 0xbb},
1000
	{0x8a, 0xe5, 0x17, 0xbb},
1001
	{0x8b, 0xe8, 0xe2, 0xbb},
1002
	{0x8c, 0xf7, 0xed, 0xbb},
1003
	{0x8d, 0x00, 0xff, 0xbb},
1004
	{0x8e, 0xec, 0x10, 0xbb},
1005
	{0x8f, 0xf0, 0xed, 0xbb},
1006
	{0x90, 0xf9, 0xf2, 0xbb},
1007
	{0x91, 0x00, 0x00, 0xbb},
1008
	{0x92, 0xe9, 0x0d, 0xbb},
1009
	{0x93, 0xf4, 0xf2, 0xbb},
1010
	{0x94, 0xfb, 0xf5, 0xbb},
1011
	{0x95, 0x00, 0xff, 0xbb},
1012
	{0xb6, 0x0f, 0x08, 0xbb},
1013
	{0xb7, 0x3d, 0x16, 0xbb},
1014
	{0xb8, 0x0c, 0x04, 0xbb},
1015
	{0xb9, 0x1c, 0x07, 0xbb},
1016
	{0xba, 0x0a, 0x03, 0xbb},
1017
	{0xbb, 0x1b, 0x09, 0xbb},
1018
	{0xbc, 0x17, 0x0d, 0xbb},
1019
	{0xbd, 0x23, 0x1d, 0xbb},
1020
	{0xbe, 0x00, 0x28, 0xbb},
1021
	{0xbf, 0x11, 0x09, 0xbb},
1022
	{0xc0, 0x16, 0x15, 0xbb},
1023
	{0xc1, 0x00, 0x1b, 0xbb},
1024
	{0xc2, 0x0e, 0x07, 0xbb},
1025
	{0xc3, 0x14, 0x10, 0xbb},
1026
	{0xc4, 0x00, 0x17, 0xbb},
1027
	{0x06, 0x74, 0x8e, 0xbb},
1028
	{0xf0, 0x00, 0x00, 0xbb},
1029
	{0x03, 0x03, 0xc0, 0xbb},
1030
	{}
1031
};
1032

1033
static const u8 mi1320_gamma[17] = {
1034
	0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
1035
	0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
1036
};
1037
static const u8 mi1320_matrix[9] = {
1038
	0x54, 0xda, 0x06, 0xf1, 0x50, 0xf4, 0xf7, 0xea, 0x52
1039
};
1040
static const u8 mi1320_initVGA_data[][4] = {
1041
	{0xb3, 0x01, 0x01, 0xcc},	{0x00, 0x00, 0x33, 0xdd},
1042
	{0xb0, 0x03, 0x19, 0xcc},	{0x00, 0x00, 0x33, 0xdd},
1043
	{0xb0, 0x04, 0x02, 0xcc},	{0x00, 0x00, 0x33, 0xdd},
1044
	{0xb3, 0x00, 0x64, 0xcc},	{0xb3, 0x00, 0x65, 0xcc},
1045
	{0xb0, 0x16, 0x03, 0xcc},	{0xb3, 0x05, 0x00, 0xcc},
1046
	{0xb3, 0x06, 0x00, 0xcc},	{0xb3, 0x08, 0x01, 0xcc},
1047
	{0xb3, 0x09, 0x0c, 0xcc},	{0xb3, 0x34, 0x02, 0xcc},
1048
	{0xb3, 0x35, 0xc8, 0xcc},	/* i2c add: 48 */
1049
	{0xb3, 0x02, 0x00, 0xcc},
1050
	{0xb3, 0x03, 0x0a, 0xcc},	{0xb3, 0x04, 0x05, 0xcc},
1051
	{0xb3, 0x20, 0x00, 0xcc},	{0xb3, 0x21, 0x00, 0xcc},
1052
	{0xb3, 0x22, 0x03, 0xcc},	{0xb3, 0x23, 0xc0, 0xcc},
1053
	{0xb3, 0x14, 0x00, 0xcc},	{0xb3, 0x15, 0x00, 0xcc},
1054
	{0xb3, 0x16, 0x04, 0xcc},	{0xb3, 0x17, 0xff, 0xcc},
1055
	{0xb3, 0x00, 0x67, 0xcc},	{0xbc, 0x00, 0xd0, 0xcc},
1056
	{0xbc, 0x01, 0x01, 0xcc},	{0xf0, 0x00, 0x00, 0xbb},
1057
	{0x0d, 0x00, 0x09, 0xbb},	{0x00, 0x01, 0x00, 0xdd},
1058
	{0x0d, 0x00, 0x08, 0xbb},	{0xf0, 0x00, 0x01, 0xbb},
1059
	{0xa1, 0x05, 0x00, 0xbb},	{0xa4, 0x03, 0xc0, 0xbb},
1060
	{0xf0, 0x00, 0x02, 0xbb},	{0x00, 0x00, 0x10, 0xdd},
1061
	{0xc8, 0x9f, 0x0b, 0xbb},	{0x00, 0x00, 0x10, 0xdd},
1062
	{0xf0, 0x00, 0x00, 0xbb},	{0x00, 0x00, 0x10, 0xdd},
1063
	{0x20, 0x01, 0x00, 0xbb},	{0x00, 0x00, 0x10, 0xdd},
1064
	{0xf0, 0x00, 0x01, 0xbb},	{0x9d, 0x3c, 0xa0, 0xbb},
1065
	{0x47, 0x30, 0x30, 0xbb},	{0xf0, 0x00, 0x00, 0xbb},
1066
	{0x0a, 0x80, 0x11, 0xbb},	{0x35, 0x00, 0x22, 0xbb},
1067
	{0xf0, 0x00, 0x02, 0xbb},	{0x9d, 0xc5, 0x05, 0xbb},
1068
	{0xdc, 0x0f, 0xfc, 0xbb},	{0xf0, 0x00, 0x01, 0xbb},
1069
	{0x06, 0x74, 0x0e, 0xbb},	{0x80, 0x00, 0x06, 0xbb},
1070
	{0x81, 0x04, 0x00, 0xbb},	{0x82, 0x01, 0x02, 0xbb},
1071
	{0x83, 0x03, 0x02, 0xbb},	{0x84, 0x05, 0x00, 0xbb},
1072
	{0x85, 0x01, 0x00, 0xbb},	{0x86, 0x03, 0x02, 0xbb},
1073
	{0x87, 0x05, 0x00, 0xbb},	{0x88, 0x01, 0x00, 0xbb},
1074
	{0x89, 0x02, 0x02, 0xbb},	{0x8a, 0xfd, 0x04, 0xbb},
1075
	{0x8b, 0xfc, 0xfd, 0xbb},	{0x8c, 0xff, 0xfd, 0xbb},
1076
	{0x8d, 0x00, 0x00, 0xbb},	{0x8e, 0xfe, 0x05, 0xbb},
1077
	{0x8f, 0xfc, 0xfd, 0xbb},	{0x90, 0xfe, 0xfd, 0xbb},
1078
	{0x91, 0x00, 0x00, 0xbb},	{0x92, 0xfe, 0x03, 0xbb},
1079
	{0x93, 0xfd, 0xfe, 0xbb},	{0x94, 0xff, 0xfd, 0xbb},
1080
	{0x95, 0x00, 0x00, 0xbb},	{0xb6, 0x07, 0x05, 0xbb},
1081
	{0xb7, 0x13, 0x06, 0xbb},	{0xb8, 0x08, 0x06, 0xbb},
1082
	{0xb9, 0x14, 0x08, 0xbb},	{0xba, 0x06, 0x05, 0xbb},
1083
	{0xbb, 0x13, 0x06, 0xbb},	{0xbc, 0x03, 0x01, 0xbb},
1084
	{0xbd, 0x03, 0x04, 0xbb},	{0xbe, 0x00, 0x02, 0xbb},
1085
	{0xbf, 0x03, 0x01, 0xbb},	{0xc0, 0x02, 0x04, 0xbb},
1086
	{0xc1, 0x00, 0x04, 0xbb},	{0xc2, 0x02, 0x01, 0xbb},
1087
	{0xc3, 0x01, 0x03, 0xbb},	{0xc4, 0x00, 0x04, 0xbb},
1088
	{0xf0, 0x00, 0x00, 0xbb},	{0x05, 0x01, 0x13, 0xbb},
1089
	{0x06, 0x00, 0x11, 0xbb},	{0x07, 0x00, 0x85, 0xbb},
1090
	{0x08, 0x00, 0x27, 0xbb},
1091
	{0x20, 0x01, 0x00, 0xbb},	/* h/v flips - was 03 */
1092
	{0x21, 0x80, 0x00, 0xbb},	{0x22, 0x0d, 0x0f, 0xbb},
1093
	{0x24, 0x80, 0x00, 0xbb},	{0x59, 0x00, 0xff, 0xbb},
1094
	{0xf0, 0x00, 0x02, 0xbb},	{0x39, 0x03, 0x0d, 0xbb},
1095
	{0x3a, 0x06, 0x1b, 0xbb},	{0x3b, 0x00, 0x95, 0xbb},
1096
	{0x3c, 0x04, 0xdb, 0xbb},	{0x57, 0x02, 0x00, 0xbb},
1097
	{0x58, 0x02, 0x66, 0xbb},	{0x59, 0x00, 0xff, 0xbb},
1098
	{0x5a, 0x01, 0x33, 0xbb},	{0x5c, 0x12, 0x0d, 0xbb},
1099
	{0x5d, 0x16, 0x11, 0xbb},	{0x64, 0x5e, 0x1c, 0xbb},
1100
	{0xf0, 0x00, 0x02, 0xbb},	{0x2f, 0xd1, 0x00, 0xbb},
1101
	{0x5b, 0x00, 0x01, 0xbb},	{0xf0, 0x00, 0x02, 0xbb},
1102
	{0x36, 0x68, 0x10, 0xbb},	{0x00, 0x00, 0x30, 0xdd},
1103
	{0x37, 0x82, 0x00, 0xbb},	{0xbc, 0x0e, 0x00, 0xcc},
1104
	{0xbc, 0x0f, 0x05, 0xcc},	{0xbc, 0x10, 0xc0, 0xcc},
1105
	{0xbc, 0x11, 0x03, 0xcc},	{0xb6, 0x00, 0x00, 0xcc},
1106
	{0xb6, 0x03, 0x05, 0xcc},	{0xb6, 0x02, 0x00, 0xcc},
1107
	{0xb6, 0x05, 0x04, 0xcc},	{0xb6, 0x04, 0x00, 0xcc},
1108
	{0xb6, 0x12, 0xf8, 0xcc},	{0xb6, 0x13, 0x29, 0xcc},
1109
	{0xb6, 0x18, 0x0a, 0xcc},	{0xb6, 0x17, 0x00, 0xcc},
1110
	{0xb6, 0x16, 0x00, 0xcc},	{0xb6, 0x22, 0x12, 0xcc},
1111
	{0xb6, 0x23, 0x0b, 0xcc},	{0xbf, 0xc0, 0x26, 0xcc},
1112
	{0xbf, 0xc1, 0x02, 0xcc},	{0xbf, 0xcc, 0x04, 0xcc},
1113
	{0xbc, 0x02, 0x18, 0xcc},	{0xbc, 0x03, 0x50, 0xcc},
1114
	{0xbc, 0x04, 0x18, 0xcc},	{0xbc, 0x05, 0x00, 0xcc},
1115
	{0xbc, 0x06, 0x00, 0xcc},	{0xbc, 0x08, 0x30, 0xcc},
1116
	{0xbc, 0x09, 0x40, 0xcc},	{0xbc, 0x0a, 0x10, 0xcc},
1117
	{0xbc, 0x0b, 0x00, 0xcc},	{0xbc, 0x0c, 0x00, 0xcc},
1118
	{0xb3, 0x5c, 0x01, 0xcc},	{0xb3, 0x01, 0x41, 0xcc},
1119
	{}
1120
};
1121
static const u8 mi1320_initQVGA_data[][4] = {
1122
	{0xb3, 0x01, 0x01, 0xcc},	{0x00, 0x00, 0x33, 0xdd},
1123
	{0xb0, 0x03, 0x19, 0xcc},	{0x00, 0x00, 0x33, 0xdd},
1124
	{0xb0, 0x04, 0x02, 0xcc},	{0x00, 0x00, 0x33, 0xdd},
1125
	{0xb3, 0x00, 0x64, 0xcc},	{0xb3, 0x00, 0x65, 0xcc},
1126
	{0xb0, 0x16, 0x03, 0xcc},	{0xb3, 0x05, 0x01, 0xcc},
1127
	{0xb3, 0x06, 0x01, 0xcc},	{0xb3, 0x08, 0x01, 0xcc},
1128
	{0xb3, 0x09, 0x0c, 0xcc},	{0xb3, 0x34, 0x02, 0xcc},
1129
	{0xb3, 0x35, 0xc8, 0xcc},	{0xb3, 0x02, 0x00, 0xcc},
1130
	{0xb3, 0x03, 0x0a, 0xcc},	{0xb3, 0x04, 0x05, 0xcc},
1131
	{0xb3, 0x20, 0x00, 0xcc},	{0xb3, 0x21, 0x00, 0xcc},
1132
	{0xb3, 0x22, 0x01, 0xcc},	{0xb3, 0x23, 0xe0, 0xcc},
1133
	{0xb3, 0x14, 0x00, 0xcc},	{0xb3, 0x15, 0x00, 0xcc},
1134
	{0xb3, 0x16, 0x02, 0xcc},	{0xb3, 0x17, 0x7f, 0xcc},
1135
	{0xb3, 0x00, 0x65, 0xcc},	{0xb8, 0x00, 0x00, 0xcc},
1136
	{0xbc, 0x00, 0xd0, 0xcc},	{0xbc, 0x01, 0x01, 0xcc},
1137
	{0xf0, 0x00, 0x00, 0xbb},	{0x0d, 0x00, 0x09, 0xbb},
1138
	{0x00, 0x01, 0x00, 0xdd},	{0x0d, 0x00, 0x08, 0xbb},
1139
	{0xf0, 0x00, 0x00, 0xbb},	{0x02, 0x00, 0x64, 0xbb},
1140
	{0x05, 0x01, 0x78, 0xbb},	{0x06, 0x00, 0x11, 0xbb},
1141
	{0x07, 0x01, 0x42, 0xbb},	{0x08, 0x00, 0x11, 0xbb},
1142
	{0x20, 0x01, 0x00, 0xbb},	{0x21, 0x80, 0x00, 0xbb},
1143
	{0x22, 0x0d, 0x0f, 0xbb},	{0x24, 0x80, 0x00, 0xbb},
1144
	{0x59, 0x00, 0xff, 0xbb},	{0xf0, 0x00, 0x01, 0xbb},
1145
	{0x9d, 0x3c, 0xa0, 0xbb},	{0x47, 0x30, 0x30, 0xbb},
1146
	{0xf0, 0x00, 0x00, 0xbb},	{0x0a, 0x80, 0x11, 0xbb},
1147
	{0x35, 0x00, 0x22, 0xbb},	{0xf0, 0x00, 0x02, 0xbb},
1148
	{0x9d, 0xc5, 0x05, 0xbb},	{0xdc, 0x0f, 0xfc, 0xbb},
1149
	{0xf0, 0x00, 0x01, 0xbb},	{0x06, 0x74, 0x0e, 0xbb},
1150
	{0x80, 0x00, 0x06, 0xbb},	{0x81, 0x04, 0x00, 0xbb},
1151
	{0x82, 0x01, 0x02, 0xbb},	{0x83, 0x03, 0x02, 0xbb},
1152
	{0x84, 0x05, 0x00, 0xbb},	{0x85, 0x01, 0x00, 0xbb},
1153
	{0x86, 0x03, 0x02, 0xbb},	{0x87, 0x05, 0x00, 0xbb},
1154
	{0x88, 0x01, 0x00, 0xbb},	{0x89, 0x02, 0x02, 0xbb},
1155
	{0x8a, 0xfd, 0x04, 0xbb},	{0x8b, 0xfc, 0xfd, 0xbb},
1156
	{0x8c, 0xff, 0xfd, 0xbb},	{0x8d, 0x00, 0x00, 0xbb},
1157
	{0x8e, 0xfe, 0x05, 0xbb},	{0x8f, 0xfc, 0xfd, 0xbb},
1158
	{0x90, 0xfe, 0xfd, 0xbb},	{0x91, 0x00, 0x00, 0xbb},
1159
	{0x92, 0xfe, 0x03, 0xbb},	{0x93, 0xfd, 0xfe, 0xbb},
1160
	{0x94, 0xff, 0xfd, 0xbb},	{0x95, 0x00, 0x00, 0xbb},
1161
	{0xb6, 0x07, 0x05, 0xbb},	{0xb7, 0x13, 0x06, 0xbb},
1162
	{0xb8, 0x08, 0x06, 0xbb},	{0xb9, 0x14, 0x08, 0xbb},
1163
	{0xba, 0x06, 0x05, 0xbb},	{0xbb, 0x13, 0x06, 0xbb},
1164
	{0xbc, 0x03, 0x01, 0xbb},	{0xbd, 0x03, 0x04, 0xbb},
1165
	{0xbe, 0x00, 0x02, 0xbb},	{0xbf, 0x03, 0x01, 0xbb},
1166
	{0xc0, 0x02, 0x04, 0xbb},	{0xc1, 0x00, 0x04, 0xbb},
1167
	{0xc2, 0x02, 0x01, 0xbb},	{0xc3, 0x01, 0x03, 0xbb},
1168
	{0xc4, 0x00, 0x04, 0xbb},	{0xf0, 0x00, 0x02, 0xbb},
1169
	{0xc8, 0x00, 0x00, 0xbb},	{0x2e, 0x00, 0x00, 0xbb},
1170
	{0x2e, 0x0c, 0x5b, 0xbb},	{0x2f, 0xd1, 0x00, 0xbb},
1171
	{0x39, 0x03, 0xca, 0xbb},	{0x3a, 0x06, 0x80, 0xbb},
1172
	{0x3b, 0x01, 0x52, 0xbb},	{0x3c, 0x05, 0x40, 0xbb},
1173
	{0x57, 0x01, 0x9c, 0xbb},	{0x58, 0x01, 0xee, 0xbb},
1174
	{0x59, 0x00, 0xf0, 0xbb},	{0x5a, 0x01, 0x20, 0xbb},
1175
	{0x5c, 0x1d, 0x17, 0xbb},	{0x5d, 0x22, 0x1c, 0xbb},
1176
	{0x64, 0x1e, 0x1c, 0xbb},	{0x5b, 0x00, 0x01, 0xbb},
1177
	{0xf0, 0x00, 0x02, 0xbb},	{0x36, 0x68, 0x10, 0xbb},
1178
	{0x00, 0x00, 0x30, 0xdd},	{0x37, 0x81, 0x00, 0xbb},
1179
	{0xbc, 0x02, 0x18, 0xcc},	{0xbc, 0x03, 0x50, 0xcc},
1180
	{0xbc, 0x04, 0x18, 0xcc},	{0xbc, 0x05, 0x00, 0xcc},
1181
	{0xbc, 0x06, 0x00, 0xcc},	{0xbc, 0x08, 0x30, 0xcc},
1182
	{0xbc, 0x09, 0x40, 0xcc},	{0xbc, 0x0a, 0x10, 0xcc},
1183
	{0xbc, 0x0b, 0x00, 0xcc},	{0xbc, 0x0c, 0x00, 0xcc},
1184
	{0xbf, 0xc0, 0x26, 0xcc},	{0xbf, 0xc1, 0x02, 0xcc},
1185
	{0xbf, 0xcc, 0x04, 0xcc},	{0xb3, 0x5c, 0x01, 0xcc},
1186
	{0xb3, 0x01, 0x41, 0xcc},
1187
	{}
1188
};
1189

1190
static const u8 mi1320_soc_InitVGA[][4] = {
1191
	{0xb3, 0x01, 0x01, 0xcc},
1192
	{0xb0, 0x03, 0x19, 0xcc},
1193
	{0xb0, 0x04, 0x02, 0xcc},
1194
	{0x00, 0x00, 0x30, 0xdd},
1195
	{0xb3, 0x00, 0x64, 0xcc},
1196
	{0xb3, 0x00, 0x67, 0xcc},
1197
	{0xb3, 0x05, 0x01, 0xcc},
1198
	{0xb3, 0x06, 0x01, 0xcc},
1199
	{0xb3, 0x08, 0x01, 0xcc},
1200
	{0xb3, 0x09, 0x0c, 0xcc},
1201
	{0xb3, 0x34, 0x02, 0xcc},
1202
	{0xb3, 0x35, 0xc8, 0xcc},	/* i2c add: 48 */
1203
	{0xb3, 0x02, 0x00, 0xcc},
1204
	{0xb3, 0x03, 0x0a, 0xcc},
1205
	{0xb3, 0x04, 0x05, 0xcc},
1206
	{0xb3, 0x20, 0x00, 0xcc},
1207
	{0xb3, 0x21, 0x00, 0xcc},
1208
	{0xb3, 0x22, 0x01, 0xcc},
1209
	{0xb3, 0x23, 0xe0, 0xcc},
1210
	{0xb3, 0x14, 0x00, 0xcc},
1211
	{0xb3, 0x15, 0x00, 0xcc},
1212
	{0xb3, 0x16, 0x02, 0xcc},
1213
	{0xb3, 0x17, 0x7f, 0xcc},
1214
	{0xb3, 0x00, 0x67, 0xcc},
1215
	{0xb8, 0x00, 0x00, 0xcc},
1216
	{0xbc, 0x00, 0x71, 0xcc},
1217
	{0xbc, 0x01, 0x01, 0xcc},
1218
	{0xb3, 0x5c, 0x01, 0xcc},
1219
	{0xf0, 0x00, 0x02, 0xbb},
1220
	{0x00, 0x00, 0x10, 0xdd},
1221
	{0xc8, 0x00, 0x00, 0xbb},
1222
	{0x00, 0x00, 0x30, 0xdd},
1223
	{0xf0, 0x00, 0x00, 0xbb},
1224
	{0x00, 0x00, 0x10, 0xdd},
1225
	{0x07, 0x00, 0xe0, 0xbb},
1226
	{0x08, 0x00, 0x0b, 0xbb},
1227
	{0x21, 0x00, 0x0c, 0xbb},
1228
	{0x20, 0x01, 0x03, 0xbb},	/* h/v flip */
1229
	{0xbf, 0xc0, 0x26, 0xcc},
1230
	{0xbf, 0xc1, 0x02, 0xcc},
1231
	{0xbf, 0xcc, 0x04, 0xcc},
1232
	{0xb3, 0x01, 0x41, 0xcc},
1233
	{0xf0, 0x00, 0x00, 0xbb},
1234
	{0x05, 0x01, 0x78, 0xbb},
1235
	{0x06, 0x00, 0x11, 0xbb},
1236
	{0x07, 0x01, 0x42, 0xbb},
1237
	{0x08, 0x00, 0x11, 0xbb},
1238
	{0x20, 0x01, 0x03, 0xbb},	/* h/v flip */
1239
	{0x21, 0x80, 0x00, 0xbb},
1240
	{0x22, 0x0d, 0x0f, 0xbb},
1241
	{0x24, 0x80, 0x00, 0xbb},
1242
	{0x59, 0x00, 0xff, 0xbb},
1243
	{0xf0, 0x00, 0x02, 0xbb},
1244
	{0x39, 0x03, 0xca, 0xbb},
1245
	{0x3a, 0x06, 0x80, 0xbb},
1246
	{0x3b, 0x01, 0x52, 0xbb},
1247
	{0x3c, 0x05, 0x40, 0xbb},
1248
	{0x57, 0x01, 0x9c, 0xbb},
1249
	{0x58, 0x01, 0xee, 0xbb},
1250
	{0x59, 0x00, 0xf0, 0xbb},
1251
	{0x5a, 0x01, 0x20, 0xbb},
1252
	{0x5c, 0x1d, 0x17, 0xbb},
1253
	{0x5d, 0x22, 0x1c, 0xbb},
1254
	{0x64, 0x1e, 0x1c, 0xbb},
1255
	{0x5b, 0x00, 0x00, 0xbb},
1256
	{0xf0, 0x00, 0x02, 0xbb},
1257
	{0x22, 0xa0, 0x78, 0xbb},
1258
	{0x23, 0xa0, 0x78, 0xbb},
1259
	{0x24, 0x7f, 0x00, 0xbb},
1260
	{0x28, 0xea, 0x02, 0xbb},
1261
	{0x29, 0x86, 0x7a, 0xbb},
1262
	{0x5e, 0x52, 0x4c, 0xbb},
1263
	{0x5f, 0x20, 0x24, 0xbb},
1264
	{0x60, 0x00, 0x02, 0xbb},
1265
	{0x02, 0x00, 0xee, 0xbb},
1266
	{0x03, 0x39, 0x23, 0xbb},
1267
	{0x04, 0x07, 0x24, 0xbb},
1268
	{0x09, 0x00, 0xc0, 0xbb},
1269
	{0x0a, 0x00, 0x79, 0xbb},
1270
	{0x0b, 0x00, 0x04, 0xbb},
1271
	{0x0c, 0x00, 0x5c, 0xbb},
1272
	{0x0d, 0x00, 0xd9, 0xbb},
1273
	{0x0e, 0x00, 0x53, 0xbb},
1274
	{0x0f, 0x00, 0x21, 0xbb},
1275
	{0x10, 0x00, 0xa4, 0xbb},
1276
	{0x11, 0x00, 0xe5, 0xbb},
1277
	{0x15, 0x00, 0x00, 0xbb},
1278
	{0x16, 0x00, 0x00, 0xbb},
1279
	{0x17, 0x00, 0x00, 0xbb},
1280
	{0x18, 0x00, 0x00, 0xbb},
1281
	{0x19, 0x00, 0x00, 0xbb},
1282
	{0x1a, 0x00, 0x00, 0xbb},
1283
	{0x1b, 0x00, 0x00, 0xbb},
1284
	{0x1c, 0x00, 0x00, 0xbb},
1285
	{0x1d, 0x00, 0x00, 0xbb},
1286
	{0x1e, 0x00, 0x00, 0xbb},
1287
	{0xf0, 0x00, 0x01, 0xbb},
1288
	{0x06, 0xe0, 0x0e, 0xbb},
1289
	{0x06, 0x60, 0x0e, 0xbb},
1290
	{0xb3, 0x5c, 0x01, 0xcc},
1291
	{}
1292
};
1293
static const u8 mi1320_soc_InitQVGA[][4] = {
1294
	{0xb3, 0x01, 0x01, 0xcc},
1295
	{0xb0, 0x03, 0x19, 0xcc},
1296
	{0xb0, 0x04, 0x02, 0xcc},
1297
	{0x00, 0x00, 0x30, 0xdd},
1298
	{0xb3, 0x00, 0x64, 0xcc},
1299
	{0xb3, 0x00, 0x67, 0xcc},
1300
	{0xb3, 0x05, 0x01, 0xcc},
1301
	{0xb3, 0x06, 0x01, 0xcc},
1302
	{0xb3, 0x08, 0x01, 0xcc},
1303
	{0xb3, 0x09, 0x0c, 0xcc},
1304
	{0xb3, 0x34, 0x02, 0xcc},
1305
	{0xb3, 0x35, 0xc8, 0xcc},
1306
	{0xb3, 0x02, 0x00, 0xcc},
1307
	{0xb3, 0x03, 0x0a, 0xcc},
1308
	{0xb3, 0x04, 0x05, 0xcc},
1309
	{0xb3, 0x20, 0x00, 0xcc},
1310
	{0xb3, 0x21, 0x00, 0xcc},
1311
	{0xb3, 0x22, 0x01, 0xcc},
1312
	{0xb3, 0x23, 0xe0, 0xcc},
1313
	{0xb3, 0x14, 0x00, 0xcc},
1314
	{0xb3, 0x15, 0x00, 0xcc},
1315
	{0xb3, 0x16, 0x02, 0xcc},
1316
	{0xb3, 0x17, 0x7f, 0xcc},
1317
	{0xb3, 0x00, 0x67, 0xcc},
1318
	{0xb8, 0x00, 0x00, 0xcc},
1319
	{0xbc, 0x00, 0xd1, 0xcc},
1320
	{0xbc, 0x01, 0x01, 0xcc},
1321
	{0xb3, 0x5c, 0x01, 0xcc},
1322
	{0xf0, 0x00, 0x02, 0xbb},
1323
	{0x00, 0x00, 0x10, 0xdd},
1324
	{0xc8, 0x00, 0x00, 0xbb},
1325
	{0x00, 0x00, 0x30, 0xdd},
1326
	{0xf0, 0x00, 0x00, 0xbb},
1327
	{0x00, 0x00, 0x10, 0xdd},
1328
	{0x07, 0x00, 0xe0, 0xbb},
1329
	{0x08, 0x00, 0x0b, 0xbb},
1330
	{0x21, 0x00, 0x0c, 0xbb},
1331
	{0x20, 0x01, 0x03, 0xbb},	/* h/v flip */
1332
	{0xbf, 0xc0, 0x26, 0xcc},
1333
	{0xbf, 0xc1, 0x02, 0xcc},
1334
	{0xbf, 0xcc, 0x04, 0xcc},
1335
	{0xbc, 0x02, 0x18, 0xcc},
1336
	{0xbc, 0x03, 0x50, 0xcc},
1337
	{0xbc, 0x04, 0x18, 0xcc},
1338
	{0xbc, 0x05, 0x00, 0xcc},
1339
	{0xbc, 0x06, 0x00, 0xcc},
1340
	{0xbc, 0x08, 0x30, 0xcc},
1341
	{0xbc, 0x09, 0x40, 0xcc},
1342
	{0xbc, 0x0a, 0x10, 0xcc},
1343
	{0xbc, 0x0b, 0x00, 0xcc},
1344
	{0xbc, 0x0c, 0x00, 0xcc},
1345
	{0xb3, 0x01, 0x41, 0xcc},
1346
	{0xf0, 0x00, 0x00, 0xbb},
1347
	{0x05, 0x01, 0x78, 0xbb},
1348
	{0x06, 0x00, 0x11, 0xbb},
1349
	{0x07, 0x01, 0x42, 0xbb},
1350
	{0x08, 0x00, 0x11, 0xbb},
1351
	{0x20, 0x01, 0x03, 0xbb},	/* h/v flip */
1352
	{0x21, 0x80, 0x00, 0xbb},
1353
	{0x22, 0x0d, 0x0f, 0xbb},
1354
	{0x24, 0x80, 0x00, 0xbb},
1355
	{0x59, 0x00, 0xff, 0xbb},
1356
	{0xf0, 0x00, 0x02, 0xbb},
1357
	{0x39, 0x03, 0xca, 0xbb},
1358
	{0x3a, 0x06, 0x80, 0xbb},
1359
	{0x3b, 0x01, 0x52, 0xbb},
1360
	{0x3c, 0x05, 0x40, 0xbb},
1361
	{0x57, 0x01, 0x9c, 0xbb},
1362
	{0x58, 0x01, 0xee, 0xbb},
1363
	{0x59, 0x00, 0xf0, 0xbb},
1364
	{0x5a, 0x01, 0x20, 0xbb},
1365
	{0x5c, 0x1d, 0x17, 0xbb},
1366
	{0x5d, 0x22, 0x1c, 0xbb},
1367
	{0x64, 0x1e, 0x1c, 0xbb},
1368
	{0x5b, 0x00, 0x00, 0xbb},
1369
	{0xf0, 0x00, 0x02, 0xbb},
1370
	{0x22, 0xa0, 0x78, 0xbb},
1371
	{0x23, 0xa0, 0x78, 0xbb},
1372
	{0x24, 0x7f, 0x00, 0xbb},
1373
	{0x28, 0xea, 0x02, 0xbb},
1374
	{0x29, 0x86, 0x7a, 0xbb},
1375
	{0x5e, 0x52, 0x4c, 0xbb},
1376
	{0x5f, 0x20, 0x24, 0xbb},
1377
	{0x60, 0x00, 0x02, 0xbb},
1378
	{0x02, 0x00, 0xee, 0xbb},
1379
	{0x03, 0x39, 0x23, 0xbb},
1380
	{0x04, 0x07, 0x24, 0xbb},
1381
	{0x09, 0x00, 0xc0, 0xbb},
1382
	{0x0a, 0x00, 0x79, 0xbb},
1383
	{0x0b, 0x00, 0x04, 0xbb},
1384
	{0x0c, 0x00, 0x5c, 0xbb},
1385
	{0x0d, 0x00, 0xd9, 0xbb},
1386
	{0x0e, 0x00, 0x53, 0xbb},
1387
	{0x0f, 0x00, 0x21, 0xbb},
1388
	{0x10, 0x00, 0xa4, 0xbb},
1389
	{0x11, 0x00, 0xe5, 0xbb},
1390
	{0x15, 0x00, 0x00, 0xbb},
1391
	{0x16, 0x00, 0x00, 0xbb},
1392
	{0x17, 0x00, 0x00, 0xbb},
1393
	{0x18, 0x00, 0x00, 0xbb},
1394
	{0x19, 0x00, 0x00, 0xbb},
1395
	{0x1a, 0x00, 0x00, 0xbb},
1396
	{0x1b, 0x00, 0x00, 0xbb},
1397
	{0x1c, 0x00, 0x00, 0xbb},
1398
	{0x1d, 0x00, 0x00, 0xbb},
1399
	{0x1e, 0x00, 0x00, 0xbb},
1400
	{0xf0, 0x00, 0x01, 0xbb},
1401
	{0x06, 0xe0, 0x0e, 0xbb},
1402
	{0x06, 0x60, 0x0e, 0xbb},
1403
	{0xb3, 0x5c, 0x01, 0xcc},
1404
	{}
1405
};
1406
static const u8 mi1320_soc_InitSXGA[][4] = {
1407
	{0xb3, 0x01, 0x01, 0xcc},
1408
	{0xb0, 0x03, 0x19, 0xcc},
1409
	{0x00, 0x00, 0x30, 0xdd},
1410
	{0xb3, 0x00, 0x64, 0xcc},
1411
	{0xb3, 0x00, 0x67, 0xcc},
1412
	{0xb3, 0x05, 0x01, 0xcc},
1413
	{0xb3, 0x06, 0x01, 0xcc},
1414
	{0xb3, 0x08, 0x01, 0xcc},
1415
	{0xb3, 0x09, 0x0c, 0xcc},
1416
	{0xb3, 0x34, 0x02, 0xcc},
1417
	{0xb3, 0x35, 0xc8, 0xcc},
1418
	{0xb3, 0x02, 0x00, 0xcc},
1419
	{0xb3, 0x03, 0x0a, 0xcc},
1420
	{0xb3, 0x04, 0x05, 0xcc},
1421
	{0xb3, 0x20, 0x00, 0xcc},
1422
	{0xb3, 0x21, 0x00, 0xcc},
1423
	{0xb3, 0x22, 0x04, 0xcc},
1424
	{0xb3, 0x23, 0x00, 0xcc},
1425
	{0xb3, 0x14, 0x00, 0xcc},
1426
	{0xb3, 0x15, 0x00, 0xcc},
1427
	{0xb3, 0x16, 0x04, 0xcc},
1428
	{0xb3, 0x17, 0xff, 0xcc},
1429
	{0xb3, 0x00, 0x67, 0xcc},
1430
	{0xbc, 0x00, 0x71, 0xcc},
1431
	{0xbc, 0x01, 0x01, 0xcc},
1432
	{0xb3, 0x5c, 0x01, 0xcc},
1433
	{0xf0, 0x00, 0x02, 0xbb},
1434
	{0x00, 0x00, 0x30, 0xdd},
1435
	{0xc8, 0x9f, 0x0b, 0xbb},
1436
	{0x00, 0x00, 0x20, 0xdd},
1437
	{0x5b, 0x00, 0x01, 0xbb},
1438
	{0x00, 0x00, 0x20, 0xdd},
1439
	{0xf0, 0x00, 0x00, 0xbb},
1440
	{0x00, 0x00, 0x30, 0xdd},
1441
	{0x20, 0x01, 0x03, 0xbb},	/* h/v flip */
1442
	{0x00, 0x00, 0x20, 0xdd},
1443
	{0xbf, 0xc0, 0x26, 0xcc},
1444
	{0xbf, 0xc1, 0x02, 0xcc},
1445
	{0xbf, 0xcc, 0x04, 0xcc},
1446
	{0xb3, 0x01, 0x41, 0xcc},
1447
	{0xf0, 0x00, 0x00, 0xbb},
1448
	{0x05, 0x01, 0x78, 0xbb},
1449
	{0x06, 0x00, 0x11, 0xbb},
1450
	{0x07, 0x01, 0x42, 0xbb},
1451
	{0x08, 0x00, 0x11, 0xbb},
1452
	{0x20, 0x01, 0x03, 0xbb},	/* h/v flip */
1453
	{0x21, 0x80, 0x00, 0xbb},
1454
	{0x22, 0x0d, 0x0f, 0xbb},
1455
	{0x24, 0x80, 0x00, 0xbb},
1456
	{0x59, 0x00, 0xff, 0xbb},
1457
	{0xf0, 0x00, 0x02, 0xbb},
1458
	{0x39, 0x03, 0xca, 0xbb},
1459
	{0x3a, 0x06, 0x80, 0xbb},
1460
	{0x3b, 0x01, 0x52, 0xbb},
1461
	{0x3c, 0x05, 0x40, 0xbb},
1462
	{0x57, 0x01, 0x9c, 0xbb},
1463
	{0x58, 0x01, 0xee, 0xbb},
1464
	{0x59, 0x00, 0xf0, 0xbb},
1465
	{0x5a, 0x01, 0x20, 0xbb},
1466
	{0x5c, 0x1d, 0x17, 0xbb},
1467
	{0x5d, 0x22, 0x1c, 0xbb},
1468
	{0x64, 0x1e, 0x1c, 0xbb},
1469
	{0x5b, 0x00, 0x00, 0xbb},
1470
	{0xf0, 0x00, 0x02, 0xbb},
1471
	{0x22, 0xa0, 0x78, 0xbb},
1472
	{0x23, 0xa0, 0x78, 0xbb},
1473
	{0x24, 0x7f, 0x00, 0xbb},
1474
	{0x28, 0xea, 0x02, 0xbb},
1475
	{0x29, 0x86, 0x7a, 0xbb},
1476
	{0x5e, 0x52, 0x4c, 0xbb},
1477
	{0x5f, 0x20, 0x24, 0xbb},
1478
	{0x60, 0x00, 0x02, 0xbb},
1479
	{0x02, 0x00, 0xee, 0xbb},
1480
	{0x03, 0x39, 0x23, 0xbb},
1481
	{0x04, 0x07, 0x24, 0xbb},
1482
	{0x09, 0x00, 0xc0, 0xbb},
1483
	{0x0a, 0x00, 0x79, 0xbb},
1484
	{0x0b, 0x00, 0x04, 0xbb},
1485
	{0x0c, 0x00, 0x5c, 0xbb},
1486
	{0x0d, 0x00, 0xd9, 0xbb},
1487
	{0x0e, 0x00, 0x53, 0xbb},
1488
	{0x0f, 0x00, 0x21, 0xbb},
1489
	{0x10, 0x00, 0xa4, 0xbb},
1490
	{0x11, 0x00, 0xe5, 0xbb},
1491
	{0x15, 0x00, 0x00, 0xbb},
1492
	{0x16, 0x00, 0x00, 0xbb},
1493
	{0x17, 0x00, 0x00, 0xbb},
1494
	{0x18, 0x00, 0x00, 0xbb},
1495
	{0x19, 0x00, 0x00, 0xbb},
1496
	{0x1a, 0x00, 0x00, 0xbb},
1497
	{0x1b, 0x00, 0x00, 0xbb},
1498
	{0x1c, 0x00, 0x00, 0xbb},
1499
	{0x1d, 0x00, 0x00, 0xbb},
1500
	{0x1e, 0x00, 0x00, 0xbb},
1501
	{0xf0, 0x00, 0x01, 0xbb},
1502
	{0x06, 0xe0, 0x0e, 0xbb},
1503
	{0x06, 0x60, 0x0e, 0xbb},
1504
	{0xb3, 0x5c, 0x01, 0xcc},
1505
	{0xf0, 0x00, 0x00, 0xbb},
1506
	{0x05, 0x01, 0x13, 0xbb},
1507
	{0x06, 0x00, 0x11, 0xbb},
1508
	{0x07, 0x00, 0x85, 0xbb},
1509
	{0x08, 0x00, 0x27, 0xbb},
1510
	{0x20, 0x01, 0x03, 0xbb},	/* h/v flip */
1511
	{0x21, 0x80, 0x00, 0xbb},
1512
	{0x22, 0x0d, 0x0f, 0xbb},
1513
	{0x24, 0x80, 0x00, 0xbb},
1514
	{0x59, 0x00, 0xff, 0xbb},
1515
	{0xf0, 0x00, 0x02, 0xbb},
1516
	{0x39, 0x03, 0x0d, 0xbb},
1517
	{0x3a, 0x06, 0x1b, 0xbb},
1518
	{0x3b, 0x00, 0x95, 0xbb},
1519
	{0x3c, 0x04, 0xdb, 0xbb},
1520
	{0x57, 0x02, 0x00, 0xbb},
1521
	{0x58, 0x02, 0x66, 0xbb},
1522
	{0x59, 0x00, 0xff, 0xbb},
1523
	{0x5a, 0x01, 0x33, 0xbb},
1524
	{0x5c, 0x12, 0x0d, 0xbb},
1525
	{0x5d, 0x16, 0x11, 0xbb},
1526
	{0x64, 0x5e, 0x1c, 0xbb},
1527
	{}
1528
};
1529
static const u8 po3130_gamma[17] = {
1530
	0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
1531
	0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
1532
};
1533
static const u8 po3130_matrix[9] = {
1534
	0x5f, 0xec, 0xf5, 0xf1, 0x5a, 0xf5, 0xf1, 0xec, 0x63
1535
};
1536

1537
static const u8 po3130_initVGA_data[][4] = {
1538
	{0xb0, 0x4d, 0x00, 0xcc},	{0xb3, 0x01, 0x01, 0xcc},
1539
	{0x00, 0x00, 0x50, 0xdd},	{0xb0, 0x03, 0x01, 0xcc},
1540
	{0xb3, 0x00, 0x04, 0xcc},	{0xb3, 0x00, 0x24, 0xcc},
1541
	{0xb3, 0x00, 0x25, 0xcc},	{0xb3, 0x08, 0x01, 0xcc},
1542
	{0xb3, 0x09, 0x0c, 0xcc},	{0xb3, 0x05, 0x00, 0xcc},
1543
	{0xb3, 0x06, 0x01, 0xcc},	{0xb3, 0x03, 0x1a, 0xcc},
1544
	{0xb3, 0x04, 0x15, 0xcc},	{0xb3, 0x20, 0x00, 0xcc},
1545
	{0xb3, 0x21, 0x00, 0xcc},	{0xb3, 0x22, 0x01, 0xcc},
1546
	{0xb3, 0x23, 0xe8, 0xcc},	{0xb8, 0x08, 0xe8, 0xcc},
1547
	{0xb3, 0x14, 0x00, 0xcc},	{0xb3, 0x15, 0x00, 0xcc},
1548
	{0xb3, 0x16, 0x02, 0xcc},	{0xb3, 0x17, 0x7f, 0xcc},
1549
	{0xb3, 0x34, 0x01, 0xcc},
1550
	{0xb3, 0x35, 0xf6, 0xcc},	/* i2c add: 76 */
1551
	{0xb3, 0x00, 0x27, 0xcc},	{0xbc, 0x00, 0x71, 0xcc},
1552
	{0xb8, 0x00, 0x21, 0xcc},	{0xb8, 0x27, 0x20, 0xcc},
1553
	{0xb8, 0x01, 0x79, 0xcc},	{0xb8, 0x81, 0x09, 0xcc},
1554
	{0xb8, 0x2c, 0x50, 0xcc},	{0xb8, 0x2d, 0xf8, 0xcc},
1555
	{0xb8, 0x2e, 0xf8, 0xcc},	{0xb8, 0x2f, 0xf8, 0xcc},
1556
	{0xb8, 0x30, 0x50, 0xcc},	{0xb8, 0x31, 0xf8, 0xcc},
1557
	{0xb8, 0x32, 0xf8, 0xcc},	{0xb8, 0x33, 0xf8, 0xcc},
1558
	{0xb8, 0x34, 0x50, 0xcc},	{0xb8, 0x35, 0x00, 0xcc},
1559
	{0xb8, 0x36, 0x00, 0xcc},	{0xb8, 0x37, 0x00, 0xcc},
1560
	{0x00, 0x1e, 0xc6, 0xaa},	{0x00, 0x20, 0x44, 0xaa},
1561
	{0x00, 0xad, 0x02, 0xaa},	{0x00, 0xae, 0x2c, 0xaa},
1562
	{0x00, 0x12, 0x08, 0xaa},	{0x00, 0x17, 0x41, 0xaa},
1563
	{0x00, 0x19, 0x41, 0xaa},	{0x00, 0x1e, 0x06, 0xaa},
1564
	{0x00, 0x21, 0x00, 0xaa},	{0x00, 0x36, 0xc0, 0xaa},
1565
	{0x00, 0x37, 0xc8, 0xaa},	{0x00, 0x3b, 0x36, 0xaa},
1566
	{0x00, 0x4b, 0xfe, 0xaa},	{0x00, 0x51, 0x1c, 0xaa},
1567
	{0x00, 0x52, 0x01, 0xaa},	{0x00, 0x55, 0x0a, 0xaa},
1568
	{0x00, 0x59, 0x02, 0xaa},	{0x00, 0x5a, 0x04, 0xaa},
1569
	{0x00, 0x5c, 0x10, 0xaa},	{0x00, 0x5d, 0x10, 0xaa},
1570
	{0x00, 0x5e, 0x10, 0xaa},	{0x00, 0x5f, 0x10, 0xaa},
1571
	{0x00, 0x61, 0x00, 0xaa},	{0x00, 0x62, 0x18, 0xaa},
1572
	{0x00, 0x63, 0x30, 0xaa},	{0x00, 0x70, 0x68, 0xaa},
1573
	{0x00, 0x80, 0x71, 0xaa},	{0x00, 0x81, 0x08, 0xaa},
1574
	{0x00, 0x82, 0x00, 0xaa},	{0x00, 0x83, 0x55, 0xaa},
1575
	{0x00, 0x84, 0x06, 0xaa},	{0x00, 0x85, 0x06, 0xaa},
1576
	{0x00, 0x86, 0x13, 0xaa},	{0x00, 0x87, 0x18, 0xaa},
1577
	{0x00, 0xaa, 0x3f, 0xaa},	{0x00, 0xab, 0x44, 0xaa},
1578
	{0x00, 0xb0, 0x68, 0xaa},	{0x00, 0xb5, 0x10, 0xaa},
1579
	{0x00, 0xb8, 0x20, 0xaa},	{0x00, 0xb9, 0xa0, 0xaa},
1580
	{0x00, 0xbc, 0x04, 0xaa},	{0x00, 0x8b, 0x40, 0xaa},
1581
	{0x00, 0x8c, 0x91, 0xaa},	{0x00, 0x8d, 0x8f, 0xaa},
1582
	{0x00, 0x8e, 0x91, 0xaa},	{0x00, 0x8f, 0x43, 0xaa},
1583
	{0x00, 0x90, 0x92, 0xaa},	{0x00, 0x91, 0x89, 0xaa},
1584
	{0x00, 0x92, 0x9d, 0xaa},	{0x00, 0x93, 0x46, 0xaa},
1585
	{0x00, 0xd6, 0x22, 0xaa},	{0x00, 0x73, 0x00, 0xaa},
1586
	{0x00, 0x74, 0x10, 0xaa},	{0x00, 0x75, 0x20, 0xaa},
1587
	{0x00, 0x76, 0x2b, 0xaa},	{0x00, 0x77, 0x36, 0xaa},
1588
	{0x00, 0x78, 0x49, 0xaa},	{0x00, 0x79, 0x5a, 0xaa},
1589
	{0x00, 0x7a, 0x7f, 0xaa},	{0x00, 0x7b, 0x9b, 0xaa},
1590
	{0x00, 0x7c, 0xba, 0xaa},	{0x00, 0x7d, 0xd4, 0xaa},
1591
	{0x00, 0x7e, 0xea, 0xaa},	{0x00, 0xd6, 0x62, 0xaa},
1592
	{0x00, 0x73, 0x00, 0xaa},	{0x00, 0x74, 0x10, 0xaa},
1593
	{0x00, 0x75, 0x20, 0xaa},	{0x00, 0x76, 0x2b, 0xaa},
1594
	{0x00, 0x77, 0x36, 0xaa},	{0x00, 0x78, 0x49, 0xaa},
1595
	{0x00, 0x79, 0x5a, 0xaa},	{0x00, 0x7a, 0x7f, 0xaa},
1596
	{0x00, 0x7b, 0x9b, 0xaa},	{0x00, 0x7c, 0xba, 0xaa},
1597
	{0x00, 0x7d, 0xd4, 0xaa},	{0x00, 0x7e, 0xea, 0xaa},
1598
	{0x00, 0xd6, 0xa2, 0xaa},	{0x00, 0x73, 0x00, 0xaa},
1599
	{0x00, 0x74, 0x10, 0xaa},	{0x00, 0x75, 0x20, 0xaa},
1600
	{0x00, 0x76, 0x2b, 0xaa},	{0x00, 0x77, 0x36, 0xaa},
1601
	{0x00, 0x78, 0x49, 0xaa},	{0x00, 0x79, 0x5a, 0xaa},
1602
	{0x00, 0x7a, 0x7f, 0xaa},	{0x00, 0x7b, 0x9b, 0xaa},
1603
	{0x00, 0x7c, 0xba, 0xaa},	{0x00, 0x7d, 0xd4, 0xaa},
1604
	{0x00, 0x7e, 0xea, 0xaa},
1605
	{0x00, 0x4c, 0x07, 0xaa},
1606
	{0x00, 0x4b, 0xe0, 0xaa},	{0x00, 0x4e, 0x77, 0xaa},
1607
	{0x00, 0x59, 0x02, 0xaa},	{0x00, 0x4d, 0x0a, 0xaa},
1608
/*	{0x00, 0xd1, 0x00, 0xaa},	{0x00, 0x20, 0xc4, 0xaa},
1609
	{0xb8, 0x8e, 0x00, 0xcc},	{0xb8, 0x8f, 0xff, 0xcc}, */
1610
	{0x00, 0xd1, 0x3c, 0xaa},	{0x00, 0x20, 0xc4, 0xaa},
1611
	{0xb8, 0x8e, 0x00, 0xcc},	{0xb8, 0x8f, 0xff, 0xcc},
1612
	{0xb8, 0xfe, 0x00, 0xcc},	{0xb8, 0xff, 0x28, 0xcc},
1613
	{0xb9, 0x00, 0x28, 0xcc},	{0xb9, 0x01, 0x28, 0xcc},
1614
	{0xb9, 0x02, 0x28, 0xcc},	{0xb9, 0x03, 0x00, 0xcc},
1615
	{0xb9, 0x04, 0x00, 0xcc},	{0xb9, 0x05, 0x3c, 0xcc},
1616
	{0xb9, 0x06, 0x3c, 0xcc},	{0xb9, 0x07, 0x3c, 0xcc},
1617
	{0xb9, 0x08, 0x3c, 0xcc},	{0x00, 0x05, 0x00, 0xaa},
1618
	{0xb3, 0x5c, 0x00, 0xcc},	{0xb3, 0x01, 0x41, 0xcc},
1619
	{}
1620
};
1621
static const u8 po3130_rundata[][4] = {
1622
	{0x00, 0x47, 0x45, 0xaa},	{0x00, 0x48, 0x9b, 0xaa},
1623
	{0x00, 0x49, 0x3a, 0xaa},	{0x00, 0x4a, 0x01, 0xaa},
1624
	{0x00, 0x44, 0x40, 0xaa},
1625
/*	{0x00, 0xd5, 0x7c, 0xaa}, */
1626
	{0x00, 0xad, 0x04, 0xaa},	{0x00, 0xae, 0x00, 0xaa},
1627
	{0x00, 0xb0, 0x78, 0xaa},	{0x00, 0x98, 0x02, 0xaa},
1628
	{0x00, 0x94, 0x25, 0xaa},	{0x00, 0x95, 0x25, 0xaa},
1629
	{0x00, 0x59, 0x68, 0xaa},	{0x00, 0x44, 0x20, 0xaa},
1630
	{0x00, 0x17, 0x50, 0xaa},	{0x00, 0x19, 0x50, 0xaa},
1631
	{0x00, 0xd1, 0x3c, 0xaa},	{0x00, 0xd1, 0x3c, 0xaa},
1632
	{0x00, 0x1e, 0x06, 0xaa},	{0x00, 0x1e, 0x06, 0xaa},
1633
	{}
1634
};
1635

1636
static const u8 po3130_initQVGA_data[][4] = {
1637
	{0xb0, 0x4d, 0x00, 0xcc},	{0xb3, 0x01, 0x01, 0xcc},
1638
	{0x00, 0x00, 0x50, 0xdd},	{0xb0, 0x03, 0x09, 0xcc},
1639
	{0xb3, 0x00, 0x04, 0xcc},	{0xb3, 0x00, 0x24, 0xcc},
1640
	{0xb3, 0x00, 0x25, 0xcc},	{0xb3, 0x08, 0x01, 0xcc},
1641
	{0xb3, 0x09, 0x0c, 0xcc},	{0xb3, 0x05, 0x00, 0xcc},
1642
	{0xb3, 0x06, 0x01, 0xcc},	{0xb3, 0x03, 0x1a, 0xcc},
1643
	{0xb3, 0x04, 0x15, 0xcc},	{0xb3, 0x20, 0x00, 0xcc},
1644
	{0xb3, 0x21, 0x00, 0xcc},	{0xb3, 0x22, 0x01, 0xcc},
1645
	{0xb3, 0x23, 0xe0, 0xcc},	{0xb8, 0x08, 0xe0, 0xcc},
1646
	{0xb3, 0x14, 0x00, 0xcc},	{0xb3, 0x15, 0x00, 0xcc},
1647
	{0xb3, 0x16, 0x02, 0xcc},	{0xb3, 0x17, 0x7f, 0xcc},
1648
	{0xb3, 0x34, 0x01, 0xcc},	{0xb3, 0x35, 0xf6, 0xcc},
1649
	{0xb3, 0x00, 0x27, 0xcc},	{0xbc, 0x00, 0xd1, 0xcc},
1650
	{0xb8, 0x00, 0x21, 0xcc},	{0xb8, 0x27, 0x20, 0xcc},
1651
	{0xb8, 0x01, 0x79, 0xcc},	{0xb8, 0x81, 0x09, 0xcc},
1652
	{0xb8, 0x2c, 0x50, 0xcc},	{0xb8, 0x2d, 0xf8, 0xcc},
1653
	{0xb8, 0x2e, 0xf8, 0xcc},	{0xb8, 0x2f, 0xf8, 0xcc},
1654
	{0xb8, 0x30, 0x50, 0xcc},	{0xb8, 0x31, 0xf8, 0xcc},
1655
	{0xb8, 0x32, 0xf8, 0xcc},	{0xb8, 0x33, 0xf8, 0xcc},
1656
	{0xb8, 0x34, 0x50, 0xcc},	{0xb8, 0x35, 0x00, 0xcc},
1657
	{0xb8, 0x36, 0x00, 0xcc},	{0xb8, 0x37, 0x00, 0xcc},
1658
	{0x00, 0x1e, 0xc6, 0xaa},	{0x00, 0x20, 0x44, 0xaa},
1659
	{0x00, 0xad, 0x02, 0xaa},	{0x00, 0xae, 0x2c, 0xaa},
1660
	{0x00, 0x12, 0x08, 0xaa},	{0x00, 0x17, 0x41, 0xaa},
1661
	{0x00, 0x19, 0x41, 0xaa},	{0x00, 0x1e, 0x06, 0xaa},
1662
	{0x00, 0x21, 0x00, 0xaa},	{0x00, 0x36, 0xc0, 0xaa},
1663
	{0x00, 0x37, 0xc8, 0xaa},	{0x00, 0x3b, 0x36, 0xaa},
1664
	{0x00, 0x4b, 0xfe, 0xaa},	{0x00, 0x51, 0x1c, 0xaa},
1665
	{0x00, 0x52, 0x01, 0xaa},	{0x00, 0x55, 0x0a, 0xaa},
1666
	{0x00, 0x59, 0x6f, 0xaa},	{0x00, 0x5a, 0x04, 0xaa},
1667
	{0x00, 0x5c, 0x10, 0xaa},	{0x00, 0x5d, 0x10, 0xaa},
1668
	{0x00, 0x5e, 0x10, 0xaa},	{0x00, 0x5f, 0x10, 0xaa},
1669
	{0x00, 0x61, 0x00, 0xaa},	{0x00, 0x62, 0x18, 0xaa},
1670
	{0x00, 0x63, 0x30, 0xaa},	{0x00, 0x70, 0x68, 0xaa},
1671
	{0x00, 0x80, 0x71, 0xaa},	{0x00, 0x81, 0x08, 0xaa},
1672
	{0x00, 0x82, 0x00, 0xaa},	{0x00, 0x83, 0x55, 0xaa},
1673
	{0x00, 0x84, 0x06, 0xaa},	{0x00, 0x85, 0x06, 0xaa},
1674
	{0x00, 0x86, 0x13, 0xaa},	{0x00, 0x87, 0x18, 0xaa},
1675
	{0x00, 0xaa, 0x3f, 0xaa},	{0x00, 0xab, 0x44, 0xaa},
1676
	{0x00, 0xb0, 0x68, 0xaa},	{0x00, 0xb5, 0x10, 0xaa},
1677
	{0x00, 0xb8, 0x20, 0xaa},	{0x00, 0xb9, 0xa0, 0xaa},
1678
	{0x00, 0xbc, 0x04, 0xaa},	{0x00, 0x8b, 0x40, 0xaa},
1679
	{0x00, 0x8c, 0x91, 0xaa},	{0x00, 0x8d, 0x8f, 0xaa},
1680
	{0x00, 0x8e, 0x91, 0xaa},	{0x00, 0x8f, 0x43, 0xaa},
1681
	{0x00, 0x90, 0x92, 0xaa},	{0x00, 0x91, 0x89, 0xaa},
1682
	{0x00, 0x92, 0x9d, 0xaa},	{0x00, 0x93, 0x46, 0xaa},
1683
	{0x00, 0xd6, 0x22, 0xaa},	{0x00, 0x73, 0x00, 0xaa},
1684
	{0x00, 0x74, 0x10, 0xaa},	{0x00, 0x75, 0x20, 0xaa},
1685
	{0x00, 0x76, 0x2b, 0xaa},	{0x00, 0x77, 0x36, 0xaa},
1686
	{0x00, 0x78, 0x49, 0xaa},	{0x00, 0x79, 0x5a, 0xaa},
1687
	{0x00, 0x7a, 0x7f, 0xaa},	{0x00, 0x7b, 0x9b, 0xaa},
1688
	{0x00, 0x7c, 0xba, 0xaa},	{0x00, 0x7d, 0xd4, 0xaa},
1689
	{0x00, 0x7e, 0xea, 0xaa},	{0x00, 0xd6, 0x62, 0xaa},
1690
	{0x00, 0x73, 0x00, 0xaa},	{0x00, 0x74, 0x10, 0xaa},
1691
	{0x00, 0x75, 0x20, 0xaa},	{0x00, 0x76, 0x2b, 0xaa},
1692
	{0x00, 0x77, 0x36, 0xaa},	{0x00, 0x78, 0x49, 0xaa},
1693
	{0x00, 0x79, 0x5a, 0xaa},	{0x00, 0x7a, 0x7f, 0xaa},
1694
	{0x00, 0x7b, 0x9b, 0xaa},	{0x00, 0x7c, 0xba, 0xaa},
1695
	{0x00, 0x7d, 0xd4, 0xaa},	{0x00, 0x7e, 0xea, 0xaa},
1696
	{0x00, 0xd6, 0xa2, 0xaa},	{0x00, 0x73, 0x00, 0xaa},
1697
	{0x00, 0x74, 0x10, 0xaa},	{0x00, 0x75, 0x20, 0xaa},
1698
	{0x00, 0x76, 0x2b, 0xaa},	{0x00, 0x77, 0x36, 0xaa},
1699
	{0x00, 0x78, 0x49, 0xaa},	{0x00, 0x79, 0x5a, 0xaa},
1700
	{0x00, 0x7a, 0x7f, 0xaa},	{0x00, 0x7b, 0x9b, 0xaa},
1701
	{0x00, 0x7c, 0xba, 0xaa},	{0x00, 0x7d, 0xd4, 0xaa},
1702
	{0x00, 0x7e, 0xea, 0xaa},	{0x00, 0x4c, 0x07, 0xaa},
1703
	{0x00, 0x4b, 0xe0, 0xaa},	{0x00, 0x4e, 0x77, 0xaa},
1704
	{0x00, 0x59, 0x66, 0xaa},	{0x00, 0x4d, 0x0a, 0xaa},
1705
	{0x00, 0xd1, 0x00, 0xaa},	{0x00, 0x20, 0xc4, 0xaa},
1706
	{0xb8, 0x8e, 0x00, 0xcc},	{0xb8, 0x8f, 0xff, 0xcc},
1707
	{0xb8, 0xfe, 0x00, 0xcc},	{0xb8, 0xff, 0x28, 0xcc},
1708
	{0xb9, 0x00, 0x28, 0xcc},	{0xb9, 0x01, 0x28, 0xcc},
1709
	{0xb9, 0x02, 0x28, 0xcc},	{0xb9, 0x03, 0x00, 0xcc},
1710
	{0xb9, 0x04, 0x00, 0xcc},	{0xb9, 0x05, 0x3c, 0xcc},
1711
	{0xb9, 0x06, 0x3c, 0xcc},	{0xb9, 0x07, 0x3c, 0xcc},
1712
	{0xb9, 0x08, 0x3c, 0xcc},	{0xbc, 0x02, 0x18, 0xcc},
1713
	{0xbc, 0x03, 0x50, 0xcc},	{0xbc, 0x04, 0x18, 0xcc},
1714
	{0xbc, 0x05, 0x00, 0xcc},	{0xbc, 0x06, 0x00, 0xcc},
1715
	{0xbc, 0x08, 0x30, 0xcc},	{0xbc, 0x09, 0x40, 0xcc},
1716
	{0xbc, 0x0a, 0x10, 0xcc},	{0xbc, 0x0b, 0x00, 0xcc},
1717
	{0xbc, 0x0c, 0x00, 0xcc},	{0x00, 0x05, 0x00, 0xaa},
1718
	{0xb3, 0x5c, 0x00, 0xcc},	{0xb3, 0x01, 0x41, 0xcc},
1719
	{}
1720
};
1721

1722
static const u8 hv7131r_gamma[17] = {
1723
	0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
1724
	0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
1725
};
1726
static const u8 hv7131r_matrix[9] = {
1727
	0x5f, 0xec, 0xf5, 0xf1, 0x5a, 0xf5, 0xf1, 0xec, 0x63
1728
};
1729
static const u8 hv7131r_initVGA_data[][4] = {
1730
	{0xb3, 0x01, 0x01, 0xcc},
1731
	{0xb0, 0x03, 0x19, 0xcc},
1732
	{0xb0, 0x04, 0x02, 0xcc},
1733
	{0x00, 0x00, 0x20, 0xdd},
1734
	{0xb3, 0x00, 0x24, 0xcc},
1735
	{0xb3, 0x00, 0x25, 0xcc},
1736
	{0xb3, 0x08, 0x01, 0xcc},
1737
	{0xb3, 0x09, 0x0c, 0xcc},
1738
	{0xb3, 0x05, 0x01, 0xcc},
1739
	{0xb3, 0x06, 0x03, 0xcc},
1740
	{0xb3, 0x01, 0x45, 0xcc},
1741
	{0xb3, 0x03, 0x0b, 0xcc},
1742
	{0xb3, 0x04, 0x05, 0xcc},
1743
	{0xb3, 0x20, 0x00, 0xcc},
1744
	{0xb3, 0x21, 0x00, 0xcc},
1745
	{0xb3, 0x22, 0x01, 0xcc},
1746
	{0xb3, 0x23, 0xe0, 0xcc},
1747
	{0xb3, 0x14, 0x00, 0xcc},
1748
	{0xb3, 0x15, 0x02, 0xcc},
1749
	{0xb3, 0x16, 0x02, 0xcc},
1750
	{0xb3, 0x17, 0x7f, 0xcc},
1751
	{0xb3, 0x34, 0x01, 0xcc},
1752
	{0xb3, 0x35, 0x91, 0xcc},	/* i2c add: 11 */
1753
	{0xb3, 0x00, 0x27, 0xcc},
1754
	{0xbc, 0x00, 0x73, 0xcc},
1755
	{0xb8, 0x00, 0x23, 0xcc},
1756
	{0xb8, 0x2c, 0x50, 0xcc},
1757
	{0xb8, 0x2d, 0xf8, 0xcc},
1758
	{0xb8, 0x2e, 0xf8, 0xcc},
1759
	{0xb8, 0x2f, 0xf8, 0xcc},
1760
	{0xb8, 0x30, 0x50, 0xcc},
1761
	{0xb8, 0x31, 0xf8, 0xcc},
1762
	{0xb8, 0x32, 0xf8, 0xcc},
1763
	{0xb8, 0x33, 0xf8, 0xcc},
1764
	{0xb8, 0x34, 0x58, 0xcc},
1765
	{0xb8, 0x35, 0x00, 0xcc},
1766
	{0xb8, 0x36, 0x00, 0xcc},
1767
	{0xb8, 0x37, 0x00, 0xcc},
1768
	{0xb8, 0x27, 0x20, 0xcc},
1769
	{0xb8, 0x01, 0x7d, 0xcc},
1770
	{0xb8, 0x81, 0x09, 0xcc},
1771
	{0xb3, 0x01, 0x41, 0xcc},
1772
	{0xb8, 0x8e, 0x00, 0xcc},
1773
	{0xb8, 0x8f, 0xff, 0xcc},
1774
	{0x00, 0x01, 0x0c, 0xaa},
1775
	{0x00, 0x14, 0x01, 0xaa},
1776
	{0x00, 0x15, 0xe6, 0xaa},
1777
	{0x00, 0x16, 0x02, 0xaa},
1778
	{0x00, 0x17, 0x86, 0xaa},
1779
	{0x00, 0x23, 0x00, 0xaa},
1780
	{0x00, 0x25, 0x03, 0xaa},
1781
	{0x00, 0x26, 0xa9, 0xaa},
1782
	{0x00, 0x27, 0x80, 0xaa},
1783
	{0x00, 0x30, 0x18, 0xaa},
1784
	{0xb6, 0x00, 0x00, 0xcc},
1785
	{0xb6, 0x03, 0x02, 0xcc},
1786
	{0xb6, 0x02, 0x80, 0xcc},
1787
	{0xb6, 0x05, 0x01, 0xcc},
1788
	{0xb6, 0x04, 0xe0, 0xcc},
1789
	{0xb6, 0x12, 0x78, 0xcc},
1790
	{0xb6, 0x18, 0x02, 0xcc},
1791
	{0xb6, 0x17, 0x58, 0xcc},
1792
	{0xb6, 0x16, 0x00, 0xcc},
1793
	{0xb6, 0x22, 0x12, 0xcc},
1794
	{0xb6, 0x23, 0x0b, 0xcc},
1795
	{0xb3, 0x02, 0x02, 0xcc},
1796
	{0xbf, 0xc0, 0x39, 0xcc},
1797
	{0xbf, 0xc1, 0x04, 0xcc},
1798
	{0xbf, 0xcc, 0x10, 0xcc},
1799
	{0xb6, 0x12, 0xf8, 0xcc},
1800
	{0xb6, 0x13, 0x13, 0xcc},
1801
	{0xb9, 0x12, 0x00, 0xcc},
1802
	{0xb9, 0x13, 0x0a, 0xcc},
1803
	{0xb9, 0x14, 0x0a, 0xcc},
1804
	{0xb9, 0x15, 0x0a, 0xcc},
1805
	{0xb9, 0x16, 0x0a, 0xcc},
1806
	{0xb8, 0x0c, 0x20, 0xcc},
1807
	{0xb8, 0x0d, 0x70, 0xcc},
1808
	{0xb9, 0x18, 0x00, 0xcc},
1809
	{0xb9, 0x19, 0x0f, 0xcc},
1810
	{0xb9, 0x1a, 0x0f, 0xcc},
1811
	{0xb9, 0x1b, 0x0f, 0xcc},
1812
	{0xb9, 0x1c, 0x0f, 0xcc},
1813
	{0xb3, 0x5c, 0x01, 0xcc},
1814
	{}
1815
};
1816

1817
static const u8 hv7131r_initQVGA_data[][4] = {
1818
	{0xb3, 0x01, 0x01, 0xcc},
1819
	{0xb0, 0x03, 0x19, 0xcc},
1820
	{0xb0, 0x04, 0x02, 0xcc},
1821
	{0x00, 0x00, 0x20, 0xdd},
1822
	{0xb3, 0x00, 0x24, 0xcc},
1823
	{0xb3, 0x00, 0x25, 0xcc},
1824
	{0xb3, 0x08, 0x01, 0xcc},
1825
	{0xb3, 0x09, 0x0c, 0xcc},
1826
	{0xb3, 0x05, 0x01, 0xcc},
1827
	{0xb3, 0x06, 0x03, 0xcc},
1828
	{0xb3, 0x01, 0x45, 0xcc},
1829
	{0xb3, 0x03, 0x0b, 0xcc},
1830
	{0xb3, 0x04, 0x05, 0xcc},
1831
	{0xb3, 0x20, 0x00, 0xcc},
1832
	{0xb3, 0x21, 0x00, 0xcc},
1833
	{0xb3, 0x22, 0x01, 0xcc},
1834
	{0xb3, 0x23, 0xe0, 0xcc},
1835
	{0xb3, 0x14, 0x00, 0xcc},
1836
	{0xb3, 0x15, 0x02, 0xcc},
1837
	{0xb3, 0x16, 0x02, 0xcc},
1838
	{0xb3, 0x17, 0x7f, 0xcc},
1839
	{0xb3, 0x34, 0x01, 0xcc},
1840
	{0xb3, 0x35, 0x91, 0xcc},
1841
	{0xb3, 0x00, 0x27, 0xcc},
1842
	{0xbc, 0x00, 0xd3, 0xcc},
1843
	{0xb8, 0x00, 0x23, 0xcc},
1844
	{0xb8, 0x2c, 0x50, 0xcc},
1845
	{0xb8, 0x2d, 0xf8, 0xcc},
1846
	{0xb8, 0x2e, 0xf8, 0xcc},
1847
	{0xb8, 0x2f, 0xf8, 0xcc},
1848
	{0xb8, 0x30, 0x50, 0xcc},
1849
	{0xb8, 0x31, 0xf8, 0xcc},
1850
	{0xb8, 0x32, 0xf8, 0xcc},
1851
	{0xb8, 0x33, 0xf8, 0xcc},
1852
	{0xb8, 0x34, 0x58, 0xcc},
1853
	{0xb8, 0x35, 0x00, 0xcc},
1854
	{0xb8, 0x36, 0x00, 0xcc},
1855
	{0xb8, 0x37, 0x00, 0xcc},
1856
	{0xb8, 0x27, 0x20, 0xcc},
1857
	{0xb8, 0x01, 0x7d, 0xcc},
1858
	{0xb8, 0x81, 0x09, 0xcc},
1859
	{0xb3, 0x01, 0x41, 0xcc},
1860
	{0xb8, 0x8e, 0x00, 0xcc},
1861
	{0xb8, 0x8f, 0xff, 0xcc},
1862
	{0x00, 0x01, 0x0c, 0xaa},
1863
	{0x00, 0x14, 0x01, 0xaa},
1864
	{0x00, 0x15, 0xe6, 0xaa},
1865
	{0x00, 0x16, 0x02, 0xaa},
1866
	{0x00, 0x17, 0x86, 0xaa},
1867
	{0x00, 0x23, 0x00, 0xaa},
1868
	{0x00, 0x25, 0x03, 0xaa},
1869
	{0x00, 0x26, 0xa9, 0xaa},
1870
	{0x00, 0x27, 0x80, 0xaa},
1871
	{0x00, 0x30, 0x18, 0xaa},
1872
	{0xb6, 0x00, 0x00, 0xcc},
1873
	{0xb6, 0x03, 0x01, 0xcc},
1874
	{0xb6, 0x02, 0x40, 0xcc},
1875
	{0xb6, 0x05, 0x00, 0xcc},
1876
	{0xb6, 0x04, 0xf0, 0xcc},
1877
	{0xb6, 0x12, 0x78, 0xcc},
1878
	{0xb6, 0x18, 0x00, 0xcc},
1879
	{0xb6, 0x17, 0x96, 0xcc},
1880
	{0xb6, 0x16, 0x00, 0xcc},
1881
	{0xb6, 0x22, 0x12, 0xcc},
1882
	{0xb6, 0x23, 0x0b, 0xcc},
1883
	{0xb3, 0x02, 0x02, 0xcc},
1884
	{0xbf, 0xc0, 0x39, 0xcc},
1885
	{0xbf, 0xc1, 0x04, 0xcc},
1886
	{0xbf, 0xcc, 0x10, 0xcc},
1887
	{0xbc, 0x02, 0x18, 0xcc},
1888
	{0xbc, 0x03, 0x50, 0xcc},
1889
	{0xbc, 0x04, 0x18, 0xcc},
1890
	{0xbc, 0x05, 0x00, 0xcc},
1891
	{0xbc, 0x06, 0x00, 0xcc},
1892
	{0xbc, 0x08, 0x30, 0xcc},
1893
	{0xbc, 0x09, 0x40, 0xcc},
1894
	{0xbc, 0x0a, 0x10, 0xcc},
1895
	{0xbc, 0x0b, 0x00, 0xcc},
1896
	{0xbc, 0x0c, 0x00, 0xcc},
1897
	{0xb9, 0x12, 0x00, 0xcc},
1898
	{0xb9, 0x13, 0x0a, 0xcc},
1899
	{0xb9, 0x14, 0x0a, 0xcc},
1900
	{0xb9, 0x15, 0x0a, 0xcc},
1901
	{0xb9, 0x16, 0x0a, 0xcc},
1902
	{0xb9, 0x18, 0x00, 0xcc},
1903
	{0xb9, 0x19, 0x0f, 0xcc},
1904
	{0xb8, 0x0c, 0x20, 0xcc},
1905
	{0xb8, 0x0d, 0x70, 0xcc},
1906
	{0xb9, 0x1a, 0x0f, 0xcc},
1907
	{0xb9, 0x1b, 0x0f, 0xcc},
1908
	{0xb9, 0x1c, 0x0f, 0xcc},
1909
	{0xb6, 0x12, 0xf8, 0xcc},
1910
	{0xb6, 0x13, 0x13, 0xcc},
1911
	{0xb3, 0x5c, 0x01, 0xcc},
1912
	{}
1913
};
1914

1915
static const u8 ov7660_gamma[17] = {
1916
	0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
1917
	0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
1918
};
1919
static const u8 ov7660_matrix[9] = {
1920
	0x5a, 0xf0, 0xf6, 0xf3, 0x57, 0xf6, 0xf3, 0xef, 0x62
1921
};
1922
static const u8 ov7660_initVGA_data[][4] = {
1923
	{0xb0, 0x4d, 0x00, 0xcc},	{0xb3, 0x01, 0x01, 0xcc},
1924
	{0x00, 0x00, 0x50, 0xdd},
1925
	{0xb0, 0x03, 0x01, 0xcc},
1926
	{0xb3, 0x00, 0x21, 0xcc},	{0xb3, 0x00, 0x26, 0xcc},
1927
	{0xb3, 0x05, 0x01, 0xcc},
1928
	{0xb3, 0x06, 0x03, 0xcc},
1929
	{0xb3, 0x03, 0x1f, 0xcc},	{0xb3, 0x04, 0x05, 0xcc},
1930
	{0xb3, 0x05, 0x00, 0xcc},
1931
	{0xb3, 0x06, 0x01, 0xcc},
1932
	{0xb3, 0x15, 0x00, 0xcc},/* 0xb315  <-0 href startl */
1933
	{0xb3, 0x16, 0x02, 0xcc},	{0xb3, 0x17, 0x7f, 0xcc},
1934
	{0xb3, 0x21, 0x00, 0xcc},
1935
	{0xb3, 0x23, 0xe0, 0xcc},	{0xb3, 0x1d, 0x01, 0xcc},
1936
	{0xb3, 0x1f, 0x02, 0xcc},
1937
	{0xb3, 0x34, 0x01, 0xcc},
1938
	{0xb3, 0x35, 0xa1, 0xcc},	/* i2c add: 21 */
1939
	{0xb3, 0x00, 0x26, 0xcc},
1940
	{0xb8, 0x00, 0x33, 0xcc}, /* 13 */
1941
	{0xb8, 0x01, 0x7d, 0xcc},
1942
	{0xbc, 0x00, 0x73, 0xcc},	{0xb8, 0x81, 0x09, 0xcc},
1943
	{0xb8, 0x27, 0x20, 0xcc},
1944
	{0xb8, 0x8f, 0x50, 0xcc},
1945
	{0x00, 0x01, 0x80, 0xaa},	{0x00, 0x02, 0x80, 0xaa},
1946
	{0x00, 0x12, 0x80, 0xaa},
1947
	{0x00, 0x12, 0x05, 0xaa},
1948
	{0x00, 0x1e, 0x01, 0xaa},	/* MVFP */
1949
	{0x00, 0x3d, 0x40, 0xaa}, /* 0x3d <-40 gamma 01 */
1950
	{0x00, 0x41, 0x00, 0xaa}, /* edge 00 */
1951
	{0x00, 0x0d, 0x48, 0xaa},	{0x00, 0x0e, 0x04, 0xaa},
1952
	{0x00, 0x13, 0xa7, 0xaa},
1953
	{0x00, 0x40, 0xc1, 0xaa},	{0x00, 0x35, 0x00, 0xaa},
1954
	{0x00, 0x36, 0x00, 0xaa},
1955
	{0x00, 0x3c, 0x68, 0xaa},	{0x00, 0x1b, 0x05, 0xaa},
1956
	{0x00, 0x39, 0x43, 0xaa},
1957
	{0x00, 0x8d, 0xcf, 0xaa},
1958
	{0x00, 0x8b, 0xcc, 0xaa},	{0x00, 0x8c, 0xcc, 0xaa},
1959
	{0x00, 0x0f, 0x62, 0xaa},
1960
	{0x00, 0x35, 0x84, 0xaa},
1961
	{0x00, 0x3b, 0x08, 0xaa}, /* 0 * Nightframe 1/4 + 50Hz -> 0xC8 */
1962
	{0x00, 0x3a, 0x00, 0xaa}, /* mx change yuyv format 00, 04, 01; 08, 0c*/
1963
	{0x00, 0x14, 0x2a, 0xaa}, /* agc ampli */
1964
	{0x00, 0x9e, 0x40, 0xaa},	{0xb8, 0x8f, 0x50, 0xcc},
1965
	{0x00, 0x01, 0x80, 0xaa},
1966
	{0x00, 0x02, 0x80, 0xaa},
1967
	{0xb8, 0xfe, 0x00, 0xcc},	{0xb8, 0xff, 0x28, 0xcc},
1968
	{0xb9, 0x00, 0x28, 0xcc},
1969
	{0xb9, 0x01, 0x28, 0xcc},	{0xb9, 0x02, 0x28, 0xcc},
1970
	{0xb9, 0x03, 0x00, 0xcc},
1971
	{0xb9, 0x04, 0x00, 0xcc},
1972
	{0xb9, 0x05, 0x3c, 0xcc},	{0xb9, 0x06, 0x3c, 0xcc},
1973
	{0xb9, 0x07, 0x3c, 0xcc},
1974
	{0xb9, 0x08, 0x3c, 0xcc},
1975

1976
	{0xb8, 0x8e, 0x00, 0xcc},	{0xb8, 0x8f, 0xff, 0xcc},
1977

1978
	{0x00, 0x29, 0x3c, 0xaa},	{0xb3, 0x01, 0x45, 0xcc},
1979
	{}
1980
};
1981
static const u8 ov7660_initQVGA_data[][4] = {
1982
	{0xb0, 0x4d, 0x00, 0xcc},	{0xb3, 0x01, 0x01, 0xcc},
1983
	{0x00, 0x00, 0x50, 0xdd},	{0xb0, 0x03, 0x01, 0xcc},
1984
	{0xb3, 0x00, 0x21, 0xcc},	{0xb3, 0x00, 0x26, 0xcc},
1985
	{0xb3, 0x05, 0x01, 0xcc},	{0xb3, 0x06, 0x03, 0xcc},
1986
	{0xb3, 0x03, 0x1f, 0xcc},	{0xb3, 0x04, 0x05, 0xcc},
1987
	{0xb3, 0x05, 0x00, 0xcc},	{0xb3, 0x06, 0x01, 0xcc},
1988
	{0xb3, 0x15, 0x00, 0xcc},/* 0xb315  <-0 href startl */
1989
	{0xb3, 0x16, 0x02, 0xcc},	{0xb3, 0x17, 0x7f, 0xcc},
1990
	{0xb3, 0x21, 0x00, 0xcc},
1991
	{0xb3, 0x23, 0xe0, 0xcc},	{0xb3, 0x1d, 0x01, 0xcc},
1992
	{0xb3, 0x1f, 0x02, 0xcc},	{0xb3, 0x34, 0x01, 0xcc},
1993
	{0xb3, 0x35, 0xa1, 0xcc},	{0xb3, 0x00, 0x26, 0xcc},
1994
	{0xb8, 0x00, 0x33, 0xcc}, /* 13 */
1995
	{0xb8, 0x01, 0x7d, 0xcc},
1996
/* sizer */
1997
	{0xbc, 0x00, 0xd3, 0xcc},
1998
	{0xb8, 0x81, 0x09, 0xcc},	{0xb8, 0x81, 0x09, 0xcc},
1999
	{0xb8, 0x27, 0x20, 0xcc},	{0xb8, 0x8f, 0x50, 0xcc},
2000
	{0x00, 0x01, 0x80, 0xaa},	{0x00, 0x02, 0x80, 0xaa},
2001
	{0x00, 0x12, 0x80, 0xaa},	{0x00, 0x12, 0x05, 0xaa},
2002
	{0x00, 0x1e, 0x01, 0xaa},	/* MVFP */
2003
	{0x00, 0x3d, 0x40, 0xaa}, /* 0x3d <-40 gamma 01 */
2004
	{0x00, 0x41, 0x00, 0xaa}, /* edge 00 */
2005
	{0x00, 0x0d, 0x48, 0xaa},	{0x00, 0x0e, 0x04, 0xaa},
2006
	{0x00, 0x13, 0xa7, 0xaa},
2007
	{0x00, 0x40, 0xc1, 0xaa},	{0x00, 0x35, 0x00, 0xaa},
2008
	{0x00, 0x36, 0x00, 0xaa},
2009
	{0x00, 0x3c, 0x68, 0xaa},	{0x00, 0x1b, 0x05, 0xaa},
2010
	{0x00, 0x39, 0x43, 0xaa},	{0x00, 0x8d, 0xcf, 0xaa},
2011
	{0x00, 0x8b, 0xcc, 0xaa},	{0x00, 0x8c, 0xcc, 0xaa},
2012
	{0x00, 0x0f, 0x62, 0xaa},	{0x00, 0x35, 0x84, 0xaa},
2013
	{0x00, 0x3b, 0x08, 0xaa}, /* 0  * Nightframe 1/4 + 50Hz -> 0xC8 */
2014
	{0x00, 0x3a, 0x00, 0xaa}, /* mx change yuyv format 00, 04, 01; 08, 0c*/
2015
	{0x00, 0x14, 0x2a, 0xaa}, /* agc ampli */
2016
	{0x00, 0x9e, 0x40, 0xaa},	{0xb8, 0x8f, 0x50, 0xcc},
2017
	{0x00, 0x01, 0x80, 0xaa},
2018
	{0x00, 0x02, 0x80, 0xaa},
2019
/* sizer filters */
2020
	{0xbc, 0x02, 0x08, 0xcc},
2021
	{0xbc, 0x03, 0x70, 0xcc},
2022
	{0xb8, 0x35, 0x00, 0xcc},
2023
	{0xb8, 0x36, 0x00, 0xcc},
2024
	{0xb8, 0x37, 0x00, 0xcc},
2025
	{0xbc, 0x04, 0x08, 0xcc},
2026
	{0xbc, 0x05, 0x00, 0xcc},
2027
	{0xbc, 0x06, 0x00, 0xcc},
2028
	{0xbc, 0x08, 0x3c, 0xcc},
2029
	{0xbc, 0x09, 0x40, 0xcc},
2030
	{0xbc, 0x0a, 0x04, 0xcc},
2031
	{0xbc, 0x0b, 0x00, 0xcc},
2032
	{0xbc, 0x0c, 0x00, 0xcc},
2033
/* */
2034
	{0xb8, 0xfe, 0x00, 0xcc},
2035
	{0xb8, 0xff, 0x28, 0xcc},
2036
/* */
2037
	{0xb9, 0x00, 0x28, 0xcc},	{0xb9, 0x01, 0x28, 0xcc},
2038
	{0xb9, 0x02, 0x28, 0xcc},	{0xb9, 0x03, 0x00, 0xcc},
2039
	{0xb9, 0x04, 0x00, 0xcc},	{0xb9, 0x05, 0x3c, 0xcc},
2040
	{0xb9, 0x06, 0x3c, 0xcc},	{0xb9, 0x07, 0x3c, 0xcc},
2041
	{0xb9, 0x08, 0x3c, 0xcc},
2042
/* */
2043
	{0xb8, 0x8e, 0x00, 0xcc},
2044
	{0xb8, 0x8f, 0xff, 0xcc}, /* ff */
2045
	{0x00, 0x29, 0x3c, 0xaa},
2046
	{0xb3, 0x01, 0x45, 0xcc}, /* 45 */
2047
	{}
2048
};
2049

2050
static const u8 ov7660_50HZ[][4] = {
2051
	{0x00, 0x3b, 0x08, 0xaa},
2052
	{0x00, 0x9d, 0x40, 0xaa},
2053
	{0x00, 0x13, 0xa7, 0xaa},
2054
	{}
2055
};
2056

2057
static const u8 ov7660_60HZ[][4] = {
2058
	{0x00, 0x3b, 0x00, 0xaa},
2059
	{0x00, 0x9e, 0x40, 0xaa},
2060
	{0x00, 0x13, 0xa7, 0xaa},
2061
	{}
2062
};
2063

2064
static const u8 ov7660_NoFliker[][4] = {
2065
	{0x00, 0x13, 0x87, 0xaa},
2066
	{}
2067
};
2068

2069
static const u8 ov7670_InitVGA[][4] = {
2070
	{0xb3, 0x01, 0x05, 0xcc},
2071
	{0x00, 0x00, 0x30, 0xdd},
2072
	{0xb0, 0x03, 0x19, 0xcc},
2073
	{0x00, 0x00, 0x10, 0xdd},
2074
	{0xb0, 0x04, 0x02, 0xcc},
2075
	{0x00, 0x00, 0x10, 0xdd},
2076
	{0xb3, 0x00, 0x66, 0xcc},
2077
	{0xb3, 0x00, 0x67, 0xcc},
2078
	{0xb0, 0x16, 0x01, 0xcc},
2079
	{0xb3, 0x35, 0xa1, 0xcc},	/* i2c add: 21 */
2080
	{0xb3, 0x34, 0x01, 0xcc},
2081
	{0xb3, 0x05, 0x01, 0xcc},
2082
	{0xb3, 0x06, 0x01, 0xcc},
2083
	{0xb3, 0x08, 0x01, 0xcc},
2084
	{0xb3, 0x09, 0x0c, 0xcc},
2085
	{0xb3, 0x02, 0x02, 0xcc},
2086
	{0xb3, 0x03, 0x1f, 0xcc},
2087
	{0xb3, 0x14, 0x00, 0xcc},
2088
	{0xb3, 0x15, 0x00, 0xcc},
2089
	{0xb3, 0x16, 0x02, 0xcc},
2090
	{0xb3, 0x17, 0x7f, 0xcc},
2091
	{0xb3, 0x04, 0x05, 0xcc},
2092
	{0xb3, 0x20, 0x00, 0xcc},
2093
	{0xb3, 0x21, 0x00, 0xcc},
2094
	{0xb3, 0x22, 0x01, 0xcc},
2095
	{0xb3, 0x23, 0xe0, 0xcc},
2096
	{0xbc, 0x00, 0x41, 0xcc},
2097
	{0xbc, 0x01, 0x01, 0xcc},
2098
	{0x00, 0x12, 0x80, 0xaa},
2099
	{0x00, 0x00, 0x20, 0xdd},
2100
	{0x00, 0x12, 0x00, 0xaa},
2101
	{0x00, 0x11, 0x40, 0xaa},
2102
	{0x00, 0x6b, 0x0a, 0xaa},
2103
	{0x00, 0x3a, 0x04, 0xaa},
2104
	{0x00, 0x40, 0xc0, 0xaa},
2105
	{0x00, 0x8c, 0x00, 0xaa},
2106
	{0x00, 0x7a, 0x29, 0xaa},
2107
	{0x00, 0x7b, 0x0e, 0xaa},
2108
	{0x00, 0x7c, 0x1a, 0xaa},
2109
	{0x00, 0x7d, 0x31, 0xaa},
2110
	{0x00, 0x7e, 0x53, 0xaa},
2111
	{0x00, 0x7f, 0x60, 0xaa},
2112
	{0x00, 0x80, 0x6b, 0xaa},
2113
	{0x00, 0x81, 0x73, 0xaa},
2114
	{0x00, 0x82, 0x7b, 0xaa},
2115
	{0x00, 0x83, 0x82, 0xaa},
2116
	{0x00, 0x84, 0x89, 0xaa},
2117
	{0x00, 0x85, 0x96, 0xaa},
2118
	{0x00, 0x86, 0xa1, 0xaa},
2119
	{0x00, 0x87, 0xb7, 0xaa},
2120
	{0x00, 0x88, 0xcc, 0xaa},
2121
	{0x00, 0x89, 0xe1, 0xaa},
2122
	{0x00, 0x13, 0xe0, 0xaa},
2123
	{0x00, 0x00, 0x00, 0xaa},
2124
	{0x00, 0x10, 0x00, 0xaa},
2125
	{0x00, 0x0d, 0x40, 0xaa},
2126
	{0x00, 0x14, 0x28, 0xaa},
2127
	{0x00, 0xa5, 0x05, 0xaa},
2128
	{0x00, 0xab, 0x07, 0xaa},
2129
	{0x00, 0x24, 0x95, 0xaa},
2130
	{0x00, 0x25, 0x33, 0xaa},
2131
	{0x00, 0x26, 0xe3, 0xaa},
2132
	{0x00, 0x9f, 0x88, 0xaa},
2133
	{0x00, 0xa0, 0x78, 0xaa},
2134
	{0x00, 0x55, 0x90, 0xaa},
2135
	{0x00, 0xa1, 0x03, 0xaa},
2136
	{0x00, 0xa6, 0xe0, 0xaa},
2137
	{0x00, 0xa7, 0xd8, 0xaa},
2138
	{0x00, 0xa8, 0xf0, 0xaa},
2139
	{0x00, 0xa9, 0x90, 0xaa},
2140
	{0x00, 0xaa, 0x14, 0xaa},
2141
	{0x00, 0x13, 0xe5, 0xaa},
2142
	{0x00, 0x0e, 0x61, 0xaa},
2143
	{0x00, 0x0f, 0x4b, 0xaa},
2144
	{0x00, 0x16, 0x02, 0xaa},
2145
	{0x00, 0x1e, 0x07, 0xaa},	/* MVFP */
2146
	{0x00, 0x21, 0x02, 0xaa},
2147
	{0x00, 0x22, 0x91, 0xaa},
2148
	{0x00, 0x29, 0x07, 0xaa},
2149
	{0x00, 0x33, 0x0b, 0xaa},
2150
	{0x00, 0x35, 0x0b, 0xaa},
2151
	{0x00, 0x37, 0x1d, 0xaa},
2152
	{0x00, 0x38, 0x71, 0xaa},
2153
	{0x00, 0x39, 0x2a, 0xaa},
2154
	{0x00, 0x3c, 0x78, 0xaa},
2155
	{0x00, 0x4d, 0x40, 0xaa},
2156
	{0x00, 0x4e, 0x20, 0xaa},
2157
	{0x00, 0x74, 0x19, 0xaa},
2158
	{0x00, 0x8d, 0x4f, 0xaa},
2159
	{0x00, 0x8e, 0x00, 0xaa},
2160
	{0x00, 0x8f, 0x00, 0xaa},
2161
	{0x00, 0x90, 0x00, 0xaa},
2162
	{0x00, 0x91, 0x00, 0xaa},
2163
	{0x00, 0x96, 0x00, 0xaa},
2164
	{0x00, 0x9a, 0x80, 0xaa},
2165
	{0x00, 0xb0, 0x84, 0xaa},
2166
	{0x00, 0xb1, 0x0c, 0xaa},
2167
	{0x00, 0xb2, 0x0e, 0xaa},
2168
	{0x00, 0xb3, 0x82, 0xaa},
2169
	{0x00, 0xb8, 0x0a, 0xaa},
2170
	{0x00, 0x43, 0x14, 0xaa},
2171
	{0x00, 0x44, 0xf0, 0xaa},
2172
	{0x00, 0x45, 0x45, 0xaa},
2173
	{0x00, 0x46, 0x63, 0xaa},
2174
	{0x00, 0x47, 0x2d, 0xaa},
2175
	{0x00, 0x48, 0x46, 0xaa},
2176
	{0x00, 0x59, 0x88, 0xaa},
2177
	{0x00, 0x5a, 0xa0, 0xaa},
2178
	{0x00, 0x5b, 0xc6, 0xaa},
2179
	{0x00, 0x5c, 0x7d, 0xaa},
2180
	{0x00, 0x5d, 0x5f, 0xaa},
2181
	{0x00, 0x5e, 0x19, 0xaa},
2182
	{0x00, 0x6c, 0x0a, 0xaa},
2183
	{0x00, 0x6d, 0x55, 0xaa},
2184
	{0x00, 0x6e, 0x11, 0xaa},
2185
	{0x00, 0x6f, 0x9e, 0xaa},
2186
	{0x00, 0x69, 0x00, 0xaa},
2187
	{0x00, 0x6a, 0x40, 0xaa},
2188
	{0x00, 0x01, 0x40, 0xaa},
2189
	{0x00, 0x02, 0x40, 0xaa},
2190
	{0x00, 0x13, 0xe7, 0xaa},
2191
	{0x00, 0x5f, 0xf0, 0xaa},
2192
	{0x00, 0x60, 0xf0, 0xaa},
2193
	{0x00, 0x61, 0xf0, 0xaa},
2194
	{0x00, 0x27, 0xa0, 0xaa},
2195
	{0x00, 0x28, 0x80, 0xaa},
2196
	{0x00, 0x2c, 0x90, 0xaa},
2197
	{0x00, 0x4f, 0x66, 0xaa},
2198
	{0x00, 0x50, 0x66, 0xaa},
2199
	{0x00, 0x51, 0x00, 0xaa},
2200
	{0x00, 0x52, 0x22, 0xaa},
2201
	{0x00, 0x53, 0x5e, 0xaa},
2202
	{0x00, 0x54, 0x80, 0xaa},
2203
	{0x00, 0x58, 0x9e, 0xaa},
2204
	{0x00, 0x41, 0x08, 0xaa},
2205
	{0x00, 0x3f, 0x00, 0xaa},
2206
	{0x00, 0x75, 0x85, 0xaa},
2207
	{0x00, 0x76, 0xe1, 0xaa},
2208
	{0x00, 0x4c, 0x00, 0xaa},
2209
	{0x00, 0x77, 0x0a, 0xaa},
2210
	{0x00, 0x3d, 0x88, 0xaa},
2211
	{0x00, 0x4b, 0x09, 0xaa},
2212
	{0x00, 0xc9, 0x60, 0xaa},
2213
	{0x00, 0x41, 0x38, 0xaa},
2214
	{0x00, 0x62, 0x30, 0xaa},
2215
	{0x00, 0x63, 0x30, 0xaa},
2216
	{0x00, 0x64, 0x08, 0xaa},
2217
	{0x00, 0x94, 0x07, 0xaa},
2218
	{0x00, 0x95, 0x0b, 0xaa},
2219
	{0x00, 0x65, 0x00, 0xaa},
2220
	{0x00, 0x66, 0x05, 0xaa},
2221
	{0x00, 0x56, 0x50, 0xaa},
2222
	{0x00, 0x34, 0x11, 0xaa},
2223
	{0x00, 0xa4, 0x88, 0xaa},
2224
	{0x00, 0x96, 0x00, 0xaa},
2225
	{0x00, 0x97, 0x30, 0xaa},
2226
	{0x00, 0x98, 0x20, 0xaa},
2227
	{0x00, 0x99, 0x30, 0xaa},
2228
	{0x00, 0x9a, 0x84, 0xaa},
2229
	{0x00, 0x9b, 0x29, 0xaa},
2230
	{0x00, 0x9c, 0x03, 0xaa},
2231
	{0x00, 0x78, 0x04, 0xaa},
2232
	{0x00, 0x79, 0x01, 0xaa},
2233
	{0x00, 0xc8, 0xf0, 0xaa},
2234
	{0x00, 0x79, 0x0f, 0xaa},
2235
	{0x00, 0xc8, 0x00, 0xaa},
2236
	{0x00, 0x79, 0x10, 0xaa},
2237
	{0x00, 0xc8, 0x7e, 0xaa},
2238
	{0x00, 0x79, 0x0a, 0xaa},
2239
	{0x00, 0xc8, 0x80, 0xaa},
2240
	{0x00, 0x79, 0x0b, 0xaa},
2241
	{0x00, 0xc8, 0x01, 0xaa},
2242
	{0x00, 0x79, 0x0c, 0xaa},
2243
	{0x00, 0xc8, 0x0f, 0xaa},
2244
	{0x00, 0x79, 0x0d, 0xaa},
2245
	{0x00, 0xc8, 0x20, 0xaa},
2246
	{0x00, 0x79, 0x09, 0xaa},
2247
	{0x00, 0xc8, 0x80, 0xaa},
2248
	{0x00, 0x79, 0x02, 0xaa},
2249
	{0x00, 0xc8, 0xc0, 0xaa},
2250
	{0x00, 0x79, 0x03, 0xaa},
2251
	{0x00, 0xc8, 0x40, 0xaa},
2252
	{0x00, 0x79, 0x05, 0xaa},
2253
	{0x00, 0xc8, 0x30, 0xaa},
2254
	{0x00, 0x79, 0x26, 0xaa},
2255
	{0x00, 0x11, 0x40, 0xaa},
2256
	{0x00, 0x3a, 0x04, 0xaa},
2257
	{0x00, 0x12, 0x00, 0xaa},
2258
	{0x00, 0x40, 0xc0, 0xaa},
2259
	{0x00, 0x8c, 0x00, 0xaa},
2260
	{0x00, 0x17, 0x14, 0xaa},
2261
	{0x00, 0x18, 0x02, 0xaa},
2262
	{0x00, 0x32, 0x92, 0xaa},
2263
	{0x00, 0x19, 0x02, 0xaa},
2264
	{0x00, 0x1a, 0x7a, 0xaa},
2265
	{0x00, 0x03, 0x0a, 0xaa},
2266
	{0x00, 0x0c, 0x00, 0xaa},
2267
	{0x00, 0x3e, 0x00, 0xaa},
2268
	{0x00, 0x70, 0x3a, 0xaa},
2269
	{0x00, 0x71, 0x35, 0xaa},
2270
	{0x00, 0x72, 0x11, 0xaa},
2271
	{0x00, 0x73, 0xf0, 0xaa},
2272
	{0x00, 0xa2, 0x02, 0xaa},
2273
	{0x00, 0xb1, 0x00, 0xaa},
2274
	{0x00, 0xb1, 0x0c, 0xaa},
2275
	{0x00, 0x1e, 0x37, 0xaa},	/* MVFP */
2276
	{0x00, 0xaa, 0x14, 0xaa},
2277
	{0x00, 0x24, 0x80, 0xaa},
2278
	{0x00, 0x25, 0x74, 0xaa},
2279
	{0x00, 0x26, 0xd3, 0xaa},
2280
	{0x00, 0x0d, 0x00, 0xaa},
2281
	{0x00, 0x14, 0x18, 0xaa},
2282
	{0x00, 0x9d, 0x99, 0xaa},
2283
	{0x00, 0x9e, 0x7f, 0xaa},
2284
	{0x00, 0x64, 0x08, 0xaa},
2285
	{0x00, 0x94, 0x07, 0xaa},
2286
	{0x00, 0x95, 0x06, 0xaa},
2287
	{0x00, 0x66, 0x05, 0xaa},
2288
	{0x00, 0x41, 0x08, 0xaa},
2289
	{0x00, 0x3f, 0x00, 0xaa},
2290
	{0x00, 0x75, 0x07, 0xaa},
2291
	{0x00, 0x76, 0xe1, 0xaa},
2292
	{0x00, 0x4c, 0x00, 0xaa},
2293
	{0x00, 0x77, 0x00, 0xaa},
2294
	{0x00, 0x3d, 0xc2, 0xaa},
2295
	{0x00, 0x4b, 0x09, 0xaa},
2296
	{0x00, 0xc9, 0x60, 0xaa},
2297
	{0x00, 0x41, 0x38, 0xaa},
2298
	{0xbf, 0xc0, 0x26, 0xcc},
2299
	{0xbf, 0xc1, 0x02, 0xcc},
2300
	{0xbf, 0xcc, 0x04, 0xcc},
2301
	{0xb3, 0x5c, 0x01, 0xcc},
2302
	{0xb3, 0x01, 0x45, 0xcc},
2303
	{0x00, 0x77, 0x05, 0xaa},
2304
	{},
2305
};
2306

2307
static const u8 ov7670_InitQVGA[][4] = {
2308
	{0xb3, 0x01, 0x05, 0xcc},
2309
	{0x00, 0x00, 0x30, 0xdd},
2310
	{0xb0, 0x03, 0x19, 0xcc},
2311
	{0x00, 0x00, 0x10, 0xdd},
2312
	{0xb0, 0x04, 0x02, 0xcc},
2313
	{0x00, 0x00, 0x10, 0xdd},
2314
	{0xb3, 0x00, 0x66, 0xcc},
2315
	{0xb3, 0x00, 0x67, 0xcc},
2316
	{0xb0, 0x16, 0x01, 0xcc},
2317
	{0xb3, 0x35, 0xa1, 0xcc},	/* i2c add: 21 */
2318
	{0xb3, 0x34, 0x01, 0xcc},
2319
	{0xb3, 0x05, 0x01, 0xcc},
2320
	{0xb3, 0x06, 0x01, 0xcc},
2321
	{0xb3, 0x08, 0x01, 0xcc},
2322
	{0xb3, 0x09, 0x0c, 0xcc},
2323
	{0xb3, 0x02, 0x02, 0xcc},
2324
	{0xb3, 0x03, 0x1f, 0xcc},
2325
	{0xb3, 0x14, 0x00, 0xcc},
2326
	{0xb3, 0x15, 0x00, 0xcc},
2327
	{0xb3, 0x16, 0x02, 0xcc},
2328
	{0xb3, 0x17, 0x7f, 0xcc},
2329
	{0xb3, 0x04, 0x05, 0xcc},
2330
	{0xb3, 0x20, 0x00, 0xcc},
2331
	{0xb3, 0x21, 0x00, 0xcc},
2332
	{0xb3, 0x22, 0x01, 0xcc},
2333
	{0xb3, 0x23, 0xe0, 0xcc},
2334
	{0xbc, 0x00, 0xd1, 0xcc},
2335
	{0xbc, 0x01, 0x01, 0xcc},
2336
	{0x00, 0x12, 0x80, 0xaa},
2337
	{0x00, 0x00, 0x20, 0xdd},
2338
	{0x00, 0x12, 0x00, 0xaa},
2339
	{0x00, 0x11, 0x40, 0xaa},
2340
	{0x00, 0x6b, 0x0a, 0xaa},
2341
	{0x00, 0x3a, 0x04, 0xaa},
2342
	{0x00, 0x40, 0xc0, 0xaa},
2343
	{0x00, 0x8c, 0x00, 0xaa},
2344
	{0x00, 0x7a, 0x29, 0xaa},
2345
	{0x00, 0x7b, 0x0e, 0xaa},
2346
	{0x00, 0x7c, 0x1a, 0xaa},
2347
	{0x00, 0x7d, 0x31, 0xaa},
2348
	{0x00, 0x7e, 0x53, 0xaa},
2349
	{0x00, 0x7f, 0x60, 0xaa},
2350
	{0x00, 0x80, 0x6b, 0xaa},
2351
	{0x00, 0x81, 0x73, 0xaa},
2352
	{0x00, 0x82, 0x7b, 0xaa},
2353
	{0x00, 0x83, 0x82, 0xaa},
2354
	{0x00, 0x84, 0x89, 0xaa},
2355
	{0x00, 0x85, 0x96, 0xaa},
2356
	{0x00, 0x86, 0xa1, 0xaa},
2357
	{0x00, 0x87, 0xb7, 0xaa},
2358
	{0x00, 0x88, 0xcc, 0xaa},
2359
	{0x00, 0x89, 0xe1, 0xaa},
2360
	{0x00, 0x13, 0xe0, 0xaa},
2361
	{0x00, 0x00, 0x00, 0xaa},
2362
	{0x00, 0x10, 0x00, 0xaa},
2363
	{0x00, 0x0d, 0x40, 0xaa},
2364
	{0x00, 0x14, 0x28, 0xaa},
2365
	{0x00, 0xa5, 0x05, 0xaa},
2366
	{0x00, 0xab, 0x07, 0xaa},
2367
	{0x00, 0x24, 0x95, 0xaa},
2368
	{0x00, 0x25, 0x33, 0xaa},
2369
	{0x00, 0x26, 0xe3, 0xaa},
2370
	{0x00, 0x9f, 0x88, 0xaa},
2371
	{0x00, 0xa0, 0x78, 0xaa},
2372
	{0x00, 0x55, 0x90, 0xaa},
2373
	{0x00, 0xa1, 0x03, 0xaa},
2374
	{0x00, 0xa6, 0xe0, 0xaa},
2375
	{0x00, 0xa7, 0xd8, 0xaa},
2376
	{0x00, 0xa8, 0xf0, 0xaa},
2377
	{0x00, 0xa9, 0x90, 0xaa},
2378
	{0x00, 0xaa, 0x14, 0xaa},
2379
	{0x00, 0x13, 0xe5, 0xaa},
2380
	{0x00, 0x0e, 0x61, 0xaa},
2381
	{0x00, 0x0f, 0x4b, 0xaa},
2382
	{0x00, 0x16, 0x02, 0xaa},
2383
	{0x00, 0x1e, 0x07, 0xaa},	/* MVFP */
2384
	{0x00, 0x21, 0x02, 0xaa},
2385
	{0x00, 0x22, 0x91, 0xaa},
2386
	{0x00, 0x29, 0x07, 0xaa},
2387
	{0x00, 0x33, 0x0b, 0xaa},
2388
	{0x00, 0x35, 0x0b, 0xaa},
2389
	{0x00, 0x37, 0x1d, 0xaa},
2390
	{0x00, 0x38, 0x71, 0xaa},
2391
	{0x00, 0x39, 0x2a, 0xaa},
2392
	{0x00, 0x3c, 0x78, 0xaa},
2393
	{0x00, 0x4d, 0x40, 0xaa},
2394
	{0x00, 0x4e, 0x20, 0xaa},
2395
	{0x00, 0x74, 0x19, 0xaa},
2396
	{0x00, 0x8d, 0x4f, 0xaa},
2397
	{0x00, 0x8e, 0x00, 0xaa},
2398
	{0x00, 0x8f, 0x00, 0xaa},
2399
	{0x00, 0x90, 0x00, 0xaa},
2400
	{0x00, 0x91, 0x00, 0xaa},
2401
	{0x00, 0x96, 0x00, 0xaa},
2402
	{0x00, 0x9a, 0x80, 0xaa},
2403
	{0x00, 0xb0, 0x84, 0xaa},
2404
	{0x00, 0xb1, 0x0c, 0xaa},
2405
	{0x00, 0xb2, 0x0e, 0xaa},
2406
	{0x00, 0xb3, 0x82, 0xaa},
2407
	{0x00, 0xb8, 0x0a, 0xaa},
2408
	{0x00, 0x43, 0x14, 0xaa},
2409
	{0x00, 0x44, 0xf0, 0xaa},
2410
	{0x00, 0x45, 0x45, 0xaa},
2411
	{0x00, 0x46, 0x63, 0xaa},
2412
	{0x00, 0x47, 0x2d, 0xaa},
2413
	{0x00, 0x48, 0x46, 0xaa},
2414
	{0x00, 0x59, 0x88, 0xaa},
2415
	{0x00, 0x5a, 0xa0, 0xaa},
2416
	{0x00, 0x5b, 0xc6, 0xaa},
2417
	{0x00, 0x5c, 0x7d, 0xaa},
2418
	{0x00, 0x5d, 0x5f, 0xaa},
2419
	{0x00, 0x5e, 0x19, 0xaa},
2420
	{0x00, 0x6c, 0x0a, 0xaa},
2421
	{0x00, 0x6d, 0x55, 0xaa},
2422
	{0x00, 0x6e, 0x11, 0xaa},
2423
	{0x00, 0x6f, 0x9e, 0xaa},
2424
	{0x00, 0x69, 0x00, 0xaa},
2425
	{0x00, 0x6a, 0x40, 0xaa},
2426
	{0x00, 0x01, 0x40, 0xaa},
2427
	{0x00, 0x02, 0x40, 0xaa},
2428
	{0x00, 0x13, 0xe7, 0xaa},
2429
	{0x00, 0x5f, 0xf0, 0xaa},
2430
	{0x00, 0x60, 0xf0, 0xaa},
2431
	{0x00, 0x61, 0xf0, 0xaa},
2432
	{0x00, 0x27, 0xa0, 0xaa},
2433
	{0x00, 0x28, 0x80, 0xaa},
2434
	{0x00, 0x2c, 0x90, 0xaa},
2435
	{0x00, 0x4f, 0x66, 0xaa},
2436
	{0x00, 0x50, 0x66, 0xaa},
2437
	{0x00, 0x51, 0x00, 0xaa},
2438
	{0x00, 0x52, 0x22, 0xaa},
2439
	{0x00, 0x53, 0x5e, 0xaa},
2440
	{0x00, 0x54, 0x80, 0xaa},
2441
	{0x00, 0x58, 0x9e, 0xaa},
2442
	{0x00, 0x41, 0x08, 0xaa},
2443
	{0x00, 0x3f, 0x00, 0xaa},
2444
	{0x00, 0x75, 0x85, 0xaa},
2445
	{0x00, 0x76, 0xe1, 0xaa},
2446
	{0x00, 0x4c, 0x00, 0xaa},
2447
	{0x00, 0x77, 0x0a, 0xaa},
2448
	{0x00, 0x3d, 0x88, 0xaa},
2449
	{0x00, 0x4b, 0x09, 0xaa},
2450
	{0x00, 0xc9, 0x60, 0xaa},
2451
	{0x00, 0x41, 0x38, 0xaa},
2452
	{0x00, 0x62, 0x30, 0xaa},
2453
	{0x00, 0x63, 0x30, 0xaa},
2454
	{0x00, 0x64, 0x08, 0xaa},
2455
	{0x00, 0x94, 0x07, 0xaa},
2456
	{0x00, 0x95, 0x0b, 0xaa},
2457
	{0x00, 0x65, 0x00, 0xaa},
2458
	{0x00, 0x66, 0x05, 0xaa},
2459
	{0x00, 0x56, 0x50, 0xaa},
2460
	{0x00, 0x34, 0x11, 0xaa},
2461
	{0x00, 0xa4, 0x88, 0xaa},
2462
	{0x00, 0x96, 0x00, 0xaa},
2463
	{0x00, 0x97, 0x30, 0xaa},
2464
	{0x00, 0x98, 0x20, 0xaa},
2465
	{0x00, 0x99, 0x30, 0xaa},
2466
	{0x00, 0x9a, 0x84, 0xaa},
2467
	{0x00, 0x9b, 0x29, 0xaa},
2468
	{0x00, 0x9c, 0x03, 0xaa},
2469
	{0x00, 0x78, 0x04, 0xaa},
2470
	{0x00, 0x79, 0x01, 0xaa},
2471
	{0x00, 0xc8, 0xf0, 0xaa},
2472
	{0x00, 0x79, 0x0f, 0xaa},
2473
	{0x00, 0xc8, 0x00, 0xaa},
2474
	{0x00, 0x79, 0x10, 0xaa},
2475
	{0x00, 0xc8, 0x7e, 0xaa},
2476
	{0x00, 0x79, 0x0a, 0xaa},
2477
	{0x00, 0xc8, 0x80, 0xaa},
2478
	{0x00, 0x79, 0x0b, 0xaa},
2479
	{0x00, 0xc8, 0x01, 0xaa},
2480
	{0x00, 0x79, 0x0c, 0xaa},
2481
	{0x00, 0xc8, 0x0f, 0xaa},
2482
	{0x00, 0x79, 0x0d, 0xaa},
2483
	{0x00, 0xc8, 0x20, 0xaa},
2484
	{0x00, 0x79, 0x09, 0xaa},
2485
	{0x00, 0xc8, 0x80, 0xaa},
2486
	{0x00, 0x79, 0x02, 0xaa},
2487
	{0x00, 0xc8, 0xc0, 0xaa},
2488
	{0x00, 0x79, 0x03, 0xaa},
2489
	{0x00, 0xc8, 0x40, 0xaa},
2490
	{0x00, 0x79, 0x05, 0xaa},
2491
	{0x00, 0xc8, 0x30, 0xaa},
2492
	{0x00, 0x79, 0x26, 0xaa},
2493
	{0x00, 0x11, 0x40, 0xaa},
2494
	{0x00, 0x3a, 0x04, 0xaa},
2495
	{0x00, 0x12, 0x00, 0xaa},
2496
	{0x00, 0x40, 0xc0, 0xaa},
2497
	{0x00, 0x8c, 0x00, 0xaa},
2498
	{0x00, 0x17, 0x14, 0xaa},
2499
	{0x00, 0x18, 0x02, 0xaa},
2500
	{0x00, 0x32, 0x92, 0xaa},
2501
	{0x00, 0x19, 0x02, 0xaa},
2502
	{0x00, 0x1a, 0x7a, 0xaa},
2503
	{0x00, 0x03, 0x0a, 0xaa},
2504
	{0x00, 0x0c, 0x00, 0xaa},
2505
	{0x00, 0x3e, 0x00, 0xaa},
2506
	{0x00, 0x70, 0x3a, 0xaa},
2507
	{0x00, 0x71, 0x35, 0xaa},
2508
	{0x00, 0x72, 0x11, 0xaa},
2509
	{0x00, 0x73, 0xf0, 0xaa},
2510
	{0x00, 0xa2, 0x02, 0xaa},
2511
	{0x00, 0xb1, 0x00, 0xaa},
2512
	{0x00, 0xb1, 0x0c, 0xaa},
2513
	{0x00, 0x1e, 0x37, 0xaa},	/* MVFP */
2514
	{0x00, 0xaa, 0x14, 0xaa},
2515
	{0x00, 0x24, 0x80, 0xaa},
2516
	{0x00, 0x25, 0x74, 0xaa},
2517
	{0x00, 0x26, 0xd3, 0xaa},
2518
	{0x00, 0x0d, 0x00, 0xaa},
2519
	{0x00, 0x14, 0x18, 0xaa},
2520
	{0x00, 0x9d, 0x99, 0xaa},
2521
	{0x00, 0x9e, 0x7f, 0xaa},
2522
	{0x00, 0x64, 0x08, 0xaa},
2523
	{0x00, 0x94, 0x07, 0xaa},
2524
	{0x00, 0x95, 0x06, 0xaa},
2525
	{0x00, 0x66, 0x05, 0xaa},
2526
	{0x00, 0x41, 0x08, 0xaa},
2527
	{0x00, 0x3f, 0x00, 0xaa},
2528
	{0x00, 0x75, 0x07, 0xaa},
2529
	{0x00, 0x76, 0xe1, 0xaa},
2530
	{0x00, 0x4c, 0x00, 0xaa},
2531
	{0x00, 0x77, 0x00, 0xaa},
2532
	{0x00, 0x3d, 0xc2, 0xaa},
2533
	{0x00, 0x4b, 0x09, 0xaa},
2534
	{0x00, 0xc9, 0x60, 0xaa},
2535
	{0x00, 0x41, 0x38, 0xaa},
2536
	{0xbc, 0x02, 0x18, 0xcc},
2537
	{0xbc, 0x03, 0x50, 0xcc},
2538
	{0xbc, 0x04, 0x18, 0xcc},
2539
	{0xbc, 0x05, 0x00, 0xcc},
2540
	{0xbc, 0x06, 0x00, 0xcc},
2541
	{0xbc, 0x08, 0x30, 0xcc},
2542
	{0xbc, 0x09, 0x40, 0xcc},
2543
	{0xbc, 0x0a, 0x10, 0xcc},
2544
	{0xbc, 0x0b, 0x00, 0xcc},
2545
	{0xbc, 0x0c, 0x00, 0xcc},
2546
	{0xbf, 0xc0, 0x26, 0xcc},
2547
	{0xbf, 0xc1, 0x02, 0xcc},
2548
	{0xbf, 0xcc, 0x04, 0xcc},
2549
	{0xb3, 0x5c, 0x01, 0xcc},
2550
	{0xb3, 0x01, 0x45, 0xcc},
2551
	{0x00, 0x77, 0x05, 0xaa},
2552
	{},
2553
};
2554

2555
/* PO1200 - values from usbvm326.inf and ms-win trace */
2556
static const u8 po1200_gamma[17] = {
2557
	0x00, 0x13, 0x38, 0x59, 0x79, 0x92, 0xa7, 0xb9, 0xc8,
2558
	0xd4, 0xdf, 0xe7, 0xee, 0xf4, 0xf9, 0xfc, 0xff
2559
};
2560
static const u8 po1200_matrix[9] = {
2561
	0x60, 0xf9, 0xe5, 0xe7, 0x50, 0x05, 0xf3, 0xe6, 0x5e
2562
};
2563
static const u8 po1200_initVGA_data[][4] = {
2564
	{0xb0, 0x03, 0x19, 0xcc},	/* reset? */
2565
	{0xb0, 0x03, 0x19, 0xcc},
2566
/*	{0x00, 0x00, 0x33, 0xdd}, */
2567
	{0xb0, 0x04, 0x02, 0xcc},
2568
	{0xb0, 0x02, 0x02, 0xcc},
2569
	{0xb3, 0x5d, 0x00, 0xcc},
2570
	{0xb3, 0x01, 0x01, 0xcc},
2571
	{0xb3, 0x00, 0x64, 0xcc},
2572
	{0xb3, 0x00, 0x65, 0xcc},
2573
	{0xb3, 0x05, 0x01, 0xcc},
2574
	{0xb3, 0x06, 0x01, 0xcc},
2575
	{0xb3, 0x5c, 0x01, 0xcc},
2576
	{0xb3, 0x08, 0x01, 0xcc},
2577
	{0xb3, 0x09, 0x0c, 0xcc},
2578
	{0xb3, 0x00, 0x67, 0xcc},
2579
	{0xb3, 0x02, 0xb2, 0xcc},
2580
	{0xb3, 0x03, 0x18, 0xcc},
2581
	{0xb3, 0x04, 0x15, 0xcc},
2582
	{0xb3, 0x20, 0x00, 0xcc},
2583
	{0xb3, 0x21, 0x00, 0xcc},
2584
	{0xb3, 0x22, 0x02, 0xcc},
2585
	{0xb3, 0x23, 0x58, 0xcc},
2586
	{0xb3, 0x14, 0x00, 0xcc},
2587
	{0xb3, 0x15, 0x00, 0xcc},
2588
	{0xb3, 0x16, 0x03, 0xcc},
2589
	{0xb3, 0x17, 0x1f, 0xcc},
2590
	{0xbc, 0x00, 0x71, 0xcc},
2591
	{0xbc, 0x01, 0x01, 0xcc},
2592
	{0xb0, 0x54, 0x13, 0xcc},
2593
	{0xb3, 0x00, 0x67, 0xcc},
2594
	{0xb3, 0x34, 0x01, 0xcc},
2595
	{0xb3, 0x35, 0xdc, 0xcc},	/* i2c add: 5c */
2596
	{0x00, 0x03, 0x00, 0xaa},
2597
	{0x00, 0x12, 0x05, 0xaa},
2598
	{0x00, 0x13, 0x02, 0xaa},
2599
	{0x00, 0x1e, 0xc6, 0xaa},	/* h/v flip */
2600
	{0x00, 0x21, 0x00, 0xaa},
2601
	{0x00, 0x25, 0x02, 0xaa},
2602
	{0x00, 0x3c, 0x4f, 0xaa},
2603
	{0x00, 0x3f, 0xe0, 0xaa},
2604
	{0x00, 0x42, 0xff, 0xaa},
2605
	{0x00, 0x45, 0x34, 0xaa},
2606
	{0x00, 0x55, 0xfe, 0xaa},
2607
	{0x00, 0x59, 0xd3, 0xaa},
2608
	{0x00, 0x5e, 0x04, 0xaa},
2609
	{0x00, 0x61, 0xb8, 0xaa},	/* sharpness */
2610
	{0x00, 0x62, 0x02, 0xaa},
2611
	{0x00, 0xa7, 0x31, 0xaa},
2612
	{0x00, 0xa9, 0x66, 0xaa},
2613
	{0x00, 0xb0, 0x00, 0xaa},
2614
	{0x00, 0xb1, 0x00, 0xaa},
2615
	{0x00, 0xb3, 0x11, 0xaa},
2616
	{0x00, 0xb6, 0x26, 0xaa},
2617
	{0x00, 0xb7, 0x20, 0xaa},
2618
	{0x00, 0xba, 0x04, 0xaa},
2619
	{0x00, 0x88, 0x42, 0xaa},
2620
	{0x00, 0x89, 0x9a, 0xaa},
2621
	{0x00, 0x8a, 0x88, 0xaa},
2622
	{0x00, 0x8b, 0x8e, 0xaa},
2623
	{0x00, 0x8c, 0x3e, 0xaa},
2624
	{0x00, 0x8d, 0x90, 0xaa},
2625
	{0x00, 0x8e, 0x87, 0xaa},
2626
	{0x00, 0x8f, 0x96, 0xaa},
2627
	{0x00, 0x90, 0x3d, 0xaa},
2628
	{0x00, 0x64, 0x00, 0xaa},
2629
	{0x00, 0x65, 0x10, 0xaa},
2630
	{0x00, 0x66, 0x20, 0xaa},
2631
	{0x00, 0x67, 0x2b, 0xaa},
2632
	{0x00, 0x68, 0x36, 0xaa},
2633
	{0x00, 0x69, 0x49, 0xaa},
2634
	{0x00, 0x6a, 0x5a, 0xaa},
2635
	{0x00, 0x6b, 0x7f, 0xaa},
2636
	{0x00, 0x6c, 0x9b, 0xaa},
2637
	{0x00, 0x6d, 0xba, 0xaa},
2638
	{0x00, 0x6e, 0xd4, 0xaa},
2639
	{0x00, 0x6f, 0xea, 0xaa},
2640
	{0x00, 0x70, 0x00, 0xaa},
2641
	{0x00, 0x71, 0x10, 0xaa},
2642
	{0x00, 0x72, 0x20, 0xaa},
2643
	{0x00, 0x73, 0x2b, 0xaa},
2644
	{0x00, 0x74, 0x36, 0xaa},
2645
	{0x00, 0x75, 0x49, 0xaa},
2646
	{0x00, 0x76, 0x5a, 0xaa},
2647
	{0x00, 0x77, 0x7f, 0xaa},
2648
	{0x00, 0x78, 0x9b, 0xaa},
2649
	{0x00, 0x79, 0xba, 0xaa},
2650
	{0x00, 0x7a, 0xd4, 0xaa},
2651
	{0x00, 0x7b, 0xea, 0xaa},
2652
	{0x00, 0x7c, 0x00, 0xaa},
2653
	{0x00, 0x7d, 0x10, 0xaa},
2654
	{0x00, 0x7e, 0x20, 0xaa},
2655
	{0x00, 0x7f, 0x2b, 0xaa},
2656
	{0x00, 0x80, 0x36, 0xaa},
2657
	{0x00, 0x81, 0x49, 0xaa},
2658
	{0x00, 0x82, 0x5a, 0xaa},
2659
	{0x00, 0x83, 0x7f, 0xaa},
2660
	{0x00, 0x84, 0x9b, 0xaa},
2661
	{0x00, 0x85, 0xba, 0xaa},
2662
	{0x00, 0x86, 0xd4, 0xaa},
2663
	{0x00, 0x87, 0xea, 0xaa},
2664
	{0x00, 0x57, 0x2a, 0xaa},
2665
	{0x00, 0x03, 0x01, 0xaa},
2666
	{0x00, 0x04, 0x10, 0xaa},
2667
	{0x00, 0x05, 0x10, 0xaa},
2668
	{0x00, 0x06, 0x10, 0xaa},
2669
	{0x00, 0x07, 0x10, 0xaa},
2670
	{0x00, 0x08, 0x13, 0xaa},
2671
	{0x00, 0x0a, 0x00, 0xaa},
2672
	{0x00, 0x0b, 0x10, 0xaa},
2673
	{0x00, 0x0c, 0x20, 0xaa},
2674
	{0x00, 0x0d, 0x18, 0xaa},
2675
	{0x00, 0x22, 0x01, 0xaa},
2676
	{0x00, 0x23, 0x60, 0xaa},
2677
	{0x00, 0x25, 0x08, 0xaa},
2678
	{0x00, 0x26, 0x82, 0xaa},
2679
	{0x00, 0x2e, 0x0f, 0xaa},
2680
	{0x00, 0x2f, 0x1e, 0xaa},
2681
	{0x00, 0x30, 0x2d, 0xaa},
2682
	{0x00, 0x31, 0x3c, 0xaa},
2683
	{0x00, 0x32, 0x4b, 0xaa},
2684
	{0x00, 0x33, 0x5a, 0xaa},
2685
	{0x00, 0x34, 0x69, 0xaa},
2686
	{0x00, 0x35, 0x78, 0xaa},
2687
	{0x00, 0x36, 0x87, 0xaa},
2688
	{0x00, 0x37, 0x96, 0xaa},
2689
	{0x00, 0x38, 0xa5, 0xaa},
2690
	{0x00, 0x39, 0xb4, 0xaa},
2691
	{0x00, 0x3a, 0xc3, 0xaa},
2692
	{0x00, 0x3b, 0xd2, 0xaa},
2693
	{0x00, 0x3c, 0xe1, 0xaa},
2694
	{0x00, 0x3e, 0xff, 0xaa},
2695
	{0x00, 0x3f, 0xff, 0xaa},
2696
	{0x00, 0x40, 0xff, 0xaa},
2697
	{0x00, 0x41, 0xff, 0xaa},
2698
	{0x00, 0x42, 0xff, 0xaa},
2699
	{0x00, 0x43, 0xff, 0xaa},
2700
	{0x00, 0x03, 0x00, 0xaa},
2701
	{0x00, 0x03, 0x00, 0xaa},
2702
	{0x00, 0x20, 0xc4, 0xaa},
2703
	{0x00, 0x13, 0x03, 0xaa},
2704
	{0x00, 0x3c, 0x50, 0xaa},
2705
	{0x00, 0x61, 0x6a, 0xaa},	/* sharpness? */
2706
	{0x00, 0x51, 0x5b, 0xaa},
2707
	{0x00, 0x52, 0x91, 0xaa},
2708
	{0x00, 0x53, 0x4c, 0xaa},
2709
	{0x00, 0x54, 0x50, 0xaa},
2710
	{0x00, 0x56, 0x02, 0xaa},
2711
	{0xb6, 0x00, 0x00, 0xcc},
2712
	{0xb6, 0x03, 0x03, 0xcc},
2713
	{0xb6, 0x02, 0x20, 0xcc},
2714
	{0xb6, 0x05, 0x02, 0xcc},
2715
	{0xb6, 0x04, 0x58, 0xcc},
2716
	{0xb6, 0x12, 0xf8, 0xcc},
2717
	{0xb6, 0x13, 0x21, 0xcc},
2718
	{0xb6, 0x18, 0x03, 0xcc},
2719
	{0xb6, 0x17, 0xa9, 0xcc},
2720
	{0xb6, 0x16, 0x80, 0xcc},
2721
	{0xb6, 0x22, 0x12, 0xcc},
2722
	{0xb6, 0x23, 0x0b, 0xcc},
2723
	{0xbf, 0xc0, 0x39, 0xcc},
2724
	{0xbf, 0xc1, 0x04, 0xcc},
2725
	{0xbf, 0xcc, 0x00, 0xcc},
2726
	{0xb8, 0x06, 0x20, 0xcc},
2727
	{0xb8, 0x07, 0x03, 0xcc},
2728
	{0xb8, 0x08, 0x58, 0xcc},
2729
	{0xb8, 0x09, 0x02, 0xcc},
2730
	{0xb3, 0x01, 0x41, 0xcc},
2731
	{0x00, 0x03, 0x00, 0xaa},
2732
	{0x00, 0xd9, 0x0f, 0xaa},
2733
	{0x00, 0xda, 0xaa, 0xaa},
2734
	{0x00, 0xd9, 0x10, 0xaa},
2735
	{0x00, 0xda, 0xaa, 0xaa},
2736
	{0x00, 0xd9, 0x11, 0xaa},
2737
	{0x00, 0xda, 0x00, 0xaa},
2738
	{0x00, 0xd9, 0x12, 0xaa},
2739
	{0x00, 0xda, 0xff, 0xaa},
2740
	{0x00, 0xd9, 0x13, 0xaa},
2741
	{0x00, 0xda, 0xff, 0xaa},
2742
	{0x00, 0xe8, 0x11, 0xaa},
2743
	{0x00, 0xe9, 0x12, 0xaa},
2744
	{0x00, 0xea, 0x5c, 0xaa},
2745
	{0x00, 0xeb, 0xff, 0xaa},
2746
	{0x00, 0xd8, 0x80, 0xaa},
2747
	{0x00, 0xe6, 0x02, 0xaa},
2748
	{0x00, 0xd6, 0x40, 0xaa},
2749
	{0x00, 0xe3, 0x05, 0xaa},
2750
	{0x00, 0xe0, 0x40, 0xaa},
2751
	{0x00, 0xde, 0x03, 0xaa},
2752
	{0x00, 0xdf, 0x03, 0xaa},
2753
	{0x00, 0xdb, 0x02, 0xaa},
2754
	{0x00, 0xdc, 0x00, 0xaa},
2755
	{0x00, 0xdd, 0x03, 0xaa},
2756
	{0x00, 0xe1, 0x08, 0xaa},
2757
	{0x00, 0xe2, 0x01, 0xaa},
2758
	{0x00, 0xd6, 0x40, 0xaa},
2759
	{0x00, 0xe4, 0x40, 0xaa},
2760
	{0x00, 0xa8, 0x8f, 0xaa},
2761
	{0x00, 0xb4, 0x16, 0xaa},
2762
	{0xb0, 0x02, 0x06, 0xcc},
2763
	{0xb0, 0x18, 0x06, 0xcc},
2764
	{0xb0, 0x19, 0x06, 0xcc},
2765
	{0xb3, 0x5d, 0x18, 0xcc},
2766
	{0xb3, 0x05, 0x00, 0xcc},
2767
	{0xb3, 0x06, 0x00, 0xcc},
2768
	{0x00, 0xb4, 0x0e, 0xaa},
2769
	{0x00, 0xb5, 0x49, 0xaa},
2770
	{0x00, 0xb6, 0x1c, 0xaa},
2771
	{0x00, 0xb7, 0x96, 0xaa},
2772
/* end of usbvm326.inf - start of ms-win trace */
2773
	{0xb6, 0x12, 0xf8, 0xcc},
2774
	{0xb6, 0x13, 0x3d, 0xcc},
2775
/*read b306*/
2776
	{0x00, 0x03, 0x00, 0xaa},
2777
	{0x00, 0x1a, 0x09, 0xaa},
2778
	{0x00, 0x1b, 0x8a, 0xaa},
2779
/*read b827*/
2780
	{0xb8, 0x27, 0x00, 0xcc},
2781
	{0xb8, 0x26, 0x60, 0xcc},
2782
	{0xb8, 0x26, 0x60, 0xcc},
2783
/*gamma - to do?*/
2784
	{0x00, 0x03, 0x00, 0xaa},
2785
	{0x00, 0xae, 0x84, 0xaa},
2786
/*gamma again*/
2787
	{0x00, 0x03, 0x00, 0xaa},
2788
	{0x00, 0x96, 0xa0, 0xaa},
2789
/*matrix*/
2790
	{0x00, 0x03, 0x00, 0xaa},
2791
	{0x00, 0x91, 0x35, 0xaa},
2792
	{0x00, 0x92, 0x22, 0xaa},
2793
/*gamma*/
2794
	{0x00, 0x03, 0x00, 0xaa},
2795
	{0x00, 0x95, 0x85, 0xaa},
2796
/*matrix*/
2797
	{0x00, 0x03, 0x00, 0xaa},
2798
	{0x00, 0x4d, 0x20, 0xaa},
2799
	{0xb8, 0x22, 0x40, 0xcc},
2800
	{0xb8, 0x23, 0x40, 0xcc},
2801
	{0xb8, 0x24, 0x40, 0xcc},
2802
	{0xb8, 0x81, 0x09, 0xcc},
2803
	{0x00, 0x00, 0x64, 0xdd},
2804
	{0x00, 0x03, 0x01, 0xaa},
2805
/*read 46*/
2806
	{0x00, 0x46, 0x3c, 0xaa},
2807
	{0x00, 0x03, 0x00, 0xaa},
2808
	{0x00, 0x16, 0x40, 0xaa},
2809
	{0x00, 0x17, 0x40, 0xaa},
2810
	{0x00, 0x18, 0x40, 0xaa},
2811
	{0x00, 0x19, 0x41, 0xaa},
2812
	{0x00, 0x03, 0x01, 0xaa},
2813
	{0x00, 0x46, 0x3c, 0xaa},
2814
	{0x00, 0x00, 0x18, 0xdd},
2815
/*read bfff*/
2816
	{0x00, 0x03, 0x00, 0xaa},
2817
	{0x00, 0xb4, 0x1c, 0xaa},
2818
	{0x00, 0xb5, 0x92, 0xaa},
2819
	{0x00, 0xb6, 0x39, 0xaa},
2820
	{0x00, 0xb7, 0x24, 0xaa},
2821
/*write 89 0400 1415*/
2822
	{}
2823
};
2824

2825
static const u8 poxxxx_init_common[][4] = {
2826
	{0xb3, 0x00, 0x04, 0xcc},
2827
	{0x00, 0x00, 0x10, 0xdd},
2828
	{0xb3, 0x00, 0x64, 0xcc},
2829
	{0x00, 0x00, 0x10, 0xdd},
2830
	{0xb3, 0x00, 0x65, 0xcc},
2831
	{0x00, 0x00, 0x10, 0xdd},
2832
	{0xb3, 0x00, 0x67, 0xcc},
2833
	{0xb0, 0x03, 0x09, 0xcc},
2834
	{0xb3, 0x05, 0x00, 0xcc},
2835
	{0xb3, 0x06, 0x00, 0xcc},
2836
	{0xb3, 0x5c, 0x01, 0xcc},
2837
	{0xb3, 0x08, 0x01, 0xcc},
2838
	{0xb3, 0x09, 0x0c, 0xcc},
2839
	{0xb3, 0x34, 0x01, 0xcc},
2840
	{0xb3, 0x35, 0xf6, 0xcc},	/* i2c add: 76 */
2841
	{0xb3, 0x02, 0xb0, 0xcc},
2842
	{0xb3, 0x03, 0x18, 0xcc},
2843
	{0xb3, 0x04, 0x15, 0xcc},
2844
	{0xb3, 0x20, 0x00, 0xcc},
2845
	{0xb3, 0x21, 0x00, 0xcc},
2846
	{0xb3, 0x22, 0x04, 0xcc},	/* sensor height = 1024 */
2847
	{0xb3, 0x23, 0x00, 0xcc},
2848
	{0xb3, 0x14, 0x00, 0xcc},
2849
	{0xb3, 0x15, 0x00, 0xcc},
2850
	{0xb3, 0x16, 0x04, 0xcc},	/* sensor width = 1280 */
2851
	{0xb3, 0x17, 0xff, 0xcc},
2852
	{0xb3, 0x2c, 0x03, 0xcc},
2853
	{0xb3, 0x2d, 0x56, 0xcc},
2854
	{0xb3, 0x2e, 0x02, 0xcc},
2855
	{0xb3, 0x2f, 0x0a, 0xcc},
2856
	{0xb3, 0x40, 0x00, 0xcc},
2857
	{0xb3, 0x41, 0x34, 0xcc},
2858
	{0xb3, 0x42, 0x01, 0xcc},
2859
	{0xb3, 0x43, 0xe0, 0xcc},
2860
	{0xbc, 0x00, 0x71, 0xcc},
2861
	{0xbc, 0x01, 0x01, 0xcc},
2862
	{0xb3, 0x01, 0x41, 0xcc},
2863
	{0xb3, 0x4d, 0x00, 0xcc},
2864
	{0x00, 0x0b, 0x2a, 0xaa},
2865
	{0x00, 0x0e, 0x03, 0xaa},
2866
	{0x00, 0x0f, 0xea, 0xaa},
2867
	{0x00, 0x12, 0x08, 0xaa},
2868
	{0x00, 0x1e, 0x06, 0xaa},
2869
	{0x00, 0x21, 0x00, 0xaa},
2870
	{0x00, 0x31, 0x1f, 0xaa},
2871
	{0x00, 0x33, 0x38, 0xaa},
2872
	{0x00, 0x36, 0xc0, 0xaa},
2873
	{0x00, 0x37, 0xc8, 0xaa},
2874
	{0x00, 0x3b, 0x36, 0xaa},
2875
	{0x00, 0x4b, 0xfe, 0xaa},
2876
	{0x00, 0x4d, 0x2e, 0xaa},
2877
	{0x00, 0x51, 0x1c, 0xaa},
2878
	{0x00, 0x52, 0x01, 0xaa},
2879
	{0x00, 0x55, 0x0a, 0xaa},
2880
	{0x00, 0x56, 0x0a, 0xaa},
2881
	{0x00, 0x57, 0x07, 0xaa},
2882
	{0x00, 0x58, 0x07, 0xaa},
2883
	{0x00, 0x59, 0x04, 0xaa},
2884
	{0x00, 0x70, 0x68, 0xaa},
2885
	{0x00, 0x71, 0x04, 0xaa},
2886
	{0x00, 0x72, 0x10, 0xaa},
2887
	{0x00, 0x80, 0x71, 0xaa},
2888
	{0x00, 0x81, 0x08, 0xaa},
2889
	{0x00, 0x82, 0x00, 0xaa},
2890
	{0x00, 0x83, 0x55, 0xaa},
2891
	{0x00, 0x84, 0x06, 0xaa},
2892
	{0x00, 0x85, 0x06, 0xaa},
2893
	{0x00, 0x8b, 0x25, 0xaa},
2894
	{0x00, 0x8c, 0x00, 0xaa},
2895
	{0x00, 0x8d, 0x86, 0xaa},
2896
	{0x00, 0x8e, 0x82, 0xaa},
2897
	{0x00, 0x8f, 0x2d, 0xaa},
2898
	{0x00, 0x90, 0x8b, 0xaa},
2899
	{0x00, 0x91, 0x81, 0xaa},
2900
	{0x00, 0x92, 0x81, 0xaa},
2901
	{0x00, 0x93, 0x23, 0xaa},
2902
	{0x00, 0xa3, 0x2a, 0xaa},
2903
	{0x00, 0xa4, 0x03, 0xaa},
2904
	{0x00, 0xa5, 0xea, 0xaa},
2905
	{0x00, 0xb0, 0x68, 0xaa},
2906
	{0x00, 0xbc, 0x04, 0xaa},
2907
	{0x00, 0xbe, 0x3b, 0xaa},
2908
	{0x00, 0x4e, 0x40, 0xaa},
2909
	{0x00, 0x06, 0x04, 0xaa},
2910
	{0x00, 0x07, 0x03, 0xaa},
2911
	{0x00, 0xcd, 0x18, 0xaa},
2912
	{0x00, 0x28, 0x03, 0xaa},
2913
	{0x00, 0x29, 0xef, 0xaa},
2914
/* reinit on alt 2 (qvga) or alt7 (vga) */
2915
	{0xb3, 0x05, 0x00, 0xcc},
2916
	{0xb3, 0x06, 0x00, 0xcc},
2917
	{0xb8, 0x00, 0x01, 0xcc},
2918

2919
	{0x00, 0x1d, 0x85, 0xaa},
2920
	{0x00, 0x1e, 0xc6, 0xaa},
2921
	{0x00, 0x00, 0x40, 0xdd},
2922
	{0x00, 0x1d, 0x05, 0xaa},
2923
	{}
2924
};
2925
static const u8 poxxxx_gamma[][4] = {
2926
	{0x00, 0xd6, 0x22, 0xaa},	/* gamma 0 */
2927
	{0x00, 0x73, 0x00, 0xaa},
2928
	{0x00, 0x74, 0x0a, 0xaa},
2929
	{0x00, 0x75, 0x16, 0xaa},
2930
	{0x00, 0x76, 0x25, 0xaa},
2931
	{0x00, 0x77, 0x34, 0xaa},
2932
	{0x00, 0x78, 0x49, 0xaa},
2933
	{0x00, 0x79, 0x5a, 0xaa},
2934
	{0x00, 0x7a, 0x7f, 0xaa},
2935
	{0x00, 0x7b, 0x9b, 0xaa},
2936
	{0x00, 0x7c, 0xba, 0xaa},
2937
	{0x00, 0x7d, 0xd4, 0xaa},
2938
	{0x00, 0x7e, 0xea, 0xaa},
2939

2940
	{0x00, 0xd6, 0x62, 0xaa},	/* gamma 1 */
2941
	{0x00, 0x73, 0x00, 0xaa},
2942
	{0x00, 0x74, 0x0a, 0xaa},
2943
	{0x00, 0x75, 0x16, 0xaa},
2944
	{0x00, 0x76, 0x25, 0xaa},
2945
	{0x00, 0x77, 0x34, 0xaa},
2946
	{0x00, 0x78, 0x49, 0xaa},
2947
	{0x00, 0x79, 0x5a, 0xaa},
2948
	{0x00, 0x7a, 0x7f, 0xaa},
2949
	{0x00, 0x7b, 0x9b, 0xaa},
2950
	{0x00, 0x7c, 0xba, 0xaa},
2951
	{0x00, 0x7d, 0xd4, 0xaa},
2952
	{0x00, 0x7e, 0xea, 0xaa},
2953

2954
	{0x00, 0xd6, 0xa2, 0xaa},	/* gamma 2 */
2955
	{0x00, 0x73, 0x00, 0xaa},
2956
	{0x00, 0x74, 0x0a, 0xaa},
2957
	{0x00, 0x75, 0x16, 0xaa},
2958
	{0x00, 0x76, 0x25, 0xaa},
2959
	{0x00, 0x77, 0x34, 0xaa},
2960
	{0x00, 0x78, 0x49, 0xaa},
2961
	{0x00, 0x79, 0x5a, 0xaa},
2962
	{0x00, 0x7a, 0x7f, 0xaa},
2963
	{0x00, 0x7b, 0x9b, 0xaa},
2964
	{0x00, 0x7c, 0xba, 0xaa},
2965
	{0x00, 0x7d, 0xd4, 0xaa},
2966
	{0x00, 0x7e, 0xea, 0xaa},
2967
	{}
2968
};
2969
static const u8 poxxxx_init_start_3[][4] = {
2970
	{0x00, 0xb8, 0x28, 0xaa},
2971
	{0x00, 0xb9, 0x1e, 0xaa},
2972
	{0x00, 0xb6, 0x14, 0xaa},
2973
	{0x00, 0xb7, 0x0f, 0xaa},
2974
	{0x00, 0x5c, 0x10, 0xaa},
2975
	{0x00, 0x5d, 0x18, 0xaa},
2976
	{0x00, 0x5e, 0x24, 0xaa},
2977
	{0x00, 0x5f, 0x24, 0xaa},
2978
	{0x00, 0x86, 0x1a, 0xaa},
2979
	{0x00, 0x60, 0x00, 0xaa},
2980
	{0x00, 0x61, 0x1b, 0xaa},
2981
	{0x00, 0x62, 0x30, 0xaa},
2982
	{0x00, 0x63, 0x40, 0xaa},
2983
	{0x00, 0x87, 0x1a, 0xaa},
2984
	{0x00, 0x64, 0x00, 0xaa},
2985
	{0x00, 0x65, 0x08, 0xaa},
2986
	{0x00, 0x66, 0x10, 0xaa},
2987
	{0x00, 0x67, 0x20, 0xaa},
2988
	{0x00, 0x88, 0x10, 0xaa},
2989
	{0x00, 0x68, 0x00, 0xaa},
2990
	{0x00, 0x69, 0x08, 0xaa},
2991
	{0x00, 0x6a, 0x0f, 0xaa},
2992
	{0x00, 0x6b, 0x0f, 0xaa},
2993
	{0x00, 0x89, 0x07, 0xaa},
2994
	{0x00, 0xd5, 0x4c, 0xaa},
2995
	{0x00, 0x0a, 0x00, 0xaa},
2996
	{0x00, 0x0b, 0x2a, 0xaa},
2997
	{0x00, 0x0e, 0x03, 0xaa},
2998
	{0x00, 0x0f, 0xea, 0xaa},
2999
	{0x00, 0xa2, 0x00, 0xaa},
3000
	{0x00, 0xa3, 0x2a, 0xaa},
3001
	{0x00, 0xa4, 0x03, 0xaa},
3002
	{0x00, 0xa5, 0xea, 0xaa},
3003
	{}
3004
};
3005
static const u8 poxxxx_initVGA[][4] = {
3006
	{0x00, 0x20, 0x11, 0xaa},
3007
	{0x00, 0x33, 0x38, 0xaa},
3008
	{0x00, 0xbb, 0x0d, 0xaa},
3009
	{0xb3, 0x22, 0x01, 0xcc},	/* change to 640x480 */
3010
	{0xb3, 0x23, 0xe0, 0xcc},
3011
	{0xb3, 0x16, 0x02, 0xcc},
3012
	{0xb3, 0x17, 0x7f, 0xcc},
3013
	{0xb3, 0x02, 0xb0, 0xcc},
3014
	{0xb3, 0x06, 0x00, 0xcc},
3015
	{0xb3, 0x5c, 0x01, 0xcc},
3016
	{0x00, 0x04, 0x06, 0xaa},
3017
	{0x00, 0x05, 0x3f, 0xaa},
3018
	{0x00, 0x04, 0x00, 0xdd},	/* delay 1s */
3019
	{}
3020
};
3021
static const u8 poxxxx_initQVGA[][4] = {
3022
	{0x00, 0x20, 0x33, 0xaa},
3023
	{0x00, 0x33, 0x38, 0xaa},
3024
	{0x00, 0xbb, 0x0d, 0xaa},
3025
	{0xb3, 0x22, 0x00, 0xcc},	/* change to 320x240 */
3026
	{0xb3, 0x23, 0xf0, 0xcc},
3027
	{0xb3, 0x16, 0x01, 0xcc},
3028
	{0xb3, 0x17, 0x3f, 0xcc},
3029
	{0xb3, 0x02, 0xb0, 0xcc},
3030
	{0xb3, 0x06, 0x01, 0xcc},
3031
	{0xb3, 0x5c, 0x00, 0xcc},
3032
	{0x00, 0x04, 0x06, 0xaa},
3033
	{0x00, 0x05, 0x3f, 0xaa},
3034
	{0x00, 0x04, 0x00, 0xdd},	/* delay 1s */
3035
	{}
3036
};
3037
static const u8 poxxxx_init_end_1[][4] = {
3038
	{0x00, 0x47, 0x25, 0xaa},
3039
	{0x00, 0x48, 0x80, 0xaa},
3040
	{0x00, 0x49, 0x1f, 0xaa},
3041
	{0x00, 0x4a, 0x40, 0xaa},
3042
	{0x00, 0x44, 0x40, 0xaa},
3043
	{0x00, 0xab, 0x4a, 0xaa},
3044
	{0x00, 0xb1, 0x00, 0xaa},
3045
	{0x00, 0xb2, 0x04, 0xaa},
3046
	{0x00, 0xb3, 0x08, 0xaa},
3047
	{0x00, 0xb4, 0x0b, 0xaa},
3048
	{0x00, 0xb5, 0x0d, 0xaa},
3049
	{}
3050
};
3051
static const u8 poxxxx_init_end_2[][4] = {
3052
	{0x00, 0x1d, 0x85, 0xaa},
3053
	{0x00, 0x1e, 0x06, 0xaa},
3054
	{0x00, 0x1d, 0x05, 0xaa},
3055
	{}
3056
};
3057

3058
struct sensor_info {
3059
	s8 sensorId;
3060
	u8 I2cAdd;
3061
	u8 IdAdd;
3062
	u16 VpId;
3063
	u8 m1;
3064
	u8 m2;
3065
	u8 op;
3066
};
3067

3068
/* probe values */
3069
static const struct sensor_info vc0321_probe_data[] = {
3070
/*      sensorId,	   I2cAdd,	IdAdd,  VpId,  m1,    m2,  op */
3071
/* 0 OV9640 */
3072
	{-1,		    0x80 | 0x30, 0x0a, 0x0000, 0x25, 0x24, 0x05},
3073
/* 1 ICM108T (may respond on IdAdd == 0x83 - tested in vc032x_probe_sensor) */
3074
	{-1,		    0x80 | 0x20, 0x82, 0x0000, 0x24, 0x25, 0x01},
3075
/* 2 PO2130 (may detect PO3130NC - tested in vc032x_probe_sensor)*/
3076
	{-1,		    0x80 | 0x76, 0x00, 0x0000, 0x24, 0x25, 0x01},
3077
/* 3 MI1310 */
3078
	{-1,		    0x80 | 0x5d, 0x00, 0x0000, 0x24, 0x25, 0x01},
3079
/* 4 MI360 - tested in vc032x_probe_sensor */
3080
/*	{SENSOR_MI0360,	    0x80 | 0x5d, 0x00, 0x8243, 0x24, 0x25, 0x01}, */
3081
/* 5 7131R */
3082
	{SENSOR_HV7131R,    0x80 | 0x11, 0x00, 0x0209, 0x24, 0x25, 0x01},
3083
/* 6 OV7649 */
3084
	{-1,		    0x80 | 0x21, 0x0a, 0x0000, 0x21, 0x20, 0x05},
3085
/* 7 PAS302BCW */
3086
	{-1,		    0x80 | 0x40, 0x00, 0x0000, 0x20, 0x22, 0x05},
3087
/* 8 OV7660 */
3088
	{SENSOR_OV7660,     0x80 | 0x21, 0x0a, 0x7660, 0x26, 0x26, 0x05},
3089
/* 9 PO3130NC - (tested in vc032x_probe_sensor) */
3090
/*	{SENSOR_PO3130NC,   0x80 | 0x76, 0x00, 0x3130, 0x24, 0x25, 0x01}, */
3091
/* 10 PO1030KC */
3092
	{-1,		    0x80 | 0x6e, 0x00, 0x0000, 0x24, 0x25, 0x01},
3093
/* 11 MI1310_SOC */
3094
	{SENSOR_MI1310_SOC, 0x80 | 0x5d, 0x00, 0x143a, 0x24, 0x25, 0x01},
3095
/* 12 OV9650 */
3096
	{-1,		    0x80 | 0x30, 0x0a, 0x0000, 0x25, 0x24, 0x05},
3097
/* 13 S5K532 */
3098
	{-1,		    0x80 | 0x11, 0x39, 0x0000, 0x24, 0x25, 0x01},
3099
/* 14 MI360_SOC - ??? */
3100
/* 15 PO1200N */
3101
	{SENSOR_PO1200,     0x80 | 0x5c, 0x00, 0x1200, 0x67, 0x67, 0x01},
3102
/* 16 PO3030K */
3103
	{-1,		    0x80 | 0x18, 0x00, 0x0000, 0x24, 0x25, 0x01},
3104
/* 17 PO2030 */
3105
	{-1,		    0x80 | 0x6e, 0x00, 0x0000, 0x24, 0x25, 0x01},
3106
/* ?? */
3107
	{-1,		    0x80 | 0x56, 0x01, 0x0000, 0x64, 0x67, 0x01},
3108
	{SENSOR_MI1320,     0x80 | 0x48, 0x00, 0x148c, 0x64, 0x65, 0x01},
3109
};
3110
static const struct sensor_info vc0323_probe_data[] = {
3111
/*      sensorId,	   I2cAdd,	IdAdd,  VpId,  m1,    m2,  op */
3112
/* 0 OV9640 */
3113
	{-1,		    0x80 | 0x30, 0x0a, 0x0000, 0x25, 0x24, 0x05},
3114
/* 1 ICM108T (may respond on IdAdd == 0x83 - tested in vc032x_probe_sensor) */
3115
	{-1,		    0x80 | 0x20, 0x82, 0x0000, 0x24, 0x25, 0x01},
3116
/* 2 PO2130 (may detect PO3130NC - tested in vc032x_probe_sensor)*/
3117
	{-1,		    0x80 | 0x76, 0x00, 0x0000, 0x24, 0x25, 0x01},
3118
/* 3 MI1310 */
3119
	{-1,		    0x80 | 0x5d, 0x00, 0x0000, 0x24, 0x25, 0x01},
3120
/* 4 MI360 - tested in vc032x_probe_sensor */
3121
/*	{SENSOR_MI0360,	    0x80 | 0x5d, 0x00, 0x8243, 0x24, 0x25, 0x01}, */
3122
/* 5 7131R */
3123
	{SENSOR_HV7131R,    0x80 | 0x11, 0x00, 0x0209, 0x24, 0x25, 0x01},
3124
/* 6 OV7649 */
3125
	{-1,		    0x80 | 0x21, 0x0a, 0x0000, 0x21, 0x20, 0x05},
3126
/* 7 PAS302BCW */
3127
	{-1,		    0x80 | 0x40, 0x00, 0x0000, 0x20, 0x22, 0x05},
3128
/* 8 OV7660 */
3129
	{SENSOR_OV7660,     0x80 | 0x21, 0x0a, 0x7660, 0x26, 0x26, 0x05},
3130
/* 9 PO3130NC - (tested in vc032x_probe_sensor) */
3131
/*	{SENSOR_PO3130NC,   0x80 | 0x76, 0x00, 0x3130, 0x24, 0x25, 0x01}, */
3132
/* 10 PO1030KC */
3133
	{-1,		    0x80 | 0x6e, 0x00, 0x0000, 0x24, 0x25, 0x01},
3134
/* 11 MI1310_SOC */
3135
	{SENSOR_MI1310_SOC, 0x80 | 0x5d, 0x00, 0x143a, 0x24, 0x25, 0x01},
3136
/* 12 OV9650 */
3137
	{-1,		    0x80 | 0x30, 0x0a, 0x0000, 0x25, 0x24, 0x05},
3138
/* 13 S5K532 */
3139
	{-1,		    0x80 | 0x11, 0x39, 0x0000, 0x24, 0x25, 0x01},
3140
/* 14 MI360_SOC - ??? */
3141
/* 15 PO1200N */
3142
	{SENSOR_PO1200,     0x80 | 0x5c, 0x00, 0x1200, 0x67, 0x67, 0x01},
3143
/* 16 ?? */
3144
	{-1,		    0x80 | 0x2d, 0x00, 0x0000, 0x65, 0x67, 0x01},
3145
/* 17 PO2030 */
3146
	{-1,		    0x80 | 0x6e, 0x00, 0x0000, 0x24, 0x25, 0x01},
3147
/* ?? */
3148
	{-1,		    0x80 | 0x56, 0x01, 0x0000, 0x64, 0x67, 0x01},
3149
	{SENSOR_MI1320_SOC, 0x80 | 0x48, 0x00, 0x148c, 0x64, 0x67, 0x01},
3150
/*fixme: not in the ms-win probe - may be found before? */
3151
	{SENSOR_OV7670,     0x80 | 0x21, 0x0a, 0x7673, 0x66, 0x67, 0x05},
3152
};
3153

3154
/* read 'len' bytes in gspca_dev->usb_buf */
3155
static void reg_r_i(struct gspca_dev *gspca_dev,
3156
		  u16 req,
3157
		  u16 index,
3158
		  u16 len)
3159
{
3160
	int ret;
3161

3162
	if (gspca_dev->usb_err < 0)
3163
		return;
3164
	ret = usb_control_msg(gspca_dev->dev,
3165
			usb_rcvctrlpipe(gspca_dev->dev, 0),
3166
			req,
3167
			USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
3168
			1,			/* value */
3169
			index, gspca_dev->usb_buf, len,
3170
			500);
3171
	if (ret < 0) {
3172
		err("reg_r err %d", ret);
3173
		gspca_dev->usb_err = ret;
3174
	}
3175
}
3176
static void reg_r(struct gspca_dev *gspca_dev,
3177
		  u16 req,
3178
		  u16 index,
3179
		  u16 len)
3180
{
3181
	reg_r_i(gspca_dev, req, index, len);
3182
#ifdef GSPCA_DEBUG
3183
	if (gspca_dev->usb_err < 0)
3184
		return;
3185
	if (len == 1)
3186
		PDEBUG(D_USBI, "GET %02x 0001 %04x %02x", req, index,
3187
				gspca_dev->usb_buf[0]);
3188
	else
3189
		PDEBUG(D_USBI, "GET %02x 0001 %04x %02x %02x %02x",
3190
				req, index,
3191
				gspca_dev->usb_buf[0],
3192
				gspca_dev->usb_buf[1],
3193
				gspca_dev->usb_buf[2]);
3194
#endif
3195
}
3196

3197
static void reg_w_i(struct gspca_dev *gspca_dev,
3198
			    u16 req,
3199
			    u16 value,
3200
			    u16 index)
3201
{
3202
	int ret;
3203

3204
	if (gspca_dev->usb_err < 0)
3205
		return;
3206
	ret = usb_control_msg(gspca_dev->dev,
3207
			usb_sndctrlpipe(gspca_dev->dev, 0),
3208
			req,
3209
			USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
3210
			value, index, NULL, 0,
3211
			500);
3212
	if (ret < 0) {
3213
		err("reg_w err %d", ret);
3214
		gspca_dev->usb_err = ret;
3215
	}
3216
}
3217
static void reg_w(struct gspca_dev *gspca_dev,
3218
			    u16 req,
3219
			    u16 value,
3220
			    u16 index)
3221
{
3222
#ifdef GSPCA_DEBUG
3223
	if (gspca_dev->usb_err < 0)
3224
		return;
3225
	PDEBUG(D_USBO, "SET %02x %04x %04x", req, value, index);
3226
#endif
3227
	reg_w_i(gspca_dev, req, value, index);
3228
}
3229

3230
static u16 read_sensor_register(struct gspca_dev *gspca_dev,
3231
				u16 address)
3232
{
3233
	u8 ldata, mdata, hdata;
3234
	int retry = 50;
3235

3236
	reg_r(gspca_dev, 0xa1, 0xb33f, 1);
3237
	if (!(gspca_dev->usb_buf[0] & 0x02)) {
3238
		err("I2c Bus Busy Wait %02x",
3239
			gspca_dev->usb_buf[0]);
3240
		return 0;
3241
	}
3242
	reg_w(gspca_dev, 0xa0, address, 0xb33a);
3243
	reg_w(gspca_dev, 0xa0, 0x02, 0xb339);
3244

3245
	do {
3246
		reg_r(gspca_dev, 0xa1, 0xb33b, 1);
3247
		if (gspca_dev->usb_buf[0] == 0x00)
3248
			break;
3249
		msleep(40);
3250
	} while (--retry >= 0);
3251

3252
	reg_r(gspca_dev, 0xa1, 0xb33e, 1);
3253
	ldata = gspca_dev->usb_buf[0];
3254
	reg_r(gspca_dev, 0xa1, 0xb33d, 1);
3255
	mdata = gspca_dev->usb_buf[0];
3256
	reg_r(gspca_dev, 0xa1, 0xb33c, 1);
3257
	hdata = gspca_dev->usb_buf[0];
3258
	if (hdata != 0 && mdata != 0 && ldata != 0)
3259
		PDEBUG(D_PROBE, "Read Sensor %02x%02x %02x",
3260
			hdata, mdata, ldata);
3261
	reg_r(gspca_dev, 0xa1, 0xb334, 1);
3262
	if (gspca_dev->usb_buf[0] == 0x02)
3263
		return (hdata << 8) + mdata;
3264
	return hdata;
3265
}
3266

3267
static int vc032x_probe_sensor(struct gspca_dev *gspca_dev)
3268
{
3269
	struct sd *sd = (struct sd *) gspca_dev;
3270
	int i, n;
3271
	u16 value;
3272
	const struct sensor_info *ptsensor_info;
3273

3274
/*fixme: should also check the other sensor (back mi1320_soc, front mc501cb)*/
3275
	if (sd->flags & FL_SAMSUNG) {
3276
		reg_w(gspca_dev, 0xa0, 0x01, 0xb301);
3277
		reg_w(gspca_dev, 0x89, 0xf0ff, 0xffff);
3278
						/* select the back sensor */
3279
	}
3280

3281
	reg_r(gspca_dev, 0xa1, 0xbfcf, 1);
3282
	PDEBUG(D_PROBE, "vc032%d check sensor header %02x",
3283
		sd->bridge == BRIDGE_VC0321 ? 1 : 3, gspca_dev->usb_buf[0]);
3284
	if (sd->bridge == BRIDGE_VC0321) {
3285
		ptsensor_info = vc0321_probe_data;
3286
		n = ARRAY_SIZE(vc0321_probe_data);
3287
	} else {
3288
		ptsensor_info = vc0323_probe_data;
3289
		n = ARRAY_SIZE(vc0323_probe_data);
3290
	}
3291
	for (i = 0; i < n; i++) {
3292
		reg_w(gspca_dev, 0xa0, 0x02, 0xb334);
3293
		reg_w(gspca_dev, 0xa0, ptsensor_info->m1, 0xb300);
3294
		reg_w(gspca_dev, 0xa0, ptsensor_info->m2, 0xb300);
3295
		reg_w(gspca_dev, 0xa0, 0x01, 0xb308);
3296
		reg_w(gspca_dev, 0xa0, 0x0c, 0xb309);
3297
		reg_w(gspca_dev, 0xa0, ptsensor_info->I2cAdd, 0xb335);
3298
		reg_w(gspca_dev, 0xa0, ptsensor_info->op, 0xb301);
3299
		value = read_sensor_register(gspca_dev, ptsensor_info->IdAdd);
3300
		if (value == 0 && ptsensor_info->IdAdd == 0x82)
3301
			value = read_sensor_register(gspca_dev, 0x83);
3302
		if (value != 0) {
3303
			PDEBUG(D_ERR|D_PROBE, "Sensor ID %04x (%d)",
3304
				value, i);
3305
			if (value == ptsensor_info->VpId)
3306
				return ptsensor_info->sensorId;
3307

3308
			switch (value) {
3309
			case 0x3130:
3310
				return SENSOR_PO3130NC;
3311
			case 0x7673:
3312
				return SENSOR_OV7670;
3313
			case 0x8243:
3314
				return SENSOR_MI0360;
3315
			}
3316
		}
3317
		ptsensor_info++;
3318
	}
3319
	return -1;
3320
}
3321

3322
static void i2c_write(struct gspca_dev *gspca_dev,
3323
			u8 reg, const u8 *val,
3324
			u8 size)		/* 1 or 2 */
3325
{
3326
	int retry;
3327

3328
#ifdef GSPCA_DEBUG
3329
	if (gspca_dev->usb_err < 0)
3330
		return;
3331
	if (size == 1)
3332
		PDEBUG(D_USBO, "i2c_w %02x %02x", reg, *val);
3333
	else
3334
		PDEBUG(D_USBO, "i2c_w %02x %02x%02x", reg, *val, val[1]);
3335
#endif
3336
	reg_r_i(gspca_dev, 0xa1, 0xb33f, 1);
3337
/*fixme:should check if (!(gspca_dev->usb_buf[0] & 0x02)) error*/
3338
	reg_w_i(gspca_dev, 0xa0, size, 0xb334);
3339
	reg_w_i(gspca_dev, 0xa0, reg, 0xb33a);
3340
	reg_w_i(gspca_dev, 0xa0, val[0], 0xb336);
3341
	if (size > 1)
3342
		reg_w_i(gspca_dev, 0xa0, val[1], 0xb337);
3343
	reg_w_i(gspca_dev, 0xa0, 0x01, 0xb339);
3344
	retry = 4;
3345
	do {
3346
		reg_r_i(gspca_dev, 0xa1, 0xb33b, 1);
3347
		if (gspca_dev->usb_buf[0] == 0)
3348
			break;
3349
		msleep(20);
3350
	} while (--retry > 0);
3351
	if (retry <= 0)
3352
		err("i2c_write timeout");
3353
}
3354

3355
static void put_tab_to_reg(struct gspca_dev *gspca_dev,
3356
			const u8 *tab, u8 tabsize, u16 addr)
3357
{
3358
	int j;
3359
	u16 ad = addr;
3360

3361
	for (j = 0; j < tabsize; j++)
3362
		reg_w(gspca_dev, 0xa0, tab[j], ad++);
3363
}
3364

3365
static void usb_exchange(struct gspca_dev *gspca_dev,
3366
			const u8 data[][4])
3367
{
3368
	int i = 0;
3369

3370
	for (;;) {
3371
		switch (data[i][3]) {
3372
		default:
3373
			return;
3374
		case 0xcc:			/* normal write */
3375
			reg_w(gspca_dev, 0xa0, data[i][2],
3376
					(data[i][0]) << 8 | data[i][1]);
3377
			break;
3378
		case 0xaa:			/* i2c op */
3379
			i2c_write(gspca_dev, data[i][1], &data[i][2], 1);
3380
			break;
3381
		case 0xbb:			/* i2c op */
3382
			i2c_write(gspca_dev, data[i][0], &data[i][1], 2);
3383
			break;
3384
		case 0xdd:
3385
			msleep(data[i][1] * 256 + data[i][2] + 10);
3386
			break;
3387
		}
3388
		i++;
3389
	}
3390
	/*not reached*/
3391
}
3392

3393

3394
/* this function is called at probe time */
3395
static int sd_config(struct gspca_dev *gspca_dev,
3396
			const struct usb_device_id *id)
3397
{
3398
	struct sd *sd = (struct sd *) gspca_dev;
3399

3400
	sd->bridge = id->driver_info >> 8;
3401
	sd->flags = id->driver_info & 0xff;
3402

3403
	if (id->idVendor == 0x046d &&
3404
	    (id->idProduct == 0x0892 || id->idProduct == 0x0896))
3405
		sd->sensor = SENSOR_POxxxx;	/* no probe */
3406

3407
	sd->brightness = BRIGHTNESS_DEF;
3408
	sd->contrast = CONTRAST_DEF;
3409
	sd->colors = COLOR_DEF;
3410
	sd->hflip = HFLIP_DEF;
3411
	sd->vflip = VFLIP_DEF;
3412
	sd->lightfreq = FREQ_DEF;
3413
	sd->sharpness = SHARPNESS_DEF;
3414
	sd->gain = GAIN_DEF;
3415
	sd->exposure = EXPOSURE_DEF;
3416
	sd->autogain = AUTOGAIN_DEF;
3417
	sd->backlight = BACKLIGHT_DEF;
3418

3419
	return 0;
3420
}
3421

3422
/* this function is called at probe and resume time */
3423
static int sd_init(struct gspca_dev *gspca_dev)
3424
{
3425
	struct sd *sd = (struct sd *) gspca_dev;
3426
	struct cam *cam;
3427
	int sensor;
3428
	/* number of packets per ISOC message */
3429
	static u8 npkt[NSENSORS] = {
3430
		[SENSOR_HV7131R] =	64,
3431
		[SENSOR_MI0360] =	32,
3432
		[SENSOR_MI1310_SOC] =	32,
3433
		[SENSOR_MI1320] =	64,
3434
		[SENSOR_MI1320_SOC] =	128,
3435
		[SENSOR_OV7660] =	32,
3436
		[SENSOR_OV7670] =	64,
3437
		[SENSOR_PO1200] =	128,
3438
		[SENSOR_PO3130NC] =	128,
3439
		[SENSOR_POxxxx] =	128,
3440
	};
3441

3442
	if (sd->sensor != SENSOR_POxxxx)
3443
		sensor = vc032x_probe_sensor(gspca_dev);
3444
	else
3445
		sensor = sd->sensor;
3446

3447
	switch (sensor) {
3448
	case -1:
3449
		err("Unknown sensor...");
3450
		return -EINVAL;
3451
	case SENSOR_HV7131R:
3452
		PDEBUG(D_PROBE, "Find Sensor HV7131R");
3453
		break;
3454
	case SENSOR_MI0360:
3455
		PDEBUG(D_PROBE, "Find Sensor MI0360");
3456
		sd->bridge = BRIDGE_VC0323;
3457
		break;
3458
	case SENSOR_MI1310_SOC:
3459
		PDEBUG(D_PROBE, "Find Sensor MI1310_SOC");
3460
		break;
3461
	case SENSOR_MI1320:
3462
		PDEBUG(D_PROBE, "Find Sensor MI1320");
3463
		break;
3464
	case SENSOR_MI1320_SOC:
3465
		PDEBUG(D_PROBE, "Find Sensor MI1320_SOC");
3466
		break;
3467
	case SENSOR_OV7660:
3468
		PDEBUG(D_PROBE, "Find Sensor OV7660");
3469
		break;
3470
	case SENSOR_OV7670:
3471
		PDEBUG(D_PROBE, "Find Sensor OV7670");
3472
		break;
3473
	case SENSOR_PO1200:
3474
		PDEBUG(D_PROBE, "Find Sensor PO1200");
3475
		break;
3476
	case SENSOR_PO3130NC:
3477
		PDEBUG(D_PROBE, "Find Sensor PO3130NC");
3478
		break;
3479
	case SENSOR_POxxxx:
3480
		PDEBUG(D_PROBE, "Sensor POxxxx");
3481
		break;
3482
	}
3483
	sd->sensor = sensor;
3484

3485
	cam = &gspca_dev->cam;
3486
	if (sd->bridge == BRIDGE_VC0321) {
3487
		cam->cam_mode = vc0321_mode;
3488
		cam->nmodes = ARRAY_SIZE(vc0321_mode);
3489
	} else {
3490
		switch (sensor) {
3491
		case SENSOR_PO1200:
3492
			cam->cam_mode = svga_mode;
3493
			cam->nmodes = ARRAY_SIZE(svga_mode);
3494
			break;
3495
		case SENSOR_MI1310_SOC:
3496
			cam->cam_mode = vc0323_mode;
3497
			cam->nmodes = ARRAY_SIZE(vc0323_mode);
3498
			break;
3499
		case SENSOR_MI1320_SOC:
3500
			cam->cam_mode = bi_mode;
3501
			cam->nmodes = ARRAY_SIZE(bi_mode);
3502
			break;
3503
		case SENSOR_OV7670:
3504
			cam->cam_mode = bi_mode;
3505
			cam->nmodes = ARRAY_SIZE(bi_mode) - 1;
3506
			break;
3507
		default:
3508
			cam->cam_mode = vc0323_mode;
3509
			cam->nmodes = ARRAY_SIZE(vc0323_mode) - 1;
3510
			break;
3511
		}
3512
	}
3513
	cam->npkt = npkt[sd->sensor];
3514
	gspca_dev->ctrl_dis = ctrl_dis[sd->sensor];
3515

3516
	if (sd->sensor == SENSOR_OV7670)
3517
		sd->flags |= FL_HFLIP | FL_VFLIP;
3518

3519
	if (sd->bridge == BRIDGE_VC0321) {
3520
		reg_r(gspca_dev, 0x8a, 0, 3);
3521
		reg_w(gspca_dev, 0x87, 0x00, 0x0f0f);
3522
		reg_r(gspca_dev, 0x8b, 0, 3);
3523
		reg_w(gspca_dev, 0x88, 0x00, 0x0202);
3524
		if (sd->sensor == SENSOR_POxxxx) {
3525
			reg_r(gspca_dev, 0xa1, 0xb300, 1);
3526
			if (gspca_dev->usb_buf[0] != 0) {
3527
				reg_w(gspca_dev, 0xa0, 0x26, 0xb300);
3528
				reg_w(gspca_dev, 0xa0, 0x04, 0xb300);
3529
			}
3530
			reg_w(gspca_dev, 0xa0, 0x00, 0xb300);
3531
		}
3532
	}
3533
	return gspca_dev->usb_err;
3534
}
3535

3536
static void setbrightness(struct gspca_dev *gspca_dev)
3537
{
3538
	struct sd *sd = (struct sd *) gspca_dev;
3539
	u8 data;
3540

3541
	if (gspca_dev->ctrl_dis & (1 << BRIGHTNESS_IDX))
3542
		return;
3543
	data = sd->brightness;
3544
	if (data >= 0x80)
3545
		data &= 0x7f;
3546
	else
3547
		data = 0xff ^ data;
3548
	i2c_write(gspca_dev, 0x98, &data, 1);
3549
}
3550

3551
static void setcontrast(struct gspca_dev *gspca_dev)
3552
{
3553
	struct sd *sd = (struct sd *) gspca_dev;
3554

3555
	if (gspca_dev->ctrl_dis & (1 << CONTRAST_IDX))
3556
		return;
3557
	i2c_write(gspca_dev, 0x99, &sd->contrast, 1);
3558
}
3559

3560
static void setcolors(struct gspca_dev *gspca_dev)
3561
{
3562
	struct sd *sd = (struct sd *) gspca_dev;
3563
	u8 data;
3564

3565
	if (gspca_dev->ctrl_dis & (1 << COLORS_IDX))
3566
		return;
3567
	data = sd->colors - (sd->colors >> 3) - 1;
3568
	i2c_write(gspca_dev, 0x94, &data, 1);
3569
	i2c_write(gspca_dev, 0x95, &sd->colors, 1);
3570
}
3571

3572
static void sethvflip(struct gspca_dev *gspca_dev)
3573
{
3574
	struct sd *sd = (struct sd *) gspca_dev;
3575
	u8 data[2], hflip, vflip;
3576

3577
	hflip = sd->hflip;
3578
	if (sd->flags & FL_HFLIP)
3579
		hflip = !hflip;
3580
	vflip = sd->vflip;
3581
	if (sd->flags & FL_VFLIP)
3582
		vflip = !vflip;
3583
	switch (sd->sensor) {
3584
	case SENSOR_MI1310_SOC:
3585
	case SENSOR_MI1320:
3586
	case SENSOR_MI1320_SOC:
3587
		data[0] = data[1] = 0;		/* select page 0 */
3588
		i2c_write(gspca_dev, 0xf0, data, 2);
3589
		data[0] = sd->sensor == SENSOR_MI1310_SOC ? 0x03 : 0x01;
3590
		data[1] = 0x02 * hflip
3591
			| 0x01 * vflip;
3592
		i2c_write(gspca_dev, 0x20, data, 2);
3593
		break;
3594
	case SENSOR_OV7660:
3595
	case SENSOR_OV7670:
3596
		data[0] = sd->sensor == SENSOR_OV7660 ? 0x01 : 0x07;
3597
		data[0] |= OV7660_MVFP_MIRROR * hflip
3598
			| OV7660_MVFP_VFLIP * vflip;
3599
		i2c_write(gspca_dev, OV7660_REG_MVFP, data, 1);
3600
		break;
3601
	case SENSOR_PO1200:
3602
		data[0] = 0;
3603
		i2c_write(gspca_dev, 0x03, data, 1);
3604
		data[0] = 0x80 * hflip
3605
			| 0x40 * vflip
3606
			| 0x06;
3607
		i2c_write(gspca_dev, 0x1e, data, 1);
3608
		break;
3609
	}
3610
}
3611

3612
static void setlightfreq(struct gspca_dev *gspca_dev)
3613
{
3614
	struct sd *sd = (struct sd *) gspca_dev;
3615
	static const u8 (*ov7660_freq_tb[3])[4] =
3616
		{ov7660_NoFliker, ov7660_50HZ, ov7660_60HZ};
3617

3618
	if (sd->sensor != SENSOR_OV7660)
3619
		return;
3620
	usb_exchange(gspca_dev, ov7660_freq_tb[sd->lightfreq]);
3621
}
3622

3623
static void setsharpness(struct gspca_dev *gspca_dev)
3624
{
3625
	struct sd *sd = (struct sd *) gspca_dev;
3626
	u8 data;
3627

3628
	switch (sd->sensor) {
3629
	case SENSOR_PO1200:
3630
		data = 0;
3631
		i2c_write(gspca_dev, 0x03, &data, 1);
3632
		if (sd->sharpness < 0)
3633
			data = 0x6a;
3634
		else
3635
			data = 0xb5 + sd->sharpness * 3;
3636
		i2c_write(gspca_dev, 0x61, &data, 1);
3637
		break;
3638
	case SENSOR_POxxxx:
3639
		if (sd->sharpness < 0)
3640
			data = 0x7e;	/* def = max */
3641
		else
3642
			data = 0x60 + sd->sharpness * 0x0f;
3643
		i2c_write(gspca_dev, 0x59, &data, 1);
3644
		break;
3645
	}
3646
}
3647
static void setgain(struct gspca_dev *gspca_dev)
3648
{
3649
	struct sd *sd = (struct sd *) gspca_dev;
3650

3651
	if (gspca_dev->ctrl_dis & (1 << GAIN_IDX))
3652
		return;
3653
	i2c_write(gspca_dev, 0x15, &sd->gain, 1);
3654
}
3655

3656
static void setexposure(struct gspca_dev *gspca_dev)
3657
{
3658
	struct sd *sd = (struct sd *) gspca_dev;
3659
	u8 data;
3660

3661
	if (gspca_dev->ctrl_dis & (1 << EXPOSURE_IDX))
3662
		return;
3663
	data = sd->exposure >> 8;
3664
	i2c_write(gspca_dev, 0x1a, &data, 1);
3665
	data = sd->exposure;
3666
	i2c_write(gspca_dev, 0x1b, &data, 1);
3667
}
3668

3669
static void setautogain(struct gspca_dev *gspca_dev)
3670
{
3671
	struct sd *sd = (struct sd *) gspca_dev;
3672
	static const u8 data[2] = {0x28, 0x3c};
3673

3674
	if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
3675
		return;
3676
	i2c_write(gspca_dev, 0xd1, &data[sd->autogain], 1);
3677
}
3678

3679
static void setgamma(struct gspca_dev *gspca_dev)
3680
{
3681
/*fixme:to do */
3682
	usb_exchange(gspca_dev, poxxxx_gamma);
3683
}
3684

3685
static void setbacklight(struct gspca_dev *gspca_dev)
3686
{
3687
	struct sd *sd = (struct sd *) gspca_dev;
3688
	u16 v;
3689
	u8 data;
3690

3691
	data = (sd->backlight << 4) | 0x0f;
3692
	i2c_write(gspca_dev, 0xaa, &data, 1);
3693
	v = 613 + 12 * sd->backlight;
3694
	data = v >> 8;
3695
	i2c_write(gspca_dev, 0xc4, &data, 1);
3696
	data = v;
3697
	i2c_write(gspca_dev, 0xc5, &data, 1);
3698
	v = 1093 - 12 * sd->backlight;
3699
	data = v >> 8;
3700
	i2c_write(gspca_dev, 0xc6, &data, 1);
3701
	data = v;
3702
	i2c_write(gspca_dev, 0xc7, &data, 1);
3703
	v = 342 + 9 * sd->backlight;
3704
	data = v >> 8;
3705
	i2c_write(gspca_dev, 0xc8, &data, 1);
3706
	data = v;
3707
	i2c_write(gspca_dev, 0xc9, &data, 1);
3708
	v = 702 - 9 * sd->backlight;
3709
	data = v >> 8;
3710
	i2c_write(gspca_dev, 0xca, &data, 1);
3711
	data = v;
3712
	i2c_write(gspca_dev, 0xcb, &data, 1);
3713
}
3714

3715
static void setwb(struct gspca_dev *gspca_dev)
3716
{
3717
/*fixme:to do - valid when reg d1 = 0x1c - (reg16 + reg15 = 0xa3)*/
3718
	static const u8 data[2] = {0x00, 0x00};
3719

3720
	i2c_write(gspca_dev, 0x16, &data[0], 1);
3721
	i2c_write(gspca_dev, 0x18, &data[1], 1);
3722
}
3723

3724
static int sd_start(struct gspca_dev *gspca_dev)
3725
{
3726
	struct sd *sd = (struct sd *) gspca_dev;
3727
	const u8 (*init)[4];
3728
	const u8 *GammaT = NULL;
3729
	const u8 *MatrixT = NULL;
3730
	int mode;
3731
	static const u8 (*mi1320_soc_init[])[4] = {
3732
		mi1320_soc_InitSXGA,
3733
		mi1320_soc_InitVGA,
3734
		mi1320_soc_InitQVGA,
3735
	};
3736

3737
/*fixme: back sensor only*/
3738
	if (sd->flags & FL_SAMSUNG) {
3739
		reg_w(gspca_dev, 0x89, 0xf0ff, 0xffff);
3740
		reg_w(gspca_dev, 0xa9, 0x8348, 0x000e);
3741
		reg_w(gspca_dev, 0xa9, 0x0000, 0x001a);
3742
	}
3743

3744
	/* Assume start use the good resolution from gspca_dev->mode */
3745
	if (sd->bridge == BRIDGE_VC0321) {
3746
		reg_w(gspca_dev, 0xa0, 0xff, 0xbfec);
3747
		reg_w(gspca_dev, 0xa0, 0xff, 0xbfed);
3748
		reg_w(gspca_dev, 0xa0, 0xff, 0xbfee);
3749
		reg_w(gspca_dev, 0xa0, 0xff, 0xbfef);
3750
		sd->image_offset = 46;
3751
	} else {
3752
		if (gspca_dev->cam.cam_mode[gspca_dev->curr_mode].pixelformat
3753
				== V4L2_PIX_FMT_JPEG)
3754
			sd->image_offset = 0;
3755
		else
3756
			sd->image_offset = 32;
3757
	}
3758

3759
	mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
3760
	switch (sd->sensor) {
3761
	case SENSOR_HV7131R:
3762
		GammaT = hv7131r_gamma;
3763
		MatrixT = hv7131r_matrix;
3764
		if (mode)
3765
			init = hv7131r_initQVGA_data;	/* 320x240 */
3766
		else
3767
			init = hv7131r_initVGA_data;	/* 640x480 */
3768
		break;
3769
	case SENSOR_OV7660:
3770
		GammaT = ov7660_gamma;
3771
		MatrixT = ov7660_matrix;
3772
		if (mode)
3773
			init = ov7660_initQVGA_data;	/* 320x240 */
3774
		else
3775
			init = ov7660_initVGA_data;	/* 640x480 */
3776
		break;
3777
	case SENSOR_MI0360:
3778
		GammaT = mi1320_gamma;
3779
		MatrixT = mi0360_matrix;
3780
		if (mode)
3781
			init = mi0360_initQVGA_JPG;	/* 320x240 */
3782
		else
3783
			init = mi0360_initVGA_JPG;	/* 640x480 */
3784
		break;
3785
	case SENSOR_MI1310_SOC:
3786
		GammaT = mi1320_gamma;
3787
		MatrixT = mi1320_matrix;
3788
		switch (mode) {
3789
		case 1:
3790
			init = mi1310_socinitQVGA_JPG;	/* 320x240 */
3791
			break;
3792
		case 0:
3793
			init = mi1310_socinitVGA_JPG;	/* 640x480 */
3794
			break;
3795
		default:
3796
			init = mi1310_soc_InitSXGA_JPG;	/* 1280x1024 */
3797
			break;
3798
		}
3799
		break;
3800
	case SENSOR_MI1320:
3801
		GammaT = mi1320_gamma;
3802
		MatrixT = mi1320_matrix;
3803
		if (mode)
3804
			init = mi1320_initQVGA_data;	/* 320x240 */
3805
		else
3806
			init = mi1320_initVGA_data;	/* 640x480 */
3807
		break;
3808
	case SENSOR_MI1320_SOC:
3809
		GammaT = mi1320_gamma;
3810
		MatrixT = mi1320_matrix;
3811
		init = mi1320_soc_init[mode];
3812
		break;
3813
	case SENSOR_OV7670:
3814
		init = mode == 1 ? ov7670_InitVGA : ov7670_InitQVGA;
3815
		break;
3816
	case SENSOR_PO3130NC:
3817
		GammaT = po3130_gamma;
3818
		MatrixT = po3130_matrix;
3819
		if (mode)
3820
			init = po3130_initQVGA_data;	/* 320x240 */
3821
		else
3822
			init = po3130_initVGA_data;	/* 640x480 */
3823
		usb_exchange(gspca_dev, init);
3824
		init = po3130_rundata;
3825
		break;
3826
	case SENSOR_PO1200:
3827
		GammaT = po1200_gamma;
3828
		MatrixT = po1200_matrix;
3829
		init = po1200_initVGA_data;
3830
		break;
3831
	default:
3832
/*	case SENSOR_POxxxx: */
3833
		usb_exchange(gspca_dev, poxxxx_init_common);
3834
		setgamma(gspca_dev);
3835
		setbacklight(gspca_dev);
3836
		setbrightness(gspca_dev);
3837
		setcontrast(gspca_dev);
3838
		setcolors(gspca_dev);
3839
		setsharpness(gspca_dev);
3840
		setautogain(gspca_dev);
3841
		setexposure(gspca_dev);
3842
		setgain(gspca_dev);
3843
		usb_exchange(gspca_dev, poxxxx_init_start_3);
3844
		if (mode)
3845
			init = poxxxx_initQVGA;
3846
		else
3847
			init = poxxxx_initVGA;
3848
		usb_exchange(gspca_dev, init);
3849
		reg_r(gspca_dev, 0x8c, 0x0000, 3);
3850
		reg_w(gspca_dev, 0xa0,
3851
				gspca_dev->usb_buf[2] & 1 ? 0 : 1,
3852
				0xb35c);
3853
		msleep(300);
3854
/*fixme: i2c read 04 and 05*/
3855
		init = poxxxx_init_end_1;
3856
		break;
3857
	}
3858
	usb_exchange(gspca_dev, init);
3859
	if (GammaT && MatrixT) {
3860
		put_tab_to_reg(gspca_dev, GammaT, 17, 0xb84a);
3861
		put_tab_to_reg(gspca_dev, GammaT, 17, 0xb85b);
3862
		put_tab_to_reg(gspca_dev, GammaT, 17, 0xb86c);
3863
		put_tab_to_reg(gspca_dev, MatrixT, 9, 0xb82c);
3864

3865
		switch (sd->sensor) {
3866
		case SENSOR_PO1200:
3867
		case SENSOR_HV7131R:
3868
			reg_w(gspca_dev, 0x89, 0x0400, 0x1415);
3869
			break;
3870
		case SENSOR_MI1310_SOC:
3871
			reg_w(gspca_dev, 0x89, 0x058c, 0x0000);
3872
			break;
3873
		}
3874
		msleep(100);
3875
		sethvflip(gspca_dev);
3876
		setlightfreq(gspca_dev);
3877
	}
3878
	switch (sd->sensor) {
3879
	case SENSOR_OV7670:
3880
		reg_w(gspca_dev, 0x87, 0xffff, 0xffff);
3881
		reg_w(gspca_dev, 0x88, 0xff00, 0xf0f1);
3882
		reg_w(gspca_dev, 0xa0, 0x0000, 0xbfff);
3883
		break;
3884
	case SENSOR_POxxxx:
3885
		usb_exchange(gspca_dev, poxxxx_init_end_2);
3886
		setwb(gspca_dev);
3887
		msleep(80);		/* led on */
3888
		reg_w(gspca_dev, 0x89, 0xffff, 0xfdff);
3889
		break;
3890
	}
3891
	return gspca_dev->usb_err;
3892
}
3893

3894
static void sd_stopN(struct gspca_dev *gspca_dev)
3895
{
3896
	struct sd *sd = (struct sd *) gspca_dev;
3897

3898
	switch (sd->sensor) {
3899
	case SENSOR_MI1310_SOC:
3900
		reg_w(gspca_dev, 0x89, 0x058c, 0x00ff);
3901
		break;
3902
	case SENSOR_POxxxx:
3903
		return;
3904
	default:
3905
		if (!(sd->flags & FL_SAMSUNG))
3906
			reg_w(gspca_dev, 0x89, 0xffff, 0xffff);
3907
		break;
3908
	}
3909
	reg_w(gspca_dev, 0xa0, 0x01, 0xb301);
3910
	reg_w(gspca_dev, 0xa0, 0x09, 0xb003);
3911
}
3912

3913
/* called on streamoff with alt 0 and on disconnect */
3914
static void sd_stop0(struct gspca_dev *gspca_dev)
3915
{
3916
	struct sd *sd = (struct sd *) gspca_dev;
3917

3918
	if (!gspca_dev->present)
3919
		return;
3920
/*fixme: is this useful?*/
3921
	if (sd->sensor == SENSOR_MI1310_SOC)
3922
		reg_w(gspca_dev, 0x89, 0x058c, 0x00ff);
3923
	else if (!(sd->flags & FL_SAMSUNG))
3924
		reg_w(gspca_dev, 0x89, 0xffff, 0xffff);
3925

3926
	if (sd->sensor == SENSOR_POxxxx) {
3927
		reg_w(gspca_dev, 0xa0, 0x26, 0xb300);
3928
		reg_w(gspca_dev, 0xa0, 0x04, 0xb300);
3929
		reg_w(gspca_dev, 0xa0, 0x00, 0xb300);
3930
	}
3931
}
3932

3933
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
3934
			u8 *data,			/* isoc packet */
3935
			int len)			/* iso pkt length */
3936
{
3937
	struct sd *sd = (struct sd *) gspca_dev;
3938

3939
	if (data[0] == 0xff && data[1] == 0xd8) {
3940
		PDEBUG(D_PACK,
3941
			"vc032x header packet found len %d", len);
3942
		gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
3943
		data += sd->image_offset;
3944
		len -= sd->image_offset;
3945
		gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
3946
		return;
3947
	}
3948

3949
	/* The vc0321 sends some additional data after sending the complete
3950
	 * frame, we ignore this. */
3951
	if (sd->bridge == BRIDGE_VC0321) {
3952
		int size, l;
3953

3954
		l = gspca_dev->image_len;
3955
		size = gspca_dev->frsz;
3956
		if (len > size - l)
3957
			len = size - l;
3958
	}
3959
	gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
3960
}
3961

3962
static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
3963
{
3964
	struct sd *sd = (struct sd *) gspca_dev;
3965

3966
	sd->brightness = val;
3967
	if (gspca_dev->streaming)
3968
		setbrightness(gspca_dev);
3969
	return gspca_dev->usb_err;
3970
}
3971

3972
static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
3973
{
3974
	struct sd *sd = (struct sd *) gspca_dev;
3975

3976
	*val = sd->brightness;
3977
	return 0;
3978
}
3979

3980
static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
3981
{
3982
	struct sd *sd = (struct sd *) gspca_dev;
3983

3984
	sd->contrast = val;
3985
	if (gspca_dev->streaming)
3986
		setcontrast(gspca_dev);
3987
	return gspca_dev->usb_err;
3988
}
3989

3990
static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
3991
{
3992
	struct sd *sd = (struct sd *) gspca_dev;
3993

3994
	*val = sd->contrast;
3995
	return 0;
3996
}
3997

3998
static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
3999
{
4000
	struct sd *sd = (struct sd *) gspca_dev;
4001

4002
	sd->colors = val;
4003
	if (gspca_dev->streaming)
4004
		setcolors(gspca_dev);
4005
	return gspca_dev->usb_err;
4006
}
4007

4008
static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
4009
{
4010
	struct sd *sd = (struct sd *) gspca_dev;
4011

4012
	*val = sd->colors;
4013
	return 0;
4014
}
4015

4016
static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
4017
{
4018
	struct sd *sd = (struct sd *) gspca_dev;
4019

4020
	sd->hflip = val;
4021
	if (gspca_dev->streaming)
4022
		sethvflip(gspca_dev);
4023
	return gspca_dev->usb_err;
4024
}
4025

4026
static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
4027
{
4028
	struct sd *sd = (struct sd *) gspca_dev;
4029

4030
	*val = sd->hflip;
4031
	return 0;
4032
}
4033

4034
static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
4035
{
4036
	struct sd *sd = (struct sd *) gspca_dev;
4037

4038
	sd->vflip = val;
4039
	if (gspca_dev->streaming)
4040
		sethvflip(gspca_dev);
4041
	return gspca_dev->usb_err;
4042
}
4043

4044
static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
4045
{
4046
	struct sd *sd = (struct sd *) gspca_dev;
4047

4048
	*val = sd->vflip;
4049
	return 0;
4050
}
4051

4052
static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
4053
{
4054
	struct sd *sd = (struct sd *) gspca_dev;
4055

4056
	sd->lightfreq = val;
4057
	if (gspca_dev->streaming)
4058
		setlightfreq(gspca_dev);
4059
	return gspca_dev->usb_err;
4060
}
4061

4062
static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
4063
{
4064
	struct sd *sd = (struct sd *) gspca_dev;
4065

4066
	*val = sd->lightfreq;
4067
	return 0;
4068
}
4069

4070
static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
4071
{
4072
	struct sd *sd = (struct sd *) gspca_dev;
4073

4074
	sd->sharpness = val;
4075
	if (gspca_dev->streaming)
4076
		setsharpness(gspca_dev);
4077
	return gspca_dev->usb_err;
4078
}
4079

4080
static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
4081
{
4082
	struct sd *sd = (struct sd *) gspca_dev;
4083

4084
	*val = sd->sharpness;
4085
	return 0;
4086
}
4087

4088
static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
4089
{
4090
	struct sd *sd = (struct sd *) gspca_dev;
4091

4092
	sd->gain = val;
4093
	if (gspca_dev->streaming)
4094
		setgain(gspca_dev);
4095
	return gspca_dev->usb_err;
4096
}
4097

4098
static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
4099
{
4100
	struct sd *sd = (struct sd *) gspca_dev;
4101

4102
	*val = sd->gain;
4103
	return 0;
4104
}
4105

4106
static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
4107
{
4108
	struct sd *sd = (struct sd *) gspca_dev;
4109

4110
	sd->exposure = val;
4111
	if (gspca_dev->streaming)
4112
		setexposure(gspca_dev);
4113
	return gspca_dev->usb_err;
4114
}
4115

4116
static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
4117
{
4118
	struct sd *sd = (struct sd *) gspca_dev;
4119

4120
	*val = sd->exposure;
4121
	return 0;
4122
}
4123

4124
static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
4125
{
4126
	struct sd *sd = (struct sd *) gspca_dev;
4127

4128
	sd->autogain = val;
4129
	if (gspca_dev->streaming)
4130
		setautogain(gspca_dev);
4131

4132
	return gspca_dev->usb_err;
4133
}
4134

4135
static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
4136
{
4137
	struct sd *sd = (struct sd *) gspca_dev;
4138

4139
	*val = sd->autogain;
4140
	return 0;
4141
}
4142

4143
static int sd_setbacklight(struct gspca_dev *gspca_dev, __s32 val)
4144
{
4145
	struct sd *sd = (struct sd *) gspca_dev;
4146

4147
	sd->backlight = val;
4148
	if (gspca_dev->streaming)
4149
		setbacklight(gspca_dev);
4150

4151
	return gspca_dev->usb_err;
4152
}
4153

4154
static int sd_getbacklight(struct gspca_dev *gspca_dev, __s32 *val)
4155
{
4156
	struct sd *sd = (struct sd *) gspca_dev;
4157

4158
	*val = sd->backlight;
4159
	return 0;
4160
}
4161

4162
static int sd_querymenu(struct gspca_dev *gspca_dev,
4163
			struct v4l2_querymenu *menu)
4164
{
4165
	static const char *freq_nm[3] = {"NoFliker", "50 Hz", "60 Hz"};
4166

4167
	switch (menu->id) {
4168
	case V4L2_CID_POWER_LINE_FREQUENCY:
4169
		if (menu->index >= ARRAY_SIZE(freq_nm))
4170
			break;
4171
		strcpy((char *) menu->name, freq_nm[menu->index]);
4172
		return 0;
4173
	}
4174
	return -EINVAL;
4175
}
4176

4177
/* sub-driver description */
4178
static const struct sd_desc sd_desc = {
4179
	.name = MODULE_NAME,
4180
	.ctrls = sd_ctrls,
4181
	.nctrls = ARRAY_SIZE(sd_ctrls),
4182
	.config = sd_config,
4183
	.init = sd_init,
4184
	.start = sd_start,
4185
	.stopN = sd_stopN,
4186
	.stop0 = sd_stop0,
4187
	.pkt_scan = sd_pkt_scan,
4188
	.querymenu = sd_querymenu,
4189
};
4190

4191
/* -- module initialisation -- */
4192
#define BF(bridge, flags) \
4193
	.driver_info = (BRIDGE_ ## bridge << 8) \
4194
		| (flags)
4195
static const struct usb_device_id device_table[] = {
4196
	{USB_DEVICE(0x041e, 0x405b), BF(VC0323, FL_VFLIP)},
4197
	{USB_DEVICE(0x046d, 0x0892), BF(VC0321, 0)},
4198
	{USB_DEVICE(0x046d, 0x0896), BF(VC0321, 0)},
4199
	{USB_DEVICE(0x046d, 0x0897), BF(VC0321, 0)},
4200
	{USB_DEVICE(0x0ac8, 0x0321), BF(VC0321, 0)},
4201
	{USB_DEVICE(0x0ac8, 0x0323), BF(VC0323, 0)},
4202
	{USB_DEVICE(0x0ac8, 0x0328), BF(VC0321, 0)},
4203
	{USB_DEVICE(0x0ac8, 0xc001), BF(VC0321, 0)},
4204
	{USB_DEVICE(0x0ac8, 0xc002), BF(VC0321, 0)},
4205
	{USB_DEVICE(0x0ac8, 0xc301), BF(VC0323, FL_SAMSUNG)},
4206
	{USB_DEVICE(0x15b8, 0x6001), BF(VC0323, 0)},
4207
	{USB_DEVICE(0x15b8, 0x6002), BF(VC0323, 0)},
4208
	{USB_DEVICE(0x17ef, 0x4802), BF(VC0323, 0)},
4209
	{}
4210
};
4211
MODULE_DEVICE_TABLE(usb, device_table);
4212

4213
/* -- device connect -- */
4214
static int sd_probe(struct usb_interface *intf,
4215
			const struct usb_device_id *id)
4216
{
4217
	return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
4218
				THIS_MODULE);
4219
}
4220

4221
static struct usb_driver sd_driver = {
4222
	.name = MODULE_NAME,
4223
	.id_table = device_table,
4224
	.probe = sd_probe,
4225
	.disconnect = gspca_disconnect,
4226
#ifdef CONFIG_PM
4227
	.suspend = gspca_suspend,
4228
	.resume = gspca_resume,
4229
#endif
4230
};
4231

4232
/* -- module insert / remove -- */
4233
static int __init sd_mod_init(void)
4234
{
4235
	return usb_register(&sd_driver);
4236
}
4237
static void __exit sd_mod_exit(void)
4238
{
4239
	usb_deregister(&sd_driver);
4240
}
4241

4242
module_init(sd_mod_init);
4243
module_exit(sd_mod_exit);
4244

4245
Product

Resources

Company
