Exynos4412 OV5640摄像头（一）—— 驱动

以下是迅为4412开发板提供的OV5640摄像头驱动，将OV5640注册为I2C设备，提供设备节点/dev/video0。

驱动下载：https://download.csdn.net/download/q1449516487/11231317

详情参考代码：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/platform_device.h>
#include <linux/videodev2.h>
#include <media/v4l2-subdev.h>
#include <media/soc_camera.h>
#include <media/v4l2-chip-ident.h>
#include <linux/delay.h>
/* add by cym 20130605 */
#include <linux/videodev2_samsung.h>
#include <linux/regulator/consumer.h>
#include <mach/gpio.h>
#include <plat/gpio-cfg.h>
#include <mach/regs-gpio.h>
#include <mach/regs-clock.h>
/* end add */
/* add by cym 20130605 */
enum {
    AUTO_FOCUS_FAILED,
    AUTO_FOCUS_DONE,
    AUTO_FOCUS_CANCELLED,
};
#ifndef CONFIG_TC4_EVT
//static struct regulator *vdd18_5m_cam_regulator = NULL;
//static struct regulator *vdd28_5m_cam_regulator = NULL;
struct regulator *ov_vddaf_cam_regulator = NULL;
struct regulator *ov_vdd5m_cam_regulator = NULL;
struct regulator *ov_vdd18_cam_regulator = NULL;
struct regulator *ov_vdd28_cam_regulator = NULL;
int down_af_firmware_flag = 0;
#endif
/* end add */
/* ANSI Color codes */
#define VT(CODES)  "\033[" CODES "m"
#define VT_NORMAL  VT("")
#define VT_RED     VT("0;32;31")
#define VT_GREEN   VT("1;32")
#define VT_YELLOW  VT("1;33")
#define VT_BLUE    VT("1;34")
#define VT_PURPLE  VT("0;35")
#define OV5640_DBG
#define xprintk(fmt, ...) \
    printk("%s()->%d " fmt, __func__, __LINE__, ## __VA_ARGS__)
#ifdef OV5640_DBG
#define _DBG(color, fmt, ...)  \
    xprintk(color "" fmt VT_NORMAL, ## __VA_ARGS__)
#define OV_INFO(fmt, args...)  _DBG(VT_GREEN, fmt, ## args)
#define OV_ERR(fmt, args...)   _DBG(VT_RED, fmt, ## args)
#else
#define OV_INFO(fmt, args...)  do {} while(0)
#define OV_ERR(fmt, args...) do {} while(0)
#endif
#define _INFO(color, fmt, ...) \
    xprintk(color "::" fmt ""VT_NORMAL, ## __VA_ARGS__)
/* mainly used in test code */
#define INFO_PURLPLE(fmt, args...) _INFO(VT_PURPLE, fmt, ## args)
#define INFO_RED(fmt, args...)     _INFO(VT_RED, fmt, ## args)
#define INFO_GREEN(fmt, args...)   _INFO(VT_GREEN, fmt, ## args)
#define INFO_BLUE(fmt, args...)    _INFO(VT_BLUE, fmt, ## args)
#define OV5640_I2C_NAME  "ov5640"
/* 
 * I2C write address: 0x78, read: 0x79 , give up least significant bit. 
 */
#define OV5640_I2C_ADDR  (0x78 >> 1)
/*
 * sensor ID
 */
#define OV5640  0x5640
#define VERSION(id, vers) ((id << 8) | (vers & 0XFF))
/* default format */
#define QVGA_WIDTH  320
#define QVGA_HEIGHT    240
#define VGA_WIDTH    640
#define VGA_HEIGHT    480
#define XGA_WIDTH    1024
#define XGA_HEIGHT    768
#define SXGA_WIDTH    1280
#define SXGA_HEIGHT    960
#define UXGA_WIDTH    1600
#define UXGA_HEIGHT    1200
#define QXGA_WIDTH    2048
#define QXGA_HEIGHT    1536
#define QSXGA_WIDTH        2560
#define QSXGA_HEIGHT    1920  //normally 2048, but ov5640 only support simple qsxga
#define CAPTURE_FRAME_RATE  500   /* multiplied by 100 */
#define PREVIEW_FRAME_RATE  1500   /* multiplied by 100 */
#define OV5640_COLUMN_SKIP 0
#define OV5640_ROW_SKIP    0
#define OV5640_MAX_WIDTH   (QSXGA_WIDTH)
#define OV5640_MAX_HEIGHT  (QSXGA_HEIGHT)
#define OV5640_HFLIP 0x1
#define OV5640_VFLIP 0x2
enum ov5640_resolution {
    RESV_VGA = 1,
    RESV_XGA,
    RESV_SXGA,
    RESV_UXGA,
    RESV_QXGA,
    RESV_QSXGA,
};
struct regval {
    unsigned short reg;
    unsigned char  val;
};
struct ov5640_color_format {
    enum v4l2_mbus_pixelcode code;
    enum v4l2_colorspace colorspace;
};
struct ov5640_win_size {
    char *name;
    enum ov5640_resolution resv;
    unsigned int  width;
    unsigned int  height;
    const struct regval *regs;
};
struct ov5640_priv {
    struct v4l2_subdev  subdev;
    const struct ov5640_color_format *cfmt;
    const struct ov5640_win_size *win;
    int  model;
    int brightness;
    int contrast;
    int saturation;
    int hue;
    int exposure;
    int sharpness;
    int colorfx;
    int flip_flag;
};
static const struct regval ov5640_init_regs[] = {
    /* for the setting , 24M Mlck input and 24M Plck output */
    {0x3103, 0x11}, 
    {0x3008, 0x82}, /* soft reset */
    {0x3008, 0x42}, 
    {0x3103, 0x03}, /* input clock, from PLL */
    {0x3017, 0xff}, /* d[9:0] pins I/O ctrl */
    {0x3018, 0xff}, 
                    /* system control */
    {0x3034, 0x1a}, /* MIPI 10-bit mode */
    {0x3035, 0x11}, /* clock, PLL sets */
    {0x3036, 0x46}, 
    {0x3037, 0x13}, 
    {0x3108, 0x01}, /* SCCB CLK root divider */
    {0x3630, 0x36}, 
    {0x3631, 0x0e}, 
    {0x3632, 0xe2}, 
    {0x3633, 0x12}, 
    {0x3621, 0xe0}, 
    {0x3704, 0xa0}, 
    {0x3703, 0x5a}, 
    {0x3715, 0x78}, 
    {0x3717, 0x01}, 
    {0x370b, 0x60}, 
    {0x3705, 0x1a}, 
    {0x3905, 0x02}, 
    {0x3906, 0x10}, 
    {0x3901, 0x0a}, 
    {0x3731, 0x12}, 
    {0x3600, 0x08}, 
    {0x3601, 0x33}, 
    {0x302d, 0x60}, 
    {0x3620, 0x52}, 
    {0x371b, 0x20}, 
    {0x471c, 0x50}, 
    {0x3a13, 0x43}, 
    {0x3a18, 0x00}, 
    {0x3a19, 0xf8}, 
    {0x3635, 0x13}, 
    {0x3636, 0x03}, 
    {0x3634, 0x40}, 
    {0x3622, 0x01}, 
    {0x3c01, 0x34},  /* 50/60HZ detector */
    {0x3c04, 0x28}, 
    {0x3c05, 0x98}, 
    {0x3c06, 0x00}, 
    {0x3c07, 0x08}, 
    {0x3c08, 0x00}, 
    {0x3c09, 0x1c}, 
    {0x3c0a, 0x9c}, 
    {0x3c0b, 0x40}, 
    {0x3820, 0x41}, /* mirror and flip */
    {0x3821, 0x07}, 
    {0x3814, 0x31}, /* image windowing */
    {0x3815, 0x31}, 
    {0x3800, 0x00}, 
    {0x3801, 0x00}, 
    {0x3802, 0x00}, 
    {0x3803, 0x04}, 
    {0x3804, 0x0a}, 
    {0x3805, 0x3f}, 
    {0x3806, 0x07}, 
    {0x3807, 0x9b}, 
    {0x3808, 0x02}, /* 0x280==640 */
    {0x3809, 0x80}, 
    {0x380a, 0x01}, /* 0x1e0==480 */
    {0x380b, 0xe0}, 
    {0x380c, 0x07}, 
    {0x380d, 0x68}, 
    {0x380e, 0x03}, 
    {0x380f, 0xd8}, 
    {0x3810, 0x00}, 
    {0x3811, 0x10}, 
    {0x3812, 0x00}, 
    {0x3813, 0x06}, 
    {0x3618, 0x00}, 
    {0x3612, 0x29}, 
    {0x3708, 0x64}, 
    {0x3709, 0x52}, 
    {0x370c, 0x03}, 
    {0x3a02, 0x03}, /* AEC/AGC control */
    {0x3a03, 0xd8}, 
    {0x3a08, 0x01}, 
    {0x3a09, 0x27}, 
    {0x3a0a, 0x00}, 
    {0x3a0b, 0xf6}, 
    {0x3a0e, 0x03}, 
    {0x3a0d, 0x04}, 
    {0x3a14, 0x03}, 
    {0x3a15, 0xd8}, 
    {0x4001, 0x02}, /* BLC start line */
    {0x4004, 0x02}, /* BLC line number */
    {0x3000, 0x00}, /* block enable */
    {0x3002, 0x1c}, 
    {0x3004, 0xff}, /* clock enable */
    {0x3006, 0xc3}, 
    {0x300e, 0x58}, 
    {0x302e, 0x00}, 
    {0x4300, 0x32}, /* format ctrl: YUV422 UYVY */
    {0x501f, 0x00}, /* format MUX ctrl: ISP YUV422 */
    {0x4713, 0x03}, /* jpeg mode select: mode 3 */
    {0x4407, 0x04}, /* jpeg ctrl */
    {0x440e, 0x00}, 
    {0x460b, 0x35}, /* VFIFO ctrl */
    {0x460c, 0x22}, 
    {0x3824, 0x02}, 
    {0x5000, 0xa7}, /* ISP top ctrl */
    {0x5001, 0xa3}, 
    {0x5180, 0xff}, /* AWB ctrl */
    {0x5181, 0xf2}, 
    {0x5182, 0x00}, 
    {0x5183, 0x14}, 
    {0x5184, 0x25}, 
    {0x5185, 0x24}, 
    {0x5186, 0x09}, 
    {0x5187, 0x09}, 
    {0x5188, 0x09}, 
    {0x5189, 0x75}, 
    {0x518a, 0x54}, 
    {0x518b, 0xe0}, 
    {0x518c, 0xb2}, 
    {0x518d, 0x42}, 
    {0x518e, 0x3d}, 
    {0x518f, 0x56}, 
    {0x5190, 0x46}, 
    {0x5191, 0xf8}, 
    {0x5192, 0x04}, 
    {0x5193, 0x70}, 
    {0x5194, 0xf0}, 
    {0x5195, 0xf0}, 
    {0x5196, 0x03}, 
    {0x5197, 0x01}, 
    {0x5198, 0x04}, 
    {0x5199, 0x12}, 
    {0x519a, 0x04}, 
    {0x519b, 0x00}, 
    {0x519c, 0x06}, 
    {0x519d, 0x82}, 
    {0x519e, 0x38}, 
    {0x5381, 0x1e}, /* Color matrix */
    {0x5382, 0x5b}, 
    {0x5383, 0x08}, 
    {0x5384, 0x0a}, 
    {0x5385, 0x7e}, 
    {0x5386, 0x88}, 
    {0x5387, 0x7c}, 
    {0x5388, 0x6c}, 
    {0x5389, 0x10}, 
    {0x538a, 0x01}, 
    {0x538b, 0x98}, 
    {0x5300, 0x08}, /* Color interpolation */
    {0x5301, 0x30}, 
    {0x5302, 0x10}, 
    {0x5303, 0x00}, 
    {0x5304, 0x08}, 
    {0x5305, 0x30}, 
    {0x5306, 0x08}, 
    {0x5307, 0x16}, 
    {0x5309, 0x08}, 
    {0x530a, 0x30}, 
    {0x530b, 0x04}, 
    {0x530c, 0x06}, 
    {0x5480, 0x01}, /* gamma ctrl */
    {0x5481, 0x08}, 
    {0x5482, 0x14}, 
    {0x5483, 0x28}, 
    {0x5484, 0x51}, 
    {0x5485, 0x65}, 
    {0x5486, 0x71}, 
    {0x5487, 0x7d}, 
    {0x5488, 0x87}, 
    {0x5489, 0x91}, 
    {0x548a, 0x9a}, 
    {0x548b, 0xaa}, 
    {0x548c, 0xb8}, 
    {0x548d, 0xcd}, 
    {0x548e, 0xdd}, 
    {0x548f, 0xea}, 
    {0x5490, 0x1d}, 
    {0x5580, 0x02}, /* special digital effects(SDE) */
    {0x5583, 0x40}, 
    {0x5584, 0x10}, 
    {0x5589, 0x10}, 
    {0x558a, 0x00}, 
    {0x558b, 0xf8}, 
    {0x5800, 0x23}, /* LENC ctrl */
    {0x5801, 0x14}, 
    {0x5802, 0x0f}, 
    {0x5803, 0x0f}, 
    {0x5804, 0x12}, 
    {0x5805, 0x26}, 
    {0x5806, 0x0c}, 
    {0x5807, 0x08}, 
    {0x5808, 0x05}, 
    {0x5809, 0x05}, 
    {0x580a, 0x08}, 
    {0x580b, 0x0d}, 
    {0x580c, 0x08}, 
    {0x580d, 0x03}, 
    {0x580e, 0x00}, 
    {0x580f, 0x00}, 
    {0x5810, 0x03}, 
    {0x5811, 0x09}, 
    {0x5812, 0x07}, 
    {0x5813, 0x03}, 
    {0x5814, 0x00}, 
    {0x5815, 0x01}, 
    {0x5816, 0x03}, 
    {0x5817, 0x08}, 
    {0x5818, 0x0d}, 
    {0x5819, 0x08}, 
    {0x581a, 0x05}, 
    {0x581b, 0x06}, 
    {0x581c, 0x08}, 
    {0x581d, 0x0e}, 
    {0x581e, 0x29}, 
    {0x581f, 0x17}, 
    {0x5820, 0x11}, 
    {0x5821, 0x11}, 
    {0x5822, 0x15}, 
    {0x5823, 0x28}, 
    {0x5824, 0x46}, 
    {0x5825, 0x26}, 
    {0x5826, 0x08}, 
    {0x5827, 0x26}, 
    {0x5828, 0x64}, 
    {0x5829, 0x26}, 
    {0x582a, 0x24}, 
    {0x582b, 0x22}, 
    {0x582c, 0x24}, 
    {0x582d, 0x24}, 
    {0x582e, 0x06}, 
    {0x582f, 0x22}, 
    {0x5830, 0x40}, 
    {0x5831, 0x42}, 
    {0x5832, 0x24}, 
    {0x5833, 0x26}, 
    {0x5834, 0x24}, 
    {0x5835, 0x22}, 
    {0x5836, 0x22}, 
    {0x5837, 0x26}, 
    {0x5838, 0x44}, 
    {0x5839, 0x24}, 
    {0x583a, 0x26}, 
    {0x583b, 0x28}, 
    {0x583c, 0x42}, 
    {0x583d, 0xce}, 
    {0x5025, 0x00}, 
    {0x3a0f, 0x30}, /* AEC functions */
    {0x3a10, 0x28}, 
    {0x3a1b, 0x30}, 
    {0x3a1e, 0x26}, 
    {0x3a11, 0x60}, 
    {0x3a1f, 0x14}, 
    {0x3008, 0x02}, /* soft reset/pwd default value */
    {0x3035, 0x21}, /* SC PLL ctrl */
    {0x3c01, 0xb4}, /* Band, 0x50Hz */
    {0x3c00, 0x04}, 
    {0x3a19, 0x7c}, /* gain ceiling */
    {0x5800, 0x2c}, /* OV5640 LENC setting */
    {0x5801, 0x17}, 
    {0x5802, 0x11}, 
    {0x5803, 0x11}, 
    {0x5804, 0x15}, 
    {0x5805, 0x29}, 
    {0x5806, 0x08}, 
    {0x5807, 0x06}, 
    {0x5808, 0x04}, 
    {0x5809, 0x04}, 
    {0x580a, 0x05}, 
    {0x580b, 0x07}, 
    {0x580c, 0x06}, 
    {0x580d, 0x03}, 
    {0x580e, 0x01}, 
    {0x580f, 0x01}, 
    {0x5810, 0x03}, 
    {0x5811, 0x06}, 
    {0x5812, 0x06}, 
    {0x5813, 0x02}, 
    {0x5814, 0x01}, 
    {0x5815, 0x01}, 
    {0x5816, 0x04}, 
    {0x5817, 0x07}, 
    {0x5818, 0x06}, 
    {0x5819, 0x07}, 
    {0x581a, 0x06}, 
    {0x581b, 0x06}, 
    {0x581c, 0x06}, 
    {0x581d, 0x0e}, 
    {0x581e, 0x31}, 
    {0x581f, 0x12}, 
    {0x5820, 0x11}, 
    {0x5821, 0x11}, 
    {0x5822, 0x11}, 
    {0x5823, 0x2f}, 
    {0x5824, 0x12}, 
    {0x5825, 0x25}, 
    {0x5826, 0x39}, 
    {0x5827, 0x29}, 
    {0x5828, 0x27}, 
    {0x5829, 0x39}, 
    {0x582a, 0x26}, 
    {0x582b, 0x33}, 
    {0x582c, 0x24}, 
    {0x582d, 0x39}, 
    {0x582e, 0x28}, 
    {0x582f, 0x21}, 
    {0x5830, 0x40}, 
    {0x5831, 0x21}, 
    {0x5832, 0x17}, 
    {0x5833, 0x17}, 
    {0x5834, 0x15}, 
    {0x5835, 0x11}, 
    {0x5836, 0x24}, 
    {0x5837, 0x27}, 
    {0x5838, 0x26}, 
    {0x5839, 0x26}, 
    {0x583a, 0x26}, 
    {0x583b, 0x28}, 
    {0x583c, 0x14}, 
    {0x583d, 0xee}, 
    {0x4005, 0x1a}, /* BLC always update */
    {0x5381, 0x26}, /* color matrix ctrl */
    {0x5382, 0x50}, 
    {0x5383, 0x0c}, 
    {0x5384, 0x09}, 
    {0x5385, 0x74}, 
    {0x5386, 0x7d}, 
    {0x5387, 0x7e}, 
    {0x5388, 0x75}, 
    {0x5389, 0x09}, 
    {0x538b, 0x98}, 
    {0x538a, 0x01}, 
    {0x5580, 0x02}, /* (SDE)UVAdjust Auto Mode */
    {0x5588, 0x01}, 
    {0x5583, 0x40}, 
    {0x5584, 0x10}, 
    {0x5589, 0x0f}, 
    {0x558a, 0x00}, 
    {0x558b, 0x3f}, 
    {0x5308, 0x25}, /* De-Noise, 0xAuto */
    {0x5304, 0x08}, 
    {0x5305, 0x30}, 
    {0x5306, 0x10}, 
    {0x5307, 0x20}, 
    {0x5180, 0xff}, /* awb ctrl */
    {0x5181, 0xf2}, 
    {0x5182, 0x11}, 
    {0x5183, 0x14}, 
    {0x5184, 0x25}, 
    {0x5185, 0x24}, 
    {0x5186, 0x10}, 
    {0x5187, 0x12}, 
    {0x5188, 0x10}, 
    {0x5189, 0x80}, 
    {0x518a, 0x54}, 
    {0x518b, 0xb8}, 
    {0x518c, 0xb2}, 
    {0x518d, 0x42}, 
    {0x518e, 0x3a}, 
    {0x518f, 0x56}, 
    {0x5190, 0x46}, 
    {0x5191, 0xf0}, 
    {0x5192, 0xf}, 
    {0x5193, 0x70}, 
    {0x5194, 0xf0}, 
    {0x5195, 0xf0}, 
    {0x5196, 0x3}, 
    {0x5197, 0x1}, 
    {0x5198, 0x6}, 
    {0x5199, 0x62}, 
    {0x519a, 0x4}, 
    {0x519b, 0x0}, 
    {0x519c, 0x4}, 
    {0x519d, 0xe7}, 
    {0x519e, 0x38}, 
};
static const struct regval ov5640_qsxga_regs[] = {
    {0x3820, 0x40},  /* diff. init */
    {0x3821, 0x06},
    {0x3814, 0x11}, /* image windowing */
    {0x3815, 0x11},
    {0x3803, 0x00},
    {0x3807, 0x9f},
    {0x3808, 0x0a}, /* 0x0a20==2592 */
    {0x3809, 0x20},
    {0x380a, 0x07}, /* 0x798==1944 */
    {0x380b, 0x98},
    {0x380c, 0x0b},
    {0x380d, 0x1c},
    {0x380e, 0x07},
    {0x380f, 0xb0},
    {0x3813, 0x04},
    {0x3618, 0x04},
    {0x3612, 0x4b},
    {0x3708, 0x21},
    {0x3709, 0x12},
    {0x370c, 0x00},
    {0x3a02, 0x07}, /* night mode */
    {0x3a03, 0xb0},
    {0x3a0e, 0x06},
    {0x3a0d, 0x08},
    {0x3a14, 0x07},
    {0x3a15, 0xb0},
    {0x4004, 0x06}, /* BLC line number */
    {0x5000, 0x07}, /* black/white pixel cancell, color interp. enable */
    {0x5181, 0x52}, /* AWB */
    {0x5182, 0x00},
    {0x5197, 0x01},
    {0x519e, 0x38},
    {0x3035, 0x21}, /* SC PLL */
    {0x5000, 0x27}, 
    {0x5001, 0x83}, /* special effect, color matrix, AWB enable */
    {0x3035, 0x71},
    {0x4713, 0x02}, /* jpeg mode 2 */
    {0x3036, 0x69},
    {0x4407, 0x0c}, /* jpeg ctrl */
    {0x460b, 0x37},
    {0x460c, 0x20},
    {0x3824, 0x01},
    {0x4005, 0x1A},
};
/*
static const struct regval ov5640_qsxga_to_qvga_regs[] = {
};
*/
static const struct regval ov5640_qsxga_to_vga_regs[] = {
    {0x3800, 0x00}, /* image windowing */
    {0x3801, 0x00},
    {0x3802, 0x00},
    {0x3803, 0x00},
    {0x3804, 0xA },
    {0x3805, 0x3f},
    {0x3806, 0x7 },
    {0x3807, 0x9f},
    {0x3808, 0x2 }, /* 0x280== 640*/
    {0x3809, 0x80},
    {0x380a, 0x1 }, /* 0x1e0== 480*/
    {0x380b, 0xe0},
    {0x380c, 0xc },
    {0x380d, 0x80},
    {0x380e, 0x7 },
    {0x380f, 0xd0},
    {0x5001, 0xa3}, /* SDE, scaling, color matrix, AWB enable */
    {0x5680, 0x0 }, /* AVG ctrl */
    {0x5681, 0x0 },
    {0x5682, 0xA },
    {0x5683, 0x20},
    {0x5684, 0x0 },
    {0x5685, 0x0 },
    {0x5686, 0x7 },
    {0x5687, 0x98},
};
static const struct regval ov5640_qsxga_to_xga_regs[] = {
    {0x3800, 0x00},
    {0x3801, 0x00},
    {0x3802, 0x00},
    {0x3803, 0x00},
    {0x3804, 0xA },
    {0x3805, 0x3f},
    {0x3806, 0x7 },
    {0x3807, 0x9f},
    {0x3808, 0x4 }, /* 0x400==1024 */
    {0x3809, 0x0 },
    {0x380a, 0x3 }, /* 0x300== 768*/
    {0x380b, 0x0 },
    {0x380c, 0xc },
    {0x380d, 0x80},
    {0x380e, 0x7 },
    {0x380f, 0xd0},
    {0x5001, 0xa3},
    {0x5680, 0x0 },
    {0x5681, 0x0 },
    {0x5682, 0xA },
    {0x5683, 0x20},
    {0x5684, 0x0 },
    {0x5685, 0x0 },
    {0x5686, 0x7 },
    {0x5687, 0x98},
};
static const struct regval ov5640_qsxga_to_sxga_regs[] = {
    {0x3800, 0x00},
    {0x3801, 0x00},
    {0x3802, 0x00},
    {0x3803, 0x00},
    {0x3804, 0xA },
    {0x3805, 0x3f},
    {0x3806, 0x7 },
    {0x3807, 0x9f},
    {0x3808, 0x5 }, /* 0x500==1280 */
    {0x3809, 0x0 },
    {0x380a, 0x3 }, /* 0x3c0==960 */
    {0x380b, 0xc0},
    {0x380c, 0xc },
    {0x380d, 0x80},
    {0x380e, 0x7 },
    {0x380f, 0xd0},
    {0x5001, 0xa3},
    {0x5680, 0x0 },
    {0x5681, 0x0 },
    {0x5682, 0xA },
    {0x5683, 0x20},
    {0x5684, 0x0 },
    {0x5685, 0x0 },
    {0x5686, 0x7 },
    {0x5687, 0x98},
};
static const struct regval ov5640_qsxga_to_uxga_regs[] = {
#if 0
    {0x3800, 0x00},
    {0x3801, 0x00},
    {0x3802, 0x00},
    {0x3803, 0x00},
    {0x3804, 0xA },
    {0x3805, 0x3f},
    {0x3806, 0x7 },
    {0x3807, 0x9f},
    {0x3808, 0x6 }, /* 0x640== 1600*/
    {0x3809, 0x40},
    {0x380a, 0x4 }, /* 0x4b0==1200 */
    {0x380b, 0xb0},
    {0x380c, 0xc },
    {0x380d, 0x80},
    {0x380e, 0x7 },
    {0x380f, 0xd0},
    {0x5001, 0xa3},
    {0x5680, 0x0 },
    {0x5681, 0x0 },
    {0x5682, 0xA },
    {0x5683, 0x20},
    {0x5684, 0x0 },
    {0x5685, 0x0 },
    {0x5686, 0x7 },
    {0x5687, 0x98},
#else
    {0x3503, 0x07},
    {0x3a00, 0x38},
    {0x4050, 0x6e},
    {0x4051, 0x8f},
    {0x5302, 0x1c},
    {0x5303, 0x08},
    {0x5306, 0x0c},
    {0x5307, 0x1c},
    {0x3820, 0x40},
    {0x3821, 0x06},
    {0x3800, 0x00},
    {0x3801, 0x00},
    {0x3802, 0x00},
    {0x3803, 0x00},
    {0x3804, 0x0a},
    {0x3805, 0x3f},
    {0x3806, 0x07},
    {0x3807, 0x9f},
    {0x3808, 0x0a},
    {0x3809, 0x20},
    {0x380a, 0x07},
    {0x380b, 0x98},
    {0x3810, 0x00},
    {0x3811, 0x10},
    {0x3812, 0x00},
    {0x3813, 0x04},
    {0x3814, 0x11},
    {0x3815, 0x11},
    {0x3034, 0x1a},
    {0x3035, 0x11},
    {0x3036, 0x46},
    {0x3037, 0x13},
    {0x3038, 0x00},
    {0x3039, 0x00},
    {0x380c, 0x0b},
    {0x380d, 0x1c},
    {0x380e, 0x07},
    {0x380f, 0xb0},
    {0x3a08, 0x00},
    {0x3a09, 0xc5},
    {0x3a0e, 0x0a},
    {0x3a0a, 0x00},
    {0x3a0b, 0xa4},
    {0x3a0d, 0x0c},
    {0x3618, 0x04},
    {0x3612, 0x2b},
    {0x3709, 0x12},
    {0x370c, 0x00},
    {0x4004, 0x06},
    {0x3002, 0x00},
    {0x3006, 0xff},
    {0x4713, 0x02},
    {0x4407, 0x04},
    {0x460b, 0x37},
    {0x460c, 0x22},
    {0x4837, 0x16},
    {0x3824, 0x01},
    {0x5001, 0x83},
    {0x4202,0x00},
#endif
};
static const struct regval ov5640_qsxga_to_qxga_regs[] = {
    {0x3800, 0x00},
    {0x3801, 0x00},
    {0x3802, 0x00},
    {0x3803, 0x00},
    {0x3804, 0xA },
    {0x3805, 0x3f},
    {0x3806, 0x7 },
    {0x3807, 0x9f},
    {0x3808, 0x8 }, /* 0x800==2048 */
    {0x3809, 0x0 },
    {0x380a, 0x6 }, /* 0x600==1536 */
    {0x380b, 0x0 },
    {0x380c, 0xc },
    {0x380d, 0x80},
    {0x380e, 0x7 },
    {0x380f, 0xd0},
    {0x5001, 0xa3},
    {0x5680, 0x0 },
    {0x5681, 0x0 },
    {0x5682, 0xA },
    {0x5683, 0x20},
    {0x5684, 0x0 },
    {0x5685, 0x0 },
    {0x5686, 0x7 },
    {0x5687, 0x98},
};
#if 0
static const struct v4l2_queryctrl ov5640_controls[] = {
    {
        .id        = V4L2_CID_VFLIP,
        .type        = V4L2_CTRL_TYPE_BOOLEAN,
        .name        = "Flip Vertically",
        .minimum    = 0,
        .maximum    = 1,
        .step        = 1,
        .default_value    = 0,
    },
    {
        .id        = V4L2_CID_HFLIP,
        .type        = V4L2_CTRL_TYPE_BOOLEAN,
        .name        = "Flip Horizontally",
        .minimum    = 0,
        .maximum    = 1,
        .step        = 1,
        .default_value    = 0,
    },
};
#endif
/* QVGA: 320*240 */ 
/*
static const struct ov5640_win_size ov5640_win_qvga = {
    .name     = "QVGA",
    .width    = QVGA_WIDTH,
    .height   = QVGA_HEIGHT,
    .regs     = ov5640_qsxga_to_qvga_regs,
};
*/
static const struct ov5640_win_size ov5640_wins[] = {
    {
        .name    = "VGA",    /* VGA: 640*480 */
        .resv    = RESV_VGA,
        .width   = VGA_WIDTH, 
        .height  = VGA_HEIGHT,
        .regs    = ov5640_qsxga_to_vga_regs,
    },
    {
        .name    = "XGA",    /* XGA: 1024*768 */
        .resv    = RESV_XGA,
        .width   = XGA_WIDTH,
        .height  = XGA_HEIGHT,
        .regs    = ov5640_qsxga_to_xga_regs,
    },
    {
        .name    = "SXGA",    /* SXGA: 1280*960  */
        .resv    = RESV_SXGA,
        .width   = SXGA_WIDTH,
        .height  = SXGA_HEIGHT,
        .regs    = ov5640_qsxga_to_sxga_regs,
    },
    {
        .name    = "UXGA",    /* UXGA: 1600*1200 */
        .resv    = RESV_UXGA,
        .width   = UXGA_WIDTH,
        .height  = UXGA_HEIGHT,
        .regs    = ov5640_qsxga_to_uxga_regs,
    },
    {
        .name    = "QXGA",    /* QXGA: 2048*1536 */
        .resv    = RESV_QXGA,
        .width   = QXGA_WIDTH,
        .height  = QXGA_HEIGHT,
        .regs    = ov5640_qsxga_to_qxga_regs,
    },
    {
        .name    = "QSXGA",    /* QSXGA: 2560*1920*/
        .resv    = RESV_QSXGA,
        .width   = QSXGA_WIDTH,
        .height  = QSXGA_HEIGHT,
        .regs    = ov5640_qsxga_regs,
    },
};
/*
 * supported color format list
 */
static const struct ov5640_color_format ov5640_cfmts[] = {
    {
        .code        = 2,//cym V4L2_MBUS_FMT_YUYV8_2X8_BE,
        .colorspace    = V4L2_COLORSPACE_JPEG,
    },
    {
        .code        = 3, //cym V4L2_MBUS_FMT_YUYV8_2X8_LE,
        .colorspace    = V4L2_COLORSPACE_JPEG,
    },
    {
                .code           = 0x2007, //cym V4L2_MBUS_FMT_YUYV8_2X8_LE,
                .colorspace     = V4L2_COLORSPACE_JPEG,
       },
};
static int i2cc_get_reg(struct i2c_client *client,
    unsigned short reg, unsigned char *value)
{
    unsigned char buffer[2];
    int ret = 0;
    int err = 0;
    buffer[0] = (reg >> 8) & 0xFF;
    buffer[1] = reg & 0xFF;
    if (2 != (ret = i2c_master_send(client, buffer, 2))) {
        err = -2;
        OV_ERR("i2cc out error: ret == %d (should be 2)\n", ret);
    }
    if (1 != (ret = i2c_master_recv(client, buffer, 1))) {
        err = -1;
        OV_ERR("i2cc in error: ret == %d (should be 1)\n", ret);
    }
    //OV_INFO("ov5640 client: read 0x%x = 0x%x\n", reg, buffer[0]);
    *value = buffer[0];
    return (err);
}
static int i2cc_set_reg(struct i2c_client *client,
    unsigned short reg, unsigned char value)
{
    unsigned char buffer[3];
    int ret = 0;
    int err = 0;
    buffer[0] = (reg >> 8) & 0xFF;
    buffer[1] = reg & 0xFF;
    buffer[2] = value;
    //OV_INFO("ov5640 client: writing 0x%x = 0x%x\n", reg, value);
    if (3 != (ret = i2c_master_send(client, buffer, 3))) {
        OV_ERR("i2cc out error: ret = %d (should be 3)\n", ret);
        err = -3;
    }
    return (err);
}
#if 1
/* add by dg 2015-07-15*/
/*************************************************************************
* FUNCTION
*   OV5640_FOCUS_AD5820_Init
*
* DESCRIPTION
*   This function is to load micro code for AF function
*
* PARAMETERS
*   None
*
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
static u8 AD5820_Config[] =
{
    0x02, 0x0f, 0xd6, 0x02, 0x0a, 0x39, 0xc2, 0x01, 0x22, 0x22, 0x00, 0x02, 0x0f, 0xb2, 0xe5, 0x1f, //0x8000,
    0x70, 0x72, 0xf5, 0x1e, 0xd2, 0x35, 0xff, 0xef, 0x25, 0xe0, 0x24, 0x4e, 0xf8, 0xe4, 0xf6, 0x08, //0x8010,
    0xf6, 0x0f, 0xbf, 0x34, 0xf2, 0x90, 0x0e, 0x93, 0xe4, 0x93, 0xff, 0xe5, 0x4b, 0xc3, 0x9f, 0x50, //0x8020,
    0x04, 0x7f, 0x05, 0x80, 0x02, 0x7f, 0xfb, 0x78, 0xbd, 0xa6, 0x07, 0x12, 0x0f, 0x04, 0x40, 0x04, //0x8030,
    0x7f, 0x03, 0x80, 0x02, 0x7f, 0x30, 0x78, 0xbc, 0xa6, 0x07, 0xe6, 0x18, 0xf6, 0x08, 0xe6, 0x78, //0x8040,
    0xb9, 0xf6, 0x78, 0xbc, 0xe6, 0x78, 0xba, 0xf6, 0x78, 0xbf, 0x76, 0x33, 0xe4, 0x08, 0xf6, 0x78, //0x8050,
    0xb8, 0x76, 0x01, 0x75, 0x4a, 0x02, 0x78, 0xb6, 0xf6, 0x08, 0xf6, 0x74, 0xff, 0x78, 0xc1, 0xf6, //0x8060,
    0x08, 0xf6, 0x75, 0x1f, 0x01, 0x78, 0xbc, 0xe6, 0x75, 0xf0, 0x05, 0xa4, 0xf5, 0x4b, 0x12, 0x0a, //0x8070,
    0xff, 0xc2, 0x37, 0x22, 0x78, 0xb8, 0xe6, 0xd3, 0x94, 0x00, 0x40, 0x02, 0x16, 0x22, 0xe5, 0x1f, //0x8080,
    0xb4, 0x05, 0x23, 0xe4, 0xf5, 0x1f, 0xc2, 0x01, 0x78, 0xb6, 0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x78, //0x8090,
    0x4e, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0xa2, 0x37, 0xe4, 0x33, 0xf5, 0x3c, 0x90, 0x30, 0x28, 0xf0, //0x80a0,
    0x75, 0x1e, 0x10, 0xd2, 0x35, 0x22, 0xe5, 0x4b, 0x75, 0xf0, 0x05, 0x84, 0x78, 0xbc, 0xf6, 0x90, //0x80b0,
    0x0e, 0x8c, 0xe4, 0x93, 0xff, 0x25, 0xe0, 0x24, 0x0a, 0xf8, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x78, //0x80c0,
    0xbc, 0xe6, 0x25, 0xe0, 0x24, 0x4e, 0xf8, 0xa6, 0x04, 0x08, 0xa6, 0x05, 0xef, 0x12, 0x0f, 0x0b, //0x80d0,
    0xd3, 0x78, 0xb7, 0x96, 0xee, 0x18, 0x96, 0x40, 0x0d, 0x78, 0xbc, 0xe6, 0x78, 0xb9, 0xf6, 0x78, //0x80e0,
    0xb6, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x90, 0x0e, 0x8c, 0xe4, 0x93, 0x12, 0x0f, 0x0b, 0xc3, 0x78, //0x80f0,
    0xc2, 0x96, 0xee, 0x18, 0x96, 0x50, 0x0d, 0x78, 0xbc, 0xe6, 0x78, 0xba, 0xf6, 0x78, 0xc1, 0xa6, //0x8100,
    0x06, 0x08, 0xa6, 0x07, 0x78, 0xb6, 0xe6, 0xfe, 0x08, 0xe6, 0xc3, 0x78, 0xc2, 0x96, 0xff, 0xee, //0x8110,
    0x18, 0x96, 0x78, 0xc3, 0xf6, 0x08, 0xa6, 0x07, 0x90, 0x0e, 0x95, 0xe4, 0x18, 0x12, 0x0e, 0xe9, //0x8120,
    0x40, 0x02, 0xd2, 0x37, 0x78, 0xbc, 0xe6, 0x08, 0x26, 0x08, 0xf6, 0xe5, 0x1f, 0x64, 0x01, 0x70, //0x8130,
    0x4a, 0xe6, 0xc3, 0x78, 0xc0, 0x12, 0x0e, 0xdf, 0x40, 0x05, 0x12, 0x0e, 0xda, 0x40, 0x39, 0x12, //0x8140,
    0x0f, 0x02, 0x40, 0x04, 0x7f, 0xfe, 0x80, 0x02, 0x7f, 0x02, 0x78, 0xbd, 0xa6, 0x07, 0x78, 0xb9, //0x8150,
    0xe6, 0x24, 0x03, 0x78, 0xbf, 0xf6, 0x78, 0xb9, 0xe6, 0x24, 0xfd, 0x78, 0xc0, 0xf6, 0x12, 0x0f, //0x8160,
    0x02, 0x40, 0x06, 0x78, 0xc0, 0xe6, 0xff, 0x80, 0x04, 0x78, 0xbf, 0xe6, 0xff, 0x78, 0xbe, 0xa6, //0x8170,
    0x07, 0x75, 0x1f, 0x02, 0x78, 0xb8, 0x76, 0x01, 0x02, 0x02, 0x4a, 0xe5, 0x1f, 0x64, 0x02, 0x60, //0x8180,
    0x03, 0x02, 0x02, 0x2a, 0x78, 0xbe, 0xe6, 0xff, 0xc3, 0x78, 0xc0, 0x12, 0x0e, 0xe0, 0x40, 0x08, //0x8190,
    0x12, 0x0e, 0xda, 0x50, 0x03, 0x02, 0x02, 0x28, 0x12, 0x0f, 0x02, 0x40, 0x04, 0x7f, 0xff, 0x80, //0x81a0,
    0x02, 0x7f, 0x01, 0x78, 0xbd, 0xa6, 0x07, 0x78, 0xb9, 0xe6, 0x04, 0x78, 0xbf, 0xf6, 0x78, 0xb9, //0x81b0,
    0xe6, 0x14, 0x78, 0xc0, 0xf6, 0x18, 0x12, 0x0f, 0x04, 0x40, 0x04, 0xe6, 0xff, 0x80, 0x02, 0x7f, //0x81c0,
    0x00, 0x78, 0xbf, 0xa6, 0x07, 0xd3, 0x08, 0xe6, 0x64, 0x80, 0x94, 0x80, 0x40, 0x04, 0xe6, 0xff, //0x81d0,
    0x80, 0x02, 0x7f, 0x00, 0x78, 0xc0, 0xa6, 0x07, 0xc3, 0x18, 0xe6, 0x64, 0x80, 0x94, 0xb3, 0x50, //0x81e0,
    0x04, 0xe6, 0xff, 0x80, 0x02, 0x7f, 0x33, 0x78, 0xbf, 0xa6, 0x07, 0xc3, 0x08, 0xe6, 0x64, 0x80, //0x81f0,
    0x94, 0xb3, 0x50, 0x04, 0xe6, 0xff, 0x80, 0x02, 0x7f, 0x33, 0x78, 0xc0, 0xa6, 0x07, 0x12, 0x0f, //0x8200,
    0x02, 0x40, 0x06, 0x78, 0xc0, 0xe6, 0xff, 0x80, 0x04, 0x78, 0xbf, 0xe6, 0xff, 0x78, 0xbe, 0xa6, //0x8210,
    0x07, 0x75, 0x1f, 0x03, 0x78, 0xb8, 0x76, 0x01, 0x80, 0x20, 0xe5, 0x1f, 0x64, 0x03, 0x70, 0x26, //0x8220,
    0x78, 0xbe, 0xe6, 0xff, 0xc3, 0x78, 0xc0, 0x12, 0x0e, 0xe0, 0x40, 0x05, 0x12, 0x0e, 0xda, 0x40, //0x8230,
    0x09, 0x78, 0xb9, 0xe6, 0x78, 0xbe, 0xf6, 0x75, 0x1f, 0x04, 0x78, 0xbe, 0xe6, 0x75, 0xf0, 0x05, //0x8240,
    0xa4, 0xf5, 0x4b, 0x02, 0x0a, 0xff, 0xe5, 0x1f, 0xb4, 0x04, 0x10, 0x90, 0x0e, 0x94, 0xe4, 0x78, //0x8250,
    0xc3, 0x12, 0x0e, 0xe9, 0x40, 0x02, 0xd2, 0x37, 0x75, 0x1f, 0x05, 0x22, 0x30, 0x01, 0x03, 0x02, //0x8260,
    0x04, 0xc0, 0x30, 0x02, 0x03, 0x02, 0x04, 0xc0, 0x90, 0x51, 0xa5, 0xe0, 0x78, 0x93, 0xf6, 0xa3, //0x8270,
    0xe0, 0x08, 0xf6, 0xa3, 0xe0, 0x08, 0xf6, 0xe5, 0x1f, 0x70, 0x3c, 0x75, 0x1e, 0x20, 0xd2, 0x35, //0x8280,
    0x12, 0x0c, 0x7a, 0x78, 0x7e, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x78, 0x8b, 0xa6, 0x09, 0x18, 0x76, //0x8290,
    0x01, 0x12, 0x0c, 0x5b, 0x78, 0x4e, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x78, 0x8b, 0xe6, 0x78, 0x6e, //0x82a0,
    0xf6, 0x75, 0x1f, 0x01, 0x78, 0x93, 0xe6, 0x78, 0x90, 0xf6, 0x78, 0x94, 0xe6, 0x78, 0x91, 0xf6, //0x82b0,
    0x78, 0x95, 0xe6, 0x78, 0x92, 0xf6, 0x22, 0x79, 0x90, 0xe7, 0xd3, 0x78, 0x93, 0x96, 0x40, 0x05, //0x82c0,
    0xe7, 0x96, 0xff, 0x80, 0x08, 0xc3, 0x79, 0x93, 0xe7, 0x78, 0x90, 0x96, 0xff, 0x78, 0x88, 0x76, //0x82d0,
    0x00, 0x08, 0xa6, 0x07, 0x79, 0x91, 0xe7, 0xd3, 0x78, 0x94, 0x96, 0x40, 0x05, 0xe7, 0x96, 0xff, //0x82e0,
    0x80, 0x08, 0xc3, 0x79, 0x94, 0xe7, 0x78, 0x91, 0x96, 0xff, 0x12, 0x0c, 0x8e, 0x79, 0x92, 0xe7, //0x82f0,
    0xd3, 0x78, 0x95, 0x96, 0x40, 0x05, 0xe7, 0x96, 0xff, 0x80, 0x08, 0xc3, 0x79, 0x95, 0xe7, 0x78, //0x8300,
    0x92, 0x96, 0xff, 0x12, 0x0c, 0x8e, 0x12, 0x0c, 0x5b, 0x78, 0x8a, 0xe6, 0x25, 0xe0, 0x24, 0x4e, //0x8310,
    0xf8, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x78, 0x8a, 0xe6, 0x24, 0x6e, 0xf8, 0xa6, 0x09, 0x78, 0x8a, //0x8320,
    0xe6, 0x24, 0x01, 0xff, 0xe4, 0x33, 0xfe, 0xd3, 0xef, 0x94, 0x0f, 0xee, 0x64, 0x80, 0x94, 0x80, //0x8330,
    0x40, 0x04, 0x7f, 0x00, 0x80, 0x05, 0x78, 0x8a, 0xe6, 0x04, 0xff, 0x78, 0x8a, 0xa6, 0x07, 0xe5, //0x8340,
    0x1f, 0xb4, 0x01, 0x0a, 0xe6, 0x60, 0x03, 0x02, 0x04, 0xc0, 0x75, 0x1f, 0x02, 0x22, 0x12, 0x0c, //0x8350,
    0x7a, 0x78, 0x80, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x12, 0x0c, 0x7a, 0x78, 0x82, 0xa6, 0x06, 0x08, //0x8360,
    0xa6, 0x07, 0x78, 0x6e, 0xe6, 0x78, 0x8c, 0xf6, 0x78, 0x6e, 0xe6, 0x78, 0x8d, 0xf6, 0x7f, 0x01, //0x8370,
    0xef, 0x25, 0xe0, 0x24, 0x4f, 0xf9, 0xc3, 0x78, 0x81, 0xe6, 0x97, 0x18, 0xe6, 0x19, 0x97, 0x50, //0x8380,
    0x0a, 0x12, 0x0c, 0x82, 0x78, 0x80, 0xa6, 0x04, 0x08, 0xa6, 0x05, 0x74, 0x6e, 0x2f, 0xf9, 0x78, //0x8390,
    0x8c, 0xe6, 0xc3, 0x97, 0x50, 0x08, 0x74, 0x6e, 0x2f, 0xf8, 0xe6, 0x78, 0x8c, 0xf6, 0xef, 0x25, //0x83a0,
    0xe0, 0x24, 0x4f, 0xf9, 0xd3, 0x78, 0x83, 0xe6, 0x97, 0x18, 0xe6, 0x19, 0x97, 0x40, 0x0a, 0x12, //0x83b0,
    0x0c, 0x82, 0x78, 0x82, 0xa6, 0x04, 0x08, 0xa6, 0x05, 0x74, 0x6e, 0x2f, 0xf9, 0x78, 0x8d, 0xe6, //0x83c0,
    0xd3, 0x97, 0x40, 0x08, 0x74, 0x6e, 0x2f, 0xf8, 0xe6, 0x78, 0x8d, 0xf6, 0x0f, 0xef, 0x64, 0x10, //0x83d0,
    0x70, 0x9e, 0xc3, 0x79, 0x81, 0xe7, 0x78, 0x83, 0x96, 0xff, 0x19, 0xe7, 0x18, 0x96, 0x78, 0x84, //0x83e0,
    0xf6, 0x08, 0xa6, 0x07, 0xc3, 0x79, 0x8c, 0xe7, 0x78, 0x8d, 0x96, 0x08, 0xf6, 0xd3, 0x79, 0x81, //0x83f0,
    0xe7, 0x78, 0x7f, 0x96, 0x19, 0xe7, 0x18, 0x96, 0x40, 0x05, 0x09, 0xe7, 0x08, 0x80, 0x06, 0xc3, //0x8400,
    0x79, 0x7f, 0xe7, 0x78, 0x81, 0x96, 0xff, 0x19, 0xe7, 0x18, 0x96, 0xfe, 0x78, 0x86, 0xa6, 0x06, //0x8410,
    0x08, 0xa6, 0x07, 0x79, 0x8c, 0xe7, 0xd3, 0x78, 0x8b, 0x96, 0x40, 0x05, 0xe7, 0x96, 0xff, 0x80, //0x8420,
    0x08, 0xc3, 0x79, 0x8b, 0xe7, 0x78, 0x8c, 0x96, 0xff, 0x78, 0x8f, 0xa6, 0x07, 0xe5, 0x1f, 0x64, //0x8430,
    0x02, 0x70, 0x69, 0x90, 0x0e, 0x91, 0x93, 0xff, 0x18, 0xe6, 0xc3, 0x9f, 0x50, 0x72, 0x12, 0x0c, //0x8440,
    0x4a, 0x12, 0x0c, 0x2f, 0x90, 0x0e, 0x8e, 0x12, 0x0c, 0x38, 0x78, 0x80, 0x12, 0x0c, 0x6b, 0x7b, //0x8450,
    0x04, 0x12, 0x0c, 0x1d, 0xc3, 0x12, 0x06, 0x45, 0x50, 0x56, 0x90, 0x0e, 0x92, 0xe4, 0x93, 0xff, //0x8460,
    0x78, 0x8f, 0xe6, 0x9f, 0x40, 0x02, 0x80, 0x11, 0x90, 0x0e, 0x90, 0xe4, 0x93, 0xff, 0xd3, 0x78, //0x8470,
    0x89, 0xe6, 0x9f, 0x18, 0xe6, 0x94, 0x00, 0x40, 0x03, 0x75, 0x1f, 0x05, 0x12, 0x0c, 0x4a, 0x12, //0x8480,
    0x0c, 0x2f, 0x90, 0x0e, 0x8f, 0x12, 0x0c, 0x38, 0x78, 0x7e, 0x12, 0x0c, 0x6b, 0x7b, 0x40, 0x12, //0x8490,
    0x0c, 0x1d, 0xd3, 0x12, 0x06, 0x45, 0x40, 0x18, 0x75, 0x1f, 0x05, 0x22, 0xe5, 0x1f, 0xb4, 0x05, //0x84a0,
    0x0f, 0xd2, 0x01, 0xc2, 0x02, 0xe4, 0xf5, 0x1f, 0xf5, 0x1e, 0xd2, 0x35, 0xd2, 0x33, 0xd2, 0x36, //0x84b0,
    0x22, 0xef, 0x8d, 0xf0, 0xa4, 0xa8, 0xf0, 0xcf, 0x8c, 0xf0, 0xa4, 0x28, 0xce, 0x8d, 0xf0, 0xa4, //0x84c0,
    0x2e, 0xfe, 0x22, 0xbc, 0x00, 0x0b, 0xbe, 0x00, 0x29, 0xef, 0x8d, 0xf0, 0x84, 0xff, 0xad, 0xf0, //0x84d0,
    0x22, 0xe4, 0xcc, 0xf8, 0x75, 0xf0, 0x08, 0xef, 0x2f, 0xff, 0xee, 0x33, 0xfe, 0xec, 0x33, 0xfc, //0x84e0,
    0xee, 0x9d, 0xec, 0x98, 0x40, 0x05, 0xfc, 0xee, 0x9d, 0xfe, 0x0f, 0xd5, 0xf0, 0xe9, 0xe4, 0xce, //0x84f0,
    0xfd, 0x22, 0xed, 0xf8, 0xf5, 0xf0, 0xee, 0x84, 0x20, 0xd2, 0x1c, 0xfe, 0xad, 0xf0, 0x75, 0xf0, //0x8500,
    0x08, 0xef, 0x2f, 0xff, 0xed, 0x33, 0xfd, 0x40, 0x07, 0x98, 0x50, 0x06, 0xd5, 0xf0, 0xf2, 0x22, //0x8510,
    0xc3, 0x98, 0xfd, 0x0f, 0xd5, 0xf0, 0xea, 0x22, 0xe8, 0x8f, 0xf0, 0xa4, 0xcc, 0x8b, 0xf0, 0xa4, //0x8520,
    0x2c, 0xfc, 0xe9, 0x8e, 0xf0, 0xa4, 0x2c, 0xfc, 0x8a, 0xf0, 0xed, 0xa4, 0x2c, 0xfc, 0xea, 0x8e, //0x8530,
    0xf0, 0xa4, 0xcd, 0xa8, 0xf0, 0x8b, 0xf0, 0xa4, 0x2d, 0xcc, 0x38, 0x25, 0xf0, 0xfd, 0xe9, 0x8f, //0x8540,
    0xf0, 0xa4, 0x2c, 0xcd, 0x35, 0xf0, 0xfc, 0xeb, 0x8e, 0xf0, 0xa4, 0xfe, 0xa9, 0xf0, 0xeb, 0x8f, //0x8550,
    0xf0, 0xa4, 0xcf, 0xc5, 0xf0, 0x2e, 0xcd, 0x39, 0xfe, 0xe4, 0x3c, 0xfc, 0xea, 0xa4, 0x2d, 0xce, //0x8560,
    0x35, 0xf0, 0xfd, 0xe4, 0x3c, 0xfc, 0x22, 0x75, 0xf0, 0x08, 0x75, 0x82, 0x00, 0xef, 0x2f, 0xff, //0x8570,
    0xee, 0x33, 0xfe, 0xcd, 0x33, 0xcd, 0xcc, 0x33, 0xcc, 0xc5, 0x82, 0x33, 0xc5, 0x82, 0x9b, 0xed, //0x8580,
    0x9a, 0xec, 0x99, 0xe5, 0x82, 0x98, 0x40, 0x0c, 0xf5, 0x82, 0xee, 0x9b, 0xfe, 0xed, 0x9a, 0xfd, //0x8590,
    0xec, 0x99, 0xfc, 0x0f, 0xd5, 0xf0, 0xd6, 0xe4, 0xce, 0xfb, 0xe4, 0xcd, 0xfa, 0xe4, 0xcc, 0xf9, //0x85a0,
    0xa8, 0x82, 0x22, 0xb8, 0x00, 0xc1, 0xb9, 0x00, 0x59, 0xba, 0x00, 0x2d, 0xec, 0x8b, 0xf0, 0x84, //0x85b0,
    0xcf, 0xce, 0xcd, 0xfc, 0xe5, 0xf0, 0xcb, 0xf9, 0x78, 0x18, 0xef, 0x2f, 0xff, 0xee, 0x33, 0xfe, //0x85c0,
    0xed, 0x33, 0xfd, 0xec, 0x33, 0xfc, 0xeb, 0x33, 0xfb, 0x10, 0xd7, 0x03, 0x99, 0x40, 0x04, 0xeb, //0x85d0,
    0x99, 0xfb, 0x0f, 0xd8, 0xe5, 0xe4, 0xf9, 0xfa, 0x22, 0x78, 0x18, 0xef, 0x2f, 0xff, 0xee, 0x33, //0x85e0,
    0xfe, 0xed, 0x33, 0xfd, 0xec, 0x33, 0xfc, 0xc9, 0x33, 0xc9, 0x10, 0xd7, 0x05, 0x9b, 0xe9, 0x9a, //0x85f0,
    0x40, 0x07, 0xec, 0x9b, 0xfc, 0xe9, 0x9a, 0xf9, 0x0f, 0xd8, 0xe0, 0xe4, 0xc9, 0xfa, 0xe4, 0xcc, //0x8600,
    0xfb, 0x22, 0x75, 0xf0, 0x10, 0xef, 0x2f, 0xff, 0xee, 0x33, 0xfe, 0xed, 0x33, 0xfd, 0xcc, 0x33, //0x8610,
    0xcc, 0xc8, 0x33, 0xc8, 0x10, 0xd7, 0x07, 0x9b, 0xec, 0x9a, 0xe8, 0x99, 0x40, 0x0a, 0xed, 0x9b, //0x8620,
    0xfd, 0xec, 0x9a, 0xfc, 0xe8, 0x99, 0xf8, 0x0f, 0xd5, 0xf0, 0xda, 0xe4, 0xcd, 0xfb, 0xe4, 0xcc, //0x8630,
    0xfa, 0xe4, 0xc8, 0xf9, 0x22, 0xeb, 0x9f, 0xf5, 0xf0, 0xea, 0x9e, 0x42, 0xf0, 0xe9, 0x9d, 0x42, //0x8640,
    0xf0, 0xe8, 0x9c, 0x45, 0xf0, 0x22, 0xe8, 0x60, 0x0f, 0xec, 0xc3, 0x13, 0xfc, 0xed, 0x13, 0xfd, //0x8650,
    0xee, 0x13, 0xfe, 0xef, 0x13, 0xff, 0xd8, 0xf1, 0x22, 0xe8, 0x60, 0x0f, 0xef, 0xc3, 0x33, 0xff, //0x8660,
    0xee, 0x33, 0xfe, 0xed, 0x33, 0xfd, 0xec, 0x33, 0xfc, 0xd8, 0xf1, 0x22, 0xe4, 0x93, 0xfc, 0x74, //0x8670,
    0x01, 0x93, 0xfd, 0x74, 0x02, 0x93, 0xfe, 0x74, 0x03, 0x93, 0xff, 0x22, 0xe6, 0xfb, 0x08, 0xe6, //0x8680,
    0xf9, 0x08, 0xe6, 0xfa, 0x08, 0xe6, 0xcb, 0xf8, 0x22, 0xec, 0xf6, 0x08, 0xed, 0xf6, 0x08, 0xee, //0x8690,
    0xf6, 0x08, 0xef, 0xf6, 0x22, 0xa4, 0x25, 0x82, 0xf5, 0x82, 0xe5, 0xf0, 0x35, 0x83, 0xf5, 0x83, //0x86a0,
    0x22, 0xd0, 0x83, 0xd0, 0x82, 0xf8, 0xe4, 0x93, 0x70, 0x12, 0x74, 0x01, 0x93, 0x70, 0x0d, 0xa3, //0x86b0,
    0xa3, 0x93, 0xf8, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x88, 0x83, 0xe4, 0x73, 0x74, 0x02, 0x93, 0x68, //0x86c0,
    0x60, 0xef, 0xa3, 0xa3, 0xa3, 0x80, 0xdf, 0x90, 0x38, 0x04, 0x78, 0x52, 0x12, 0x0b, 0xfd, 0x90, //0x86d0,
    0x38, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xed, 0xff, 0xc3, 0x12, 0x0b, 0x9e, 0x90, 0x38, 0x10, //0x86e0,
    0x12, 0x0b, 0x92, 0x90, 0x38, 0x06, 0x78, 0x54, 0x12, 0x0b, 0xfd, 0x90, 0x38, 0x02, 0xe0, 0xfe, //0x86f0,
    0xa3, 0xe0, 0xfd, 0xed, 0xff, 0xc3, 0x12, 0x0b, 0x9e, 0x90, 0x38, 0x12, 0x12, 0x0b, 0x92, 0xa3, //0x8700,
    0xe0, 0xb4, 0x31, 0x07, 0x78, 0x52, 0x79, 0x52, 0x12, 0x0c, 0x13, 0x90, 0x38, 0x14, 0xe0, 0xb4, //0x8710,
    0x71, 0x15, 0x78, 0x52, 0xe6, 0xfe, 0x08, 0xe6, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, //0x8720,
    0xf9, 0x79, 0x53, 0xf7, 0xee, 0x19, 0xf7, 0x90, 0x38, 0x15, 0xe0, 0xb4, 0x31, 0x07, 0x78, 0x54, //0x8730,
    0x79, 0x54, 0x12, 0x0c, 0x13, 0x90, 0x38, 0x15, 0xe0, 0xb4, 0x71, 0x15, 0x78, 0x54, 0xe6, 0xfe, //0x8740,
    0x08, 0xe6, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x79, 0x55, 0xf7, 0xee, 0x19, //0x8750,
    0xf7, 0x79, 0x52, 0x12, 0x0b, 0xd9, 0x09, 0x12, 0x0b, 0xd9, 0xaf, 0x47, 0x12, 0x0b, 0xb2, 0xe5, //0x8760,
    0x44, 0xfb, 0x7a, 0x00, 0xfd, 0x7c, 0x00, 0x12, 0x04, 0xd3, 0x78, 0x5a, 0xa6, 0x06, 0x08, 0xa6, //0x8770,
    0x07, 0xaf, 0x45, 0x12, 0x0b, 0xb2, 0xad, 0x03, 0x7c, 0x00, 0x12, 0x04, 0xd3, 0x78, 0x56, 0xa6, //0x8780,
    0x06, 0x08, 0xa6, 0x07, 0xaf, 0x48, 0x78, 0x54, 0x12, 0x0b, 0xb4, 0xe5, 0x43, 0xfb, 0xfd, 0x7c, //0x8790,
    0x00, 0x12, 0x04, 0xd3, 0x78, 0x5c, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0xaf, 0x46, 0x7e, 0x00, 0x78, //0x87a0,
    0x54, 0x12, 0x0b, 0xb6, 0xad, 0x03, 0x7c, 0x00, 0x12, 0x04, 0xd3, 0x78, 0x58, 0xa6, 0x06, 0x08, //0x87b0,
    0xa6, 0x07, 0xc3, 0x78, 0x5b, 0xe6, 0x94, 0x08, 0x18, 0xe6, 0x94, 0x00, 0x50, 0x05, 0x76, 0x00, //0x87c0,
    0x08, 0x76, 0x08, 0xc3, 0x78, 0x5d, 0xe6, 0x94, 0x08, 0x18, 0xe6, 0x94, 0x00, 0x50, 0x05, 0x76, //0x87d0,
    0x00, 0x08, 0x76, 0x08, 0x78, 0x5a, 0x12, 0x0b, 0xc6, 0xff, 0xd3, 0x78, 0x57, 0xe6, 0x9f, 0x18, //0x87e0,
    0xe6, 0x9e, 0x40, 0x0e, 0x78, 0x5a, 0xe6, 0x13, 0xfe, 0x08, 0xe6, 0x78, 0x57, 0x12, 0x0c, 0x08, //0x87f0,
    0x80, 0x04, 0x7e, 0x00, 0x7f, 0x00, 0x78, 0x5e, 0x12, 0x0b, 0xbe, 0xff, 0xd3, 0x78, 0x59, 0xe6, //0x8800,
    0x9f, 0x18, 0xe6, 0x9e, 0x40, 0x0e, 0x78, 0x5c, 0xe6, 0x13, 0xfe, 0x08, 0xe6, 0x78, 0x59, 0x12, //0x8810,
    0x0c, 0x08, 0x80, 0x04, 0x7e, 0x00, 0x7f, 0x00, 0xe4, 0xfc, 0xfd, 0x78, 0x62, 0x12, 0x06, 0x99, //0x8820,
    0x78, 0x5a, 0x12, 0x0b, 0xc6, 0x78, 0x57, 0x26, 0xff, 0xee, 0x18, 0x36, 0xfe, 0x78, 0x66, 0x12, //0x8830,
    0x0b, 0xbe, 0x78, 0x59, 0x26, 0xff, 0xee, 0x18, 0x36, 0xfe, 0xe4, 0xfc, 0xfd, 0x78, 0x6a, 0x12, //0x8840,
    0x06, 0x99, 0x12, 0x0b, 0xce, 0x78, 0x66, 0x12, 0x06, 0x8c, 0xd3, 0x12, 0x06, 0x45, 0x40, 0x08, //0x8850,
    0x12, 0x0b, 0xce, 0x78, 0x66, 0x12, 0x06, 0x99, 0x78, 0x54, 0x12, 0x0b, 0xd0, 0x78, 0x6a, 0x12, //0x8860,
    0x06, 0x8c, 0xd3, 0x12, 0x06, 0x45, 0x40, 0x0a, 0x78, 0x54, 0x12, 0x0b, 0xd0, 0x78, 0x6a, 0x12, //0x8870,
    0x06, 0x99, 0x78, 0x61, 0xe6, 0x90, 0x60, 0x01, 0xf0, 0x78, 0x65, 0xe6, 0xa3, 0xf0, 0x78, 0x69, //0x8880,
    0xe6, 0xa3, 0xf0, 0x78, 0x55, 0xe6, 0xa3, 0xf0, 0x7d, 0x01, 0x78, 0x61, 0x12, 0x0b, 0xe9, 0x24, //0x8890,
    0x01, 0x12, 0x0b, 0xa6, 0x78, 0x65, 0x12, 0x0b, 0xe9, 0x24, 0x02, 0x12, 0x0b, 0xa6, 0x78, 0x69, //0x88a0,
    0x12, 0x0b, 0xe9, 0x24, 0x03, 0x12, 0x0b, 0xa6, 0x78, 0x6d, 0x12, 0x0b, 0xe9, 0x24, 0x04, 0x12, //0x88b0,
    0x0b, 0xa6, 0x0d, 0xbd, 0x05, 0xd4, 0xc2, 0x0e, 0xc2, 0x06, 0x22, 0x85, 0x08, 0x41, 0x90, 0x30, //0x88c0,
    0x24, 0xe0, 0xf5, 0x3d, 0xa3, 0xe0, 0xf5, 0x3e, 0xa3, 0xe0, 0xf5, 0x3f, 0xa3, 0xe0, 0xf5, 0x40, //0x88d0,
    0xa3, 0xe0, 0xf5, 0x3c, 0xd2, 0x34, 0xe5, 0x41, 0x12, 0x06, 0xb1, 0x09, 0x31, 0x03, 0x09, 0x35, //0x88e0,
    0x04, 0x09, 0x3b, 0x05, 0x09, 0x3e, 0x06, 0x09, 0x41, 0x07, 0x09, 0x4a, 0x08, 0x09, 0x5b, 0x12, //0x88f0,
    0x09, 0x73, 0x18, 0x09, 0x89, 0x19, 0x09, 0x5e, 0x1a, 0x09, 0x6a, 0x1b, 0x09, 0xad, 0x80, 0x09, //0x8900,
    0xb2, 0x81, 0x0a, 0x1d, 0x8f, 0x0a, 0x09, 0x90, 0x0a, 0x1d, 0x91, 0x0a, 0x1d, 0x92, 0x0a, 0x1d, //0x8910,
    0x93, 0x0a, 0x1d, 0x94, 0x0a, 0x1d, 0x98, 0x0a, 0x17, 0x9f, 0x0a, 0x1a, 0xec, 0x00, 0x00, 0x0a, //0x8920,
    0x38, 0x12, 0x0f, 0x74, 0x22, 0x12, 0x0f, 0x74, 0xd2, 0x03, 0x22, 0xd2, 0x03, 0x22, 0xc2, 0x03, //0x8930,
    0x22, 0xa2, 0x37, 0xe4, 0x33, 0xf5, 0x3c, 0x02, 0x0a, 0x1d, 0xc2, 0x01, 0xc2, 0x02, 0xc2, 0x03, //0x8940,
    0x12, 0x0d, 0x0d, 0x75, 0x1e, 0x70, 0xd2, 0x35, 0x02, 0x0a, 0x1d, 0x02, 0x0a, 0x04, 0x85, 0x40, //0x8950,
    0x4a, 0x85, 0x3c, 0x4b, 0x12, 0x0a, 0xff, 0x02, 0x0a, 0x1d, 0x85, 0x4a, 0x40, 0x85, 0x4b, 0x3c, //0x8960,
    0x02, 0x0a, 0x1d, 0xe4, 0xf5, 0x22, 0xf5, 0x23, 0x85, 0x40, 0x31, 0x85, 0x3f, 0x30, 0x85, 0x3e, //0x8970,
    0x2f, 0x85, 0x3d, 0x2e, 0x12, 0x0f, 0x46, 0x80, 0x1f, 0x75, 0x22, 0x00, 0x75, 0x23, 0x01, 0x74, //0x8980,
    0xff, 0xf5, 0x2d, 0xf5, 0x2c, 0xf5, 0x2b, 0xf5, 0x2a, 0x12, 0x0f, 0x46, 0x85, 0x2d, 0x40, 0x85, //0x8990,
    0x2c, 0x3f, 0x85, 0x2b, 0x3e, 0x85, 0x2a, 0x3d, 0xe4, 0xf5, 0x3c, 0x80, 0x70, 0x12, 0x0f, 0x16, //0x89a0,
    0x80, 0x6b, 0x85, 0x3d, 0x45, 0x85, 0x3e, 0x46, 0xe5, 0x47, 0xc3, 0x13, 0xff, 0xe5, 0x45, 0xc3, //0x89b0,
    0x9f, 0x50, 0x02, 0x8f, 0x45, 0xe5, 0x48, 0xc3, 0x13, 0xff, 0xe5, 0x46, 0xc3, 0x9f, 0x50, 0x02, //0x89c0,
    0x8f, 0x46, 0xe5, 0x47, 0xc3, 0x13, 0xff, 0xfd, 0xe5, 0x45, 0x2d, 0xfd, 0xe4, 0x33, 0xfc, 0xe5, //0x89d0,
    0x44, 0x12, 0x0f, 0x90, 0x40, 0x05, 0xe5, 0x44, 0x9f, 0xf5, 0x45, 0xe5, 0x48, 0xc3, 0x13, 0xff, //0x89e0,
    0xfd, 0xe5, 0x46, 0x2d, 0xfd, 0xe4, 0x33, 0xfc, 0xe5, 0x43, 0x12, 0x0f, 0x90, 0x40, 0x05, 0xe5, //0x89f0,
    0x43, 0x9f, 0xf5, 0x46, 0x12, 0x06, 0xd7, 0x80, 0x14, 0x85, 0x40, 0x48, 0x85, 0x3f, 0x47, 0x85, //0x8a00,
    0x3e, 0x46, 0x85, 0x3d, 0x45, 0x80, 0x06, 0x02, 0x06, 0xd7, 0x12, 0x0d, 0x7e, 0x90, 0x30, 0x24, //0x8a10,
    0xe5, 0x3d, 0xf0, 0xa3, 0xe5, 0x3e, 0xf0, 0xa3, 0xe5, 0x3f, 0xf0, 0xa3, 0xe5, 0x40, 0xf0, 0xa3, //0x8a20,
    0xe5, 0x3c, 0xf0, 0x90, 0x30, 0x23, 0xe4, 0xf0, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, //0x8a30,
    0xd0, 0x90, 0x3f, 0x0c, 0xe0, 0xf5, 0x32, 0xe5, 0x32, 0x30, 0xe3, 0x74, 0x30, 0x36, 0x66, 0x90, //0x8a40,
    0x60, 0x19, 0xe0, 0xf5, 0x0a, 0xa3, 0xe0, 0xf5, 0x0b, 0x90, 0x60, 0x1d, 0xe0, 0xf5, 0x14, 0xa3, //0x8a50,
    0xe0, 0xf5, 0x15, 0x90, 0x60, 0x21, 0xe0, 0xf5, 0x0c, 0xa3, 0xe0, 0xf5, 0x0d, 0x90, 0x60, 0x29, //0x8a60,
    0xe0, 0xf5, 0x0e, 0xa3, 0xe0, 0xf5, 0x0f, 0x90, 0x60, 0x31, 0xe0, 0xf5, 0x10, 0xa3, 0xe0, 0xf5, //0x8a70,
    0x11, 0x90, 0x60, 0x39, 0xe0, 0xf5, 0x12, 0xa3, 0xe0, 0xf5, 0x13, 0x30, 0x01, 0x06, 0x30, 0x33, //0x8a80,
    0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x09, 0x30, 0x02, 0x06, 0x30, 0x33, 0x03, 0xd3, 0x80, 0x01, //0x8a90,
    0xc3, 0x92, 0x0a, 0x30, 0x33, 0x0c, 0x30, 0x03, 0x09, 0x20, 0x02, 0x06, 0x20, 0x01, 0x03, 0xd3, //0x8aa0,
    0x80, 0x01, 0xc3, 0x92, 0x0b, 0x90, 0x30, 0x01, 0xe0, 0x44, 0x40, 0xf0, 0xe0, 0x54, 0xbf, 0xf0, //0x8ab0,
    0xe5, 0x32, 0x30, 0xe1, 0x14, 0x30, 0x34, 0x11, 0x90, 0x30, 0x22, 0xe0, 0xf5, 0x08, 0xe4, 0xf0, //0x8ac0,
    0x30, 0x00, 0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x08, 0xe5, 0x32, 0x30, 0xe5, 0x12, 0x90, 0x56, //0x8ad0,
    0xa1, 0xe0, 0xf5, 0x09, 0x30, 0x31, 0x09, 0x30, 0x05, 0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x0d, //0x8ae0,
    0x90, 0x3f, 0x0c, 0xe5, 0x32, 0xf0, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x90, //0x8af0,
    0x0e, 0x7e, 0xe4, 0x93, 0xfe, 0x74, 0x01, 0x93, 0xff, 0xc3, 0x90, 0x0e, 0x7c, 0x74, 0x01, 0x93, //0x8b00,
    0x9f, 0xff, 0xe4, 0x93, 0x9e, 0xfe, 0xe4, 0x8f, 0x3b, 0x8e, 0x3a, 0xf5, 0x39, 0xf5, 0x38, 0xab, //0x8b10,
    0x3b, 0xaa, 0x3a, 0xa9, 0x39, 0xa8, 0x38, 0xaf, 0x4b, 0xfc, 0xfd, 0xfe, 0x12, 0x05, 0x28, 0x12, //0x8b20,
    0x0d, 0xe1, 0xe4, 0x7b, 0xff, 0xfa, 0xf9, 0xf8, 0x12, 0x05, 0xb3, 0x12, 0x0d, 0xe1, 0x90, 0x0e, //0x8b30,
    0x69, 0xe4, 0x12, 0x0d, 0xf6, 0x12, 0x0d, 0xe1, 0xe4, 0x85, 0x4a, 0x37, 0xf5, 0x36, 0xf5, 0x35, //0x8b40,
    0xf5, 0x34, 0xaf, 0x37, 0xae, 0x36, 0xad, 0x35, 0xac, 0x34, 0xa3, 0x12, 0x0d, 0xf6, 0x8f, 0x37, //0x8b50,
    0x8e, 0x36, 0x8d, 0x35, 0x8c, 0x34, 0xe5, 0x3b, 0x45, 0x37, 0xf5, 0x3b, 0xe5, 0x3a, 0x45, 0x36, //0x8b60,
    0xf5, 0x3a, 0xe5, 0x39, 0x45, 0x35, 0xf5, 0x39, 0xe5, 0x38, 0x45, 0x34, 0xf5, 0x38, 0xe4, 0xf5, //0x8b70,
    0x22, 0xf5, 0x23, 0x85, 0x3b, 0x31, 0x85, 0x3a, 0x30, 0x85, 0x39, 0x2f, 0x85, 0x38, 0x2e, 0x02, //0x8b80,
    0x0f, 0x46, 0xe0, 0xa3, 0xe0, 0x75, 0xf0, 0x02, 0xa4, 0xff, 0xae, 0xf0, 0xc3, 0x08, 0xe6, 0x9f, //0x8b90,
    0xf6, 0x18, 0xe6, 0x9e, 0xf6, 0x22, 0xff, 0xe5, 0xf0, 0x34, 0x60, 0x8f, 0x82, 0xf5, 0x83, 0xec, //0x8ba0,
    0xf0, 0x22, 0x78, 0x52, 0x7e, 0x00, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x02, 0x04, 0xc1, 0xe4, 0xfc, //0x8bb0,
    0xfd, 0x12, 0x06, 0x99, 0x78, 0x5c, 0xe6, 0xc3, 0x13, 0xfe, 0x08, 0xe6, 0x13, 0x22, 0x78, 0x52, //0x8bc0,
    0xe6, 0xfe, 0x08, 0xe6, 0xff, 0xe4, 0xfc, 0xfd, 0x22, 0xe7, 0xc4, 0xf8, 0x54, 0xf0, 0xc8, 0x68, //0x8bd0,
    0xf7, 0x09, 0xe7, 0xc4, 0x54, 0x0f, 0x48, 0xf7, 0x22, 0xe6, 0xfc, 0xed, 0x75, 0xf0, 0x04, 0xa4, //0x8be0,
    0x22, 0x12, 0x06, 0x7c, 0x8f, 0x48, 0x8e, 0x47, 0x8d, 0x46, 0x8c, 0x45, 0x22, 0xe0, 0xfe, 0xa3, //0x8bf0,
    0xe0, 0xfd, 0xee, 0xf6, 0xed, 0x08, 0xf6, 0x22, 0x13, 0xff, 0xc3, 0xe6, 0x9f, 0xff, 0x18, 0xe6, //0x8c00,
    0x9e, 0xfe, 0x22, 0xe6, 0xc3, 0x13, 0xf7, 0x08, 0xe6, 0x13, 0x09, 0xf7, 0x22, 0xad, 0x39, 0xac, //0x8c10,
    0x38, 0xfa, 0xf9, 0xf8, 0x12, 0x05, 0x28, 0x8f, 0x3b, 0x8e, 0x3a, 0x8d, 0x39, 0x8c, 0x38, 0xab, //0x8c20,
    0x37, 0xaa, 0x36, 0xa9, 0x35, 0xa8, 0x34, 0x22, 0x93, 0xff, 0xe4, 0xfc, 0xfd, 0xfe, 0x12, 0x05, //0x8c30,
    0x28, 0x8f, 0x37, 0x8e, 0x36, 0x8d, 0x35, 0x8c, 0x34, 0x22, 0x78, 0x84, 0xe6, 0xfe, 0x08, 0xe6, //0x8c40,
    0xff, 0xe4, 0x8f, 0x37, 0x8e, 0x36, 0xf5, 0x35, 0xf5, 0x34, 0x22, 0x90, 0x0e, 0x8c, 0xe4, 0x93, //0x8c50,
    0x25, 0xe0, 0x24, 0x0a, 0xf8, 0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe6, 0xfe, 0x08, 0xe6, 0xff, //0x8c60,
    0xe4, 0x8f, 0x3b, 0x8e, 0x3a, 0xf5, 0x39, 0xf5, 0x38, 0x22, 0x78, 0x4e, 0xe6, 0xfe, 0x08, 0xe6, //0x8c70,
    0xff, 0x22, 0xef, 0x25, 0xe0, 0x24, 0x4e, 0xf8, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x22, 0x78, 0x89, //0x8c80,
    0xef, 0x26, 0xf6, 0x18, 0xe4, 0x36, 0xf6, 0x22, 0x75, 0x89, 0x03, 0x75, 0xa8, 0x01, 0x75, 0xb8, //0x8c90,
    0x04, 0x75, 0x34, 0xff, 0x75, 0x35, 0x0e, 0x75, 0x36, 0x15, 0x75, 0x37, 0x0d, 0x12, 0x0e, 0x9a, //0x8ca0,
    0x12, 0x00, 0x09, 0x12, 0x0f, 0x16, 0x12, 0x00, 0x06, 0xd2, 0x00, 0xd2, 0x34, 0xd2, 0xaf, 0x75, //0x8cb0,
    0x34, 0xff, 0x75, 0x35, 0x0e, 0x75, 0x36, 0x49, 0x75, 0x37, 0x03, 0x12, 0x0e, 0x9a, 0x30, 0x08, //0x8cc0,
    0x09, 0xc2, 0x34, 0x12, 0x08, 0xcb, 0xc2, 0x08, 0xd2, 0x34, 0x30, 0x0b, 0x09, 0xc2, 0x36, 0x12, //0x8cd0,
    0x02, 0x6c, 0xc2, 0x0b, 0xd2, 0x36, 0x30, 0x09, 0x09, 0xc2, 0x36, 0x12, 0x00, 0x0e, 0xc2, 0x09, //0x8ce0,
    0xd2, 0x36, 0x30, 0x0e, 0x03, 0x12, 0x06, 0xd7, 0x30, 0x35, 0xd3, 0x90, 0x30, 0x29, 0xe5, 0x1e, //0x8cf0,
    0xf0, 0xb4, 0x10, 0x05, 0x90, 0x30, 0x23, 0xe4, 0xf0, 0xc2, 0x35, 0x80, 0xc1, 0xe4, 0xf5, 0x4b, //0x8d00,
    0x90, 0x0e, 0x7a, 0x93, 0xff, 0xe4, 0x8f, 0x37, 0xf5, 0x36, 0xf5, 0x35, 0xf5, 0x34, 0xaf, 0x37, //0x8d10,
    0xae, 0x36, 0xad, 0x35, 0xac, 0x34, 0x90, 0x0e, 0x6a, 0x12, 0x0d, 0xf6, 0x8f, 0x37, 0x8e, 0x36, //0x8d20,
    0x8d, 0x35, 0x8c, 0x34, 0x90, 0x0e, 0x72, 0x12, 0x06, 0x7c, 0xef, 0x45, 0x37, 0xf5, 0x37, 0xee, //0x8d30,
    0x45, 0x36, 0xf5, 0x36, 0xed, 0x45, 0x35, 0xf5, 0x35, 0xec, 0x45, 0x34, 0xf5, 0x34, 0xe4, 0xf5, //0x8d40,
    0x22, 0xf5, 0x23, 0x85, 0x37, 0x31, 0x85, 0x36, 0x30, 0x85, 0x35, 0x2f, 0x85, 0x34, 0x2e, 0x12, //0x8d50,
    0x0f, 0x46, 0xe4, 0xf5, 0x22, 0xf5, 0x23, 0x90, 0x0e, 0x72, 0x12, 0x0d, 0xea, 0x12, 0x0f, 0x46, //0x8d60,
    0xe4, 0xf5, 0x22, 0xf5, 0x23, 0x90, 0x0e, 0x6e, 0x12, 0x0d, 0xea, 0x02, 0x0f, 0x46, 0xe5, 0x40, //0x8d70,
    0x24, 0xf2, 0xf5, 0x37, 0xe5, 0x3f, 0x34, 0x43, 0xf5, 0x36, 0xe5, 0x3e, 0x34, 0xa2, 0xf5, 0x35, //0x8d80,
    0xe5, 0x3d, 0x34, 0x28, 0xf5, 0x34, 0xe5, 0x37, 0xff, 0xe4, 0xfe, 0xfd, 0xfc, 0x78, 0x18, 0x12, //0x8d90,
    0x06, 0x69, 0x8f, 0x40, 0x8e, 0x3f, 0x8d, 0x3e, 0x8c, 0x3d, 0xe5, 0x37, 0x54, 0xa0, 0xff, 0xe5, //0x8da0,
    0x36, 0xfe, 0xe4, 0xfd, 0xfc, 0x78, 0x07, 0x12, 0x06, 0x56, 0x78, 0x10, 0x12, 0x0f, 0x9a, 0xe4, //0x8db0,
    0xff, 0xfe, 0xe5, 0x35, 0xfd, 0xe4, 0xfc, 0x78, 0x0e, 0x12, 0x06, 0x56, 0x12, 0x0f, 0x9d, 0xe4, //0x8dc0,
    0xff, 0xfe, 0xfd, 0xe5, 0x34, 0xfc, 0x78, 0x18, 0x12, 0x06, 0x56, 0x78, 0x08, 0x12, 0x0f, 0x9a, //0x8dd0,
    0x22, 0x8f, 0x3b, 0x8e, 0x3a, 0x8d, 0x39, 0x8c, 0x38, 0x22, 0x12, 0x06, 0x7c, 0x8f, 0x31, 0x8e, //0x8de0,
    0x30, 0x8d, 0x2f, 0x8c, 0x2e, 0x22, 0x93, 0xf9, 0xf8, 0x02, 0x06, 0x69, 0x00, 0x00, 0x00, 0x00, //0x8df0,
    0x12, 0x01, 0x17, 0x08, 0x31, 0x15, 0x53, 0x54, 0x44, 0x20, 0x20, 0x20, 0x20, 0x20, 0x13, 0x01, //0x8e00,
    0x10, 0x01, 0x56, 0x40, 0x1a, 0x30, 0x29, 0x7e, 0x00, 0x30, 0x04, 0x20, 0xdf, 0x30, 0x05, 0x40, //0x8e10,
    0xbf, 0x50, 0x03, 0x00, 0xfd, 0x50, 0x27, 0x01, 0xfe, 0x60, 0x00, 0x11, 0x00, 0x3f, 0x05, 0x30, //0x8e20,
    0x00, 0x3f, 0x06, 0x22, 0x00, 0x3f, 0x01, 0x2a, 0x00, 0x3f, 0x02, 0x00, 0x00, 0x36, 0x06, 0x07, //0x8e30,
    0x00, 0x3f, 0x0b, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x30, 0x01, 0x40, 0xbf, 0x30, 0x01, 0x00, //0x8e40,
    0xbf, 0x30, 0x29, 0x70, 0x00, 0x3a, 0x00, 0x00, 0xff, 0x3a, 0x00, 0x00, 0xff, 0x36, 0x03, 0x36, //0x8e50,
    0x02, 0x41, 0x44, 0x58, 0x20, 0x18, 0x10, 0x0a, 0x04, 0x04, 0x00, 0x03, 0xff, 0x64, 0x00, 0x00, //0x8e60,
    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x06, 0x06, 0x00, 0x03, 0x51, 0x00, 0x7a, //0x8e70,
    0x50, 0x3c, 0x28, 0x1e, 0x10, 0x10, 0x50, 0x2d, 0x28, 0x16, 0x10, 0x10, 0x02, 0x00, 0x10, 0x0c, //0x8e80,
    0x10, 0x04, 0x0c, 0x6e, 0x06, 0x05, 0x00, 0xa5, 0x5a, 0x00, 0xae, 0x35, 0xaf, 0x36, 0xe4, 0xfd, //0x8e90,
    0xed, 0xc3, 0x95, 0x37, 0x50, 0x33, 0x12, 0x0f, 0xe2, 0xe4, 0x93, 0xf5, 0x38, 0x74, 0x01, 0x93, //0x8ea0,
    0xf5, 0x39, 0x45, 0x38, 0x60, 0x23, 0x85, 0x39, 0x82, 0x85, 0x38, 0x83, 0xe0, 0xfc, 0x12, 0x0f, //0x8eb0,
    0xe2, 0x74, 0x03, 0x93, 0x52, 0x04, 0x12, 0x0f, 0xe2, 0x74, 0x02, 0x93, 0x42, 0x04, 0x85, 0x39, //0x8ec0,
    0x82, 0x85, 0x38, 0x83, 0xec, 0xf0, 0x0d, 0x80, 0xc7, 0x22, 0x78, 0xbe, 0xe6, 0xd3, 0x08, 0xff, //0x8ed0,
    0xe6, 0x64, 0x80, 0xf8, 0xef, 0x64, 0x80, 0x98, 0x22, 0x93, 0xff, 0x7e, 0x00, 0xe6, 0xfc, 0x08, //0x8ee0,
    0xe6, 0xfd, 0x12, 0x04, 0xc1, 0x78, 0xc1, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0xd3, 0xef, 0x9d, 0xee, //0x8ef0,
    0x9c, 0x22, 0x78, 0xbd, 0xd3, 0xe6, 0x64, 0x80, 0x94, 0x80, 0x22, 0x25, 0xe0, 0x24, 0x0a, 0xf8, //0x8f00,
    0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe5, 0x3c, 0xd3, 0x94, 0x00, 0x40, 0x0b, 0x90, 0x0e, 0x88, //0x8f10,
    0x12, 0x0b, 0xf1, 0x90, 0x0e, 0x86, 0x80, 0x09, 0x90, 0x0e, 0x82, 0x12, 0x0b, 0xf1, 0x90, 0x0e, //0x8f20,
    0x80, 0xe4, 0x93, 0xf5, 0x44, 0xa3, 0xe4, 0x93, 0xf5, 0x43, 0xd2, 0x06, 0x30, 0x06, 0x03, 0xd3, //0x8f30,
    0x80, 0x01, 0xc3, 0x92, 0x0e, 0x22, 0xa2, 0xaf, 0x92, 0x32, 0xc2, 0xaf, 0xe5, 0x23, 0x45, 0x22, //0x8f40,
    0x90, 0x0e, 0x5d, 0x60, 0x0e, 0x12, 0x0f, 0xcb, 0xe0, 0xf5, 0x2c, 0x12, 0x0f, 0xc8, 0xe0, 0xf5, //0x8f50,
    0x2d, 0x80, 0x0c, 0x12, 0x0f, 0xcb, 0xe5, 0x30, 0xf0, 0x12, 0x0f, 0xc8, 0xe5, 0x31, 0xf0, 0xa2, //0x8f60,
    0x32, 0x92, 0xaf, 0x22, 0xd2, 0x01, 0xc2, 0x02, 0xe4, 0xf5, 0x1f, 0xf5, 0x1e, 0xd2, 0x35, 0xd2, //0x8f70,
    0x33, 0xd2, 0x36, 0xd2, 0x01, 0xc2, 0x02, 0xf5, 0x1f, 0xf5, 0x1e, 0xd2, 0x35, 0xd2, 0x33, 0x22, //0x8f80,
    0xfb, 0xd3, 0xed, 0x9b, 0x74, 0x80, 0xf8, 0x6c, 0x98, 0x22, 0x12, 0x06, 0x69, 0xe5, 0x40, 0x2f, //0x8f90,
    0xf5, 0x40, 0xe5, 0x3f, 0x3e, 0xf5, 0x3f, 0xe5, 0x3e, 0x3d, 0xf5, 0x3e, 0xe5, 0x3d, 0x3c, 0xf5, //0x8fa0,
    0x3d, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0x90, 0x3f, 0x0d, 0xe0, 0xf5, 0x33, 0xe5, 0x33, //0x8fb0,
    0xf0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x90, 0x0e, 0x5f, 0xe4, 0x93, 0xfe, 0x74, 0x01, //0x8fc0,
    0x93, 0xf5, 0x82, 0x8e, 0x83, 0x22, 0x78, 0x7f, 0xe4, 0xf6, 0xd8, 0xfd, 0x75, 0x81, 0xcd, 0x02, //0x8fd0,
    0x0c, 0x98, 0x8f, 0x82, 0x8e, 0x83, 0x75, 0xf0, 0x04, 0xed, 0x02, 0x06, 0xa5,                   //0x8fe0
};
#define SENSORDB(fmt, arg...)  printk(fmt, ##arg)
static struct timeval OV5640YUV_ktv1, OV5640YUV_ktv2;
struct i2c_client * g_client=NULL;
#define UINT32  unsigned int
#define  UINT8  u8
typedef enum
{
    OV5640_720P,       //1M 1280x960
    OV5640_5M,     //5M 2592x1944
} OV5640_RES_TYPE;
OV5640_RES_TYPE OV5640YUV_g_RES=OV5640_720P;
typedef enum
{
    OV5640_MODE_PREVIEW,  //1M      1280x960
    OV5640_MODE_CAPTURE   //5M    2592x1944
} OV5640_MODE;
OV5640_MODE g_iOV5640YUV_Mode=OV5640_MODE_PREVIEW;
#define KAL_FALSE false
#define KAL_TRUE  true
#define kal_uint32  unsigned int
#define kal_uint16  u16
#define kal_uint8  unsigned char
#define UINT16  u16
#define UINT8   unsigned char
#define  kal_bool  bool
#define Sleep   msleep
UINT8 OV5640YUVPixelClockDivider=0;
kal_uint32 OV5640YUV_sensor_pclk=56000000;
kal_uint32 OV5640YUV_PV_pclk = 5600;
kal_uint32 OV5640YUV_CAP_pclk = 5600;
kal_uint16 OV5640YUV_pv_exposure_lines=0x100,OV5640YUV_g_iBackupExtraExp = 0,OV5640YUV_extra_exposure_lines = 0;
kal_uint16 OV5640YUV_sensor_id=0;
//MSDK_SENSOR_CONFIG_STRUCT OV5640YUVSensorConfigData;
kal_uint32 OV5640YUV_FAC_SENSOR_REG;
kal_uint16 OV5640YUV_sensor_flip_value;
//liuxinming add
kal_uint32 back_shutter = 0;
kal_uint32 back_pv_gain = 0;
kal_uint32 tem = 0;
bool  OV5640YUV_MPEG4_encode_mode = KAL_FALSE;
bool  OV5640YUV_night_mode = KAL_FALSE;
#define  ERROR_NONE  1
inline void OV5640YUV_imgSensorProfileStart(void)
{
    do_gettimeofday(&OV5640YUV_ktv1);
}
inline void OV5640YUV_imgSensorProfileEnd(char *tag)
{
    unsigned long TimeIntervalUS;
    do_gettimeofday(&OV5640YUV_ktv2);
    TimeIntervalUS = (OV5640YUV_ktv2.tv_sec - OV5640YUV_ktv1.tv_sec) * 1000000 + (OV5640YUV_ktv2.tv_usec - OV5640YUV_ktv1.tv_usec);
    SENSORDB("[%s]Profile = %lu\n",tag, TimeIntervalUS);
}
u8  OV5640YUV_read_cmos_sensor(u16 addr)
{
    unsigned char value=0;
     i2cc_get_reg(g_client,addr,&value);
     return value;
}
void OV5640YUV_write_cmos_sensor(u16 addr,u32 param)
{
      i2cc_set_reg(g_client,addr,param);
}
static void OV5640_FOCUS_AD5820_Check_MCU()
{
    u8 check[13] = {0x00};
    //mcu on
    check[0] = OV5640YUV_read_cmos_sensor(0x3000);
    check[1] = OV5640YUV_read_cmos_sensor(0x3004);
    //soft reset of mcu
    check[2] = OV5640YUV_read_cmos_sensor(0x3f00);
    //afc on
    check[3] = OV5640YUV_read_cmos_sensor(0x3001);
    check[4] = OV5640YUV_read_cmos_sensor(0x3005);
    //gpio1,gpio2
    check[5] = OV5640YUV_read_cmos_sensor(0x3018);
    check[6] = OV5640YUV_read_cmos_sensor(0x301e);
    check[7] = OV5640YUV_read_cmos_sensor(0x301b);
    check[8] = OV5640YUV_read_cmos_sensor(0x3042);
    //y0
    check[9] = OV5640YUV_read_cmos_sensor(0x3018);
    check[10] = OV5640YUV_read_cmos_sensor(0x301e);
    check[11] = OV5640YUV_read_cmos_sensor(0x301b);
    check[12] = OV5640YUV_read_cmos_sensor(0x3042);
    int i = 0;
    for(i = 0; i < 13; i++)
        SENSORDB("check[%d]=0x%x\n", i, check[i]);
}
static void OV5640_FOCUS_AD5820_Init(void)
{
    u8 state=0x8F;
    unsigned int  iteration = 100;
    int totalCnt = 0;
    int sentCnt = 0;
    int index=0;
    u16 addr = 0x8000;
    u8 buf[256];
    int len = 128;
  //  OV5640YUV_imgSensorProfileStart();
    OV5640YUV_write_cmos_sensor(0x3000, 0x20);
    totalCnt = ARRAY_SIZE(AD5820_Config);
#if 0//Brust mode
    while (index < totalCnt) {
        sentCnt = totalCnt - index > len  ? len  : totalCnt - index;
        buf[0] = addr >> 8;
        buf[1] = addr & 0xff;
        memcpy(&buf[2], &AD5820_Config[index], len );
        OV5640YUV_multi_write_cmos_sensor(buf, sentCnt + 2);
        addr += len ;
        index += len ;
    }
#else//single mode
    for(sentCnt =0; sentCnt<totalCnt; sentCnt++)
    {
        OV5640YUV_write_cmos_sensor(addr,AD5820_Config[sentCnt]);
        addr++;
    }
#endif
    mdelay(10);
    OV5640YUV_write_cmos_sensor(0x3022, 0x00);
    OV5640YUV_write_cmos_sensor(0x3023, 0x00);
    OV5640YUV_write_cmos_sensor(0x3024, 0x00);
    OV5640YUV_write_cmos_sensor(0x3025, 0x00);
    OV5640YUV_write_cmos_sensor(0x3026, 0x00);
    OV5640YUV_write_cmos_sensor(0x3027, 0x00);
    OV5640YUV_write_cmos_sensor(0x3028, 0x00);
    OV5640YUV_write_cmos_sensor(0x3029, 0x7f);
    OV5640YUV_write_cmos_sensor(0x3000, 0x00);
    do {
        state = (u8)OV5640YUV_read_cmos_sensor(0x3029);
        mdelay(5);
        if (iteration-- == 0)
        {
            break;
        }
    } while(state!=0x70);
    OV5640YUV_imgSensorProfileEnd("OV5640_FOCUS_AD5820_Init");
    OV5640_FOCUS_AD5820_Check_MCU();
    return;
}   /*  OV5640_FOCUS_AD5820_Init  */
void OV5640YUV_Sensor_Dvp_Init(void)
{
    OV5640YUV_write_cmos_sensor(0x4740, 0x20);//liuxinming
    OV5640YUV_write_cmos_sensor(0x3008, 0x42);
    OV5640YUV_write_cmos_sensor(0x3103, 0x03);
    OV5640YUV_write_cmos_sensor(0x3017, 0x7f);
    OV5640YUV_write_cmos_sensor(0x3018, 0xff);
    OV5640YUV_write_cmos_sensor(0x302c, 0x82);
    OV5640YUV_write_cmos_sensor(0x3108, 0x01);
    OV5640YUV_write_cmos_sensor(0x3630, 0x2e);//2e
    OV5640YUV_write_cmos_sensor(0x3632, 0xe2);
    OV5640YUV_write_cmos_sensor(0x3633, 0x23);//23
    OV5640YUV_write_cmos_sensor(0x3621, 0xe0);
    OV5640YUV_write_cmos_sensor(0x3704, 0xa0);
    OV5640YUV_write_cmos_sensor(0x3703, 0x5a);
    OV5640YUV_write_cmos_sensor(0x3715, 0x78);
    OV5640YUV_write_cmos_sensor(0x3717, 0x01);
    OV5640YUV_write_cmos_sensor(0x370b, 0x60);
    OV5640YUV_write_cmos_sensor(0x3705, 0x1a);
    OV5640YUV_write_cmos_sensor(0x3905, 0x02);
    OV5640YUV_write_cmos_sensor(0x3906, 0x10);
    OV5640YUV_write_cmos_sensor(0x3901, 0x0a);
    OV5640YUV_write_cmos_sensor(0x3731, 0x12);
    OV5640YUV_write_cmos_sensor(0x3600, 0x08);
    OV5640YUV_write_cmos_sensor(0x3601, 0x33);
    OV5640YUV_write_cmos_sensor(0x302d, 0x60);
    OV5640YUV_write_cmos_sensor(0x3620, 0x52);
    OV5640YUV_write_cmos_sensor(0x371b, 0x20);
    OV5640YUV_write_cmos_sensor(0x471c, 0x50);
    OV5640YUV_write_cmos_sensor(0x3a18, 0x00);
    OV5640YUV_write_cmos_sensor(0x3a19, 0xf8);
    OV5640YUV_write_cmos_sensor(0x3635, 0x1c);//1c
    OV5640YUV_write_cmos_sensor(0x3634, 0x40);
    OV5640YUV_write_cmos_sensor(0x3622, 0x01);
    OV5640YUV_write_cmos_sensor(0x3c04, 0x28);
    OV5640YUV_write_cmos_sensor(0x3c05, 0x98);
    OV5640YUV_write_cmos_sensor(0x3c06, 0x00);
    OV5640YUV_write_cmos_sensor(0x3c07, 0x08);
    OV5640YUV_write_cmos_sensor(0x3c08, 0x00);
    OV5640YUV_write_cmos_sensor(0x3c09, 0x1c);
    OV5640YUV_write_cmos_sensor(0x3c0a, 0x9c);
    OV5640YUV_write_cmos_sensor(0x3c0b, 0x40);
  //  OV5640YUV_write_cmos_sensor(0x3820, 0x47);
   // OV5640YUV_write_cmos_sensor(0x3821, 0x01);
    //dg add 2015-07-24 for stop flip & mirror image
    OV5640YUV_write_cmos_sensor(0x3820, 0x40);
    OV5640YUV_write_cmos_sensor(0x3821, 0x06);
    //windows setup
    OV5640YUV_write_cmos_sensor(0x3800, 0x00);
    OV5640YUV_write_cmos_sensor(0x3801, 0x00);
    OV5640YUV_write_cmos_sensor(0x3802, 0x00);
    OV5640YUV_write_cmos_sensor(0x3803, 0x04);
    //dg add  2015-07-25 to adjust X_AADR_END long for image windeos show
    OV5640YUV_write_cmos_sensor(0x3804, 0x0a);
    OV5640YUV_write_cmos_sensor(0x3805, 0x5f); //3f-5f->Good
    OV5640YUV_write_cmos_sensor(0x3806, 0x07);
    OV5640YUV_write_cmos_sensor(0x3807, 0x9b);
#if 1
    OV5640YUV_write_cmos_sensor(0x3808, 0x05);//1280
    OV5640YUV_write_cmos_sensor(0x3809, 0x00);
    OV5640YUV_write_cmos_sensor(0x380a, 0x03);//960
    OV5640YUV_write_cmos_sensor(0x380b, 0xc0);
#else
    OV5640YUV_write_cmos_sensor(0x3808, 0x05);
    OV5640YUV_write_cmos_sensor(0x3809, 0x80);
    OV5640YUV_write_cmos_sensor(0x380a, 0x01);
    OV5640YUV_write_cmos_sensor(0x380b, 0xe0);
#endif
    //OV5640YUV_write_cmos_sensor(0x3810, 0x00);
   // OV5640YUV_write_cmos_sensor(0x3811, 0x10);
    //dg add  2015-07-25 to adjust X OFFSET position coordinate for image windeos show
    OV5640YUV_write_cmos_sensor(0x3810, 0x00); // 00->01->00
    OV5640YUV_write_cmos_sensor(0x3811, 0xED); // 10->00->F0->EF->EE->ED->Good
    OV5640YUV_write_cmos_sensor(0x3812, 0x00);
    OV5640YUV_write_cmos_sensor(0x3813, 0x06);
    OV5640YUV_write_cmos_sensor(0x3814, 0x31);
    OV5640YUV_write_cmos_sensor(0x3815, 0x31);
    OV5640YUV_write_cmos_sensor(0x3034, 0x1a);
    OV5640YUV_write_cmos_sensor(0x3035, 0x21); //15fps
    OV5640YUV_write_cmos_sensor(0x3036, 0x46);
    OV5640YUV_write_cmos_sensor(0x3037, 0x13);
    OV5640YUV_write_cmos_sensor(0x3038, 0x00);
    OV5640YUV_write_cmos_sensor(0x3039, 0x00);
    OV5640YUV_write_cmos_sensor(0x380c, 0x07);
    OV5640YUV_write_cmos_sensor(0x380d, 0x68);
    OV5640YUV_write_cmos_sensor(0x380e, 0x03); //03
    OV5640YUV_write_cmos_sensor(0x380f, 0xd8); //d8
    OV5640YUV_write_cmos_sensor(0x3c01, 0xb4);
    OV5640YUV_write_cmos_sensor(0x3c00, 0x04);
    OV5640YUV_write_cmos_sensor(0x3a08, 0x00);
    OV5640YUV_write_cmos_sensor(0x3a09, 0x93);
    OV5640YUV_write_cmos_sensor(0x3a0e, 0x06);
    OV5640YUV_write_cmos_sensor(0x3a0a, 0x00);
    OV5640YUV_write_cmos_sensor(0x3a0b, 0x7b);
    OV5640YUV_write_cmos_sensor(0x3a0d, 0x08);
    OV5640YUV_write_cmos_sensor(0x3a00, 0x38); //25fps-20fps
    OV5640YUV_write_cmos_sensor(0x3a02, 0x03);
    OV5640YUV_write_cmos_sensor(0x3a03, 0xd8);
    OV5640YUV_write_cmos_sensor(0x3a14, 0x03);
    OV5640YUV_write_cmos_sensor(0x3a15, 0xd8);
    OV5640YUV_write_cmos_sensor(0x3618, 0x00);
    OV5640YUV_write_cmos_sensor(0x3612, 0x29);
    OV5640YUV_write_cmos_sensor(0x3708, 0x64);
    OV5640YUV_write_cmos_sensor(0x3709, 0x52);
    OV5640YUV_write_cmos_sensor(0x370c, 0x03);
    OV5640YUV_write_cmos_sensor(0x4001, 0x02);
    OV5640YUV_write_cmos_sensor(0x4004, 0x02);
    OV5640YUV_write_cmos_sensor(0x3000, 0x00);
    OV5640YUV_write_cmos_sensor(0x3002, 0x1c);
    OV5640YUV_write_cmos_sensor(0x3004, 0xff);
    OV5640YUV_write_cmos_sensor(0x3006, 0xc3);
    OV5640YUV_write_cmos_sensor(0x300e, 0x58);
    OV5640YUV_write_cmos_sensor(0x302e, 0x00);
     //OV5640YUV_write_cmos_sensor(0x4300, 0x30);
     OV5640YUV_write_cmos_sensor(0x4300, 0x32); //dg changge from 0x30->0x33
    OV5640YUV_write_cmos_sensor(0x501f, 0x00);
    OV5640YUV_write_cmos_sensor(0x4713, 0x03);
    OV5640YUV_write_cmos_sensor(0x4407, 0x04);
    OV5640YUV_write_cmos_sensor(0x460b, 0x35);
    OV5640YUV_write_cmos_sensor(0x460c, 0x22);//add by bright
    OV5640YUV_write_cmos_sensor(0x3824, 0x01);//add by bright
    OV5640YUV_write_cmos_sensor(0x5001, 0xa3);
    OV5640YUV_write_cmos_sensor(0x3406, 0x01);//awbinit
    OV5640YUV_write_cmos_sensor(0x3400, 0x06);
    OV5640YUV_write_cmos_sensor(0x3401, 0x80);
    OV5640YUV_write_cmos_sensor(0x3402, 0x04);
    OV5640YUV_write_cmos_sensor(0x3403, 0x00);
    OV5640YUV_write_cmos_sensor(0x3404, 0x06);
    OV5640YUV_write_cmos_sensor(0x3405, 0x00);
    //awb
    OV5640YUV_write_cmos_sensor(0x5180, 0xff);
    OV5640YUV_write_cmos_sensor(0x5181, 0xf2);
    OV5640YUV_write_cmos_sensor(0x5182, 0x00);
    OV5640YUV_write_cmos_sensor(0x5183, 0x14);
    OV5640YUV_write_cmos_sensor(0x5184, 0x25);
    OV5640YUV_write_cmos_sensor(0x5185, 0x24);
    OV5640YUV_write_cmos_sensor(0x5186, 0x16);
    OV5640YUV_write_cmos_sensor(0x5187, 0x16);
    OV5640YUV_write_cmos_sensor(0x5188, 0x16);
    OV5640YUV_write_cmos_sensor(0x5189, 0x72);
    OV5640YUV_write_cmos_sensor(0x518a, 0x68);
    OV5640YUV_write_cmos_sensor(0x518b, 0xf0);
    OV5640YUV_write_cmos_sensor(0x518c, 0xb2);
    OV5640YUV_write_cmos_sensor(0x518d, 0x50);
    OV5640YUV_write_cmos_sensor(0x518e, 0x30);
    OV5640YUV_write_cmos_sensor(0x518f, 0x30);
    OV5640YUV_write_cmos_sensor(0x5190, 0x50);
    OV5640YUV_write_cmos_sensor(0x5191, 0xf8);
    OV5640YUV_write_cmos_sensor(0x5192, 0x04);
    OV5640YUV_write_cmos_sensor(0x5193, 0x70);
    OV5640YUV_write_cmos_sensor(0x5194, 0xf0);
    OV5640YUV_write_cmos_sensor(0x5195, 0xf0);
    OV5640YUV_write_cmos_sensor(0x5196, 0x03);
    OV5640YUV_write_cmos_sensor(0x5197, 0x01);
    OV5640YUV_write_cmos_sensor(0x5198, 0x04);
    OV5640YUV_write_cmos_sensor(0x5199, 0x12);
    OV5640YUV_write_cmos_sensor(0x519a, 0x04);
    OV5640YUV_write_cmos_sensor(0x519b, 0x00);
    OV5640YUV_write_cmos_sensor(0x519c, 0x06);
    OV5640YUV_write_cmos_sensor(0x519d, 0x82);
    OV5640YUV_write_cmos_sensor(0x519e, 0x38);
    //color matrix
    OV5640YUV_write_cmos_sensor(0x5381, 0x1e);
    OV5640YUV_write_cmos_sensor(0x5382, 0x5b);
    OV5640YUV_write_cmos_sensor(0x5383, 0x14);
    OV5640YUV_write_cmos_sensor(0x5384, 0x06);
    OV5640YUV_write_cmos_sensor(0x5385, 0x82);
    OV5640YUV_write_cmos_sensor(0x5386, 0x88);
    OV5640YUV_write_cmos_sensor(0x5387, 0x7c);
    OV5640YUV_write_cmos_sensor(0x5388, 0x60);
    OV5640YUV_write_cmos_sensor(0x5389, 0x1c);
    OV5640YUV_write_cmos_sensor(0x538a, 0x01);
    OV5640YUV_write_cmos_sensor(0x538b, 0x98);
    //sharp&noise
    OV5640YUV_write_cmos_sensor(0x5300, 0x08);
    OV5640YUV_write_cmos_sensor(0x5301, 0x30);
    OV5640YUV_write_cmos_sensor(0x5302, 0x3f);
    OV5640YUV_write_cmos_sensor(0x5303, 0x10);
    OV5640YUV_write_cmos_sensor(0x5304, 0x08);
    OV5640YUV_write_cmos_sensor(0x5305, 0x30);
    OV5640YUV_write_cmos_sensor(0x5306, 0x18);
    OV5640YUV_write_cmos_sensor(0x5307, 0x28);
    OV5640YUV_write_cmos_sensor(0x5309, 0x08);
    OV5640YUV_write_cmos_sensor(0x530a, 0x30);
    OV5640YUV_write_cmos_sensor(0x530b, 0x04);
    OV5640YUV_write_cmos_sensor(0x530c, 0x06);
    //gamma
    OV5640YUV_write_cmos_sensor(0x5480, 0x01);
    OV5640YUV_write_cmos_sensor(0x5481, 0x06);
    OV5640YUV_write_cmos_sensor(0x5482, 0x12);
    OV5640YUV_write_cmos_sensor(0x5483, 0x1e);
    OV5640YUV_write_cmos_sensor(0x5484, 0x4a);
    OV5640YUV_write_cmos_sensor(0x5485, 0x58);
    OV5640YUV_write_cmos_sensor(0x5486, 0x65);
    OV5640YUV_write_cmos_sensor(0x5487, 0x72);
    OV5640YUV_write_cmos_sensor(0x5488, 0x7d);
    OV5640YUV_write_cmos_sensor(0x5489, 0x88);
    OV5640YUV_write_cmos_sensor(0x548a, 0x92);
    OV5640YUV_write_cmos_sensor(0x548b, 0xa3);
    OV5640YUV_write_cmos_sensor(0x548c, 0xb2);
    OV5640YUV_write_cmos_sensor(0x548d, 0xc8);
    OV5640YUV_write_cmos_sensor(0x548e, 0xdd);
    OV5640YUV_write_cmos_sensor(0x548f, 0xf0);
    OV5640YUV_write_cmos_sensor(0x5490, 0x15);
    //UV adjust
    OV5640YUV_write_cmos_sensor(0x5580, 0x06);
    OV5640YUV_write_cmos_sensor(0x5583, 0x40);
    OV5640YUV_write_cmos_sensor(0x5584, 0x10);
    OV5640YUV_write_cmos_sensor(0x5589, 0x10);
    OV5640YUV_write_cmos_sensor(0x558a, 0x00);
    OV5640YUV_write_cmos_sensor(0x558b, 0xf8);
    //lens shading
    OV5640YUV_write_cmos_sensor(0x5000, 0xa7);
    OV5640YUV_write_cmos_sensor(0x5800, 0x20);
    OV5640YUV_write_cmos_sensor(0x5801, 0x19);
    OV5640YUV_write_cmos_sensor(0x5802, 0x17);
    OV5640YUV_write_cmos_sensor(0x5803, 0x16);
    OV5640YUV_write_cmos_sensor(0x5804, 0x18);
    OV5640YUV_write_cmos_sensor(0x5805, 0x21);
    OV5640YUV_write_cmos_sensor(0x5806, 0x0F);
    OV5640YUV_write_cmos_sensor(0x5807, 0x0A);
    OV5640YUV_write_cmos_sensor(0x5808, 0x07);
    OV5640YUV_write_cmos_sensor(0x5809, 0x07);
    OV5640YUV_write_cmos_sensor(0x580a, 0x0A);
    OV5640YUV_write_cmos_sensor(0x580b, 0x0C);
    OV5640YUV_write_cmos_sensor(0x580c, 0x0A);
    OV5640YUV_write_cmos_sensor(0x580d, 0x03);
    OV5640YUV_write_cmos_sensor(0x580e, 0x01);
    OV5640YUV_write_cmos_sensor(0x580f, 0x01);
    OV5640YUV_write_cmos_sensor(0x5810, 0x03);
    OV5640YUV_write_cmos_sensor(0x5811, 0x09);
    OV5640YUV_write_cmos_sensor(0x5812, 0x0A);
    OV5640YUV_write_cmos_sensor(0x5813, 0x03);
    OV5640YUV_write_cmos_sensor(0x5814, 0x01);
    OV5640YUV_write_cmos_sensor(0x5815, 0x01);
    OV5640YUV_write_cmos_sensor(0x5816, 0x03);
    OV5640YUV_write_cmos_sensor(0x5817, 0x08);
    OV5640YUV_write_cmos_sensor(0x5818, 0x10);
    OV5640YUV_write_cmos_sensor(0x5819, 0x0A);
    OV5640YUV_write_cmos_sensor(0x581a, 0x06);
    OV5640YUV_write_cmos_sensor(0x581b, 0x06);
    OV5640YUV_write_cmos_sensor(0x581c, 0x08);
    OV5640YUV_write_cmos_sensor(0x581d, 0x0E);
    OV5640YUV_write_cmos_sensor(0x581e, 0x22);
    OV5640YUV_write_cmos_sensor(0x581f, 0x18);
    OV5640YUV_write_cmos_sensor(0x5820, 0x13);
    OV5640YUV_write_cmos_sensor(0x5821, 0x12);
    OV5640YUV_write_cmos_sensor(0x5822, 0x16);
    OV5640YUV_write_cmos_sensor(0x5823, 0x1E);
    OV5640YUV_write_cmos_sensor(0x5824, 0x64);
    OV5640YUV_write_cmos_sensor(0x5825, 0x2A);
    OV5640YUV_write_cmos_sensor(0x5826, 0x2C);
    OV5640YUV_write_cmos_sensor(0x5827, 0x2A);
    OV5640YUV_write_cmos_sensor(0x5828, 0x46);
    OV5640YUV_write_cmos_sensor(0x5829, 0x2A);
    OV5640YUV_write_cmos_sensor(0x582a, 0x26);
    OV5640YUV_write_cmos_sensor(0x582b, 0x24);
    OV5640YUV_write_cmos_sensor(0x582c, 0x26);
    OV5640YUV_write_cmos_sensor(0x582d, 0x2A);
    OV5640YUV_write_cmos_sensor(0x582e, 0x28);
    OV5640YUV_write_cmos_sensor(0x582f, 0x42);
    OV5640YUV_write_cmos_sensor(0x5830, 0x40);
    OV5640YUV_write_cmos_sensor(0x5831, 0x42);
    OV5640YUV_write_cmos_sensor(0x5832, 0x08);
    OV5640YUV_write_cmos_sensor(0x5833, 0x28);
    OV5640YUV_write_cmos_sensor(0x5834, 0x26);
    OV5640YUV_write_cmos_sensor(0x5835, 0x24);
    OV5640YUV_write_cmos_sensor(0x5836, 0x26);
    OV5640YUV_write_cmos_sensor(0x5837, 0x2A);
    OV5640YUV_write_cmos_sensor(0x5838, 0x44);
    OV5640YUV_write_cmos_sensor(0x5839, 0x4A);
    OV5640YUV_write_cmos_sensor(0x583a, 0x2C);
    OV5640YUV_write_cmos_sensor(0x583b, 0x2a);
    OV5640YUV_write_cmos_sensor(0x583c, 0x46);
    OV5640YUV_write_cmos_sensor(0x583d, 0xCE);
    OV5640YUV_write_cmos_sensor(0x5688, 0x22);
    OV5640YUV_write_cmos_sensor(0x5689, 0x22);
    OV5640YUV_write_cmos_sensor(0x568a, 0x42);
    OV5640YUV_write_cmos_sensor(0x568b, 0x24);
    OV5640YUV_write_cmos_sensor(0x568c, 0x42);
    OV5640YUV_write_cmos_sensor(0x568d, 0x24);
    OV5640YUV_write_cmos_sensor(0x568e, 0x22);
    OV5640YUV_write_cmos_sensor(0x568f, 0x22);
    OV5640YUV_write_cmos_sensor(0x5025, 0x00);
    OV5640YUV_write_cmos_sensor(0x3a0f, 0x30);
    OV5640YUV_write_cmos_sensor(0x3a10, 0x28);
    OV5640YUV_write_cmos_sensor(0x3a1b, 0x30);
    OV5640YUV_write_cmos_sensor(0x3a1e, 0x28);
    OV5640YUV_write_cmos_sensor(0x3a11, 0x61);
    OV5640YUV_write_cmos_sensor(0x3a1f, 0x10);
    OV5640YUV_write_cmos_sensor(0x4005, 0x1a);
    OV5640YUV_write_cmos_sensor(0x3406, 0x00);//awbinit
    OV5640YUV_write_cmos_sensor(0x3503, 0x00);//awbinit
    OV5640YUV_write_cmos_sensor(0x3008, 0x02);
}
//set constant focus
static void OV5640_FOCUS_AD5820_Constant_Focus(void)
{
    UINT8 state = 0x8F;
    UINT32 iteration = 300;
    //send constant focus mode command to firmware
    OV5640YUV_write_cmos_sensor(0x3023,0x01);
    OV5640YUV_write_cmos_sensor(0x3022,0x04);
    return;
}
static void OV5640_FOCUS_AD5820_Single_Focus()
{
    UINT8 state = 0x8F;
    UINT32 iteration = 100;
    OV5640YUV_write_cmos_sensor(0x3023,0x01);
    OV5640YUV_write_cmos_sensor(0x3022,0x03);
    iteration = 100;
    do{
        state = (UINT8)OV5640YUV_read_cmos_sensor(0x3023);
        if(state == 0x00)
        {
            SENSORDB("single focused!\n");
            break;
        }
     //   mdelay(30);
         mdelay(3);
        iteration --;
    }while(iteration);
    return;
}
static void OV5640_FOCUS_AD5820_Pause_Focus()
{
    UINT8 state = 0x8F;
    UINT32 iteration = 100;
    //send idle command to firmware
    OV5640YUV_write_cmos_sensor(0x3023,0x01);
    OV5640YUV_write_cmos_sensor(0x3022,0x06);
    iteration = 100;
    do{
        state = (UINT8)OV5640YUV_read_cmos_sensor(0x3023);
        if(state == 0x00)
        {
            break;
        }
        msleep(30);
    //      msleep(10);
        iteration --;
    }while(iteration);
    if(iteration==0)
    {
        printk("pause focus fail.........state is 0x%x...",state);
       return ;
    }
    printk("pause focus  OK ......");
}
static void OV5640_FOCUS_AD5820_Cancel_Focus()
{
    UINT8 state = 0x8F;
    UINT32 iteration = 100;
    //send idle command to firmware
    OV5640YUV_write_cmos_sensor(0x3023,0x01);
    OV5640YUV_write_cmos_sensor(0x3022,0x08);
    iteration = 100;
    do{
        state = (UINT8)OV5640YUV_read_cmos_sensor(0x3023);
        if(state == 0x00)
        {
            break;
        }
        msleep(30);
        iteration --;
    }while(iteration);
}
void OV5640YUV_set_720P_init(void)
{
    //OV5640YUV_write_cmos_sensor(0x3008, 0x42);
    OV5640YUV_write_cmos_sensor(0x5189, 0x72);
    OV5640YUV_write_cmos_sensor(0x3503, 0x00);//AE
    //OV5640YUV_write_cmos_sensor(0x3406, 0x00);//AWB
    OV5640YUV_write_cmos_sensor(0x3a00, 0x38);//enable night
    OV5640YUV_write_cmos_sensor(0x5302, 0x20);
    OV5640YUV_write_cmos_sensor(0x5303, 0x08);
    OV5640YUV_write_cmos_sensor(0x5306, 0x10);//18
    OV5640YUV_write_cmos_sensor(0x5307, 0x20);//28
    //OV5640YUV_write_cmos_sensor(0x3820, 0x47);
   // OV5640YUV_write_cmos_sensor(0x3821, 0x01);
    //dg add 2015-07-24 for stop flip image
    OV5640YUV_write_cmos_sensor(0x3820, 0x40);
    OV5640YUV_write_cmos_sensor(0x3821, 0x06);
    OV5640YUV_write_cmos_sensor(0x3108, 0x01);
    //windows setup
    OV5640YUV_write_cmos_sensor(0x3800, 0x00);
    OV5640YUV_write_cmos_sensor(0x3801, 0x00);
    OV5640YUV_write_cmos_sensor(0x3802, 0x00);
    OV5640YUV_write_cmos_sensor(0x3803, 0x04);
    //dg add  2015-07-25 to adjust X_AADR_END long for image windeos show
    OV5640YUV_write_cmos_sensor(0x3804, 0x0a);
    OV5640YUV_write_cmos_sensor(0x3805, 0x5f); //3f-5f->Good
    OV5640YUV_write_cmos_sensor(0x3806, 0x07);
    OV5640YUV_write_cmos_sensor(0x3807, 0x9b);
#if 1
    OV5640YUV_write_cmos_sensor(0x3808, 0x05);//1280
    OV5640YUV_write_cmos_sensor(0x3809, 0x00);
    OV5640YUV_write_cmos_sensor(0x380a, 0x03);//960
    OV5640YUV_write_cmos_sensor(0x380b, 0xc0);
#else
    OV5640YUV_write_cmos_sensor(0x3808, 0x05);
    OV5640YUV_write_cmos_sensor(0x3809, 0x80);
    OV5640YUV_write_cmos_sensor(0x380a, 0x01);
    OV5640YUV_write_cmos_sensor(0x380b, 0xe0);
#endif
    //OV5640YUV_write_cmos_sensor(0x3810, 0x00);
   // OV5640YUV_write_cmos_sensor(0x3811, 0x10);
    //dg add  2015-07-25 to adjust X OFFSET position coordinate for image windeos show
    OV5640YUV_write_cmos_sensor(0x3810, 0x00); // 00->01->00
    OV5640YUV_write_cmos_sensor(0x3811, 0xED); // 10->00->F0->EF->EE->ED->Good
    OV5640YUV_write_cmos_sensor(0x3812, 0x00);
    OV5640YUV_write_cmos_sensor(0x3813, 0x06);
    OV5640YUV_write_cmos_sensor(0x3814, 0x31);
    OV5640YUV_write_cmos_sensor(0x3815, 0x31);
    OV5640YUV_write_cmos_sensor(0x3034, 0x1a);
    OV5640YUV_write_cmos_sensor(0x3035, 0x21); //25fps
    OV5640YUV_write_cmos_sensor(0x3036, 0x46);
    OV5640YUV_write_cmos_sensor(0x3037, 0x13);
    OV5640YUV_write_cmos_sensor(0x3038, 0x00);
    OV5640YUV_write_cmos_sensor(0x3039, 0x00);
    OV5640YUV_write_cmos_sensor(0x380c, 0x07);
    OV5640YUV_write_cmos_sensor(0x380d, 0x68);
    OV5640YUV_write_cmos_sensor(0x380e, 0x03);
    OV5640YUV_write_cmos_sensor(0x380f, 0xd8);
    OV5640YUV_write_cmos_sensor(0x3a08, 0x00);
    OV5640YUV_write_cmos_sensor(0x3a09, 0x93);
    OV5640YUV_write_cmos_sensor(0x3a0e, 0x06);
    OV5640YUV_write_cmos_sensor(0x3a0a, 0x00);
    OV5640YUV_write_cmos_sensor(0x3a0b, 0x7b);
    OV5640YUV_write_cmos_sensor(0x3a0d, 0x08);
    OV5640YUV_write_cmos_sensor(0x3618, 0x00);
    OV5640YUV_write_cmos_sensor(0x3612, 0x29);
    OV5640YUV_write_cmos_sensor(0x3709, 0x52);
    OV5640YUV_write_cmos_sensor(0x370c, 0x03);
    OV5640YUV_write_cmos_sensor(0x4004, 0x02);
    OV5640YUV_write_cmos_sensor(0x460b, 0x35);
    OV5640YUV_write_cmos_sensor(0x460c, 0x22);
    OV5640YUV_write_cmos_sensor(0x4837, 0x15);
    OV5640YUV_write_cmos_sensor(0x3824, 0x01);
    OV5640YUV_write_cmos_sensor(0x5001, 0xa3);
    //OV5640YUV_write_cmos_sensor(0x3008, 0x02);
}
void OV5640YUV_set_5M_init(void)
{
    //OV5640YUV_write_cmos_sensor(0x3008, 0x42);
    OV5640YUV_write_cmos_sensor(0x5189, 0x66);
    OV5640YUV_write_cmos_sensor(0x3503, 0x07);//AE
    //OV5640YUV_write_cmos_sensor(0x3406, 0x01);//AWB
    OV5640YUV_write_cmos_sensor(0x3a00, 0x38);//disable night
    OV5640YUV_write_cmos_sensor(0x5302, 0x30);
    OV5640YUV_write_cmos_sensor(0x5303, 0x10);
    OV5640YUV_write_cmos_sensor(0x5306, 0x08);
    OV5640YUV_write_cmos_sensor(0x5307, 0x18);
    OV5640YUV_write_cmos_sensor(0x3820, 0x40); //46
    OV5640YUV_write_cmos_sensor(0x3821, 0x06); //00
    OV5640YUV_write_cmos_sensor(0x3800, 0x00);
    OV5640YUV_write_cmos_sensor(0x3801, 0x00);
    OV5640YUV_write_cmos_sensor(0x3802, 0x00);
    OV5640YUV_write_cmos_sensor(0x3803, 0x00);
    OV5640YUV_write_cmos_sensor(0x3804, 0x0a);
    OV5640YUV_write_cmos_sensor(0x3805, 0x3f);
    OV5640YUV_write_cmos_sensor(0x3806, 0x07);
    OV5640YUV_write_cmos_sensor(0x3807, 0x9f);
    OV5640YUV_write_cmos_sensor(0x3808, 0x0a);
    OV5640YUV_write_cmos_sensor(0x3809, 0x20);
    OV5640YUV_write_cmos_sensor(0x380a, 0x07);
    OV5640YUV_write_cmos_sensor(0x380b, 0x98);
    OV5640YUV_write_cmos_sensor(0x3810, 0x00);
    OV5640YUV_write_cmos_sensor(0x3811, 0x10);
    OV5640YUV_write_cmos_sensor(0x3812, 0x00);
    OV5640YUV_write_cmos_sensor(0x3813, 0x04);
    OV5640YUV_write_cmos_sensor(0x3814, 0x11);
    OV5640YUV_write_cmos_sensor(0x3815, 0x11);
    OV5640YUV_write_cmos_sensor(0x3034, 0x1a);
    OV5640YUV_write_cmos_sensor(0x3035, 0x11); //10fps
    OV5640YUV_write_cmos_sensor(0x3036, 0x46);
    OV5640YUV_write_cmos_sensor(0x3037, 0x13);
    OV5640YUV_write_cmos_sensor(0x3038, 0x00);
    OV5640YUV_write_cmos_sensor(0x3039, 0x00);
    OV5640YUV_write_cmos_sensor(0x380c, 0x0b);
    OV5640YUV_write_cmos_sensor(0x380d, 0x1c);
    OV5640YUV_write_cmos_sensor(0x380e, 0x07);
    OV5640YUV_write_cmos_sensor(0x380f, 0xb0);
    OV5640YUV_write_cmos_sensor(0x3a08, 0x00);
    OV5640YUV_write_cmos_sensor(0x3a09, 0xc5);
    OV5640YUV_write_cmos_sensor(0x3a0e, 0x0a);
    OV5640YUV_write_cmos_sensor(0x3a0a, 0x00);
    OV5640YUV_write_cmos_sensor(0x3a0b, 0xa4);
    OV5640YUV_write_cmos_sensor(0x3a0d, 0x0c);
    OV5640YUV_write_cmos_sensor(0x3618, 0x04);
    OV5640YUV_write_cmos_sensor(0x3612, 0x2b);
    OV5640YUV_write_cmos_sensor(0x3709, 0x12);
    OV5640YUV_write_cmos_sensor(0x370c, 0x00);
    OV5640YUV_write_cmos_sensor(0x4004, 0x06);
    OV5640YUV_write_cmos_sensor(0x3002, 0x00);
    OV5640YUV_write_cmos_sensor(0x3006, 0xff);
    OV5640YUV_write_cmos_sensor(0x4713, 0x02);
    OV5640YUV_write_cmos_sensor(0x4407, 0x04);
    OV5640YUV_write_cmos_sensor(0x460b, 0x37);
    OV5640YUV_write_cmos_sensor(0x460c, 0x22);
    OV5640YUV_write_cmos_sensor(0x4837, 0x16);
    OV5640YUV_write_cmos_sensor(0x3824, 0x01);
    OV5640YUV_write_cmos_sensor(0x5001, 0x83);
    //OV5640YUV_write_cmos_sensor(0x3008, 0x02);
    mdelay(300);//liuxinming
}
void OV5640YUV_set_720P(void)
{
    SENSORDB("OV5640YUV_set_720P Start \n");
    OV5640YUV_g_RES = OV5640_720P;
    OV5640YUV_set_720P_init();
    OV5640YUV_PV_pclk = 5600;
    OV5640YUV_sensor_pclk=56000000;
    SENSORDB("Set 720P End\n");
}
void OV5640YUV_set_5M(void)
{
    SENSORDB("Set 5M begin\n");
    OV5640YUV_g_RES = OV5640_5M;
    OV5640YUV_set_5M_init();
    OV5640YUV_CAP_pclk = 5600;
    OV5640YUV_sensor_pclk=56000000;
    SENSORDB("Set 5M End\n");
}
/*************************************************************************
* FUNCTION
*   OV5640_night_mode
*
* DESCRIPTION
*   This function night mode of OV5640.
*
* PARAMETERS
*   none
*
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void OV5640YUV_NightMode(bool bEnable)
{
    if(bEnable)
    {
        OV5640YUV_night_mode = true;
        if(OV5640YUV_MPEG4_encode_mode== true)
        {
            OV5640YUV_write_cmos_sensor(0x3034, 0x1a);
            OV5640YUV_write_cmos_sensor(0x3035, 0x21); //10fps
            OV5640YUV_write_cmos_sensor(0x3036, 0x46);
            OV5640YUV_write_cmos_sensor(0x3037, 0x13);
            OV5640YUV_write_cmos_sensor(0x3038, 0x00);
            OV5640YUV_write_cmos_sensor(0x3039, 0x00);
            OV5640YUV_write_cmos_sensor(0x380c, 0x07);
            OV5640YUV_write_cmos_sensor(0x380d, 0x68);
            OV5640YUV_write_cmos_sensor(0x380e, 0x05);
            OV5640YUV_write_cmos_sensor(0x380f, 0xc4);
            OV5640YUV_write_cmos_sensor(0x3c01, 0xb4);
            OV5640YUV_write_cmos_sensor(0x3c00, 0x04);
            OV5640YUV_write_cmos_sensor(0x3a08, 0x00);
            OV5640YUV_write_cmos_sensor(0x3a09, 0x93);
            OV5640YUV_write_cmos_sensor(0x3a0e, 0x0a);
            OV5640YUV_write_cmos_sensor(0x3a0a, 0x00);
            OV5640YUV_write_cmos_sensor(0x3a0b, 0x7b);
            OV5640YUV_write_cmos_sensor(0x3a0d, 0x0c);
            OV5640YUV_write_cmos_sensor(0x3a00, 0x38);
            OV5640YUV_write_cmos_sensor(0x3a02 ,0x05);
            OV5640YUV_write_cmos_sensor(0x3a03 ,0xc4);
            OV5640YUV_write_cmos_sensor(0x3a14 ,0x05);
            OV5640YUV_write_cmos_sensor(0x3a15 ,0xc4);
        }
        else
        {
            OV5640YUV_write_cmos_sensor(0x3a00, 0x3c);//25fps-5fps
            OV5640YUV_write_cmos_sensor(0x3a02 ,0x0b);
            OV5640YUV_write_cmos_sensor(0x3a03 ,0x88);
            OV5640YUV_write_cmos_sensor(0x3a14 ,0x0b);
            OV5640YUV_write_cmos_sensor(0x3a15 ,0x88);
        }
    }
    else
    {
        OV5640YUV_night_mode = false;
        if(OV5640YUV_MPEG4_encode_mode==false)
        {
            OV5640YUV_write_cmos_sensor(0x3034, 0x1a);
            OV5640YUV_write_cmos_sensor(0x3035, 0x21); //15fps
            OV5640YUV_write_cmos_sensor(0x3036, 0x46);
            OV5640YUV_write_cmos_sensor(0x3037, 0x13);
            OV5640YUV_write_cmos_sensor(0x3038, 0x00);
            OV5640YUV_write_cmos_sensor(0x3039, 0x00);
            OV5640YUV_write_cmos_sensor(0x380c, 0x07);
            OV5640YUV_write_cmos_sensor(0x380d, 0x68);
            OV5640YUV_write_cmos_sensor(0x380e, 0x03);
            OV5640YUV_write_cmos_sensor(0x380f, 0xd8);
            OV5640YUV_write_cmos_sensor(0x3c01, 0xb4);
            OV5640YUV_write_cmos_sensor(0x3c00, 0x04);
            OV5640YUV_write_cmos_sensor(0x3a08, 0x00);
            OV5640YUV_write_cmos_sensor(0x3a09, 0x93);
            OV5640YUV_write_cmos_sensor(0x3a0e, 0x06);
            OV5640YUV_write_cmos_sensor(0x3a0a, 0x00);
            OV5640YUV_write_cmos_sensor(0x3a0b, 0x7b);
            OV5640YUV_write_cmos_sensor(0x3a0d, 0x08);
            OV5640YUV_write_cmos_sensor(0x3a00, 0x38);
            OV5640YUV_write_cmos_sensor(0x3a02 ,0x03);
            OV5640YUV_write_cmos_sensor(0x3a03 ,0xd8);
            OV5640YUV_write_cmos_sensor(0x3a14 ,0x03);
            OV5640YUV_write_cmos_sensor(0x3a15 ,0xd8);
        }
        else
        {
            OV5640YUV_write_cmos_sensor(0x3a00, 0x38);//25fps-20fps
            OV5640YUV_write_cmos_sensor(0x3a02 ,0x03);
            OV5640YUV_write_cmos_sensor(0x3a03 ,0xd8);
            OV5640YUV_write_cmos_sensor(0x3a14 ,0x03);
            OV5640YUV_write_cmos_sensor(0x3a15 ,0xd8);
        }
    }
}
static void OV5640YUV_SetDummy(const kal_uint16 iPixels, const kal_uint16 iLines)
{
   return ;
}
static void OV5640YUV_set_AE_mode(kal_bool AE_enable)
{
    kal_uint8 temp_AE_reg = 0;
    if (AE_enable == KAL_TRUE)
    {
        OV5640YUV_write_cmos_sensor(0x3503, 0x00);
    }
    else
    {
        OV5640YUV_write_cmos_sensor(0x3503, 0x07);
    }
}
#if 0
static void OV5640YUV_set_AWB_mode(kal_bool AWB_enable)
{
    kal_uint8 temp_AWB_reg = 0;
    if (AWB_enable == KAL_TRUE)
    {
        OV5640YUV_write_cmos_sensor(0x3406, 0x00);
    }
    else
    {
        OV5640YUV_write_cmos_sensor(0x3406, 0x01);
    }
}
#endif
/*************************************************************************
* FUNCTION
*    OV5640YUV_SetGain
*
* DESCRIPTION
*    This function is to set global gain to sensor.
*
* PARAMETERS
*    gain : sensor global gain(base: 0x40)
*
* RETURNS
*    the actually gain set to sensor.
*
* GLOBALS AFFECTED
*
*************************************************************************/
//! Due to the OV5640 set gain will happen race condition.
//! It need to use a critical section to protect it.
//static atomic_t OV5640_SetGain_Flag;
//static wait_queue_head_t OV5640_SetGain_waitQueue;
void OV5640YUV_SetGain(UINT16 iGain)
{
    kal_uint8 iReg;
    int timeOut = 0;
#if 0
    if (atomic_read(&OV5640_SetGain_Flag) == 1) {
        timeOut = wait_event_interruptible_timeout(
                    OV5640_SetGain_waitQueue, atomic_read(&OV5640_SetGain_Flag) == 0, 1 * HZ);
        if (timeOut == 0) {
            SENSORDB("[OV5640YUV_SetGain] Set Gain Wait Queue time out \n");
            return;
        }
    }
    atomic_set(&OV5640_SetGain_Flag, 1);
#endif
    OV5640YUV_write_cmos_sensor(0x3212, 0x00);
    OV5640YUV_write_cmos_sensor(0x350B, (kal_uint32)iGain);
    OV5640YUV_write_cmos_sensor(0x3212, 0x10);
    OV5640YUV_write_cmos_sensor(0x3212, 0xA0);
#if 0
    atomic_set(&OV5640_SetGain_Flag, 0);
    wake_up_interruptible(&OV5640_SetGain_waitQueue);
#endif
}   /*  OV5640YUV_SetGain  */
/*************************************************************************
* FUNCTION
*   OV5640YUV_read_shutter
*
* DESCRIPTION
*   This function to  Get exposure time.
*
* PARAMETERS
*   None
*
* RETURNS
*   shutter : exposured lines
*
* GLOBALS AFFECTED
*
*************************************************************************/
UINT16 OV5640YUV_read_shutter(void)
{
    kal_uint8 temp_reg1, temp_reg2, temp_reg3;
    kal_uint16 temp_reg;
    temp_reg1 = OV5640YUV_read_cmos_sensor(0x3500);
    temp_reg2 = OV5640YUV_read_cmos_sensor(0x3501);
    temp_reg3 = OV5640YUV_read_cmos_sensor(0x3502);
    // SENSORDB("ov5640read shutter 0x3500=0x%x,0x3501=0x%x,0x3502=0x%x\n",
    //    temp_reg1,temp_reg2,temp_reg3);
    temp_reg = ((temp_reg1<<12) & 0xF000) | ((temp_reg2<<4) & 0x0FF0) | ((temp_reg3>>4) & 0x0F);
    //SENSORDB("ov5640read shutter = 0x%x\n", temp_reg);
    return (UINT16)temp_reg;
}
void OV5640YUV_write_shutter(kal_uint16 shutter)
{
    kal_uint16 iExp = shutter;
    kal_uint16 OV5640_g_iExtra_ExpLines = 0 ;
    int timeOut = 0;
    OV5640YUV_write_cmos_sensor(0x3500, (iExp >> 12) & 0xFF);
    OV5640YUV_write_cmos_sensor(0x3501, (iExp >> 4 ) & 0xFF);
    OV5640YUV_write_cmos_sensor(0x3502, (iExp <<4 ) & 0xFF);
}   /* write_OV5640_shutter */
/*************************************************************************
* FUNCTION
*   OV5640YUV_SetShutter
*
* DESCRIPTION
*   This function set e-shutter of OV5640 to change exposure time.
*
* PARAMETERS
*   shutter : exposured lines
*
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void OV5640YUV_SetShutter(kal_uint16 iShutter)
{
    if (iShutter < 1)
        iShutter = 1;
    OV5640YUV_pv_exposure_lines = iShutter;
    OV5640YUV_write_shutter(iShutter);
    //SENSORDB("iShutter = %d\n", iShutter);
}   /*  OV5640YUV_SetShutter   */
/*************************************************************************
* FUNCTION
*    read_OV5640YUV_gain
*
* DESCRIPTION
*    This function is to set global gain to sensor.
*
* PARAMETERS
*    None
*
* RETURNS
*    gain : sensor global gain(base: 0x40)
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_uint16 read_OV5640YUV_gain(void)
{
    kal_uint8 temp_gain;
    kal_uint16 gain;
    gain = OV5640YUV_read_cmos_sensor(0x350B);
    return gain;
}  /* read_OV5640YUV_gain */
void write_OV5640YUV_gain(kal_uint16 gain)
{
    OV5640YUV_SetGain(gain);
}
/*************************************************************************
* FUNCTION
*   OV5640YUVPreview
*
* DESCRIPTION
*   This function start the sensor preview.
*
* PARAMETERS
*   *image_window : address pointer of pixel numbers in one period of HSYNC
*  *sensor_config_data : address pointer of line numbers in one period of VSYNC
*
* RETURNS
*   None
*
* GLOBALS AFFECTED
*
*************************************************************************/
UINT32 OV5640YUVPreview()
{
 //   kal_uint16 iStartX = 0, iStartY = 0;
   g_iOV5640YUV_Mode = OV5640_MODE_PREVIEW;
    OV5640YUV_write_cmos_sensor(0x4202,0x0f);
   // msleep(30);
    msleep(5);
    OV5640YUV_set_720P();
    OV5640YUV_write_cmos_sensor(0x4202,0x00);
  //  msleep(30);
  // dg cancle  ,donot focus  start,otherwise picture is not working well.
   //dg  use after
   // OV5640YUV_write_cmos_sensor(0x3023,0x01);
  //  OV5640YUV_write_cmos_sensor(0x3022,0x04);
#if 0
    if (tem){
        OV5640YUV_SetShutter(back_shutter);
        write_OV5640YUV_gain(back_pv_gain);
    }
    tem =0;
#endif
    //OV5640YUV_write_cmos_sensor(0x3820, 0x46);
    //OV5640YUV_write_cmos_sensor(0x3821, 0x00);
/*
    if(sensor_config_data->SensorOperationMode==MSDK_SENSOR_OPERATION_MODE_VIDEO)        // MPEG4 Encode Mode
    {
        OV5640YUV_MPEG4_encode_mode = KAL_TRUE;
    }
    else
    {
        OV5640YUV_MPEG4_encode_mode = KAL_FALSE;
    }
    iStartX += OV5640_IMAGE_SENSOR_PV_STARTX;
    iStartY += OV5640_IMAGE_SENSOR_PV_STARTY;
*/
    // sensor_config_data->SensorImageMirror = IMAGE_HV_MIRROR;
    // OV5640YUV_Set_Mirror_Flip(sensor_config_data->SensorImageMirror);
    /*************************************************************************************************************/
    //dg cancle 2015-07-18
    //OV5640YUV_write_cmos_sensor(0x3820,0x47);
    //OV5640YUV_write_cmos_sensor(0x3821,0x01);
   // OV5640YUV_write_cmos_sensor(0x4514,0x00);
    /*************************************************************************************************************/
#if 0
    OV5640YUV_dummy_pixels = 0;
    OV5640YUV_dummy_lines = 0;
    OV5640YUV_PV_dummy_pixels = OV5640YUV_dummy_pixels;
    OV5640YUV_PV_dummy_lines = OV5640YUV_dummy_lines;
    //OV5640YUV_SetDummy(OV5640YUV_dummy_pixels, OV5640YUV_dummy_lines);
#endif
    //OV5640YUV_NightMode(OV5640YUV_night_mode);
    OV5640YUV_NightMode(false);
#if 0
    memcpy(&OV5640YUVSensorConfigData, sensor_config_data, sizeof(MSDK_SENSOR_CONFIG_STRUCT));
    image_window->GrabStartX= iStartX;
    image_window->GrabStartY= iStartY;
    image_window->ExposureWindowWidth= OV5640_IMAGE_SENSOR_PV_WIDTH - 2*iStartX;
    image_window->ExposureWindowHeight= OV5640_IMAGE_SENSOR_PV_HEIGHT - 2*iStartY;
#endif
    return 0;
}
UINT32 OV5640YUVCapture( )
{
    kal_uint32 shutter = 0;
    kal_uint32 temp_shutter = 0;
    kal_uint16 iStartX = 0, iStartY = 0;
    kal_uint32 pv_gain = 0;
    kal_uint8 temp = 0;//for night mode
    if(g_iOV5640YUV_Mode == OV5640_MODE_PREVIEW)
    {
        g_iOV5640YUV_Mode = OV5640_MODE_CAPTURE;
      //  if(sensor_config_data->EnableShutterTansfer==KAL_TRUE)
         //   shutter=sensor_config_data->CaptureShutter;
        temp= OV5640YUV_read_cmos_sensor(0x3a00);
        OV5640YUV_write_cmos_sensor(0x3a00,temp&0xfb);
        OV5640YUV_set_AE_mode(KAL_FALSE);
        //OV5640YUV_set_AWB_mode(KAL_FALSE);
        shutter = OV5640YUV_read_shutter();
        pv_gain = read_OV5640YUV_gain();
        back_shutter = shutter;
        back_pv_gain = pv_gain;
        tem = 1;
        SENSORDB("Preview Shutter = %d, Gain = %d\n", shutter, pv_gain);
#if 0
        if ((image_window->ImageTargetWidth<= OV5640_IMAGE_SENSOR_PV_WIDTH) &&
                (image_window->ImageTargetHeight<= OV5640_IMAGE_SENSOR_PV_HEIGHT))
        {
            OV5640YUV_dummy_pixels= 0;
            OV5640YUV_dummy_lines = 0;
            iStartX = OV5640_IMAGE_SENSOR_PV_STARTX;
            iStartY = OV5640_IMAGE_SENSOR_PV_STARTY;
            image_window->GrabStartX=iStartX;
            image_window->GrabStartY=iStartY;
            image_window->ExposureWindowWidth=OV5640_IMAGE_SENSOR_PV_WIDTH - 2*iStartX;
            image_window->ExposureWindowHeight=OV5640_IMAGE_SENSOR_PV_HEIGHT- 2*iStartY;
        }
        else
        {
#endif
            OV5640_FOCUS_AD5820_Single_Focus();
            OV5640YUV_write_cmos_sensor(0x4202,0x0f);
            Sleep(30);
            OV5640YUV_set_5M();
            OV5640YUV_write_cmos_sensor(0x4202,0x00);
            Sleep(30);
#if 0
            OV5640YUV_dummy_pixels= 0;
            OV5640YUV_dummy_lines = 0;
            OV5640YUV_CAP_pclk = 560;
            OV5640YUV_PV_pclk = 560;
            //temp_shutter = (shutter*(OV5640_PV_PERIOD_PIXEL_NUMS_HTS+OV5640YUV_PV_dummy_pixels)*OV5640YUV_CAP_pclk)
            //            /(OV5640_FULL_PERIOD_PIXEL_NUMS_HTS+OV5640YUV_dummy_pixels)/OV5640YUV_PV_pclk;
            //shutter = (kal_uint32)(temp_shutter);
            shutter = shutter*4/3;
            SENSORDB("cap shutter calutaed = %d, 0x%x\n", shutter,shutter);
            iStartX = 2* OV5640_IMAGE_SENSOR_PV_STARTX;
            iStartY = 2* OV5640_IMAGE_SENSOR_PV_STARTY;
            image_window->GrabStartX=iStartX;
            image_window->GrabStartY=iStartY;
            image_window->ExposureWindowWidth=OV5640_IMAGE_SENSOR_FULL_WIDTH -2*iStartX;
            image_window->ExposureWindowHeight=OV5640_IMAGE_SENSOR_FULL_HEIGHT-2*iStartY;
        }
        sensor_config_data->Lines = image_window->ExposureWindowHeight;
        sensor_config_data->Shutter =shutter;
        OV5640YUV_SetDummy(OV5640YUV_dummy_pixels, OV5640YUV_dummy_lines);
#endif
        OV5640YUV_SetShutter(shutter);
        write_OV5640YUV_gain(pv_gain);
#if 0
        memcpy(&OV5640YUVSensorConfigData, sensor_config_data, sizeof(MSDK_SENSOR_CONFIG_STRUCT));
#endif
        // sensor_config_data->SensorImageMirror = IMAGE_NORMAL;
        // OV5640YUV_Set_Mirror_Flip(sensor_config_data->SensorImageMirror);
    }
    /*************************************************************************************************************/
    OV5640YUV_write_cmos_sensor(0x3820,0x46);
    OV5640YUV_write_cmos_sensor(0x3821,0x00);
    OV5640YUV_write_cmos_sensor(0x4514,0x88);
    /*************************************************************************************************************/
    return ERROR_NONE;
}
#endif  //end dg add 2015-07-15
/* add by cym 20130605 */
static int ov5640_power(int flag)
{
        int err;
        printk("cym: ov5640 sensor is power %s\n",flag == 1 ?"on":"off");
        //Attention: Power On the all the camera module when system turn on
        //Here only control the reset&&powerdown pin
        /* Camera A */
        if(1 == flag)
        {
                //poweron
#ifndef CONFIG_TC4_EVT
        regulator_enable(ov_vdd18_cam_regulator);
               udelay(10);
                regulator_enable(ov_vdd28_cam_regulator);
               udelay(10);
                regulator_enable(ov_vdd5m_cam_regulator); //DOVDD  DVDD 1.8v
               udelay(10);
                regulator_enable(ov_vddaf_cam_regulator);         //AVDD 2.8v
               udelay(10);
#endif
#if 1
                //pwdn        GPF0_5: 2M PWDN
                err = gpio_request(EXYNOS4_GPF0(5), "GPF0_5");
                if (err)
                        printk(KERN_ERR "#### failed to request GPF0_5 ####\n");
                s3c_gpio_setpull(EXYNOS4_GPF0(5), S3C_GPIO_PULL_NONE);
                gpio_direction_output(EXYNOS4_GPF0(5), 1);
                gpio_free(EXYNOS4_GPF0(5));
#endif
                //pwdn1    GPF2_4: 5M PWDN
                err = gpio_request(EXYNOS4_GPL0(3), "GPL0_3");
                if (err)
                        printk(KERN_ERR "#### failed to request GPL0_3 ####\n");
                s3c_gpio_setpull(EXYNOS4_GPL0(3), S3C_GPIO_PULL_NONE);
                gpio_direction_output(EXYNOS4_GPL0(3), 0);
                gpio_free(EXYNOS4_GPL0(3));
                msleep(20);
                //reset
                err = gpio_request(EXYNOS4_GPL0(1), "GPL0_1");
                if (err)
                        printk(KERN_ERR "#### failed to request GPL0_1 ####\n");
                s3c_gpio_setpull(EXYNOS4_GPL0(1), S3C_GPIO_PULL_NONE);
                gpio_direction_output(EXYNOS4_GPL0(1), 1);
                msleep(10);
                gpio_direction_output(EXYNOS4_GPL0(1), 0);
                msleep(10);
                gpio_direction_output(EXYNOS4_GPL0(1), 1);
                gpio_free(EXYNOS4_GPL0(1));
                msleep(20);
        }
        else
        {
            err = gpio_request(EXYNOS4_GPL0(1), "GPF0");
            if (err)
                printk(KERN_ERR "#### failed to request GPF0_4 ####\n");
            s3c_gpio_setpull(EXYNOS4_GPL0(1), S3C_GPIO_PULL_NONE);
            gpio_direction_output(EXYNOS4_GPL0(1), 0);
            gpio_free(EXYNOS4_GPL0(1));
#if 1
                //powerdown    GPF0_5: 2M PWDN
                err = gpio_request(EXYNOS4_GPF0(5), "GPF0_5");
                if (err)
                        printk(KERN_ERR "#### failed to request GPE0_5 ####\n");
                s3c_gpio_setpull(EXYNOS4_GPF0(5), S3C_GPIO_PULL_NONE);
                gpio_direction_output(EXYNOS4_GPF0(5), 1);
                gpio_free(EXYNOS4_GPF0(5));
#endif
         //pwdn1            GPF2_4: 5M PWDN
                err = gpio_request(EXYNOS4_GPL0(3), "GPL0_3");
                if (err)
                        printk(KERN_ERR "#### failed to request GPF2_4 ####\n");
                s3c_gpio_setpull(EXYNOS4_GPL0(3), S3C_GPIO_PULL_NONE);
                gpio_direction_output(EXYNOS4_GPL0(3), 1);
                gpio_free(EXYNOS4_GPL0(3));
#ifndef CONFIG_TC4_EVT
                regulator_disable(ov_vdd18_cam_regulator);
               udelay(10);
                regulator_disable(ov_vdd28_cam_regulator);
               udelay(10);
                regulator_disable(ov_vdd5m_cam_regulator);
               udelay(10);
                regulator_disable(ov_vddaf_cam_regulator);
               udelay(10);
#endif
        }
        return 0;
}
#define DEV_DBG_EN       1 
#define REG_ADDR_STEP 2
#define REG_DATA_STEP 1
#define REG_STEP             (REG_ADDR_STEP+REG_DATA_STEP)
#define csi_dev_err(x,arg...) printk(KERN_INFO"[OV5640]"x,##arg)
#define csi_dev_print(x,arg...) printk(KERN_INFO"[OV5640]"x,##arg)
struct regval_list {
    unsigned char reg_num[REG_ADDR_STEP];
    unsigned char value[REG_DATA_STEP];
};
static char ov5640_sensor_af_fw_regs[] = {
    0x02, 0x0f, 0xd6, 0x02, 0x0a, 0x39, 0xc2, 0x01, 0x22, 0x22, 0x00, 0x02, 0x0f, 0xb2, 0xe5, 0x1f, //0x8000,
    0x70, 0x72, 0xf5, 0x1e, 0xd2, 0x35, 0xff, 0xef, 0x25, 0xe0, 0x24, 0x4e, 0xf8, 0xe4, 0xf6, 0x08, //0x8010,
    0xf6, 0x0f, 0xbf, 0x34, 0xf2, 0x90, 0x0e, 0x93, 0xe4, 0x93, 0xff, 0xe5, 0x4b, 0xc3, 0x9f, 0x50, //0x8020,
    0x04, 0x7f, 0x05, 0x80, 0x02, 0x7f, 0xfb, 0x78, 0xbd, 0xa6, 0x07, 0x12, 0x0f, 0x04, 0x40, 0x04, //0x8030,
    0x7f, 0x03, 0x80, 0x02, 0x7f, 0x30, 0x78, 0xbc, 0xa6, 0x07, 0xe6, 0x18, 0xf6, 0x08, 0xe6, 0x78, //0x8040,
    0xb9, 0xf6, 0x78, 0xbc, 0xe6, 0x78, 0xba, 0xf6, 0x78, 0xbf, 0x76, 0x33, 0xe4, 0x08, 0xf6, 0x78, //0x8050,
    0xb8, 0x76, 0x01, 0x75, 0x4a, 0x02, 0x78, 0xb6, 0xf6, 0x08, 0xf6, 0x74, 0xff, 0x78, 0xc1, 0xf6, //0x8060,
    0x08, 0xf6, 0x75, 0x1f, 0x01, 0x78, 0xbc, 0xe6, 0x75, 0xf0, 0x05, 0xa4, 0xf5, 0x4b, 0x12, 0x0a, //0x8070,
    0xff, 0xc2, 0x37, 0x22, 0x78, 0xb8, 0xe6, 0xd3, 0x94, 0x00, 0x40, 0x02, 0x16, 0x22, 0xe5, 0x1f, //0x8080,
    0xb4, 0x05, 0x23, 0xe4, 0xf5, 0x1f, 0xc2, 0x01, 0x78, 0xb6, 0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x78, //0x8090,
    0x4e, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0xa2, 0x37, 0xe4, 0x33, 0xf5, 0x3c, 0x90, 0x30, 0x28, 0xf0, //0x80a0,
    0x75, 0x1e, 0x10, 0xd2, 0x35, 0x22, 0xe5, 0x4b, 0x75, 0xf0, 0x05, 0x84, 0x78, 0xbc, 0xf6, 0x90, //0x80b0,
    0x0e, 0x8c, 0xe4, 0x93, 0xff, 0x25, 0xe0, 0x24, 0x0a, 0xf8, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x78, //0x80c0,
    0xbc, 0xe6, 0x25, 0xe0, 0x24, 0x4e, 0xf8, 0xa6, 0x04, 0x08, 0xa6, 0x05, 0xef, 0x12, 0x0f, 0x0b, //0x80d0,
    0xd3, 0x78, 0xb7, 0x96, 0xee, 0x18, 0x96, 0x40, 0x0d, 0x78, 0xbc, 0xe6, 0x78, 0xb9, 0xf6, 0x78, //0x80e0,
    0xb6, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x90, 0x0e, 0x8c, 0xe4, 0x93, 0x12, 0x0f, 0x0b, 0xc3, 0x78, //0x80f0,
    0xc2, 0x96, 0xee, 0x18, 0x96, 0x50, 0x0d, 0x78, 0xbc, 0xe6, 0x78, 0xba, 0xf6, 0x78, 0xc1, 0xa6, //0x8100,
    0x06, 0x08, 0xa6, 0x07, 0x78, 0xb6, 0xe6, 0xfe, 0x08, 0xe6, 0xc3, 0x78, 0xc2, 0x96, 0xff, 0xee, //0x8110,
    0x18, 0x96, 0x78, 0xc3, 0xf6, 0x08, 0xa6, 0x07, 0x90, 0x0e, 0x95, 0xe4, 0x18, 0x12, 0x0e, 0xe9, //0x8120,
    0x40, 0x02, 0xd2, 0x37, 0x78, 0xbc, 0xe6, 0x08, 0x26, 0x08, 0xf6, 0xe5, 0x1f, 0x64, 0x01, 0x70, //0x8130,
    0x4a, 0xe6, 0xc3, 0x78, 0xc0, 0x12, 0x0e, 0xdf, 0x40, 0x05, 0x12, 0x0e, 0xda, 0x40, 0x39, 0x12, //0x8140,
    0x0f, 0x02, 0x40, 0x04, 0x7f, 0xfe, 0x80, 0x02, 0x7f, 0x02, 0x78, 0xbd, 0xa6, 0x07, 0x78, 0xb9, //0x8150,
    0xe6, 0x24, 0x03, 0x78, 0xbf, 0xf6, 0x78, 0xb9, 0xe6, 0x24, 0xfd, 0x78, 0xc0, 0xf6, 0x12, 0x0f, //0x8160,
    0x02, 0x40, 0x06, 0x78, 0xc0, 0xe6, 0xff, 0x80, 0x04, 0x78, 0xbf, 0xe6, 0xff, 0x78, 0xbe, 0xa6, //0x8170,
    0x07, 0x75, 0x1f, 0x02, 0x78, 0xb8, 0x76, 0x01, 0x02, 0x02, 0x4a, 0xe5, 0x1f, 0x64, 0x02, 0x60, //0x8180,
    0x03, 0x02, 0x02, 0x2a, 0x78, 0xbe, 0xe6, 0xff, 0xc3, 0x78, 0xc0, 0x12, 0x0e, 0xe0, 0x40, 0x08, //0x8190,
    0x12, 0x0e, 0xda, 0x50, 0x03, 0x02, 0x02, 0x28, 0x12, 0x0f, 0x02, 0x40, 0x04, 0x7f, 0xff, 0x80, //0x81a0,
    0x02, 0x7f, 0x01, 0x78, 0xbd, 0xa6, 0x07, 0x78, 0xb9, 0xe6, 0x04, 0x78, 0xbf, 0xf6, 0x78, 0xb9, //0x81b0,
    0xe6, 0x14, 0x78, 0xc0, 0xf6, 0x18, 0x12, 0x0f, 0x04, 0x40, 0x04, 0xe6, 0xff, 0x80, 0x02, 0x7f, //0x81c0,
    0x00, 0x78, 0xbf, 0xa6, 0x07, 0xd3, 0x08, 0xe6, 0x64, 0x80, 0x94, 0x80, 0x40, 0x04, 0xe6, 0xff, //0x81d0,
    0x80, 0x02, 0x7f, 0x00, 0x78, 0xc0, 0xa6, 0x07, 0xc3, 0x18, 0xe6, 0x64, 0x80, 0x94, 0xb3, 0x50, //0x81e0,
    0x04, 0xe6, 0xff, 0x80, 0x02, 0x7f, 0x33, 0x78, 0xbf, 0xa6, 0x07, 0xc3, 0x08, 0xe6, 0x64, 0x80, //0x81f0,
    0x94, 0xb3, 0x50, 0x04, 0xe6, 0xff, 0x80, 0x02, 0x7f, 0x33, 0x78, 0xc0, 0xa6, 0x07, 0x12, 0x0f, //0x8200,
    0x02, 0x40, 0x06, 0x78, 0xc0, 0xe6, 0xff, 0x80, 0x04, 0x78, 0xbf, 0xe6, 0xff, 0x78, 0xbe, 0xa6, //0x8210,
    0x07, 0x75, 0x1f, 0x03, 0x78, 0xb8, 0x76, 0x01, 0x80, 0x20, 0xe5, 0x1f, 0x64, 0x03, 0x70, 0x26, //0x8220,
    0x78, 0xbe, 0xe6, 0xff, 0xc3, 0x78, 0xc0, 0x12, 0x0e, 0xe0, 0x40, 0x05, 0x12, 0x0e, 0xda, 0x40, //0x8230,
    0x09, 0x78, 0xb9, 0xe6, 0x78, 0xbe, 0xf6, 0x75, 0x1f, 0x04, 0x78, 0xbe, 0xe6, 0x75, 0xf0, 0x05, //0x8240,
    0xa4, 0xf5, 0x4b, 0x02, 0x0a, 0xff, 0xe5, 0x1f, 0xb4, 0x04, 0x10, 0x90, 0x0e, 0x94, 0xe4, 0x78, //0x8250,
    0xc3, 0x12, 0x0e, 0xe9, 0x40, 0x02, 0xd2, 0x37, 0x75, 0x1f, 0x05, 0x22, 0x30, 0x01, 0x03, 0x02, //0x8260,
    0x04, 0xc0, 0x30, 0x02, 0x03, 0x02, 0x04, 0xc0, 0x90, 0x51, 0xa5, 0xe0, 0x78, 0x93, 0xf6, 0xa3, //0x8270,
    0xe0, 0x08, 0xf6, 0xa3, 0xe0, 0x08, 0xf6, 0xe5, 0x1f, 0x70, 0x3c, 0x75, 0x1e, 0x20, 0xd2, 0x35, //0x8280,
    0x12, 0x0c, 0x7a, 0x78, 0x7e, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x78, 0x8b, 0xa6, 0x09, 0x18, 0x76, //0x8290,
    0x01, 0x12, 0x0c, 0x5b, 0x78, 0x4e, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x78, 0x8b, 0xe6, 0x78, 0x6e, //0x82a0,
    0xf6, 0x75, 0x1f, 0x01, 0x78, 0x93, 0xe6, 0x78, 0x90, 0xf6, 0x78, 0x94, 0xe6, 0x78, 0x91, 0xf6, //0x82b0,
    0x78, 0x95, 0xe6, 0x78, 0x92, 0xf6, 0x22, 0x79, 0x90, 0xe7, 0xd3, 0x78, 0x93, 0x96, 0x40, 0x05, //0x82c0,
    0xe7, 0x96, 0xff, 0x80, 0x08, 0xc3, 0x79, 0x93, 0xe7, 0x78, 0x90, 0x96, 0xff, 0x78, 0x88, 0x76, //0x82d0,
    0x00, 0x08, 0xa6, 0x07, 0x79, 0x91, 0xe7, 0xd3, 0x78, 0x94, 0x96, 0x40, 0x05, 0xe7, 0x96, 0xff, //0x82e0,
    0x80, 0x08, 0xc3, 0x79, 0x94, 0xe7, 0x78, 0x91, 0x96, 0xff, 0x12, 0x0c, 0x8e, 0x79, 0x92, 0xe7, //0x82f0,
    0xd3, 0x78, 0x95, 0x96, 0x40, 0x05, 0xe7, 0x96, 0xff, 0x80, 0x08, 0xc3, 0x79, 0x95, 0xe7, 0x78, //0x8300,
    0x92, 0x96, 0xff, 0x12, 0x0c, 0x8e, 0x12, 0x0c, 0x5b, 0x78, 0x8a, 0xe6, 0x25, 0xe0, 0x24, 0x4e, //0x8310,
    0xf8, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x78, 0x8a, 0xe6, 0x24, 0x6e, 0xf8, 0xa6, 0x09, 0x78, 0x8a, //0x8320,
    0xe6, 0x24, 0x01, 0xff, 0xe4, 0x33, 0xfe, 0xd3, 0xef, 0x94, 0x0f, 0xee, 0x64, 0x80, 0x94, 0x80, //0x8330,
    0x40, 0x04, 0x7f, 0x00, 0x80, 0x05, 0x78, 0x8a, 0xe6, 0x04, 0xff, 0x78, 0x8a, 0xa6, 0x07, 0xe5, //0x8340,
    0x1f, 0xb4, 0x01, 0x0a, 0xe6, 0x60, 0x03, 0x02, 0x04, 0xc0, 0x75, 0x1f, 0x02, 0x22, 0x12, 0x0c, //0x8350,
    0x7a, 0x78, 0x80, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0x12, 0x0c, 0x7a, 0x78, 0x82, 0xa6, 0x06, 0x08, //0x8360,
    0xa6, 0x07, 0x78, 0x6e, 0xe6, 0x78, 0x8c, 0xf6, 0x78, 0x6e, 0xe6, 0x78, 0x8d, 0xf6, 0x7f, 0x01, //0x8370,
    0xef, 0x25, 0xe0, 0x24, 0x4f, 0xf9, 0xc3, 0x78, 0x81, 0xe6, 0x97, 0x18, 0xe6, 0x19, 0x97, 0x50, //0x8380,
    0x0a, 0x12, 0x0c, 0x82, 0x78, 0x80, 0xa6, 0x04, 0x08, 0xa6, 0x05, 0x74, 0x6e, 0x2f, 0xf9, 0x78, //0x8390,
    0x8c, 0xe6, 0xc3, 0x97, 0x50, 0x08, 0x74, 0x6e, 0x2f, 0xf8, 0xe6, 0x78, 0x8c, 0xf6, 0xef, 0x25, //0x83a0,
    0xe0, 0x24, 0x4f, 0xf9, 0xd3, 0x78, 0x83, 0xe6, 0x97, 0x18, 0xe6, 0x19, 0x97, 0x40, 0x0a, 0x12, //0x83b0,
    0x0c, 0x82, 0x78, 0x82, 0xa6, 0x04, 0x08, 0xa6, 0x05, 0x74, 0x6e, 0x2f, 0xf9, 0x78, 0x8d, 0xe6, //0x83c0,
    0xd3, 0x97, 0x40, 0x08, 0x74, 0x6e, 0x2f, 0xf8, 0xe6, 0x78, 0x8d, 0xf6, 0x0f, 0xef, 0x64, 0x10, //0x83d0,
    0x70, 0x9e, 0xc3, 0x79, 0x81, 0xe7, 0x78, 0x83, 0x96, 0xff, 0x19, 0xe7, 0x18, 0x96, 0x78, 0x84, //0x83e0,
    0xf6, 0x08, 0xa6, 0x07, 0xc3, 0x79, 0x8c, 0xe7, 0x78, 0x8d, 0x96, 0x08, 0xf6, 0xd3, 0x79, 0x81, //0x83f0,
    0xe7, 0x78, 0x7f, 0x96, 0x19, 0xe7, 0x18, 0x96, 0x40, 0x05, 0x09, 0xe7, 0x08, 0x80, 0x06, 0xc3, //0x8400,
    0x79, 0x7f, 0xe7, 0x78, 0x81, 0x96, 0xff, 0x19, 0xe7, 0x18, 0x96, 0xfe, 0x78, 0x86, 0xa6, 0x06, //0x8410,
    0x08, 0xa6, 0x07, 0x79, 0x8c, 0xe7, 0xd3, 0x78, 0x8b, 0x96, 0x40, 0x05, 0xe7, 0x96, 0xff, 0x80, //0x8420,
    0x08, 0xc3, 0x79, 0x8b, 0xe7, 0x78, 0x8c, 0x96, 0xff, 0x78, 0x8f, 0xa6, 0x07, 0xe5, 0x1f, 0x64, //0x8430,
    0x02, 0x70, 0x69, 0x90, 0x0e, 0x91, 0x93, 0xff, 0x18, 0xe6, 0xc3, 0x9f, 0x50, 0x72, 0x12, 0x0c, //0x8440,
    0x4a, 0x12, 0x0c, 0x2f, 0x90, 0x0e, 0x8e, 0x12, 0x0c, 0x38, 0x78, 0x80, 0x12, 0x0c, 0x6b, 0x7b, //0x8450,
    0x04, 0x12, 0x0c, 0x1d, 0xc3, 0x12, 0x06, 0x45, 0x50, 0x56, 0x90, 0x0e, 0x92, 0xe4, 0x93, 0xff, //0x8460,
    0x78, 0x8f, 0xe6, 0x9f, 0x40, 0x02, 0x80, 0x11, 0x90, 0x0e, 0x90, 0xe4, 0x93, 0xff, 0xd3, 0x78, //0x8470,
    0x89, 0xe6, 0x9f, 0x18, 0xe6, 0x94, 0x00, 0x40, 0x03, 0x75, 0x1f, 0x05, 0x12, 0x0c, 0x4a, 0x12, //0x8480,
    0x0c, 0x2f, 0x90, 0x0e, 0x8f, 0x12, 0x0c, 0x38, 0x78, 0x7e, 0x12, 0x0c, 0x6b, 0x7b, 0x40, 0x12, //0x8490,
    0x0c, 0x1d, 0xd3, 0x12, 0x06, 0x45, 0x40, 0x18, 0x75, 0x1f, 0x05, 0x22, 0xe5, 0x1f, 0xb4, 0x05, //0x84a0,
    0x0f, 0xd2, 0x01, 0xc2, 0x02, 0xe4, 0xf5, 0x1f, 0xf5, 0x1e, 0xd2, 0x35, 0xd2, 0x33, 0xd2, 0x36, //0x84b0,
    0x22, 0xef, 0x8d, 0xf0, 0xa4, 0xa8, 0xf0, 0xcf, 0x8c, 0xf0, 0xa4, 0x28, 0xce, 0x8d, 0xf0, 0xa4, //0x84c0,
    0x2e, 0xfe, 0x22, 0xbc, 0x00, 0x0b, 0xbe, 0x00, 0x29, 0xef, 0x8d, 0xf0, 0x84, 0xff, 0xad, 0xf0, //0x84d0,
    0x22, 0xe4, 0xcc, 0xf8, 0x75, 0xf0, 0x08, 0xef, 0x2f, 0xff, 0xee, 0x33, 0xfe, 0xec, 0x33, 0xfc, //0x84e0,
    0xee, 0x9d, 0xec, 0x98, 0x40, 0x05, 0xfc, 0xee, 0x9d, 0xfe, 0x0f, 0xd5, 0xf0, 0xe9, 0xe4, 0xce, //0x84f0,
    0xfd, 0x22, 0xed, 0xf8, 0xf5, 0xf0, 0xee, 0x84, 0x20, 0xd2, 0x1c, 0xfe, 0xad, 0xf0, 0x75, 0xf0, //0x8500,
    0x08, 0xef, 0x2f, 0xff, 0xed, 0x33, 0xfd, 0x40, 0x07, 0x98, 0x50, 0x06, 0xd5, 0xf0, 0xf2, 0x22, //0x8510,
    0xc3, 0x98, 0xfd, 0x0f, 0xd5, 0xf0, 0xea, 0x22, 0xe8, 0x8f, 0xf0, 0xa4, 0xcc, 0x8b, 0xf0, 0xa4, //0x8520,
    0x2c, 0xfc, 0xe9, 0x8e, 0xf0, 0xa4, 0x2c, 0xfc, 0x8a, 0xf0, 0xed, 0xa4, 0x2c, 0xfc, 0xea, 0x8e, //0x8530,
    0xf0, 0xa4, 0xcd, 0xa8, 0xf0, 0x8b, 0xf0, 0xa4, 0x2d, 0xcc, 0x38, 0x25, 0xf0, 0xfd, 0xe9, 0x8f, //0x8540,
    0xf0, 0xa4, 0x2c, 0xcd, 0x35, 0xf0, 0xfc, 0xeb, 0x8e, 0xf0, 0xa4, 0xfe, 0xa9, 0xf0, 0xeb, 0x8f, //0x8550,
    0xf0, 0xa4, 0xcf, 0xc5, 0xf0, 0x2e, 0xcd, 0x39, 0xfe, 0xe4, 0x3c, 0xfc, 0xea, 0xa4, 0x2d, 0xce, //0x8560,
    0x35, 0xf0, 0xfd, 0xe4, 0x3c, 0xfc, 0x22, 0x75, 0xf0, 0x08, 0x75, 0x82, 0x00, 0xef, 0x2f, 0xff, //0x8570,
    0xee, 0x33, 0xfe, 0xcd, 0x33, 0xcd, 0xcc, 0x33, 0xcc, 0xc5, 0x82, 0x33, 0xc5, 0x82, 0x9b, 0xed, //0x8580,
    0x9a, 0xec, 0x99, 0xe5, 0x82, 0x98, 0x40, 0x0c, 0xf5, 0x82, 0xee, 0x9b, 0xfe, 0xed, 0x9a, 0xfd, //0x8590,
    0xec, 0x99, 0xfc, 0x0f, 0xd5, 0xf0, 0xd6, 0xe4, 0xce, 0xfb, 0xe4, 0xcd, 0xfa, 0xe4, 0xcc, 0xf9, //0x85a0,
    0xa8, 0x82, 0x22, 0xb8, 0x00, 0xc1, 0xb9, 0x00, 0x59, 0xba, 0x00, 0x2d, 0xec, 0x8b, 0xf0, 0x84, //0x85b0,
    0xcf, 0xce, 0xcd, 0xfc, 0xe5, 0xf0, 0xcb, 0xf9, 0x78, 0x18, 0xef, 0x2f, 0xff, 0xee, 0x33, 0xfe, //0x85c0,
    0xed, 0x33, 0xfd, 0xec, 0x33, 0xfc, 0xeb, 0x33, 0xfb, 0x10, 0xd7, 0x03, 0x99, 0x40, 0x04, 0xeb, //0x85d0,
    0x99, 0xfb, 0x0f, 0xd8, 0xe5, 0xe4, 0xf9, 0xfa, 0x22, 0x78, 0x18, 0xef, 0x2f, 0xff, 0xee, 0x33, //0x85e0,
    0xfe, 0xed, 0x33, 0xfd, 0xec, 0x33, 0xfc, 0xc9, 0x33, 0xc9, 0x10, 0xd7, 0x05, 0x9b, 0xe9, 0x9a, //0x85f0,
    0x40, 0x07, 0xec, 0x9b, 0xfc, 0xe9, 0x9a, 0xf9, 0x0f, 0xd8, 0xe0, 0xe4, 0xc9, 0xfa, 0xe4, 0xcc, //0x8600,
    0xfb, 0x22, 0x75, 0xf0, 0x10, 0xef, 0x2f, 0xff, 0xee, 0x33, 0xfe, 0xed, 0x33, 0xfd, 0xcc, 0x33, //0x8610,
    0xcc, 0xc8, 0x33, 0xc8, 0x10, 0xd7, 0x07, 0x9b, 0xec, 0x9a, 0xe8, 0x99, 0x40, 0x0a, 0xed, 0x9b, //0x8620,
    0xfd, 0xec, 0x9a, 0xfc, 0xe8, 0x99, 0xf8, 0x0f, 0xd5, 0xf0, 0xda, 0xe4, 0xcd, 0xfb, 0xe4, 0xcc, //0x8630,
    0xfa, 0xe4, 0xc8, 0xf9, 0x22, 0xeb, 0x9f, 0xf5, 0xf0, 0xea, 0x9e, 0x42, 0xf0, 0xe9, 0x9d, 0x42, //0x8640,
    0xf0, 0xe8, 0x9c, 0x45, 0xf0, 0x22, 0xe8, 0x60, 0x0f, 0xec, 0xc3, 0x13, 0xfc, 0xed, 0x13, 0xfd, //0x8650,
    0xee, 0x13, 0xfe, 0xef, 0x13, 0xff, 0xd8, 0xf1, 0x22, 0xe8, 0x60, 0x0f, 0xef, 0xc3, 0x33, 0xff, //0x8660,
    0xee, 0x33, 0xfe, 0xed, 0x33, 0xfd, 0xec, 0x33, 0xfc, 0xd8, 0xf1, 0x22, 0xe4, 0x93, 0xfc, 0x74, //0x8670,
    0x01, 0x93, 0xfd, 0x74, 0x02, 0x93, 0xfe, 0x74, 0x03, 0x93, 0xff, 0x22, 0xe6, 0xfb, 0x08, 0xe6, //0x8680,
    0xf9, 0x08, 0xe6, 0xfa, 0x08, 0xe6, 0xcb, 0xf8, 0x22, 0xec, 0xf6, 0x08, 0xed, 0xf6, 0x08, 0xee, //0x8690,
    0xf6, 0x08, 0xef, 0xf6, 0x22, 0xa4, 0x25, 0x82, 0xf5, 0x82, 0xe5, 0xf0, 0x35, 0x83, 0xf5, 0x83, //0x86a0,
    0x22, 0xd0, 0x83, 0xd0, 0x82, 0xf8, 0xe4, 0x93, 0x70, 0x12, 0x74, 0x01, 0x93, 0x70, 0x0d, 0xa3, //0x86b0,
    0xa3, 0x93, 0xf8, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x88, 0x83, 0xe4, 0x73, 0x74, 0x02, 0x93, 0x68, //0x86c0,
    0x60, 0xef, 0xa3, 0xa3, 0xa3, 0x80, 0xdf, 0x90, 0x38, 0x04, 0x78, 0x52, 0x12, 0x0b, 0xfd, 0x90, //0x86d0,
    0x38, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xed, 0xff, 0xc3, 0x12, 0x0b, 0x9e, 0x90, 0x38, 0x10, //0x86e0,
    0x12, 0x0b, 0x92, 0x90, 0x38, 0x06, 0x78, 0x54, 0x12, 0x0b, 0xfd, 0x90, 0x38, 0x02, 0xe0, 0xfe, //0x86f0,
    0xa3, 0xe0, 0xfd, 0xed, 0xff, 0xc3, 0x12, 0x0b, 0x9e, 0x90, 0x38, 0x12, 0x12, 0x0b, 0x92, 0xa3, //0x8700,
    0xe0, 0xb4, 0x31, 0x07, 0x78, 0x52, 0x79, 0x52, 0x12, 0x0c, 0x13, 0x90, 0x38, 0x14, 0xe0, 0xb4, //0x8710,
    0x71, 0x15, 0x78, 0x52, 0xe6, 0xfe, 0x08, 0xe6, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, //0x8720,
    0xf9, 0x79, 0x53, 0xf7, 0xee, 0x19, 0xf7, 0x90, 0x38, 0x15, 0xe0, 0xb4, 0x31, 0x07, 0x78, 0x54, //0x8730,
    0x79, 0x54, 0x12, 0x0c, 0x13, 0x90, 0x38, 0x15, 0xe0, 0xb4, 0x71, 0x15, 0x78, 0x54, 0xe6, 0xfe, //0x8740,
    0x08, 0xe6, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x79, 0x55, 0xf7, 0xee, 0x19, //0x8750,
    0xf7, 0x79, 0x52, 0x12, 0x0b, 0xd9, 0x09, 0x12, 0x0b, 0xd9, 0xaf, 0x47, 0x12, 0x0b, 0xb2, 0xe5, //0x8760,
    0x44, 0xfb, 0x7a, 0x00, 0xfd, 0x7c, 0x00, 0x12, 0x04, 0xd3, 0x78, 0x5a, 0xa6, 0x06, 0x08, 0xa6, //0x8770,
    0x07, 0xaf, 0x45, 0x12, 0x0b, 0xb2, 0xad, 0x03, 0x7c, 0x00, 0x12, 0x04, 0xd3, 0x78, 0x56, 0xa6, //0x8780,
    0x06, 0x08, 0xa6, 0x07, 0xaf, 0x48, 0x78, 0x54, 0x12, 0x0b, 0xb4, 0xe5, 0x43, 0xfb, 0xfd, 0x7c, //0x8790,
    0x00, 0x12, 0x04, 0xd3, 0x78, 0x5c, 0xa6, 0x06, 0x08, 0xa6, 0x07, 0xaf, 0x46, 0x7e, 0x00, 0x78, //0x87a0,
    0x54, 0x12, 0x0b, 0xb6, 0xad, 0x03, 0x7c, 0x00, 0x12, 0x04, 0xd3, 0x78, 0x58, 0xa6, 0x06, 0x08, //0x87b0,
    0xa6, 0x07, 0xc3, 0x78, 0x5b, 0xe6, 0x94, 0x08, 0x18, 0xe6, 0x94, 0x00, 0x50, 0x05, 0x76, 0x00, //0x87c0,
    0x08, 0x76, 0x08, 0xc3, 0x78, 0x5d, 0xe6, 0x94, 0x08, 0x18, 0xe6, 0x94, 0x00, 0x50, 0x05, 0x76, //0x87d0,
    0x00, 0x08, 0x76, 0x08, 0x78, 0x5a, 0x12, 0x0b, 0xc6, 0xff, 0xd3, 0x78, 0x57, 0xe6, 0x9f, 0x18, //0x87e0,
    0xe6, 0x9e, 0x40, 0x0e, 0x78, 0x5a, 0xe6, 0x13, 0xfe, 0x08, 0xe6, 0x78, 0x57, 0x12, 0x0c, 0x08, //0x87f0,
    0x80, 0x04, 0x7e, 0x00, 0x7f, 0x00, 0x78, 0x5e, 0x12, 0x0b, 0xbe, 0xff, 0xd3, 0x78, 0x59, 0xe6, //0x8800,
    0x9f, 0x18, 0xe6, 0x9e, 0x40, 0x0e, 0x78, 0x5c, 0xe6, 0x13, 0xfe, 0x08, 0xe6, 0x78, 0x59, 0x12, //0x8810,
    0x0c, 0x08, 0x80, 0x04, 0x7e, 0x00, 0x7f, 0x00, 0xe4, 0xfc, 0xfd, 0x78, 0x62, 0x12, 0x06, 0x99, //0x8820,
    0x78, 0x5a, 0x12, 0x0b, 0xc6, 0x78, 0x57, 0x26, 0xff, 0xee, 0x18, 0x36, 0xfe, 0x78, 0x66, 0x12, //0x8830,
    0x0b, 0xbe, 0x78, 0x59, 0x26, 0xff, 0xee, 0x18, 0x36, 0xfe, 0xe4, 0xfc, 0xfd, 0x78, 0x6a, 0x12, //0x8840,
    0x06, 0x99, 0x12, 0x0b, 0xce, 0x78, 0x66, 0x12, 0x06, 0x8c, 0xd3, 0x12, 0x06, 0x45, 0x40, 0x08, //0x8850,
    0x12, 0x0b, 0xce, 0x78, 0x66, 0x12, 0x06, 0x99, 0x78, 0x54, 0x12, 0x0b, 0xd0, 0x78, 0x6a, 0x12, //0x8860,
    0x06, 0x8c, 0xd3, 0x12, 0x06, 0x45, 0x40, 0x0a, 0x78, 0x54, 0x12, 0x0b, 0xd0, 0x78, 0x6a, 0x12, //0x8870,
    0x06, 0x99, 0x78, 0x61, 0xe6, 0x90, 0x60, 0x01, 0xf0, 0x78, 0x65, 0xe6, 0xa3, 0xf0, 0x78, 0x69, //0x8880,
    0xe6, 0xa3, 0xf0, 0x78, 0x55, 0xe6, 0xa3, 0xf0, 0x7d, 0x01, 0x78, 0x61, 0x12, 0x0b, 0xe9, 0x24, //0x8890,
    0x01, 0x12, 0x0b, 0xa6, 0x78, 0x65, 0x12, 0x0b, 0xe9, 0x24, 0x02, 0x12, 0x0b, 0xa6, 0x78, 0x69, //0x88a0,
    0x12, 0x0b, 0xe9, 0x24, 0x03, 0x12, 0x0b, 0xa6, 0x78, 0x6d, 0x12, 0x0b, 0xe9, 0x24, 0x04, 0x12, //0x88b0,
    0x0b, 0xa6, 0x0d, 0xbd, 0x05, 0xd4, 0xc2, 0x0e, 0xc2, 0x06, 0x22, 0x85, 0x08, 0x41, 0x90, 0x30, //0x88c0,
    0x24, 0xe0, 0xf5, 0x3d, 0xa3, 0xe0, 0xf5, 0x3e, 0xa3, 0xe0, 0xf5, 0x3f, 0xa3, 0xe0, 0xf5, 0x40, //0x88d0,
    0xa3, 0xe0, 0xf5, 0x3c, 0xd2, 0x34, 0xe5, 0x41, 0x12, 0x06, 0xb1, 0x09, 0x31, 0x03, 0x09, 0x35, //0x88e0,
    0x04, 0x09, 0x3b, 0x05, 0x09, 0x3e, 0x06, 0x09, 0x41, 0x07, 0x09, 0x4a, 0x08, 0x09, 0x5b, 0x12, //0x88f0,
    0x09, 0x73, 0x18, 0x09, 0x89, 0x19, 0x09, 0x5e, 0x1a, 0x09, 0x6a, 0x1b, 0x09, 0xad, 0x80, 0x09, //0x8900,
    0xb2, 0x81, 0x0a, 0x1d, 0x8f, 0x0a, 0x09, 0x90, 0x0a, 0x1d, 0x91, 0x0a, 0x1d, 0x92, 0x0a, 0x1d, //0x8910,
    0x93, 0x0a, 0x1d, 0x94, 0x0a, 0x1d, 0x98, 0x0a, 0x17, 0x9f, 0x0a, 0x1a, 0xec, 0x00, 0x00, 0x0a, //0x8920,
    0x38, 0x12, 0x0f, 0x74, 0x22, 0x12, 0x0f, 0x74, 0xd2, 0x03, 0x22, 0xd2, 0x03, 0x22, 0xc2, 0x03, //0x8930,
    0x22, 0xa2, 0x37, 0xe4, 0x33, 0xf5, 0x3c, 0x02, 0x0a, 0x1d, 0xc2, 0x01, 0xc2, 0x02, 0xc2, 0x03, //0x8940,
    0x12, 0x0d, 0x0d, 0x75, 0x1e, 0x70, 0xd2, 0x35, 0x02, 0x0a, 0x1d, 0x02, 0x0a, 0x04, 0x85, 0x40, //0x8950,
    0x4a, 0x85, 0x3c, 0x4b, 0x12, 0x0a, 0xff, 0x02, 0x0a, 0x1d, 0x85, 0x4a, 0x40, 0x85, 0x4b, 0x3c, //0x8960,
    0x02, 0x0a, 0x1d, 0xe4, 0xf5, 0x22, 0xf5, 0x23, 0x85, 0x40, 0x31, 0x85, 0x3f, 0x30, 0x85, 0x3e, //0x8970,
    0x2f, 0x85, 0x3d, 0x2e, 0x12, 0x0f, 0x46, 0x80, 0x1f, 0x75, 0x22, 0x00, 0x75, 0x23, 0x01, 0x74, //0x8980,
    0xff, 0xf5, 0x2d, 0xf5, 0x2c, 0xf5, 0x2b, 0xf5, 0x2a, 0x12, 0x0f, 0x46, 0x85, 0x2d, 0x40, 0x85, //0x8990,
    0x2c, 0x3f, 0x85, 0x2b, 0x3e, 0x85, 0x2a, 0x3d, 0xe4, 0xf5, 0x3c, 0x80, 0x70, 0x12, 0x0f, 0x16, //0x89a0,
    0x80, 0x6b, 0x85, 0x3d, 0x45, 0x85, 0x3e, 0x46, 0xe5, 0x47, 0xc3, 0x13, 0xff, 0xe5, 0x45, 0xc3, //0x89b0,
    0x9f, 0x50, 0x02, 0x8f, 0x45, 0xe5, 0x48, 0xc3, 0x13, 0xff, 0xe5, 0x46, 0xc3, 0x9f, 0x50, 0x02, //0x89c0,
    0x8f, 0x46, 0xe5, 0x47, 0xc3, 0x13, 0xff, 0xfd, 0xe5, 0x45, 0x2d, 0xfd, 0xe4, 0x33, 0xfc, 0xe5, //0x89d0,
    0x44, 0x12, 0x0f, 0x90, 0x40, 0x05, 0xe5, 0x44, 0x9f, 0xf5, 0x45, 0xe5, 0x48, 0xc3, 0x13, 0xff, //0x89e0,
    0xfd, 0xe5, 0x46, 0x2d, 0xfd, 0xe4, 0x33, 0xfc, 0xe5, 0x43, 0x12, 0x0f, 0x90, 0x40, 0x05, 0xe5, //0x89f0,
    0x43, 0x9f, 0xf5, 0x46, 0x12, 0x06, 0xd7, 0x80, 0x14, 0x85, 0x40, 0x48, 0x85, 0x3f, 0x47, 0x85, //0x8a00,
    0x3e, 0x46, 0x85, 0x3d, 0x45, 0x80, 0x06, 0x02, 0x06, 0xd7, 0x12, 0x0d, 0x7e, 0x90, 0x30, 0x24, //0x8a10,
    0xe5, 0x3d, 0xf0, 0xa3, 0xe5, 0x3e, 0xf0, 0xa3, 0xe5, 0x3f, 0xf0, 0xa3, 0xe5, 0x40, 0xf0, 0xa3, //0x8a20,
    0xe5, 0x3c, 0xf0, 0x90, 0x30, 0x23, 0xe4, 0xf0, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, //0x8a30,
    0xd0, 0x90, 0x3f, 0x0c, 0xe0, 0xf5, 0x32, 0xe5, 0x32, 0x30, 0xe3, 0x74, 0x30, 0x36, 0x66, 0x90, //0x8a40,
    0x60, 0x19, 0xe0, 0xf5, 0x0a, 0xa3, 0xe0, 0xf5, 0x0b, 0x90, 0x60, 0x1d, 0xe0, 0xf5, 0x14, 0xa3, //0x8a50,
    0xe0, 0xf5, 0x15, 0x90, 0x60, 0x21, 0xe0, 0xf5, 0x0c, 0xa3, 0xe0, 0xf5, 0x0d, 0x90, 0x60, 0x29, //0x8a60,
    0xe0, 0xf5, 0x0e, 0xa3, 0xe0, 0xf5, 0x0f, 0x90, 0x60, 0x31, 0xe0, 0xf5, 0x10, 0xa3, 0xe0, 0xf5, //0x8a70,
    0x11, 0x90, 0x60, 0x39, 0xe0, 0xf5, 0x12, 0xa3, 0xe0, 0xf5, 0x13, 0x30, 0x01, 0x06, 0x30, 0x33, //0x8a80,
    0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x09, 0x30, 0x02, 0x06, 0x30, 0x33, 0x03, 0xd3, 0x80, 0x01, //0x8a90,
    0xc3, 0x92, 0x0a, 0x30, 0x33, 0x0c, 0x30, 0x03, 0x09, 0x20, 0x02, 0x06, 0x20, 0x01, 0x03, 0xd3, //0x8aa0,
    0x80, 0x01, 0xc3, 0x92, 0x0b, 0x90, 0x30, 0x01, 0xe0, 0x44, 0x40, 0xf0, 0xe0, 0x54, 0xbf, 0xf0, //0x8ab0,
    0xe5, 0x32, 0x30, 0xe1, 0x14, 0x30, 0x34, 0x11, 0x90, 0x30, 0x22, 0xe0, 0xf5, 0x08, 0xe4, 0xf0, //0x8ac0,
    0x30, 0x00, 0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x08, 0xe5, 0x32, 0x30, 0xe5, 0x12, 0x90, 0x56, //0x8ad0,
    0xa1, 0xe0, 0xf5, 0x09, 0x30, 0x31, 0x09, 0x30, 0x05, 0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x0d, //0x8ae0,
    0x90, 0x3f, 0x0c, 0xe5, 0x32, 0xf0, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x90, //0x8af0,
    0x0e, 0x7e, 0xe4, 0x93, 0xfe, 0x74, 0x01, 0x93, 0xff, 0xc3, 0x90, 0x0e, 0x7c, 0x74, 0x01, 0x93, //0x8b00,
    0x9f, 0xff, 0xe4, 0x93, 0x9e, 0xfe, 0xe4, 0x8f, 0x3b, 0x8e, 0x3a, 0xf5, 0x39, 0xf5, 0x38, 0xab, //0x8b10,
    0x3b, 0xaa, 0x3a, 0xa9, 0x39, 0xa8, 0x38, 0xaf, 0x4b, 0xfc, 0xfd, 0xfe, 0x12, 0x05, 0x28, 0x12, //0x8b20,
    0x0d, 0xe1, 0xe4, 0x7b, 0xff, 0xfa, 0xf9, 0xf8, 0x12, 0x05, 0xb3, 0x12, 0x0d, 0xe1, 0x90, 0x0e, //0x8b30,
    0x69, 0xe4, 0x12, 0x0d, 0xf6, 0x12, 0x0d, 0xe1, 0xe4, 0x85, 0x4a, 0x37, 0xf5, 0x36, 0xf5, 0x35, //0x8b40,
    0xf5, 0x34, 0xaf, 0x37, 0xae, 0x36, 0xad, 0x35, 0xac, 0x34, 0xa3, 0x12, 0x0d, 0xf6, 0x8f, 0x37, //0x8b50,
    0x8e, 0x36, 0x8d, 0x35, 0x8c, 0x34, 0xe5, 0x3b, 0x45, 0x37, 0xf5, 0x3b, 0xe5, 0x3a, 0x45, 0x36, //0x8b60,
    0xf5, 0x3a, 0xe5, 0x39, 0x45, 0x35, 0xf5, 0x39, 0xe5, 0x38, 0x45, 0x34, 0xf5, 0x38, 0xe4, 0xf5, //0x8b70,
    0x22, 0xf5, 0x23, 0x85, 0x3b, 0x31, 0x85, 0x3a, 0x30, 0x85, 0x39, 0x2f, 0x85, 0x38, 0x2e, 0x02, //0x8b80,
    0x0f, 0x46, 0xe0, 0xa3, 0xe0, 0x75, 0xf0, 0x02, 0xa4, 0xff, 0xae, 0xf0, 0xc3, 0x08, 0xe6, 0x9f, //0x8b90,
    0xf6, 0x18, 0xe6, 0x9e, 0xf6, 0x22, 0xff, 0xe5, 0xf0, 0x34, 0x60, 0x8f, 0x82, 0xf5, 0x83, 0xec, //0x8ba0,
    0xf0, 0x22, 0x78, 0x52, 0x7e, 0x00, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x02, 0x04, 0xc1, 0xe4, 0xfc, //0x8bb0,
    0xfd, 0x12, 0x06, 0x99, 0x78, 0x5c, 0xe6, 0xc3, 0x13, 0xfe, 0x08, 0xe6, 0x13, 0x22, 0x78, 0x52, //0x8bc0,
    0xe6, 0xfe, 0x08, 0xe6, 0xff, 0xe4, 0xfc, 0xfd, 0x22, 0xe7, 0xc4, 0xf8, 0x54, 0xf0, 0xc8, 0x68, //0x8bd0,
    0xf7, 0x09, 0xe7, 0xc4, 0x54, 0x0f, 0x48, 0xf7, 0x22, 0xe6, 0xfc, 0xed, 0x75, 0xf0, 0x04, 0xa4, //0x8be0,
    0x22, 0x12, 0x06, 0x7c, 0x8f, 0x48, 0x8e, 0x47, 0x8d, 0x46, 0x8c, 0x45, 0x22, 0xe0, 0xfe, 0xa3, //0x8bf0,
    0xe0, 0xfd, 0xee, 0xf6, 0xed, 0x08, 0xf6, 0x22, 0x13, 0xff, 0xc3, 0xe6, 0x9f, 0xff, 0x18, 0xe6, //0x8c00,
    0x9e, 0xfe, 0x22, 0xe6, 0xc3, 0x13, 0xf7, 0x08, 0xe6, 0x13, 0x09, 0xf7, 0x22, 0xad, 0x39, 0xac, //0x8c10,
    0x38, 0xfa, 0xf9, 0xf8, 0x12, 0x05, 0x28, 0x8f, 0x3b, 0x8e, 0x3a, 0x8d, 0x39, 0x8c, 0x38, 0xab, //0x8c20,
    0x37, 0xaa, 0x36, 0xa9, 0x35, 0xa8, 0x34, 0x22, 0x93, 0xff, 0xe4, 0xfc, 0xfd, 0xfe, 0x12, 0x05, //0x8c30,
    0x28, 0x8f, 0x37, 0x8e, 0x36, 0x8d, 0x35, 0x8c, 0x34, 0x22, 0x78, 0x84, 0xe6, 0xfe, 0x08, 0xe6, //0x8c40,
    0xff, 0xe4, 0x8f, 0x37, 0x8e, 0x36, 0xf5, 0x35, 0xf5, 0x34, 0x22, 0x90, 0x0e, 0x8c, 0xe4, 0x93, //0x8c50,
    0x25, 0xe0, 0x24, 0x0a, 0xf8, 0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe6, 0xfe, 0x08, 0xe6, 0xff, //0x8c60,
    0xe4, 0x8f, 0x3b, 0x8e, 0x3a, 0xf5, 0x39, 0xf5, 0x38, 0x22, 0x78, 0x4e, 0xe6, 0xfe, 0x08, 0xe6, //0x8c70,
    0xff, 0x22, 0xef, 0x25, 0xe0, 0x24, 0x4e, 0xf8, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x22, 0x78, 0x89, //0x8c80,
    0xef, 0x26, 0xf6, 0x18, 0xe4, 0x36, 0xf6, 0x22, 0x75, 0x89, 0x03, 0x75, 0xa8, 0x01, 0x75, 0xb8, //0x8c90,
    0x04, 0x75, 0x34, 0xff, 0x75, 0x35, 0x0e, 0x75, 0x36, 0x15, 0x75, 0x37, 0x0d, 0x12, 0x0e, 0x9a, //0x8ca0,
    0x12, 0x00, 0x09, 0x12, 0x0f, 0x16, 0x12, 0x00, 0x06, 0xd2, 0x00, 0xd2, 0x34, 0xd2, 0xaf, 0x75, //0x8cb0,
    0x34, 0xff, 0x75, 0x35, 0x0e, 0x75, 0x36, 0x49, 0x75, 0x37, 0x03, 0x12, 0x0e, 0x9a, 0x30, 0x08, //0x8cc0,
    0x09, 0xc2, 0x34, 0x12, 0x08, 0xcb, 0xc2, 0x08, 0xd2, 0x34, 0x30, 0x0b, 0x09, 0xc2, 0x36, 0x12, //0x8cd0,
    0x02, 0x6c, 0xc2, 0x0b, 0xd2, 0x36, 0x30, 0x09, 0x09, 0xc2, 0x36, 0x12, 0x00, 0x0e, 0xc2, 0x09, //0x8ce0,
    0xd2, 0x36, 0x30, 0x0e, 0x03, 0x12, 0x06, 0xd7, 0x30, 0x35, 0xd3, 0x90, 0x30, 0x29, 0xe5, 0x1e, //0x8cf0,
    0xf0, 0xb4, 0x10, 0x05, 0x90, 0x30, 0x23, 0xe4, 0xf0, 0xc2, 0x35, 0x80, 0xc1, 0xe4, 0xf5, 0x4b, //0x8d00,
    0x90, 0x0e, 0x7a, 0x93, 0xff, 0xe4, 0x8f, 0x37, 0xf5, 0x36, 0xf5, 0x35, 0xf5, 0x34, 0xaf, 0x37, //0x8d10,
    0xae, 0x36, 0xad, 0x35, 0xac, 0x34, 0x90, 0x0e, 0x6a, 0x12, 0x0d, 0xf6, 0x8f, 0x37, 0x8e, 0x36, //0x8d20,
    0x8d, 0x35, 0x8c, 0x34, 0x90, 0x0e, 0x72, 0x12, 0x06, 0x7c, 0xef, 0x45, 0x37, 0xf5, 0x37, 0xee, //0x8d30,
    0x45, 0x36, 0xf5, 0x36, 0xed, 0x45, 0x35, 0xf5, 0x35, 0xec, 0x45, 0x34, 0xf5, 0x34, 0xe4, 0xf5, //0x8d40,
    0x22, 0xf5, 0x23, 0x85, 0x37, 0x31, 0x85, 0x36, 0x30, 0x85, 0x35, 0x2f, 0x85, 0x34, 0x2e, 0x12, //0x8d50,
    0x0f, 0x46, 0xe4, 0xf5, 0x22, 0xf5, 0x23, 0x90, 0x0e, 0x72, 0x12, 0x0d, 0xea, 0x12, 0x0f, 0x46, //0x8d60,
    0xe4, 0xf5, 0x22, 0xf5, 0x23, 0x90, 0x0e, 0x6e, 0x12, 0x0d, 0xea, 0x02, 0x0f, 0x46, 0xe5, 0x40, //0x8d70,
    0x24, 0xf2, 0xf5, 0x37, 0xe5, 0x3f, 0x34, 0x43, 0xf5, 0x36, 0xe5, 0x3e, 0x34, 0xa2, 0xf5, 0x35, //0x8d80,
    0xe5, 0x3d, 0x34, 0x28, 0xf5, 0x34, 0xe5, 0x37, 0xff, 0xe4, 0xfe, 0xfd, 0xfc, 0x78, 0x18, 0x12, //0x8d90,
    0x06, 0x69, 0x8f, 0x40, 0x8e, 0x3f, 0x8d, 0x3e, 0x8c, 0x3d, 0xe5, 0x37, 0x54, 0xa0, 0xff, 0xe5, //0x8da0,
    0x36, 0xfe, 0xe4, 0xfd, 0xfc, 0x78, 0x07, 0x12, 0x06, 0x56, 0x78, 0x10, 0x12, 0x0f, 0x9a, 0xe4, //0x8db0,
    0xff, 0xfe, 0xe5, 0x35, 0xfd, 0xe4, 0xfc, 0x78, 0x0e, 0x12, 0x06, 0x56, 0x12, 0x0f, 0x9d, 0xe4, //0x8dc0,
    0xff, 0xfe, 0xfd, 0xe5, 0x34, 0xfc, 0x78, 0x18, 0x12, 0x06, 0x56, 0x78, 0x08, 0x12, 0x0f, 0x9a, //0x8dd0,
    0x22, 0x8f, 0x3b, 0x8e, 0x3a, 0x8d, 0x39, 0x8c, 0x38, 0x22, 0x12, 0x06, 0x7c, 0x8f, 0x31, 0x8e, //0x8de0,
    0x30, 0x8d, 0x2f, 0x8c, 0x2e, 0x22, 0x93, 0xf9, 0xf8, 0x02, 0x06, 0x69, 0x00, 0x00, 0x00, 0x00, //0x8df0,
    0x12, 0x01, 0x17, 0x08, 0x31, 0x15, 0x53, 0x54, 0x44, 0x20, 0x20, 0x20, 0x20, 0x20, 0x13, 0x01, //0x8e00,
    0x10, 0x01, 0x56, 0x40, 0x1a, 0x30, 0x29, 0x7e, 0x00, 0x30, 0x04, 0x20, 0xdf, 0x30, 0x05, 0x40, //0x8e10,
    0xbf, 0x50, 0x03, 0x00, 0xfd, 0x50, 0x27, 0x01, 0xfe, 0x60, 0x00, 0x11, 0x00, 0x3f, 0x05, 0x30, //0x8e20,
    0x00, 0x3f, 0x06, 0x22, 0x00, 0x3f, 0x01, 0x2a, 0x00, 0x3f, 0x02, 0x00, 0x00, 0x36, 0x06, 0x07, //0x8e30,
    0x00, 0x3f, 0x0b, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x30, 0x01, 0x40, 0xbf, 0x30, 0x01, 0x00, //0x8e40,
    0xbf, 0x30, 0x29, 0x70, 0x00, 0x3a, 0x00, 0x00, 0xff, 0x3a, 0x00, 0x00, 0xff, 0x36, 0x03, 0x36, //0x8e50,
    0x02, 0x41, 0x44, 0x58, 0x20, 0x18, 0x10, 0x0a, 0x04, 0x04, 0x00, 0x03, 0xff, 0x64, 0x00, 0x00, //0x8e60,
    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x06, 0x06, 0x00, 0x03, 0x51, 0x00, 0x7a, //0x8e70,
    0x50, 0x3c, 0x28, 0x1e, 0x10, 0x10, 0x50, 0x2d, 0x28, 0x16, 0x10, 0x10, 0x02, 0x00, 0x10, 0x0c, //0x8e80,
    0x10, 0x04, 0x0c, 0x6e, 0x06, 0x05, 0x00, 0xa5, 0x5a, 0x00, 0xae, 0x35, 0xaf, 0x36, 0xe4, 0xfd, //0x8e90,
    0xed, 0xc3, 0x95, 0x37, 0x50, 0x33, 0x12, 0x0f, 0xe2, 0xe4, 0x93, 0xf5, 0x38, 0x74, 0x01, 0x93, //0x8ea0,
    0xf5, 0x39, 0x45, 0x38, 0x60, 0x23, 0x85, 0x39, 0x82, 0x85, 0x38, 0x83, 0xe0, 0xfc, 0x12, 0x0f, //0x8eb0,
    0xe2, 0x74, 0x03, 0x93, 0x52, 0x04, 0x12, 0x0f, 0xe2, 0x74, 0x02, 0x93, 0x42, 0x04, 0x85, 0x39, //0x8ec0,
    0x82, 0x85, 0x38, 0x83, 0xec, 0xf0, 0x0d, 0x80, 0xc7, 0x22, 0x78, 0xbe, 0xe6, 0xd3, 0x08, 0xff, //0x8ed0,
    0xe6, 0x64, 0x80, 0xf8, 0xef, 0x64, 0x80, 0x98, 0x22, 0x93, 0xff, 0x7e, 0x00, 0xe6, 0xfc, 0x08, //0x8ee0,
    0xe6, 0xfd, 0x12, 0x04, 0xc1, 0x78, 0xc1, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0xd3, 0xef, 0x9d, 0xee, //0x8ef0,
    0x9c, 0x22, 0x78, 0xbd, 0xd3, 0xe6, 0x64, 0x80, 0x94, 0x80, 0x22, 0x25, 0xe0, 0x24, 0x0a, 0xf8, //0x8f00,
    0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe5, 0x3c, 0xd3, 0x94, 0x00, 0x40, 0x0b, 0x90, 0x0e, 0x88, //0x8f10,
    0x12, 0x0b, 0xf1, 0x90, 0x0e, 0x86, 0x80, 0x09, 0x90, 0x0e, 0x82, 0x12, 0x0b, 0xf1, 0x90, 0x0e, //0x8f20,
    0x80, 0xe4, 0x93, 0xf5, 0x44, 0xa3, 0xe4, 0x93, 0xf5, 0x43, 0xd2, 0x06, 0x30, 0x06, 0x03, 0xd3, //0x8f30,
    0x80, 0x01, 0xc3, 0x92, 0x0e, 0x22, 0xa2, 0xaf, 0x92, 0x32, 0xc2, 0xaf, 0xe5, 0x23, 0x45, 0x22, //0x8f40,
    0x90, 0x0e, 0x5d, 0x60, 0x0e, 0x12, 0x0f, 0xcb, 0xe0, 0xf5, 0x2c, 0x12, 0x0f, 0xc8, 0xe0, 0xf5, //0x8f50,
    0x2d, 0x80, 0x0c, 0x12, 0x0f, 0xcb, 0xe5, 0x30, 0xf0, 0x12, 0x0f, 0xc8, 0xe5, 0x31, 0xf0, 0xa2, //0x8f60,
    0x32, 0x92, 0xaf, 0x22, 0xd2, 0x01, 0xc2, 0x02, 0xe4, 0xf5, 0x1f, 0xf5, 0x1e, 0xd2, 0x35, 0xd2, //0x8f70,
    0x33, 0xd2, 0x36, 0xd2, 0x01, 0xc2, 0x02, 0xf5, 0x1f, 0xf5, 0x1e, 0xd2, 0x35, 0xd2, 0x33, 0x22, //0x8f80,
    0xfb, 0xd3, 0xed, 0x9b, 0x74, 0x80, 0xf8, 0x6c, 0x98, 0x22, 0x12, 0x06, 0x69, 0xe5, 0x40, 0x2f, //0x8f90,
    0xf5, 0x40, 0xe5, 0x3f, 0x3e, 0xf5, 0x3f, 0xe5, 0x3e, 0x3d, 0xf5, 0x3e, 0xe5, 0x3d, 0x3c, 0xf5, //0x8fa0,
    0x3d, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0x90, 0x3f, 0x0d, 0xe0, 0xf5, 0x33, 0xe5, 0x33, //0x8fb0,
    0xf0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x90, 0x0e, 0x5f, 0xe4, 0x93, 0xfe, 0x74, 0x01, //0x8fc0,
    0x93, 0xf5, 0x82, 0x8e, 0x83, 0x22, 0x78, 0x7f, 0xe4, 0xf6, 0xd8, 0xfd, 0x75, 0x81, 0xcd, 0x02, //0x8fd0,
    0x0c, 0x98, 0x8f, 0x82, 0x8e, 0x83, 0x75, 0xf0, 0x04, 0xed, 0x02, 0x06, 0xa5, //0x8fe0
};
static int ov5640_sensor_read(struct v4l2_subdev *sd, unsigned char *reg,
        unsigned char *value)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    u8 data[REG_STEP];
    struct i2c_msg msg;
    int ret,i;
    for(i = 0; i < REG_ADDR_STEP; i++)
        data[i] = reg[i];
    for(i = REG_ADDR_STEP; i < REG_STEP; i++)
        data[i] = 0xff;
    /*
     * Send out the register address...
     */
    msg.addr = client->addr;
    msg.flags = 0;
    msg.len = REG_ADDR_STEP;
    msg.buf = data;
    ret = i2c_transfer(client->adapter, &msg, 1);
    if (ret < 0) {
        csi_dev_err("Error %d on register write\n", ret);
        return ret;
    }
    /*
     * ...then read back the result.
     */
    msg.flags = I2C_M_RD;
    msg.len = REG_DATA_STEP;
    msg.buf = &data[REG_ADDR_STEP];
    ret = i2c_transfer(client->adapter, &msg, 1);
    if (ret >= 0) {
        for(i = 0; i < REG_DATA_STEP; i++)
            value[i] = data[i+REG_ADDR_STEP];
        ret = 0;
    }
    else {
        csi_dev_err("Error %d on register read\n", ret);
    }
    return ret;
}
static int ov5640_sensor_write(struct v4l2_subdev *sd, unsigned char *reg,
        unsigned char *value)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    struct i2c_msg msg;
    unsigned char data[REG_STEP];
    int ret,i;
    for(i = 0; i < REG_ADDR_STEP; i++)
            data[i] = reg[i];
    for(i = REG_ADDR_STEP; i < REG_STEP; i++)
            data[i] = value[i-REG_ADDR_STEP];
    msg.addr = client->addr;
    msg.flags = 0;
    msg.len = REG_STEP;
    msg.buf = data;
    ret = i2c_transfer(client->adapter, &msg, 1);
    if (ret > 0) {
        ret = 0;
    }
    else if (ret < 0) {
        csi_dev_print("addr = 0x%4x, value = 0x%2x\n ",reg[0]*256+reg[1],value[0]);
        csi_dev_err("sensor_write error!\n");
    }
    return ret;
}
#if 0
static int sensor_write_im(struct v4l2_subdev *sd, unsigned int addr,
        unsigned char value)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    struct i2c_msg msg;
    unsigned char data[REG_STEP];
    int ret;
    unsigned int retry=0;
    data[0] = (addr&0xff00)>>8;
    data[1] = addr&0x00ff;
    data[2] = value;
    msg.addr = client->addr;
    msg.flags = 0;
    msg.len = REG_STEP;
    msg.buf = data;
sensor_write_im_transfer:
    ret = i2c_transfer(client->adapter, &msg, 1);
    if (ret > 0) {
        ret = 0;
    }
    else if (ret < 0) {
        if(retry<3) {
            retry++;
            csi_dev_err("sensor_write retry %d!\n",retry);
            goto sensor_write_im_transfer;
        }
        csi_dev_err("addr = 0x%4x, value = 0x%4x\n ",addr,value);
        csi_dev_err("sensor_write error!\n");
    }
    return ret;
}
#endif
static int ov5640_sensor_write_array(struct v4l2_subdev *sd, struct regval_list *vals , uint size)
{
    int i,ret;
    unsigned int cnt;
//    unsigned char rd;
    if (size == 0)
        return -EINVAL;
    for(i = 0; i < size ; i++)
    {
        if(vals->reg_num[0] == 0xff && vals->reg_num[1] == 0xff) {
            mdelay(vals->value[0]);
        }    
        else {
            cnt=0;
            ret = ov5640_sensor_write(sd, vals->reg_num, vals->value);
            while( ret < 0 && cnt < 3)
            {
                if(ret<0)
                    csi_dev_err("sensor_write_err!\n");
                ret = ov5640_sensor_write(sd, vals->reg_num, vals->value);
                cnt++;
            }
            if(cnt>0)
                csi_dev_err("csi i2c retry cnt=%d\n",cnt);
            if(ret<0 && cnt >=3)
                return ret;
        }
        vals++;
    }
    return 0;
}
static int ov5640_sensor_write_continuous(struct v4l2_subdev *sd, int addr, char vals[] , uint size)
{
    int i,ret;
    struct regval_list reg_addr;
    if (size == 0)
        return -EINVAL;
    for(i = 0; i < size ; i++)
    {
        reg_addr.reg_num[0] = (addr&0xff00)>>8;
        reg_addr.reg_num[1] = (addr&0x00ff);
        ret = ov5640_sensor_write(sd, reg_addr.reg_num, &vals[i]);
        if (ret < 0)
        {
            csi_dev_err("sensor_write_err!\n");
            return ret;
        }
        addr++;
    }
    return 0;
}
/* stuff about auto focus */
static int ov5640_sensor_download_af_fw(struct v4l2_subdev *sd)
{
    int ret,cnt;
    struct regval_list regs;
    struct regval_list af_fw_reset_reg[] = {
        {
   {0x30,0x00},{0x20}},
    };
    struct regval_list af_fw_start_reg[] = {
        {
   {0x30,0x22},{0x00}},
        {
   {0x30,0x23},{0x00}},
        {
   {0x30,0x24},{0x00}},
        {
   {0x30,0x25},{0x00}},
        {
   {0x30,0x26},{0x00}},
        {
   {0x30,0x27},{0x00}},
        {
   {0x30,0x28},{0x00}},
        {
   {0x30,0x29},{0x7f}},//0x7f
        {
   {0x30,0x00},{0x00}},    //start firmware for af
    };
    //reset sensor MCU
    ret = ov5640_sensor_write_array(sd, af_fw_reset_reg, ARRAY_SIZE(af_fw_reset_reg));
    if(ret < 0) {
        csi_dev_err("reset sensor MCU error\n");
        return ret;
    }
    //download af fw
    ret =ov5640_sensor_write_continuous(sd, 0x8000, ov5640_sensor_af_fw_regs, ARRAY_SIZE(ov5640_sensor_af_fw_regs));
    if(ret < 0) {
        csi_dev_err("download af fw error\n");
        return ret;
    }
    //start af firmware
    ret = ov5640_sensor_write_array(sd, af_fw_start_reg, ARRAY_SIZE(af_fw_start_reg));
    if(ret < 0) {
        csi_dev_err("start af firmware error\n");
        return ret;
    }
    mdelay(10);
    //check the af firmware status
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x29;
    regs.value[0] = 0xff;
    cnt = 0;
    while(regs.value[0]!=0x70) {
        mdelay(5);
        ret = ov5640_sensor_read(sd, regs.reg_num, regs.value);
        if (ret < 0)
        {
            csi_dev_err("sensor check the af firmware status err !\n");
            return ret;
        }
        cnt++;
        if(cnt > 200) {
            csi_dev_err("AF firmware check status time out !\n");
            return -EFAULT;
        }
    }
    csi_dev_print("AF firmware check status complete,0x3029 = 0x%x\n",regs.value[0]);
#if DEV_DBG_EN == 1    
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x00;
    ov5640_sensor_read(sd, regs.reg_num, regs.value);
    csi_dev_print("0x3000 = 0x%x\n",regs.value[0]);
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x04;
    ov5640_sensor_read(sd, regs.reg_num, regs.value);
    csi_dev_print("0x3004 = 0x%x\n",regs.value[0]);
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x01;
    ov5640_sensor_read(sd, regs.reg_num, regs.value);
    csi_dev_print("0x3001 = 0x%x\n",regs.value[0]);
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x05;
    ov5640_sensor_read(sd, regs.reg_num, regs.value);
    csi_dev_print("0x3005 = 0x%x\n",regs.value[0]);
#endif
  return 0;
}
static int ov5640_sensor_s_release_af(struct v4l2_subdev *sd)
{
    struct regval_list regs;
    int ret;
    //release focus
    csi_dev_print("sensor_s_release_af\n");
    //trig single af
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x22;
    regs.value[0] = 0x03;    
    ret = ov5640_sensor_write(sd, regs.reg_num, regs.value);
    if (ret < 0)
    {
        csi_dev_err("sensor tigger single af err !\n");
        return ret;
    }
    //release single af
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x22;
    regs.value[0] = 0x08;    
    ret = ov5640_sensor_write(sd, regs.reg_num, regs.value);
    if (ret < 0)
    {
        csi_dev_err("release focus err !\n");
        return ret;
    }
    return 0;
}
static int ov5640_sensor_s_af_zone(struct v4l2_subdev *sd, unsigned int xc, unsigned int yc)
{
    //struct sensor_info *info = to_state(sd);
    struct regval_list regs;
    int ret;
    csi_dev_print("sensor_s_af_zone\n");
    csi_dev_print("af zone input xc=%d,yc=%d\n",xc,yc);
#if 0    
    if(info->width == 0 || info->height == 0) {
        csi_dev_err("current width or height is zero!\n");
        return -EINVAL;
    }
#endif    
    xc = xc * 80 /640;
    yc = yc * 60 / 480;
    //csi_dev_dbg("af zone after xc=%d,yc=%d\n",xc,yc);
    //set x center
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x24;
    regs.value[0] = xc;    
    ret = ov5640_sensor_write(sd, regs.reg_num, regs.value);
    if (ret < 0)
    {
        csi_dev_err("sensor_s_af_zone_xc error!\n");
        return ret;
    }
    //set y center
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x25;
    regs.value[0] = yc;    
    ret = ov5640_sensor_write(sd, regs.reg_num, regs.value);
    if (ret < 0)
    {
        csi_dev_err("sensor_s_af_zone_yc error!\n");
        return ret;
    }
    //set af zone
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x22;
    regs.value[0] = 0x81;    
    ret = ov5640_sensor_write(sd, regs.reg_num, regs.value);
    if (ret < 0)
    {
        csi_dev_err("sensor_s_af_zone error!\n");
        return ret;
    }
    mdelay(5);
    return 0;
}
static int ov5640_sensor_s_pause_af(struct v4l2_subdev *sd)
{
    struct regval_list regs;
    int ret;
    //pause af poisition
    csi_dev_print("sensor_s_pause_af\n");
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x22;
    regs.value[0] = 0x06;    
    ret = ov5640_sensor_write(sd, regs.reg_num, regs.value);
    if (ret < 0)
    {
        csi_dev_err("sensor pause af err !\n");
        return ret;
    }
    mdelay(5);
    return 0;
}
static int ov5640_get_auto_focus_result(struct v4l2_subdev *sd,
                    struct v4l2_control *ctrl)
{
    struct regval_list regs;
    int ret,cnt;
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x23;
    regs.value[0] = 0xff;
    cnt = 0;
        //dg add  2015-07-13 0x3022 register:
       // 0x03 - Trig Single Auto Focus
       // 0x06 - Pause Auto Focus
       // 0x08 - Release Focus
       // 0x12 - Re-launch Focus Zones
       // 0x00 – command is finished
        //send idle command to firmware
        OV5640YUV_write_cmos_sensor(0x3023,0x01);
        OV5640YUV_write_cmos_sensor(0x3022,0x06); //pause auto focus
        //wait for af pause complete
        regs.reg_num[0] = 0x30;
        regs.reg_num[1] = 0x29;//dg change 0x23 to 0x29;
        regs.value[0] = 0xff;
         cnt = 0;
        while(regs.value[0]!=0x10)// dg change 0x00 to 0x10
        {
                mdelay(50);
                ret = ov5640_sensor_read(sd, regs.reg_num, regs.value);
                if (ret < 0)
                {
                        csi_dev_err("sensor get af pause status err !\n");
                        return ret;
                }
                cnt++;
                if(cnt>1000) {
                        csi_dev_err("Single AF  pause is timeout,value = 0x%x\n",regs.value[0]);
                        return -EFAULT;
                }
        }
        printk("pause focus  ok.....................");
    //ov5640_sensor_s_af_zone(sd, 640, 480);
        ctrl->value = AUTO_FOCUS_DONE;
    return 0;
}
static int ov5640_sensor_s_single_af(struct v4l2_subdev *sd)
{
    struct regval_list regs;
    int ret;
    csi_dev_print("sensor_s_single_af\n");
#if 1
    //trig single af
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x23;
    regs.value[0] = 0x01;    
    ret = ov5640_sensor_write(sd, regs.reg_num, regs.value);
    if (ret < 0)
    {
        csi_dev_err("sensor tigger single af err !\n");
        return ret;
    }
#endif
    regs.reg_num[0] = 0x30;
    regs.reg_num[1] = 0x22;
    regs.value[0] = 0x03;    
    ret = ov5640_sensor_write(sd, regs.reg_num, regs.value);
    if (ret < 0)
    {
        csi_dev_err("sensor tigger single af err !\n");
        return ret;
    }
#if 1
    //wait for af complete
    regs.reg_num[0] = 0x30;
        regs.reg_num[1] = 0x29;//dg change 0x23 to 0x29;
    regs.value[0] = 0xff;
        int cnt = 0;
        while(regs.value[0]!=0x10)// dg change 0x00 to 0x10)
    {
                mdelay(50);
        ret = ov5640_sensor_read(sd, regs.reg_num, regs.value);
        if (ret < 0)
        {
            csi_dev_err("sensor get af status err !\n");
            return ret;
        }
        cnt++;
                if(cnt>100) {
            csi_dev_err("Single AF is timeout,value = 0x%x\n",regs.value[0]);
            return -EFAULT;
        }
    }
#else
    ;
#endif
        csi_dev_print("Single AF is complete,value = 0x%x\n",regs.value[0]);
  return 0;
}
/* end add */
static inline struct ov5640_priv *to_ov5640(const struct i2c_client *client)
{
    return container_of(i2c_get_clientdata(client), struct ov5640_priv, subdev);
}
static int write_regs(struct i2c_client *client, 
    const struct regval *regs, int array_len)
{
    int i;
    int ret = 0;
    for (i = 0; i < array_len; i++) {
        if ((ret = i2cc_set_reg(client, regs->reg, regs->val))) {
            OV_ERR("error to set reg:0x%d -> value:%d(index:%d)\n", regs->reg, 
                regs->val, i);
            break;
        }
        regs++;
    }
//    INFO_BLUE("------*------- write array regs over -------*------ \n");
    return (ret);
}
static int ov5640_set_bus_param(struct soc_camera_device *icd, 
    unsigned long flags)
{
    INFO_PURLPLE("\n");
    return 0;
}
static unsigned long ov5640_query_bus_param(struct soc_camera_device *icd)
{
    struct soc_camera_link *icl = to_soc_camera_link(icd);
    /* camera can do 10 bit transfers,  but omit it now */
    unsigned long flags = SOCAM_PCLK_SAMPLE_RISING | SOCAM_MASTER |
        SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_HIGH |
        SOCAM_DATA_ACTIVE_HIGH | SOCAM_DATAWIDTH_8;
    return soc_camera_apply_sensor_flags(icl, flags);
}
static int ov5640_g_chip_ident(struct v4l2_subdev *sd,
                   struct v4l2_dbg_chip_ident *id)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    struct ov5640_priv *priv = to_ov5640(client);
    id->ident = priv->model;
    id->revision = 0;
    return (0);
}
static const struct ov5640_win_size *select_win(
    unsigned int width, unsigned int height)
{
    const struct ov5640_win_size *ret = NULL;
    int size = ARRAY_SIZE(ov5640_wins);
    unsigned int diff = -1;
    unsigned int tmp;
    int i;
    //width = 1600;
    //height = 1200;
    for (i = 0; i < size; i++) {
        tmp = abs(width - ov5640_wins[i].width) + 
            abs(height - ov5640_wins[i].height);
        if (tmp < diff) {
            diff = tmp;
            ret = ov5640_wins + i;
        }
    }
    return (ret); 
}
static int ov5640_try_fmt(struct v4l2_subdev *sd,
    struct v4l2_mbus_framefmt *vmf)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    struct ov5640_priv *priv = to_ov5640(client);
    const struct ov5640_win_size *win;
    int found = 0;
    int i;
    win = select_win(vmf->width, vmf->height);
    vmf->width = win->width;
    vmf->height = win->height;
    vmf->field = V4L2_FIELD_NONE;
    for (i = 0; i < ARRAY_SIZE(ov5640_cfmts); i++) {
        if (ov5640_cfmts[i].code == vmf->code) {
            found = 1;
            break;
        }
    }
    if (found) {
        vmf->colorspace = ov5640_cfmts[i].colorspace;
    } else {
        /* Unsupported format requested. Propose either */
        if (priv->cfmt) {
            /* the current one or */
            vmf->colorspace = priv->cfmt->colorspace;
            vmf->code = priv->cfmt->code;
        } else {
            /* the default one */
            vmf->colorspace = ov5640_cfmts[0].colorspace;
            vmf->code = ov5640_cfmts[0].code;
        }
    }
    INFO_GREEN("code:%d-%s %dX%d\n", 
        vmf->code, win->name, vmf->width, vmf->height);
    return (0);
}
/* start or stop streaming from the device */
static int ov5640_s_stream(struct v4l2_subdev *sd, int enable)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    struct ov5640_priv *priv = to_ov5640(client);
    if (!enable) {
        INFO_PURLPLE("stream down\n");
        // set regs to enter sleep mode, already in DVP mode
     //   i2cc_set_reg(client, 0x3008, 0x42); //dg cancel 2015-07-18,  ov5640 power down,beacuse it cause some command not running.
        return (0);
    }
