summaryrefslogtreecommitdiffstats
path: root/extras/recipes-kernel/linux/linux-omap-psp-2.6.32/cam/0001-mt9t111-first-stab-at-merging-sensor-driver-based-on.patch
diff options
context:
space:
mode:
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.patch2394
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 @@
1From 4e23fe54d7f8ecc1c927d225b1b74e6b00e22997 Mon Sep 17 00:00:00 2001
2From: OpenEmbedded User <oe@OE-builder.(none)>
3Date: Tue, 9 Feb 2010 17:16:13 +0100
4Subject: [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
17diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
18index 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
36diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
37index 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
48diff --git a/drivers/media/video/mt9t111.c b/drivers/media/video/mt9t111.c
49new file mode 100644
50index 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");
937diff --git a/drivers/media/video/mt9t111_reg.h b/drivers/media/video/mt9t111_reg.h
938new file mode 100644
939index 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
2307diff --git a/include/media/mt9t111.h b/include/media/mt9t111.h
2308new file mode 100644
2309index 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--
23931.6.6.1
2394
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2024-05-28 13:27:55 +0000