android—camera从应用到驱动——驱动代码

下面是展讯平台一个camera_gc5004的驱动代码：
所做的工作主要有：
1、camera上电_gc5004_mipi_PowerOn
2、识别camera型号_gc5004_mipi_Identify
3、硬件寄存器相关的设置
4、为kernel系统提供函数接口g_gc5004_mipi_raw_info

#include <utils/Log.h>
#include "sensor.h"
#include "jpeg_exif_header.h"
#include "sensor_drv_u.h"
#include "sensor_raw.h"
#include "sensor_gc5004_mipi_raw_param.c"

#define SENSOR_PRINT CMR_LOGE

#define DW9714_VCM_SLAVE_ADDR (0x18>>1)

#define gc5004_mipi_I2C_ADDR_W        0x36
#define gc5004_mipi_I2C_ADDR_R         0x36

#define gc5004_mipi_RAW_PARAM_COM  0x0000

static int s_gc5004_mipi_gain = 0;
static int s_capture_shutter = 0;
static int s_capture_VTS = 0;
static int s_video_min_framerate = 0;
static int s_video_max_framerate = 0;

LOCAL uint32_t _gc5004_mipi_GetResolutionTrimTab(uint32_t param);
LOCAL uint32_t _gc5004_mipi_PowerOn(uint32_t power_on);				/*上电函数*/
LOCAL uint32_t _gc5004_mipi_Identify(uint32_t param);               /*读取ID函数*/
LOCAL uint32_t _gc5004_mipi_BeforeSnapshot(uint32_t param);
LOCAL uint32_t _gc5004_mipi_after_snapshot(uint32_t param);
LOCAL uint32_t _gc5004_mipi_StreamOn(uint32_t param);
LOCAL uint32_t _gc5004_mipi_StreamOff(uint32_t param);
LOCAL uint32_t _gc5004_mipi_write_exposure(uint32_t param);
LOCAL uint32_t _gc5004_mipi_write_gain(uint32_t param);
LOCAL uint32_t _gc5004_mipi_write_af(uint32_t param);
LOCAL uint32_t _gc5004_mipi_flash(uint32_t param);
LOCAL uint32_t _gc5004_mipi_ExtFunc(uint32_t ctl_param);
LOCAL uint32_t _gc5004_mipi_get_VTS(void);
LOCAL uint32_t _gc5004_mipi_set_VTS(int VTS);
LOCAL uint32_t _gc5004_mipi_ReadGain(uint32_t param);
LOCAL uint32_t _gc5004_mipi_set_video_mode(uint32_t param);
LOCAL uint32_t _gc5004_mipi_get_shutter(void);
LOCAL uint32_t _dw9174_SRCInit(uint32_t mode);
LOCAL uint32_t _gc5004_mipi_com_Identify_otp(void* param_ptr);

LOCAL const struct raw_param_info_tab s_gc5004_mipi_raw_param_tab[]={
{gc5004_mipi_RAW_PARAM_COM, &s_gc5004_mipi_raw_info, _gc5004_mipi_com_Identify_otp, PNULL},
{RAW_INFO_END_ID, PNULL, PNULL, PNULL}
};

struct sensor_raw_info* s_gc5004_mipi_raw_info_ptr=NULL;

static uint32_t g_module_id = 0;

static uint32_t g_flash_mode_en = 0;
static uint32_t g_af_slewrate = 1;

LOCAL const SENSOR_REG_T gc5004_mipi_common_init[] = {
//......
{0x04, 0x40},
{0x05, 0x01},
//......
};

LOCAL const SENSOR_REG_T gc5004_mipi_2592X1944_mipi_raw[] = {
//......
{0x18, 0x02},//skip on
//......
};

LOCAL SENSOR_REG_TAB_INFO_T s_gc5004_mipi_resolution_Tab_RAW[] = {
{ADDR_AND_LEN_OF_ARRAY(gc5004_mipi_common_init), 0, 0, 24, SENSOR_IMAGE_FORMAT_RAW},
{ADDR_AND_LEN_OF_ARRAY(gc5004_mipi_1296X972_mipi_raw), 1296, 972, 24, SENSOR_IMAGE_FORMAT_RAW},
{ADDR_AND_LEN_OF_ARRAY(gc5004_mipi_2592X1944_mipi_raw), 2592, 1944, 24, SENSOR_IMAGE_FORMAT_RAW},

};

