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