#if 0
    if (NULL == priv->win || NULL == priv->cfmt) {
        OV_ERR("win or cfmt select error!\n");
        return (-EPERM);
    }
#endif
    INFO_PURLPLE("stream on\n");
    //set regs to leave sleep mode, in DVP mode , needn't to set 0x300e to 0xc
  //  i2cc_set_reg(client, 0x3008, 0x02);  //dg cancel 2015-07-18,//dg cancel 2015-07-18,  ov5640 power down,beacuse it cause some command not running.
#if 0
    INFO_GREEN("format: %d, win:%s\n", priv->cfmt->code, priv->win->name);
    // wait for 2 Vsync, and capture the 3rd frame, (1 / 7.5) * 2 =. 267ms
    mdelay(270);
    if(0 == down_af_firmware_flag)
    {
        ov5640_sensor_download_af_fw(sd);
        down_af_firmware_flag = 1;
    }
#endif
        OV5640YUVPreview();
       // OV5640YUVCapture();
        //ov5640_sensor_s_single_af(sd);
        //dg add 2015-07-15
        //OV5640_FOCUS_AD5820_Single_Focus();
    //    OV5640_FOCUS_AD5820_Constant_Focus();
    return (0);
}
static int reset_ov5640(struct i2c_client *client)
{
    int ret = i2cc_set_reg(client, 0x3008, 0x82);
    mdelay(5);
    return (ret);
}
#if 0  //remove by cym 20130807
static int ov5640_get_params(struct i2c_client *client, unsigned int *width, 
    unsigned int *height, enum v4l2_mbus_pixelcode code)
{
    struct ov5640_priv *priv = to_ov5640(client);
    int ret = -EINVAL;
    int i;
    /* select format */
    priv->cfmt = NULL;
    for (i = 0; i < ARRAY_SIZE(ov5640_cfmts); i++) {
        if (code == ov5640_cfmts[i].code) {
            priv->cfmt = ov5640_cfmts + i;
            break;
        }
    }
    if (NULL == priv->cfmt) {
        return (ret);
    }
    priv->win = select_win(*width, *height);
    *width = priv->win->width;
    *height = priv->win->height;
    INFO_PURLPLE("current params: %s %dX%d\n", 
        priv->win->name, *width, *height);
    return (0);
}
#endif
static inline void init_setting_values(struct ov5640_priv *priv)
{
    priv->flip_flag = OV5640_HFLIP; 
}
#if 1  //remove by cym 20130807
static void get_preview_params(struct i2c_client *client, 
    unsigned int *exposure, unsigned short *maxlines, unsigned short *gain)
{
    unsigned char ret_h = 0;
    unsigned char ret_m = 0;
    unsigned char ret_l = 0;
    i2cc_get_reg(client, 0x3500, &ret_h);
    i2cc_get_reg(client, 0x3501, &ret_m);
    i2cc_get_reg(client, 0x3502, &ret_l);
    *exposure = ((ret_h << 16) + (ret_m << 8) + ret_l) >> 4;
    INFO_GREEN("expl:0x%x, expm:0x%x, exph:0x%x\n", 
            ret_l, ret_m, ret_h);
    i2cc_get_reg(client, 0x350c, &ret_h);
    i2cc_get_reg(client, 0x350d, &ret_l);
    *maxlines = (ret_h << 8) + ret_l;
    //i2cc_get_reg(client, 0x350a, &ret_h);
    i2cc_get_reg(client, 0x350b, &ret_l);
    *gain = /*((ret_h & 0x1) << 8) + */ret_l;
    INFO_GREEN("exposure:0x%x, maxlines:0x%x, gain:0x%x\n",
        *exposure, *maxlines, *gain);
}
#endif
#if 1  //remove by cym 20130807
static void manual_set_exposure_and_gain(struct i2c_client *client,
    unsigned int p_exposure, unsigned short p_maxlines, unsigned short p_gain)
{
    unsigned char ret_h = 0;
    unsigned char ret_l = 0;
    unsigned char exp_h;
    unsigned char exp_m;
    unsigned char exp_l;
    unsigned char lines_10ms;
    unsigned short cap_maxlines;
    unsigned short cap_exposure;
    unsigned short cap_gain;
//    unsigned short gain;
    unsigned int   cap_exp_gain;
    i2cc_get_reg(client, 0x350c, &ret_h);
    i2cc_get_reg(client, 0x350d, &ret_l);
    cap_maxlines = (ret_h << 8) + ret_l;
    //p_maxlines = 980;
    //cap_maxlines = 1964;
    INFO_GREEN("cap_maxlines: 0x%x\n", cap_maxlines);
    // for 50HZ, if 60HZ, devided by 12000
    lines_10ms = CAPTURE_FRAME_RATE * cap_maxlines / 10000 * 13 / 12;
    if (0 == p_maxlines) {
        p_maxlines = 1;
    }
    cap_exposure = ((p_exposure * CAPTURE_FRAME_RATE * cap_maxlines) / 
        (p_maxlines * PREVIEW_FRAME_RATE)) * 6 / 5;
    //cap_exp_gain = 1126 * cap_exposure * cap_gain;
    cap_exp_gain = cap_exposure * p_gain;  // in night mode, need multiply 2 again.
    //cap_exp_gain >>= 9;
    if (cap_exp_gain < (long)cap_maxlines * 16) {
        cap_exposure = cap_exp_gain / 16;
        if (cap_exposure > lines_10ms) {
            cap_exposure /= lines_10ms;
            cap_exposure *= lines_10ms;
        }
    } else {
        cap_exposure = cap_maxlines;
    }
    if (0 == cap_exposure) {
        cap_exposure = 1;
    }
    cap_gain = ((cap_exp_gain << 1) / cap_exposure + 1) >> 1;
    exp_l = (cap_exposure << 4) & 0xFF;
    exp_m = (cap_exposure >> 4) & 0xFF;
    exp_h = (cap_exposure >> 12) & 0xFF;
    INFO_GREEN("gain:0x%x, expl:0x%x, expm:0x%x, exph:0x%x, cap_maxlines:0x%x\n", 
        cap_gain, exp_l, exp_m, exp_h, cap_maxlines);
    i2cc_set_reg(client, 0x350b, cap_gain);
    i2cc_set_reg(client, 0x3502, exp_l);
    i2cc_set_reg(client, 0x3501, exp_m);
    i2cc_set_reg(client, 0x3500, exp_h);
    /*
    * add delay-time, to avoid boundary problem between dark and bright
    */
    mdelay(100);
}
#endif
static int ov5640_set_params(struct i2c_client *client, unsigned int *width, 
    unsigned int *height, enum v4l2_mbus_pixelcode code)
{
    struct ov5640_priv *priv = to_ov5640(client);
    int ret = -EINVAL;
    int i;
    const struct regval *reg_list = NULL;
    int list_len = 0;
    printk("%s(%d): code = %d\n", __FUNCTION__, __LINE__, code);
    printk("%s(%d): width = %d, height = %d\n", __FUNCTION__, __LINE__, *width, *height);
    /* select format */
    priv->cfmt = NULL;
    for (i = 0; i < ARRAY_SIZE(ov5640_cfmts); i++) {
        if (code == ov5640_cfmts[i].code) {
            priv->cfmt = ov5640_cfmts + i;
            break;
        }
    }
    if (NULL == priv->cfmt) {
    printk("%s(%d)\n", __FUNCTION__, __LINE__);
        return (ret);
    }
    /* select win size, now only one, so select directly */
    priv->win = select_win(*width, *height);
    /* set hardware regs needed */
    if (RESV_VGA == priv->win->resv) {
        reset_ov5640(client);
        /* set default regs */
        write_regs(client, ov5640_init_regs, ARRAY_SIZE(ov5640_init_regs));
        init_setting_values(priv);
    }
    switch (priv->win->resv) {
        case RESV_XGA: {
            reg_list = ov5640_qsxga_to_xga_regs;
            list_len = ARRAY_SIZE(ov5640_qsxga_to_xga_regs);
            break;
        }
        case RESV_SXGA: {
            reg_list = ov5640_qsxga_to_sxga_regs;
            list_len = ARRAY_SIZE(ov5640_qsxga_to_sxga_regs);
            break;
        }
        case RESV_UXGA: {
            reg_list = ov5640_qsxga_to_uxga_regs;
            list_len = ARRAY_SIZE(ov5640_qsxga_to_uxga_regs);
            break;
        }
        case RESV_QXGA: {
            reg_list = ov5640_qsxga_to_qxga_regs;
            list_len = ARRAY_SIZE(ov5640_qsxga_to_qxga_regs);
            break;
        }
        case RESV_QSXGA:
        default:
            break;
    }
#if 0    //remove by cym 20130807
    if (RESV_VGA != priv->win->resv) {
        unsigned int preview_exp;
        unsigned short preview_maxl;
        unsigned short preview_gain;
        /* manually set exposure and gain */
       // i2cc_set_reg(client, 0x3503, 0x07);
        get_preview_params(client, &preview_exp, &preview_maxl, &preview_gain);
        write_regs(client, ov5640_qsxga_regs, ARRAY_SIZE(ov5640_qsxga_regs));
    write_regs(client, ov5640_qsxga_to_uxga_regs, ARRAY_SIZE(ov5640_qsxga_to_uxga_regs));
        if (NULL != reg_list) {
            ;//write_regs(client, reg_list, list_len);
        }
        //manual_set_exposure_and_gain(client, preview_exp, preview_maxl, preview_gain);
    }
#endif
    *width = priv->win->width;
    *height = priv->win->height;
    INFO_PURLPLE("ok, params are width:%d-height:%d\n", *width, *height);
    return (0);
}
static int ov5640_g_fmt(struct v4l2_subdev *sd, 
    struct v4l2_mbus_framefmt *vmf)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