LOCAL SENSOR_TRIM_T s_gc5004_mipi_Resolution_Trim_Tab[] = {
{0, 0, 0, 0, 0, 0, {0, 0, 0, 0}},
{0, 0, 1296, 972, 200, 480, 1000, {0, 0, 1296, 972}},//sysclk*10
{0, 0, 2592, 1944, 500, 480, 1972, {0, 0, 2592, 1944}},//sysclk*10

};

LOCAL const SENSOR_REG_T s_gc5004_mipi_1296X972_video_tab[SENSOR_VIDEO_MODE_MAX][1] = {
/*video mode 0: ?fps*/
{
{0xff, 0xff}
},

};
LOCAL const SENSOR_REG_T s_gc5004_mipi_2592X1944_video_tab[SENSOR_VIDEO_MODE_MAX][1] = {
/*video mode 0: ?fps*/
{
{0xff, 0xff}
},
};

LOCAL SENSOR_VIDEO_INFO_T s_gc5004_mipi_video_info[] = {
{{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}, PNULL},
{{{30, 30, 200, 64}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},(SENSOR_REG_T**)s_gc5004_mipi_1296X972_video_tab},
{{{15, 15, 500, 64}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},(SENSOR_REG_T**)s_gc5004_mipi_2592X1944_video_tab},
{{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}, PNULL},
};

LOCAL uint32_t _gc5004_mipi_set_video_mode(uint32_t param)
{
SENSOR_REG_T_PTR sensor_reg_ptr;
uint16_t         i = 0x00;
uint32_t         mode;

if (param >= SENSOR_VIDEO_MODE_MAX)
return 0;

if (SENSOR_SUCCESS != Sensor_GetMode(&mode)) {
SENSOR_PRINT("fail.");
return SENSOR_FAIL;
}

if (PNULL == s_gc5004_mipi_video_info[mode].setting_ptr) {
SENSOR_PRINT("fail.");
return SENSOR_FAIL;
}

sensor_reg_ptr = (SENSOR_REG_T_PTR)&s_gc5004_mipi_video_info[mode].setting_ptr[param];
if (PNULL == sensor_reg_ptr) {
SENSOR_PRINT("fail.");
return SENSOR_FAIL;
}

for (i=0x00; (0xff!=sensor_reg_ptr[i].reg_addr)||(0xff!=sensor_reg_ptr[i].reg_value); i++) {
Sensor_WriteReg(sensor_reg_ptr[i].reg_addr, sensor_reg_ptr[i].reg_value);
}

SENSOR_PRINT("0x%02x", param);
return 0;
}

LOCAL SENSOR_IOCTL_FUNC_TAB_T s_gc5004_mipi_ioctl_func_tab = {
PNULL,
_gc5004_mipi_PowerOn,     //上电
PNULL,
_gc5004_mipi_Identify,    //读取id
_gc5004_mipi_GetResolutionTrimTab,

_gc5004_mipi_BeforeSnapshot,
_gc5004_mipi_after_snapshot,
PNULL, //_gc5004_mipi_flash,
PNULL,
_gc5004_mipi_write_exposure,
PNULL,
_gc5004_mipi_write_gain,
PNULL,
PNULL,
_gc5004_mipi_write_af,    //对焦函数
PNULL,
PNULL, //_gc5004_mipi_GetExifInfo,
_gc5004_mipi_ExtFunc,
PNULL, //_gc5004_mipi_set_anti_flicker,
_gc5004_mipi_StreamOn,    //打开camera函数
_gc5004_mipi_StreamOff,   //关闭camera函数
PNULL,
};

