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

素颜马尾好姑娘i 2022-01-21 06:15 2239阅读 0赞

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

驱动下载：[https://download.csdn.net/download/q1449516487/11231317][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");

[https_download.csdn.net_download_q1449516487_11231317]: https://download.csdn.net/download/q1449516487/11231317