//    struct ov5640_priv *priv = to_ov5640(client);
    struct soc_camera_device *icd = client->dev.platform_data;
#if 0
    if (NULL == priv->win || NULL == priv->cfmt) {
        unsigned int width = VGA_WIDTH;
        unsigned int height = VGA_HEIGHT;
        int ret = 0;
        ret = ov5640_get_params(client, &width, &height, 2);
            //cym V4L2_MBUS_FMT_YUYV8_2X8_BE);
        if (ret < 0) {
            return (ret);
        }
    }
    vmf->width = priv->win->width;
    vmf->height = priv->win->height;
    vmf->code = priv->cfmt->code;
    vmf->colorspace = priv->cfmt->colorspace;
    vmf->field = V4L2_FIELD_NONE;
#else
    //printk("%s(%d)\n", __FUNCTION__, __LINE__);
    vmf->width    = icd->user_width;
    //printk("%s(%d)\n", __FUNCTION__, __LINE__);
    vmf->height    = icd->user_height;
    //printk("%s(%d)\n", __FUNCTION__, __LINE__);
    vmf->code    = 2;//priv->cfmt->code;
    //printk("%s(%d)\n", __FUNCTION__, __LINE__);
    vmf->colorspace    = V4L2_COLORSPACE_JPEG;//priv->cfmt->colorspace;
    vmf->field    = V4L2_FIELD_NONE;