SENSOR_INFO_T g_gc5004_mipi_raw_info = {   //外部调用接口
gc5004_mipi_I2C_ADDR_W,	// salve i2c write address
gc5004_mipi_I2C_ADDR_R,	// salve i2c read address

SENSOR_I2C_REG_8BIT | SENSOR_I2C_REG_8BIT,	// bit0: 0: i2c register value is 8 bit, 1: i2c register value is 16 bit
// bit1: 0: i2c register addr  is 8 bit, 1: i2c register addr  is 16 bit
// other bit: reseved
SENSOR_HW_SIGNAL_PCLK_N | SENSOR_HW_SIGNAL_VSYNC_N | SENSOR_HW_SIGNAL_HSYNC_P,	// bit0: 0:negative; 1:positive -> polarily of pixel clock
// bit2: 0:negative; 1:positive -> polarily of horizontal synchronization signal
// bit4: 0:negative; 1:positive -> polarily of vertical synchronization signal
// other bit: reseved

// preview mode
SENSOR_ENVIROMENT_NORMAL | SENSOR_ENVIROMENT_NIGHT,

// image effect
SENSOR_IMAGE_EFFECT_NORMAL |
SENSOR_IMAGE_EFFECT_BLACKWHITE |
SENSOR_IMAGE_EFFECT_RED |
SENSOR_IMAGE_EFFECT_GREEN |
SENSOR_IMAGE_EFFECT_BLUE |
SENSOR_IMAGE_EFFECT_YELLOW |
SENSOR_IMAGE_EFFECT_NEGATIVE | SENSOR_IMAGE_EFFECT_CANVAS,

// while balance mode
0,

7,			// bit[0:7]: count of step in brightness, contrast, sharpness, saturation
// bit[8:31] reseved

SENSOR_LOW_PULSE_RESET,	// reset pulse level
50,			// reset pulse width(ms)

SENSOR_HIGH_LEVEL_PWDN,	// 1: high level valid; 0: low level valid

1,			// count of identify code
{{0xf0, 0x50},		// supply two code to identify sensor.
{0xf1, 0x04}},		// for Example: index = 0-> Device id, index = 1 -> version id

SENSOR_AVDD_2800MV,	// voltage of avdd

2592,			// max width of source image
1944,			// max height of source image
"gc5004_mipi",		// name of sensor

SENSOR_IMAGE_FORMAT_RAW,	// define in SENSOR_IMAGE_FORMAT_E enum,SENSOR_IMAGE_FORMAT_MAX
// if set to SENSOR_IMAGE_FORMAT_MAX here, image format depent on SENSOR_REG_TAB_INFO_T

SENSOR_IMAGE_PATTERN_RAWRGB_B,// pattern of input image form sensor;

s_gc5004_mipi_resolution_Tab_RAW,	// point to resolution table information structure
&s_gc5004_mipi_ioctl_func_tab,	// point to ioctl function table
&s_gc5004_mipi_raw_info_ptr,		// information and table about Rawrgb sensor
NULL,			//&g_gc5004_mipi_ext_info,                // extend information about sensor
SENSOR_AVDD_1800MV,	// iovdd
SENSOR_AVDD_1500MV,	// dvdd
3,			// skip frame num before preview  打开camera到预览跳过得帧数
1,			// skip frame num before capture  打开camera拍照览跳过得帧数
0,			// deci frame num during preview
0,			// deci frame num during video preview

0,
0,
0,
0,
0,
{SENSOR_INTERFACE_TYPE_CSI2, 2, 10, 0},
s_gc5004_mipi_video_info,
3,			// skip frame num while change setting
};

LOCAL struct sensor_raw_info* Sensor_GetContext(void)
{

4000
return s_gc5004_mipi_raw_info_ptr;
}

LOCAL uint32_t Sensor_gc5004_mipi_InitRawTuneInfo(void)
{
uint32_t rtn=0x00;
struct sensor_raw_info* raw_sensor_ptr=Sensor_GetContext();
struct sensor_raw_tune_info* sensor_ptr=raw_sensor_ptr->tune_ptr;
struct sensor_raw_cali_info* cali_ptr=raw_sensor_ptr->cali_ptr;

raw_sensor_ptr->version_info->version_id=0x00010000;
raw_sensor_ptr->version_info->srtuct_size=sizeof(struct sensor_raw_info);

return rtn;
}

LOCAL uint32_t _gc5004_mipi_GetResolutionTrimTab(uint32_t param)
{
SENSOR_PRINT("0x%x",  (uint32_t)s_gc5004_mipi_Resolution_Trim_Tab);
return (uint32_t) s_gc5004_mipi_Resolution_Trim_Tab;
}

