From mboxrd@z Thu Jan 1 00:00:00 1970 From: Deepthy Ravi Subject: [PATCH 2/5] [media] v4l: Add mt9t111 sensor driver Date: Tue, 20 Sep 2011 20:26:49 +0530 Message-ID: <1316530612-23075-3-git-send-email-deepthy.ravi@ti.com> References: <1316530612-23075-1-git-send-email-deepthy.ravi@ti.com> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="===============1687754430==" Return-path: In-Reply-To: <1316530612-23075-1-git-send-email-deepthy.ravi@ti.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: linux-arm-kernel-bounces@lists.infradead.org Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: laurent.pinchart@ideasonboard.com, mchehab@infradead.org, tony@atomide.com, hvaibhav@ti.com, linux-media@vger.kernel.org, linux@arm.linux.org.uk, linux-arm-kernel@lists.in Cc: Deepthy Ravi , linux-omap@vger.kernel.org List-Id: linux-omap@vger.kernel.org --===============1687754430== Content-Type: text/plain From: Vaibhav Hiremath The MT9T111 is a 3.1Mp CMOS sensor from Aptina with its latest image signal processing (ISP) and 1.75μm pixel technology. The sensor driver currently supports only VGA resolution. Signed-off-by: Vaibhav Hiremath Signed-off-by: Deepthy Ravi --- drivers/media/video/Kconfig | 7 + drivers/media/video/Makefile | 1 + drivers/media/video/mt9t111.c | 793 +++++++++++++++++++++ drivers/media/video/mt9t111_reg.h | 1367 +++++++++++++++++++++++++++++++++++++ include/media/mt9t111.h | 45 ++ 5 files changed, 2213 insertions(+), 0 deletions(-) create mode 100644 drivers/media/video/mt9t111.c create mode 100644 drivers/media/video/mt9t111_reg.h create mode 100644 include/media/mt9t111.h diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig index f574dc0..ca374cb 100644 --- a/drivers/media/video/Kconfig +++ b/drivers/media/video/Kconfig @@ -482,6 +482,13 @@ config VIDEO_MT9V032 This is a Video4Linux2 sensor-level driver for the Micron MT9V032 752x480 CMOS sensor. +config VIDEO_MT9T111 + tristate "Aptina MT9T111 VGA CMOS IMAGE SENSOR" + depends on VIDEO_V4L2 && I2C && VIDEO_V4L2_SUBDEV_API + ---help--- + This is a Video4Linux2 sensor-level driver for the Aptina MT9T111 + image sensor. + config VIDEO_TCM825X tristate "TCM825x camera sensor support" depends on I2C && VIDEO_V4L2 diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile index 2723900..52cfef5 100644 --- a/drivers/media/video/Makefile +++ b/drivers/media/video/Makefile @@ -68,6 +68,7 @@ obj-$(CONFIG_VIDEO_TVEEPROM) += tveeprom.o obj-$(CONFIG_VIDEO_MT9V011) += mt9v011.o obj-$(CONFIG_VIDEO_MT9V032) += mt9v032.o obj-$(CONFIG_VIDEO_SR030PC30) += sr030pc30.o +obj-$(CONFIG_VIDEO_MT9T111) += mt9t111.o obj-$(CONFIG_VIDEO_NOON010PC30) += noon010pc30.o obj-$(CONFIG_VIDEO_M5MOLS) += m5mols/ obj-$(CONFIG_VIDEO_ADP1653) += adp1653.o diff --git a/drivers/media/video/mt9t111.c b/drivers/media/video/mt9t111.c new file mode 100644 index 0000000..5f6131a --- /dev/null +++ b/drivers/media/video/mt9t111.c @@ -0,0 +1,793 @@ +/* + * drivers/media/video/mt9t111.c + * + * mt9t111 sensor driver + * + * Copyright (C) 2010 Texas Instruments Inc + * Author: Vaibhav Hiremath + + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation version 2. + + * This program is distributed "as is" WITHOUT ANY WARRANTY of any + * kind, whether express or implied; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "mt9t111_reg.h" + +/* + * struct mt9t111 - main structure for storage of sensor information + * @subdev: V4L2 sub-device structure structure + * @pad: Media entity pad structure + * @format: Media-bus format + * @rect: + * @pix: V4L2 pixel format information structure + * @ctrls: v4l2 control handler + * @frameival: sub-dev pad frame interval + * @pdata: access functions and data for platform level information + * @ver: mt9t111 chip version + * @power: Turn on OR off the interface + * @omap3evm_1v8: pointer to the regulator used for camera interface + * @omap3evm_2v8: pointer to the regulator used for camera interface + */ +struct mt9t111 { + struct v4l2_subdev subdev; + struct media_pad pad; + struct v4l2_mbus_framefmt format; + struct v4l2_rect rect; + struct v4l2_pix_format pix; + + struct v4l2_ctrl_handler ctrls; + + struct mt9t111_platform_data *pdata; + int ver; + unsigned int power; + struct regulator *omap3evm_1v8; + struct regulator *omap3evm_2v8; +}; + +#define to_mt9t111(sd) container_of(sd, struct mt9t111, subdev) + +/* + * struct mt9t111_fmt - + * @mbus_code: associated media bus code + * @fmt: format descriptor + */ +struct mt9t111_fmt { + unsigned int mbus_code; + struct v4l2_fmtdesc fmt; +}; + +/* + * List of image formats supported by mt9t111 + * Currently we are using 8 bit and 8x2 bit mode only, but can be + * extended to 10 bit mode. + */ +static const struct mt9t111_fmt mt9t111_fmt_list[] = { + { + .mbus_code = V4L2_MBUS_FMT_UYVY8_2X8, + .fmt = { + .index = 0, + .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, + .flags = 0, + .description = "8-bit UYVY 4:2:2 Format", + .pixelformat = V4L2_PIX_FMT_UYVY, + }, + }, + { + .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8, + .fmt = { + .index = 1, + .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, + .flags = 0, + .description = "8-bit YUYV 4:2:2 Format", + .pixelformat = V4L2_PIX_FMT_YUYV, + }, + }, + { + .mbus_code = V4L2_MBUS_FMT_RGB565_2X8_LE, + .fmt = { + .index = 2, + .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, + .flags = 0, + .description = "16-bit RGB565 format", + .pixelformat = V4L2_PIX_FMT_RGB565, + }, + }, +}; + +/* + * 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); + if (err < 0) + return err; + + return 0; +} + +/* + * 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, 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; +} + + +static int mt9t111_refresh(struct i2c_client *client) +{ + int i, err = 0; + unsigned short value; + + /* MCU_ADDRESS [SEQ_CMD] -- refresh mode */ + err = mt9t111_write_reg(client, 0x098E, 0x8400); + if (err) + return err; + err = mt9t111_write_reg(client, 0x0990, 0x0006); + if (err) + return err; + + /* refresh command */ + err = mt9t111_write_reg(client, 0x098E, 0x8400); + if (err) + return err; + err = mt9t111_write_reg(client, 0x0990, 0x0005); + if (err) + return err; + + for (i = 0; i < 100; i++) { + err = mt9t111_write_reg(client, 0x098E, 0x8400); + if (err) + break; + err = mt9t111_read_reg(client, 0x0990, &value); + if ((value == 0) || (err)) + break; + mdelay(5); + } + + return err; +} + +static int mt9t111_enable_pll(struct i2c_client *client) +{ + int i, err = 0; + unsigned short value; + + err = mt9t111_write_regs(client, pll_regs1, + sizeof(pll_regs1) / sizeof(mt9t111_regs)); + if (err) + return err; + + for (i = 0; i < 100; i++) { + err = mt9t111_read_reg(client, 0x0014, &value); + if (((value & 0x8000) != 0) || (err)) + break; + mdelay(2); + } + err = mt9t111_write_regs(client, pll_regs2, + sizeof(pll_regs2) / sizeof(mt9t111_regs)); + return err; +} + +/* + * 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_subdev *subdev) +{ + struct i2c_client *client = v4l2_get_subdevdata(subdev); + int err = 0; + + err = mt9t111_write_reg(client, 0x001A, 0x001D); + if (err < 0) + return err; + + msleep(1); + + err = mt9t111_write_reg(client, 0x001A, 0x0018); + if (err < 0) + goto out; + + err = mt9t111_enable_pll(client); + if (err) + goto out; + + err = mt9t111_write_regs(client, def_regs1, + sizeof(def_regs1) / sizeof(mt9t111_regs)); + if (err) + goto out; + + err = mt9t111_write_regs(client, patch_rev6, + sizeof(patch_rev6) / sizeof(mt9t111_regs)); + if (err) + goto out; + + err = mt9t111_write_regs(client, def_regs2, + sizeof(def_regs2) / sizeof(mt9t111_regs)); + if (err) + goto out; + + err = mt9t111_refresh(client); +out: + return err; +} + +/* + * mt9t111_detect - Detect if an mt9t111 is present, and if so which revision + * @subdev: pointer to the V4L2 sub-device 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 v4l2_subdev *subdev) +{ + u16 val; + struct i2c_client *client = v4l2_get_subdevdata(subdev); + + /* 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_err(&client->dev, "model id mismatch received 0x%x" + " expecting 0x%x\n", + val, MT9T111_CHIP_ID_VALUE); + return -ENODEV; + } + + return (int)val; + +} + +/* + * mt9t111_dev_init - sensor init, tries to detect the sensor + * @subdev: pointer to standard V4L2 subdev structure + */ + +static int mt9t111_dev_init(struct v4l2_subdev *subdev) +{ + struct mt9t111 *mt9t111 = to_mt9t111(subdev); + struct i2c_client *client = v4l2_get_subdevdata(subdev); + int rval; + + rval = mt9t111->pdata->s_power(subdev, 1); + if (rval) + return rval; + + rval = mt9t111_detect(subdev); + if (rval < 0) { + v4l_err(client, "Unable to detect" + MT9T111_MODULE_NAME "sensor\n"); + goto out; + } + mt9t111->ver = rval; + v4l_info(client, MT9T111_MODULE_NAME + " chip version 0x%02x detected\n", mt9t111->ver); + rval = 0; +out: + mt9t111->pdata->s_power(subdev, 0); + return rval; +} + +static int omap3evm_regulator_ctrl(struct mt9t111 *mt9t111, u32 on) +{ + if (!(mt9t111->omap3evm_1v8) || !(mt9t111->omap3evm_2v8)) { + printk(KERN_ERR "No regulator available\n"); + return -ENODEV; + } + if (on) { + regulator_enable(mt9t111->omap3evm_1v8); + mdelay(1); + regulator_enable(mt9t111->omap3evm_2v8); + mdelay(50); + } else { + if (regulator_is_enabled(mt9t111->omap3evm_1v8)) + regulator_disable(mt9t111->omap3evm_1v8); + if (regulator_is_enabled(mt9t111->omap3evm_2v8)) + regulator_disable(mt9t111->omap3evm_2v8); + } + return 0; +} + +/* ----------------------------------------------------------------------------- + * V4L2 subdev core operations + */ +/* + * mt9t111_s_power - V4L2 sensor interface handler for s_power + * @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 mt9t111_s_power(struct v4l2_subdev *subdev, int on) +{ + struct mt9t111 *mt9t111 = to_mt9t111(subdev); + struct i2c_client *client = v4l2_get_subdevdata(subdev); + int rval; + + if (on) { + rval = omap3evm_regulator_ctrl(mt9t111, on); + if (rval) + goto out; + + rval = mt9t111->pdata->s_power(subdev, 1); + if (rval) + goto out; + + rval = mt9t111_configure(subdev); + if (rval) { + mt9t111->pdata->s_power(subdev, 0); + goto out; + } + } else { + rval = mt9t111->pdata->s_power(subdev, 0); + if (rval) + goto out; + } + + mt9t111->power = on; + +out: + if (rval) + v4l_err(client, "Unable to set target power state\n"); + + return rval; +} + +/* -------------------------------------------------------------------------- + * V4L2 subdev internal operations + */ +/* + * mt9t111_registered - called when subdevice is registered + * @subdev: pointer to standard V4L2 subdev structure + */ +static int mt9t111_registered(struct v4l2_subdev *subdev) +{ + + return mt9t111_dev_init(subdev); +} + +static int mt9t111_open(struct v4l2_subdev *subdev, struct v4l2_subdev_fh *fh) +{ + struct v4l2_mbus_framefmt *format; + struct v4l2_rect *crop; + + /* + * Default configuration - + * Resolution: VGA + * Format: UYVY + * crop = window + */ + crop = v4l2_subdev_get_try_crop(fh, 0); + crop->left = 0; + crop->top = 0; + crop->width = MT9T111_IMAGE_WIDTH; + crop->height = MT9T111_IMAGE_HEIGHT; + + format = v4l2_subdev_get_try_format(fh, 0); + format->code = V4L2_MBUS_FMT_UYVY8_2X8; + format->width = MT9T111_IMAGE_WIDTH; + format->height = MT9T111_IMAGE_HEIGHT; + format->field = V4L2_FIELD_NONE; + format->colorspace = V4L2_COLORSPACE_JPEG; + + return 0; +} + +/* -------------------------------------------------------------------------- + * V4L2 subdev video operations + */ + +static int mt9t111_s_stream(struct v4l2_subdev *subdev, int streaming) +{ + /* + * FIXME: We should put here the specific reg setting to turn on + * streaming in sensor. + */ + return 0; +} + + +/* -------------------------------------------------------------------------- + * V4L2 subdev pad operations + */ +/* + * mt9t111_enum_mbus_code - V4L2 sensor interface handler for pad_ops + * @subdev: pointer to standard V4L2 sub-device structure + * @qctrl: 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 mt9t111_enum_mbus_code(struct v4l2_subdev *subdev, + struct v4l2_subdev_fh *fh, + struct v4l2_subdev_mbus_code_enum *code) +{ + struct mt9t111 *mt9t111 = to_mt9t111(subdev); + + if (code->index >= ARRAY_SIZE(mt9t111_fmt_list)) + return -EINVAL; + + code->code = mt9t111->format.code; + + return 0; +} + +static int mt9t111_enum_frame_size(struct v4l2_subdev *subdev, + struct v4l2_subdev_fh *fh, + struct v4l2_subdev_frame_size_enum *fse) +{ + int i; + + /* Is requested media-bus format/pixelformat not found on sensor? */ + for (i = 0; i < ARRAY_SIZE(mt9t111_fmt_list); i++) { + if (fse->code == mt9t111_fmt_list[i].mbus_code) + goto fmt_found; + } + if (i >= ARRAY_SIZE(mt9t111_fmt_list)) + return -EINVAL; + +fmt_found: + /* + * Currently only supports VGA resolution + */ + fse->min_width = fse->max_width = MT9T111_IMAGE_WIDTH; + fse->min_height = fse->max_height = MT9T111_IMAGE_HEIGHT; + + return 0; +} + + +static int mt9t111_get_pad_format(struct v4l2_subdev *subdev, + struct v4l2_subdev_fh *fh, + struct v4l2_subdev_format *fmt) +{ + struct mt9t111 *mt9t111 = to_mt9t111(subdev); + + fmt->format = mt9t111->format; + return 0; +} + +static int mt9t111_set_pad_format(struct v4l2_subdev *subdev, + struct v4l2_subdev_fh *fh, + struct v4l2_subdev_format *fmt) +{ + int i; + struct mt9t111 *mt9t111 = to_mt9t111(subdev); + + for (i = 0; i < ARRAY_SIZE(mt9t111_fmt_list); i++) { + if (fmt->format.code == mt9t111_fmt_list[i].mbus_code) + goto fmt_found; + } + if (i >= ARRAY_SIZE(mt9t111_fmt_list)) + return -EINVAL; + +fmt_found: + /* + * Only VGA resolution supported + */ + fmt->format.width = MT9T111_IMAGE_WIDTH; + fmt->format.height = MT9T111_IMAGE_HEIGHT; + fmt->format.field = V4L2_FIELD_NONE; + fmt->format.colorspace = V4L2_COLORSPACE_JPEG; + + mt9t111->format = fmt->format; + + return 0; +} + +static int mt9t111_get_crop(struct v4l2_subdev *subdev, + struct v4l2_subdev_fh *fh, struct v4l2_subdev_crop *crop) +{ + struct mt9t111 *mt9t111 = to_mt9t111(subdev); + + crop->rect = mt9t111->rect; + return 0; +} + +static int mt9t111_set_crop(struct v4l2_subdev *subdev, + struct v4l2_subdev_fh *fh, struct v4l2_subdev_crop *crop) +{ + struct mt9t111 *mt9t111 = to_mt9t111(subdev); + struct v4l2_rect rect; + + /* + * Only VGA resolution/window is supported + */ + rect.left = 0; + rect.top = 0; + rect.width = MT9T111_IMAGE_WIDTH; + rect.height = MT9T111_IMAGE_HEIGHT; + + mt9t111->rect = rect; + crop->rect = rect; + + return 0; +} + +static const struct v4l2_subdev_core_ops mt9t111_core_ops = { + .s_power = mt9t111_s_power, +}; + +static struct v4l2_subdev_internal_ops mt9t111_subdev_internal_ops = { + .registered = mt9t111_registered, + .open = mt9t111_open, +}; + +static const struct v4l2_subdev_video_ops mt9t111_video_ops = { + .s_stream = mt9t111_s_stream, +}; + +static const struct v4l2_subdev_pad_ops mt9t111_pad_ops = { + .enum_mbus_code = mt9t111_enum_mbus_code, + .enum_frame_size = mt9t111_enum_frame_size, + .get_fmt = mt9t111_get_pad_format, + .set_fmt = mt9t111_set_pad_format, + .get_crop = mt9t111_get_crop, + .set_crop = mt9t111_set_crop, +}; + +static const struct v4l2_subdev_ops mt9t111_ops = { + .core = &mt9t111_core_ops, + .video = &mt9t111_video_ops, + .pad = &mt9t111_pad_ops, +}; + +/* + * 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 *mt9t111; + int ret; + + /* Check if the adapter supports the needed features */ + if (!i2c_check_functionality(client->adapter, + I2C_FUNC_SMBUS_BYTE_DATA)) { + v4l_err(client, "mt9t111: I2C Adapter doesn't support" \ + " I2C_FUNC_SMBUS_WORD\n"); + return -EIO; + } + + if (!client->dev.platform_data) { + v4l_err(client, "No platform data!!\n"); + return -ENODEV; + } + + mt9t111 = kzalloc(sizeof(*mt9t111), GFP_KERNEL); + if (mt9t111 == NULL) { + v4l_err(client, "Could not able to alocate memory!!\n"); + return -ENOMEM; + } + + mt9t111->pdata = client->dev.platform_data; + + /* + * Regulator supply required for camera interface + */ + mt9t111->omap3evm_1v8 = regulator_get(NULL, "vio_1v8"); + if (IS_ERR(mt9t111->omap3evm_1v8)) { + printk(KERN_ERR "vio_1v8 regulator missing\n"); + ret = PTR_ERR(mt9t111->omap3evm_1v8); + goto err_1; + } + mt9t111->omap3evm_2v8 = regulator_get(NULL, "cam_2v8"); + if (IS_ERR(mt9t111->omap3evm_2v8)) { + printk(KERN_ERR "cam_2v8 regulator missing\n"); + ret = PTR_ERR(mt9t111->omap3evm_2v8); + goto err_2; + } + + /* + * Default configuration - + * Resolution: VGA + * Format: UYVY + * crop = window + */ + + mt9t111->rect.left = 0; + mt9t111->rect.top = 0; + mt9t111->rect.width = MT9T111_IMAGE_WIDTH; + mt9t111->rect.height = MT9T111_IMAGE_HEIGHT; + + mt9t111->format.code = V4L2_MBUS_FMT_UYVY8_2X8; + mt9t111->format.width = MT9T111_IMAGE_WIDTH; + mt9t111->format.height = MT9T111_IMAGE_HEIGHT; + mt9t111->format.field = V4L2_FIELD_NONE; + mt9t111->format.colorspace = V4L2_COLORSPACE_JPEG; + + v4l2_i2c_subdev_init(&mt9t111->subdev, client, &mt9t111_ops); + mt9t111->subdev.internal_ops = &mt9t111_subdev_internal_ops; + mt9t111->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; + + mt9t111->pad.flags = MEDIA_PAD_FL_SOURCE; + ret = media_entity_init(&mt9t111->subdev.entity, 1, &mt9t111->pad, 0); + if (!ret) + return 0; + + kfree(mt9t111); +err_2: + regulator_put(mt9t111->omap3evm_2v8); +err_1: + regulator_put(mt9t111->omap3evm_1v8); + + return ret; +} + +/* + * 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 v4l2_subdev *subdev = i2c_get_clientdata(client); + struct mt9t111 *mt9t111 = to_mt9t111(subdev); + + v4l2_device_unregister_subdev(&mt9t111->subdev); + media_entity_cleanup(&mt9t111->subdev.entity); + kfree(mt9t111); + + return 0; +} + +static const struct i2c_device_id mt9t111_id[] = { + { MT9T111_MODULE_NAME, 0 }, + { }, +}; +MODULE_DEVICE_TABLE(i2c, mt9t111_id); + +static struct i2c_driver mt9t111_i2c_driver = { + .driver = { + .name = MT9T111_MODULE_NAME, + .owner = THIS_MODULE, + }, + .probe = mt9t111_probe, + .remove = __exit_p(mt9t111_remove), + .id_table = mt9t111_id, +}; + +/* + * mt9t111_init - sensor driver module_init handler + * + * Registers driver as an i2c client driver. Returns 0 on success, + * error code otherwise. + */ +static int __init mt9t111_init(void) +{ + return i2c_add_driver(&mt9t111_i2c_driver); +} + +/* + * mt9t111_cleanup - sensor driver module_exit handler + * + * Unregisters/deletes driver as an i2c client driver. + * Complement of mt9t111_init. + */ +static void __exit mt9t111_cleanup(void) +{ + i2c_del_driver(&mt9t111_i2c_driver); +} + +module_init(mt9t111_init); +module_exit(mt9t111_cleanup); + +MODULE_AUTHOR("Texas Instruments"); +MODULE_DESCRIPTION("mt9t111 camera sensor driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/media/video/mt9t111_reg.h b/drivers/media/video/mt9t111_reg.h new file mode 100644 index 0000000..2f610d4 --- /dev/null +++ b/drivers/media/video/mt9t111_reg.h @@ -0,0 +1,1367 @@ +/* + * 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) + +#define MT9T111_IMAGE_WIDTH (640) +#define MT9T111_IMAGE_HEIGHT (480) + +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 new file mode 100644 index 0000000..1d6a583 --- /dev/null +++ b/include/media/mt9t111.h @@ -0,0 +1,45 @@ +/* + * 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 + +struct v4l2_subdev; + +/* + * Defines and Macros and globals + */ +#define MT9T111_MODULE_NAME "mt9t111" + +/*i2c adress for MT9T111*/ +#define MT9T111_I2C_ADDR (0x78 >> 1) + +#define MT9T111_CLK_MAX (96000000) /* 96MHz */ +#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 { + int (*s_power) (struct v4l2_subdev *subdev, u32 on); + int (*set_xclk) (struct v4l2_subdev *subdev, u32 hz); + int (*configure_interface) (struct v4l2_subdev *subdev, u32 pixclk); +}; + +#endif /* ifndef MT9T111 */ + -- 1.7.0.4 --===============1687754430== Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel --===============1687754430==--