#endif
    INFO_GREEN("ok, get fmt w:%dXh:%d-code:%d-csp:%d\n", 
        vmf->width, vmf->height, vmf->code, vmf->colorspace);
    return (0);
}
static int ov5640_s_fmt(struct v4l2_subdev *sd,
            struct v4l2_mbus_framefmt *vmf)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    struct ov5640_priv *priv = to_ov5640(client);
    //ov5640_g_fmt(sd, vmf);
    //printk("*********** %s, line = %d(code = 0x%x, w:%d, h:%d)\n", __FUNCTION__, __LINE__, 
    //                        vmf->code, vmf->width, vmf->height);
#if 0
        int ret = ov5640_set_params(client, &vmf->width, &vmf->height, vmf->code);
        printk("%s(%d): rest = %d\n", __FUNCTION__, __LINE__, ret);
        if (!ret)
                vmf->colorspace = priv->cfmt->colorspace;
        return (ret);
#endif
        return 1;
    //INFO_PURLPLE("\n");
}
//  TODO..... modify
static int ov5640_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *vcc)
{
    vcc->bounds.left = OV5640_COLUMN_SKIP;
    vcc->bounds.top  = OV5640_ROW_SKIP;
    vcc->bounds.width  = OV5640_MAX_WIDTH;
    vcc->bounds.height = OV5640_MAX_HEIGHT;
    vcc->defrect = vcc->bounds;  /* set default rect. */
    vcc->type    = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    vcc->pixelaspect.numerator   = 1;
    vcc->pixelaspect.denominator = 1;
    INFO_PURLPLE("\n");
    return (0);
}
//  TODO..... modify
static int ov5640_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *vc)
{
    vc->c.left    = 0;
    vc->c.top    = 0;
    vc->c.width    = QSXGA_WIDTH;
    vc->c.height    = QSXGA_HEIGHT;
    vc->type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    INFO_BLUE("\n");
    return (0);
}
static int ov5640_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
               enum v4l2_mbus_pixelcode *code)
{
    if (index >= ARRAY_SIZE(ov5640_cfmts))
        return -EINVAL;
    *code = ov5640_cfmts[index].code;
    OV_INFO("fmt index:%d\n", index);
    return 0;
}
static int ov5640_enum_framesizes(struct v4l2_subdev *sd,
                  struct v4l2_frmsizeenum *fsize)
{
    //struct s5k4ecgx_state *state =
    //    container_of(sd, struct s5k4ecgx_state, sd);
    //struct i2c_client *client = v4l2_get_subdevdata(sd);
    //struct ov5640_priv *priv = to_ov5640(client);
    //printk("********************** %s(%d) **************************\n", __FUNCTION__, __LINE__);
    fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
    fsize->discrete.width = 640;//state->pix.width;
    fsize->discrete.height = 480;//state->pix.height;
    return 0;
}
static int ov5640_set_brightness(struct i2c_client *client, int bright)
{
    struct ov5640_priv *priv = to_ov5640(client);
    unsigned char reg5587, reg5588;
    if (bright < -4 || 4 < bright) {
        OV_ERR("brightness - %d is out of range[-4, 4]\n", bright);
        return (-ERANGE);
    }
    if (bright < 0) {
        reg5587 = 0x10 * (-bright);
        reg5588 = 0x09; /* bit[3] is Y bright sign */
    } else {
        reg5587 = 0x10 * bright;
        reg5588 = 0x01;
    }
    i2cc_set_reg(client, 0x5001, 0xff);
    i2cc_set_reg(client, 0x5587, reg5587);
    i2cc_set_reg(client, 0x5580, 0x04);
    i2cc_set_reg(client, 0x5588, reg5588);
    priv->brightness = bright;
    OV_INFO("brightness:%d, reg5587:0x%x, reg5588:0x%x\n", 
        bright, reg5587, reg5588);
    return (0);
}
static int ov5640_set_contrast(struct i2c_client *client, int contrast)
{
    struct ov5640_priv *priv = to_ov5640(client);
    unsigned char y_gain, reg5588;
    if (contrast < -4 || 4 < contrast) {
        OV_ERR("contrast - %d is out of range[-4, 4]\n", contrast);
        return (-ERANGE);
    }
    if (0 == contrast) {
        reg5588 = 0x1;
    } else {
        reg5588 = 0x41;
    }
    y_gain = 0x20 + 0x4 * contrast;
    i2cc_set_reg(client, 0x5001, 0xff);
    i2cc_set_reg(client, 0x5580, 0x04);
    i2cc_set_reg(client, 0x5586, y_gain);
    i2cc_set_reg(client, 0x5585, y_gain);
    i2cc_set_reg(client, 0x5588, reg5588);
    priv->contrast = contrast;
    OV_INFO("contrast:%d, y_gain:0x%x, reg5588:0x%x\n", contrast, y_gain, reg5588);
    return (0);
}
/* auto, manual seperated is ok?? */
static int ov5640_set_saturation(struct i2c_client *client, int saturation)
{
    struct ov5640_priv *priv = to_ov5640(client);
    unsigned char uv_max, uv_min, reg5588;
    if (saturation < -4 || 4 < saturation) {
        OV_ERR("saturation - %d is out of range[-4, 4]\n", saturation);
        return (-ERANGE);
    }
    if (0 == saturation) {  /* different from application notes */
        uv_max = 0x40;   /* max value for UV adjust */
        uv_min = 0x10;   /* min value for UV adjust */
        reg5588 = 0x01;  /* bit[6]==0, auto saturation */
    } else {
        uv_max = 0x40 + 0x10 * saturation; /* U sat. */
        uv_min = uv_max; /* v sat */
        reg5588 = 0x41;  /* bit[6]==1, manual saturation */
    }
    i2cc_set_reg(client, 0x5001, 0xff);  /* init is 0xa3 */
    i2cc_set_reg(client, 0x5583, uv_max);
    i2cc_set_reg(client, 0x5584, uv_min);
    i2cc_set_reg(client, 0x5580, 0x02);  /* bit[1], enable(1)/disabe(0) saturation */
    i2cc_set_reg(client, 0x5588, reg5588); 
    priv->saturation = saturation;
    OV_INFO("saturation:%d\n", saturation);
    return (0);
}
/* XXX:effect is reversed to note's picture exept -180. check it */
static int ov5640_set_hue(struct i2c_client *client, int hue)
{
    struct ov5640_priv *priv = to_ov5640(client);
    unsigned char reg5581, reg5582, reg5588;
    switch (hue) {
        case -180:
            reg5581 = 0x80;
            reg5582 = 0x00;
            reg5588 = 0x32;
            break;
        case -150:
            reg5581 = 0x6f;
            reg5582 = 0x40;
            reg5588 = 0x32;
            break;
        case -120:
            reg5581 = 0x40;
            reg5582 = 0x6f;
            reg5588 = 0x32;
            break;
        case -90:
            reg5581 = 0x00;
            reg5582 = 0x80;
            reg5588 = 0x02;
            break;
        case -60:
            reg5581 = 0x40;
            reg5582 = 0x6f;
            reg5588 = 0x02;
            break;
        case -30:
            reg5581 = 0x6f;
            reg5582 = 0x40;
            reg5588 = 0x02;
            break;
        case 0:
            reg5581 = 0x80;
            reg5582 = 0x00;
            reg5588 = 0x01;
            break;
        case 30:
            reg5581 = 0x6f;
            reg5582 = 0x40;
            reg5588 = 0x01;
            break;
        case 60:
            reg5581 = 0x40;
            reg5582 = 0x6f;
            reg5588 = 0x01;
            break;
        case 90:
            reg5581 = 0x00;
            reg5582 = 0x80;
            reg5588 = 0x31;
            break;
        case 120:
            reg5581 = 0x40;
            reg5582 = 0x6f;
            reg5588 = 0x31;
            break;
        case 150:
            reg5581 = 0x6f;
            reg5582 = 0x40;
            reg5588 = 0x31;
            break;
        default:
            OV_ERR("hue - %d is out of range[-180, 150]/step-30\n", hue);
            return (-ERANGE);
    }
    i2cc_set_reg(client, 0x5001, 0xff);
    i2cc_set_reg(client, 0x5580, 0x01);  /* XXXX:diff. from defualt value */
    i2cc_set_reg(client, 0x5581, reg5581);  /* hue cos coefficient */
    i2cc_set_reg(client, 0x5582, reg5582);  /* hue sin coefficient */
    i2cc_set_reg(client, 0x5588, reg5588);
    priv->hue = hue;
    OV_INFO("hue: %d, 5581:0x%x, 5582:0x%x, 5588:0x%x\n", 
        hue, reg5581, reg5582, reg5588);
    return (0);
}
/* default value here is different from init one. */
static int ov5640_set_exposure_level(struct i2c_client *client, int level)
{
    struct ov5640_priv *priv = to_ov5640(client);
    unsigned char reg3a0f, reg3a10;
    unsigned char reg3a1b, reg3a1e;
    unsigned char reg3a11, reg3a1f;
    reg3a0f = 0x38 + 0x8 * level;
    reg3a10 = 0x30 + 0x8 * level;
    reg3a1b = reg3a0f;
    reg3a1e = reg3a10;
    reg3a1f = 0x10;
    switch (level) {
        case -5:  /* -1.7EV */
            reg3a11 = 0x20;
            break;
        case -4:  /* -1.3EV */
            reg3a11 = 0x30;
            break;
        case -3:  /* -1.0EV */
            reg3a11 = 0x41;
            break;
        case -2:  /* -0.7EV */
            reg3a11 = 0x51;
            break;
        case -1:  /* -0.3EV */
            reg3a11 = 0x61;
            break;
        case 0:  /* 0EV, default */
            reg3a11 = 0x61;
            break;
        case 1:  /* 0.3EV */
            reg3a11 = 0x71;
            break;
        case 2:  /* 0.7EV */
            reg3a11 = 0x80;
            reg3a1f = 0x20;
            break;
        case 3:  /* 1.0EV */
            reg3a11 = 0x90;
            reg3a1f = 0x20;
            break;
        case 4:  /* 1.3EV */
            reg3a11 = 0x91;
            reg3a1f = 0x20;
            break;
        case 5:  /* 1.7EV */
            reg3a11 = 0xa0;
            reg3a1f = 0x20;
            break;
        default:
            OV_ERR("exposure - %d is out of range[-5, 5]\n", level);
            return (-ERANGE);
    }
    OV_INFO("exposure: %d, 0x3a0f:0x%x, 0x3a10:0x%x\n", level, reg3a0f, reg3a10);
    //OV_INFO("0x3a1b:0x%x, 0x3a1e:0x%x\n", reg3a1b, reg3a1e);
    OV_INFO("0x3a11:0x%x, 0x3a1f:0x%x\n\n", reg3a11, reg3a1f);
    i2cc_set_reg(client, 0x3a0f, reg3a0f);  /* stable range high limit(enter) */
    i2cc_set_reg(client, 0x3a10, reg3a10);  /* stable range low limit(enter) */
    i2cc_set_reg(client, 0x3a11, reg3a11);  /* fast zone high limit */
    i2cc_set_reg(client, 0x3a1b, reg3a1b);  /* stable range high limit(go out) */
    i2cc_set_reg(client, 0x3a1e, reg3a1e);  /* stable range low limit(go out) */
    i2cc_set_reg(client, 0x3a1f, reg3a1f);  /* fast zone low limit */
    priv->exposure = level;
    return (0);
}
#define OV5640_FLIP_VAL  ((unsigned char)0x06)
#define OV5640_FLIP_MASK (~(OV5640_FLIP_VAL))
static int ov5640_set_flip(struct i2c_client *client, struct v4l2_control *ctrl)
{
    struct ov5640_priv *priv = to_ov5640(client);
    unsigned char reg3820, reg3821;
    OV_INFO("old flag: %d\n", priv->flip_flag);
    switch (ctrl->id) {
        case V4L2_CID_HFLIP:
            if (ctrl->value) {
                priv->flip_flag |= OV5640_HFLIP;
            } else {
                priv->flip_flag &= ~OV5640_HFLIP;
            }
            break;
        case V4L2_CID_VFLIP:
            if (ctrl->value) {
                priv->flip_flag |= OV5640_VFLIP;
            } else {
                priv->flip_flag &= ~OV5640_VFLIP;
            }
            break;
        default:
            OV_ERR("set flip out of range\n");
            return (-ERANGE);
    }
    OV_INFO("new flag: %d\n", priv->flip_flag);
    i2cc_get_reg(client, 0x3820, &reg3820);
    i2cc_get_reg(client, 0x3821, &reg3821);
    if (priv->flip_flag & OV5640_VFLIP) {
        reg3820 |= OV5640_FLIP_VAL;
    } else {
        reg3820 &= OV5640_FLIP_MASK;
    }
    if (priv->flip_flag & OV5640_HFLIP) {
        reg3821 |= OV5640_FLIP_VAL;
    } else {
        reg3821 &= OV5640_FLIP_MASK;
    }
    /* have a bug which flip a half picture only. */
    //i2cc_set_reg(client, 0x3212, 0x00);   /* enable group0, when add no flip */
    i2cc_set_reg(client, 0x3820, reg3820); 
    i2cc_set_reg(client, 0x3821, reg3821);
    //i2cc_set_reg(client, 0x3212, 0x10);   /* end group0 */
    //i2cc_set_reg(client, 0x3212, 0xa1);   /* launch group1 */
    OV_INFO("0x3820:0x%x, 0x3821:0x%x\n", reg3820, reg3821);
    return (0);
}
static int ov5640_set_sharpness(struct i2c_client *client, int sharp)
{
    struct ov5640_priv *priv = to_ov5640(client);
    unsigned char reg5302;
    switch (sharp) {
        case -1:  /*auto sharpness*/
            break;
        case 0:   /* sharpness off */
            reg5302 = 0x00;
            break;
        case 1:
            reg5302 = 0x02;
            break;
        case 2:
            reg5302 = 0x04;
            break;
        case 3:
            reg5302 = 0x08;
            break;
        case 4:
            reg5302 = 0x0c;
            break;
        case 5:
            reg5302 = 0x10;
            break;
        case 6:
            reg5302 = 0x14;
            break;
        case 7:
            reg5302 = 0x18;
            break;
        case 8:
            reg5302 = 0x20;
            break;
        default:
            OV_ERR("set sharpness is out of range - %d[-1,8]\n", sharp);
            return (-ERANGE);
    }
    if (0 <= sharp) {
        i2cc_set_reg(client, 0x5308, 0x65);
        i2cc_set_reg(client, 0x5302, reg5302);
        OV_INFO("sharp:%d, 5302:0x%x\n", sharp, reg5302);
    } else {
        const struct regval ov5640_auto_sharpness[] = {
            {0x5308, 0x25},
            {0x5300, 0x08},
            {0x5301, 0x30},
            {0x5302, 0x10},
            {0x5303, 0x00},
            {0x5309, 0x08},
            {0x530a, 0x30},
            {0x530b, 0x04},
            {0x530c, 0x06},
        };
        int len = ARRAY_SIZE(ov5640_auto_sharpness);
        write_regs(client, ov5640_auto_sharpness, len);
        OV_INFO("sharp:%d, len:%d\n", sharp, len);
    }
    priv->sharpness = sharp;
    return (0);
}
static int ov5640_set_colorfx(struct i2c_client *client, int effect)
{
    struct ov5640_priv *priv = to_ov5640(client);
    unsigned char reg5583, reg5584, reg5001, reg5580;
    reg5001 = 0xff;
    reg5580 = 0x18;
    switch (effect) {
        case 0: /* normal */
            reg5001 = 0x7f;
            reg5580 = 0x00;
            break;
        case 1: /* black and white */
            reg5583 = 0x80;
            reg5584 = 0x80;
            break;
        case 2: /* sepia , antique */
            reg5583 = 0x40;
            reg5584 = 0xa0;
            break;
        case 3: /* negative */
            reg5001 = 0xff;
            reg5580 = 0x40;
            break;
        case 4: /* bluish */
            reg5583 = 0xa0;
            reg5584 = 0x40;
            break;
        case 5: /* greenish */
            reg5583 = 0x60;
            reg5584 = 0x60;
            break;
        case 6: /* reddish */
            reg5583 = 0x80;
            reg5584 = 0xc0;
            break;
        default:
            OV_ERR("set color effects out of range - %d[0,6]\n", effect);
            return (-ERANGE);
    }
    i2cc_set_reg(client, 0x5001, reg5001);
    i2cc_set_reg(client, 0x5580, reg5580);
    OV_INFO("effect:%d, 0x5001:0x%x, 0x5580:0x%x\n", effect, reg5001, reg5580);
    if (0 != effect && 3 != effect) {
        i2cc_set_reg(client, 0x5583, reg5583);
        i2cc_set_reg(client, 0x5584, reg5584); 
        OV_INFO("0x5583:0x%x, 0x5584:0x%x\n", reg5583, reg5584);
    }
    priv->colorfx = effect;
    return (0);
}
/* Must be sorted from low to high control ID! */
static const u32 ov5640_user_ctrls[] = {
    V4L2_CID_USER_CLASS,
    V4L2_CID_BRIGHTNESS,
    V4L2_CID_CONTRAST,
    V4L2_CID_SATURATION,
    V4L2_CID_HUE,
//    V4L2_CID_BLACK_LEVEL,
    V4L2_CID_AUTO_WHITE_BALANCE,
//    V4L2_CID_DO_WHITE_BALANCE,
//    V4L2_CID_RED_BALANCE,
//    V4L2_CID_BLUE_BALANCE,
//    V4L2_CID_GAMMA,
    V4L2_CID_EXPOSURE,
    V4L2_CID_AUTOGAIN,
    V4L2_CID_GAIN,
    V4L2_CID_HFLIP,
    V4L2_CID_VFLIP,
    V4L2_CID_POWER_LINE_FREQUENCY,
//    V4L2_CID_HUE_AUTO,
    V4L2_CID_WHITE_BALANCE_TEMPERATURE,
    V4L2_CID_SHARPNESS,
//    V4L2_CID_BACKLIGHT_COMPENSATION,
//    V4L2_CID_CHROMA_AGC,
//    V4L2_CID_CHROMA_GAIN,
//    V4L2_CID_COLOR_KILLER,
    V4L2_CID_COLORFX,
//    V4L2_CID_AUTOBRIGHTNESS,
    V4L2_CID_BAND_STOP_FILTER,
//    V4L2_CID_ROTATE,
//    V4L2_CID_BG_COLOR,
    0,
};
static const u32 ov5640_camera_ctrls[] = {
    V4L2_CID_CAMERA_CLASS,
    V4L2_CID_EXPOSURE_AUTO,
//    V4L2_CID_EXPOSURE_ABSOLUTE,
//    V4L2_CID_EXPOSURE_AUTO_PRIORITY,
//    V4L2_CID_PAN_RELATIVE,
//    V4L2_CID_TILT_RELATIVE,
//    V4L2_CID_PAN_RESET,
//    V4L2_CID_TILT_RESET,
//    V4L2_CID_PAN_ABSOLUTE,
//    V4L2_CID_TILT_ABSOLUTE,
//    V4L2_CID_FOCUS_ABSOLUTE,
//    V4L2_CID_FOCUS_RELATIVE,
//    V4L2_CID_FOCUS_AUTO,
//    V4L2_CID_ZOOM_ABSOLUTE,
//    V4L2_CID_ZOOM_RELATIVE,
//    V4L2_CID_ZOOM_CONTINUOUS,
//    V4L2_CID_IRIS_ABSOLUTE,
//    V4L2_CID_IRIS_RELATIVE,
//    V4L2_CID_PRIVACY,
//cym    V4L2_CID_SCENE_EXPOSURE,
    0,
};
static const u32 *ov5640_ctrl_classes[] = {
    ov5640_user_ctrls,
    ov5640_camera_ctrls,
    NULL,
};
static int ov5640_queryctrl(struct v4l2_subdev *sd,
        struct v4l2_queryctrl *qc)
{
    //struct i2c_client *client = v4l2_get_subdevdata(sd);
    qc->id = v4l2_ctrl_next(ov5640_ctrl_classes, qc->id);
    if (qc->id == 0) {
        return (-EINVAL);
    }
    OV_INFO("%s: id-%s\n", __func__, v4l2_ctrl_get_name(qc->id));
    /* Fill in min, max, step and default value for these controls. */
    switch (qc->id) {
    /* Standard V4L2 controls */
    case V4L2_CID_USER_CLASS:
        return v4l2_ctrl_query_fill(qc, 0, 0, 0, 0);
    case V4L2_CID_BRIGHTNESS:
        return v4l2_ctrl_query_fill(qc, -4, 4, 1, 0);
    case V4L2_CID_CONTRAST:
        return v4l2_ctrl_query_fill(qc, -4, 4, 1, 0);
    case V4L2_CID_SATURATION:
        return v4l2_ctrl_query_fill(qc, -4, 4, 1, 0);
    case V4L2_CID_HUE:
        return v4l2_ctrl_query_fill(qc, -180, 150, 30, 0);
#if 0
//    case V4L2_CID_BLACK_LEVEL:
    case V4L2_CID_AUTO_WHITE_BALANCE:
        return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
//    case V4L2_CID_DO_WHITE_BALANCE:
//    case V4L2_CID_RED_BALANCE:
//    case V4L2_CID_BLUE_BALANCE:
//    case V4L2_CID_GAMMA:
#endif
    case V4L2_CID_EXPOSURE:
        return v4l2_ctrl_query_fill(qc, -5, 5, 1, 0);
#if 0
    case V4L2_CID_AUTOGAIN:
        return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
    case V4L2_CID_GAIN:
        return v4l2_ctrl_query_fill(qc, 0, 0xFFU, 1, 128);
#endif
    case V4L2_CID_HFLIP:
    case V4L2_CID_VFLIP:
        return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
#if 0
    case V4L2_CID_POWER_LINE_FREQUENCY:
        return v4l2_ctrl_query_fill(qc, 0, 2, 1, 1);
//    case V4L2_CID_HUE_AUTO:
    case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
        return v4l2_ctrl_query_fill(qc, 0, 3, 1, 0);
#endif
    case V4L2_CID_SHARPNESS:
        return v4l2_ctrl_query_fill(qc, -1, 8, 1, -1);
//    case V4L2_CID_BACKLIGHT_COMPENSATION:
//    case V4L2_CID_CHROMA_AGC:
//    case V4L2_CID_CHROMA_GAIN:
//    case V4L2_CID_COLOR_KILLER:
    case V4L2_CID_COLORFX:
        return v4l2_ctrl_query_fill(qc, 0, 6, 1, 0);
//    case V4L2_CID_AUTOBRIGHTNESS:
#if 0
    case V4L2_CID_BAND_STOP_FILTER:
        return v4l2_ctrl_query_fill(qc, 0, 63, 1, 2);
//    case V4L2_CID_ROTATE:
//    case V4L2_CID_BG_COLOR:
#endif
    case V4L2_CID_CAMERA_CLASS:
        return v4l2_ctrl_query_fill(qc, 0, 0, 0, 0);
#if 0
    case V4L2_CID_EXPOSURE_AUTO:
        return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
//    case V4L2_CID_EXPOSURE_ABSOLUTE:
//    case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
//    case V4L2_CID_PAN_RELATIVE:
//    case V4L2_CID_TILT_RELATIVE:
//    case V4L2_CID_PAN_RESET:
//    case V4L2_CID_TILT_RESET:
//    case V4L2_CID_PAN_ABSOLUTE:
//    case V4L2_CID_TILT_ABSOLUTE:
//    case V4L2_CID_FOCUS_ABSOLUTE:
//    case V4L2_CID_FOCUS_RELATIVE:
//    case V4L2_CID_FOCUS_AUTO:
//    case V4L2_CID_ZOOM_ABSOLUTE:
//    case V4L2_CID_ZOOM_RELATIVE:
//    case V4L2_CID_ZOOM_CONTINUOUS:
//    case V4L2_CID_IRIS_ABSOLUTE:
//    case V4L2_CID_IRIS_RELATIVE:
//    case V4L2_CID_PRIVACY:
    case V4L2_CID_SCENE_EXPOSURE:
        return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
#endif
    default:
        OV_ERR("invalid control ctrl: %s\n", v4l2_ctrl_get_name(qc->id));
        qc->flags |= V4L2_CTRL_FLAG_DISABLED;
        return (-EINVAL);
    }
    return (0);
}
static int ov5640_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    //struct ov5640_priv *priv = to_ov5640(client);
    int ret = 0;
    //int val = 0;
    /* add by cym 20130812 */
    int err = 0;
    //int value = ctrl->value;
    /* end add */
    OV_INFO("%s: control ctrl- %s\n", __func__, v4l2_ctrl_get_name(ctrl->id));
    printk("%s: control ctrl- id = %d\n", __func__, ctrl->id-V4L2_CID_PRIVATE_BASE);
    switch (ctrl->id) {
    case V4L2_CID_BRIGHTNESS:
        ov5640_set_brightness(client, ctrl->value);
        break;
    case V4L2_CID_CONTRAST:
        ov5640_set_contrast(client, ctrl->value);
        break;
    case V4L2_CID_SATURATION:
        ov5640_set_saturation(client, ctrl->value);
        break;
    case V4L2_CID_HUE:
        ov5640_set_hue(client, ctrl->value);
        break;
#if 0
//    case V4L2_CID_BLACK_LEVEL:
//        ov5640_set_black_level(sd, ctrl->value);
//        break;
    case V4L2_CID_AUTO_WHITE_BALANCE:
        ov5640_set_awb(client, ctrl->value);
        break;
//    case V4L2_CID_DO_WHITE_BALANCE:
//        ov5640_set_do_white_balance(sd, ctrl->value);
//        break;
//    case V4L2_CID_RED_BALANCE:
//        ov5640_set_red_balance(sd, ctrl->value);
//        break;
//    case V4L2_CID_BLUE_BALANCE:
//        ov5640_set_blue_balance(sd, ctrl->value);
//        break;
//    case V4L2_CID_GAMMA:
//        ov5640_set_gamma(sd, ctrl->value);
//        break;
#endif
    case V4L2_CID_EXPOSURE:
        ov5640_set_exposure_level(client, ctrl->value);
        break;
#if 0
    case V4L2_CID_AUTOGAIN:
        ov5640_set_autogain(sd, ctrl->value);
        break;
    case V4L2_CID_GAIN:
        ov5640_set_gain(sd, ctrl->value);
        break;
#endif
    case V4L2_CID_HFLIP:
    case V4L2_CID_VFLIP:
        ov5640_set_flip(client, ctrl);
        break;
#if 0
    case V4L2_CID_POWER_LINE_FREQUENCY:
        ov5640_set_power_line_frequency(sd, ctrl->value);
        break;
//    case V4L2_CID_HUE_AUTO:
//        ov5640_set_hue_auto(sd, ctrl->value);
//        break;
    case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
        set_white_balance_temperature(client, ctrl->value);
        break;
#endif
    case V4L2_CID_SHARPNESS:
        ov5640_set_sharpness(client, ctrl->value);
        break;
//    case V4L2_CID_BACKLIGHT_COMPENSATION:
//        ov5640_set_backlight_compensation(sd, ctrl->value);
//        break;
//    case V4L2_CID_CHROMA_AGC:
//        ov5640_set_chroma_agc(sd, ctrl->value);
//        break;
//    case V4L2_CID_CHROMA_GAIN:
//        ov5640_set_chroma_gain(sd, ctrl->value);
//        break;
//    case V4L2_CID_COLOR_KILLER:
//        ov5640_set_color_killer(sd, ctrl->value);
//        break;
    case V4L2_CID_COLORFX:
        ov5640_set_colorfx(client, ctrl->value);
        break;
#if 0
//    case V4L2_CID_AUTOBRIGHTNESS:
//        ov5640_set_autobrightness(sd, ctrl->value);
//        break;
    case V4L2_CID_BAND_STOP_FILTER:
        ov5640_set_band_stop_filter(sd, ctrl->value);
        break;
//    case V4L2_CID_ROTATE:
//        ov5640_set_rotate(sd, ctrl->value);
//        break;
//    case V4L2_CID_BG_COLOR:
//        ov5640_set_bg_color(sd, ctrl->value);
//        break;
    case V4L2_CID_EXPOSURE_AUTO:
        ov5640_set_exposure_auto(sd, ctrl->value);
        break;
//    case V4L2_CID_EXPOSURE_ABSOLUTE:
//    case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
//    case V4L2_CID_PAN_RELATIVE:
//    case V4L2_CID_TILT_RELATIVE:
//    case V4L2_CID_PAN_RESET:
//    case V4L2_CID_TILT_RESET:
//    case V4L2_CID_PAN_ABSOLUTE:
//    case V4L2_CID_TILT_ABSOLUTE:
//    case V4L2_CID_FOCUS_ABSOLUTE:
//    case V4L2_CID_FOCUS_RELATIVE:
//    case V4L2_CID_FOCUS_AUTO:
//    case V4L2_CID_ZOOM_ABSOLUTE:
//    case V4L2_CID_ZOOM_RELATIVE:
//    case V4L2_CID_ZOOM_CONTINUOUS:
//    case V4L2_CID_IRIS_ABSOLUTE:
//    case V4L2_CID_IRIS_RELATIVE:
//    case V4L2_CID_PRIVACY:
    case V4L2_CID_SCENE_EXPOSURE:
        ov5640_set_scene_exposure(sd, ctrl->value);
        break;
#endif
    /* add by cym 20130812 */
    case V4L2_CID_CAMERA_SET_AUTO_FOCUS:
        {
                printk("auto focus......\n");
                err = ov5640_sensor_s_single_af(sd);
           //      OV5640_FOCUS_AD5820_Single_Focus();
             //   OV5640_FOCUS_AD5820_Constant_Focus();
         }
            break;
    /* end add */
    default:
        OV_ERR("invalid control ctrl: %s\n", v4l2_ctrl_get_name(ctrl->id));
        return (-EINVAL);
    }
    return (ret);
}
static int ov5640_init(struct v4l2_subdev *sd, u32 val)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    struct ov5640_priv *priv = to_ov5640(client);
        unsigned char pid;
        unsigned char version;
    //int err = -EINVAL;
    /* add by cym 20121121 */
    ov5640_power(1);
    /* end add */
        //dg add 2015-07-15
        i2cc_set_reg(client, 0x3103,0x11);
        i2cc_set_reg(client, 0x3008,0x82);
        mdelay(20);
     // check and show product ID and manufacturer ID
    i2cc_get_reg(client, 0x300a, &pid);
    i2cc_get_reg(client, 0x300b, &version);
    printk("%s: version = 0x%x%x\n", __FUNCTION__, pid, version);
    if (OV5640 != VERSION(pid, version)) {
        OV_ERR("ov5640 probed failed!!\n");
        return (-ENODEV);
    }
    priv->model = 1;//cym V4L2_IDENT_OV5640;
    //ov5640_sensor_download_af_fw(sd);
    //ov5640_sensor_s_single_af(sd);
        //dg add  2015-07-25
        OV5640_FOCUS_AD5820_Init();
        OV5640YUV_Sensor_Dvp_Init();
        down_af_firmware_flag =1;
    INFO_BLUE("ov5640 device probed success\n");
    return 0;
}
static int ov5640_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    struct ov5640_priv *priv = to_ov5640(client);
    int err = 0;
    OV_INFO("%s: control ctrl- %s\n", __func__, v4l2_ctrl_get_name(ctrl->id));
        printk("%s: control ctrl- id = %d\n", __func__, ctrl->id);
    switch (ctrl->id) {
    case V4L2_CID_BRIGHTNESS:
        ctrl->value = priv->brightness;
        break;
    case V4L2_CID_CONTRAST:
        ctrl->value = priv->contrast;
        break;
    case V4L2_CID_SATURATION:
        ctrl->value = priv->saturation;
        break;
    case V4L2_CID_HUE:
        ctrl->value = priv->hue;
        break;
    //  case V4L2_CID_BLACK_LEVEL:
    //      ctrl->value = priv->black_level;
    //      break;
#if 0
    case V4L2_CID_AUTO_WHITE_BALANCE:
        ctrl->value = priv->auto_white_balance;
        break;
    //  case V4L2_CID_DO_WHITE_BALANCE:
    //      ctrl->value = priv->do_white_balance;
    //      break;
    //  case V4L2_CID_RED_BALANCE:
    //      ctrl->value = priv->red_balance;
    //      break;
    //  case V4L2_CID_BLUE_BALANCE:
    //      ctrl->value = priv->blue_balance;
    //      break;
    //  case V4L2_CID_GAMMA:
    //      ctrl->value = priv->gamma;
    //      break;
#endif
    case V4L2_CID_EXPOSURE:
        ctrl->value = priv->exposure;
        break;
#if 0
    case V4L2_CID_AUTOGAIN:
    ctrl->value = priv->autogain;
    break;
    case V4L2_CID_GAIN:
    ctrl->value = priv->gain;
    break;
#endif
    case V4L2_CID_HFLIP:
        ctrl->value = !!(priv->flip_flag & OV5640_HFLIP);
        break;
    case V4L2_CID_VFLIP:
        ctrl->value = !!(priv->flip_flag & OV5640_VFLIP);
        break;
#if 0
    case V4L2_CID_POWER_LINE_FREQUENCY:
    ctrl->value = priv->power_line_frequency;
    break;
    //  case V4L2_CID_HUE_AUTO:
    //      ctrl->value = priv->hue_auto;
    //      break;
    case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
        ctrl->value = priv->white_balance_temperature;
        break;
#endif
    case V4L2_CID_SHARPNESS:
        ctrl->value = priv->sharpness;
        break;
    //  case V4L2_CID_BACKLIGHT_COMPENSATION:
    //      ctrl->value = priv->backlight_compensation;
    //      break;
    //  case V4L2_CID_CHROMA_AGC:
    //      ctrl->value = priv->chroma_agc;
    //      break;
    //  case V4L2_CID_CHROMA_GAIN:
    //      ctrl->value = priv->chroma_gain;
    //      break;
    //  case V4L2_CID_COLOR_KILLER:
    //      ctrl->value = priv->color_killer;
    //      break;
    case V4L2_CID_COLORFX:
        ctrl->value = priv->colorfx;
        break;
#if 0
    //  case V4L2_CID_AUTOBRIGHTNESS:
    //      ctrl->value = priv->autobrightness;
    //      break;
    case V4L2_CID_BAND_STOP_FILTER:
    ctrl->value = priv->band_stop_filter;
    break;
    //  case V4L2_CID_ROTATE:
    //      ctrl->value = priv->rotate;
    //      break;
    //  case V4L2_CID_BG_COLOR:
    //      ctrl->value = priv->bg_color;
    //      break;
    case V4L2_CID_EXPOSURE_AUTO:
    ctrl->value = priv->exposure_auto;
    break;
    //  case V4L2_CID_EXPOSURE_ABSOLUTE:
    //  case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
    //  case V4L2_CID_PAN_RELATIVE:
    //  case V4L2_CID_TILT_RELATIVE:
    //  case V4L2_CID_PAN_RESET:
    //  case V4L2_CID_TILT_RESET:
    //  case V4L2_CID_PAN_ABSOLUTE:
    //  case V4L2_CID_TILT_ABSOLUTE:
    //  case V4L2_CID_FOCUS_ABSOLUTE:
    //  case V4L2_CID_FOCUS_RELATIVE:
    //  case V4L2_CID_FOCUS_AUTO:
    //  case V4L2_CID_ZOOM_ABSOLUTE:
    //  case V4L2_CID_ZOOM_RELATIVE:
    //  case V4L2_CID_ZOOM_CONTINUOUS:
    //  case V4L2_CID_IRIS_ABSOLUTE:
    //  case V4L2_CID_IRIS_RELATIVE:
    //  case V4L2_CID_PRIVACY:
    case V4L2_CID_SCENE_EXPOSURE:
    ctrl->value = priv->scene_exposure;
    break;
#endif
    /* add by cym 20130829 */
        case V4L2_CID_CAMERA_AUTO_FOCUS_RESULT:
               //android4.0 use this, it is very important for take picture,android4.4 not use.
        err = ov5640_get_auto_focus_result(sd, ctrl);
        break;
    /* end add */
    default:
    OV_ERR("invalid control ctrl: %s\n", v4l2_ctrl_get_name(ctrl->id));
    return (-EINVAL);
    }
    return (0);
}
static int ov5640_s_ext_ctrls(struct v4l2_subdev *sd, 
    struct v4l2_ext_controls *ctrls)
{
    //struct i2c_client *client = v4l2_get_subdevdata(sd);
    struct v4l2_control ctrl;
    int i;
    int err = 0;
    if ((ctrls->ctrl_class != V4L2_CTRL_CLASS_USER)
        && (ctrls->ctrl_class != V4L2_CTRL_CLASS_CAMERA)) {
        OV_ERR("ctrl class[%s] is illegal.\n", v4l2_ctrl_get_name(ctrls->ctrl_class));
        return (-EINVAL);
    }
    for (i = 0; i < ctrls->count; i++) {
        ctrl.id = ctrls->controls[i].id;
        ctrl.value = ctrls->controls[i].value;
        err = ov5640_s_ctrl(sd, &ctrl);
        //ctrls->controls[i].value = ctrl.value;
        if (err) {
            ctrls->error_idx = i;
            break;
        }
    }
    return (err);
}
static int ov5640_g_ext_ctrls(struct v4l2_subdev *sd, 
    struct v4l2_ext_controls *ctrls)
{
    //struct i2c_client *client = v4l2_get_subdevdata(sd);
    struct v4l2_control ctrl;
    int i;
    int err = 0;
    if ((ctrls->ctrl_class != V4L2_CTRL_CLASS_USER)
        && (ctrls->ctrl_class != V4L2_CTRL_CLASS_CAMERA)) {
        OV_ERR("ctrl class[%s] is illegal.\n", v4l2_ctrl_get_name(ctrls->ctrl_class));
        return (-EINVAL);
    }
    for (i = 0; i < ctrls->count; i++) {
        ctrl.id = ctrls->controls[i].id;
        //ctrl.value = ctrls->controls[i].value;
        err = ov5640_g_ctrl(sd, &ctrl);
        ctrls->controls[i].value = ctrl.value;
        if (err) {
            ctrls->error_idx = i;
            break;
        }
    }
    return (err);
}
static int ov5640_try_ctrl(struct v4l2_subdev *sd,
    struct v4l2_ext_control *ctrl)
{
    struct v4l2_queryctrl qctrl;
    const char **menu_items = NULL;
    int err;
    qctrl.id = ctrl->id;
    err = ov5640_queryctrl(sd, &qctrl);
    if (err)
        return (err);
    if (qctrl.type == V4L2_CTRL_TYPE_MENU)
        menu_items = v4l2_ctrl_get_menu(qctrl.id);
    return v4l2_ctrl_check(ctrl, &qctrl, menu_items);
}
static int ov5640_try_ext_ctrls(struct v4l2_subdev *sd, 
    struct v4l2_ext_controls *ctrls)
{
    //struct i2c_client *client = v4l2_get_subdevdata(sd);
    int i;
    int err = 0;
    if ((ctrls->ctrl_class != V4L2_CTRL_CLASS_USER)
        && (ctrls->ctrl_class != V4L2_CTRL_CLASS_CAMERA)) {
        OV_ERR("ctrl_class[%s] is illegal.\n", v4l2_ctrl_get_name(ctrls->ctrl_class));
        return (-EINVAL);
    }
    for (i = 0; i < ctrls->count; i++) {
        err = ov5640_try_ctrl(sd, &ctrls->controls[i]);
        if (err) {
            ctrls->error_idx = i;
            break;
        }
    }
    return (err);
}
#ifdef CONFIG_VIDEO_ADV_DEBUG
static int ov5640_g_register(struct v4l2_subdev *sd,
    struct v4l2_dbg_register *reg)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    unsigned char val;
    int err;
    reg->size = 2;
    if (reg->reg > 0x603f) {
        return (-EINVAL);
    }
    err = i2cc_get_reg(client, reg->reg, &val);
    if (err) {
        return (err);
    }
    reg->val = val;
    return (0);
}
static int ov5640_s_register(struct v4l2_subdev *sd,
    struct v4l2_dbg_register *reg)
{
    struct i2c_client *client = v4l2_get_subdevdata(sd);
    if (reg->reg > 0x603f) {
        return (-EINVAL);
    }
    return (i2cc_set_reg(client, (unsigned short)reg->reg,(unsigned char)reg->val));
}
#endif
static struct soc_camera_ops ov5640_ops = {
    .set_bus_param = ov5640_set_bus_param,
    .query_bus_param = ov5640_query_bus_param,
    //.controls = ov5640_controls,
    //.num_controls = ARRAY_SIZE(ov5640_controls),
};
static struct v4l2_subdev_core_ops ov5640_subdev_core_ops = {
    .init = ov5640_init,    
    .g_ctrl        = ov5640_g_ctrl,
    .s_ctrl        = ov5640_s_ctrl,
    .queryctrl  = ov5640_queryctrl,
    .g_ext_ctrls = ov5640_g_ext_ctrls,
    .s_ext_ctrls = ov5640_s_ext_ctrls,
    .try_ext_ctrls = ov5640_try_ext_ctrls,
    .g_chip_ident    = ov5640_g_chip_ident,
#ifdef CONFIG_VIDEO_ADV_DEBUG
    .g_register    = ov5640_g_register,
    .s_register    = ov5640_s_register,
#endif
};
static struct v4l2_subdev_video_ops ov5640_subdev_video_ops = {
        .s_stream    =  ov5640_s_stream,
        .g_mbus_fmt    = ov5640_g_fmt,
    .s_mbus_fmt    = ov5640_s_fmt,
    .try_mbus_fmt    = ov5640_try_fmt,
    .cropcap    = ov5640_cropcap,
    .g_crop        = ov5640_g_crop,
    .enum_mbus_fmt    = ov5640_enum_fmt,
    .enum_framesizes = ov5640_enum_framesizes,
};
static struct v4l2_subdev_ops  ov5640_subdev_ops = {
    .core = &ov5640_subdev_core_ops,
    .video = &ov5640_subdev_video_ops,
};
#if 0  //remove by cym 20130807
static int ov5640_video_probe(struct soc_camera_device *icd, 
    struct i2c_client *client) 
{
    struct ov5640_priv *priv = to_ov5640(client);
    unsigned char pid;
    unsigned char version;
    /*
     * We must have a parent by now. And it cannot be a wrong one.
     * So this entire test is completely redundant.
     */
    if (NULL == icd->dev.parent ||
        to_soc_camera_host(icd->dev.parent)->nr != icd->iface) {
        OV_ERR("error : has a wrong parent\n");
        //return (-ENODEV);
    }
    // check and show product ID and manufacturer ID
    i2cc_get_reg(client, 0x300a, &pid);
    i2cc_get_reg(client, 0x300b, &version);
    if (OV5640 != VERSION(pid, version)) {
        OV_ERR("ov5640 probed failed!!\n");
        return (-ENODEV);
    }
    priv->model = 1;//cym V4L2_IDENT_OV5640;
    INFO_BLUE("ov5640 device probed success\n");
    return (0);
}
#endif
static int ov5640_probe(struct i2c_client *client, 
    const struct i2c_device_id *did)
{
    struct ov5640_priv *priv;
    struct v4l2_subdev *sd = NULL;
    struct soc_camera_device *icd = client->dev.platform_data;
    //struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
    struct soc_camera_link *icl;
    int ret = 0;
    OV_INFO("ov5640 probe start...\n");
    if (NULL == icd) {
        ret = -EINVAL;
        OV_ERR("error: missing soc camera device\n");
        goto failed;
    }
    g_client=client;
    /* add by cym 20130605 */
#ifndef CONFIG_TC4_EVT
        ov_vdd18_cam_regulator = regulator_get(NULL, "vdd18_cam");
        if (IS_ERR(ov_vdd18_cam_regulator)) {
                printk("%s: failed to get %s\n", __func__, "vdd18_cam");
                ret = -ENODEV;
                goto err_regulator;
        }
        ov_vdd28_cam_regulator = regulator_get(NULL, "vdda28_2m");
        if (IS_ERR(ov_vdd28_cam_regulator)) {
                printk("%s: failed to get %s\n", __func__, "vdda28_2m");
                ret = -ENODEV;
                goto err_regulator;
        }
        ov_vddaf_cam_regulator = regulator_get(NULL, "vdd28_af");
        if (IS_ERR(ov_vddaf_cam_regulator)) {
                printk("%s: failed to get %s\n", __func__, "vdd28_af");
                ret = -ENODEV;
                goto err_regulator;
        }
        ov_vdd5m_cam_regulator = regulator_get(NULL, "vdd28_cam");
        if (IS_ERR(ov_vdd5m_cam_regulator)) {
                printk("%s: failed to get %s\n", __func__, "vdd28_cam");
                ret = -ENODEV;
                goto err_regulator;
        }
       // ov5640_power(1);
#endif
        /* end add */
    icl = to_soc_camera_link(icd);
    if (NULL == icl) {
        ret = -EINVAL;
        OV_ERR("error: missing soc camera link\n");
        //cym goto failed;
    }
    ret = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA);
    if (0 == ret) {
        ret = -EINVAL;
        OV_ERR("I2C DOESN'T support I2C_FUNC_SMBUS_BYTE_DATA\n");
        goto failed;
    }
    priv = (struct ov5640_priv *)kzalloc(sizeof(struct ov5640_priv), GFP_KERNEL);
    if (NULL == priv) {
        ret = -ENOMEM;
        OV_ERR("alloc ov5640_priv struct failed!\n");
        goto failed;
    }
    sd = &priv->subdev;
    strcpy(sd->name, OV5640_I2C_NAME);
    v4l2_i2c_subdev_init(sd, client, &ov5640_subdev_ops);
    icd->ops = &ov5640_ops;