LOCAL uint32_t _gc5004_mipi_PowerOn(uint32_t power_on)  /*上电函数*/
{
SENSOR_AVDD_VAL_E dvdd_val = g_gc5004_mipi_raw_info.dvdd_val;
SENSOR_AVDD_VAL_E avdd_val = g_gc5004_mipi_raw_info.avdd_val;
SENSOR_AVDD_VAL_E iovdd_val = g_gc5004_mipi_raw_info.iovdd_val;
BOOLEAN power_down = g_gc5004_mipi_raw_info.power_down_level;
BOOLEAN reset_level = g_gc5004_mipi_raw_info.reset_pulse_level;

if (SENSOR_TRUE == power_on) {//上电时序
Sensor_PowerDown(power_down);
// Open power
Sensor_SetMonitorVoltage(SENSOR_AVDD_2800MV);
Sensor_SetVoltage(dvdd_val, avdd_val, iovdd_val);
Sensor_SetMonitorVoltage(SENSOR_AVDD_2800MV);
usleep(20*1000);
_dw9174_SRCInit(2);
Sensor_SetMCLK(SENSOR_DEFALUT_MCLK);
usleep(10*1000);
Sensor_PowerDown(!power_down);
// Reset sensor
Sensor_Reset(reset_level);
usleep(10*1000);
} else {
Sensor_PowerDown(power_down);
Sensor_SetMCLK(SENSOR_DISABLE_MCLK);
Sensor_SetVoltage(SENSOR_AVDD_CLOSED, SENSOR_AVDD_CLOSED, SENSOR_AVDD_CLOSED);
Sensor_SetMonitorVoltage(SENSOR_AVDD_CLOSED);
}
SENSOR_PRINT("SENSOR_gc5004_mipi: _gc5004_mipi_Power_On(1:on, 0:off): %d", power_on);
return SENSOR_SUCCESS;
}

LOCAL uint32_t _gc5004_mipi_cfg_otp(uint32_t  param)
{
uint32_t rtn=SENSOR_SUCCESS;
struct raw_param_info_tab* tab_ptr = (struct raw_param_info_tab*)s_gc5004_mipi_raw_param_tab;
uint32_t module_id=g_module_id;

SENSOR_PRINT("SENSOR_gc5004_mipi: _gc5004_mipi_cfg_otp");

if(PNULL!=tab_ptr[module_id].cfg_otp){
tab_ptr[module_id].cfg_otp(0);
}

return rtn;
}

LOCAL uint32_t _gc5004_mipi_com_Identify_otp(void* param_ptr)
{
uint32_t rtn=SENSOR_FAIL;
uint32_t param_id;

SENSOR_PRINT("SENSOR_gc5004_mipi: _gc5004_mipi_com_Identify_otp1111111111111111");

/*read param id from sensor omap*/
param_id=gc5004_mipi_RAW_PARAM_COM;

if(gc5004_mipi_RAW_PARAM_COM==param_id){
rtn=SENSOR_SUCCESS ;
}
rtn=SENSOR_SUCCESS ;
return rtn;
}

LOCAL uint32_t _gc5004_mipi_GetRawInof(void)
{
uint32_t rtn=SENSOR_SUCCESS;
struct raw_param_info_tab* tab_ptr = (struct raw_param_info_tab*)s_gc5004_mipi_raw_param_tab;
uint32_t param_id;
uint32_t i=0x00;

/*read param id from sensor omap*/
param_id=gc5004_mipi_RAW_PARAM_COM;

for(i=0x00; ; i++)
{
g_module_id = i;
if(RAW_INFO_END_ID==tab_ptr[i].param_id){
if(NULL==s_gc5004_mipi_raw_info_ptr){
SENSOR_PRINT("SENSOR_gc5004_mipi: ov5647_GetRawInof no param error");
rtn=SENSOR_FAIL;
}
SENSOR_PRINT("SENSOR_gc5004_mipi: gc5004_mipi_GetRawInof end");
break;
}
else if(PNULL!=tab_ptr[i].identify_otp){
if(SENSOR_SUCCESS==tab_ptr[i].identify_otp(0))
{
s_gc5004_mipi_raw_info_ptr = tab_ptr[i].info_ptr;
SENSOR_PRINT("SENSOR_gc5004_mipi: gc5004_mipi_GetRawInof success");
break;
}
}
}

return rtn;
}

LOCAL uint32_t _gc5004_mipi_GetMaxFrameLine(uint32_t index)
{
uint32_t max_line=0x00;
SENSOR_TRIM_T_PTR trim_ptr=s_gc5004_mipi_Resolution_Trim_Tab;

max_line=trim_ptr[index].frame_line;

return max_line;
}

