cmr_int cmr_sensor_open(cmr_handle sensor_handle, cmr_u32 sensor_id_bits)
{
CMR_MSG_INIT(message);
cmr_int ret = CMR_CAMERA_SUCCESS;
struct cmr_sensor_handle *handle = (struct cmr_sensor_handle *)sensor_handle;
cmr_u32 cameraId = 0;
CMR_LOGI("E");
CHECK_HANDLE_VALID(handle);
/*the open&close function should be sync*/
message.msg_type = CMR_SENSOR_EVT_OPEN;
message.sync_flag = CMR_MSG_SYNC_PROCESSED;
message.data = (void*)((unsigned long)sensor_id_bits);
ret = cmr_thread_msg_send(handle->thread_cxt.thread_handle, &message);
if (ret) {
CMR_LOGE("X send msg failed!");
return CMR_CAMERA_FAIL;
} else {
for (cameraId = 0; cameraId < CAMERA_ID_MAX; cameraId++) {
if (sensor_id_bits & (1 << cameraId)) {
break;
}
}
if (handle->sensor_cxt[cameraId].fd_sensor == CMR_CAMERA_FD_INIT) {
CMR_LOGE("camera %d open fail!", cameraId);
ret = CMR_CAMERA_FAIL;
}
}
CMR_LOGI("X ret %ld", ret);
return ret;
}
LOCAL uint32_t _BF3905_PowerOn(uint32_t power_on)
{
SENSOR_AVDD_VAL_E dvdd_val=g_BF3905_mipi_yuv_info.dvdd_val;
SENSOR_AVDD_VAL_E avdd_val=g_BF3905_mipi_yuv_info.avdd_val;
SENSOR_AVDD_VAL_E iovdd_val=g_BF3905_mipi_yuv_info.iovdd_val;
BOOLEAN power_down=g_BF3905_mipi_yuv_info.power_down_level;
BOOLEAN reset_level=g_BF3905_mipi_yuv_info.reset_pulse_level;
//uint32_t reset_width=g_BF3905_mipi_yuv_info.reset_pulse_width;
if(SENSOR_TRUE==power_on)
{
Sensor_PowerDown(power_down);
// Open power
Sensor_SetVoltage(dvdd_val, avdd_val, iovdd_val);
SENSOR_Sleep(20);
Sensor_SetMCLK(SENSOR_DEFALUT_MCLK);
SENSOR_Sleep(10);
Sensor_PowerDown(!power_down);
// Reset sensor
Sensor_Reset(reset_level);
CMR_LOGE("qzhu BF3905 power_on is true\n");
}
else
{
Sensor_PowerDown(power_down);
SENSOR_Sleep(10);
Sensor_SetMCLK(SENSOR_DISABLE_MCLK);
Sensor_SetVoltage(SENSOR_AVDD_CLOSED, SENSOR_AVDD_CLOSED, SENSOR_AVDD_CLOSED);
CMR_LOGE("qzhu BF3905 power_on is false\n");
}
return SENSOR_SUCCESS;
}
cmr_int cmr_sensor_deinit(cmr_handle sensor_handle)
{
CMR_LOGI("E");
cmr_int ret = CMR_CAMERA_SUCCESS;
struct cmr_sensor_handle *handle = (struct cmr_sensor_handle *)sensor_handle;
if (!sensor_handle) {
CMR_LOGE("X Invalid param!");
return CMR_CAMERA_INVALID_PARAM;
}
/*destory thread*/
ret = cmr_sns_destroy_thread(handle);
if (ret) {
CMR_LOGE("destory thread failed!");
ret = CMR_CAMERA_FAIL;
goto deinit_end;
}
/*release handle*/
if (handle) {
free(handle);
handle = NULL;
}
deinit_end:
CMR_LOGI("X ret %ld", ret);
return ret;
}
int camera_get_trim_rect(struct img_rect *src_trim_rect, uint32_t zoom_level, struct img_size *dst_size)
{
uint32_t trim_width;
uint32_t trim_height;
uint32_t zoom_step_w = 0, zoom_step_h = 0;
if (NULL == src_trim_rect || NULL == dst_size) {
CMR_LOGE("0x%x, 0x%x", (uint32_t)src_trim_rect, (uint32_t)dst_size);
return -CAMERA_INVALID_PARM;
}
trim_width = src_trim_rect->width;
trim_height = src_trim_rect->height;
if (0 == dst_size->width || 0 == dst_size->height) {
CMR_LOGE("0x%x, 0x%x", dst_size->width, dst_size->height);
return -CAMERA_INVALID_PARM;
}
if (dst_size->width * src_trim_rect->height < dst_size->height * src_trim_rect->width) {
trim_width = dst_size->width * src_trim_rect->height / dst_size->height;
} else {
trim_height = dst_size->height * src_trim_rect->width / dst_size->width;
}
zoom_step_w = ZOOM_STEP(trim_width);
zoom_step_w &= ~1;
zoom_step_w *= zoom_level;
zoom_step_h = ZOOM_STEP(trim_height);
zoom_step_h &= ~1;
zoom_step_h *= zoom_level;
trim_width = trim_width - zoom_step_w;
trim_height = trim_height - zoom_step_h;
src_trim_rect->start_x += (src_trim_rect->width - trim_width) >> 1;
src_trim_rect->start_y += (src_trim_rect->height - trim_height) >> 1;
src_trim_rect->start_x = CAMERA_WIDTH(src_trim_rect->start_x);
src_trim_rect->start_y = CAMERA_HEIGHT(src_trim_rect->start_y);
src_trim_rect->width = CAMERA_WIDTH(trim_width);
src_trim_rect->height = CAMERA_HEIGHT(trim_height);
CMR_LOGI("zoom_level %d, trim rect, %d %d %d %d",
zoom_level,
src_trim_rect->start_x,
src_trim_rect->start_y,
src_trim_rect->width,
src_trim_rect->height);
return CAMERA_SUCCESS;
}
/**---------------------------------------------------------------------------*
** External Functions *
**---------------------------------------------------------------------------*/
cmr_int cmr_sensor_init(struct sensor_init_param *init_param_ptr, cmr_handle *sensor_handle)
{
cmr_int ret = CMR_CAMERA_SUCCESS;
struct cmr_sensor_handle *handle = NULL;
CMR_LOGI("E");
if (!init_param_ptr) {
CMR_LOGE("Invalid param!");
return CMR_CAMERA_INVALID_PARAM;
}
handle = (struct cmr_sensor_handle *)malloc(sizeof(struct cmr_sensor_handle));
if (!handle) {
CMR_LOGE("No mem!");
return CMR_CAMERA_NO_MEM;
}
cmr_bzero(handle, sizeof(struct cmr_sensor_handle));
/*save init param*/
handle->oem_handle = init_param_ptr->oem_handle;
handle->sensor_bits = init_param_ptr->sensor_bits;
handle->private_data = init_param_ptr->private_data;
handle->is_autotest = init_param_ptr->is_autotest;
CMR_LOGD("oem_handle: 0x%lx, sensor_bits: %ld, private_data: 0x%lx autotest %ld",
(cmr_uint)handle->oem_handle, handle->sensor_bits, (cmr_uint)handle->private_data, handle->is_autotest);
/*create thread*/
ret = cmr_sns_create_thread(handle);
if (ret) {
CMR_LOGE("create thread failed!");
ret = CMR_CAMERA_FAIL;
goto init_end;
}
/*return handle*/
*sensor_handle = (cmr_handle)handle;
CMR_LOGI("handle 0x%lx created!", (cmr_uint)handle);
init_end:
if (ret) {
if (handle) {
free(handle);
handle = NULL;
}
}
CMR_LOGV("X ret %ld", ret);
return ret;
}
int camera_set_sensormark(void)
{
FILE *fp;
uint32_t i = 0;
uint32_t len = 0;
uint8_t sensor_param[SENSOR_PARAM_NUM];
int ret = CAMERA_SUCCESS;
bzero(&sensor_param[0], sizeof(sensor_param));
fp = fopen(SENSOR_PARA, "rb+");
if (NULL == fp) {
fp = fopen(SENSOR_PARA,"wb+");
if (NULL == fp) {
CMR_LOGE("open file error: %s",SENSOR_PARA);
}
memset(&sensor_param[0], 0xFF, SENSOR_PARAM_NUM);
}
if (NULL != fp) {
len = fread(sensor_param, 1, SENSOR_PARAM_NUM, fp);
CMR_LOGI(":param len %d", len);
CMR_LOGI("sensor param: %d, %d, %d, %d, %d, %d, %d, %d",
sensor_param[0], sensor_param[1], sensor_param[2], sensor_param[3],
sensor_param[4], sensor_param[5], sensor_param[6], sensor_param[7]);
fclose(fp);
}
Sensor_SetMark(sensor_param);
return CAMERA_SUCCESS;
}
/******************************************************************************
Function : ov5648_sunny_p5v18g_select_bank
Description: Select the specific bankNum. OTP will be read into IC's internel men.
******************************************************************************/
static int ov5648_sunny_p5v18g_select_bank(struct msm_sensor_ctrl_t *s_ctrl, int bankNum)
{
CMR_LOGD("%s, select bank num :%d\n",__func__, bankNum);
if (OV5648_SUNNY_P5V18G_OTP_BANK0 == bankNum)
{
ov5648_sunny_p5v18g_cci_i2c_write(s_ctrl, 0x3d84, 0xc0);
ov5648_sunny_p5v18g_cci_i2c_write(s_ctrl, 0x3d85, 0x00);//bank0
ov5648_sunny_p5v18g_cci_i2c_write(s_ctrl, 0x3d86, 0x0f);
ov5648_sunny_p5v18g_cci_i2c_write(s_ctrl, 0x3d81, 0x01);//start read
mdelay(3);//must delay 3ms
return 0;
}
else if (OV5648_SUNNY_P5V18G_OTP_BANK1 == bankNum)
{
ov5648_sunny_p5v18g_cci_i2c_write(s_ctrl, 0x3d84, 0xc0);
ov5648_sunny_p5v18g_cci_i2c_write(s_ctrl, 0x3d85, 0x10);//bank1
ov5648_sunny_p5v18g_cci_i2c_write(s_ctrl, 0x3d86, 0x1f);
ov5648_sunny_p5v18g_cci_i2c_write(s_ctrl, 0x3d81, 0x01);//start read
mdelay(3);//must delay 3ms
return 0;
}
else
{
CMR_LOGE("%s, Error bank number!\n",__func__);
return -1;
}
return 0;
}
static cmr_int cmr_sns_monitor_proc(void *p_data)
{
cmr_u32 ret = CMR_CAMERA_SUCCESS;
cmr_u32 i = 0, cnt = 0;
struct cmr_sensor_handle *sensor_handle = (struct cmr_sensor_handle *)p_data;
while (1) {
if (!sensor_handle) {
CMR_LOGE("sensor_handle is NULL");
return CMR_CAMERA_INVALID_PARAM;
}
usleep(10000);
if (sensor_handle->monitor_thread_cxt.is_exit) {
sensor_handle->monitor_thread_cxt.is_exit = 0;
CMR_LOGI("EXIT!");
break;
}
cnt ++;
if (cnt >= SENSOR_CHECK_STATUS_INTERVAL) {
cnt = 0;
for (i = 0; i < CAMERA_ID_MAX; i++) {
if (0 != ((1 << i) & sensor_handle->sensor_bits)) {
cmr_sns_check_err(sensor_handle, i);
}
}
}
}
return ret;
}
cmr_int cmr_sns_close(struct cmr_sensor_handle *handle, cmr_u32 sensor_id_bits)
{
cmr_int ret = CMR_CAMERA_SUCCESS;
cmr_u32 cameraId = 0;
cmr_u32 cameraCnt = 0;
CHECK_HANDLE_VALID(handle);
/*close all signed camera sensor*/
for (cameraId = 0; cameraId < CAMERA_ID_MAX; cameraId++) {
if (0 != (sensor_id_bits & (1 << cameraId))) {
ret = sensor_close_common(&handle->sensor_cxt[cameraId], cameraId);
if (ret) {
CMR_LOGE("camera %u open failed!", cameraId);
} else {
handle->sensor_bits &= ~(1 << cameraId);
CMR_LOGI("close sensor ok");
/*cmr_sns_af_init(&handle->sensor_cxt[cameraId]);*/
}
}
}
if (!handle->sensor_bits) {
/*when all sensors are closed, the monitor and focus move thread should be returned off*/
cmr_sns_kill_fmove_thread(handle);
cmr_sns_kill_monitor_thread(handle);
}
/*todo, if close not success, how to handle the issue*/
return ret;
}
cmr_int cmr_sensor_update_isparm_from_file(cmr_handle sensor_handle, cmr_uint sensor_id)
{
CMR_MSG_INIT(message);
cmr_int ret = CMR_CAMERA_SUCCESS;
struct cmr_sensor_handle *handle = (struct cmr_sensor_handle *)sensor_handle;
CMR_LOGI("E");
CHECK_HANDLE_VALID(handle);
ret = sensor_update_isparm_from_file(&handle->sensor_cxt[sensor_id], sensor_id);
#if 0
message.msg_type = CMR_SENSOR_EVT_ISPARAM_FROM_FILE;
message.sub_msg_type = sensor_id;
message.sync_flag = CMR_MSG_SYNC_PROCESSED;
ret = cmr_thread_msg_send(handle->thread_cxt.thread_handle, &message);
if (ret) {
CMR_LOGE("X send msg failed!");
return CMR_CAMERA_FAIL;
}
#endif
CMR_LOGI("X ret %ld", ret);
return ret;
}
cmr_int camera_get_trim_rect(struct img_rect *src_trim_rect, cmr_uint zoom_level, struct img_size *dst_size)
{
cmr_int ret = CMR_CAMERA_SUCCESS;
cmr_uint trim_width = 0, trim_height = 0;
cmr_uint zoom_step_w = 0, zoom_step_h = 0;
if (!src_trim_rect || !dst_size) {
CMR_LOGE("0x%lx 0x%lx", (cmr_uint)src_trim_rect, (cmr_uint)dst_size);
ret = -CMR_CAMERA_INVALID_PARAM;
goto exit;
}
trim_width = src_trim_rect->width;
trim_height = src_trim_rect->height;
if (0 == dst_size->width || 0 == dst_size->height) {
CMR_LOGE("0x%x 0x%x", dst_size->width, dst_size->height);
ret = -CMR_CAMERA_INVALID_PARAM;
goto exit;
}
if (dst_size->width * src_trim_rect->height < dst_size->height * src_trim_rect->width) {
trim_width = dst_size->width * src_trim_rect->height / dst_size->height;
} else {
trim_height = dst_size->height * src_trim_rect->width / dst_size->width;
}
zoom_step_w = ZOOM_STEP(trim_width);
zoom_step_w &= ~1;
zoom_step_w *= zoom_level;
zoom_step_h = ZOOM_STEP(trim_height);
zoom_step_h &= ~1;
zoom_step_h *= zoom_level;
trim_width = trim_width - zoom_step_w;
trim_height = trim_height - zoom_step_h;
src_trim_rect->start_x += (src_trim_rect->width - trim_width) >> 1;
src_trim_rect->start_y += (src_trim_rect->height - trim_height) >> 1;
src_trim_rect->start_x = CAMERA_WIDTH(src_trim_rect->start_x);
src_trim_rect->start_y = CAMERA_HEIGHT(src_trim_rect->start_y);
src_trim_rect->width = CAMERA_WIDTH(trim_width);
src_trim_rect->height = CAMERA_HEIGHT(trim_height);
CMR_LOGI("zoom_level %ld trim rect %d %d %d %d", zoom_level, src_trim_rect->start_x,
src_trim_rect->start_y, src_trim_rect->width, src_trim_rect->height);
exit:
return ret;
}
cmr_int camera_get_trim_rect2(struct img_rect *src_trim_rect, float zoom_ratio, float dst_ratio,
cmr_u32 sensor_w, cmr_u32 sensor_h, cmr_u8 rot)//for hal2.0 calculate crop again
{
cmr_u32 trim_width;
cmr_u32 trim_height;
float minOutputRatio;
float zoom_width, zoom_height, sensor_ratio;
if (NULL == src_trim_rect) {
CMR_LOGE("param error");
return -CMR_CAMERA_INVALID_PARAM;
} else if (src_trim_rect->width == 0 || src_trim_rect->height == 0) {
CMR_LOGE("0x%lx w %d h %d", (cmr_uint)src_trim_rect, src_trim_rect->width, src_trim_rect->height);
return -CMR_CAMERA_INVALID_PARAM;
}
minOutputRatio = dst_ratio;
sensor_ratio = (float)sensor_w / (float)sensor_h;
if (rot != IMG_ANGLE_0 && rot != IMG_ANGLE_180) {
minOutputRatio = 1 / minOutputRatio;
}
if (minOutputRatio > sensor_ratio) {
zoom_width = (float)sensor_w / zoom_ratio;
zoom_height = zoom_width / minOutputRatio;
} else {
zoom_height = (float)sensor_h / zoom_ratio;
zoom_width = zoom_height * minOutputRatio;
}
trim_width = (cmr_u32)zoom_width;
trim_height = (cmr_u32)zoom_height;
CMR_LOGI("sensor_ratio %f, minOutputRatio %f, zoom_ratio %f", sensor_ratio, minOutputRatio, zoom_ratio);
CMR_LOGI("trim_width %d, trim_height %d", trim_width, trim_height);
src_trim_rect->start_x += (src_trim_rect->width - trim_width) >> 1;
src_trim_rect->start_y += (src_trim_rect->height - trim_height) >> 1;
src_trim_rect->start_x = CAMERA_WIDTH(src_trim_rect->start_x);
src_trim_rect->start_y = CAMERA_HEIGHT(src_trim_rect->start_y);
src_trim_rect->width = CAMERA_WIDTH(trim_width);
src_trim_rect->height = CAMERA_HEIGHT(trim_height);
CMR_LOGI("zoom_level %f trim rect %d %d %d %d",
zoom_ratio,
src_trim_rect->start_x,
src_trim_rect->start_y,
src_trim_rect->width,
src_trim_rect->height);
return CMR_CAMERA_SUCCESS;
}
/******************************************************************************
Function : ov5648_sunny_p5v18g_otp_read_module_info
Description: read module info OTP.
******************************************************************************/
static int ov5648_sunny_p5v18g_otp_read_module_info(struct msm_sensor_ctrl_t *s_ctrl,
struct ov5648_sunny_p5v18g_otp_struct * otp_ptr)
{
//module info from group2,bank1 first
if (-1 == ov5648_sunny_p5v18g_select_bank(s_ctrl, OV5648_SUNNY_P5V18G_OTP_BANK1))
{
return -1;
}
//Module info: Bank 1:0x3d02~0x3d06
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d02, &(otp_ptr->product_year));
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d03, &(otp_ptr->product_month));
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d04, &(otp_ptr->product_date));
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d05, &(otp_ptr->camera_id));
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d06, &(otp_ptr->supplier_version_id));
CMR_LOGD("%s,group 2 otp_ptr.product_year:%d\n",__func__,otp_ptr->product_year);
CMR_LOGD("%s,group 2 otp_ptr.product_month:%d\n",__func__,otp_ptr->product_month);
CMR_LOGD("%s,group 2 otp_ptr.product_date:%d\n",__func__,otp_ptr->product_date);
CMR_LOGD("%s,group 2 otp_ptr.camera_id:%d\n",__func__,otp_ptr->camera_id);
CMR_LOGD("%s,group 2 otp_ptr.supplier_version_id:%d\n",__func__,otp_ptr->supplier_version_id);
ov5648_sunny_p5v18g_otp_clear(s_ctrl);
if (0 != otp_ptr->product_year)// year is not zero, we assume module info is correct
{
CMR_LOGW("%s, Module info lays in group 2\n",__func__);
return 0;
}
//group2 fail, check group1, bank0
if (-1 == ov5648_sunny_p5v18g_select_bank(s_ctrl, OV5648_SUNNY_P5V18G_OTP_BANK0))
{
return -1;
}
//Module info: Bank 0:0x3d05~0x3d09
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d05, &(otp_ptr->product_year));
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d06, &(otp_ptr->product_month));
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d07, &(otp_ptr->product_date));
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d08, &(otp_ptr->camera_id));
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d09, &(otp_ptr->supplier_version_id));
CMR_LOGD("%s,group 2 otp_ptr.product_year:%d\n",__func__,otp_ptr->product_year);
CMR_LOGD("%s,group 2 otp_ptr.product_month:%d\n",__func__,otp_ptr->product_month);
CMR_LOGD("%s,group 2 otp_ptr.product_date:%d\n",__func__,otp_ptr->product_date);
CMR_LOGD("%s,group 2 otp_ptr.camera_id:%d\n",__func__,otp_ptr->camera_id);
CMR_LOGD("%s,group 2 otp_ptr.supplier_version_id:%d\n",__func__,otp_ptr->supplier_version_id);
ov5648_sunny_p5v18g_otp_clear(s_ctrl);
if (0 != otp_ptr->product_year) // year is not zero, we assume module info is correct
{
CMR_LOGW("%s, Module info lays in group 1\n",__func__);
return 0;//otp read sucess
}
else
{
CMR_LOGE("%s, Error !No Module inf found in OTP\n",__func__);
return -1;//otp read fail
}
return 0;
}
void camera_take_snapshot_step(enum CAMERA_TAKEPIC_STEP step)
{
if (step > CMR_STEP_CALL_BACK) {
CMR_LOGE("error %d", step);
return;
}
cap_stp[step].timestamp = systemTime(CLOCK_MONOTONIC);
cap_stp[step].valid = 1;
}
int camera_get_trim_rect2(struct img_rect *src_trim_rect, float zoomRatio, float dstRatio,uint32_t SensorW, uint32_t SensorH, uint8_t Rot)//for hal2.0 calculate crop again
{
uint32_t trim_width;
uint32_t trim_height;
float minOutputRatio;
float zoomWidth,zoomHeight,SensorRatio;
if (NULL == src_trim_rect) {
CMR_LOGE("NULL");
return -CAMERA_INVALID_PARM;
} else if (src_trim_rect->width == 0 || src_trim_rect->height == 0) {
CMR_LOGE("0x%x w=%d h=%d", (uint32_t)src_trim_rect,src_trim_rect->width,src_trim_rect->height);
return -CAMERA_INVALID_PARM;
}
minOutputRatio = dstRatio;
SensorRatio = (float)SensorW /SensorH;
if (Rot != IMG_ROT_0) {
minOutputRatio = 1 / minOutputRatio;
}
if (minOutputRatio > SensorRatio) {
zoomWidth = SensorW / zoomRatio;
zoomHeight = zoomWidth / minOutputRatio;
} else {
zoomHeight = SensorH / zoomRatio;
zoomWidth = zoomHeight * minOutputRatio;
}
trim_width = zoomWidth;
trim_height = zoomHeight;
src_trim_rect->start_x += (src_trim_rect->width - trim_width) >> 1;
src_trim_rect->start_y += (src_trim_rect->height - trim_height) >> 1;
src_trim_rect->start_x = CAMERA_WIDTH(src_trim_rect->start_x);
src_trim_rect->start_y = CAMERA_HEIGHT(src_trim_rect->start_y);
src_trim_rect->width = CAMERA_WIDTH(trim_width);
src_trim_rect->height = CAMERA_HEIGHT(trim_height);
CMR_LOGI("zoom_level %f, trim rect, %d %d %d %d",
zoomRatio,
src_trim_rect->start_x,
src_trim_rect->start_y,
src_trim_rect->width,
src_trim_rect->height);
return CAMERA_SUCCESS;
}
/******************************************************************************
Function : ov5648_sunny_p5v18g_otp_read_vcm
Description: read vcm info OTP.
******************************************************************************/
static int ov5648_sunny_p5v18g_otp_read_vcm(struct msm_sensor_ctrl_t *s_ctrl,
struct ov5648_sunny_p5v18g_otp_struct * otp_ptr)
{
uint16_t vcm_start_value = 0;
uint16_t vcm_end_value = 0;
//vcm otp lays in bank1
if (0 != ov5648_sunny_p5v18g_select_bank(s_ctrl, OV5648_SUNNY_P5V18G_OTP_BANK1))
{
return -1;
}
//VCM Start: Bank 1, 0x3d0d, 0x3d00
//group 2
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d0d, &vcm_start_value);
CMR_LOGD("%s, VCM start group2 value:0x%x\n",__func__ , vcm_start_value);
if (0 == vcm_start_value)
{
//group1
ov5648_sunny_p5v18g_cci_i2c_read( s_ctrl, 0x3d00, &vcm_start_value);
CMR_LOGD("%s, VCM start group1 value:0x%x\n",__func__ , vcm_start_value);
}
//VCM:End, Bank 1,0x3d0e, 0x3d01
//group 2
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d0e, &vcm_end_value );
CMR_LOGD("%s, VCM end group2 value:0x%x\n",__func__ , vcm_end_value );
if (0 == vcm_end_value )
{
//group 1
ov5648_sunny_p5v18g_cci_i2c_read(s_ctrl, 0x3d01, &vcm_end_value );
CMR_LOGD("%s, VCM end group1 value:0x%x\n",__func__ , vcm_end_value );
}
//clear the buffer
ov5648_sunny_p5v18g_otp_clear(s_ctrl);
if ((0 != vcm_start_value) && (0 != vcm_end_value))
{
otp_ptr->vcm_start = vcm_start_value;
otp_ptr->vcm_end = vcm_end_value;
CMR_LOGD("%s, VCM info read sucess!\n\n",__func__);
//otp read success
return 0;
}
else
{
CMR_LOGE("%s, Error VCM info is not correct!\n",__func__);
//otp read fail
return -1;
}
}
cmr_int cmr_sns_open(struct cmr_sensor_handle *handle, cmr_u32 sensor_id_bits)
{
cmr_int ret = CMR_CAMERA_SUCCESS;
cmr_u32 cameraId = 0;
cmr_u32 cameraCnt = 0;
CHECK_HANDLE_VALID(handle);
/*open all signed camera sensor*/
for (cameraId = 0; cameraId < CAMERA_ID_MAX; cameraId++) {
if (0 != (sensor_id_bits & (1 << cameraId))) {
ret = sensor_open_common(&handle->sensor_cxt[cameraId], cameraId, handle->is_autotest);
if (ret) {
CMR_LOGE("camera %u open failed!", cameraId);
} else {
handle->sensor_bits |= (1 << cameraId);
}
}
}
if (!handle->sensor_bits) {
ret = CMR_CAMERA_FAIL;
} else {
ret = cmr_sns_create_monitor_thread(handle);
if (ret)
CMR_LOGE("camera monitor thread create failed");
for (cameraId = 0; cameraId < CAMERA_ID_MAX; cameraId++) {
if (0 != (sensor_id_bits & (1 << cameraId))) {
CMR_LOGE("sensor format =%d",handle->sensor_cxt[cameraId].sensor_info_ptr->image_format);
if (SENSOR_IMAGE_FORMAT_RAW != handle->sensor_cxt[cameraId].sensor_info_ptr->image_format) {
ret = cmr_sns_create_fmove_thread(handle);
if (ret)
CMR_LOGE("Failed to create focus move dummy thread");
}
}
}
}
return ret;
}
cmr_int cmr_sensor_focus_init(cmr_handle sensor_handle, cmr_u32 sensor_id)
{
cmr_int ret = CMR_CAMERA_SUCCESS;
CMR_MSG_INIT(message);
struct cmr_sensor_handle *handle = (struct cmr_sensor_handle *)sensor_handle;
CMR_LOGE("E");
CHECK_HANDLE_VALID(handle);
message.msg_type = CMR_SENSOR_EVT_AFINIT;
message.sub_msg_type = sensor_id;
message.sync_flag = CMR_MSG_SYNC_NONE;
ret = cmr_thread_msg_send(handle->thread_cxt.thread_handle, &message);
if (ret) {
CMR_LOGE("send msg failed!");
return CMR_CAMERA_FAIL;
}
CMR_LOGE("x ret= %ld",ret);
return ret;
}
int32_t ispGetUpParamV0000(void*param_ptr, void* rtn_param_ptr)
{
int32_t rtn=0x00;
uint32_t* offset_ptr=(uint32_t*)param_ptr;
struct isp_parser_buf_rtn* rtn_ptr=(struct isp_parser_buf_rtn*)rtn_param_ptr;
uint32_t* data_addr=NULL;
uint32_t data_len=0x00;
SENSOR_EXP_INFO_T_PTR sensor_info_ptr=Sensor_GetInfo();
struct sensor_raw_info* sensor_raw_info_ptr=(struct sensor_raw_info*)sensor_info_ptr->raw_info_ptr;
struct sensor_version_info* raw_version_info_ptr=sensor_raw_info_ptr->version_info;
struct sensor_raw_tune_info* raw_tune_ptr=sensor_raw_info_ptr->tune_ptr;
CMR_LOGE("ISP_TOOL:sensor_raw_info_ptr:0x%x:0x%x:0x%x",(uint32_t)sensor_raw_info_ptr, (uint32_t)raw_version_info_ptr, (uint32_t)raw_tune_ptr);
ispGetParamSizeV0000(&data_len);
rtn_ptr->buf_len=data_len+0x10;
data_addr=ispParserAlloc(rtn_ptr->buf_len);
rtn_ptr->buf_addr=(uint32_t)data_addr;
CMR_LOGE("ISP_TOOL:sensor_raw_info_ptr:0x%x:0x%x:0x%x:0x%x",(uint32_t)data_addr, (uint32_t)rtn_ptr->buf_addr, rtn_ptr->buf_len, data_len);
if(NULL!=data_addr)
{
// packet cfg
// version_id||module_id||packet_len||module_info||data
data_addr[0]=raw_version_info_ptr->version_id;
data_addr[1]=ISP_PACKET_ALL;
data_addr[2]=data_len;
data_addr[3]=0x00;
// tab
memcpy((void*)&data_addr[4], (void*)raw_tune_ptr, data_len);
}
else
{
rtn_ptr->buf_addr = (uint32_t)NULL;
rtn_ptr->buf_len = 0x00;
}
return rtn;
}
cmr_int cmr_sensor_get_flash_info (cmr_handle sensor_handle, cmr_u32 sensor_id, struct sensor_flash_level *level)
{
cmr_int ret = CMR_CAMERA_SUCCESS;
struct cmr_sensor_handle *handle = (struct cmr_sensor_handle *)sensor_handle;
CHECK_HANDLE_VALID(handle);
if (!handle || !level) {
CMR_LOGE("param err 0x%lx", (cmr_uint)sensor_handle);
ret = -CMR_CAMERA_INVALID_PARAM;
goto exit;
}
ret = sns_dev_get_flash_level (&handle->sensor_cxt[sensor_id], level);
if (ret) {
CMR_LOGE("get falsh level failed!");
ret = CMR_CAMERA_FAIL;
}
exit:
CMR_LOGI("ret= %ld", ret);
return ret;
}
LOCAL uint32_t _BF3905_Identify(uint32_t param)
{
#define BF3905_PID_VALUE 0x39
#define BF3905_PID_ADDR 0xFC
#define BF3905_VER_VALUE 0x05
#define BF3905_VER_ADDR 0xFD
uint8_t pid_value=0x00;
uint8_t ver_value=0x00;
uint32_t ret_value=SENSOR_FAIL;
CMR_LOGE("SENSOR:BF3905 identify .\n");
pid_value = Sensor_ReadReg(BF3905_PID_ADDR);
if(BF3905_PID_VALUE==pid_value)
{
ver_value=Sensor_ReadReg(BF3905_VER_ADDR);
CMR_LOGE("SENSOR: BF3905_Identify: PID = %x, VER = %x \n",pid_value, ver_value);
if(BF3905_VER_VALUE==ver_value)
{
ret_value=SENSOR_SUCCESS;
CMR_LOGE("SENSOR: this is BF3905 sensor ! \n");
}
else
{
CMR_LOGE("SENSOR: BF3905_Identify this is TOSHIBA sensor ! \n");
}
}
else
{
CMR_LOGE("SENSOR:BF3905 identify fail,pid_value=%d .\n",pid_value);
}
return ret_value;
}
/****************************************************************************
* FunctionName: ov5648_sunny_p5v18g_cci_i2c_write;
* Description : i2c write interface;
***************************************************************************/
static int32_t ov5648_sunny_p5v18g_cci_i2c_write(struct msm_sensor_ctrl_t *s_ctrl,uint32_t addr, uint16_t data)
{
int32_t rc = -EFAULT;
rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_write(
s_ctrl->sensor_i2c_client, addr, data, MSM_CAMERA_I2C_BYTE_DATA);
if(rc < 0)
{
CMR_LOGE("%s fail, rc = %d! addr = 0x%x, data = 0x%x\n", __func__, rc, addr, data);
}
return rc;
}
cmr_int cmr_sensor_ioctl(cmr_handle sensor_handle, cmr_u32 sensor_id, cmr_uint cmd, cmr_uint arg)
{
CMR_MSG_INIT(message);
cmr_int ret = CMR_CAMERA_SUCCESS;
struct cmr_sns_ioctl_param ioctl_param;
struct cmr_sensor_handle *handle = (struct cmr_sensor_handle *)sensor_handle;
CMR_LOGI("E");
CHECK_HANDLE_VALID(handle);
cmr_bzero(&ioctl_param, sizeof(ioctl_param));
ioctl_param.cmd = cmd;
ioctl_param.arg = arg;
/*the set mode function can be async control*/
message.msg_type = CMR_SENSOR_EVT_IOCTL;
message.sub_msg_type = sensor_id;
message.sync_flag = CMR_MSG_SYNC_PROCESSED;
message.data = (void *)malloc(sizeof(struct cmr_sns_ioctl_param));
if (!message.data) {
CMR_LOGE("No mem!");
return CMR_CAMERA_NO_MEM;
} else {
message.alloc_flag = 1;
}
cmr_copy(message.data, &ioctl_param, sizeof(struct cmr_sns_ioctl_param));
ret = cmr_thread_msg_send(handle->thread_cxt.thread_handle, &message);
if (ret) {
CMR_LOGE("send msg failed!");
return CMR_CAMERA_FAIL;
}
CMR_LOGI("X ret %ld", ret);
return ret;
}
/****************************************************************************
* FunctionName: ov5648_foxconn_132_cci_i2c_read;
* Description : i2c read interface;
***************************************************************************/
static int32_t ov5648_foxconn_132_cci_i2c_read(struct msm_sensor_ctrl_t *s_ctrl, uint32_t addr, uint16_t *data)
{
int32_t rc = -EFAULT;
uint16_t temp_data = 0;
rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_read(
s_ctrl->sensor_i2c_client,
addr,
&temp_data, MSM_CAMERA_I2C_BYTE_DATA);
if(rc < 0)
{
CMR_LOGE("%s fail, rc = %d! addr = 0x%x, data = 0x%x\n", __func__, rc, addr, temp_data);
}
*data = temp_data;
return rc;
}
cmr_int cmr_sensor_get_autotest_mode(cmr_handle sensor_handle, cmr_u32 sensor_id, cmr_uint *is_autotest)
{
UNUSED(sensor_id);
cmr_int ret = CMR_CAMERA_SUCCESS;
struct cmr_sensor_handle *handle = (struct cmr_sensor_handle *)sensor_handle;
if (!handle || !is_autotest) {
CMR_LOGE("param err 0x%lx", (cmr_uint)sensor_handle);
ret = -CMR_CAMERA_INVALID_PARAM;
goto exit;
}
*is_autotest = handle->is_autotest;
CMR_LOGI("auto test %d", (cmr_s32)*is_autotest);
exit:
return ret;
}
static cmr_int cmr_sns_af_init(struct sensor_drv_context *sensor_cxt)
{
SENSOR_EXT_FUN_PARAM_T af_param;
cmr_int ret = CMR_CAMERA_SUCCESS;
CMR_LOGI("Enter");
SENSOR_DRV_CHECK_ZERO(sensor_cxt);
af_param.cmd = SENSOR_EXT_FUNC_INIT;
af_param.param = SENSOR_EXT_FOCUS_TRIG;
ret = cmr_sns_ioctl(sensor_cxt, SENSOR_FOCUS, (cmr_uint)&af_param);
if (ret) {
CMR_LOGE("Failed to init AF");
} else {
CMR_LOGI("OK to init auto focus");
}
return ret;
}
cmr_int cmr_sensor_get_raw_settings(cmr_handle sensor_handle, void *raw_setting, cmr_u32 camera_id)
{
struct sensor_drv_context *sensor_cxt = NULL;
CHECK_HANDLE_VALID(sensor_handle);
sensor_cxt = &(((struct cmr_sensor_handle *)sensor_handle)->sensor_cxt[camera_id]);
if (PNULL == sensor_cxt->sensor_info_ptr) {
CMR_LOGE("No sensor info!");
return -1;
}
/*the current function of raw setting refer is a dummy*/
CHECK_HANDLE_VALID(raw_setting);
if (raw_setting) {
CMR_LOGI("get sensor_info_ptr addr %p", sensor_cxt->sensor_info_ptr);
cmr_copy(raw_setting, sensor_cxt->sensor_info_ptr, sizeof(EXIF_SPEC_PIC_TAKING_COND_T));
}
return CMR_CAMERA_SUCCESS;
}
/*because use copy methods, we should get info every time when use that*/
cmr_int cmr_sensor_get_info(cmr_handle sensor_handle, cmr_uint sensor_id, struct sensor_exp_info *sensor_info)
{
cmr_int ret = CMR_CAMERA_SUCCESS;
struct cmr_sensor_handle *handle = (struct cmr_sensor_handle *)sensor_handle;
CHECK_HANDLE_VALID(handle);
SENSOR_EXP_INFO_T *cur_sensor_info = NULL;
CMR_LOGV("E");
ret = sensor_get_info_common(&handle->sensor_cxt[sensor_id], &cur_sensor_info);
if (ret) {
CMR_LOGE("X fail, bypass this!");
return ret;
}
CHECK_HANDLE_VALID(sensor_info);
cmr_sns_copy_info(sensor_info, cur_sensor_info);
CMR_LOGV("X");
return ret;
}
cmr_int cmr_sensor_set_mode_done(cmr_handle sensor_handle, cmr_uint sensor_id)
{
cmr_int ret = CMR_CAMERA_SUCCESS;
CMR_MSG_INIT(message);
struct cmr_sensor_handle *handle = (struct cmr_sensor_handle*)sensor_handle;
CMR_LOGI("E");
CHECK_HANDLE_VALID(handle);
message.msg_type = CMR_SENSOR_EVT_SETMODONE;
message.sub_msg_type = sensor_id;
message.sync_flag = CMR_MSG_SYNC_PROCESSED;
ret = cmr_thread_msg_send(handle->thread_cxt.thread_handle, &message);
if (ret) {
CMR_LOGE("X send msg failed!");
return CMR_CAMERA_FAIL;
}
CMR_LOGI("X ret %ld", ret);
return ret;
}
cmr_int cmr_sensor_get_gain_thrs(cmr_handle sensor_handle, cmr_uint sensor_id, cmr_u32 *gain_thrs)
{
cmr_int ret = CMR_CAMERA_SUCCESS;
struct sensor_gain_thrs_tag *gain_thrs_param = NULL;
cmr_uint sensor_param = 0;
gain_thrs_param = malloc(sizeof(struct sensor_gain_thrs_tag));
if (!gain_thrs_param) {
CMR_LOGE("fail to malloc");
return CMR_CAMERA_NO_MEM;
}
gain_thrs_param->cmd = SENSOR_EXT_GAIN_OVER_THRS;
//gain_thrs_param->param = param_ptr->cmd_value;
sensor_param = (cmr_uint)gain_thrs_param;
ret = cmr_sensor_ioctl(sensor_handle, sensor_id, SENSOR_GET_GAIN_THRS, sensor_param);
*gain_thrs = gain_thrs_param->gain_thrs;
free(gain_thrs_param);
gain_thrs_param = NULL;
return ret;
}