#if 0
    ret = ov5640_video_probe(icd, client);
    if (ret) {
        icd->ops = NULL;
        kfree(priv);
        OV_ERR("error : failed to probe camera device");
    }
#endif
    failed:
          //return (ret);
        return (0);
#ifndef CONFIG_TC4_EVT
err_regulator:
        ov5640_power(0);
        regulator_put(ov_vddaf_cam_regulator);
        regulator_put(ov_vdd5m_cam_regulator);
        /* add by cym 20130506 */
        regulator_put(ov_vdd18_cam_regulator);
        regulator_put(ov_vdd28_cam_regulator);
        /* end add */
        return ret;
#endif
}
static int ov5640_remove(struct i2c_client *client)
{
    struct ov5640_priv *priv = to_ov5640(client);
    struct soc_camera_device *icd = client->dev.platform_data;
    struct v4l2_subdev *sd = i2c_get_clientdata(client);
    v4l2_device_unregister_subdev(sd);
    //icd->ops = NULL;
    kfree(priv);
       INFO_RED("ov5640 device removed!\n");
#ifndef CONFIG_TC4_EVT
        ov5640_power(0);
        regulator_put(ov_vddaf_cam_regulator);
        regulator_put(ov_vdd5m_cam_regulator);
        regulator_put(ov_vdd18_cam_regulator);
        regulator_put(ov_vdd28_cam_regulator);
    down_af_firmware_flag = 0;
        /* end add */
#endif
    return (0);
}
#if 0
static int ov5640_detect(struct i2c_client *client, struct i2c_board_info *info)
{
    strcpy(info->type, OV5640_I2C_NAME);
    return 0;
}
#endif
static const struct i2c_device_id ov5640_id[] = {
    { OV5640_I2C_NAME, 0 },
    { }
};
MODULE_DEVICE_TABLE(i2c, ov5640_id);
static const unsigned short ov5640_addrs[] = {
    OV5640_I2C_ADDR,
    I2C_CLIENT_END,
};
#if 0
struct i2c_board_info ov5640_info = {
    I2C_BOARD_INFO(OV5640_I2C_NAME, OV5640_I2C_ADDR),
};
#endif
static struct i2c_driver ov5640_i2c_driver = {
    .driver = {
        .name = OV5640_I2C_NAME,
        .owner = THIS_MODULE,
    },
    .class = I2C_CLASS_HWMON,
    .probe    = ov5640_probe,
    .remove   = ov5640_remove,
    .id_table = ov5640_id,
    .address_list = ov5640_addrs,
};
/*
 * module function
 */
static int __init ov5640_module_init(void)
{
    OV_INFO("install module\n");
    printk("%s\n", __FUNCTION__);
    return i2c_add_driver(&ov5640_i2c_driver);
}
static void __exit ov5640_module_exit(void)
{
    OV_INFO("uninstall module\n");
    i2c_del_driver(&ov5640_i2c_driver);
}
module_init(ov5640_module_init);
module_exit(ov5640_module_exit);
MODULE_DESCRIPTION("SoC Camera driver for ov5640");
MODULE_AUTHOR("caoym@topeet.com ");
MODULE_LICENSE("GPL v2");