LOCAL uint32_t _gc5004_mipi_Identify(uint32_t param)
{
#define gc5004_mipi_PID_VALUE    0x50
#define gc5004_mipi_PID_ADDR     0xf0
#define gc5004_mipi_VER_VALUE    0x04
#define gc5004_mipi_VER_ADDR     0xf1

uint8_t pid_value = 0x00;
uint8_t ver_value = 0x00;
uint32_t ret_value = SENSOR_FAIL;

SENSOR_PRINT("SENSOR_gc5004_mipi: mipi raw identify\n");

pid_value = Sensor_ReadReg(gc5004_mipi_PID_ADDR);
if (gc5004_mipi_PID_VALUE == pid_value) {
ver_value = Sensor_ReadReg(gc5004_mipi_VER_ADDR);//读取ID
SENSOR_PRINT("SENSOR_gc5004_mipi: Identify: PID = %x, VER = %x", pid_value, ver_value);
if (gc5004_mipi_VER_VALUE == ver_value) {   //判断读取的id是否正确
ret_value=_gc5004_mipi_GetRawInof();
Sensor_gc5004_mipi_InitRawTuneInfo();
ret_value = SENSOR_SUCCESS;
SENSOR_PRINT("SENSOR_gc5004_mipi: this is gc5004_mipi sensor !");
} else {
SENSOR_PRINT
("SENSOR_gc5004_mipi: Identify this is GC%x%x sensor !", pid_value, ver_value);
}
} else {
SENSOR_PRINT("SENSOR_gc5004_mipi: identify fail,pid_value=%x", pid_value);
}

return ret_value;//返回ID是否读取正确
}

LOCAL uint32_t _gc5004_mipi_write_exposure(uint32_t param)
{
uint32_t ret_value = SENSOR_SUCCESS;
uint16_t expsure_line=0x00;
uint16_t dummy_line=0x00;
uint16_t shutter_temp=0x00;

SENSOR_PRINT("gc5004_mipi_Write_line  param_exp  = %d \n",param);
expsure_line=param&0xffff;
dummy_line=(param>>0x10)&0xffff;

SENSOR_PRINT("gc5004_mipi_Write_line  dummy_line  = %d \n",dummy_line );
if (!expsure_line) expsure_line = 4; /* avoid 0 */

if(expsure_line < 4) expsure_line = 4;
if(expsure_line > 8191) expsure_line = 8191;//2    ^ 13
//Update Shutter
expsure_line = expsure_line/4;
expsure_line = expsure_line*4;
shutter_temp = expsure_line%4;

if(shutter_temp >2)
expsure_line+=4;

SENSOR_PRINT("gc5004_mipi_Write_line  5004line  = %d \n",expsure_line);
ret_value = Sensor_WriteReg(0x04, (expsure_line) & 0xFF);
ret_value = Sensor_WriteReg(0x03, (expsure_line >> 8) & 0x1F);

return ret_value;
}

