aboutsummaryrefslogtreecommitdiffstats
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 @@
+From 59d42cae8d60b7e86013293055f6c989ab578f26 Mon Sep 17 00:00:00 2001
+From: Sergio Aguirre <saaguirre@ti.com>
+Date: Thu, 15 Jul 2010 00:50:07 -0500
+Subject: [PATCH 48/75] REMOVE: v4l2: Delete MT9T111 sensor driver
+
+This removes MT9T111 support from the kernel.
+
+Reason? Driver already exists in open source, and we're going to
+reuse that one instead.
+
+Signed-off-by: Sergio Aguirre <saaguirre@ti.com>
+---
+ drivers/media/video/Kconfig | 8 -
+ drivers/media/video/Makefile | 1 -
+ drivers/media/video/mt9t111.c | 885 ------------------------
+ drivers/media/video/mt9t111_reg.h | 1364 -------------------------------------
+ include/media/mt9t111.h | 79 ---
+ 5 files changed, 0 insertions(+), 2337 deletions(-)
+ delete mode 100644 drivers/media/video/mt9t111.c
+ delete mode 100644 drivers/media/video/mt9t111_reg.h
+ delete mode 100644 include/media/mt9t111.h
+
+diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
+index c14d758..780b246 100644
+--- a/drivers/media/video/Kconfig
++++ b/drivers/media/video/Kconfig
+@@ -354,14 +354,6 @@ config VIDEO_MT9P012
+ MT9P012 camera. It is currently working with the TI OMAP3
+ camera controller.
+
+-config VIDEO_MT9T111
+- tristate "Micron MT9T111 raw sensor driver (3MP)"
+- depends on I2C && VIDEO_V4L2
+- ---help---
+- This is a Video4Linux2 sensor-level driver for the Micron
+- MT9T111 camera. It is currently working with the TI OMAP3
+- camera controller.
+-
+ config VIDEO_DW9710
+ tristate "Lens driver for DW9710"
+ depends on I2C && VIDEO_V4L2
+diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
+index 763c157..3828723 100644
+--- a/drivers/media/video/Makefile
++++ b/drivers/media/video/Makefile
+@@ -128,7 +128,6 @@ obj-$(CONFIG_VIDEO_CAFE_CCIC) += cafe_ccic.o
+ obj-y += isp/
+ obj-$(CONFIG_VIDEO_OMAP3) += omap34xxcam.o
+ obj-$(CONFIG_VIDEO_MT9P012) += mt9p012.o
+-obj-$(CONFIG_VIDEO_MT9T111) += mt9t111.o
+ obj-$(CONFIG_VIDEO_DW9710) += dw9710.o
+ obj-$(CONFIG_VIDEO_TPS61059) += tps61059.o
+ obj-$(CONFIG_VIDEO_OV3640) += ov3640.o
+diff --git a/drivers/media/video/mt9t111.c b/drivers/media/video/mt9t111.c
+deleted file mode 100644
+index 10080af..0000000
+--- a/drivers/media/video/mt9t111.c
++++ /dev/null
+@@ -1,885 +0,0 @@
+-/*
+- * drivers/media/video/mt9t111.c
+- *
+- * mt9t111 sensor driver
+- *
+- * Copyright (C) 2009 Leopard Imaging
+- *
+- * This file is licensed under the terms of the GNU General Public License
+- * version 2. This program is licensed "as is" without any warranty of any
+- * kind, whether express or implied.
+- */
+-
+-#include <linux/i2c.h>
+-#include <linux/delay.h>
+-#include <media/v4l2-int-device.h>
+-
+-#include <media/mt9t111.h>
+-#include "mt9t111_reg.h"
+-
+-/* YCbCr mode does not work yet */
+-#define USE_RAW
+-/* Create a Color bar test pattern, Blue, Green, Red, Grey */
+-/* #define COLOR_BAR */
+-
+-#define SENSOR_DETECTED 1
+-#define SENSOR_NOT_DETECTED 0
+-
+-static void mt9t111_loaddefault(struct i2c_client *client);
+-
+-/*
+- * as a place holder for further development
+- */
+-static void debug_dummy(char *in_msg)
+-{
+-}
+-
+-/* list of image formats supported by mt9t111 sensor */
+-const static struct v4l2_fmtdesc mt9t111_formats[] = {
+-#ifdef USE_RAW
+- {
+- .description = "RAW ",
+- .pixelformat = V4L2_PIX_FMT_SGRBG10,
+- },
+-#else
+- {
+- .description = "YUV 422 ",
+- .pixelformat = V4L2_PIX_FMT_YUYV,
+- },
+-#endif
+-};
+-
+-#define NUM_CAPTURE_FORMATS ARRAY_SIZE(mt9t111_formats)
+-
+-/*
+- * Array of image sizes supported by MT9T111. These must be ordered from
+- * smallest image size to largest.
+- */
+-const static struct capture_size mt9t111_sizes[] = {
+- { 640, 480 },
+- /* { 2048, 1536} */
+-};
+-
+-#define NUM_CAPTURE_SIZE ARRAY_SIZE(mt9t111_sizes)
+-
+-
+-const struct v4l2_fract mt9t111_frameintervals[] = {
+- { .numerator = 1, .denominator = 10 }
+-};
+-
+-#define NUM_CAPTURE_FRAMEINTERVALS ARRAY_SIZE(mt9t111_frameintervals)
+-
+-/**
+- * struct mt9t111_sensor - main structure for storage of sensor information
+- * @pdata: access functions and data for platform level information
+- * @v4l2_int_device: V4L2 device structure structure
+- * @i2c_client: iic client device structure
+- * @pix: V4L2 pixel format information structure
+- * @timeperframe: time per frame expressed as V4L fraction
+- * @scaler:
+- * @ver: mt9t111 chip version
+- * @fps: frames per second value
+- */
+-struct mt9t111_sensor {
+- const struct mt9t111_platform_data *pdata;
+- struct v4l2_int_device *v4l2_int_device;
+- struct i2c_client *i2c_client;
+- struct v4l2_pix_format pix;
+- struct v4l2_fract timeperframe;
+- int scaler;
+- int ver;
+- int fps;
+- int state;
+-};
+-
+-static struct mt9t111_sensor mt9t111 = {
+- .timeperframe = {
+- .numerator = 1,
+- .denominator = 10,
+- },
+- .state = SENSOR_NOT_DETECTED,
+-};
+-
+-/**
+- * mt9t111_read_reg - Read a value from a register in an mt9t111 sensor device
+- * @client: i2c driver client structure
+- * @data_length: length of data to be read
+- * @reg: register address / offset
+- * @val: stores the value that gets read
+- *
+- * Read a value from a register in an mt9t111 sensor device.
+- * The value is returned in 'val'.
+- * Returns zero if successful, or non-zero otherwise.
+- */
+-static int
+-mt9t111_read_reg(struct i2c_client *client, u16 reg, u16 *val)
+-{
+- struct i2c_msg msg[1];
+- u8 data[4];
+- int err;
+-
+- msg->addr = client->addr;
+- msg->flags = 0;
+- msg->len = 2;
+- msg->buf = data;
+- data[0] = (reg & 0xff00) >> 8;
+- data[1] = (reg & 0x00ff);
+- err = i2c_transfer(client->adapter, msg, 1);
+- if (err >= 0) {
+- msg->flags = I2C_M_RD;
+- msg->len = 2; /* 2 byte read */
+- err = i2c_transfer(client->adapter, msg, 1);
+- if (err >= 0) {
+- *val = ((data[0] & 0x00ff) << 8)
+- | (data[1] & 0x00ff);
+- return 0;
+- }
+- }
+- return err;
+-}
+-
+-/**
+- * mt9t111_write_reg - Write a value to a register in an mt9t111 sensor device
+- * @client: i2c driver client structure
+- * @data_length: length of data to be read
+- * @reg: register address / offset
+- * @val: value to be written to specified register
+- *
+- * Write a value to a register in an mt9t111 sensor device.
+- * Returns zero if successful, or non-zero otherwise.
+- */
+-static int
+-mt9t111_write_reg(struct i2c_client *client, u16 reg, u16 val)
+-{
+- struct i2c_msg msg[1];
+- u8 data[20];
+- int err;
+-
+- msg->addr = client->addr;
+- msg->flags = 0;
+- msg->len = 4;
+- msg->buf = data;
+- data[0] = (u8)((reg & 0xff00) >> 8);
+- data[1] = (u8)(reg & 0x00ff);
+- data[2] = (u8)((val & 0xff00) >> 8);
+- data[3] = (u8)(val & 0x00ff);
+- err = i2c_transfer(client->adapter, msg, 1);
+-
+- return err;
+-}
+-
+-/**
+- * mt9t111_write_regs - Write registers to an mt9t111 sensor device
+- * @client: i2c driver client structure
+- * @reg_in: pointer to registers to write
+- * @cnt: the number of registers
+- *
+- * Write registers .
+- * Returns zero if successful, or non-zero otherwise.
+- */
+-static int
+-mt9t111_write_regs(struct i2c_client *client, mt9t111_regs *reg_in, int cnt)
+-{
+- int err = 0;
+- int i;
+- mt9t111_regs *reg = reg_in;
+-
+- for (i = 0; i < cnt; i++) {
+- if (reg->delay_time == 0) {
+- err |= mt9t111_write_reg(client, reg->addr, reg->data);
+- } else if (reg->addr != 0 || reg->data != 0) {
+- err |= mt9t111_write_reg(client, reg->addr, reg->data);
+- mdelay(reg->delay_time);
+- } else {
+- mdelay(reg->delay_time);
+- }
+-
+- if (err < 0) {
+- dev_warn(&client->dev, "write reg error, addr = 0x%x,"
+- " data = 0x%x \n",
+- reg->addr, reg->data);
+- return err;
+- }
+- reg++;
+- }
+- return err;
+-}
+-
+-/**
+- * mt9t111_detect - Detect if an mt9t111 is present, and if so which revision
+- * @client: pointer to the i2c client driver structure
+- *
+- * Detect if an mt9t111 is present
+- * Returns a negative error number if no device is detected, or the
+- * non-negative value of the version ID register if a device is detected.
+- */
+-static int
+-mt9t111_detect(struct i2c_client *client)
+-{
+- u16 val;
+-
+- /* chip ID is at address 0 */
+- if (mt9t111_read_reg(client, MT9T111_CHIP_ID, &val) < 0)
+- return -ENODEV;
+-
+- if (val != MT9T111_CHIP_ID_VALUE) {
+- dev_warn(&client->dev, "model id mismatch received 0x%x"
+- " expecting 0x%x\n",
+- val, MT9T111_CHIP_ID_VALUE);
+-
+- return -ENODEV;
+- }
+-
+- return (int)val;
+-
+-}
+-
+-/**
+- * mt9t111_configure - Configure the mt9t111 for the specified image mode
+- * @s: pointer to standard V4L2 device structure
+- *
+- * Configure the mt9t111 for a specified image size, pixel format, and frame
+- * period. xclk is the frequency (in Hz) of the xclk input to the mt9t111.
+- * fper is the frame period (in seconds) expressed as a fraction.
+- * Returns zero if successful, or non-zero otherwise.
+- * The actual frame period is returned in fper.
+- */
+-static int mt9t111_configure(struct v4l2_int_device *s)
+-{
+- debug_dummy("debug_dummy -- to set imager mode");
+-
+- return 0;
+-}
+-
+-/**
+- * ioctl_enum_framesizes - V4L2 sensor if handler for vidioc_int_enum_framesizes
+- * @s: pointer to standard V4L2 device structure
+- * @frms: pointer to standard V4L2 framesizes enumeration structure
+- *
+- * Returns possible framesizes depending on choosen pixel format
+- **/
+-static int ioctl_enum_framesizes(struct v4l2_int_device *s,
+- struct v4l2_frmsizeenum *frms)
+-{
+- int ifmt;
+-
+- for (ifmt = 0; ifmt < NUM_CAPTURE_FORMATS; ifmt++) {
+- if (frms->pixel_format == mt9t111_formats[ifmt].pixelformat)
+- break;
+- }
+- /* Is requested pixelformat not found on sensor? */
+- if (ifmt == NUM_CAPTURE_FORMATS)
+- return -EINVAL;
+-
+- /* Do we already reached all discrete framesizes? */
+- if (frms->index >= NUM_CAPTURE_SIZE)
+- return -EINVAL;
+-
+- frms->type = V4L2_FRMSIZE_TYPE_DISCRETE;
+- frms->discrete.width = mt9t111_sizes[frms->index].width;
+- frms->discrete.height = mt9t111_sizes[frms->index].height;
+-
+- return 0;
+-
+-}
+-
+-static int ioctl_enum_frameintervals(struct v4l2_int_device *s,
+- struct v4l2_frmivalenum *frmi)
+-{
+- int ifmt;
+-
+- if (frmi->index >= NUM_CAPTURE_FRAMEINTERVALS)
+- return -EINVAL;
+-
+- for (ifmt = 0; ifmt < NUM_CAPTURE_FORMATS; ifmt++) {
+- if (frmi->pixel_format == mt9t111_formats[ifmt].pixelformat)
+- break;
+- }
+- /* Is requested pixelformat not found on sensor? */
+- if (ifmt == NUM_CAPTURE_FORMATS)
+- return -EINVAL;
+-
+- frmi->type = V4L2_FRMSIZE_TYPE_DISCRETE;
+- frmi->discrete.numerator =
+- mt9t111_frameintervals[frmi->index].numerator;
+- frmi->discrete.denominator =
+- mt9t111_frameintervals[frmi->index].denominator;
+- return 0;
+-}
+-
+-/**
+- * ioctl_init - V4L2 sensor interface handler for VIDIOC_INT_INIT
+- * @s: pointer to standard V4L2 device structure
+- *
+- * Initialize the sensor device (call mt9t111_configure())
+- */
+-static int ioctl_init(struct v4l2_int_device *s)
+-{
+- return 0;
+-}
+-
+-/**
+- * ioctl_dev_exit - V4L2 sensor interface handler for vidioc_int_dev_exit_num
+- * @s: pointer to standard V4L2 device structure
+- *
+- * Delinitialise the dev. at slave detach. The complement of ioctl_dev_init.
+- */
+-static int ioctl_dev_exit(struct v4l2_int_device *s)
+-{
+- return 0;
+-}
+-
+-/**
+- * ioctl_dev_init - V4L2 sensor interface handler for vidioc_int_dev_init_num
+- * @s: pointer to standard V4L2 device structure
+- *
+- * Initialise the device when slave attaches to the master. Returns 0 if
+- * mt9t111 device could be found, otherwise returns appropriate error.
+- */
+-static int ioctl_dev_init(struct v4l2_int_device *s)
+-{
+- return 0;
+-}
+-
+-/**
+- * ioctl_s_power - V4L2 sensor interface handler for vidioc_int_s_power_num
+- * @s: pointer to standard V4L2 device structure
+- * @on: power state to which device is to be set
+- *
+- * Sets devices power state to requrested state, if possible.
+- */
+-static int ioctl_s_power(struct v4l2_int_device *s, enum v4l2_power on)
+-{
+- struct mt9t111_sensor *sensor = s->priv;
+- struct i2c_client *c = sensor->i2c_client;
+- int rval;
+-
+- if ((on == V4L2_POWER_STANDBY) && (sensor->state == SENSOR_DETECTED))
+- debug_dummy("debug_dummy -- put to standby\n");
+-
+- if (on != V4L2_POWER_ON)
+- debug_dummy("debug_dummy -- stop master clock\n");
+- else
+- debug_dummy("debug_dummy -- enable clock\n");;
+-
+- rval = sensor->pdata->power_set(s, on);
+- if (rval < 0) {
+- dev_err(&c->dev, "Unable to set the power state: " "mt9t111"
+- " sensor\n");
+- /* sensor->pdata->set_xclk(0); */
+- return rval;
+- }
+-
+- if ((on == V4L2_POWER_ON) && (sensor->state == SENSOR_DETECTED))
+- mt9t111_loaddefault(c);
+-
+- if ((on == V4L2_POWER_ON) && (sensor->state == SENSOR_NOT_DETECTED)) {
+- rval = mt9t111_detect(c);
+- if (rval < 0) {
+- dev_err(&c->dev, "Unable to detect " "mt9t111"
+- " sensor\n");
+- sensor->state = SENSOR_NOT_DETECTED;
+- return rval;
+- }
+- dev_info(&c->dev, "chip version 0x%02x detected\n", rval);
+- sensor->state = SENSOR_DETECTED;
+- sensor->ver = rval;
+- }
+- return 0;
+-}
+-
+-/**
+- * ioctl_g_priv - V4L2 sensor interface handler for vidioc_int_g_priv_num
+- * @s: pointer to standard V4L2 device structure
+- * @p: void pointer to hold sensor's private data address
+- *
+- * Returns device's (sensor's) private data area address in p parameter
+- */
+-static int ioctl_g_priv(struct v4l2_int_device *s, void *p)
+-{
+- struct mt9t111_sensor *sensor = s->priv;
+-
+- return sensor->pdata->priv_data_set(p);
+-}
+-
+-/**
+- * ioctl_s_parm - V4L2 sensor interface handler for VIDIOC_S_PARM ioctl
+- * @s: pointer to standard V4L2 device structure
+- * @a: pointer to standard V4L2 VIDIOC_S_PARM ioctl structure
+- *
+- * Configures the sensor to use the input parameters, if possible. If
+- * not possible, reverts to the old parameters and returns the
+- * appropriate error code.
+- */
+-static int ioctl_s_parm(struct v4l2_int_device *s,
+- struct v4l2_streamparm *a)
+-{
+- /* TODO: set paramters */
+- debug_dummy("debug_dummy -- VIDIOC_S_PARM ");
+- return 0;
+-}
+-
+-/**
+- * ioctl_g_parm - V4L2 sensor interface handler for VIDIOC_G_PARM ioctl
+- * @s: pointer to standard V4L2 device structure
+- * @a: pointer to standard V4L2 VIDIOC_G_PARM ioctl structure
+- *
+- * Returns the sensor's video CAPTURE parameters.
+- */
+-static int ioctl_g_parm(struct v4l2_int_device *s,
+- struct v4l2_streamparm *a)
+-{
+- struct mt9t111_sensor *sensor = s->priv;
+- struct v4l2_captureparm *cparm = &a->parm.capture;
+-
+- if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+- return -EINVAL;
+-
+- memset(a, 0, sizeof(*a));
+- a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+-
+- cparm->capability = V4L2_CAP_TIMEPERFRAME;
+- cparm->timeperframe = sensor->timeperframe;
+-
+- return 0;
+-}
+-
+-/**
+- * ioctl_g_fmt_cap - V4L2 sensor interface handler for ioctl_g_fmt_cap
+- * @s: pointer to standard V4L2 device structure
+- * @f: pointer to standard V4L2 v4l2_format structure
+- *
+- * Returns the sensor's current pixel format in the v4l2_format
+- * parameter.
+- */
+-static int ioctl_g_fmt_cap(struct v4l2_int_device *s,
+- struct v4l2_format *f)
+-{
+- struct mt9t111_sensor *sensor = s->priv;
+- f->fmt.pix = sensor->pix;
+-
+- return 0;
+-}
+-
+-/**
+- * ioctl_try_fmt_cap - Implement the CAPTURE buffer VIDIOC_TRY_FMT ioctl
+- * @s: pointer to standard V4L2 device structure
+- * @f: pointer to standard V4L2 VIDIOC_TRY_FMT ioctl structure
+- *
+- * Implement the VIDIOC_TRY_FMT ioctl for the CAPTURE buffer type. This
+- * ioctl is used to negotiate the image capture size and pixel format
+- * without actually making it take effect.
+- */
+-static int ioctl_try_fmt_cap(struct v4l2_int_device *s,
+- struct v4l2_format *f)
+-{
+- struct v4l2_pix_format *pix = &f->fmt.pix;
+- struct mt9t111_sensor *sensor = s->priv;
+- struct v4l2_pix_format *pix2 = &sensor->pix;
+-
+- pix->width = 640;
+- pix->height = 480;
+-#ifdef USE_RAW
+- pix->pixelformat = V4L2_PIX_FMT_SGRBG10;
+- pix->bytesperline = pix->width;
+- pix->colorspace = V4L2_COLORSPACE_SRGB;
+-#else
+- pix->pixelformat = V4L2_PIX_FMT_YUYV;
+- pix->bytesperline = pix->width * 2;
+- pix->colorspace = V4L2_COLORSPACE_JPEG;
+-#endif
+- pix->field = V4L2_FIELD_NONE;
+-
+- pix->sizeimage = pix->bytesperline * pix->height;
+- pix->priv = 0;
+- *pix2 = *pix;
+- return 0;
+-}
+-
+-/**
+- * ioctl_s_fmt_cap - V4L2 sensor interface handler for VIDIOC_S_FMT ioctl
+- * @s: pointer to standard V4L2 device structure
+- * @f: pointer to standard V4L2 VIDIOC_S_FMT ioctl structure
+- *
+- * If the requested format is supported, configures the HW to use that
+- * format, returns error code if format not supported or HW can't be
+- * correctly configured.
+- */
+-static int ioctl_s_fmt_cap(struct v4l2_int_device *s,
+- struct v4l2_format *f)
+-{
+- struct mt9t111_sensor *sensor = s->priv;
+- struct v4l2_pix_format *pix = &f->fmt.pix;
+- int rval;
+-
+- rval = ioctl_try_fmt_cap(s, f);
+- if (!rval)
+- sensor->pix = *pix;
+-
+- return rval;
+-}
+-
+-/**
+- * ioctl_enum_fmt_cap - Implement the CAPTURE buffer VIDIOC_ENUM_FMT ioctl
+- * @s: pointer to standard V4L2 device structure
+- * @fmt: standard V4L2 VIDIOC_ENUM_FMT ioctl structure
+- *
+- * Implement the VIDIOC_ENUM_FMT ioctl for the CAPTURE buffer type.
+- */
+-static int ioctl_enum_fmt_cap(struct v4l2_int_device *s,
+- struct v4l2_fmtdesc *fmt)
+-{
+- int index = fmt->index;
+- enum v4l2_buf_type type = fmt->type;
+-
+- memset(fmt, 0, sizeof(*fmt));
+- fmt->index = index;
+- fmt->type = type;
+-
+- switch (fmt->type) {
+- case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+- if (index >= NUM_CAPTURE_FORMATS)
+- return -EINVAL;
+- break;
+- default:
+- return -EINVAL;
+- }
+-
+- fmt->flags = mt9t111_formats[index].flags;
+- strlcpy(fmt->description, mt9t111_formats[index].description,
+- sizeof(fmt->description));
+- fmt->pixelformat = mt9t111_formats[index].pixelformat;
+-
+- return 0;
+-}
+-
+-/**
+- * ioctl_s_ctrl - V4L2 sensor interface handler for VIDIOC_S_CTRL ioctl
+- * @s: pointer to standard V4L2 device structure
+- * @vc: standard V4L2 VIDIOC_S_CTRL ioctl structure
+- *
+- * If the requested control is supported, sets the control's current
+- * value in HW (and updates the video_control[] array). Otherwise,
+- * returns -EINVAL if the control is not supported.
+- */
+-static int ioctl_s_ctrl(struct v4l2_int_device *s,
+- struct v4l2_control *vc)
+-{
+- debug_dummy("debug_dummy -- s ctrl\n");
+- return 0;
+-}
+-
+-/**
+- * ioctl_g_ctrl - V4L2 sensor interface handler for VIDIOC_G_CTRL ioctl
+- * @s: pointer to standard V4L2 device structure
+- * @vc: standard V4L2 VIDIOC_G_CTRL ioctl structure
+- *
+- * If the requested control is supported, returns the control's current
+- * value from the video_control[] array. Otherwise, returns -EINVAL
+- * if the control is not supported.
+- */
+-static int ioctl_g_ctrl(struct v4l2_int_device *s,
+- struct v4l2_control *vc)
+-{
+- debug_dummy("debug_dummy -- g ctrl\n");
+- return 0;
+-}
+-
+-/**
+- * ioctl_queryctrl - V4L2 sensor interface handler for VIDIOC_QUERYCTRL ioctl
+- * @s: pointer to standard V4L2 device structure
+- * @qc: standard V4L2 VIDIOC_QUERYCTRL ioctl structure
+- *
+- * If the requested control is supported, returns the control information
+- * from the video_control[] array. Otherwise, returns -EINVAL if the
+- * control is not supported.
+- */
+-static int ioctl_queryctrl(struct v4l2_int_device *s,
+- struct v4l2_queryctrl *qc)
+-{
+- debug_dummy("debug_dummy -- query ctrl\n");
+- return -EINVAL;
+-}
+-
+-/**
+- * ioctl_s_routing - V4L2 decoder interface handler for VIDIOC_S_INPUT ioctl
+- * @s: pointer to standard V4L2 device structure
+- * @index: number of the input
+- *
+- * If index is valid, selects the requested input. Otherwise, returns -EINVAL if
+- * the input is not supported or there is no active signal present in the
+- * selected input.
+- */
+-static int ioctl_s_routing(struct v4l2_int_device *s,
+- struct v4l2_routing *route)
+-{
+- return 0;
+-}
+-
+-/**
+- * ioctl_g_ifparm - V4L2 decoder interface handler for vidioc_int_g_ifparm_num
+- * @s: pointer to standard V4L2 device structure
+- * @p: pointer to standard V4L2 vidioc_int_g_ifparm_num ioctl structure
+- *
+- * Gets slave interface parameters.
+- * Calculates the required xclk value to support the requested
+- * clock parameters in p. This value is returned in the p
+- * parameter.
+- */
+-static int ioctl_g_ifparm(struct v4l2_int_device *s, struct v4l2_ifparm *p)
+-{
+- struct mt9t111_sensor *sensor = s->priv;
+- int rval;
+-
+- if (p == NULL)
+- return -EINVAL;
+-
+- if (NULL == sensor->pdata->ifparm)
+- return -EINVAL;
+-
+- rval = sensor->pdata->ifparm(p);
+- if (rval) {
+- v4l_err(sensor->i2c_client, "g_ifparm.Err[%d]\n", rval);
+- return rval;
+- }
+-
+- p->u.ycbcr.clock_curr = 40 * 1000000; /* temporal value */
+-
+- return 0;
+-}
+-
+-static struct v4l2_int_ioctl_desc mt9t111_ioctl_desc[] = {
+- { .num = vidioc_int_enum_framesizes_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_enum_framesizes },
+- { .num = vidioc_int_enum_frameintervals_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_enum_frameintervals },
+- { .num = vidioc_int_dev_init_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_dev_init },
+- { .num = vidioc_int_dev_exit_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_dev_exit },
+- { .num = vidioc_int_s_power_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_s_power },
+- { .num = vidioc_int_g_priv_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_g_priv },
+- { .num = vidioc_int_g_ifparm_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_g_ifparm },
+- { .num = vidioc_int_init_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_init },
+- { .num = vidioc_int_enum_fmt_cap_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_enum_fmt_cap },
+- { .num = vidioc_int_try_fmt_cap_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_try_fmt_cap },
+- { .num = vidioc_int_g_fmt_cap_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_g_fmt_cap },
+- { .num = vidioc_int_s_fmt_cap_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_s_fmt_cap },
+- { .num = vidioc_int_g_parm_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_g_parm },
+- { .num = vidioc_int_s_parm_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_s_parm },
+- { .num = vidioc_int_queryctrl_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_queryctrl },
+- { .num = vidioc_int_g_ctrl_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_g_ctrl },
+- { .num = vidioc_int_s_ctrl_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_s_ctrl },
+- { .num = vidioc_int_s_video_routing_num,
+- .func = (v4l2_int_ioctl_func *)ioctl_s_routing },
+-};
+-
+-static void mt9t111_refresh(struct i2c_client *client)
+-{
+- int i;
+- unsigned short value;
+- /* MCU_ADDRESS [SEQ_CMD] -- refresh */
+- mt9t111_write_reg(client, 0x098E, 0x8400);
+- mt9t111_write_reg(client, 0x0990, 0x0006);
+- for (i = 0; i < 100; i++) {
+- mt9t111_write_reg(client, 0x098E, 0x8400);
+- mt9t111_read_reg(client, 0x0990, &value);
+- if (value == 0)
+- break;
+- mdelay(5);
+- }
+-}
+-
+-#ifdef COLOR_BAR
+-static void mt9t111_color_bar(struct i2c_client *client)
+-{
+- mt9t111_write_reg(client, 0x3210, 0x01B0); /* disable lens correction */
+-
+- mt9t111_write_reg(client, 0x098E, 0x6003);
+- mt9t111_write_reg(client, 0x0990, 0x0100);
+- mt9t111_write_reg(client, 0x098E, 0x6025);
+- mt9t111_write_reg(client, 0x0990, 0x0003);
+-}
+-#endif
+-
+-static void mt9t111_bayer_format(struct i2c_client *client)
+-{
+- mt9t111_write_regs(client, bayer_pattern_regs,
+- sizeof(bayer_pattern_regs) / sizeof(mt9t111_regs));
+-}
+-
+-static void mt9t111_enable_pll(struct i2c_client *client)
+-{
+- int i;
+- unsigned short value;
+-
+- mt9t111_write_regs(client, pll_regs1,
+- sizeof(pll_regs1) / sizeof(mt9t111_regs));
+- for (i = 0; i < 100; i++) {
+- mt9t111_read_reg(client, 0x0014, &value);
+- if ((value & 0x8000) != 0)
+- break;
+- mdelay(2);
+- }
+- mt9t111_write_regs(client, pll_regs2,
+- sizeof(pll_regs2) / sizeof(mt9t111_regs));
+-}
+-
+-
+-static void mt9t111_loaddefault(struct i2c_client *client)
+-{
+- mt9t111_write_reg(client, 0x001A, 0x0219);
+- mt9t111_write_reg(client, 0x001A, 0x0218);
+-
+- mt9t111_enable_pll(client);
+- mt9t111_write_regs(client, def_regs1,
+- sizeof(def_regs1) / sizeof(mt9t111_regs));
+- mt9t111_write_regs(client, patch_rev6,
+- sizeof(patch_rev6) / sizeof(mt9t111_regs));
+- mt9t111_write_regs(client, def_regs2,
+- sizeof(def_regs2) / sizeof(mt9t111_regs));
+-
+-#ifdef USE_RAW
+- mt9t111_bayer_format(client);
+-#endif
+-
+-#ifdef COLOR_BAR
+- mt9t111_color_bar(client);
+-#endif
+-
+- mt9t111_refresh(client);
+-}
+-
+-static struct v4l2_int_slave mt9t111_slave = {
+- .ioctls = mt9t111_ioctl_desc,
+- .num_ioctls = ARRAY_SIZE(mt9t111_ioctl_desc),
+-};
+-
+-static struct v4l2_int_device mt9t111_int_device = {
+- .module = THIS_MODULE,
+- .name = "mt9t111",
+- .priv = &mt9t111,
+- .type = v4l2_int_type_slave,
+- .u = {
+- .slave = &mt9t111_slave,
+- },
+-};
+-
+-/**
+- * mt9t111_probe - sensor driver i2c probe handler
+- * @client: i2c driver client device structure
+- *
+- * Register sensor as an i2c client device and V4L2
+- * device.
+- */
+-static int
+-mt9t111_probe(struct i2c_client *client, const struct i2c_device_id *id)
+-{
+- struct mt9t111_sensor *sensor = &mt9t111;
+- int err;
+-
+- if (i2c_get_clientdata(client))
+- return -EBUSY;
+-
+- sensor->pdata = client->dev.platform_data;
+-
+- if (!sensor->pdata) {
+- dev_err(&client->dev, "no platform data?\n");
+- return -ENODEV;
+- }
+-
+- sensor->v4l2_int_device = &mt9t111_int_device;
+- sensor->i2c_client = client;
+-
+- i2c_set_clientdata(client, sensor);
+-
+- sensor->pix.width = 640;
+- sensor->pix.height = 480;
+-#ifdef USE_RAW
+- sensor->pix.pixelformat = V4L2_PIX_FMT_SGRBG10;
+-#else
+- sensor->pix.pixelformat = V4L2_PIX_FMT_YUYV;
+-#endif
+- err = v4l2_int_device_register(sensor->v4l2_int_device);
+- if (err)
+- i2c_set_clientdata(client, NULL);
+- return err;
+-}
+-
+-/**
+- * mt9t111_remove - sensor driver i2c remove handler
+- * @client: i2c driver client device structure
+- *
+- * Unregister sensor as an i2c client device and V4L2
+- * device. Complement of mt9t111_probe().
+- */
+-static int __exit
+-mt9t111_remove(struct i2c_client *client)
+-{
+- struct mt9t111_sensor *sensor = i2c_get_clientdata(client);
+-
+- if (!client->adapter)
+- return -ENODEV; /* our client isn't attached */
+-
+- v4l2_int_device_unregister(sensor->v4l2_int_device);
+- i2c_set_clientdata(client, NULL);
+-
+- return 0;
+-}
+-
+-static const struct i2c_device_id mt9t111_id[] = {
+- { "mt9t111", 0 },
+- { },
+-};
+-MODULE_DEVICE_TABLE(i2c, mt9t111_id);
+-
+-static struct i2c_driver mt9t111sensor_i2c_driver = {
+- .driver = {
+- .name = "mt9t111",
+- .owner = THIS_MODULE,
+- },
+- .probe = mt9t111_probe,
+- .remove = __exit_p(mt9t111_remove),
+- .id_table = mt9t111_id,
+-};
+-
+-/**
+- * mt9t111sensor_init - sensor driver module_init handler
+- *
+- * Registers driver as an i2c client driver. Returns 0 on success,
+- * error code otherwise.
+- */
+-static int __init mt9t111sensor_init(void)
+-{
+-printk(KERN_INFO "entering mt9t111sensor_init\n");
+- return i2c_add_driver(&mt9t111sensor_i2c_driver);
+-}
+-module_init(mt9t111sensor_init);
+-
+-/**
+- * mt9t111sensor_cleanup - sensor driver module_exit handler
+- *
+- * Unregisters/deletes driver as an i2c client driver.
+- * Complement of mt9t111sensor_init.
+- */
+-static void __exit mt9t111sensor_cleanup(void)
+-{
+- i2c_del_driver(&mt9t111sensor_i2c_driver);
+-}
+-module_exit(mt9t111sensor_cleanup);
+-
+-MODULE_LICENSE("GPL");
+-MODULE_DESCRIPTION("mt9t111 camera sensor driver");
+diff --git a/drivers/media/video/mt9t111_reg.h b/drivers/media/video/mt9t111_reg.h
+deleted file mode 100644
+index e226c37..0000000
+--- a/drivers/media/video/mt9t111_reg.h
++++ /dev/null
+@@ -1,1364 +0,0 @@
+-/*
+- * drivers/media/video/mt9t111_reg.h
+- *
+- * mt9t111 sensor driver header file
+- *
+- * Copyright (C) 2009 Leopard Imaging
+- *
+- * This file is licensed under the terms of the GNU General Public License
+- * version 2. This program is licensed "as is" without any warranty of any
+- * kind, whether express or implied.
+- */
+-
+-#ifndef MT9T111_REG_H
+-#define MT9T111_REG_H
+-
+-/* register addr */
+-#define MT9T111_CHIP_ID (0x0000)
+-
+-/* register value */
+-#define MT9T111_CHIP_ID_VALUE (0x2680)
+-
+-typedef struct {
+- u16 delay_time;
+- u16 addr;
+- u16 data;
+-} mt9t111_regs;
+-
+-mt9t111_regs patch_rev6[] = {
+- {0, 0x0982, 0x0},
+- {0, 0x098A, 0xCE7},
+- {0, 0x0990, 0x3C3C},
+- {0, 0x0992, 0x3C3C},
+- {0, 0x0994, 0x3C5F},
+- {0, 0x0996, 0x4F30},
+- {0, 0x0998, 0xED08},
+- {0, 0x099a, 0xBD61},
+- {0, 0x099c, 0xD5CE},
+- {0, 0x099e, 0x4CD},
+- {0, 0x098A, 0xCF7},
+- {0, 0x0990, 0x1F17},
+- {0, 0x0992, 0x211},
+- {0, 0x0994, 0xCC33},
+- {0, 0x0996, 0x2E30},
+- {0, 0x0998, 0xED02},
+- {0, 0x099a, 0xCCFF},
+- {0, 0x099c, 0xFDED},
+- {0, 0x099e, 0xCC},
+- {0, 0x098A, 0xD07},
+- {0, 0x0990, 0x2},
+- {0, 0x0992, 0xBD70},
+- {0, 0x0994, 0x6D18},
+- {0, 0x0996, 0xDE1F},
+- {0, 0x0998, 0x181F},
+- {0, 0x099a, 0x8E01},
+- {0, 0x099c, 0x10CC},
+- {0, 0x099e, 0x3C52},
+- {0, 0x098A, 0xD17},
+- {0, 0x0990, 0x30ED},
+- {0, 0x0992, 0x18},
+- {0, 0x0994, 0xECA0},
+- {0, 0x0996, 0xC4FD},
+- {0, 0x0998, 0xBD70},
+- {0, 0x099a, 0x2120},
+- {0, 0x099c, 0x1ECC},
+- {0, 0x099e, 0x3C52},
+- {0, 0x098A, 0xD27},
+- {0, 0x0990, 0x30ED},
+- {0, 0x0992, 0xDE},
+- {0, 0x0994, 0x1FEC},
+- {0, 0x0996, 0xA0BD},
+- {0, 0x0998, 0x7021},
+- {0, 0x099a, 0xCC3C},
+- {0, 0x099c, 0x5230},
+- {0, 0x099e, 0xED02},
+- {0, 0x098A, 0xD37},
+- {0, 0x0990, 0xCCFF},
+- {0, 0x0992, 0xFCED},
+- {0, 0x0994, 0xCC},
+- {0, 0x0996, 0x2},
+- {0, 0x0998, 0xBD70},
+- {0, 0x099a, 0x6DFC},
+- {0, 0x099c, 0x4E1},
+- {0, 0x099e, 0x1A83},
+- {0, 0x098A, 0xD47},
+- {0, 0x0990, 0x1},
+- {0, 0x0992, 0x2720},
+- {0, 0x0994, 0x1A83},
+- {0, 0x0996, 0x4},
+- {0, 0x0998, 0x271E},
+- {0, 0x099a, 0x1A83},
+- {0, 0x099c, 0x8},
+- {0, 0x099e, 0x271C},
+- {0, 0x098A, 0xD57},
+- {0, 0x0990, 0x1A83},
+- {0, 0x0992, 0x10},
+- {0, 0x0994, 0x271A},
+- {0, 0x0996, 0x1A83},
+- {0, 0x0998, 0x20},
+- {0, 0x099a, 0x2718},
+- {0, 0x099c, 0x1A83},
+- {0, 0x099e, 0x40},
+- {0, 0x098A, 0xD67},
+- {0, 0x0990, 0x2716},
+- {0, 0x0992, 0x2019},
+- {0, 0x0994, 0xC61E},
+- {0, 0x0996, 0x2012},
+- {0, 0x0998, 0xC622},
+- {0, 0x099a, 0x200E},
+- {0, 0x099c, 0xC621},
+- {0, 0x099e, 0x200A},
+- {0, 0x098A, 0xD77},
+- {0, 0x0990, 0xC620},
+- {0, 0x0992, 0x2006},
+- {0, 0x0994, 0xC62A},
+- {0, 0x0996, 0x2002},
+- {0, 0x0998, 0xC62B},
+- {0, 0x099a, 0x30ED},
+- {0, 0x099c, 0x8CC},
+- {0, 0x099e, 0x3400},
+- {0, 0x098A, 0xD87},
+- {0, 0x0990, 0x30ED},
+- {0, 0x0992, 0x34},
+- {0, 0x0994, 0xBD6F},
+- {0, 0x0996, 0xD184},
+- {0, 0x0998, 0x330},
+- {0, 0x099a, 0xED07},
+- {0, 0x099c, 0xA60A},
+- {0, 0x099e, 0x4848},
+- {0, 0x098A, 0xD97},
+- {0, 0x0990, 0x5FED},
+- {0, 0x0992, 0x5EA},
+- {0, 0x0994, 0x8AA},
+- {0, 0x0996, 0x731},
+- {0, 0x0998, 0xBD70},
+- {0, 0x099a, 0x2130},
+- {0, 0x099c, 0xC60A},
+- {0, 0x099e, 0x3A35},
+- {0, 0x098A, 0xDA7},
+- {0, 0x0990, 0x3937},
+- {0, 0x0992, 0x3C3C},
+- {0, 0x0994, 0x3C34},
+- {0, 0x0996, 0xDE2F},
+- {0, 0x0998, 0xEE0E},
+- {0, 0x099a, 0xAD00},
+- {0, 0x099c, 0x7D13},
+- {0, 0x099e, 0xEF27},
+- {0, 0x098A, 0xDB7},
+- {0, 0x0990, 0x7CCE},
+- {0, 0x0992, 0x13E0},
+- {0, 0x0994, 0x1E05},
+- {0, 0x0996, 0x1060},
+- {0, 0x0998, 0xE60E},
+- {0, 0x099a, 0x4FC3},
+- {0, 0x099c, 0x13F0},
+- {0, 0x099e, 0x8FE6},
+- {0, 0x098A, 0xDC7},
+- {0, 0x0990, 0x30},
+- {0, 0x0992, 0xE107},
+- {0, 0x0994, 0x2216},
+- {0, 0x0996, 0xF613},
+- {0, 0x0998, 0xEE4F},
+- {0, 0x099a, 0xC313},
+- {0, 0x099c, 0xF38F},
+- {0, 0x099e, 0xE600},
+- {0, 0x098A, 0xDD7},
+- {0, 0x0990, 0x30E1},
+- {0, 0x0992, 0x725},
+- {0, 0x0994, 0x7F6},
+- {0, 0x0996, 0x13EE},
+- {0, 0x0998, 0xC103},
+- {0, 0x099a, 0x253C},
+- {0, 0x099c, 0x7F13},
+- {0, 0x099e, 0xEEF6},
+- {0, 0x098A, 0xDE7},
+- {0, 0x0990, 0x13EF},
+- {0, 0x0992, 0xE706},
+- {0, 0x0994, 0xCC13},
+- {0, 0x0996, 0xF0ED},
+- {0, 0x0998, 0x4CC},
+- {0, 0x099a, 0x13F3},
+- {0, 0x099c, 0x200F},
+- {0, 0x099e, 0x7C13},
+- {0, 0x098A, 0xDF7},
+- {0, 0x0990, 0xEEEC},
+- {0, 0x0992, 0x4C3},
+- {0, 0x0994, 0x1},
+- {0, 0x0996, 0xED04},
+- {0, 0x0998, 0xEC02},
+- {0, 0x099a, 0xC300},
+- {0, 0x099c, 0x1ED},
+- {0, 0x099e, 0x2F6},
+- {0, 0x098A, 0xE07},
+- {0, 0x0990, 0x13EE},
+- {0, 0x0992, 0xE106},
+- {0, 0x0994, 0x2412},
+- {0, 0x0996, 0xEE04},
+- {0, 0x0998, 0xE600},
+- {0, 0x099a, 0x30E1},
+- {0, 0x099c, 0x722},
+- {0, 0x099e, 0xDFEE},
+- {0, 0x098A, 0xE17},
+- {0, 0x0990, 0x2E6},
+- {0, 0x0992, 0x30},
+- {0, 0x0994, 0xE107},
+- {0, 0x0996, 0x25D6},
+- {0, 0x0998, 0xDE49},
+- {0, 0x099a, 0xEE08},
+- {0, 0x099c, 0xAD00},
+- {0, 0x099e, 0xCC13},
+- {0, 0x098A, 0xE27},
+- {0, 0x0990, 0xF630},
+- {0, 0x0992, 0xED00},
+- {0, 0x0994, 0xDE2F},
+- {0, 0x0996, 0xEE10},
+- {0, 0x0998, 0xCC13},
+- {0, 0x099a, 0xFAAD},
+- {0, 0x099c, 0x38},
+- {0, 0x099e, 0x3838},
+- {0, 0x098A, 0xE37},
+- {0, 0x0990, 0x3839},
+- {0, 0x098A, 0x1000},
+- {0, 0x0990, 0xCC10},
+- {0, 0x0992, 0x9BD},
+- {0, 0x0994, 0x4224},
+- {0, 0x0996, 0x7E10},
+- {0, 0x0998, 0x9C6},
+- {0, 0x099a, 0x1F7},
+- {0, 0x099c, 0x18A},
+- {0, 0x099e, 0xC606},
+- {0, 0x098A, 0x1010},
+- {0, 0x0990, 0xF701},
+- {0, 0x0992, 0x8BDE},
+- {0, 0x0994, 0x3F18},
+- {0, 0x0996, 0xCE0B},
+- {0, 0x0998, 0xF1CC},
+- {0, 0x099a, 0x11},
+- {0, 0x099c, 0xBDD7},
+- {0, 0x099e, 0xCC},
+- {0, 0x098A, 0x1020},
+- {0, 0x0990, 0xBF1},
+- {0, 0x0992, 0xDD3F},
+- {0, 0x0994, 0xDE35},
+- {0, 0x0996, 0x18CE},
+- {0, 0x0998, 0xC03},
+- {0, 0x099a, 0xCC00},
+- {0, 0x099c, 0x3FBD},
+- {0, 0x099e, 0xD700},
+- {0, 0x098A, 0x1030},
+- {0, 0x0990, 0xCC0C},
+- {0, 0x0992, 0x3DD},
+- {0, 0x0994, 0x35DE},
+- {0, 0x0996, 0x4718},
+- {0, 0x0998, 0xCE0C},
+- {0, 0x099a, 0x43CC},
+- {0, 0x099c, 0x15},
+- {0, 0x099e, 0xBDD7},
+- {0, 0x098A, 0x1040},
+- {0, 0x0990, 0xCC},
+- {0, 0x0992, 0xC43},
+- {0, 0x0994, 0xDD47},
+- {0, 0x0996, 0xFE00},
+- {0, 0x0998, 0x3318},
+- {0, 0x099a, 0xCE0C},
+- {0, 0x099c, 0x59CC},
+- {0, 0x099e, 0x9},
+- {0, 0x098A, 0x1050},
+- {0, 0x0990, 0xBDD7},
+- {0, 0x0992, 0xCC},
+- {0, 0x0994, 0xC59},
+- {0, 0x0996, 0xFD00},
+- {0, 0x0998, 0x33DE},
+- {0, 0x099a, 0x4118},
+- {0, 0x099c, 0xCE0C},
+- {0, 0x099e, 0x63CC},
+- {0, 0x098A, 0x1060},
+- {0, 0x0990, 0xD},
+- {0, 0x0992, 0xBDD7},
+- {0, 0x0994, 0xCC},
+- {0, 0x0996, 0xC63},
+- {0, 0x0998, 0xDD41},
+- {0, 0x099a, 0xFE00},
+- {0, 0x099c, 0x3118},
+- {0, 0x099e, 0xCE0C},
+- {0, 0x098A, 0x1070},
+- {0, 0x0990, 0x71CC},
+- {0, 0x0992, 0x29},
+- {0, 0x0994, 0xBDD7},
+- {0, 0x0996, 0xCC},
+- {0, 0x0998, 0xC71},
+- {0, 0x099a, 0xFD00},
+- {0, 0x099c, 0x31DE},
+- {0, 0x099e, 0x3918},
+- {0, 0x098A, 0x1080},
+- {0, 0x0990, 0xCE0C},
+- {0, 0x0992, 0x9BCC},
+- {0, 0x0994, 0x23},
+- {0, 0x0996, 0xBDD7},
+- {0, 0x0998, 0xCC},
+- {0, 0x099a, 0xC9B},
+- {0, 0x099c, 0xDD39},
+- {0, 0x099e, 0xDE49},
+- {0, 0x098A, 0x1090},
+- {0, 0x0990, 0x18CE},
+- {0, 0x0992, 0xCBF},
+- {0, 0x0994, 0xCC00},
+- {0, 0x0996, 0xDBD},
+- {0, 0x0998, 0xD700},
+- {0, 0x099a, 0xCC0C},
+- {0, 0x099c, 0xBFDD},
+- {0, 0x099e, 0x49CC},
+- {0, 0x098A, 0x10A0},
+- {0, 0x0990, 0x1162},
+- {0, 0x0992, 0xFD0B},
+- {0, 0x0994, 0xFDCC},
+- {0, 0x0996, 0xCE7},
+- {0, 0x0998, 0xFD0C},
+- {0, 0x099a, 0x1FCC},
+- {0, 0x099c, 0x1245},
+- {0, 0x099e, 0xFD0C},
+- {0, 0x098A, 0x10B0},
+- {0, 0x0990, 0x51CC},
+- {0, 0x0992, 0x110B},
+- {0, 0x0994, 0xFD0C},
+- {0, 0x0996, 0x5BCC},
+- {0, 0x0998, 0x1108},
+- {0, 0x099a, 0xFD0C},
+- {0, 0x099c, 0x65CC},
+- {0, 0x099e, 0x10D0},
+- {0, 0x098A, 0x10C0},
+- {0, 0x0990, 0xFD0C},
+- {0, 0x0992, 0x7BCC},
+- {0, 0x0994, 0x12DE},
+- {0, 0x0996, 0xFD0C},
+- {0, 0x0998, 0xA7CC},
+- {0, 0x099a, 0xDA8},
+- {0, 0x099c, 0xFD0C},
+- {0, 0x099e, 0xCB39},
+- {0, 0x098A, 0x10D0},
+- {0, 0x0990, 0x37DE},
+- {0, 0x0992, 0x1DEC},
+- {0, 0x0994, 0xC5F},
+- {0, 0x0996, 0x8402},
+- {0, 0x0998, 0x4416},
+- {0, 0x099a, 0x4FF7},
+- {0, 0x099c, 0xCCD},
+- {0, 0x099e, 0xE60B},
+- {0, 0x098A, 0x10E0},
+- {0, 0x0990, 0xC407},
+- {0, 0x0992, 0xF70C},
+- {0, 0x0994, 0xCE7F},
+- {0, 0x0996, 0x30C4},
+- {0, 0x0998, 0xEC25},
+- {0, 0x099a, 0xFD30},
+- {0, 0x099c, 0xC5FC},
+- {0, 0x099e, 0x6D6},
+- {0, 0x098A, 0x10F0},
+- {0, 0x0990, 0xFD30},
+- {0, 0x0992, 0xC701},
+- {0, 0x0994, 0xFC30},
+- {0, 0x0996, 0xC0FD},
+- {0, 0x0998, 0xBED},
+- {0, 0x099a, 0xFC30},
+- {0, 0x099c, 0xC2FD},
+- {0, 0x099e, 0xBEF},
+- {0, 0x098A, 0x1100},
+- {0, 0x0990, 0x30E6},
+- {0, 0x0992, 0xBD},
+- {0, 0x0994, 0x5203},
+- {0, 0x0996, 0x3139},
+- {0, 0x0998, 0x7E9E},
+- {0, 0x099a, 0x143C},
+- {0, 0x099c, 0x3C3C},
+- {0, 0x099e, 0x2101},
+- {0, 0x098A, 0x1110},
+- {0, 0x0990, 0xCC00},
+- {0, 0x0992, 0x18BD},
+- {0, 0x0994, 0x6FD1},
+- {0, 0x0996, 0xC504},
+- {0, 0x0998, 0x26F5},
+- {0, 0x099a, 0xDC25},
+- {0, 0x099c, 0x30ED},
+- {0, 0x099e, 0x420},
+- {0, 0x098A, 0x1120},
+- {0, 0x0990, 0x12EE},
+- {0, 0x0992, 0x43C},
+- {0, 0x0994, 0x1838},
+- {0, 0x0996, 0xE621},
+- {0, 0x0998, 0x18E7},
+- {0, 0x099a, 0xBE30},
+- {0, 0x099c, 0xEE04},
+- {0, 0x099e, 0xEC1D},
+- {0, 0x098A, 0x1130},
+- {0, 0x0990, 0x30ED},
+- {0, 0x0992, 0x4EC},
+- {0, 0x0994, 0x426},
+- {0, 0x0996, 0xEACC},
+- {0, 0x0998, 0x1A},
+- {0, 0x099a, 0xED02},
+- {0, 0x099c, 0xCCFB},
+- {0, 0x099e, 0xFFED},
+- {0, 0x098A, 0x1140},
+- {0, 0x0990, 0xCC},
+- {0, 0x0992, 0x400},
+- {0, 0x0994, 0xBD70},
+- {0, 0x0996, 0x6DCC},
+- {0, 0x0998, 0x1A},
+- {0, 0x099a, 0x30ED},
+- {0, 0x099c, 0x2CC},
+- {0, 0x099e, 0xFBFF},
+- {0, 0x098A, 0x1150},
+- {0, 0x0990, 0xED00},
+- {0, 0x0992, 0x5F4F},
+- {0, 0x0994, 0xBD70},
+- {0, 0x0996, 0x6D5F},
+- {0, 0x0998, 0xBD5B},
+- {0, 0x099a, 0x17BD},
+- {0, 0x099c, 0x558B},
+- {0, 0x099e, 0x3838},
+- {0, 0x098A, 0x1160},
+- {0, 0x0990, 0x3839},
+- {0, 0x0992, 0x3C3C},
+- {0, 0x0994, 0xC640},
+- {0, 0x0996, 0xF730},
+- {0, 0x0998, 0xC4FC},
+- {0, 0x099a, 0xBED},
+- {0, 0x099c, 0xFD30},
+- {0, 0x099e, 0xC0FC},
+- {0, 0x098A, 0x1170},
+- {0, 0x0990, 0xBEF},
+- {0, 0x0992, 0xFD30},
+- {0, 0x0994, 0xC2DE},
+- {0, 0x0996, 0x1DEC},
+- {0, 0x0998, 0x25FD},
+- {0, 0x099a, 0x30C5},
+- {0, 0x099c, 0x101},
+- {0, 0x099e, 0x1FC},
+- {0, 0x098A, 0x1180},
+- {0, 0x0990, 0x30C2},
+- {0, 0x0992, 0xFD06},
+- {0, 0x0994, 0xD6EC},
+- {0, 0x0996, 0xC5F},
+- {0, 0x0998, 0x8402},
+- {0, 0x099a, 0x4416},
+- {0, 0x099c, 0x4F30},
+- {0, 0x099e, 0xE703},
+- {0, 0x098A, 0x1190},
+- {0, 0x0990, 0xF10C},
+- {0, 0x0992, 0xCD27},
+- {0, 0x0994, 0x15F1},
+- {0, 0x0996, 0xCCD},
+- {0, 0x0998, 0x2309},
+- {0, 0x099a, 0xFC06},
+- {0, 0x099c, 0xD604},
+- {0, 0x099e, 0xFD06},
+- {0, 0x098A, 0x11A0},
+- {0, 0x0990, 0xD620},
+- {0, 0x0992, 0x7FC},
+- {0, 0x0994, 0x6D6},
+- {0, 0x0996, 0x5FD},
+- {0, 0x0998, 0x6D6},
+- {0, 0x099a, 0xDE1D},
+- {0, 0x099c, 0xE60B},
+- {0, 0x099e, 0xC407},
+- {0, 0x098A, 0x11B0},
+- {0, 0x0990, 0x30E7},
+- {0, 0x0992, 0x2F1},
+- {0, 0x0994, 0xCCE},
+- {0, 0x0996, 0x272C},
+- {0, 0x0998, 0x7D0C},
+- {0, 0x099a, 0xCE27},
+- {0, 0x099c, 0x275D},
+- {0, 0x099e, 0x2724},
+- {0, 0x098A, 0x11C0},
+- {0, 0x0990, 0x7F30},
+- {0, 0x0992, 0xC4FC},
+- {0, 0x0994, 0x6D6},
+- {0, 0x0996, 0xFD30},
+- {0, 0x0998, 0xC5F6},
+- {0, 0x099a, 0xCCE},
+- {0, 0x099c, 0x4FFD},
+- {0, 0x099e, 0x30C7},
+- {0, 0x098A, 0x11D0},
+- {0, 0x0990, 0xC640},
+- {0, 0x0992, 0xF730},
+- {0, 0x0994, 0xC4E6},
+- {0, 0x0996, 0x24F},
+- {0, 0x0998, 0xFD30},
+- {0, 0x099a, 0xC501},
+- {0, 0x099c, 0x101},
+- {0, 0x099e, 0xFC30},
+- {0, 0x098A, 0x11E0},
+- {0, 0x0990, 0xC2FD},
+- {0, 0x0992, 0x6D6},
+- {0, 0x0994, 0x7D06},
+- {0, 0x0996, 0xCB27},
+- {0, 0x0998, 0x2EC6},
+- {0, 0x099a, 0x40F7},
+- {0, 0x099c, 0x30C4},
+- {0, 0x099e, 0xFC06},
+- {0, 0x098A, 0x11F0},
+- {0, 0x0990, 0xC104},
+- {0, 0x0992, 0xF306},
+- {0, 0x0994, 0xD6ED},
+- {0, 0x0996, 0x5F},
+- {0, 0x0998, 0x6D00},
+- {0, 0x099a, 0x2A01},
+- {0, 0x099c, 0x5317},
+- {0, 0x099e, 0xFD30},
+- {0, 0x098A, 0x1200},
+- {0, 0x0990, 0xC0EC},
+- {0, 0x0992, 0xFD},
+- {0, 0x0994, 0x30C2},
+- {0, 0x0996, 0xFC06},
+- {0, 0x0998, 0xC1FD},
+- {0, 0x099a, 0x30C5},
+- {0, 0x099c, 0x101},
+- {0, 0x099e, 0x1FC},
+- {0, 0x098A, 0x1210},
+- {0, 0x0990, 0x30C2},
+- {0, 0x0992, 0xFD06},
+- {0, 0x0994, 0xC720},
+- {0, 0x0996, 0x227F},
+- {0, 0x0998, 0x30C4},
+- {0, 0x099a, 0xDE1D},
+- {0, 0x099c, 0xEC25},
+- {0, 0x099e, 0xFD30},
+- {0, 0x098A, 0x1220},
+- {0, 0x0990, 0xC5FC},
+- {0, 0x0992, 0x6D6},
+- {0, 0x0994, 0xFD30},
+- {0, 0x0996, 0xC701},
+- {0, 0x0998, 0xFC30},
+- {0, 0x099a, 0xC0FD},
+- {0, 0x099c, 0x6D0},
+- {0, 0x099e, 0xFC30},
+- {0, 0x098A, 0x1230},
+- {0, 0x0990, 0xC2FD},
+- {0, 0x0992, 0x6D2},
+- {0, 0x0994, 0xEC25},
+- {0, 0x0996, 0xFD06},
+- {0, 0x0998, 0xC3BD},
+- {0, 0x099a, 0x953C},
+- {0, 0x099c, 0xDE3F},
+- {0, 0x099e, 0xEE10},
+- {0, 0x098A, 0x1240},
+- {0, 0x0990, 0xAD00},
+- {0, 0x0992, 0x3838},
+- {0, 0x0994, 0x3930},
+- {0, 0x0996, 0x8FC3},
+- {0, 0x0998, 0xFFE9},
+- {0, 0x099a, 0x8F35},
+- {0, 0x099c, 0xBDAD},
+- {0, 0x099e, 0x1530},
+- {0, 0x098A, 0x1250},
+- {0, 0x0990, 0x6F16},
+- {0, 0x0992, 0x18DE},
+- {0, 0x0994, 0x1918},
+- {0, 0x0996, 0x8FC3},
+- {0, 0x0998, 0x14B},
+- {0, 0x099a, 0x188F},
+- {0, 0x099c, 0x18EC},
+- {0, 0x099e, 0xFD},
+- {0, 0x098A, 0x1260},
+- {0, 0x0990, 0x50E},
+- {0, 0x0992, 0x18EC},
+- {0, 0x0994, 0x2FD},
+- {0, 0x0996, 0x510},
+- {0, 0x0998, 0xE616},
+- {0, 0x099a, 0x4FED},
+- {0, 0x099c, 0x418},
+- {0, 0x099e, 0x8FC3},
+- {0, 0x098A, 0x1270},
+- {0, 0x0990, 0xFFCB},
+- {0, 0x0992, 0xE304},
+- {0, 0x0994, 0x8FE6},
+- {0, 0x0996, 0xF7},
+- {0, 0x0998, 0x514},
+- {0, 0x099a, 0x18DE},
+- {0, 0x099c, 0x1930},
+- {0, 0x099e, 0xE616},
+- {0, 0x098A, 0x1280},
+- {0, 0x0990, 0x4FED},
+- {0, 0x0992, 0x418},
+- {0, 0x0994, 0x8FC3},
+- {0, 0x0996, 0x119},
+- {0, 0x0998, 0xE304},
+- {0, 0x099a, 0x8FE6},
+- {0, 0x099c, 0xF7},
+- {0, 0x099e, 0x515},
+- {0, 0x098A, 0x1290},
+- {0, 0x0990, 0xFC05},
+- {0, 0x0992, 0x5BFD},
+- {0, 0x0994, 0x512},
+- {0, 0x0996, 0xDE37},
+- {0, 0x0998, 0xEE08},
+- {0, 0x099a, 0xAD00},
+- {0, 0x099c, 0x30E6},
+- {0, 0x099e, 0x164F},
+- {0, 0x098A, 0x12A0},
+- {0, 0x0990, 0x5ED},
+- {0, 0x0992, 0x48F},
+- {0, 0x0994, 0xC300},
+- {0, 0x0996, 0x630},
+- {0, 0x0998, 0xE304},
+- {0, 0x099a, 0x8FF6},
+- {0, 0x099c, 0x516},
+- {0, 0x099e, 0x4FED},
+- {0, 0x098A, 0x12B0},
+- {0, 0x0990, 0x30},
+- {0, 0x0992, 0x6C16},
+- {0, 0x0994, 0xE616},
+- {0, 0x0996, 0xC103},
+- {0, 0x0998, 0x2598},
+- {0, 0x099a, 0xCC32},
+- {0, 0x099c, 0x8EED},
+- {0, 0x099e, 0xEC},
+- {0, 0x098A, 0x12C0},
+- {0, 0x0990, 0x6BD},
+- {0, 0x0992, 0x7021},
+- {0, 0x0994, 0xCC32},
+- {0, 0x0996, 0x6C30},
+- {0, 0x0998, 0xED02},
+- {0, 0x099a, 0xCCF8},
+- {0, 0x099c, 0xED},
+- {0, 0x099e, 0xA6},
+- {0, 0x098A, 0x12D0},
+- {0, 0x0990, 0x9E3},
+- {0, 0x0992, 0xA84},
+- {0, 0x0994, 0x7BD},
+- {0, 0x0996, 0x706D},
+- {0, 0x0998, 0x30C6},
+- {0, 0x099a, 0x173A},
+- {0, 0x099c, 0x3539},
+- {0, 0x099e, 0x3CBD},
+- {0, 0x098A, 0x12E0},
+- {0, 0x0990, 0x776D},
+- {0, 0x0992, 0xCC32},
+- {0, 0x0994, 0x5C30},
+- {0, 0x0996, 0xED00},
+- {0, 0x0998, 0xFC13},
+- {0, 0x099a, 0x8683},
+- {0, 0x099c, 0x1},
+- {0, 0x099e, 0xBD70},
+- {0, 0x098A, 0x12F0},
+- {0, 0x0990, 0x21CC},
+- {0, 0x0992, 0x325E},
+- {0, 0x0994, 0x30ED},
+- {0, 0x0996, 0xFC},
+- {0, 0x0998, 0x1388},
+- {0, 0x099a, 0x8300},
+- {0, 0x099c, 0x1BD},
+- {0, 0x099e, 0x7021},
+- {0, 0x098A, 0x1300},
+- {0, 0x0990, 0x3839},
+- {0, 0x098E, 0x0010},
+- {0, 0x0990, 0x1000},
+- {0, 0x098E, 0x0003},
+- {100, 0x0990, 0x0004}
+-};
+-
+-mt9t111_regs def_regs1[] = {
+- {0, 0x001A, 0x0218},
+- {0, 0x001E, 0x0777},
+- {0, 0x3084, 0x2409},
+- {0, 0x3092, 0x0A49},
+- {0, 0x3094, 0x4949},
+- {0, 0x3096, 0x4950},
+- {0, 0x0018, 0x402D},
+- {100, 0x0018, 0x402C},
+- {0, 0x098E, 0x6800},
+- {0, 0x0990, 0x0280},
+- {0, 0x098E, 0x6802},
+- {0, 0x0990, 0x01E0},
+- {0, 0x098E, 0xE88E},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0x68A0},
+- {0, 0x0990, 0x082D},
+- {0, 0x098E, 0x4802},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0x4804},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0x4806},
+- {0, 0x0990, 0x060D},
+- {0, 0x098E, 0x4808},
+- {0, 0x0990, 0x080D},
+- {0, 0x098E, 0x480A},
+- {0, 0x0990, 0x0111},
+- {0, 0x098E, 0x480C},
+- {0, 0x0990, 0x046C},
+- {0, 0x098E, 0x480F},
+- {0, 0x0990, 0x00CC},
+- {0, 0x098E, 0x4811},
+- {0, 0x0990, 0x0381},
+- {0, 0x098E, 0x4813},
+- {0, 0x0990, 0x024F},
+- {0, 0x098E, 0x481D},
+- {0, 0x0990, 0x05AE},
+- {0, 0x098E, 0x481F},
+- {0, 0x0990, 0x05D0},
+- {0, 0x098E, 0x4825},
+- {0, 0x0990, 0x07AC},
+- {0, 0x098E, 0x6C00},
+- {0, 0x0990, 0x0800},
+- {0, 0x098E, 0x6C02},
+- {0, 0x0990, 0x0600},
+- {0, 0x098E, 0xEC8E},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0x6CA0},
+- {0, 0x0990, 0x082D},
+- {0, 0x098E, 0x484A},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0x484C},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0x484E},
+- {0, 0x0990, 0x060D},
+- {0, 0x098E, 0x4850},
+- {0, 0x0990, 0x080D},
+- {0, 0x098E, 0x4852},
+- {0, 0x0990, 0x0111},
+- {0, 0x098E, 0x4854},
+- {0, 0x0990, 0x146C},
+- {0, 0x098E, 0x4857},
+- {0, 0x0990, 0x00CC},
+- {0, 0x098E, 0x4859},
+- {0, 0x0990, 0x0381},
+- {0, 0x098E, 0x485B},
+- {0, 0x0990, 0x024F},
+- {0, 0x098E, 0x4865},
+- {0, 0x0990, 0x05AE},
+- {0, 0x098E, 0x4867},
+- {0, 0x0990, 0x05D0},
+- {0, 0x098E, 0x486D},
+- {0, 0x0990, 0x07AC},
+- {0, 0x098E, 0xC8A5},
+- {0, 0x0990, 0x001D},
+- {0, 0x098E, 0xC8A6},
+- {0, 0x0990, 0x0020},
+- {0, 0x098E, 0xC8A7},
+- {0, 0x0990, 0x0023},
+- {0, 0x098E, 0xC8A8},
+- {0, 0x0990, 0x0026},
+- {0, 0x098E, 0xC844},
+- {0, 0x0990, 0x0091},
+- {0, 0x098E, 0xC92F},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xC845},
+- {0, 0x0990, 0x0079},
+- {0, 0x098E, 0xC92D},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xC88C},
+- {0, 0x0990, 0x0091},
+- {0, 0x098E, 0xC930},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xC88D},
+- {0, 0x0990, 0x0079},
+- {0, 0x098E, 0xC92E},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xA002},
+- {0, 0x0990, 0x0010},
+- {0, 0x098E, 0xA009},
+- {0, 0x0990, 0x0002},
+- {0, 0x098E, 0xA00A},
+- {0, 0x0990, 0x0003},
+- {0, 0x098E, 0xA00C},
+- {0, 0x0990, 0x000A},
+- {0, 0x098E, 0x4846},
+- {0, 0x0990, 0x0014},
+- {0, 0x098E, 0x68AA},
+- {0, 0x0990, 0x0278},
+- {0, 0x098E, 0x488E},
+- {0, 0x0990, 0x0014},
+- {0, 0x098E, 0x6CAA},
+- {0, 0x0990, 0x0218},
+- {0, 0x098E, 0x8400},
+- {0, 0x0990, 0x0006},
+- {0, 0x098E, 0x8400},
+- {0, 0x0990, 0x0005},
+- {0, 0x3C20, 0x0001},
+- {0, 0x364A, 0x7D2F},
+- {0, 0x364C, 0x79EB},
+- {0, 0x364E, 0x18D2},
+- {0, 0x3650, 0x9F8F},
+- {0, 0x3652, 0xA7D2},
+- {0, 0x368A, 0x460C},
+- {0, 0x368C, 0x14F0},
+- {0, 0x368E, 0x946F},
+- {0, 0x3690, 0xC471},
+- {0, 0x3692, 0x04B1},
+- {0, 0x36CA, 0x0433},
+- {0, 0x36CC, 0x680D},
+- {0, 0x36CE, 0xEEF3},
+- {0, 0x36D0, 0x4850},
+- {0, 0x36D2, 0xF233},
+- {0, 0x370A, 0xB2AF},
+- {0, 0x370C, 0x2CF0},
+- {0, 0x370E, 0x3F10},
+- {0, 0x3710, 0xC673},
+- {0, 0x3712, 0xA972},
+- {0, 0x374A, 0x0590},
+- {0, 0x374C, 0xAFB3},
+- {0, 0x374E, 0x93D7},
+- {0, 0x3750, 0x8D12},
+- {0, 0x3752, 0x2539},
+- {0, 0x3640, 0x0350},
+- {0, 0x3642, 0x322C},
+- {0, 0x3644, 0x77D1},
+- {0, 0x3646, 0xA26F},
+- {0, 0x3648, 0xC872},
+- {0, 0x3680, 0x0C4C},
+- {0, 0x3682, 0x9510},
+- {0, 0x3684, 0x110E},
+- {0, 0x3686, 0x4331},
+- {0, 0x3688, 0xC1CF},
+- {0, 0x36C0, 0x6152},
+- {0, 0x36C2, 0x038E},
+- {0, 0x36C4, 0x9AF4},
+- {0, 0x36C6, 0xE12F},
+- {0, 0x36C8, 0x09F3},
+- {0, 0x3700, 0xC5AF},
+- {0, 0x3702, 0xCA90},
+- {0, 0x3704, 0x5D0F},
+- {0, 0x3706, 0x3293},
+- {0, 0x3708, 0x2B92},
+- {0, 0x3740, 0xC590},
+- {0, 0x3742, 0x8133},
+- {0, 0x3744, 0xE0F6},
+- {0, 0x3746, 0x0254},
+- {0, 0x3748, 0x10B9},
+- {0, 0x3654, 0x7F8F},
+- {0, 0x3656, 0x6F6C},
+- {0, 0x3658, 0x5971},
+- {0, 0x365A, 0x9A0F},
+- {0, 0x365C, 0xA1B2},
+- {0, 0x3694, 0xB00C},
+- {0, 0x3696, 0xEBCF},
+- {0, 0x3698, 0x06AD},
+- {0, 0x369A, 0x4D31},
+- {0, 0x369C, 0x2A4E},
+- {0, 0x36D4, 0x4752},
+- {0, 0x36D6, 0x724D},
+- {0, 0x36D8, 0xAD34},
+- {0, 0x36DA, 0x1350},
+- {0, 0x36DC, 0x4E94},
+- {0, 0x3714, 0xA06E},
+- {0, 0x3716, 0x9152},
+- {0, 0x3718, 0x1F53},
+- {0, 0x371A, 0x3933},
+- {0, 0x371C, 0xBA94},
+- {0, 0x3754, 0x1233},
+- {0, 0x3756, 0xA032},
+- {0, 0x3758, 0xE936},
+- {0, 0x375A, 0xBE34},
+- {0, 0x375C, 0x02D9},
+- {0, 0x365E, 0x7DEF},
+- {0, 0x3660, 0x434B},
+- {0, 0x3662, 0x69F1},
+- {0, 0x3664, 0x8A0F},
+- {0, 0x3666, 0xBDB2},
+- {0, 0x369E, 0x290D},
+- {0, 0x36A0, 0x42CF},
+- {0, 0x36A2, 0xDC6D},
+- {0, 0x36A4, 0x91B1},
+- {0, 0x36A6, 0x9DE9},
+- {0, 0x36DE, 0x70B2},
+- {0, 0x36E0, 0x02AC},
+- {0, 0x36E2, 0x9714},
+- {0, 0x36E4, 0xF3CF},
+- {0, 0x36E6, 0x6BD1},
+- {0, 0x371E, 0xE42E},
+- {0, 0x3720, 0x1D32},
+- {0, 0x3722, 0xCC31},
+- {0, 0x3724, 0xAE94},
+- {0, 0x3726, 0x6413},
+- {0, 0x375E, 0xE290},
+- {0, 0x3760, 0x8F53},
+- {0, 0x3762, 0xF936},
+- {0, 0x3764, 0x4614},
+- {0, 0x3766, 0x1B59},
+- {0, 0x3784, 0x0404},
+- {0, 0x3782, 0x0304},
+- {0, 0x3210, 0x01B8},
+- {0, 0x098E, 0xC913},
+- {0, 0x0990, 0x000A},
+- {0, 0x098E, 0x686B},
+- {0, 0x0990, 0x05DC},
+- {0, 0x098E, 0x686D},
+- {0, 0x0990, 0x0BB8},
+- {0, 0x098E, 0x6C6B},
+- {0, 0x0990, 0x05DC},
+- {0, 0x098E, 0x6C6D},
+- {0, 0x0990, 0x0BB8},
+- {0, 0x098E, 0x3439},
+- {0, 0x0990, 0x05DC},
+- {0, 0x098E, 0x343B},
+- {0, 0x0990, 0x0BB8},
+- {0, 0x098E, 0x4926},
+- {0, 0x0990, 0x0001},
+- {0, 0x098E, 0x4928},
+- {0, 0x0990, 0x0002},
+- {0, 0x098E, 0x492A},
+- {0, 0x0990, 0x0656},
+- {0, 0x098E, 0x4D26},
+- {0, 0x0990, 0x0001},
+- {0, 0x098E, 0x4D28},
+- {0, 0x0990, 0x0002},
+- {0, 0x098E, 0x4D2A},
+- {0, 0x0990, 0x0656},
+- {0, 0x33F4, 0x040B},
+- {0, 0x098E, 0xC916},
+- {0, 0x0990, 0x0014},
+- {0, 0x098E, 0xC919},
+- {0, 0x0990, 0x0028},
+- {0, 0x098E, 0xC917},
+- {0, 0x0990, 0x0004},
+- {0, 0x098E, 0xC918},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xC91A},
+- {0, 0x0990, 0x0001},
+- {0, 0x098E, 0xC91B},
+- {0, 0x0990, 0x0009},
+- {0, 0x326C, 0x0C00},
+- {0, 0x098E, 0x494B},
+- {0, 0x0990, 0x0042},
+- {0, 0x098E, 0x494D},
+- {0, 0x0990, 0x012C},
+- {0, 0x098E, 0xC91E},
+- {0, 0x0990, 0x0012},
+- {0, 0x098E, 0xC91F},
+- {0, 0x0990, 0x000A},
+- {0, 0x098E, 0xC920},
+- {0, 0x0990, 0x0012},
+- {0, 0x098E, 0xC921},
+- {0, 0x0990, 0x000A},
+- {0, 0x098E, 0xC922},
+- {0, 0x0990, 0x0026},
+- {0, 0x098E, 0xC923},
+- {0, 0x0990, 0x001E},
+- {0, 0x098E, 0xC924},
+- {0, 0x0990, 0x0026},
+- {0, 0x098E, 0xC925},
+- {0, 0x0990, 0x0026},
+- {0, 0x098E, 0xBC02},
+- {0, 0x0990, 0x0003},
+- {0, 0x098E, 0xBC05},
+- {0, 0x0990, 0x000E},
+- {0, 0x098E, 0xC950},
+- {0, 0x0990, 0x0064},
+- {0, 0x098E, 0xC94F},
+- {0, 0x0990, 0x0038},
+- {0, 0x098E, 0xC952},
+- {0, 0x0990, 0x0064},
+- {0, 0x098E, 0xC951},
+- {0, 0x0990, 0x0051},
+- {0, 0x098E, 0xC954},
+- {0, 0x0990, 0x0010},
+- {0, 0x098E, 0xC953},
+- {0, 0x0990, 0x0020},
+- {0, 0x098E, 0xC956},
+- {0, 0x0990, 0x0010},
+- {0, 0x098E, 0xC955},
+- {0, 0x0990, 0x0020},
+- {0, 0x098E, 0xC958},
+- {0, 0x0990, 0x0020},
+- {0, 0x098E, 0xC957},
+- {0, 0x0990, 0x0014},
+- {0, 0x098E, 0xC95A},
+- {0, 0x0990, 0x001D},
+- {0, 0x098E, 0xC959},
+- {0, 0x0990, 0x0020},
+- {0, 0x098E, 0xC95C},
+- {0, 0x0990, 0x000C},
+- {0, 0x098E, 0xC95B},
+- {0, 0x0990, 0x0008},
+- {0, 0x098E, 0xC95E},
+- {0, 0x0990, 0x000C},
+- {0, 0x098E, 0xC95D},
+- {0, 0x0990, 0x0008},
+- {0, 0x098E, 0xC95F},
+- {0, 0x0990, 0x0064},
+- {0, 0x098E, 0x48DC},
+- {0, 0x0990, 0x004D},
+- {0, 0x098E, 0x48DE},
+- {0, 0x0990, 0x0096},
+- {0, 0x098E, 0x48E0},
+- {0, 0x0990, 0x001D},
+- {0, 0x098E, 0x48E2},
+- {0, 0x0990, 0x004D},
+- {0, 0x098E, 0x48E4},
+- {0, 0x0990, 0x0096},
+- {0, 0x098E, 0x48E6},
+- {0, 0x0990, 0x001D},
+- {0, 0x098E, 0x48E8},
+- {0, 0x0990, 0x004D},
+- {0, 0x098E, 0x48EA},
+- {0, 0x0990, 0x0096},
+- {0, 0x098E, 0x48EC},
+- {0, 0x0990, 0x001D},
+- {0, 0x098E, 0xDC2A},
+- {0, 0x0990, 0x000B},
+- {0, 0x098E, 0xDC2B},
+- {0, 0x0990, 0x0017},
+- {0, 0x098E, 0xBC0B},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xBC0C},
+- {0, 0x0990, 0x001B},
+- {0, 0x098E, 0xBC0D},
+- {0, 0x0990, 0x002A},
+- {0, 0x098E, 0xBC0E},
+- {0, 0x0990, 0x003E},
+- {0, 0x098E, 0xBC0F},
+- {0, 0x0990, 0x005A},
+- {0, 0x098E, 0xBC10},
+- {0, 0x0990, 0x0070},
+- {0, 0x098E, 0xBC11},
+- {0, 0x0990, 0x0081},
+- {0, 0x098E, 0xBC12},
+- {0, 0x0990, 0x0090},
+- {0, 0x098E, 0xBC13},
+- {0, 0x0990, 0x009E},
+- {0, 0x098E, 0xBC14},
+- {0, 0x0990, 0x00AB},
+- {0, 0x098E, 0xBC15},
+- {0, 0x0990, 0x00B6},
+- {0, 0x098E, 0xBC16},
+- {0, 0x0990, 0x00C1},
+- {0, 0x098E, 0xBC17},
+- {0, 0x0990, 0x00CB},
+- {0, 0x098E, 0xBC18},
+- {0, 0x0990, 0x00D5},
+- {0, 0x098E, 0xBC19},
+- {0, 0x0990, 0x00DE},
+- {0, 0x098E, 0xBC1A},
+- {0, 0x0990, 0x00E7},
+- {0, 0x098E, 0xBC1B},
+- {0, 0x0990, 0x00EF},
+- {0, 0x098E, 0xBC1C},
+- {0, 0x0990, 0x00F7},
+- {0, 0x098E, 0xBC1D},
+- {0, 0x0990, 0x00FF},
+- {0, 0x098E, 0xBC1E},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xBC1F},
+- {0, 0x0990, 0x001B},
+- {0, 0x098E, 0xBC20},
+- {0, 0x0990, 0x002A},
+- {0, 0x098E, 0xBC21},
+- {0, 0x0990, 0x003E},
+- {0, 0x098E, 0xBC22},
+- {0, 0x0990, 0x005A},
+- {0, 0x098E, 0xBC23},
+- {0, 0x0990, 0x0070},
+- {0, 0x098E, 0xBC24},
+- {0, 0x0990, 0x0081},
+- {0, 0x098E, 0xBC25},
+- {0, 0x0990, 0x0090},
+- {0, 0x098E, 0xBC26},
+- {0, 0x0990, 0x009E},
+- {0, 0x098E, 0xBC27},
+- {0, 0x0990, 0x00AB},
+- {0, 0x098E, 0xBC28},
+- {0, 0x0990, 0x00B6},
+- {0, 0x098E, 0xBC29},
+- {0, 0x0990, 0x00C1},
+- {0, 0x098E, 0xBC2A},
+- {0, 0x0990, 0x00CB},
+- {0, 0x098E, 0xBC2B},
+- {0, 0x0990, 0x00D5},
+- {0, 0x098E, 0xBC2C},
+- {0, 0x0990, 0x00DE},
+- {0, 0x098E, 0xBC2D},
+- {0, 0x0990, 0x00E7},
+- {0, 0x098E, 0xBC2E},
+- {0, 0x0990, 0x00EF},
+- {0, 0x098E, 0xBC2F},
+- {0, 0x0990, 0x00F7},
+- {0, 0x098E, 0xBC30},
+- {0, 0x0990, 0x00FF},
+- {0, 0x098E, 0xBC31},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xBC32},
+- {0, 0x0990, 0x000D},
+- {0, 0x098E, 0xBC33},
+- {0, 0x0990, 0x0019},
+- {0, 0x098E, 0xBC34},
+- {0, 0x0990, 0x0030},
+- {0, 0x098E, 0xBC35},
+- {0, 0x0990, 0x0056},
+- {0, 0x098E, 0xBC36},
+- {0, 0x0990, 0x0070},
+- {0, 0x098E, 0xBC37},
+- {0, 0x0990, 0x0081},
+- {0, 0x098E, 0xBC38},
+- {0, 0x0990, 0x0090},
+- {0, 0x098E, 0xBC39},
+- {0, 0x0990, 0x009E},
+- {0, 0x098E, 0xBC3A},
+- {0, 0x0990, 0x00AB},
+- {0, 0x098E, 0xBC3B},
+- {0, 0x0990, 0x00B6},
+- {0, 0x098E, 0xBC3C},
+- {0, 0x0990, 0x00C1},
+- {0, 0x098E, 0xBC3D},
+- {0, 0x0990, 0x00CB},
+- {0, 0x098E, 0xBC3E},
+- {0, 0x0990, 0x00D5},
+- {0, 0x098E, 0xBC3F},
+- {0, 0x0990, 0x00DE},
+- {0, 0x098E, 0xBC40},
+- {0, 0x0990, 0x00E7},
+- {0, 0x098E, 0xBC41},
+- {0, 0x0990, 0x00EF},
+- {0, 0x098E, 0xBC42},
+- {0, 0x0990, 0x00F7},
+- {0, 0x098E, 0xBC43},
+- {0, 0x0990, 0x00FF},
+- {0, 0x098E, 0x6865},
+- {0, 0x0990, 0x00E0},
+- {0, 0x098E, 0x6867},
+- {0, 0x0990, 0x00F4},
+- {0, 0x098E, 0x8400},
+- {0, 0x0990, 0x0006},
+- {0, 0x098E, 0xBC4A},
+- {0, 0x0990, 0x007F},
+- {0, 0x098E, 0xBC4B},
+- {0, 0x0990, 0x007F},
+- {0, 0x098E, 0xBC4C},
+- {0, 0x0990, 0x007F},
+- {0, 0x3542, 0x0010},
+- {0, 0x3544, 0x0030},
+- {0, 0x3546, 0x0040},
+- {0, 0x3548, 0x0080},
+- {0, 0x354A, 0x0100},
+- {0, 0x354C, 0x0200},
+- {0, 0x354E, 0x0300},
+- {0, 0x3550, 0x0010},
+- {0, 0x3552, 0x0030},
+- {0, 0x3554, 0x0040},
+- {0, 0x3556, 0x0080},
+- {0, 0x3558, 0x012C},
+- {0, 0x355A, 0x0320},
+- {0, 0x355C, 0x03E8},
+- {0, 0x3560, 0x0040},
+- {0, 0x3562, 0x0020},
+- {0, 0x3564, 0x0040},
+- {0, 0x3566, 0x0010},
+- {0, 0x3568, 0x0008},
+- {0, 0x356A, 0x0004},
+- {0, 0x356C, 0x0004},
+- {0, 0x356E, 0x0004},
+- {0, 0x098E, 0x3C4D},
+- {0, 0x0990, 0x0DAC},
+- {0, 0x098E, 0x3C4F},
+- {0, 0x0990, 0x148A},
+- {0, 0x098E, 0xC911},
+- {0, 0x0990, 0x00C8},
+- {0, 0x098E, 0xC8F4},
+- {0, 0x0990, 0x0004},
+- {0, 0x098E, 0xC8F5},
+- {0, 0x0990, 0x0002},
+- {0, 0x098E, 0x48F6},
+- {0, 0x0990, 0x3B4D},
+- {0, 0x098E, 0x48F8},
+- {0, 0x0990, 0x6380},
+- {0, 0x098E, 0x48FA},
+- {0, 0x0990, 0x9B18},
+- {0, 0x098E, 0x48FC},
+- {0, 0x0990, 0x5D51},
+- {0, 0x098E, 0x48FE},
+- {0, 0x0990, 0xEDE8},
+- {0, 0x098E, 0x4900},
+- {0, 0x0990, 0xE515},
+- {0, 0x098E, 0x4902},
+- {0, 0x0990, 0xBFF4},
+- {0, 0x098E, 0x4904},
+- {0, 0x0990, 0x001E},
+- {0, 0x098E, 0x4906},
+- {0, 0x0990, 0x0026},
+- {0, 0x098E, 0x4908},
+- {0, 0x0990, 0x0033},
+- {0, 0x098E, 0xE84A},
+- {0, 0x0990, 0x0083},
+- {0, 0x098E, 0xE84D},
+- {0, 0x0990, 0x0083},
+- {0, 0x098E, 0xE84C},
+- {0, 0x0990, 0x0080},
+- {0, 0x098E, 0xE84F},
+- {0, 0x0990, 0x0080},
+- {0, 0x098E, 0x8400},
+- {0, 0x0990, 0x0006},
+- {0, 0x098E, 0x48B0},
+- {0, 0x0990, 0x0180},
+- {0, 0x098E, 0x48B2},
+- {0, 0x0990, 0xFF7A},
+- {0, 0x098E, 0x48B4},
+- {0, 0x0990, 0x0018},
+- {0, 0x098E, 0x48B6},
+- {0, 0x0990, 0xFFCA},
+- {0, 0x098E, 0x48B8},
+- {0, 0x0990, 0x017C},
+- {0, 0x098E, 0x48BA},
+- {0, 0x0990, 0xFFCC},
+- {0, 0x098E, 0x48BC},
+- {0, 0x0990, 0x000C},
+- {0, 0x098E, 0x48BE},
+- {0, 0x0990, 0xFF1F},
+- {0, 0x098E, 0x48C0},
+- {0, 0x0990, 0x01E8},
+- {0, 0x098E, 0x48C2},
+- {0, 0x0990, 0x0020},
+- {0, 0x098E, 0x48C4},
+- {0, 0x0990, 0x0044},
+- {0, 0x098E, 0x48C6},
+- {0, 0x0990, 0x0079},
+- {0, 0x098E, 0x48C8},
+- {0, 0x0990, 0xFFAD},
+- {0, 0x098E, 0x48CA},
+- {0, 0x0990, 0xFFE2},
+- {0, 0x098E, 0x48CC},
+- {0, 0x0990, 0x0033},
+- {0, 0x098E, 0x48CE},
+- {0, 0x0990, 0x002A},
+- {0, 0x098E, 0x48D0},
+- {0, 0x0990, 0xFFAA},
+- {0, 0x098E, 0x48D2},
+- {0, 0x0990, 0x0017},
+- {0, 0x098E, 0x48D4},
+- {0, 0x0990, 0x004B},
+- {0, 0x098E, 0x48D6},
+- {0, 0x0990, 0xFFA5},
+- {0, 0x098E, 0x48D8},
+- {0, 0x0990, 0x0015},
+- {0, 0x098E, 0x48DA},
+- {0, 0x0990, 0xFFE2},
+- {0, 0x35A2, 0x0014},
+- {0, 0x098E, 0xC949},
+- {0, 0x0990, 0x0024},
+- {0, 0x35A4, 0x0596},
+- {0, 0x098E, 0xC94A},
+- {0, 0x0990, 0x0062},
+- {0, 0x098E, 0xC948},
+- {0, 0x0990, 0x0006},
+- {0, 0x098E, 0xC914},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xC915},
+- {0, 0x0990, 0x00FF},
+- {0, 0x098E, 0xE86F},
+- {0, 0x0990, 0x0060},
+- {0, 0x098E, 0xE870},
+- {0, 0x0990, 0x003C},
+- {0, 0x098E, 0xEC6F},
+- {0, 0x0990, 0x0060},
+- {0, 0x098E, 0xEC70},
+- {0, 0x0990, 0x003C},
+- {0, 0x098E, 0xE883},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xEC83},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0x8400},
+- {0, 0x0990, 0x0006},
+- {0, 0x098E, 0xE885},
+- {0, 0x0990, 0x001E},
+- {0, 0x098E, 0xE886},
+- {0, 0x0990, 0x00D8},
+- {0, 0x098E, 0xEC85},
+- {0, 0x0990, 0x001E},
+- {0, 0x098E, 0xEC86},
+- {0, 0x0990, 0x00D8},
+- {0, 0x098E, 0xE884},
+- {0, 0x0990, 0x005C},
+- {0, 0x098E, 0xEC84},
+- {0, 0x0990, 0x005C},
+- {0, 0x098E, 0x490A},
+- {0, 0x0990, 0x0666},
+- {0, 0x098E, 0x490C},
+- {0, 0x0990, 0x0140},
+- {0, 0x098E, 0x6857},
+- {0, 0x0990, 0x0014},
+- {0, 0x098E, 0x685C},
+- {0, 0x0990, 0x0005},
+- {0, 0x098E, 0x490E},
+- {0, 0x0990, 0x00A4},
+- {0, 0x098E, 0xB43D},
+- {0, 0x0990, 0x0031},
+- {0, 0x098E, 0xB43E},
+- {0, 0x0990, 0x001B},
+- {0, 0x098E, 0xB43F},
+- {0, 0x0990, 0x0028},
+- {0, 0x098E, 0xB440},
+- {0, 0x0990, 0x0003},
+- {0, 0x098E, 0xB441},
+- {0, 0x0990, 0x00CD},
+- {0, 0x098E, 0xB442},
+- {0, 0x0990, 0x0064},
+- {0, 0x098E, 0xB443},
+- {0, 0x0990, 0x000F},
+- {0, 0x098E, 0xB444},
+- {0, 0x0990, 0x0007},
+- {0, 0x098E, 0x300D},
+- {0, 0x0990, 0x000F},
+- {0, 0x098E, 0x3017},
+- {0, 0x0990, 0x0F0F},
+- {0, 0x098E, 0x8400},
+- {0, 0x0990, 0x0006},
+- {0, 0x098E, 0xE81F},
+- {0, 0x0990, 0x0020},
+- {0, 0x098E, 0x68A0},
+- {0, 0x0990, 0x082E},
+- {0, 0x098E, 0x6CA0},
+- {0, 0x0990, 0x082E},
+- {0, 0x098E, 0x70A0},
+- {0, 0x0990, 0x082E},
+- {0, 0x098E, 0x74A0},
+- {0, 0x0990, 0x082E},
+- {0, 0x3C52, 0x082E},
+- {0, 0x098E, 0x488E},
+- {0, 0x0990, 0x0020},
+- {0, 0x098E, 0xECAC},
+- {0, 0x0990, 0x0000}
+-};
+-
+-mt9t111_regs def_regs2[] = {
+- {100, 0x0018, 0x0028},
+- {0, 0x316C, 0x350F},
+- {0, 0x098E, 0x6817},
+- {0, 0x0990, 0x000C},
+- {0, 0x0034, 0x0000}
+-};
+-
+-mt9t111_regs pll_regs1[] = {
+- {0, 0x0014, 0x2425},
+- {0, 0x0014, 0x2425},
+- {0, 0x0014, 0x2145},
+- {0, 0x0010, 0x0219},
+- {0, 0x0012, 0x0090},
+- {0, 0x002A, 0x79DD},
+- {0, 0x0014, 0x2545},
+- {0, 0x0014, 0x2547},
+- {0, 0x0014, 0x3447},
+- {0, 0x0014, 0x3047}
+-};
+-
+-mt9t111_regs pll_regs2[] = {
+- {0, 0x0014, 0x3046},
+- {0, 0x0022, 0x01E0},
+- {0, 0x001E, 0x0707},
+- {0, 0x3B84, 0x011D}
+-};
+-
+-mt9t111_regs bayer_pattern_regs[] = {
+- {0, 0x098E, 0x6807},
+- {0, 0x0990, 0x0100},
+- {0, 0x098E, 0x6809},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xE88E},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0x6C07},
+- {0, 0x0990, 0x0100},
+- {0, 0x098E, 0x6C09},
+- {0, 0x0990, 0x0000},
+- {0, 0x098E, 0xEC8E},
+- {0, 0x0990, 0x0000}
+-};
+-
+-#endif
+diff --git a/include/media/mt9t111.h b/include/media/mt9t111.h
+deleted file mode 100644
+index cd34885..0000000
+--- a/include/media/mt9t111.h
++++ /dev/null
+@@ -1,79 +0,0 @@
+-/*
+- * include/media/mt9t111.h
+- *
+- * mt9t111 sensor driver
+- *
+- * Copyright (C) 2009 Leopard Imaging
+- *
+- * This file is licensed under the terms of the GNU General Public License
+- * version 2. This program is licensed "as is" without any warranty of any
+- * kind, whether express or implied.
+- */
+-
+-#ifndef MT9T111_H
+-#define MT9T111_H
+-
+-/*********************************
+- * Defines and Macros and globals
+- ********************************/
+-
+-#ifdef TRUE
+-#undef TRUE
+-#endif
+-
+-#ifdef FALSE
+-#undef FALSE
+-#endif
+-
+-#define TRUE 1
+-#define FALSE 0
+-
+-#ifdef DEBUG
+-#undef DEBUG
+-#endif
+-
+-#ifndef TYPES
+-#define TYPES
+-#endif
+-
+-#define MT9T111_I2C_REGISTERED (1)
+-#define MT9T111_I2C_UNREGISTERED (0)
+-
+-/*i2c adress for MT9T111*/
+-#define MT9T111_I2C_ADDR (0x78 >> 1)
+-
+-#define MT9T111_CLK_MAX (54000000) /* 54MHz */
+-#define MT9T111_CLK_MIN (6000000) /* 6Mhz */
+-
+-#define MT9T111_I2C_CONFIG (1)
+-#define I2C_ONE_BYTE_TRANSFER (1)
+-#define I2C_TWO_BYTE_TRANSFER (2)
+-#define I2C_THREE_BYTE_TRANSFER (3)
+-#define I2C_FOUR_BYTE_TRANSFER (4)
+-#define I2C_TXRX_DATA_MASK (0x00FF)
+-#define I2C_TXRX_DATA_MASK_UPPER (0xFF00)
+-#define I2C_TXRX_DATA_SHIFT (8)
+-
+-struct mt9t111_platform_data {
+- char *master;
+- int (*power_set) (struct v4l2_int_device *s, enum v4l2_power on);
+- int (*ifparm) (struct v4l2_ifparm *p);
+- int (*priv_data_set) (void *);
+- /* Interface control params */
+- bool clk_polarity;
+- bool hs_polarity;
+- bool vs_polarity;
+-};
+-
+-/**
+- * struct capture_size - image capture size information
+- * @width: image width in pixels
+- * @height: image height in pixels
+- */
+-struct capture_size {
+- unsigned long width;
+- unsigned long height;
+-};
+-
+-#endif /*for ifndef MT9T111 */
+-
+--
+1.6.6.1
+
generated by cgit 1.2.3-korg (git 2.39.0) at 2024-04-16 09:35:01 +0000