diff options
Diffstat (limited to 'extras/recipes-kernel/linux/linux-omap-psp-2.6.32/cam/0001-mt9t111-first-stab-at-merging-sensor-driver-based-on.patch')
-rw-r--r-- | extras/recipes-kernel/linux/linux-omap-psp-2.6.32/cam/0001-mt9t111-first-stab-at-merging-sensor-driver-based-on.patch | 2394 |
1 files changed, 2394 insertions, 0 deletions
diff --git a/extras/recipes-kernel/linux/linux-omap-psp-2.6.32/cam/0001-mt9t111-first-stab-at-merging-sensor-driver-based-on.patch b/extras/recipes-kernel/linux/linux-omap-psp-2.6.32/cam/0001-mt9t111-first-stab-at-merging-sensor-driver-based-on.patch new file mode 100644 index 00000000..bd4a7f88 --- /dev/null +++ b/extras/recipes-kernel/linux/linux-omap-psp-2.6.32/cam/0001-mt9t111-first-stab-at-merging-sensor-driver-based-on.patch | |||
@@ -0,0 +1,2394 @@ | |||
1 | From 4e23fe54d7f8ecc1c927d225b1b74e6b00e22997 Mon Sep 17 00:00:00 2001 | ||
2 | From: OpenEmbedded User <oe@OE-builder.(none)> | ||
3 | Date: Tue, 9 Feb 2010 17:16:13 +0100 | ||
4 | Subject: [PATCH 01/75] mt9t111: first stab at merging sensor driver based on a patch by Leopard Imaging | ||
5 | |||
6 | --- | ||
7 | drivers/media/video/Kconfig | 8 + | ||
8 | drivers/media/video/Makefile | 1 + | ||
9 | drivers/media/video/mt9t111.c | 883 ++++++++++++++++++++++++ | ||
10 | drivers/media/video/mt9t111_reg.h | 1364 +++++++++++++++++++++++++++++++++++++ | ||
11 | include/media/mt9t111.h | 79 +++ | ||
12 | 5 files changed, 2335 insertions(+), 0 deletions(-) | ||
13 | create mode 100644 drivers/media/video/mt9t111.c | ||
14 | create mode 100644 drivers/media/video/mt9t111_reg.h | ||
15 | create mode 100644 include/media/mt9t111.h | ||
16 | |||
17 | diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig | ||
18 | index 41e39a7..f67ed46 100644 | ||
19 | --- a/drivers/media/video/Kconfig | ||
20 | +++ b/drivers/media/video/Kconfig | ||
21 | @@ -344,6 +344,14 @@ config VIDEO_MT9P012 | ||
22 | MT9P012 camera. It is currently working with the TI OMAP3 | ||
23 | camera controller. | ||
24 | |||
25 | +config VIDEO_MT9T111 | ||
26 | + tristate "Micron MT9T111 raw sensor driver (3MP)" | ||
27 | + depends on I2C && VIDEO_V4L2 | ||
28 | + ---help--- | ||
29 | + This is a Video4Linux2 sensor-level driver for the Micron | ||
30 | + MT9T111 camera. It is currently working with the TI OMAP3 | ||
31 | + camera controller. | ||
32 | + | ||
33 | config VIDEO_DW9710 | ||
34 | tristate "Lens driver for DW9710" | ||
35 | depends on I2C && VIDEO_V4L2 | ||
36 | diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile | ||
37 | index 88e8ec1..31688bf 100644 | ||
38 | --- a/drivers/media/video/Makefile | ||
39 | +++ b/drivers/media/video/Makefile | ||
40 | @@ -127,6 +127,7 @@ obj-$(CONFIG_VIDEO_CAFE_CCIC) += cafe_ccic.o | ||
41 | obj-y += isp/ | ||
42 | obj-$(CONFIG_VIDEO_OMAP3) += omap34xxcam.o | ||
43 | obj-$(CONFIG_VIDEO_MT9P012) += mt9p012.o | ||
44 | +obj-$(CONFIG_VIDEO_MT9T111) += mt9t111.o | ||
45 | obj-$(CONFIG_VIDEO_DW9710) += dw9710.o | ||
46 | obj-$(CONFIG_VIDEO_TPS61059) += tps61059.o | ||
47 | obj-$(CONFIG_VIDEO_OV3640) += ov3640.o | ||
48 | diff --git a/drivers/media/video/mt9t111.c b/drivers/media/video/mt9t111.c | ||
49 | new file mode 100644 | ||
50 | index 0000000..ecc5115 | ||
51 | --- /dev/null | ||
52 | +++ b/drivers/media/video/mt9t111.c | ||
53 | @@ -0,0 +1,883 @@ | ||
54 | +/* | ||
55 | + * drivers/media/video/mt9t111.c | ||
56 | + * | ||
57 | + * mt9t111 sensor driver | ||
58 | + * | ||
59 | + * Copyright (C) 2009 Leopard Imaging | ||
60 | + * | ||
61 | + * This file is licensed under the terms of the GNU General Public License | ||
62 | + * version 2. This program is licensed "as is" without any warranty of any | ||
63 | + * kind, whether express or implied. | ||
64 | + */ | ||
65 | + | ||
66 | +#include <linux/i2c.h> | ||
67 | +#include <linux/delay.h> | ||
68 | +#include <media/v4l2-int-device.h> | ||
69 | + | ||
70 | +#include <media/mt9t111.h> | ||
71 | +#include "mt9t111_reg.h" | ||
72 | + | ||
73 | +#define USE_RAW // YCbCr mode does not work yet | ||
74 | +//#define COLOR_BAR // Create a Color bar test pattern, Blue, Green, Red, Grey | ||
75 | + | ||
76 | +#define SENSOR_DETECTED 1 | ||
77 | +#define SENSOR_NOT_DETECTED 0 | ||
78 | + | ||
79 | +static void mt9t111_loaddefault(struct i2c_client *client); | ||
80 | + | ||
81 | +/* | ||
82 | +* as a place holder for further development | ||
83 | +*/ | ||
84 | +static void debug_dummy(char *in_msg) | ||
85 | +{ | ||
86 | + | ||
87 | +} | ||
88 | + | ||
89 | +/* list of image formats supported by mt9t111 sensor */ | ||
90 | +const static struct v4l2_fmtdesc mt9t111_formats[] = { | ||
91 | +#ifdef USE_RAW | ||
92 | + { | ||
93 | + .description = "RAW ", | ||
94 | + .pixelformat = V4L2_PIX_FMT_SGRBG10, | ||
95 | + }, | ||
96 | +#else | ||
97 | + { | ||
98 | + .description = "YUV 422 ", | ||
99 | + .pixelformat = V4L2_PIX_FMT_YUYV, | ||
100 | + }, | ||
101 | +#endif | ||
102 | +}; | ||
103 | + | ||
104 | +#define NUM_CAPTURE_FORMATS ARRAY_SIZE(mt9t111_formats) | ||
105 | + | ||
106 | +/* | ||
107 | + * Array of image sizes supported by MT9T111. These must be ordered from | ||
108 | + * smallest image size to largest. | ||
109 | + */ | ||
110 | +const static struct capture_size mt9t111_sizes[] = { | ||
111 | + { 640, 480 }, | ||
112 | +// { 2048, 1536} | ||
113 | +}; | ||
114 | + | ||
115 | +#define NUM_CAPTURE_SIZE ARRAY_SIZE(mt9t111_sizes) | ||
116 | + | ||
117 | + | ||
118 | +const struct v4l2_fract mt9t111_frameintervals[] = { | ||
119 | + { .numerator = 1, .denominator = 10 } | ||
120 | +}; | ||
121 | + | ||
122 | +#define NUM_CAPTURE_FRAMEINTERVALS ARRAY_SIZE(mt9t111_frameintervals) | ||
123 | + | ||
124 | +/** | ||
125 | + * struct mt9t111_sensor - main structure for storage of sensor information | ||
126 | + * @pdata: access functions and data for platform level information | ||
127 | + * @v4l2_int_device: V4L2 device structure structure | ||
128 | + * @i2c_client: iic client device structure | ||
129 | + * @pix: V4L2 pixel format information structure | ||
130 | + * @timeperframe: time per frame expressed as V4L fraction | ||
131 | + * @scaler: | ||
132 | + * @ver: mt9t111 chip version | ||
133 | + * @fps: frames per second value | ||
134 | + */ | ||
135 | +struct mt9t111_sensor { | ||
136 | + const struct mt9t111_platform_data *pdata; | ||
137 | + struct v4l2_int_device *v4l2_int_device; | ||
138 | + struct i2c_client *i2c_client; | ||
139 | + struct v4l2_pix_format pix; | ||
140 | + struct v4l2_fract timeperframe; | ||
141 | + int scaler; | ||
142 | + int ver; | ||
143 | + int fps; | ||
144 | + int state; | ||
145 | +}; | ||
146 | + | ||
147 | +static struct mt9t111_sensor mt9t111 = { | ||
148 | + .timeperframe = { | ||
149 | + .numerator = 1, | ||
150 | + .denominator = 10, | ||
151 | + }, | ||
152 | + .state = SENSOR_NOT_DETECTED, | ||
153 | +}; | ||
154 | + | ||
155 | +/** | ||
156 | + * mt9t111_read_reg - Read a value from a register in an mt9t111 sensor device | ||
157 | + * @client: i2c driver client structure | ||
158 | + * @data_length: length of data to be read | ||
159 | + * @reg: register address / offset | ||
160 | + * @val: stores the value that gets read | ||
161 | + * | ||
162 | + * Read a value from a register in an mt9t111 sensor device. | ||
163 | + * The value is returned in 'val'. | ||
164 | + * Returns zero if successful, or non-zero otherwise. | ||
165 | + */ | ||
166 | +static int | ||
167 | +mt9t111_read_reg(struct i2c_client *client, u16 reg, u16 *val) | ||
168 | +{ | ||
169 | + struct i2c_msg msg[1]; | ||
170 | + u8 data[4]; | ||
171 | + int err; | ||
172 | + | ||
173 | + msg->addr = client->addr; | ||
174 | + msg->flags = 0; | ||
175 | + msg->len = 2; | ||
176 | + msg->buf = data; | ||
177 | + data[0] = (reg & 0xff00) >> 8; | ||
178 | + data[1] = (reg & 0x00ff); | ||
179 | + err = i2c_transfer(client->adapter, msg, 1); | ||
180 | + if (err >= 0) { | ||
181 | + msg->flags = I2C_M_RD; | ||
182 | + msg->len = 2; /* 2 byte read */ | ||
183 | + err = i2c_transfer(client->adapter, msg, 1); | ||
184 | + if (err >= 0) { | ||
185 | + *val = ((data[0] & 0x00ff) << 8) | ||
186 | + | (data[1] & 0x00ff); | ||
187 | + return 0; | ||
188 | + } | ||
189 | + } | ||
190 | + return err; | ||
191 | +} | ||
192 | + | ||
193 | +/** | ||
194 | + * mt9t111_write_reg - Write a value to a register in an mt9t111 sensor device | ||
195 | + * @client: i2c driver client structure | ||
196 | + * @data_length: length of data to be read | ||
197 | + * @reg: register address / offset | ||
198 | + * @val: value to be written to specified register | ||
199 | + * | ||
200 | + * Write a value to a register in an mt9t111 sensor device. | ||
201 | + * Returns zero if successful, or non-zero otherwise. | ||
202 | + */ | ||
203 | +static int | ||
204 | +mt9t111_write_reg(struct i2c_client *client, u16 reg, u16 val) | ||
205 | +{ | ||
206 | + struct i2c_msg msg[1]; | ||
207 | + u8 data[20]; | ||
208 | + int err; | ||
209 | + | ||
210 | + msg->addr = client->addr; | ||
211 | + msg->flags = 0; | ||
212 | + msg->len = 4; | ||
213 | + msg->buf = data; | ||
214 | + data[0] = (u8)((reg & 0xff00) >> 8); | ||
215 | + data[1] = (u8)(reg & 0x00ff); | ||
216 | + data[2] = (u8)((val & 0xff00) >> 8); | ||
217 | + data[3] = (u8)(val & 0x00ff); | ||
218 | + err = i2c_transfer(client->adapter, msg, 1); | ||
219 | + | ||
220 | + return err; | ||
221 | +} | ||
222 | + | ||
223 | +/** | ||
224 | + * mt9t111_write_regs - Write registers to an mt9t111 sensor device | ||
225 | + * @client: i2c driver client structure | ||
226 | + * @reg_in: pointer to registers to write | ||
227 | + * @cnt: the number of registers | ||
228 | + * | ||
229 | + * Write registers . | ||
230 | + * Returns zero if successful, or non-zero otherwise. | ||
231 | + */ | ||
232 | +static int | ||
233 | +mt9t111_write_regs(struct i2c_client *client, mt9t111_regs *reg_in, int cnt) | ||
234 | +{ | ||
235 | + int err = 0; | ||
236 | + int i; | ||
237 | + mt9t111_regs *reg = reg_in; | ||
238 | + | ||
239 | + for (i=0;i<cnt;i++) { | ||
240 | + if (reg->delay_time == 0) { | ||
241 | + err |= mt9t111_write_reg(client, reg->addr, reg->data); | ||
242 | + } else if (reg->addr != 0 || reg->data != 0) { | ||
243 | + err |= mt9t111_write_reg(client, reg->addr, reg->data); | ||
244 | + mdelay(reg->delay_time); | ||
245 | + } else | ||
246 | + mdelay(reg->delay_time); | ||
247 | + | ||
248 | + if (err < 0) { | ||
249 | + dev_warn(&client->dev, "write reg error, addr = 0x%x, data = 0x%x \n", \ | ||
250 | + reg->addr, reg->data); | ||
251 | + return err; | ||
252 | + } | ||
253 | + reg++; | ||
254 | + } | ||
255 | + return err; | ||
256 | +} | ||
257 | + | ||
258 | +/** | ||
259 | + * mt9t111_detect - Detect if an mt9t111 is present, and if so which revision | ||
260 | + * @client: pointer to the i2c client driver structure | ||
261 | + * | ||
262 | + * Detect if an mt9t111 is present | ||
263 | + * Returns a negative error number if no device is detected, or the | ||
264 | + * non-negative value of the version ID register if a device is detected. | ||
265 | + */ | ||
266 | +static int | ||
267 | +mt9t111_detect(struct i2c_client *client) | ||
268 | +{ | ||
269 | + u16 val; | ||
270 | + | ||
271 | + /* chip ID is at address 0 */ | ||
272 | + if (mt9t111_read_reg(client, MT9T111_CHIP_ID, &val) < 0) | ||
273 | + return -ENODEV; | ||
274 | + dev_info(&client->dev, "model id detected 0x%x\n", val); | ||
275 | + | ||
276 | + if (val != MT9T111_CHIP_ID_VALUE) { | ||
277 | + dev_warn(&client->dev, "model id mismatch received 0x%x expecting 0x%x\n", | ||
278 | + val, MT9T111_CHIP_ID_VALUE); | ||
279 | + | ||
280 | + return -ENODEV; | ||
281 | + } | ||
282 | + | ||
283 | + return 0; | ||
284 | + | ||
285 | +} | ||
286 | + | ||
287 | +/** | ||
288 | + * mt9t111_configure - Configure the mt9t111 for the specified image mode | ||
289 | + * @s: pointer to standard V4L2 device structure | ||
290 | + * | ||
291 | + * Configure the mt9t111 for a specified image size, pixel format, and frame | ||
292 | + * period. xclk is the frequency (in Hz) of the xclk input to the mt9t111. | ||
293 | + * fper is the frame period (in seconds) expressed as a fraction. | ||
294 | + * Returns zero if successful, or non-zero otherwise. | ||
295 | + * The actual frame period is returned in fper. | ||
296 | + */ | ||
297 | +static int mt9t111_configure(struct v4l2_int_device *s) | ||
298 | +{ | ||
299 | + debug_dummy("debug_dummy -- to set imager mode"); | ||
300 | + | ||
301 | + return 0; | ||
302 | +} | ||
303 | + | ||
304 | +/** | ||
305 | + * ioctl_enum_framesizes - V4L2 sensor if handler for vidioc_int_enum_framesizes | ||
306 | + * @s: pointer to standard V4L2 device structure | ||
307 | + * @frms: pointer to standard V4L2 framesizes enumeration structure | ||
308 | + * | ||
309 | + * Returns possible framesizes depending on choosen pixel format | ||
310 | + **/ | ||
311 | +static int ioctl_enum_framesizes(struct v4l2_int_device *s, | ||
312 | + struct v4l2_frmsizeenum *frms) | ||
313 | +{ | ||
314 | + int ifmt; | ||
315 | + | ||
316 | + for (ifmt = 0; ifmt < NUM_CAPTURE_FORMATS; ifmt++) { | ||
317 | + if (frms->pixel_format == mt9t111_formats[ifmt].pixelformat) | ||
318 | + break; | ||
319 | + } | ||
320 | + /* Is requested pixelformat not found on sensor? */ | ||
321 | + if (ifmt == NUM_CAPTURE_FORMATS) | ||
322 | + return -EINVAL; | ||
323 | + | ||
324 | + /* Do we already reached all discrete framesizes? */ | ||
325 | + if (frms->index >= NUM_CAPTURE_SIZE) | ||
326 | + return -EINVAL; | ||
327 | + | ||
328 | + frms->type = V4L2_FRMSIZE_TYPE_DISCRETE; | ||
329 | + frms->discrete.width = mt9t111_sizes[frms->index].width; | ||
330 | + frms->discrete.height = mt9t111_sizes[frms->index].height; | ||
331 | + | ||
332 | + return 0; | ||
333 | + | ||
334 | +} | ||
335 | + | ||
336 | +static int ioctl_enum_frameintervals(struct v4l2_int_device *s, | ||
337 | + struct v4l2_frmivalenum *frmi) | ||
338 | +{ | ||
339 | + int ifmt; | ||
340 | + | ||
341 | +printk(KERN_INFO "entering ioctl_enum_frameintervals\n"); | ||
342 | +printk(KERN_INFO "index = %d, pixel_format = 0x%x, width = %d, height = %d\n", | ||
343 | + frmi->index, frmi->pixel_format, frmi->width, frmi->height); | ||
344 | +printk(KERN_INFO "mt9t111 format = 0x%x\n", mt9t111_formats[0].pixelformat); | ||
345 | + | ||
346 | + if (frmi->index >= NUM_CAPTURE_FRAMEINTERVALS) | ||
347 | + return -EINVAL; | ||
348 | + | ||
349 | + for (ifmt = 0; ifmt < NUM_CAPTURE_FORMATS; ifmt++) { | ||
350 | + if (frmi->pixel_format == mt9t111_formats[ifmt].pixelformat) | ||
351 | + break; | ||
352 | + } | ||
353 | + /* Is requested pixelformat not found on sensor? */ | ||
354 | + if (ifmt == NUM_CAPTURE_FORMATS) | ||
355 | + return -EINVAL; | ||
356 | + | ||
357 | + frmi->type = V4L2_FRMSIZE_TYPE_DISCRETE; | ||
358 | + frmi->discrete.numerator = | ||
359 | + mt9t111_frameintervals[frmi->index].numerator; | ||
360 | + frmi->discrete.denominator = | ||
361 | + mt9t111_frameintervals[frmi->index].denominator; | ||
362 | + return 0; | ||
363 | +} | ||
364 | + | ||
365 | +/** | ||
366 | + * ioctl_init - V4L2 sensor interface handler for VIDIOC_INT_INIT | ||
367 | + * @s: pointer to standard V4L2 device structure | ||
368 | + * | ||
369 | + * Initialize the sensor device (call mt9t111_configure()) | ||
370 | + */ | ||
371 | +static int ioctl_init(struct v4l2_int_device *s) | ||
372 | +{ | ||
373 | + return 0; | ||
374 | +} | ||
375 | + | ||
376 | +/** | ||
377 | + * ioctl_dev_exit - V4L2 sensor interface handler for vidioc_int_dev_exit_num | ||
378 | + * @s: pointer to standard V4L2 device structure | ||
379 | + * | ||
380 | + * Delinitialise the dev. at slave detach. The complement of ioctl_dev_init. | ||
381 | + */ | ||
382 | +static int ioctl_dev_exit(struct v4l2_int_device *s) | ||
383 | +{ | ||
384 | + return 0; | ||
385 | +} | ||
386 | + | ||
387 | +/** | ||
388 | + * ioctl_dev_init - V4L2 sensor interface handler for vidioc_int_dev_init_num | ||
389 | + * @s: pointer to standard V4L2 device structure | ||
390 | + * | ||
391 | + * Initialise the device when slave attaches to the master. Returns 0 if | ||
392 | + * mt9t111 device could be found, otherwise returns appropriate error. | ||
393 | + */ | ||
394 | +static int ioctl_dev_init(struct v4l2_int_device *s) | ||
395 | +{ | ||
396 | + return 0; | ||
397 | +} | ||
398 | + | ||
399 | +/** | ||
400 | + * ioctl_s_power - V4L2 sensor interface handler for vidioc_int_s_power_num | ||
401 | + * @s: pointer to standard V4L2 device structure | ||
402 | + * @on: power state to which device is to be set | ||
403 | + * | ||
404 | + * Sets devices power state to requrested state, if possible. | ||
405 | + */ | ||
406 | +static int ioctl_s_power(struct v4l2_int_device *s, enum v4l2_power on) | ||
407 | +{ | ||
408 | + struct mt9t111_sensor *sensor = s->priv; | ||
409 | + struct i2c_client *c = sensor->i2c_client; | ||
410 | + int rval; | ||
411 | + | ||
412 | + if ((on == V4L2_POWER_STANDBY) && (sensor->state == SENSOR_DETECTED)) | ||
413 | + debug_dummy("debug_dummy -- put to standby\n"); | ||
414 | + | ||
415 | + if (on != V4L2_POWER_ON) | ||
416 | + debug_dummy("debug_dummy -- stop master clock\n"); | ||
417 | + else | ||
418 | + debug_dummy("debug_dummy -- enable clock\n");; | ||
419 | + | ||
420 | + rval = sensor->pdata->power_set(on); | ||
421 | + if (rval < 0) { | ||
422 | + dev_err(&c->dev, "Unable to set the power state: " "mt9t111" | ||
423 | + " sensor\n"); | ||
424 | + //sensor->pdata->set_xclk(0); | ||
425 | + return rval; | ||
426 | + } | ||
427 | + | ||
428 | + if ((on == V4L2_POWER_ON) && (sensor->state == SENSOR_DETECTED)) | ||
429 | + mt9t111_configure(s); | ||
430 | + | ||
431 | + if ((on == V4L2_POWER_ON) && (sensor->state == SENSOR_NOT_DETECTED)) { | ||
432 | + rval = mt9t111_detect(c); | ||
433 | + if (rval < 0) { | ||
434 | + dev_err(&c->dev, "Unable to detect " "mt9t111" | ||
435 | + " sensor\n"); | ||
436 | + sensor->state = SENSOR_NOT_DETECTED; | ||
437 | + return rval; | ||
438 | + } | ||
439 | + mt9t111_loaddefault(c); | ||
440 | + sensor->state = SENSOR_DETECTED; | ||
441 | + sensor->ver = rval; | ||
442 | + pr_info("mt9t111" " chip version 0x%02x detected\n", | ||
443 | + sensor->ver); | ||
444 | + } | ||
445 | + return 0; | ||
446 | +} | ||
447 | + | ||
448 | +/** | ||
449 | + * ioctl_g_priv - V4L2 sensor interface handler for vidioc_int_g_priv_num | ||
450 | + * @s: pointer to standard V4L2 device structure | ||
451 | + * @p: void pointer to hold sensor's private data address | ||
452 | + * | ||
453 | + * Returns device's (sensor's) private data area address in p parameter | ||
454 | + */ | ||
455 | +static int ioctl_g_priv(struct v4l2_int_device *s, void *p) | ||
456 | +{ | ||
457 | + struct mt9t111_sensor *sensor = s->priv; | ||
458 | + | ||
459 | + return sensor->pdata->priv_data_set(p); | ||
460 | +} | ||
461 | + | ||
462 | +/** | ||
463 | + * ioctl_s_parm - V4L2 sensor interface handler for VIDIOC_S_PARM ioctl | ||
464 | + * @s: pointer to standard V4L2 device structure | ||
465 | + * @a: pointer to standard V4L2 VIDIOC_S_PARM ioctl structure | ||
466 | + * | ||
467 | + * Configures the sensor to use the input parameters, if possible. If | ||
468 | + * not possible, reverts to the old parameters and returns the | ||
469 | + * appropriate error code. | ||
470 | + */ | ||
471 | +static int ioctl_s_parm(struct v4l2_int_device *s, | ||
472 | + struct v4l2_streamparm *a) | ||
473 | +{ | ||
474 | + //TODO: set paramters | ||
475 | + debug_dummy("debug_dummy -- VIDIOC_S_PARM "); | ||
476 | + return 0; | ||
477 | +} | ||
478 | + | ||
479 | +/** | ||
480 | + * ioctl_g_parm - V4L2 sensor interface handler for VIDIOC_G_PARM ioctl | ||
481 | + * @s: pointer to standard V4L2 device structure | ||
482 | + * @a: pointer to standard V4L2 VIDIOC_G_PARM ioctl structure | ||
483 | + * | ||
484 | + * Returns the sensor's video CAPTURE parameters. | ||
485 | + */ | ||
486 | +static int ioctl_g_parm(struct v4l2_int_device *s, | ||
487 | + struct v4l2_streamparm *a) | ||
488 | +{ | ||
489 | + struct mt9t111_sensor *sensor = s->priv; | ||
490 | + struct v4l2_captureparm *cparm = &a->parm.capture; | ||
491 | + | ||
492 | + if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) | ||
493 | + return -EINVAL; | ||
494 | + | ||
495 | + memset(a, 0, sizeof(*a)); | ||
496 | + a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; | ||
497 | + | ||
498 | + cparm->capability = V4L2_CAP_TIMEPERFRAME; | ||
499 | + cparm->timeperframe = sensor->timeperframe; | ||
500 | + | ||
501 | + return 0; | ||
502 | +} | ||
503 | + | ||
504 | +/** | ||
505 | + * ioctl_g_fmt_cap - V4L2 sensor interface handler for ioctl_g_fmt_cap | ||
506 | + * @s: pointer to standard V4L2 device structure | ||
507 | + * @f: pointer to standard V4L2 v4l2_format structure | ||
508 | + * | ||
509 | + * Returns the sensor's current pixel format in the v4l2_format | ||
510 | + * parameter. | ||
511 | + */ | ||
512 | +static int ioctl_g_fmt_cap(struct v4l2_int_device *s, | ||
513 | + struct v4l2_format *f) | ||
514 | +{ | ||
515 | + struct mt9t111_sensor *sensor = s->priv; | ||
516 | + f->fmt.pix = sensor->pix; | ||
517 | + | ||
518 | + return 0; | ||
519 | +} | ||
520 | + | ||
521 | +/** | ||
522 | + * ioctl_try_fmt_cap - Implement the CAPTURE buffer VIDIOC_TRY_FMT ioctl | ||
523 | + * @s: pointer to standard V4L2 device structure | ||
524 | + * @f: pointer to standard V4L2 VIDIOC_TRY_FMT ioctl structure | ||
525 | + * | ||
526 | + * Implement the VIDIOC_TRY_FMT ioctl for the CAPTURE buffer type. This | ||
527 | + * ioctl is used to negotiate the image capture size and pixel format | ||
528 | + * without actually making it take effect. | ||
529 | + */ | ||
530 | +static int ioctl_try_fmt_cap(struct v4l2_int_device *s, | ||
531 | + struct v4l2_format *f) | ||
532 | +{ | ||
533 | + struct v4l2_pix_format *pix = &f->fmt.pix; | ||
534 | + struct mt9t111_sensor *sensor = s->priv; | ||
535 | + struct v4l2_pix_format *pix2 = &sensor->pix; | ||
536 | + | ||
537 | + pix->width = 640; | ||
538 | + pix->height = 480; | ||
539 | +#ifdef USE_RAW | ||
540 | + pix->pixelformat = V4L2_PIX_FMT_SGRBG10; | ||
541 | + pix->bytesperline = pix->width; | ||
542 | + pix->colorspace = V4L2_COLORSPACE_SRGB; | ||
543 | +#else | ||
544 | + pix->pixelformat = V4L2_PIX_FMT_YUYV; | ||
545 | + pix->bytesperline = pix->width * 2; | ||
546 | + pix->colorspace = V4L2_COLORSPACE_JPEG; | ||
547 | +#endif | ||
548 | + pix->field = V4L2_FIELD_NONE; | ||
549 | + | ||
550 | + pix->sizeimage = pix->bytesperline * pix->height; | ||
551 | + pix->priv = 0; | ||
552 | + *pix2 = *pix; | ||
553 | + return 0; | ||
554 | +} | ||
555 | + | ||
556 | +/** | ||
557 | + * ioctl_s_fmt_cap - V4L2 sensor interface handler for VIDIOC_S_FMT ioctl | ||
558 | + * @s: pointer to standard V4L2 device structure | ||
559 | + * @f: pointer to standard V4L2 VIDIOC_S_FMT ioctl structure | ||
560 | + * | ||
561 | + * If the requested format is supported, configures the HW to use that | ||
562 | + * format, returns error code if format not supported or HW can't be | ||
563 | + * correctly configured. | ||
564 | + */ | ||
565 | +static int ioctl_s_fmt_cap(struct v4l2_int_device *s, | ||
566 | + struct v4l2_format *f) | ||
567 | +{ | ||
568 | + struct mt9t111_sensor *sensor = s->priv; | ||
569 | + struct v4l2_pix_format *pix = &f->fmt.pix; | ||
570 | + int rval; | ||
571 | + | ||
572 | + rval = ioctl_try_fmt_cap(s, f); | ||
573 | + if (!rval) | ||
574 | + sensor->pix = *pix; | ||
575 | + | ||
576 | + return rval; | ||
577 | +} | ||
578 | + | ||
579 | +/** | ||
580 | + * ioctl_enum_fmt_cap - Implement the CAPTURE buffer VIDIOC_ENUM_FMT ioctl | ||
581 | + * @s: pointer to standard V4L2 device structure | ||
582 | + * @fmt: standard V4L2 VIDIOC_ENUM_FMT ioctl structure | ||
583 | + * | ||
584 | + * Implement the VIDIOC_ENUM_FMT ioctl for the CAPTURE buffer type. | ||
585 | + */ | ||
586 | +static int ioctl_enum_fmt_cap(struct v4l2_int_device *s, | ||
587 | + struct v4l2_fmtdesc *fmt) | ||
588 | +{ | ||
589 | + int index = fmt->index; | ||
590 | + enum v4l2_buf_type type = fmt->type; | ||
591 | + | ||
592 | + memset(fmt, 0, sizeof(*fmt)); | ||
593 | + fmt->index = index; | ||
594 | + fmt->type = type; | ||
595 | + | ||
596 | + switch (fmt->type) { | ||
597 | + case V4L2_BUF_TYPE_VIDEO_CAPTURE: | ||
598 | + if (index >= NUM_CAPTURE_FORMATS) | ||
599 | + return -EINVAL; | ||
600 | + break; | ||
601 | + default: | ||
602 | + return -EINVAL; | ||
603 | + } | ||
604 | + | ||
605 | + fmt->flags = mt9t111_formats[index].flags; | ||
606 | + strlcpy(fmt->description, mt9t111_formats[index].description, | ||
607 | + sizeof(fmt->description)); | ||
608 | + fmt->pixelformat = mt9t111_formats[index].pixelformat; | ||
609 | + | ||
610 | + return 0; | ||
611 | +} | ||
612 | + | ||
613 | +/** | ||
614 | + * ioctl_s_ctrl - V4L2 sensor interface handler for VIDIOC_S_CTRL ioctl | ||
615 | + * @s: pointer to standard V4L2 device structure | ||
616 | + * @vc: standard V4L2 VIDIOC_S_CTRL ioctl structure | ||
617 | + * | ||
618 | + * If the requested control is supported, sets the control's current | ||
619 | + * value in HW (and updates the video_control[] array). Otherwise, | ||
620 | + * returns -EINVAL if the control is not supported. | ||
621 | + */ | ||
622 | +static int ioctl_s_ctrl(struct v4l2_int_device *s, | ||
623 | + struct v4l2_control *vc) | ||
624 | +{ | ||
625 | + debug_dummy("debug_dummy -- s ctrl\n"); | ||
626 | + return 0; | ||
627 | +} | ||
628 | + | ||
629 | +/** | ||
630 | + * ioctl_g_ctrl - V4L2 sensor interface handler for VIDIOC_G_CTRL ioctl | ||
631 | + * @s: pointer to standard V4L2 device structure | ||
632 | + * @vc: standard V4L2 VIDIOC_G_CTRL ioctl structure | ||
633 | + * | ||
634 | + * If the requested control is supported, returns the control's current | ||
635 | + * value from the video_control[] array. Otherwise, returns -EINVAL | ||
636 | + * if the control is not supported. | ||
637 | + */ | ||
638 | +static int ioctl_g_ctrl(struct v4l2_int_device *s, | ||
639 | + struct v4l2_control *vc) | ||
640 | +{ | ||
641 | + debug_dummy("debug_dummy -- g ctrl\n"); | ||
642 | + return 0; | ||
643 | +} | ||
644 | + | ||
645 | +/** | ||
646 | + * ioctl_queryctrl - V4L2 sensor interface handler for VIDIOC_QUERYCTRL ioctl | ||
647 | + * @s: pointer to standard V4L2 device structure | ||
648 | + * @qc: standard V4L2 VIDIOC_QUERYCTRL ioctl structure | ||
649 | + * | ||
650 | + * If the requested control is supported, returns the control information | ||
651 | + * from the video_control[] array. Otherwise, returns -EINVAL if the | ||
652 | + * control is not supported. | ||
653 | + */ | ||
654 | +static int ioctl_queryctrl(struct v4l2_int_device *s, | ||
655 | + struct v4l2_queryctrl *qc) | ||
656 | +{ | ||
657 | + debug_dummy("debug_dummy -- query ctrl\n"); | ||
658 | + return-EINVAL; | ||
659 | +} | ||
660 | + | ||
661 | +/** | ||
662 | + * ioctl_s_routing - V4L2 decoder interface handler for VIDIOC_S_INPUT ioctl | ||
663 | + * @s: pointer to standard V4L2 device structure | ||
664 | + * @index: number of the input | ||
665 | + * | ||
666 | + * If index is valid, selects the requested input. Otherwise, returns -EINVAL if | ||
667 | + * the input is not supported or there is no active signal present in the | ||
668 | + * selected input. | ||
669 | + */ | ||
670 | +static int ioctl_s_routing(struct v4l2_int_device *s, | ||
671 | + struct v4l2_routing *route) | ||
672 | +{ | ||
673 | + return 0; | ||
674 | +} | ||
675 | + | ||
676 | +/** | ||
677 | + * ioctl_g_ifparm - V4L2 decoder interface handler for vidioc_int_g_ifparm_num | ||
678 | + * @s: pointer to standard V4L2 device structure | ||
679 | + * @p: pointer to standard V4L2 vidioc_int_g_ifparm_num ioctl structure | ||
680 | + * | ||
681 | + * Gets slave interface parameters. | ||
682 | + * Calculates the required xclk value to support the requested | ||
683 | + * clock parameters in p. This value is returned in the p | ||
684 | + * parameter. | ||
685 | + */ | ||
686 | +static int ioctl_g_ifparm(struct v4l2_int_device *s, struct v4l2_ifparm *p) | ||
687 | +{ | ||
688 | + struct mt9t111_sensor *sensor = s->priv; | ||
689 | + int rval; | ||
690 | + | ||
691 | + if (p == NULL) | ||
692 | + return -EINVAL; | ||
693 | + | ||
694 | + if (NULL == sensor->pdata->ifparm) | ||
695 | + return -EINVAL; | ||
696 | + | ||
697 | + rval = sensor->pdata->ifparm(p); | ||
698 | + if (rval) { | ||
699 | + v4l_err(sensor->i2c_client, "g_ifparm.Err[%d]\n", rval); | ||
700 | + return rval; | ||
701 | + } | ||
702 | + | ||
703 | + p->u.ycbcr.clock_curr = 40*1000000; // temporal value | ||
704 | + | ||
705 | + return 0; | ||
706 | +} | ||
707 | + | ||
708 | + | ||
709 | +static struct v4l2_int_ioctl_desc mt9t111_ioctl_desc[] = { | ||
710 | + { .num = vidioc_int_enum_framesizes_num, | ||
711 | + .func = (v4l2_int_ioctl_func *)ioctl_enum_framesizes }, | ||
712 | + { .num = vidioc_int_enum_frameintervals_num, | ||
713 | + .func = (v4l2_int_ioctl_func *)ioctl_enum_frameintervals }, | ||
714 | + { .num = vidioc_int_dev_init_num, | ||
715 | + .func = (v4l2_int_ioctl_func *)ioctl_dev_init }, | ||
716 | + { .num = vidioc_int_dev_exit_num, | ||
717 | + .func = (v4l2_int_ioctl_func *)ioctl_dev_exit }, | ||
718 | + { .num = vidioc_int_s_power_num, | ||
719 | + .func = (v4l2_int_ioctl_func *)ioctl_s_power }, | ||
720 | + { .num = vidioc_int_g_priv_num, | ||
721 | + .func = (v4l2_int_ioctl_func *)ioctl_g_priv }, | ||
722 | + {vidioc_int_g_ifparm_num, | ||
723 | + .func = (v4l2_int_ioctl_func*) ioctl_g_ifparm}, | ||
724 | + { .num = vidioc_int_init_num, | ||
725 | + .func = (v4l2_int_ioctl_func *)ioctl_init }, | ||
726 | + { .num = vidioc_int_enum_fmt_cap_num, | ||
727 | + .func = (v4l2_int_ioctl_func *)ioctl_enum_fmt_cap }, | ||
728 | + { .num = vidioc_int_try_fmt_cap_num, | ||
729 | + .func = (v4l2_int_ioctl_func *)ioctl_try_fmt_cap }, | ||
730 | + { .num = vidioc_int_g_fmt_cap_num, | ||
731 | + .func = (v4l2_int_ioctl_func *)ioctl_g_fmt_cap }, | ||
732 | + { .num = vidioc_int_s_fmt_cap_num, | ||
733 | + .func = (v4l2_int_ioctl_func *)ioctl_s_fmt_cap }, | ||
734 | + { .num = vidioc_int_g_parm_num, | ||
735 | + .func = (v4l2_int_ioctl_func *)ioctl_g_parm }, | ||
736 | + { .num = vidioc_int_s_parm_num, | ||
737 | + .func = (v4l2_int_ioctl_func *)ioctl_s_parm }, | ||
738 | + { .num = vidioc_int_queryctrl_num, | ||
739 | + .func = (v4l2_int_ioctl_func *)ioctl_queryctrl }, | ||
740 | + { .num = vidioc_int_g_ctrl_num, | ||
741 | + .func = (v4l2_int_ioctl_func *)ioctl_g_ctrl }, | ||
742 | + { .num = vidioc_int_s_ctrl_num, | ||
743 | + .func = (v4l2_int_ioctl_func *)ioctl_s_ctrl }, | ||
744 | + {.num = vidioc_int_s_video_routing_num, | ||
745 | + .func = (v4l2_int_ioctl_func *) ioctl_s_routing}, | ||
746 | +}; | ||
747 | + | ||
748 | +static void mt9t111_refresh(struct i2c_client *client){ | ||
749 | + int i; | ||
750 | + unsigned short value; | ||
751 | + // MCU_ADDRESS [SEQ_CMD] -- refresh | ||
752 | + mt9t111_write_reg(client, 0x098E, 0x8400); | ||
753 | + mt9t111_write_reg(client, 0x0990, 0x0006); | ||
754 | + for (i=0;i<100;i++){ | ||
755 | + mt9t111_write_reg(client, 0x098E, 0x8400); | ||
756 | + mt9t111_read_reg(client,0x0990,&value); | ||
757 | + if ( value == 0) | ||
758 | + break; | ||
759 | + mdelay(5); | ||
760 | + } | ||
761 | +} | ||
762 | + | ||
763 | +#ifdef COLOR_BAR | ||
764 | +static void mt9t111_color_bar(struct i2c_client *client) | ||
765 | +{ | ||
766 | + mt9t111_write_reg(client, 0x3210, 0x01B0); // disable lens correction | ||
767 | + | ||
768 | + mt9t111_write_reg(client, 0x098E, 0x6003); | ||
769 | + mt9t111_write_reg(client, 0x0990, 0x0100); | ||
770 | + mt9t111_write_reg(client, 0x098E, 0x6025); | ||
771 | + mt9t111_write_reg(client, 0x0990, 0x0003); | ||
772 | +} | ||
773 | +#endif | ||
774 | + | ||
775 | +static void mt9t111_bayer_format(struct i2c_client *client) | ||
776 | +{ | ||
777 | + mt9t111_write_regs(client, bayer_pattern_regs, sizeof(bayer_pattern_regs)/sizeof(mt9t111_regs)); | ||
778 | +} | ||
779 | + | ||
780 | +static void mt9t111_enable_pll(struct i2c_client *client) | ||
781 | +{ | ||
782 | + int i; | ||
783 | + unsigned short value; | ||
784 | + | ||
785 | + mt9t111_write_regs(client, pll_regs1, sizeof(pll_regs1)/sizeof(mt9t111_regs)); | ||
786 | + for (i=0;i<100;i++){ | ||
787 | + mt9t111_read_reg(client,0x0014,&value); | ||
788 | + if (( value & 0x8000) != 0) | ||
789 | + break; | ||
790 | + mdelay(2); | ||
791 | + } | ||
792 | + mt9t111_write_regs(client, pll_regs2, sizeof(pll_regs2)/sizeof(mt9t111_regs)); | ||
793 | +} | ||
794 | + | ||
795 | + | ||
796 | +static void mt9t111_loaddefault(struct i2c_client *client) | ||
797 | +{ | ||
798 | + mt9t111_write_reg(client, 0x001A, 0x0219); | ||
799 | + mt9t111_write_reg(client, 0x001A, 0x0218); | ||
800 | + | ||
801 | + mt9t111_enable_pll(client); | ||
802 | + mt9t111_write_regs(client, def_regs1, sizeof(def_regs1)/sizeof(mt9t111_regs)); | ||
803 | + mt9t111_write_regs(client, patch_rev6, sizeof(patch_rev6)/sizeof(mt9t111_regs)); | ||
804 | + mt9t111_write_regs(client, def_regs2, sizeof(def_regs2)/sizeof(mt9t111_regs)); | ||
805 | + | ||
806 | +#ifdef USE_RAW | ||
807 | + mt9t111_bayer_format(client); | ||
808 | +#endif | ||
809 | + | ||
810 | +#ifdef COLOR_BAR | ||
811 | + mt9t111_color_bar(client); | ||
812 | +#endif | ||
813 | + | ||
814 | + mt9t111_refresh(client); | ||
815 | +} | ||
816 | + | ||
817 | +static struct v4l2_int_slave mt9t111_slave = { | ||
818 | + .ioctls = mt9t111_ioctl_desc, | ||
819 | + .num_ioctls = ARRAY_SIZE(mt9t111_ioctl_desc), | ||
820 | +}; | ||
821 | + | ||
822 | +static struct v4l2_int_device mt9t111_int_device = { | ||
823 | + .module = THIS_MODULE, | ||
824 | + .name = "mt9t111", | ||
825 | + .priv = &mt9t111, | ||
826 | + .type = v4l2_int_type_slave, | ||
827 | + .u = { | ||
828 | + .slave = &mt9t111_slave, | ||
829 | + }, | ||
830 | +}; | ||
831 | + | ||
832 | +/** | ||
833 | + * mt9t111_probe - sensor driver i2c probe handler | ||
834 | + * @client: i2c driver client device structure | ||
835 | + * | ||
836 | + * Register sensor as an i2c client device and V4L2 | ||
837 | + * device. | ||
838 | + */ | ||
839 | +static int | ||
840 | +mt9t111_probe(struct i2c_client *client, const struct i2c_device_id *id) | ||
841 | +{ | ||
842 | + struct mt9t111_sensor *sensor = &mt9t111; | ||
843 | + int err; | ||
844 | + | ||
845 | + if (i2c_get_clientdata(client)) | ||
846 | + return -EBUSY; | ||
847 | + | ||
848 | + sensor->pdata = client->dev.platform_data; | ||
849 | + | ||
850 | + if (!sensor->pdata) { | ||
851 | + dev_err(&client->dev, "no platform data?\n"); | ||
852 | + return -ENODEV; | ||
853 | + } | ||
854 | + | ||
855 | + sensor->v4l2_int_device = &mt9t111_int_device; | ||
856 | + sensor->i2c_client = client; | ||
857 | + | ||
858 | + i2c_set_clientdata(client, sensor); | ||
859 | + | ||
860 | + sensor->pix.width = 640; | ||
861 | + sensor->pix.height = 480; | ||
862 | +#ifdef USE_RAW | ||
863 | + sensor->pix.pixelformat = V4L2_PIX_FMT_SGRBG10; | ||
864 | +#else | ||
865 | + sensor->pix.pixelformat = V4L2_PIX_FMT_YUYV; | ||
866 | +#endif | ||
867 | + err = v4l2_int_device_register(sensor->v4l2_int_device); | ||
868 | + if (err) | ||
869 | + i2c_set_clientdata(client, NULL); | ||
870 | + return err; | ||
871 | +} | ||
872 | + | ||
873 | +/** | ||
874 | + * mt9t111_remove - sensor driver i2c remove handler | ||
875 | + * @client: i2c driver client device structure | ||
876 | + * | ||
877 | + * Unregister sensor as an i2c client device and V4L2 | ||
878 | + * device. Complement of mt9t111_probe(). | ||
879 | + */ | ||
880 | +static int __exit | ||
881 | +mt9t111_remove(struct i2c_client *client) | ||
882 | +{ | ||
883 | + struct mt9t111_sensor *sensor = i2c_get_clientdata(client); | ||
884 | + | ||
885 | + if (!client->adapter) | ||
886 | + return -ENODEV; /* our client isn't attached */ | ||
887 | + | ||
888 | + v4l2_int_device_unregister(sensor->v4l2_int_device); | ||
889 | + i2c_set_clientdata(client, NULL); | ||
890 | + | ||
891 | + return 0; | ||
892 | +} | ||
893 | + | ||
894 | +static const struct i2c_device_id mt9t111_id[] = { | ||
895 | + { "mt9t111", 0 }, | ||
896 | + { }, | ||
897 | +}; | ||
898 | +MODULE_DEVICE_TABLE(i2c, mt9t111_id); | ||
899 | + | ||
900 | +static struct i2c_driver mt9t111sensor_i2c_driver = { | ||
901 | + .driver = { | ||
902 | + .name = "mt9t111", | ||
903 | + .owner = THIS_MODULE, | ||
904 | + }, | ||
905 | + .probe = mt9t111_probe, | ||
906 | + .remove = __exit_p(mt9t111_remove), | ||
907 | + .id_table = mt9t111_id, | ||
908 | +}; | ||
909 | + | ||
910 | +/** | ||
911 | + * mt9t111sensor_init - sensor driver module_init handler | ||
912 | + * | ||
913 | + * Registers driver as an i2c client driver. Returns 0 on success, | ||
914 | + * error code otherwise. | ||
915 | + */ | ||
916 | +static int __init mt9t111sensor_init(void) | ||
917 | +{ | ||
918 | +printk(KERN_INFO "entering mt9t111sensor_init\n"); | ||
919 | + return i2c_add_driver(&mt9t111sensor_i2c_driver); | ||
920 | +} | ||
921 | +module_init(mt9t111sensor_init); | ||
922 | + | ||
923 | +/** | ||
924 | + * mt9t111sensor_cleanup - sensor driver module_exit handler | ||
925 | + * | ||
926 | + * Unregisters/deletes driver as an i2c client driver. | ||
927 | + * Complement of mt9t111sensor_init. | ||
928 | + */ | ||
929 | +static void __exit mt9t111sensor_cleanup(void) | ||
930 | +{ | ||
931 | + i2c_del_driver(&mt9t111sensor_i2c_driver); | ||
932 | +} | ||
933 | +module_exit(mt9t111sensor_cleanup); | ||
934 | + | ||
935 | +MODULE_LICENSE("GPL"); | ||
936 | +MODULE_DESCRIPTION("mt9t111 camera sensor driver"); | ||
937 | diff --git a/drivers/media/video/mt9t111_reg.h b/drivers/media/video/mt9t111_reg.h | ||
938 | new file mode 100644 | ||
939 | index 0000000..e012eeb | ||
940 | --- /dev/null | ||
941 | +++ b/drivers/media/video/mt9t111_reg.h | ||
942 | @@ -0,0 +1,1364 @@ | ||
943 | +/* | ||
944 | + * drivers/media/video/mt9t111_reg.h | ||
945 | + * | ||
946 | + * mt9t111 sensor driver header file | ||
947 | + * | ||
948 | + * Copyright (C) 2009 Leopard Imaging | ||
949 | + * | ||
950 | + * This file is licensed under the terms of the GNU General Public License | ||
951 | + * version 2. This program is licensed "as is" without any warranty of any | ||
952 | + * kind, whether express or implied. | ||
953 | + */ | ||
954 | + | ||
955 | +#ifndef MT9T111_REG_H | ||
956 | +#define MT9T111_REG_H | ||
957 | + | ||
958 | +/* register addr */ | ||
959 | +#define MT9T111_CHIP_ID (0x0000) | ||
960 | + | ||
961 | +/* register value */ | ||
962 | +#define MT9T111_CHIP_ID_VALUE (0x2680) | ||
963 | + | ||
964 | +typedef struct { | ||
965 | + u16 delay_time; | ||
966 | + u16 addr; | ||
967 | + u16 data; | ||
968 | +} mt9t111_regs; | ||
969 | + | ||
970 | +mt9t111_regs patch_rev6[] ={ | ||
971 | + {0, 0x0982, 0x0}, | ||
972 | + {0, 0x098A, 0xCE7}, | ||
973 | + {0, 0x0990, 0x3C3C}, | ||
974 | + {0, 0x0992, 0x3C3C}, | ||
975 | + {0, 0x0994, 0x3C5F}, | ||
976 | + {0, 0x0996, 0x4F30}, | ||
977 | + {0, 0x0998, 0xED08}, | ||
978 | + {0, 0x099a, 0xBD61}, | ||
979 | + {0, 0x099c, 0xD5CE}, | ||
980 | + {0, 0x099e, 0x4CD}, | ||
981 | + {0, 0x098A, 0xCF7}, | ||
982 | + {0, 0x0990, 0x1F17}, | ||
983 | + {0, 0x0992, 0x211}, | ||
984 | + {0, 0x0994, 0xCC33}, | ||
985 | + {0, 0x0996, 0x2E30}, | ||
986 | + {0, 0x0998, 0xED02}, | ||
987 | + {0, 0x099a, 0xCCFF}, | ||
988 | + {0, 0x099c, 0xFDED}, | ||
989 | + {0, 0x099e, 0xCC}, | ||
990 | + {0, 0x098A, 0xD07}, | ||
991 | + {0, 0x0990, 0x2}, | ||
992 | + {0, 0x0992, 0xBD70}, | ||
993 | + {0, 0x0994, 0x6D18}, | ||
994 | + {0, 0x0996, 0xDE1F}, | ||
995 | + {0, 0x0998, 0x181F}, | ||
996 | + {0, 0x099a, 0x8E01}, | ||
997 | + {0, 0x099c, 0x10CC}, | ||
998 | + {0, 0x099e, 0x3C52}, | ||
999 | + {0, 0x098A, 0xD17}, | ||
1000 | + {0, 0x0990, 0x30ED}, | ||
1001 | + {0, 0x0992, 0x18}, | ||
1002 | + {0, 0x0994, 0xECA0}, | ||
1003 | + {0, 0x0996, 0xC4FD}, | ||
1004 | + {0, 0x0998, 0xBD70}, | ||
1005 | + {0, 0x099a, 0x2120}, | ||
1006 | + {0, 0x099c, 0x1ECC}, | ||
1007 | + {0, 0x099e, 0x3C52}, | ||
1008 | + {0, 0x098A, 0xD27}, | ||
1009 | + {0, 0x0990, 0x30ED}, | ||
1010 | + {0, 0x0992, 0xDE}, | ||
1011 | + {0, 0x0994, 0x1FEC}, | ||
1012 | + {0, 0x0996, 0xA0BD}, | ||
1013 | + {0, 0x0998, 0x7021}, | ||
1014 | + {0, 0x099a, 0xCC3C}, | ||
1015 | + {0, 0x099c, 0x5230}, | ||
1016 | + {0, 0x099e, 0xED02}, | ||
1017 | + {0, 0x098A, 0xD37}, | ||
1018 | + {0, 0x0990, 0xCCFF}, | ||
1019 | + {0, 0x0992, 0xFCED}, | ||
1020 | + {0, 0x0994, 0xCC}, | ||
1021 | + {0, 0x0996, 0x2}, | ||
1022 | + {0, 0x0998, 0xBD70}, | ||
1023 | + {0, 0x099a, 0x6DFC}, | ||
1024 | + {0, 0x099c, 0x4E1}, | ||
1025 | + {0, 0x099e, 0x1A83}, | ||
1026 | + {0, 0x098A, 0xD47}, | ||
1027 | + {0, 0x0990, 0x1}, | ||
1028 | + {0, 0x0992, 0x2720}, | ||
1029 | + {0, 0x0994, 0x1A83}, | ||
1030 | + {0, 0x0996, 0x4}, | ||
1031 | + {0, 0x0998, 0x271E}, | ||
1032 | + {0, 0x099a, 0x1A83}, | ||
1033 | + {0, 0x099c, 0x8}, | ||
1034 | + {0, 0x099e, 0x271C}, | ||
1035 | + {0, 0x098A, 0xD57}, | ||
1036 | + {0, 0x0990, 0x1A83}, | ||
1037 | + {0, 0x0992, 0x10}, | ||
1038 | + {0, 0x0994, 0x271A}, | ||
1039 | + {0, 0x0996, 0x1A83}, | ||
1040 | + {0, 0x0998, 0x20}, | ||
1041 | + {0, 0x099a, 0x2718}, | ||
1042 | + {0, 0x099c, 0x1A83}, | ||
1043 | + {0, 0x099e, 0x40}, | ||
1044 | + {0, 0x098A, 0xD67}, | ||
1045 | + {0, 0x0990, 0x2716}, | ||
1046 | + {0, 0x0992, 0x2019}, | ||
1047 | + {0, 0x0994, 0xC61E}, | ||
1048 | + {0, 0x0996, 0x2012}, | ||
1049 | + {0, 0x0998, 0xC622}, | ||
1050 | + {0, 0x099a, 0x200E}, | ||
1051 | + {0, 0x099c, 0xC621}, | ||
1052 | + {0, 0x099e, 0x200A}, | ||
1053 | + {0, 0x098A, 0xD77}, | ||
1054 | + {0, 0x0990, 0xC620}, | ||
1055 | + {0, 0x0992, 0x2006}, | ||
1056 | + {0, 0x0994, 0xC62A}, | ||
1057 | + {0, 0x0996, 0x2002}, | ||
1058 | + {0, 0x0998, 0xC62B}, | ||
1059 | + {0, 0x099a, 0x30ED}, | ||
1060 | + {0, 0x099c, 0x8CC}, | ||
1061 | + {0, 0x099e, 0x3400}, | ||
1062 | + {0, 0x098A, 0xD87}, | ||
1063 | + {0, 0x0990, 0x30ED}, | ||
1064 | + {0, 0x0992, 0x34}, | ||
1065 | + {0, 0x0994, 0xBD6F}, | ||
1066 | + {0, 0x0996, 0xD184}, | ||
1067 | + {0, 0x0998, 0x330}, | ||
1068 | + {0, 0x099a, 0xED07}, | ||
1069 | + {0, 0x099c, 0xA60A}, | ||
1070 | + {0, 0x099e, 0x4848}, | ||
1071 | + {0, 0x098A, 0xD97}, | ||
1072 | + {0, 0x0990, 0x5FED}, | ||
1073 | + {0, 0x0992, 0x5EA}, | ||
1074 | + {0, 0x0994, 0x8AA}, | ||
1075 | + {0, 0x0996, 0x731}, | ||
1076 | + {0, 0x0998, 0xBD70}, | ||
1077 | + {0, 0x099a, 0x2130}, | ||
1078 | + {0, 0x099c, 0xC60A}, | ||
1079 | + {0, 0x099e, 0x3A35}, | ||
1080 | + {0, 0x098A, 0xDA7}, | ||
1081 | + {0, 0x0990, 0x3937}, | ||
1082 | + {0, 0x0992, 0x3C3C}, | ||
1083 | + {0, 0x0994, 0x3C34}, | ||
1084 | + {0, 0x0996, 0xDE2F}, | ||
1085 | + {0, 0x0998, 0xEE0E}, | ||
1086 | + {0, 0x099a, 0xAD00}, | ||
1087 | + {0, 0x099c, 0x7D13}, | ||
1088 | + {0, 0x099e, 0xEF27}, | ||
1089 | + {0, 0x098A, 0xDB7}, | ||
1090 | + {0, 0x0990, 0x7CCE}, | ||
1091 | + {0, 0x0992, 0x13E0}, | ||
1092 | + {0, 0x0994, 0x1E05}, | ||
1093 | + {0, 0x0996, 0x1060}, | ||
1094 | + {0, 0x0998, 0xE60E}, | ||
1095 | + {0, 0x099a, 0x4FC3}, | ||
1096 | + {0, 0x099c, 0x13F0}, | ||
1097 | + {0, 0x099e, 0x8FE6}, | ||
1098 | + {0, 0x098A, 0xDC7}, | ||
1099 | + {0, 0x0990, 0x30}, | ||
1100 | + {0, 0x0992, 0xE107}, | ||
1101 | + {0, 0x0994, 0x2216}, | ||
1102 | + {0, 0x0996, 0xF613}, | ||
1103 | + {0, 0x0998, 0xEE4F}, | ||
1104 | + {0, 0x099a, 0xC313}, | ||
1105 | + {0, 0x099c, 0xF38F}, | ||
1106 | + {0, 0x099e, 0xE600}, | ||
1107 | + {0, 0x098A, 0xDD7}, | ||
1108 | + {0, 0x0990, 0x30E1}, | ||
1109 | + {0, 0x0992, 0x725}, | ||
1110 | + {0, 0x0994, 0x7F6}, | ||
1111 | + {0, 0x0996, 0x13EE}, | ||
1112 | + {0, 0x0998, 0xC103}, | ||
1113 | + {0, 0x099a, 0x253C}, | ||
1114 | + {0, 0x099c, 0x7F13}, | ||
1115 | + {0, 0x099e, 0xEEF6}, | ||
1116 | + {0, 0x098A, 0xDE7}, | ||
1117 | + {0, 0x0990, 0x13EF}, | ||
1118 | + {0, 0x0992, 0xE706}, | ||
1119 | + {0, 0x0994, 0xCC13}, | ||
1120 | + {0, 0x0996, 0xF0ED}, | ||
1121 | + {0, 0x0998, 0x4CC}, | ||
1122 | + {0, 0x099a, 0x13F3}, | ||
1123 | + {0, 0x099c, 0x200F}, | ||
1124 | + {0, 0x099e, 0x7C13}, | ||
1125 | + {0, 0x098A, 0xDF7}, | ||
1126 | + {0, 0x0990, 0xEEEC}, | ||
1127 | + {0, 0x0992, 0x4C3}, | ||
1128 | + {0, 0x0994, 0x1}, | ||
1129 | + {0, 0x0996, 0xED04}, | ||
1130 | + {0, 0x0998, 0xEC02}, | ||
1131 | + {0, 0x099a, 0xC300}, | ||
1132 | + {0, 0x099c, 0x1ED}, | ||
1133 | + {0, 0x099e, 0x2F6}, | ||
1134 | + {0, 0x098A, 0xE07}, | ||
1135 | + {0, 0x0990, 0x13EE}, | ||
1136 | + {0, 0x0992, 0xE106}, | ||
1137 | + {0, 0x0994, 0x2412}, | ||
1138 | + {0, 0x0996, 0xEE04}, | ||
1139 | + {0, 0x0998, 0xE600}, | ||
1140 | + {0, 0x099a, 0x30E1}, | ||
1141 | + {0, 0x099c, 0x722}, | ||
1142 | + {0, 0x099e, 0xDFEE}, | ||
1143 | + {0, 0x098A, 0xE17}, | ||
1144 | + {0, 0x0990, 0x2E6}, | ||
1145 | + {0, 0x0992, 0x30}, | ||
1146 | + {0, 0x0994, 0xE107}, | ||
1147 | + {0, 0x0996, 0x25D6}, | ||
1148 | + {0, 0x0998, 0xDE49}, | ||
1149 | + {0, 0x099a, 0xEE08}, | ||
1150 | + {0, 0x099c, 0xAD00}, | ||
1151 | + {0, 0x099e, 0xCC13}, | ||
1152 | + {0, 0x098A, 0xE27}, | ||
1153 | + {0, 0x0990, 0xF630}, | ||
1154 | + {0, 0x0992, 0xED00}, | ||
1155 | + {0, 0x0994, 0xDE2F}, | ||
1156 | + {0, 0x0996, 0xEE10}, | ||
1157 | + {0, 0x0998, 0xCC13}, | ||
1158 | + {0, 0x099a, 0xFAAD}, | ||
1159 | + {0, 0x099c, 0x38}, | ||
1160 | + {0, 0x099e, 0x3838}, | ||
1161 | + {0, 0x098A, 0xE37}, | ||
1162 | + {0, 0x0990, 0x3839}, | ||
1163 | + {0, 0x098A, 0x1000}, | ||
1164 | + {0, 0x0990, 0xCC10}, | ||
1165 | + {0, 0x0992, 0x9BD}, | ||
1166 | + {0, 0x0994, 0x4224}, | ||
1167 | + {0, 0x0996, 0x7E10}, | ||
1168 | + {0, 0x0998, 0x9C6}, | ||
1169 | + {0, 0x099a, 0x1F7}, | ||
1170 | + {0, 0x099c, 0x18A}, | ||
1171 | + {0, 0x099e, 0xC606}, | ||
1172 | + {0, 0x098A, 0x1010}, | ||
1173 | + {0, 0x0990, 0xF701}, | ||
1174 | + {0, 0x0992, 0x8BDE}, | ||
1175 | + {0, 0x0994, 0x3F18}, | ||
1176 | + {0, 0x0996, 0xCE0B}, | ||
1177 | + {0, 0x0998, 0xF1CC}, | ||
1178 | + {0, 0x099a, 0x11}, | ||
1179 | + {0, 0x099c, 0xBDD7}, | ||
1180 | + {0, 0x099e, 0xCC}, | ||
1181 | + {0, 0x098A, 0x1020}, | ||
1182 | + {0, 0x0990, 0xBF1}, | ||
1183 | + {0, 0x0992, 0xDD3F}, | ||
1184 | + {0, 0x0994, 0xDE35}, | ||
1185 | + {0, 0x0996, 0x18CE}, | ||
1186 | + {0, 0x0998, 0xC03}, | ||
1187 | + {0, 0x099a, 0xCC00}, | ||
1188 | + {0, 0x099c, 0x3FBD}, | ||
1189 | + {0, 0x099e, 0xD700}, | ||
1190 | + {0, 0x098A, 0x1030}, | ||
1191 | + {0, 0x0990, 0xCC0C}, | ||
1192 | + {0, 0x0992, 0x3DD}, | ||
1193 | + {0, 0x0994, 0x35DE}, | ||
1194 | + {0, 0x0996, 0x4718}, | ||
1195 | + {0, 0x0998, 0xCE0C}, | ||
1196 | + {0, 0x099a, 0x43CC}, | ||
1197 | + {0, 0x099c, 0x15}, | ||
1198 | + {0, 0x099e, 0xBDD7}, | ||
1199 | + {0, 0x098A, 0x1040}, | ||
1200 | + {0, 0x0990, 0xCC}, | ||
1201 | + {0, 0x0992, 0xC43}, | ||
1202 | + {0, 0x0994, 0xDD47}, | ||
1203 | + {0, 0x0996, 0xFE00}, | ||
1204 | + {0, 0x0998, 0x3318}, | ||
1205 | + {0, 0x099a, 0xCE0C}, | ||
1206 | + {0, 0x099c, 0x59CC}, | ||
1207 | + {0, 0x099e, 0x9}, | ||
1208 | + {0, 0x098A, 0x1050}, | ||
1209 | + {0, 0x0990, 0xBDD7}, | ||
1210 | + {0, 0x0992, 0xCC}, | ||
1211 | + {0, 0x0994, 0xC59}, | ||
1212 | + {0, 0x0996, 0xFD00}, | ||
1213 | + {0, 0x0998, 0x33DE}, | ||
1214 | + {0, 0x099a, 0x4118}, | ||
1215 | + {0, 0x099c, 0xCE0C}, | ||
1216 | + {0, 0x099e, 0x63CC}, | ||
1217 | + {0, 0x098A, 0x1060}, | ||
1218 | + {0, 0x0990, 0xD}, | ||
1219 | + {0, 0x0992, 0xBDD7}, | ||
1220 | + {0, 0x0994, 0xCC}, | ||
1221 | + {0, 0x0996, 0xC63}, | ||
1222 | + {0, 0x0998, 0xDD41}, | ||
1223 | + {0, 0x099a, 0xFE00}, | ||
1224 | + {0, 0x099c, 0x3118}, | ||
1225 | + {0, 0x099e, 0xCE0C}, | ||
1226 | + {0, 0x098A, 0x1070}, | ||
1227 | + {0, 0x0990, 0x71CC}, | ||
1228 | + {0, 0x0992, 0x29}, | ||
1229 | + {0, 0x0994, 0xBDD7}, | ||
1230 | + {0, 0x0996, 0xCC}, | ||
1231 | + {0, 0x0998, 0xC71}, | ||
1232 | + {0, 0x099a, 0xFD00}, | ||
1233 | + {0, 0x099c, 0x31DE}, | ||
1234 | + {0, 0x099e, 0x3918}, | ||
1235 | + {0, 0x098A, 0x1080}, | ||
1236 | + {0, 0x0990, 0xCE0C}, | ||
1237 | + {0, 0x0992, 0x9BCC}, | ||
1238 | + {0, 0x0994, 0x23}, | ||
1239 | + {0, 0x0996, 0xBDD7}, | ||
1240 | + {0, 0x0998, 0xCC}, | ||
1241 | + {0, 0x099a, 0xC9B}, | ||
1242 | + {0, 0x099c, 0xDD39}, | ||
1243 | + {0, 0x099e, 0xDE49}, | ||
1244 | + {0, 0x098A, 0x1090}, | ||
1245 | + {0, 0x0990, 0x18CE}, | ||
1246 | + {0, 0x0992, 0xCBF}, | ||
1247 | + {0, 0x0994, 0xCC00}, | ||
1248 | + {0, 0x0996, 0xDBD}, | ||
1249 | + {0, 0x0998, 0xD700}, | ||
1250 | + {0, 0x099a, 0xCC0C}, | ||
1251 | + {0, 0x099c, 0xBFDD}, | ||
1252 | + {0, 0x099e, 0x49CC}, | ||
1253 | + {0, 0x098A, 0x10A0}, | ||
1254 | + {0, 0x0990, 0x1162}, | ||
1255 | + {0, 0x0992, 0xFD0B}, | ||
1256 | + {0, 0x0994, 0xFDCC}, | ||
1257 | + {0, 0x0996, 0xCE7}, | ||
1258 | + {0, 0x0998, 0xFD0C}, | ||
1259 | + {0, 0x099a, 0x1FCC}, | ||
1260 | + {0, 0x099c, 0x1245}, | ||
1261 | + {0, 0x099e, 0xFD0C}, | ||
1262 | + {0, 0x098A, 0x10B0}, | ||
1263 | + {0, 0x0990, 0x51CC}, | ||
1264 | + {0, 0x0992, 0x110B}, | ||
1265 | + {0, 0x0994, 0xFD0C}, | ||
1266 | + {0, 0x0996, 0x5BCC}, | ||
1267 | + {0, 0x0998, 0x1108}, | ||
1268 | + {0, 0x099a, 0xFD0C}, | ||
1269 | + {0, 0x099c, 0x65CC}, | ||
1270 | + {0, 0x099e, 0x10D0}, | ||
1271 | + {0, 0x098A, 0x10C0}, | ||
1272 | + {0, 0x0990, 0xFD0C}, | ||
1273 | + {0, 0x0992, 0x7BCC}, | ||
1274 | + {0, 0x0994, 0x12DE}, | ||
1275 | + {0, 0x0996, 0xFD0C}, | ||
1276 | + {0, 0x0998, 0xA7CC}, | ||
1277 | + {0, 0x099a, 0xDA8}, | ||
1278 | + {0, 0x099c, 0xFD0C}, | ||
1279 | + {0, 0x099e, 0xCB39}, | ||
1280 | + {0, 0x098A, 0x10D0}, | ||
1281 | + {0, 0x0990, 0x37DE}, | ||
1282 | + {0, 0x0992, 0x1DEC}, | ||
1283 | + {0, 0x0994, 0xC5F}, | ||
1284 | + {0, 0x0996, 0x8402}, | ||
1285 | + {0, 0x0998, 0x4416}, | ||
1286 | + {0, 0x099a, 0x4FF7}, | ||
1287 | + {0, 0x099c, 0xCCD}, | ||
1288 | + {0, 0x099e, 0xE60B}, | ||
1289 | + {0, 0x098A, 0x10E0}, | ||
1290 | + {0, 0x0990, 0xC407}, | ||
1291 | + {0, 0x0992, 0xF70C}, | ||
1292 | + {0, 0x0994, 0xCE7F}, | ||
1293 | + {0, 0x0996, 0x30C4}, | ||
1294 | + {0, 0x0998, 0xEC25}, | ||
1295 | + {0, 0x099a, 0xFD30}, | ||
1296 | + {0, 0x099c, 0xC5FC}, | ||
1297 | + {0, 0x099e, 0x6D6}, | ||
1298 | + {0, 0x098A, 0x10F0}, | ||
1299 | + {0, 0x0990, 0xFD30}, | ||
1300 | + {0, 0x0992, 0xC701}, | ||
1301 | + {0, 0x0994, 0xFC30}, | ||
1302 | + {0, 0x0996, 0xC0FD}, | ||
1303 | + {0, 0x0998, 0xBED}, | ||
1304 | + {0, 0x099a, 0xFC30}, | ||
1305 | + {0, 0x099c, 0xC2FD}, | ||
1306 | + {0, 0x099e, 0xBEF}, | ||
1307 | + {0, 0x098A, 0x1100}, | ||
1308 | + {0, 0x0990, 0x30E6}, | ||
1309 | + {0, 0x0992, 0xBD}, | ||
1310 | + {0, 0x0994, 0x5203}, | ||
1311 | + {0, 0x0996, 0x3139}, | ||
1312 | + {0, 0x0998, 0x7E9E}, | ||
1313 | + {0, 0x099a, 0x143C}, | ||
1314 | + {0, 0x099c, 0x3C3C}, | ||
1315 | + {0, 0x099e, 0x2101}, | ||
1316 | + {0, 0x098A, 0x1110}, | ||
1317 | + {0, 0x0990, 0xCC00}, | ||
1318 | + {0, 0x0992, 0x18BD}, | ||
1319 | + {0, 0x0994, 0x6FD1}, | ||
1320 | + {0, 0x0996, 0xC504}, | ||
1321 | + {0, 0x0998, 0x26F5}, | ||
1322 | + {0, 0x099a, 0xDC25}, | ||
1323 | + {0, 0x099c, 0x30ED}, | ||
1324 | + {0, 0x099e, 0x420}, | ||
1325 | + {0, 0x098A, 0x1120}, | ||
1326 | + {0, 0x0990, 0x12EE}, | ||
1327 | + {0, 0x0992, 0x43C}, | ||
1328 | + {0, 0x0994, 0x1838}, | ||
1329 | + {0, 0x0996, 0xE621}, | ||
1330 | + {0, 0x0998, 0x18E7}, | ||
1331 | + {0, 0x099a, 0xBE30}, | ||
1332 | + {0, 0x099c, 0xEE04}, | ||
1333 | + {0, 0x099e, 0xEC1D}, | ||
1334 | + {0, 0x098A, 0x1130}, | ||
1335 | + {0, 0x0990, 0x30ED}, | ||
1336 | + {0, 0x0992, 0x4EC}, | ||
1337 | + {0, 0x0994, 0x426}, | ||
1338 | + {0, 0x0996, 0xEACC}, | ||
1339 | + {0, 0x0998, 0x1A}, | ||
1340 | + {0, 0x099a, 0xED02}, | ||
1341 | + {0, 0x099c, 0xCCFB}, | ||
1342 | + {0, 0x099e, 0xFFED}, | ||
1343 | + {0, 0x098A, 0x1140}, | ||
1344 | + {0, 0x0990, 0xCC}, | ||
1345 | + {0, 0x0992, 0x400}, | ||
1346 | + {0, 0x0994, 0xBD70}, | ||
1347 | + {0, 0x0996, 0x6DCC}, | ||
1348 | + {0, 0x0998, 0x1A}, | ||
1349 | + {0, 0x099a, 0x30ED}, | ||
1350 | + {0, 0x099c, 0x2CC}, | ||
1351 | + {0, 0x099e, 0xFBFF}, | ||
1352 | + {0, 0x098A, 0x1150}, | ||
1353 | + {0, 0x0990, 0xED00}, | ||
1354 | + {0, 0x0992, 0x5F4F}, | ||
1355 | + {0, 0x0994, 0xBD70}, | ||
1356 | + {0, 0x0996, 0x6D5F}, | ||
1357 | + {0, 0x0998, 0xBD5B}, | ||
1358 | + {0, 0x099a, 0x17BD}, | ||
1359 | + {0, 0x099c, 0x558B}, | ||
1360 | + {0, 0x099e, 0x3838}, | ||
1361 | + {0, 0x098A, 0x1160}, | ||
1362 | + {0, 0x0990, 0x3839}, | ||
1363 | + {0, 0x0992, 0x3C3C}, | ||
1364 | + {0, 0x0994, 0xC640}, | ||
1365 | + {0, 0x0996, 0xF730}, | ||
1366 | + {0, 0x0998, 0xC4FC}, | ||
1367 | + {0, 0x099a, 0xBED}, | ||
1368 | + {0, 0x099c, 0xFD30}, | ||
1369 | + {0, 0x099e, 0xC0FC}, | ||
1370 | + {0, 0x098A, 0x1170}, | ||
1371 | + {0, 0x0990, 0xBEF}, | ||
1372 | + {0, 0x0992, 0xFD30}, | ||
1373 | + {0, 0x0994, 0xC2DE}, | ||
1374 | + {0, 0x0996, 0x1DEC}, | ||
1375 | + {0, 0x0998, 0x25FD}, | ||
1376 | + {0, 0x099a, 0x30C5}, | ||
1377 | + {0, 0x099c, 0x101}, | ||
1378 | + {0, 0x099e, 0x1FC}, | ||
1379 | + {0, 0x098A, 0x1180}, | ||
1380 | + {0, 0x0990, 0x30C2}, | ||
1381 | + {0, 0x0992, 0xFD06}, | ||
1382 | + {0, 0x0994, 0xD6EC}, | ||
1383 | + {0, 0x0996, 0xC5F}, | ||
1384 | + {0, 0x0998, 0x8402}, | ||
1385 | + {0, 0x099a, 0x4416}, | ||
1386 | + {0, 0x099c, 0x4F30}, | ||
1387 | + {0, 0x099e, 0xE703}, | ||
1388 | + {0, 0x098A, 0x1190}, | ||
1389 | + {0, 0x0990, 0xF10C}, | ||
1390 | + {0, 0x0992, 0xCD27}, | ||
1391 | + {0, 0x0994, 0x15F1}, | ||
1392 | + {0, 0x0996, 0xCCD}, | ||
1393 | + {0, 0x0998, 0x2309}, | ||
1394 | + {0, 0x099a, 0xFC06}, | ||
1395 | + {0, 0x099c, 0xD604}, | ||
1396 | + {0, 0x099e, 0xFD06}, | ||
1397 | + {0, 0x098A, 0x11A0}, | ||
1398 | + {0, 0x0990, 0xD620}, | ||
1399 | + {0, 0x0992, 0x7FC}, | ||
1400 | + {0, 0x0994, 0x6D6}, | ||
1401 | + {0, 0x0996, 0x5FD}, | ||
1402 | + {0, 0x0998, 0x6D6}, | ||
1403 | + {0, 0x099a, 0xDE1D}, | ||
1404 | + {0, 0x099c, 0xE60B}, | ||
1405 | + {0, 0x099e, 0xC407}, | ||
1406 | + {0, 0x098A, 0x11B0}, | ||
1407 | + {0, 0x0990, 0x30E7}, | ||
1408 | + {0, 0x0992, 0x2F1}, | ||
1409 | + {0, 0x0994, 0xCCE}, | ||
1410 | + {0, 0x0996, 0x272C}, | ||
1411 | + {0, 0x0998, 0x7D0C}, | ||
1412 | + {0, 0x099a, 0xCE27}, | ||
1413 | + {0, 0x099c, 0x275D}, | ||
1414 | + {0, 0x099e, 0x2724}, | ||
1415 | + {0, 0x098A, 0x11C0}, | ||
1416 | + {0, 0x0990, 0x7F30}, | ||
1417 | + {0, 0x0992, 0xC4FC}, | ||
1418 | + {0, 0x0994, 0x6D6}, | ||
1419 | + {0, 0x0996, 0xFD30}, | ||
1420 | + {0, 0x0998, 0xC5F6}, | ||
1421 | + {0, 0x099a, 0xCCE}, | ||
1422 | + {0, 0x099c, 0x4FFD}, | ||
1423 | + {0, 0x099e, 0x30C7}, | ||
1424 | + {0, 0x098A, 0x11D0}, | ||
1425 | + {0, 0x0990, 0xC640}, | ||
1426 | + {0, 0x0992, 0xF730}, | ||
1427 | + {0, 0x0994, 0xC4E6}, | ||
1428 | + {0, 0x0996, 0x24F}, | ||
1429 | + {0, 0x0998, 0xFD30}, | ||
1430 | + {0, 0x099a, 0xC501}, | ||
1431 | + {0, 0x099c, 0x101}, | ||
1432 | + {0, 0x099e, 0xFC30}, | ||
1433 | + {0, 0x098A, 0x11E0}, | ||
1434 | + {0, 0x0990, 0xC2FD}, | ||
1435 | + {0, 0x0992, 0x6D6}, | ||
1436 | + {0, 0x0994, 0x7D06}, | ||
1437 | + {0, 0x0996, 0xCB27}, | ||
1438 | + {0, 0x0998, 0x2EC6}, | ||
1439 | + {0, 0x099a, 0x40F7}, | ||
1440 | + {0, 0x099c, 0x30C4}, | ||
1441 | + {0, 0x099e, 0xFC06}, | ||
1442 | + {0, 0x098A, 0x11F0}, | ||
1443 | + {0, 0x0990, 0xC104}, | ||
1444 | + {0, 0x0992, 0xF306}, | ||
1445 | + {0, 0x0994, 0xD6ED}, | ||
1446 | + {0, 0x0996, 0x5F}, | ||
1447 | + {0, 0x0998, 0x6D00}, | ||
1448 | + {0, 0x099a, 0x2A01}, | ||
1449 | + {0, 0x099c, 0x5317}, | ||
1450 | + {0, 0x099e, 0xFD30}, | ||
1451 | + {0, 0x098A, 0x1200}, | ||
1452 | + {0, 0x0990, 0xC0EC}, | ||
1453 | + {0, 0x0992, 0xFD}, | ||
1454 | + {0, 0x0994, 0x30C2}, | ||
1455 | + {0, 0x0996, 0xFC06}, | ||
1456 | + {0, 0x0998, 0xC1FD}, | ||
1457 | + {0, 0x099a, 0x30C5}, | ||
1458 | + {0, 0x099c, 0x101}, | ||
1459 | + {0, 0x099e, 0x1FC}, | ||
1460 | + {0, 0x098A, 0x1210}, | ||
1461 | + {0, 0x0990, 0x30C2}, | ||
1462 | + {0, 0x0992, 0xFD06}, | ||
1463 | + {0, 0x0994, 0xC720}, | ||
1464 | + {0, 0x0996, 0x227F}, | ||
1465 | + {0, 0x0998, 0x30C4}, | ||
1466 | + {0, 0x099a, 0xDE1D}, | ||
1467 | + {0, 0x099c, 0xEC25}, | ||
1468 | + {0, 0x099e, 0xFD30}, | ||
1469 | + {0, 0x098A, 0x1220}, | ||
1470 | + {0, 0x0990, 0xC5FC}, | ||
1471 | + {0, 0x0992, 0x6D6}, | ||
1472 | + {0, 0x0994, 0xFD30}, | ||
1473 | + {0, 0x0996, 0xC701}, | ||
1474 | + {0, 0x0998, 0xFC30}, | ||
1475 | + {0, 0x099a, 0xC0FD}, | ||
1476 | + {0, 0x099c, 0x6D0}, | ||
1477 | + {0, 0x099e, 0xFC30}, | ||
1478 | + {0, 0x098A, 0x1230}, | ||
1479 | + {0, 0x0990, 0xC2FD}, | ||
1480 | + {0, 0x0992, 0x6D2}, | ||
1481 | + {0, 0x0994, 0xEC25}, | ||
1482 | + {0, 0x0996, 0xFD06}, | ||
1483 | + {0, 0x0998, 0xC3BD}, | ||
1484 | + {0, 0x099a, 0x953C}, | ||
1485 | + {0, 0x099c, 0xDE3F}, | ||
1486 | + {0, 0x099e, 0xEE10}, | ||
1487 | + {0, 0x098A, 0x1240}, | ||
1488 | + {0, 0x0990, 0xAD00}, | ||
1489 | + {0, 0x0992, 0x3838}, | ||
1490 | + {0, 0x0994, 0x3930}, | ||
1491 | + {0, 0x0996, 0x8FC3}, | ||
1492 | + {0, 0x0998, 0xFFE9}, | ||
1493 | + {0, 0x099a, 0x8F35}, | ||
1494 | + {0, 0x099c, 0xBDAD}, | ||
1495 | + {0, 0x099e, 0x1530}, | ||
1496 | + {0, 0x098A, 0x1250}, | ||
1497 | + {0, 0x0990, 0x6F16}, | ||
1498 | + {0, 0x0992, 0x18DE}, | ||
1499 | + {0, 0x0994, 0x1918}, | ||
1500 | + {0, 0x0996, 0x8FC3}, | ||
1501 | + {0, 0x0998, 0x14B}, | ||
1502 | + {0, 0x099a, 0x188F}, | ||
1503 | + {0, 0x099c, 0x18EC}, | ||
1504 | + {0, 0x099e, 0xFD}, | ||
1505 | + {0, 0x098A, 0x1260}, | ||
1506 | + {0, 0x0990, 0x50E}, | ||
1507 | + {0, 0x0992, 0x18EC}, | ||
1508 | + {0, 0x0994, 0x2FD}, | ||
1509 | + {0, 0x0996, 0x510}, | ||
1510 | + {0, 0x0998, 0xE616}, | ||
1511 | + {0, 0x099a, 0x4FED}, | ||
1512 | + {0, 0x099c, 0x418}, | ||
1513 | + {0, 0x099e, 0x8FC3}, | ||
1514 | + {0, 0x098A, 0x1270}, | ||
1515 | + {0, 0x0990, 0xFFCB}, | ||
1516 | + {0, 0x0992, 0xE304}, | ||
1517 | + {0, 0x0994, 0x8FE6}, | ||
1518 | + {0, 0x0996, 0xF7}, | ||
1519 | + {0, 0x0998, 0x514}, | ||
1520 | + {0, 0x099a, 0x18DE}, | ||
1521 | + {0, 0x099c, 0x1930}, | ||
1522 | + {0, 0x099e, 0xE616}, | ||
1523 | + {0, 0x098A, 0x1280}, | ||
1524 | + {0, 0x0990, 0x4FED}, | ||
1525 | + {0, 0x0992, 0x418}, | ||
1526 | + {0, 0x0994, 0x8FC3}, | ||
1527 | + {0, 0x0996, 0x119}, | ||
1528 | + {0, 0x0998, 0xE304}, | ||
1529 | + {0, 0x099a, 0x8FE6}, | ||
1530 | + {0, 0x099c, 0xF7}, | ||
1531 | + {0, 0x099e, 0x515}, | ||
1532 | + {0, 0x098A, 0x1290}, | ||
1533 | + {0, 0x0990, 0xFC05}, | ||
1534 | + {0, 0x0992, 0x5BFD}, | ||
1535 | + {0, 0x0994, 0x512}, | ||
1536 | + {0, 0x0996, 0xDE37}, | ||
1537 | + {0, 0x0998, 0xEE08}, | ||
1538 | + {0, 0x099a, 0xAD00}, | ||
1539 | + {0, 0x099c, 0x30E6}, | ||
1540 | + {0, 0x099e, 0x164F}, | ||
1541 | + {0, 0x098A, 0x12A0}, | ||
1542 | + {0, 0x0990, 0x5ED}, | ||
1543 | + {0, 0x0992, 0x48F}, | ||
1544 | + {0, 0x0994, 0xC300}, | ||
1545 | + {0, 0x0996, 0x630}, | ||
1546 | + {0, 0x0998, 0xE304}, | ||
1547 | + {0, 0x099a, 0x8FF6}, | ||
1548 | + {0, 0x099c, 0x516}, | ||
1549 | + {0, 0x099e, 0x4FED}, | ||
1550 | + {0, 0x098A, 0x12B0}, | ||
1551 | + {0, 0x0990, 0x30}, | ||
1552 | + {0, 0x0992, 0x6C16}, | ||
1553 | + {0, 0x0994, 0xE616}, | ||
1554 | + {0, 0x0996, 0xC103}, | ||
1555 | + {0, 0x0998, 0x2598}, | ||
1556 | + {0, 0x099a, 0xCC32}, | ||
1557 | + {0, 0x099c, 0x8EED}, | ||
1558 | + {0, 0x099e, 0xEC}, | ||
1559 | + {0, 0x098A, 0x12C0}, | ||
1560 | + {0, 0x0990, 0x6BD}, | ||
1561 | + {0, 0x0992, 0x7021}, | ||
1562 | + {0, 0x0994, 0xCC32}, | ||
1563 | + {0, 0x0996, 0x6C30}, | ||
1564 | + {0, 0x0998, 0xED02}, | ||
1565 | + {0, 0x099a, 0xCCF8}, | ||
1566 | + {0, 0x099c, 0xED}, | ||
1567 | + {0, 0x099e, 0xA6}, | ||
1568 | + {0, 0x098A, 0x12D0}, | ||
1569 | + {0, 0x0990, 0x9E3}, | ||
1570 | + {0, 0x0992, 0xA84}, | ||
1571 | + {0, 0x0994, 0x7BD}, | ||
1572 | + {0, 0x0996, 0x706D}, | ||
1573 | + {0, 0x0998, 0x30C6}, | ||
1574 | + {0, 0x099a, 0x173A}, | ||
1575 | + {0, 0x099c, 0x3539}, | ||
1576 | + {0, 0x099e, 0x3CBD}, | ||
1577 | + {0, 0x098A, 0x12E0}, | ||
1578 | + {0, 0x0990, 0x776D}, | ||
1579 | + {0, 0x0992, 0xCC32}, | ||
1580 | + {0, 0x0994, 0x5C30}, | ||
1581 | + {0, 0x0996, 0xED00}, | ||
1582 | + {0, 0x0998, 0xFC13}, | ||
1583 | + {0, 0x099a, 0x8683}, | ||
1584 | + {0, 0x099c, 0x1}, | ||
1585 | + {0, 0x099e, 0xBD70}, | ||
1586 | + {0, 0x098A, 0x12F0}, | ||
1587 | + {0, 0x0990, 0x21CC}, | ||
1588 | + {0, 0x0992, 0x325E}, | ||
1589 | + {0, 0x0994, 0x30ED}, | ||
1590 | + {0, 0x0996, 0xFC}, | ||
1591 | + {0, 0x0998, 0x1388}, | ||
1592 | + {0, 0x099a, 0x8300}, | ||
1593 | + {0, 0x099c, 0x1BD}, | ||
1594 | + {0, 0x099e, 0x7021}, | ||
1595 | + {0, 0x098A, 0x1300}, | ||
1596 | + {0, 0x0990, 0x3839}, | ||
1597 | + {0, 0x098E, 0x0010}, | ||
1598 | + {0, 0x0990, 0x1000}, | ||
1599 | + {0, 0x098E, 0x0003}, | ||
1600 | + {100, 0x0990, 0x0004} | ||
1601 | +}; | ||
1602 | + | ||
1603 | +mt9t111_regs def_regs1[] ={ | ||
1604 | + {0, 0x001A, 0x0218}, | ||
1605 | + {0, 0x001E, 0x0777}, | ||
1606 | + {0, 0x3084, 0x2409}, | ||
1607 | + {0, 0x3092, 0x0A49}, | ||
1608 | + {0, 0x3094, 0x4949}, | ||
1609 | + {0, 0x3096, 0x4950}, | ||
1610 | + {0, 0x0018, 0x402D}, | ||
1611 | + {100, 0x0018, 0x402C}, | ||
1612 | + {0, 0x098E, 0x6800}, | ||
1613 | + {0, 0x0990, 0x0280}, | ||
1614 | + {0, 0x098E, 0x6802}, | ||
1615 | + {0, 0x0990, 0x01E0}, | ||
1616 | + {0, 0x098E, 0xE88E}, | ||
1617 | + {0, 0x0990, 0x0000}, | ||
1618 | + {0, 0x098E, 0x68A0}, | ||
1619 | + {0, 0x0990, 0x082D}, | ||
1620 | + {0, 0x098E, 0x4802}, | ||
1621 | + {0, 0x0990, 0x0000}, | ||
1622 | + {0, 0x098E, 0x4804}, | ||
1623 | + {0, 0x0990, 0x0000}, | ||
1624 | + {0, 0x098E, 0x4806}, | ||
1625 | + {0, 0x0990, 0x060D}, | ||
1626 | + {0, 0x098E, 0x4808}, | ||
1627 | + {0, 0x0990, 0x080D}, | ||
1628 | + {0, 0x098E, 0x480A}, | ||
1629 | + {0, 0x0990, 0x0111}, | ||
1630 | + {0, 0x098E, 0x480C}, | ||
1631 | + {0, 0x0990, 0x046C}, | ||
1632 | + {0, 0x098E, 0x480F}, | ||
1633 | + {0, 0x0990, 0x00CC}, | ||
1634 | + {0, 0x098E, 0x4811}, | ||
1635 | + {0, 0x0990, 0x0381}, | ||
1636 | + {0, 0x098E, 0x4813}, | ||
1637 | + {0, 0x0990, 0x024F}, | ||
1638 | + {0, 0x098E, 0x481D}, | ||
1639 | + {0, 0x0990, 0x05AE}, | ||
1640 | + {0, 0x098E, 0x481F}, | ||
1641 | + {0, 0x0990, 0x05D0}, | ||
1642 | + {0, 0x098E, 0x4825}, | ||
1643 | + {0, 0x0990, 0x07AC}, | ||
1644 | + {0, 0x098E, 0x6C00}, | ||
1645 | + {0, 0x0990, 0x0800}, | ||
1646 | + {0, 0x098E, 0x6C02}, | ||
1647 | + {0, 0x0990, 0x0600}, | ||
1648 | + {0, 0x098E, 0xEC8E}, | ||
1649 | + {0, 0x0990, 0x0000}, | ||
1650 | + {0, 0x098E, 0x6CA0}, | ||
1651 | + {0, 0x0990, 0x082D}, | ||
1652 | + {0, 0x098E, 0x484A}, | ||
1653 | + {0, 0x0990, 0x0000}, | ||
1654 | + {0, 0x098E, 0x484C}, | ||
1655 | + {0, 0x0990, 0x0000}, | ||
1656 | + {0, 0x098E, 0x484E}, | ||
1657 | + {0, 0x0990, 0x060D}, | ||
1658 | + {0, 0x098E, 0x4850}, | ||
1659 | + {0, 0x0990, 0x080D}, | ||
1660 | + {0, 0x098E, 0x4852}, | ||
1661 | + {0, 0x0990, 0x0111}, | ||
1662 | + {0, 0x098E, 0x4854}, | ||
1663 | + {0, 0x0990, 0x146C}, | ||
1664 | + {0, 0x098E, 0x4857}, | ||
1665 | + {0, 0x0990, 0x00CC}, | ||
1666 | + {0, 0x098E, 0x4859}, | ||
1667 | + {0, 0x0990, 0x0381}, | ||
1668 | + {0, 0x098E, 0x485B}, | ||
1669 | + {0, 0x0990, 0x024F}, | ||
1670 | + {0, 0x098E, 0x4865}, | ||
1671 | + {0, 0x0990, 0x05AE}, | ||
1672 | + {0, 0x098E, 0x4867}, | ||
1673 | + {0, 0x0990, 0x05D0}, | ||
1674 | + {0, 0x098E, 0x486D}, | ||
1675 | + {0, 0x0990, 0x07AC}, | ||
1676 | + {0, 0x098E, 0xC8A5}, | ||
1677 | + {0, 0x0990, 0x001D}, | ||
1678 | + {0, 0x098E, 0xC8A6}, | ||
1679 | + {0, 0x0990, 0x0020}, | ||
1680 | + {0, 0x098E, 0xC8A7}, | ||
1681 | + {0, 0x0990, 0x0023}, | ||
1682 | + {0, 0x098E, 0xC8A8}, | ||
1683 | + {0, 0x0990, 0x0026}, | ||
1684 | + {0, 0x098E, 0xC844}, | ||
1685 | + {0, 0x0990, 0x0091}, | ||
1686 | + {0, 0x098E, 0xC92F}, | ||
1687 | + {0, 0x0990, 0x0000}, | ||
1688 | + {0, 0x098E, 0xC845}, | ||
1689 | + {0, 0x0990, 0x0079}, | ||
1690 | + {0, 0x098E, 0xC92D}, | ||
1691 | + {0, 0x0990, 0x0000}, | ||
1692 | + {0, 0x098E, 0xC88C}, | ||
1693 | + {0, 0x0990, 0x0091}, | ||
1694 | + {0, 0x098E, 0xC930}, | ||
1695 | + {0, 0x0990, 0x0000}, | ||
1696 | + {0, 0x098E, 0xC88D}, | ||
1697 | + {0, 0x0990, 0x0079}, | ||
1698 | + {0, 0x098E, 0xC92E}, | ||
1699 | + {0, 0x0990, 0x0000}, | ||
1700 | + {0, 0x098E, 0xA002}, | ||
1701 | + {0, 0x0990, 0x0010}, | ||
1702 | + {0, 0x098E, 0xA009}, | ||
1703 | + {0, 0x0990, 0x0002}, | ||
1704 | + {0, 0x098E, 0xA00A}, | ||
1705 | + {0, 0x0990, 0x0003}, | ||
1706 | + {0, 0x098E, 0xA00C}, | ||
1707 | + {0, 0x0990, 0x000A}, | ||
1708 | + {0, 0x098E, 0x4846}, | ||
1709 | + {0, 0x0990, 0x0014}, | ||
1710 | + {0, 0x098E, 0x68AA}, | ||
1711 | + {0, 0x0990, 0x0278}, | ||
1712 | + {0, 0x098E, 0x488E}, | ||
1713 | + {0, 0x0990, 0x0014}, | ||
1714 | + {0, 0x098E, 0x6CAA}, | ||
1715 | + {0, 0x0990, 0x0218}, | ||
1716 | + {0, 0x098E, 0x8400}, | ||
1717 | + {0, 0x0990, 0x0006}, | ||
1718 | + {0, 0x098E, 0x8400}, | ||
1719 | + {0, 0x0990, 0x0005}, | ||
1720 | + {0, 0x3C20, 0x0001}, | ||
1721 | + {0, 0x364A, 0x7D2F}, | ||
1722 | + {0, 0x364C, 0x79EB}, | ||
1723 | + {0, 0x364E, 0x18D2}, | ||
1724 | + {0, 0x3650, 0x9F8F}, | ||
1725 | + {0, 0x3652, 0xA7D2}, | ||
1726 | + {0, 0x368A, 0x460C}, | ||
1727 | + {0, 0x368C, 0x14F0}, | ||
1728 | + {0, 0x368E, 0x946F}, | ||
1729 | + {0, 0x3690, 0xC471}, | ||
1730 | + {0, 0x3692, 0x04B1}, | ||
1731 | + {0, 0x36CA, 0x0433}, | ||
1732 | + {0, 0x36CC, 0x680D}, | ||
1733 | + {0, 0x36CE, 0xEEF3}, | ||
1734 | + {0, 0x36D0, 0x4850}, | ||
1735 | + {0, 0x36D2, 0xF233}, | ||
1736 | + {0, 0x370A, 0xB2AF}, | ||
1737 | + {0, 0x370C, 0x2CF0}, | ||
1738 | + {0, 0x370E, 0x3F10}, | ||
1739 | + {0, 0x3710, 0xC673}, | ||
1740 | + {0, 0x3712, 0xA972}, | ||
1741 | + {0, 0x374A, 0x0590}, | ||
1742 | + {0, 0x374C, 0xAFB3}, | ||
1743 | + {0, 0x374E, 0x93D7}, | ||
1744 | + {0, 0x3750, 0x8D12}, | ||
1745 | + {0, 0x3752, 0x2539}, | ||
1746 | + {0, 0x3640, 0x0350}, | ||
1747 | + {0, 0x3642, 0x322C}, | ||
1748 | + {0, 0x3644, 0x77D1}, | ||
1749 | + {0, 0x3646, 0xA26F}, | ||
1750 | + {0, 0x3648, 0xC872}, | ||
1751 | + {0, 0x3680, 0x0C4C}, | ||
1752 | + {0, 0x3682, 0x9510}, | ||
1753 | + {0, 0x3684, 0x110E}, | ||
1754 | + {0, 0x3686, 0x4331}, | ||
1755 | + {0, 0x3688, 0xC1CF}, | ||
1756 | + {0, 0x36C0, 0x6152}, | ||
1757 | + {0, 0x36C2, 0x038E}, | ||
1758 | + {0, 0x36C4, 0x9AF4}, | ||
1759 | + {0, 0x36C6, 0xE12F}, | ||
1760 | + {0, 0x36C8, 0x09F3}, | ||
1761 | + {0, 0x3700, 0xC5AF}, | ||
1762 | + {0, 0x3702, 0xCA90}, | ||
1763 | + {0, 0x3704, 0x5D0F}, | ||
1764 | + {0, 0x3706, 0x3293}, | ||
1765 | + {0, 0x3708, 0x2B92}, | ||
1766 | + {0, 0x3740, 0xC590}, | ||
1767 | + {0, 0x3742, 0x8133}, | ||
1768 | + {0, 0x3744, 0xE0F6}, | ||
1769 | + {0, 0x3746, 0x0254}, | ||
1770 | + {0, 0x3748, 0x10B9}, | ||
1771 | + {0, 0x3654, 0x7F8F}, | ||
1772 | + {0, 0x3656, 0x6F6C}, | ||
1773 | + {0, 0x3658, 0x5971}, | ||
1774 | + {0, 0x365A, 0x9A0F}, | ||
1775 | + {0, 0x365C, 0xA1B2}, | ||
1776 | + {0, 0x3694, 0xB00C}, | ||
1777 | + {0, 0x3696, 0xEBCF}, | ||
1778 | + {0, 0x3698, 0x06AD}, | ||
1779 | + {0, 0x369A, 0x4D31}, | ||
1780 | + {0, 0x369C, 0x2A4E}, | ||
1781 | + {0, 0x36D4, 0x4752}, | ||
1782 | + {0, 0x36D6, 0x724D}, | ||
1783 | + {0, 0x36D8, 0xAD34}, | ||
1784 | + {0, 0x36DA, 0x1350}, | ||
1785 | + {0, 0x36DC, 0x4E94}, | ||
1786 | + {0, 0x3714, 0xA06E}, | ||
1787 | + {0, 0x3716, 0x9152}, | ||
1788 | + {0, 0x3718, 0x1F53}, | ||
1789 | + {0, 0x371A, 0x3933}, | ||
1790 | + {0, 0x371C, 0xBA94}, | ||
1791 | + {0, 0x3754, 0x1233}, | ||
1792 | + {0, 0x3756, 0xA032}, | ||
1793 | + {0, 0x3758, 0xE936}, | ||
1794 | + {0, 0x375A, 0xBE34}, | ||
1795 | + {0, 0x375C, 0x02D9}, | ||
1796 | + {0, 0x365E, 0x7DEF}, | ||
1797 | + {0, 0x3660, 0x434B}, | ||
1798 | + {0, 0x3662, 0x69F1}, | ||
1799 | + {0, 0x3664, 0x8A0F}, | ||
1800 | + {0, 0x3666, 0xBDB2}, | ||
1801 | + {0, 0x369E, 0x290D}, | ||
1802 | + {0, 0x36A0, 0x42CF}, | ||
1803 | + {0, 0x36A2, 0xDC6D}, | ||
1804 | + {0, 0x36A4, 0x91B1}, | ||
1805 | + {0, 0x36A6, 0x9DE9}, | ||
1806 | + {0, 0x36DE, 0x70B2}, | ||
1807 | + {0, 0x36E0, 0x02AC}, | ||
1808 | + {0, 0x36E2, 0x9714}, | ||
1809 | + {0, 0x36E4, 0xF3CF}, | ||
1810 | + {0, 0x36E6, 0x6BD1}, | ||
1811 | + {0, 0x371E, 0xE42E}, | ||
1812 | + {0, 0x3720, 0x1D32}, | ||
1813 | + {0, 0x3722, 0xCC31}, | ||
1814 | + {0, 0x3724, 0xAE94}, | ||
1815 | + {0, 0x3726, 0x6413}, | ||
1816 | + {0, 0x375E, 0xE290}, | ||
1817 | + {0, 0x3760, 0x8F53}, | ||
1818 | + {0, 0x3762, 0xF936}, | ||
1819 | + {0, 0x3764, 0x4614}, | ||
1820 | + {0, 0x3766, 0x1B59}, | ||
1821 | + {0, 0x3784, 0x0404}, | ||
1822 | + {0, 0x3782, 0x0304}, | ||
1823 | + {0, 0x3210, 0x01B8}, | ||
1824 | + {0, 0x098E, 0xC913}, | ||
1825 | + {0, 0x0990, 0x000A}, | ||
1826 | + {0, 0x098E, 0x686B}, | ||
1827 | + {0, 0x0990, 0x05DC}, | ||
1828 | + {0, 0x098E, 0x686D}, | ||
1829 | + {0, 0x0990, 0x0BB8}, | ||
1830 | + {0, 0x098E, 0x6C6B}, | ||
1831 | + {0, 0x0990, 0x05DC}, | ||
1832 | + {0, 0x098E, 0x6C6D}, | ||
1833 | + {0, 0x0990, 0x0BB8}, | ||
1834 | + {0, 0x098E, 0x3439}, | ||
1835 | + {0, 0x0990, 0x05DC}, | ||
1836 | + {0, 0x098E, 0x343B}, | ||
1837 | + {0, 0x0990, 0x0BB8}, | ||
1838 | + {0, 0x098E, 0x4926}, | ||
1839 | + {0, 0x0990, 0x0001}, | ||
1840 | + {0, 0x098E, 0x4928}, | ||
1841 | + {0, 0x0990, 0x0002}, | ||
1842 | + {0, 0x098E, 0x492A}, | ||
1843 | + {0, 0x0990, 0x0656}, | ||
1844 | + {0, 0x098E, 0x4D26}, | ||
1845 | + {0, 0x0990, 0x0001}, | ||
1846 | + {0, 0x098E, 0x4D28}, | ||
1847 | + {0, 0x0990, 0x0002}, | ||
1848 | + {0, 0x098E, 0x4D2A}, | ||
1849 | + {0, 0x0990, 0x0656}, | ||
1850 | + {0, 0x33F4, 0x040B}, | ||
1851 | + {0, 0x098E, 0xC916}, | ||
1852 | + {0, 0x0990, 0x0014}, | ||
1853 | + {0, 0x098E, 0xC919}, | ||
1854 | + {0, 0x0990, 0x0028}, | ||
1855 | + {0, 0x098E, 0xC917}, | ||
1856 | + {0, 0x0990, 0x0004}, | ||
1857 | + {0, 0x098E, 0xC918}, | ||
1858 | + {0, 0x0990, 0x0000}, | ||
1859 | + {0, 0x098E, 0xC91A}, | ||
1860 | + {0, 0x0990, 0x0001}, | ||
1861 | + {0, 0x098E, 0xC91B}, | ||
1862 | + {0, 0x0990, 0x0009}, | ||
1863 | + {0, 0x326C, 0x0C00}, | ||
1864 | + {0, 0x098E, 0x494B}, | ||
1865 | + {0, 0x0990, 0x0042}, | ||
1866 | + {0, 0x098E, 0x494D}, | ||
1867 | + {0, 0x0990, 0x012C}, | ||
1868 | + {0, 0x098E, 0xC91E}, | ||
1869 | + {0, 0x0990, 0x0012}, | ||
1870 | + {0, 0x098E, 0xC91F}, | ||
1871 | + {0, 0x0990, 0x000A}, | ||
1872 | + {0, 0x098E, 0xC920}, | ||
1873 | + {0, 0x0990, 0x0012}, | ||
1874 | + {0, 0x098E, 0xC921}, | ||
1875 | + {0, 0x0990, 0x000A}, | ||
1876 | + {0, 0x098E, 0xC922}, | ||
1877 | + {0, 0x0990, 0x0026}, | ||
1878 | + {0, 0x098E, 0xC923}, | ||
1879 | + {0, 0x0990, 0x001E}, | ||
1880 | + {0, 0x098E, 0xC924}, | ||
1881 | + {0, 0x0990, 0x0026}, | ||
1882 | + {0, 0x098E, 0xC925}, | ||
1883 | + {0, 0x0990, 0x0026}, | ||
1884 | + {0, 0x098E, 0xBC02}, | ||
1885 | + {0, 0x0990, 0x0003}, | ||
1886 | + {0, 0x098E, 0xBC05}, | ||
1887 | + {0, 0x0990, 0x000E}, | ||
1888 | + {0, 0x098E, 0xC950}, | ||
1889 | + {0, 0x0990, 0x0064}, | ||
1890 | + {0, 0x098E, 0xC94F}, | ||
1891 | + {0, 0x0990, 0x0038}, | ||
1892 | + {0, 0x098E, 0xC952}, | ||
1893 | + {0, 0x0990, 0x0064}, | ||
1894 | + {0, 0x098E, 0xC951}, | ||
1895 | + {0, 0x0990, 0x0051}, | ||
1896 | + {0, 0x098E, 0xC954}, | ||
1897 | + {0, 0x0990, 0x0010}, | ||
1898 | + {0, 0x098E, 0xC953}, | ||
1899 | + {0, 0x0990, 0x0020}, | ||
1900 | + {0, 0x098E, 0xC956}, | ||
1901 | + {0, 0x0990, 0x0010}, | ||
1902 | + {0, 0x098E, 0xC955}, | ||
1903 | + {0, 0x0990, 0x0020}, | ||
1904 | + {0, 0x098E, 0xC958}, | ||
1905 | + {0, 0x0990, 0x0020}, | ||
1906 | + {0, 0x098E, 0xC957}, | ||
1907 | + {0, 0x0990, 0x0014}, | ||
1908 | + {0, 0x098E, 0xC95A}, | ||
1909 | + {0, 0x0990, 0x001D}, | ||
1910 | + {0, 0x098E, 0xC959}, | ||
1911 | + {0, 0x0990, 0x0020}, | ||
1912 | + {0, 0x098E, 0xC95C}, | ||
1913 | + {0, 0x0990, 0x000C}, | ||
1914 | + {0, 0x098E, 0xC95B}, | ||
1915 | + {0, 0x0990, 0x0008}, | ||
1916 | + {0, 0x098E, 0xC95E}, | ||
1917 | + {0, 0x0990, 0x000C}, | ||
1918 | + {0, 0x098E, 0xC95D}, | ||
1919 | + {0, 0x0990, 0x0008}, | ||
1920 | + {0, 0x098E, 0xC95F}, | ||
1921 | + {0, 0x0990, 0x0064}, | ||
1922 | + {0, 0x098E, 0x48DC}, | ||
1923 | + {0, 0x0990, 0x004D}, | ||
1924 | + {0, 0x098E, 0x48DE}, | ||
1925 | + {0, 0x0990, 0x0096}, | ||
1926 | + {0, 0x098E, 0x48E0}, | ||
1927 | + {0, 0x0990, 0x001D}, | ||
1928 | + {0, 0x098E, 0x48E2}, | ||
1929 | + {0, 0x0990, 0x004D}, | ||
1930 | + {0, 0x098E, 0x48E4}, | ||
1931 | + {0, 0x0990, 0x0096}, | ||
1932 | + {0, 0x098E, 0x48E6}, | ||
1933 | + {0, 0x0990, 0x001D}, | ||
1934 | + {0, 0x098E, 0x48E8}, | ||
1935 | + {0, 0x0990, 0x004D}, | ||
1936 | + {0, 0x098E, 0x48EA}, | ||
1937 | + {0, 0x0990, 0x0096}, | ||
1938 | + {0, 0x098E, 0x48EC}, | ||
1939 | + {0, 0x0990, 0x001D}, | ||
1940 | + {0, 0x098E, 0xDC2A}, | ||
1941 | + {0, 0x0990, 0x000B}, | ||
1942 | + {0, 0x098E, 0xDC2B}, | ||
1943 | + {0, 0x0990, 0x0017}, | ||
1944 | + {0, 0x098E, 0xBC0B}, | ||
1945 | + {0, 0x0990, 0x0000}, | ||
1946 | + {0, 0x098E, 0xBC0C}, | ||
1947 | + {0, 0x0990, 0x001B}, | ||
1948 | + {0, 0x098E, 0xBC0D}, | ||
1949 | + {0, 0x0990, 0x002A}, | ||
1950 | + {0, 0x098E, 0xBC0E}, | ||
1951 | + {0, 0x0990, 0x003E}, | ||
1952 | + {0, 0x098E, 0xBC0F}, | ||
1953 | + {0, 0x0990, 0x005A}, | ||
1954 | + {0, 0x098E, 0xBC10}, | ||
1955 | + {0, 0x0990, 0x0070}, | ||
1956 | + {0, 0x098E, 0xBC11}, | ||
1957 | + {0, 0x0990, 0x0081}, | ||
1958 | + {0, 0x098E, 0xBC12}, | ||
1959 | + {0, 0x0990, 0x0090}, | ||
1960 | + {0, 0x098E, 0xBC13}, | ||
1961 | + {0, 0x0990, 0x009E}, | ||
1962 | + {0, 0x098E, 0xBC14}, | ||
1963 | + {0, 0x0990, 0x00AB}, | ||
1964 | + {0, 0x098E, 0xBC15}, | ||
1965 | + {0, 0x0990, 0x00B6}, | ||
1966 | + {0, 0x098E, 0xBC16}, | ||
1967 | + {0, 0x0990, 0x00C1}, | ||
1968 | + {0, 0x098E, 0xBC17}, | ||
1969 | + {0, 0x0990, 0x00CB}, | ||
1970 | + {0, 0x098E, 0xBC18}, | ||
1971 | + {0, 0x0990, 0x00D5}, | ||
1972 | + {0, 0x098E, 0xBC19}, | ||
1973 | + {0, 0x0990, 0x00DE}, | ||
1974 | + {0, 0x098E, 0xBC1A}, | ||
1975 | + {0, 0x0990, 0x00E7}, | ||
1976 | + {0, 0x098E, 0xBC1B}, | ||
1977 | + {0, 0x0990, 0x00EF}, | ||
1978 | + {0, 0x098E, 0xBC1C}, | ||
1979 | + {0, 0x0990, 0x00F7}, | ||
1980 | + {0, 0x098E, 0xBC1D}, | ||
1981 | + {0, 0x0990, 0x00FF}, | ||
1982 | + {0, 0x098E, 0xBC1E}, | ||
1983 | + {0, 0x0990, 0x0000}, | ||
1984 | + {0, 0x098E, 0xBC1F}, | ||
1985 | + {0, 0x0990, 0x001B}, | ||
1986 | + {0, 0x098E, 0xBC20}, | ||
1987 | + {0, 0x0990, 0x002A}, | ||
1988 | + {0, 0x098E, 0xBC21}, | ||
1989 | + {0, 0x0990, 0x003E}, | ||
1990 | + {0, 0x098E, 0xBC22}, | ||
1991 | + {0, 0x0990, 0x005A}, | ||
1992 | + {0, 0x098E, 0xBC23}, | ||
1993 | + {0, 0x0990, 0x0070}, | ||
1994 | + {0, 0x098E, 0xBC24}, | ||
1995 | + {0, 0x0990, 0x0081}, | ||
1996 | + {0, 0x098E, 0xBC25}, | ||
1997 | + {0, 0x0990, 0x0090}, | ||
1998 | + {0, 0x098E, 0xBC26}, | ||
1999 | + {0, 0x0990, 0x009E}, | ||
2000 | + {0, 0x098E, 0xBC27}, | ||
2001 | + {0, 0x0990, 0x00AB}, | ||
2002 | + {0, 0x098E, 0xBC28}, | ||
2003 | + {0, 0x0990, 0x00B6}, | ||
2004 | + {0, 0x098E, 0xBC29}, | ||
2005 | + {0, 0x0990, 0x00C1}, | ||
2006 | + {0, 0x098E, 0xBC2A}, | ||
2007 | + {0, 0x0990, 0x00CB}, | ||
2008 | + {0, 0x098E, 0xBC2B}, | ||
2009 | + {0, 0x0990, 0x00D5}, | ||
2010 | + {0, 0x098E, 0xBC2C}, | ||
2011 | + {0, 0x0990, 0x00DE}, | ||
2012 | + {0, 0x098E, 0xBC2D}, | ||
2013 | + {0, 0x0990, 0x00E7}, | ||
2014 | + {0, 0x098E, 0xBC2E}, | ||
2015 | + {0, 0x0990, 0x00EF}, | ||
2016 | + {0, 0x098E, 0xBC2F}, | ||
2017 | + {0, 0x0990, 0x00F7}, | ||
2018 | + {0, 0x098E, 0xBC30}, | ||
2019 | + {0, 0x0990, 0x00FF}, | ||
2020 | + {0, 0x098E, 0xBC31}, | ||
2021 | + {0, 0x0990, 0x0000}, | ||
2022 | + {0, 0x098E, 0xBC32}, | ||
2023 | + {0, 0x0990, 0x000D}, | ||
2024 | + {0, 0x098E, 0xBC33}, | ||
2025 | + {0, 0x0990, 0x0019}, | ||
2026 | + {0, 0x098E, 0xBC34}, | ||
2027 | + {0, 0x0990, 0x0030}, | ||
2028 | + {0, 0x098E, 0xBC35}, | ||
2029 | + {0, 0x0990, 0x0056}, | ||
2030 | + {0, 0x098E, 0xBC36}, | ||
2031 | + {0, 0x0990, 0x0070}, | ||
2032 | + {0, 0x098E, 0xBC37}, | ||
2033 | + {0, 0x0990, 0x0081}, | ||
2034 | + {0, 0x098E, 0xBC38}, | ||
2035 | + {0, 0x0990, 0x0090}, | ||
2036 | + {0, 0x098E, 0xBC39}, | ||
2037 | + {0, 0x0990, 0x009E}, | ||
2038 | + {0, 0x098E, 0xBC3A}, | ||
2039 | + {0, 0x0990, 0x00AB}, | ||
2040 | + {0, 0x098E, 0xBC3B}, | ||
2041 | + {0, 0x0990, 0x00B6}, | ||
2042 | + {0, 0x098E, 0xBC3C}, | ||
2043 | + {0, 0x0990, 0x00C1}, | ||
2044 | + {0, 0x098E, 0xBC3D}, | ||
2045 | + {0, 0x0990, 0x00CB}, | ||
2046 | + {0, 0x098E, 0xBC3E}, | ||
2047 | + {0, 0x0990, 0x00D5}, | ||
2048 | + {0, 0x098E, 0xBC3F}, | ||
2049 | + {0, 0x0990, 0x00DE}, | ||
2050 | + {0, 0x098E, 0xBC40}, | ||
2051 | + {0, 0x0990, 0x00E7}, | ||
2052 | + {0, 0x098E, 0xBC41}, | ||
2053 | + {0, 0x0990, 0x00EF}, | ||
2054 | + {0, 0x098E, 0xBC42}, | ||
2055 | + {0, 0x0990, 0x00F7}, | ||
2056 | + {0, 0x098E, 0xBC43}, | ||
2057 | + {0, 0x0990, 0x00FF}, | ||
2058 | + {0, 0x098E, 0x6865}, | ||
2059 | + {0, 0x0990, 0x00E0}, | ||
2060 | + {0, 0x098E, 0x6867}, | ||
2061 | + {0, 0x0990, 0x00F4}, | ||
2062 | + {0, 0x098E, 0x8400}, | ||
2063 | + {0, 0x0990, 0x0006}, | ||
2064 | + {0, 0x098E, 0xBC4A}, | ||
2065 | + {0, 0x0990, 0x007F}, | ||
2066 | + {0, 0x098E, 0xBC4B}, | ||
2067 | + {0, 0x0990, 0x007F}, | ||
2068 | + {0, 0x098E, 0xBC4C}, | ||
2069 | + {0, 0x0990, 0x007F}, | ||
2070 | + {0, 0x3542, 0x0010}, | ||
2071 | + {0, 0x3544, 0x0030}, | ||
2072 | + {0, 0x3546, 0x0040}, | ||
2073 | + {0, 0x3548, 0x0080}, | ||
2074 | + {0, 0x354A, 0x0100}, | ||
2075 | + {0, 0x354C, 0x0200}, | ||
2076 | + {0, 0x354E, 0x0300}, | ||
2077 | + {0, 0x3550, 0x0010}, | ||
2078 | + {0, 0x3552, 0x0030}, | ||
2079 | + {0, 0x3554, 0x0040}, | ||
2080 | + {0, 0x3556, 0x0080}, | ||
2081 | + {0, 0x3558, 0x012C}, | ||
2082 | + {0, 0x355A, 0x0320}, | ||
2083 | + {0, 0x355C, 0x03E8}, | ||
2084 | + {0, 0x3560, 0x0040}, | ||
2085 | + {0, 0x3562, 0x0020}, | ||
2086 | + {0, 0x3564, 0x0040}, | ||
2087 | + {0, 0x3566, 0x0010}, | ||
2088 | + {0, 0x3568, 0x0008}, | ||
2089 | + {0, 0x356A, 0x0004}, | ||
2090 | + {0, 0x356C, 0x0004}, | ||
2091 | + {0, 0x356E, 0x0004}, | ||
2092 | + {0, 0x098E, 0x3C4D}, | ||
2093 | + {0, 0x0990, 0x0DAC}, | ||
2094 | + {0, 0x098E, 0x3C4F}, | ||
2095 | + {0, 0x0990, 0x148A}, | ||
2096 | + {0, 0x098E, 0xC911}, | ||
2097 | + {0, 0x0990, 0x00C8}, | ||
2098 | + {0, 0x098E, 0xC8F4}, | ||
2099 | + {0, 0x0990, 0x0004}, | ||
2100 | + {0, 0x098E, 0xC8F5}, | ||
2101 | + {0, 0x0990, 0x0002}, | ||
2102 | + {0, 0x098E, 0x48F6}, | ||
2103 | + {0, 0x0990, 0x3B4D}, | ||
2104 | + {0, 0x098E, 0x48F8}, | ||
2105 | + {0, 0x0990, 0x6380}, | ||
2106 | + {0, 0x098E, 0x48FA}, | ||
2107 | + {0, 0x0990, 0x9B18}, | ||
2108 | + {0, 0x098E, 0x48FC}, | ||
2109 | + {0, 0x0990, 0x5D51}, | ||
2110 | + {0, 0x098E, 0x48FE}, | ||
2111 | + {0, 0x0990, 0xEDE8}, | ||
2112 | + {0, 0x098E, 0x4900}, | ||
2113 | + {0, 0x0990, 0xE515}, | ||
2114 | + {0, 0x098E, 0x4902}, | ||
2115 | + {0, 0x0990, 0xBFF4}, | ||
2116 | + {0, 0x098E, 0x4904}, | ||
2117 | + {0, 0x0990, 0x001E}, | ||
2118 | + {0, 0x098E, 0x4906}, | ||
2119 | + {0, 0x0990, 0x0026}, | ||
2120 | + {0, 0x098E, 0x4908}, | ||
2121 | + {0, 0x0990, 0x0033}, | ||
2122 | + {0, 0x098E, 0xE84A}, | ||
2123 | + {0, 0x0990, 0x0083}, | ||
2124 | + {0, 0x098E, 0xE84D}, | ||
2125 | + {0, 0x0990, 0x0083}, | ||
2126 | + {0, 0x098E, 0xE84C}, | ||
2127 | + {0, 0x0990, 0x0080}, | ||
2128 | + {0, 0x098E, 0xE84F}, | ||
2129 | + {0, 0x0990, 0x0080}, | ||
2130 | + {0, 0x098E, 0x8400}, | ||
2131 | + {0, 0x0990, 0x0006}, | ||
2132 | + {0, 0x098E, 0x48B0}, | ||
2133 | + {0, 0x0990, 0x0180}, | ||
2134 | + {0, 0x098E, 0x48B2}, | ||
2135 | + {0, 0x0990, 0xFF7A}, | ||
2136 | + {0, 0x098E, 0x48B4}, | ||
2137 | + {0, 0x0990, 0x0018}, | ||
2138 | + {0, 0x098E, 0x48B6}, | ||
2139 | + {0, 0x0990, 0xFFCA}, | ||
2140 | + {0, 0x098E, 0x48B8}, | ||
2141 | + {0, 0x0990, 0x017C}, | ||
2142 | + {0, 0x098E, 0x48BA}, | ||
2143 | + {0, 0x0990, 0xFFCC}, | ||
2144 | + {0, 0x098E, 0x48BC}, | ||
2145 | + {0, 0x0990, 0x000C}, | ||
2146 | + {0, 0x098E, 0x48BE}, | ||
2147 | + {0, 0x0990, 0xFF1F}, | ||
2148 | + {0, 0x098E, 0x48C0}, | ||
2149 | + {0, 0x0990, 0x01E8}, | ||
2150 | + {0, 0x098E, 0x48C2}, | ||
2151 | + {0, 0x0990, 0x0020}, | ||
2152 | + {0, 0x098E, 0x48C4}, | ||
2153 | + {0, 0x0990, 0x0044}, | ||
2154 | + {0, 0x098E, 0x48C6}, | ||
2155 | + {0, 0x0990, 0x0079}, | ||
2156 | + {0, 0x098E, 0x48C8}, | ||
2157 | + {0, 0x0990, 0xFFAD}, | ||
2158 | + {0, 0x098E, 0x48CA}, | ||
2159 | + {0, 0x0990, 0xFFE2}, | ||
2160 | + {0, 0x098E, 0x48CC}, | ||
2161 | + {0, 0x0990, 0x0033}, | ||
2162 | + {0, 0x098E, 0x48CE}, | ||
2163 | + {0, 0x0990, 0x002A}, | ||
2164 | + {0, 0x098E, 0x48D0}, | ||
2165 | + {0, 0x0990, 0xFFAA}, | ||
2166 | + {0, 0x098E, 0x48D2}, | ||
2167 | + {0, 0x0990, 0x0017}, | ||
2168 | + {0, 0x098E, 0x48D4}, | ||
2169 | + {0, 0x0990, 0x004B}, | ||
2170 | + {0, 0x098E, 0x48D6}, | ||
2171 | + {0, 0x0990, 0xFFA5}, | ||
2172 | + {0, 0x098E, 0x48D8}, | ||
2173 | + {0, 0x0990, 0x0015}, | ||
2174 | + {0, 0x098E, 0x48DA}, | ||
2175 | + {0, 0x0990, 0xFFE2}, | ||
2176 | + {0, 0x35A2, 0x0014}, | ||
2177 | + {0, 0x098E, 0xC949}, | ||
2178 | + {0, 0x0990, 0x0024}, | ||
2179 | + {0, 0x35A4, 0x0596}, | ||
2180 | + {0, 0x098E, 0xC94A}, | ||
2181 | + {0, 0x0990, 0x0062}, | ||
2182 | + {0, 0x098E, 0xC948}, | ||
2183 | + {0, 0x0990, 0x0006}, | ||
2184 | + {0, 0x098E, 0xC914}, | ||
2185 | + {0, 0x0990, 0x0000}, | ||
2186 | + {0, 0x098E, 0xC915}, | ||
2187 | + {0, 0x0990, 0x00FF}, | ||
2188 | + {0, 0x098E, 0xE86F}, | ||
2189 | + {0, 0x0990, 0x0060}, | ||
2190 | + {0, 0x098E, 0xE870}, | ||
2191 | + {0, 0x0990, 0x003C}, | ||
2192 | + {0, 0x098E, 0xEC6F}, | ||
2193 | + {0, 0x0990, 0x0060}, | ||
2194 | + {0, 0x098E, 0xEC70}, | ||
2195 | + {0, 0x0990, 0x003C}, | ||
2196 | + {0, 0x098E, 0xE883}, | ||
2197 | + {0, 0x0990, 0x0000}, | ||
2198 | + {0, 0x098E, 0xEC83}, | ||
2199 | + {0, 0x0990, 0x0000}, | ||
2200 | + {0, 0x098E, 0x8400}, | ||
2201 | + {0, 0x0990, 0x0006}, | ||
2202 | + {0, 0x098E, 0xE885}, | ||
2203 | + {0, 0x0990, 0x001E}, | ||
2204 | + {0, 0x098E, 0xE886}, | ||
2205 | + {0, 0x0990, 0x00D8}, | ||
2206 | + {0, 0x098E, 0xEC85}, | ||
2207 | + {0, 0x0990, 0x001E}, | ||
2208 | + {0, 0x098E, 0xEC86}, | ||
2209 | + {0, 0x0990, 0x00D8}, | ||
2210 | + {0, 0x098E, 0xE884}, | ||
2211 | + {0, 0x0990, 0x005C}, | ||
2212 | + {0, 0x098E, 0xEC84}, | ||
2213 | + {0, 0x0990, 0x005C}, | ||
2214 | + {0, 0x098E, 0x490A}, | ||
2215 | + {0, 0x0990, 0x0666}, | ||
2216 | + {0, 0x098E, 0x490C}, | ||
2217 | + {0, 0x0990, 0x0140}, | ||
2218 | + {0, 0x098E, 0x6857}, | ||
2219 | + {0, 0x0990, 0x0014}, | ||
2220 | + {0, 0x098E, 0x685C}, | ||
2221 | + {0, 0x0990, 0x0005}, | ||
2222 | + {0, 0x098E, 0x490E}, | ||
2223 | + {0, 0x0990, 0x00A4}, | ||
2224 | + {0, 0x098E, 0xB43D}, | ||
2225 | + {0, 0x0990, 0x0031}, | ||
2226 | + {0, 0x098E, 0xB43E}, | ||
2227 | + {0, 0x0990, 0x001B}, | ||
2228 | + {0, 0x098E, 0xB43F}, | ||
2229 | + {0, 0x0990, 0x0028}, | ||
2230 | + {0, 0x098E, 0xB440}, | ||
2231 | + {0, 0x0990, 0x0003}, | ||
2232 | + {0, 0x098E, 0xB441}, | ||
2233 | + {0, 0x0990, 0x00CD}, | ||
2234 | + {0, 0x098E, 0xB442}, | ||
2235 | + {0, 0x0990, 0x0064}, | ||
2236 | + {0, 0x098E, 0xB443}, | ||
2237 | + {0, 0x0990, 0x000F}, | ||
2238 | + {0, 0x098E, 0xB444}, | ||
2239 | + {0, 0x0990, 0x0007}, | ||
2240 | + {0, 0x098E, 0x300D}, | ||
2241 | + {0, 0x0990, 0x000F}, | ||
2242 | + {0, 0x098E, 0x3017}, | ||
2243 | + {0, 0x0990, 0x0F0F}, | ||
2244 | + {0, 0x098E, 0x8400}, | ||
2245 | + {0, 0x0990, 0x0006}, | ||
2246 | + {0, 0x098E, 0xE81F}, | ||
2247 | + {0, 0x0990, 0x0020}, | ||
2248 | + {0, 0x098E, 0x68A0}, | ||
2249 | + {0, 0x0990, 0x082E}, | ||
2250 | + {0, 0x098E, 0x6CA0}, | ||
2251 | + {0, 0x0990, 0x082E}, | ||
2252 | + {0, 0x098E, 0x70A0}, | ||
2253 | + {0, 0x0990, 0x082E}, | ||
2254 | + {0, 0x098E, 0x74A0}, | ||
2255 | + {0, 0x0990, 0x082E}, | ||
2256 | + {0, 0x3C52, 0x082E}, | ||
2257 | + {0, 0x098E, 0x488E}, | ||
2258 | + {0, 0x0990, 0x0020}, | ||
2259 | + {0, 0x098E, 0xECAC}, | ||
2260 | + {0, 0x0990, 0x0000} | ||
2261 | +}; | ||
2262 | + | ||
2263 | +mt9t111_regs def_regs2[] = { | ||
2264 | + {100, 0x0018, 0x0028}, | ||
2265 | + {0, 0x316C, 0x350F}, | ||
2266 | + {0, 0x098E, 0x6817}, | ||
2267 | + {0, 0x0990, 0x000C}, | ||
2268 | + {0, 0x0034, 0x0000} | ||
2269 | +}; | ||
2270 | + | ||
2271 | +mt9t111_regs pll_regs1[] = { | ||
2272 | + {0, 0x0014, 0x2425}, | ||
2273 | + {0, 0x0014, 0x2425}, | ||
2274 | + {0, 0x0014, 0x2145}, | ||
2275 | + {0, 0x0010, 0x0219}, | ||
2276 | + {0, 0x0012, 0x0090}, | ||
2277 | + {0, 0x002A, 0x79DD}, | ||
2278 | + {0, 0x0014, 0x2545}, | ||
2279 | + {0, 0x0014, 0x2547}, | ||
2280 | + {0, 0x0014, 0x3447}, | ||
2281 | + {0, 0x0014, 0x3047} | ||
2282 | +}; | ||
2283 | + | ||
2284 | +mt9t111_regs pll_regs2[] = { | ||
2285 | + {0, 0x0014, 0x3046}, | ||
2286 | + {0, 0x0022, 0x01E0}, | ||
2287 | + {0, 0x001E, 0x0707}, | ||
2288 | + {0, 0x3B84, 0x011D} | ||
2289 | +}; | ||
2290 | + | ||
2291 | +mt9t111_regs bayer_pattern_regs[] = { | ||
2292 | + {0, 0x098E, 0x6807}, | ||
2293 | + {0, 0x0990, 0x0100}, | ||
2294 | + {0, 0x098E, 0x6809}, | ||
2295 | + {0, 0x0990, 0x0000}, | ||
2296 | + {0, 0x098E, 0xE88E}, | ||
2297 | + {0, 0x0990, 0x0000}, | ||
2298 | + {0, 0x098E, 0x6C07}, | ||
2299 | + {0, 0x0990, 0x0100}, | ||
2300 | + {0, 0x098E, 0x6C09}, | ||
2301 | + {0, 0x0990, 0x0000}, | ||
2302 | + {0, 0x098E, 0xEC8E}, | ||
2303 | + {0, 0x0990, 0x0000} | ||
2304 | +}; | ||
2305 | + | ||
2306 | +#endif | ||
2307 | diff --git a/include/media/mt9t111.h b/include/media/mt9t111.h | ||
2308 | new file mode 100644 | ||
2309 | index 0000000..7acbeed | ||
2310 | --- /dev/null | ||
2311 | +++ b/include/media/mt9t111.h | ||
2312 | @@ -0,0 +1,79 @@ | ||
2313 | +/* | ||
2314 | + * include/media/mt9t111.h | ||
2315 | + * | ||
2316 | + * mt9t111 sensor driver | ||
2317 | + * | ||
2318 | + * Copyright (C) 2009 Leopard Imaging | ||
2319 | + * | ||
2320 | + * This file is licensed under the terms of the GNU General Public License | ||
2321 | + * version 2. This program is licensed "as is" without any warranty of any | ||
2322 | + * kind, whether express or implied. | ||
2323 | + */ | ||
2324 | + | ||
2325 | +#ifndef MT9T111_H | ||
2326 | +#define MT9T111_H | ||
2327 | + | ||
2328 | +/********************************* | ||
2329 | + * Defines and Macros and globals | ||
2330 | + ********************************/ | ||
2331 | + | ||
2332 | +#ifdef TRUE | ||
2333 | +#undef TRUE | ||
2334 | +#endif | ||
2335 | + | ||
2336 | +#ifdef FALSE | ||
2337 | +#undef FALSE | ||
2338 | +#endif | ||
2339 | + | ||
2340 | +#define TRUE 1 | ||
2341 | +#define FALSE 0 | ||
2342 | + | ||
2343 | +#ifdef DEBUG | ||
2344 | +#undef DEBUG | ||
2345 | +#endif | ||
2346 | + | ||
2347 | +#ifndef TYPES | ||
2348 | +#define TYPES | ||
2349 | +#endif | ||
2350 | + | ||
2351 | +#define MT9T111_I2C_REGISTERED (1) | ||
2352 | +#define MT9T111_I2C_UNREGISTERED (0) | ||
2353 | + | ||
2354 | +/*i2c adress for MT9T111*/ | ||
2355 | +#define MT9T111_I2C_ADDR (0x78 >>1) | ||
2356 | + | ||
2357 | +#define MT9T111_CLK_MAX (75000000) /* 75MHz */ | ||
2358 | +#define MT9T111_CLK_MIN (6000000) /* 6Mhz */ | ||
2359 | + | ||
2360 | +#define MT9T111_I2C_CONFIG (1) | ||
2361 | +#define I2C_ONE_BYTE_TRANSFER (1) | ||
2362 | +#define I2C_TWO_BYTE_TRANSFER (2) | ||
2363 | +#define I2C_THREE_BYTE_TRANSFER (3) | ||
2364 | +#define I2C_FOUR_BYTE_TRANSFER (4) | ||
2365 | +#define I2C_TXRX_DATA_MASK (0x00FF) | ||
2366 | +#define I2C_TXRX_DATA_MASK_UPPER (0xFF00) | ||
2367 | +#define I2C_TXRX_DATA_SHIFT (8) | ||
2368 | + | ||
2369 | +struct mt9t111_platform_data { | ||
2370 | + char *master; | ||
2371 | + int (*power_set) (enum v4l2_power on); | ||
2372 | + int (*ifparm) (struct v4l2_ifparm *p); | ||
2373 | + int (*priv_data_set) (void *); | ||
2374 | + /* Interface control params */ | ||
2375 | + bool clk_polarity; | ||
2376 | + bool hs_polarity; | ||
2377 | + bool vs_polarity; | ||
2378 | +}; | ||
2379 | + | ||
2380 | +/** | ||
2381 | + * struct capture_size - image capture size information | ||
2382 | + * @width: image width in pixels | ||
2383 | + * @height: image height in pixels | ||
2384 | + */ | ||
2385 | +struct capture_size { | ||
2386 | + unsigned long width; | ||
2387 | + unsigned long height; | ||
2388 | +}; | ||
2389 | + | ||
2390 | +#endif /*for ifndef MT9T111 */ | ||
2391 | + | ||
2392 | -- | ||
2393 | 1.6.6.1 | ||
2394 | |||