LOCAL uint32_t _gc5004_mipi_write_gain(uint32_t param)
{
uint32_t ret_value = SENSOR_SUCCESS;

uint16_t temp=0x00;
uint32_t real_gain = 0;
SENSOR_PRINT("_gc5004_mipi raw _write_gain param = %d  \n",param);

real_gain = ((param&0xf)+16)*(((param>>4)&0x01)+1)*(((param>>5)&0x01)+1)*(((param>>6)&0x01)+1)*(((param>>7)&0x01)+1);
real_gain = real_gain*(((param>>8)&0x01)+1)*(((param>>9)&0x01)+1)*(((param>>10)&0x01)+1)*(((param>>11)&0x01)+1);

real_gain <<= 2;

SENSOR_PRINT("_gc5004_mipi raw _write_gain real_gain = %d  \n",real_gain);
Sensor_WriteReg(0xfe, 0x00);
Sensor_WriteReg(0xb6, 0x00);
Sensor_WriteReg(0xb1, 0x01);
Sensor_WriteReg(0xb2, 0x00);

if(real_gain < 64)
{
real_gain = 64;
Sensor_WriteReg(0xb6, 0x00);
Sensor_WriteReg(0xb1, 0x01);
Sensor_WriteReg(0xb2, 0x00);

}
else if ((64 <= real_gain)&(real_gain < 90))
{
Sensor_WriteReg(0xb6, 0x00);
temp = real_gain;
SENSOR_PRINT("_gc5004_mipi_write_gain_1 temp = %d  \n",temp);
Sensor_WriteReg(0xb1, temp>>6);
Sensor_WriteReg(0xb2, (temp<<2)&0xfc);
}
else if ((90 <= real_gain)&(real_gain < 128))
{
Sensor_WriteReg(0xb6, 0x01);
temp = 64*real_gain/90;
SENSOR_PRINT("_gc5004_mipi_write_gain_2 temp = %d  \n",temp);
Sensor_WriteReg(0xb1, temp>>6);
Sensor_WriteReg(0xb2, (temp<<2)&0xfc);
}
else if ((128 <= real_gain)&(real_gain < 178))
{
Sensor_WriteReg(0xb6, 0x02);
temp = 64*real_gain/128;
SENSOR_PRINT("_gc5004_mipi_write_gain_3 temp = %d  \n",temp);
Sensor_WriteReg(0xb1, temp>>6);
Sensor_WriteReg(0xb2, (temp<<2)&0xfc);
}
else if ((178 <= real_gain)&(real_gain < 247))
{
Sensor_WriteReg(0xb6, 0x03);
temp = 64*real_gain/178;
SENSOR_PRINT("_gc5004_mipi_write_gain_4 temp = %d  \n",temp);
Sensor_WriteReg(0xb1, temp>>6);
Sensor_WriteReg(0xb2, (temp<<2)&0xfc);
}
else if (247 <= real_gain)
{
Sensor_WriteReg(0xb6, 0x04);
temp = 64*real_gain/247;
SENSOR_PRINT("_gc5004_mipi_write_gain_5 temp = %d  \n",temp);
Sensor_WriteReg(0xb1, temp>>6);
Sensor_WriteReg(0xb2, (temp<<2)&0xfc);
}

return ret_value;
}

LOCAL uint32_t _gc5004_mipi_write_af(uint32_t param)
{
uint32_t ret_value = SENSOR_SUCCESS;
uint16_t  slave_addr = DW9714_VCM_SLAVE_ADDR;
uint16_t cmd_len = 0;
uint8_t cmd_val[2] = {0x00};

cmd_val[0] = ((param&0xfff0)>>4) & 0x3f;
cmd_val[1] = ((param&0x0f)<<4) & 0xf0;
cmd_len = 2;
ret_value = Sensor_WriteI2C(slave_addr,(uint8_t*)&cmd_val[0], cmd_len);

SENSOR_PRINT("SENSOR_Gc5004: _write_af, ret =  %d, param = %d,  MSL:%x, LSL:%x\n",
ret_value, param, cmd_val[0], cmd_val[1]);
return ret_value;
}

LOCAL uint32_t _gc5004_mipi_PreBeforeSnapshot(uint32_t param)
{
uint32_t  cap_shutter,prv_shutter;
uint32_t shutter_h,shutter_l,shutter;

SENSOR_PRINT("_gc5004_mipi_PreBeforeSnapshot param :%d",param);

if(SENSOR_MODE_PREVIEW_ONE>= param){
SENSOR_PRINT("SENSOR_gc5004_mipi:preview equal to capture");
return SENSOR_SUCCESS;
}

shutter_l = (uint8_t)Sensor_ReadReg(0x04);
shutter_h = (uint8_t)Sensor_ReadReg(0x03);
shutter = ((shutter_h<<8)&0x1F00)|(shutter_l&0xFF);
SENSOR_PRINT("SENSOR_gc5004_mipi_PreBeforeSnapshot prv_shutter = %d",shutter);
prv_shutter = shutter;

Sensor_SetMode(param);
cap_shutter = shutter*2/5;

SENSOR_PRINT("SENSOR_gc5004_mipi_PreBeforeSnapshot cap_shutter = %d",cap_shutter);

if(!cap_shutter)cap_shutter=1;
if(cap_shutter<1)cap_shutter=1;
if(cap_shutter>8191)cap_shutter=8191;

Sensor_WriteReg(0x04,cap_shutter&0xFF);
Sensor_WriteReg(0x03,(cap_shutter>>8)&0x1F);
//   usleep(100*1000);
//Sensor_StreamOff();
return SENSOR_SUCCESS;
}

LOCAL uint32_t _gc5004_mipi_BeforeSnapshot(uint32_t param)
{
uint32_t cap_mode = (param >> CAP_MODE_BITS);
uint32_t rtn = SENSOR_SUCCESS;
param = param & 0xffff;
rtn = _gc5004_mipi_PreBeforeSnapshot(param);
SENSOR_PRINT("_gc5004_mipi_BeforeSnapshot+++++++++++++++++ param = %d",param);
return rtn;
}
LOCAL uint32_t _gc5004_mipi_after_snapshot(uint32_t param)
{
SENSOR_PRINT("SENSOR_gc5004_mipi: after_snapshot mode:%d", param);
Sensor_SetMode(param);
return SENSOR_SUCCESS;
}
#if 0
LOCAL uint32_t _gc5004_mipi_flash(uint32_t param)
{
SENSOR_PRINT("SENSOR_gc5004_mipi: param=%d", param);
g_flash_mode_en = param;
Sensor_SetFlash(param);
SENSOR_PRINT_HIGH("end");
return SENSOR_SUCCESS;
}
#endif

LOCAL uint32_t _gc5004_mipi_StreamOn(uint32_t param)
{
SENSOR_PRINT("SENSOR_gc5004_mipi: StreamOn");
usleep(50*1000);
Sensor_WriteReg(0xfe, 0x03);
Sensor_WriteReg(0x10, 0x91);
Sensor_WriteReg(0xfe, 0x00);
usleep(50*1000);
return 0;
}

LOCAL uint32_t _gc5004_mipi_StreamOff(uint32_t param)
{
SENSOR_PRINT("SENSOR_gc5004_mipi: StreamOff");
usleep(50*1000);
Sensor_WriteReg(0xfe, 0x03);
Sensor_WriteReg(0x10, 0x81);
Sensor_WriteReg(0xfe, 0x00);
usleep(50*1000);
return 0;
}

static uint32_t _gc5004_mipi_SetEV(uint32_t param)
{
uint32_t rtn = SENSOR_SUCCESS;

return rtn;
}
LOCAL uint32_t _gc5004_mipi_ExtFunc(uint32_t ctl_param)
{
uint32_t rtn = SENSOR_SUCCESS;
SENSOR_EXT_FUN_PARAM_T_PTR ext_ptr =
(SENSOR_EXT_FUN_PARAM_T_PTR) ctl_param;
SENSOR_PRINT_HIGH("0x%x", ext_ptr->cmd);

switch (ext_ptr->cmd) {
case SENSOR_EXT_FUNC_INIT:
break;
case SENSOR_EXT_FOCUS_START:
break;
case SENSOR_EXT_EXPOSURE_START:
break;
case SENSOR_EXT_EV:
rtn = _gc5004_mipi_SetEV(ctl_param);
break;
default:
break;
}
return rtn;
}

LOCAL uint32_t _dw9174_SRCInit(uint32_t mode)
{
uint8_t cmd_val[2] = {0x00};
uint16_t  slave_addr = 0;
uint16_t cmd_len = 0;
uint32_t ret_value = SENSOR_SUCCESS;
int i = 0;

slave_addr = DW9714_VCM_SLAVE_ADDR;
SENSOR_PRINT("SENSOR_Gc5004: _DW9714A_SRCInit: mode = %d\n", mode);
switch (mode) {
case 1:
break;

case 2:
{
cmd_val[0] = 0xec;
cmd_val[1] = 0xa3;
cmd_len = 2;
ret_value = Sensor_WriteI2C(slave_addr,(uint8_t*)&cmd_val[0], cmd_len);

cmd_val[0] = 0xa1;
cmd_val[1] = 0x0e;
cmd_len = 2;
ret_value = Sensor_WriteI2C(slave_addr,(uint8_t*)&cmd_val[0], cmd_len);

cmd_val[0] = 0xf2;
cmd_val[1] = 0x90;
cmd_len = 2;
ret_value = Sensor_WriteI2C(slave_addr,(uint8_t*)&cmd_val[0], cmd_len);

cmd_val[0] = 0xdc;
cmd_val[1] = 0x51;
cmd_len = 2;
ret_value = Sensor_WriteI2C(slave_addr,(uint8_t*)&cmd_val[0], cmd_len);
}
break;

case 3:
break;

}

return ret_value;
}

LOCAL uint32_t _gc5004_mipi_ReadGain(uint32_t param)
{
uint32_t rtn = SENSOR_SUCCESS;
return rtn;
}