int32_t msm_sensor_setting1(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
static int csi_config;
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
printk("Register INIT\n");
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
msm_sensor_write_init_settings(s_ctrl);
if (NULL != s_ctrl->func_tbl->sensor_download_af_firmware)
{
pr_err("+++++download af firmware+++++++++++ %s \n",__func__);
rc=s_ctrl->func_tbl->sensor_download_af_firmware(s_ctrl);
if(!rc)
{
printk("%s:ov5640 AF FW download success\n",__func__);
#ifdef CONFIG_OV5640
download_flag=1; //download success is 1
#endif
}
}
csi_config = 0;
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
printk("PERIODIC : %d\n", res);
printk("%s:sensor_name = %s, res = %d\n",__func__, s_ctrl->sensordata->sensor_name, res);
msm_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
s_ctrl->msm_sensor_reg->mode_settings, res);
msleep(30);
if (!csi_config) {
s_ctrl->curr_csic_params = s_ctrl->csic_params[res];
printk("CSI config in progress\n");
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIC_CFG,
s_ctrl->curr_csic_params);
printk("CSI config is done\n");
mb();
msleep(30);
csi_config = 1;
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE,
&s_ctrl->sensordata->pdata->ioclk.vfe_clk_rate);
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(50);
}
return rc;
}
int32_t imx111_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
pr_err("[rafal47] %s: update: %d, res : %d : Change camera mode\n", __func__, update_type, res);
// s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
// msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
msm_sensor_enable_debugfs(s_ctrl);
msm_sensor_write_init_settings(s_ctrl);
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
if (res == 0) {
msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client,
(struct msm_camera_i2c_reg_conf *)
imx111_comm_confs[0].conf,
imx111_comm_confs[0].size,
imx111_comm_confs[0].data_type);
printk("[tykim] %s: csi_lane_assign not setting\n", __func__); /* */
} else {
msm_sensor_write_res_settings(s_ctrl, res);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
}
}
printk("%s: X", __func__);
return rc;
}
int32_t hi542_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
static int csi_config;
if (update_type == MSM_SENSOR_REG_INIT) {
CDBG("Register INIT\n");
printk("##### %s line%d: Register INIT\n",__func__,__LINE__);
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(66);
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
printk("##### %s line%d: begin to write init setting !\n",__func__,__LINE__);
msm_sensor_write_init_settings(s_ctrl);
printk("##### %s line%d: init setting end !\n",__func__,__LINE__);
csi_config = 0;
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
CDBG("PERIODIC : %d\n", res);
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(66);
msm_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
s_ctrl->msm_sensor_reg->mode_settings, res);
msleep(100);
if (!csi_config) {
s_ctrl->curr_csic_params = s_ctrl->csic_params[res];
CDBG("CSI config in progress\n");
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIC_CFG,
s_ctrl->curr_csic_params);
CDBG("CSI config is done\n");
mb();
msleep(30);
csi_config = 1;
}
//zxj ++
#ifdef ORIGINAL_VERSION
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE,
&s_ctrl->sensordata->pdata->ioclk.vfe_clk_rate);
#else
printk("##### %s line%d: vfe_clk_rate = %d\n",__func__,__LINE__,vfe_clk_rate);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &vfe_clk_rate);
#endif
//zxj --
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(100);
}
return rc;
}
int32_t msm_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_OFF_IMMEDIATELY));
printk("%s:[F_PANTECH_CAMERA] %d, %d res=%d\n", __func__, __LINE__,update_type,res);
if (s_ctrl->func_tbl->sensor_stop_stream)
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
msm_sensor_write_init_settings(s_ctrl);
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
msm_sensor_write_res_settings(s_ctrl, res);
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
printk("%s:[F_PANTECH_CAMERA] ==> MIPI setting E %d\n", __func__, update_type);
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CID_CHANGE, NULL);
mb();
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
msleep(20);
printk("%s:[F_PANTECH_CAMERA] ==> MIPI setting X %d\n", __func__, update_type);
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_ON_FRAME_BOUNDARY));
if (s_ctrl->func_tbl->sensor_start_stream) {
//printk("%s:kernal delay start %d x\n", __func__, __LINE__);
msleep(30); // 02.03 bsy pink ¡þO?oA¡þO??
//printk("%s: kernal delay end%d x\n", __func__, __LINE__);
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
}
msleep(30);
}
return rc;
}
int32_t mt9t113_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
pr_err("%s %d\n", __func__,update_type);
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
//s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
/*uesd to write special initialization arrays of some sensors*/
if(s_ctrl->func_tbl->sensor_write_init_settings)
{
s_ctrl->func_tbl->sensor_write_init_settings(s_ctrl);
}
else
{
msm_sensor_write_init_settings(s_ctrl);
}
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
msm_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
s_ctrl->msm_sensor_reg->mode_settings, res);
#if 0
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
s_ctrl->curr_csi_params->csid_params.lane_assign =
s_ctrl->sensordata->sensor_platform_info->
csi_lane_params->csi_lane_assign;
s_ctrl->curr_csi_params->csiphy_params.lane_mask =
s_ctrl->sensordata->sensor_platform_info->
csi_lane_params->csi_lane_mask;
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
mb();
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
msleep(20);
}
#endif
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(30);
}
pr_err("%s rc = %d\n", __func__,rc);
return rc;
}
int32_t msm_sensor_setting2(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
static int csi_config;
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
if (csi_config == 0 || res == 0)
msleep(66);
else
msleep(266);
if (update_type == MSM_SENSOR_REG_INIT) {
CDBG("Register INIT\n");
s_ctrl->curr_csi_params = NULL;
msm_camera_i2c_write(
s_ctrl->sensor_i2c_client,
0x103, 0x1,
MSM_CAMERA_I2C_BYTE_DATA);
msm_sensor_enable_debugfs(s_ctrl);
msm_sensor_write_init_settings(s_ctrl);
csi_config = 0;
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
CDBG("PERIODIC : %d\n", res);
msm_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
s_ctrl->msm_sensor_reg->mode_settings, res);
msleep(30);
if (!csi_config) {
s_ctrl->curr_csic_params = s_ctrl->csic_params[res];
CDBG("CSI config in progress\n");
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIC_CFG,
s_ctrl->curr_csic_params);
CDBG("CSI config is done\n");
mb();
msleep(30);
csi_config = 1;
msm_camera_i2c_write(
s_ctrl->sensor_i2c_client,
0x100, 0x1,
MSM_CAMERA_I2C_BYTE_DATA);
}
msm_camera_i2c_write(
s_ctrl->sensor_i2c_client,
0x4800, 0x4,
MSM_CAMERA_I2C_BYTE_DATA);
msleep(266);
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(50);
}
return rc;
}
int32_t imx111_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
printk("%s: E: update_type=%d, res=%d\n", __func__, update_type, res);
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
msm_sensor_write_init_settings(s_ctrl);
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
if (res == 0) {
msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client,
(struct msm_camera_i2c_reg_conf *)
imx111_comm_confs[0].conf,
imx111_comm_confs[0].size,
imx111_comm_confs[0].data_type);
} else {
msm_sensor_write_res_settings(s_ctrl, res);
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
s_ctrl->curr_csi_params->csid_params.lane_assign =
s_ctrl->sensordata->sensor_platform_info->
csi_lane_params->csi_lane_assign;
s_ctrl->curr_csi_params->csiphy_params.lane_mask =
s_ctrl->sensordata->sensor_platform_info->
csi_lane_params->csi_lane_mask;
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
mb();
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
msleep(20);
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(30);
}
}
printk("%s: X", __func__);
return rc;
}
int32_t msm_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_OFF_IMMEDIATELY));
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
#if !defined(DVE005_CAMERA_DRV)
msm_sensor_write_init_settings(s_ctrl);
#endif
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
#if defined(DVE005_CAMERA_DRV)
rc = s_ctrl->func_tbl->sensor_write_res_settings(s_ctrl, res);
#else
msm_sensor_write_res_settings(s_ctrl, res);
#endif
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CID_CHANGE, NULL);
mb();
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
msleep(20);
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_ON_FRAME_BOUNDARY));
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(30);
}
return rc;
}
int32_t hi351_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
static int csi_config;
if (update_type == MSM_SENSOR_REG_INIT) {
#if defined (LGE_CAMERA_ANTIBAND_50HZ) //Flicker 50Hz
pr_err("Register INIT with Flicker 50Hz Mode\n");
#else
pr_err("Register INIT with Flicker 60Hz Mode\n");
#endif
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
PREV_EFFECT = -1;
PREV_ISO = -1;
PREV_WB = -1;
PREV_FPS = -1;
PREV_BESTSHOT = -1;
DELAY_START = 0;
hi351_reg_init(s_ctrl);
csi_config = 0;
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
pr_err("PERIODIC : %d\n", res);
if (!csi_config) {
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(20);
s_ctrl->curr_csic_params = s_ctrl->csic_params[res];
pr_err("CSI config in progress\n");
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIC_CFG,
s_ctrl->curr_csic_params);
pr_err("CSI config is done\n");
mb();
msleep(50);
csi_config = 1;
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
}
hi351_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
s_ctrl->msm_sensor_reg->mode_settings, res);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE,
&s_ctrl->sensordata->pdata->ioclk.vfe_clk_rate);
}
return rc;
}
int32_t s5k5ca_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
printk("\n s5k5ca_sensor_setting() update_type:%d res:%d\n",update_type,res);
if (update_type == MSM_SENSOR_REG_INIT) {
//printk("PERIODIC : %d\n", res);
s_ctrl->curr_csic_params = s_ctrl->csic_params[res];
//printk("CSI config in progress\n");
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIC_CFG,
s_ctrl->curr_csic_params);
//printk("CSI config is done\n");
mb();
//printk("Register INIT\n");
s_ctrl->curr_csi_params = NULL;
rc=msm_sensor_enable_debugfs(s_ctrl);
if( rc!=0 )
printk("s5k5ca_sensor_setting()rc:%d",rc);
rc=msm_sensor_write_init_settings(s_ctrl);
if( rc!=0 )
printk("s5k5ca_sensor_setting()rc:%d",rc);
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
//CDBG("PERIODIC : %d\n", res);
if((res==0) &&(night_mode_flag==msm_v4l2_best_shot_night))
{
rc=msm_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
&s5k5ca_confs_night_mode[0], res);
if( rc!=0 )
printk("s5k5ca_sensor_setting()rc:%d",rc);
}
else
rc=msm_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
s_ctrl->msm_sensor_reg->mode_settings, res);
if( rc!=0 )
printk("s5k5ca_sensor_setting()rc:%d",rc);
if (res == MSM_SENSOR_RES_4)
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE,
&vfe_clk);
}
return rc;
}
int32_t msm_sensor_setting1(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
static int csi_config;
printk("%s : E\n", __func__); // [email protected]
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
CDBG("Register INIT\n");
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
msm_sensor_write_init_settings(s_ctrl);
csi_config = 0;
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
CDBG("PERIODIC : %d\n", res);
msm_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
s_ctrl->msm_sensor_reg->mode_settings, res);
msleep(30);
if (!csi_config) {
s_ctrl->curr_csic_params = s_ctrl->csic_params[res];
CDBG("CSI config in progress\n");
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIC_CFG,
s_ctrl->curr_csic_params);
CDBG("CSI config is done\n");
mb();
msleep(30);
csi_config = 1;
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE,
&s_ctrl->sensordata->pdata->ioclk.vfe_clk_rate);
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(50);
}
printk("%s : X\n", __func__); // [email protected]
return rc;
}
static int32_t ov2720_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int rt)
{
struct msm_camera_csid_params ov2720_csid_params;
struct msm_camera_csiphy_params ov2720_csiphy_params;
int32_t rc = 0;
s_ctrl->func_tbl.sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
s_ctrl->config_csi_flag = 1;
msm_sensor_enable_debugfs(s_ctrl);
msm_sensor_write_b_init_settings(s_ctrl);
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
msm_sensor_write_b_res_settings(s_ctrl, rt);
if (s_ctrl->config_csi_flag) {
struct msm_camera_csid_vc_cfg ov2720_vccfg[] = {
{0, CSI_RAW10, CSI_DECODE_10BIT},
{1, CSI_EMBED_DATA, CSI_DECODE_8BIT},
};
ov2720_csid_params.lane_cnt = 2;
ov2720_csid_params.lane_assign = 0xe4;
ov2720_csid_params.lut_params.num_cid =
ARRAY_SIZE(ov2720_vccfg);
ov2720_csid_params.lut_params.vc_cfg =
&ov2720_vccfg[0];
ov2720_csiphy_params.lane_cnt = 2;
ov2720_csiphy_params.settle_cnt = 0x1B;
rc = msm_camio_csid_config(&ov2720_csid_params);
v4l2_subdev_notify(s_ctrl->sensor_v4l2_subdev,
NOTIFY_CID_CHANGE, NULL);
mb();
rc = msm_camio_csiphy_config(&ov2720_csiphy_params);
mb();
msleep(20);
s_ctrl->config_csi_flag = 0;
}
s_ctrl->func_tbl.sensor_start_stream(s_ctrl);
msleep(30);
}
return rc;
}
int32_t msm_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
msm_sensor_write_init_settings(s_ctrl);
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
msm_sensor_write_res_settings(s_ctrl, res);
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
s_ctrl->curr_csi_params->csid_params.lane_assign =
s_ctrl->sensordata->sensor_platform_info->
csi_lane_params->csi_lane_assign;
s_ctrl->curr_csi_params->csiphy_params.lane_mask =
s_ctrl->sensordata->sensor_platform_info->
csi_lane_params->csi_lane_mask;
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
mb();
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
msleep(20);
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(30);
}
return rc;
}
int32_t iu091_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
int linecount;
int frame_time,exposure_time;
struct msm_sensor_output_info_t curr_info,new_info;
IU091_LOG_INF("START\n");
curr_info = iu091_dimensions[s_ctrl->curr_res];
new_info = iu091_dimensions[res];
if( res != 0)
{
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
}
if (update_type == MSM_SENSOR_REG_INIT) {
curr_frame_length_lines = 0;
rc = msm_sensor_enable_debugfs(s_ctrl);
if(rc < 0){
IU091_LOG_DBG("msm_sensor_enable_debugfs (rc:%d)\n",rc);
}
rc = msm_sensor_write_init_settings(s_ctrl);
if(rc < 0){
IU091_LOG_ERR("%s: msm_sensor_write_init_settings (rc:%d)\n", __func__,rc);
return rc;
}
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
if( s_ctrl->curr_res != MSM_SENSOR_INVALID_RES)
{
IU091_LOG_DBG("setting change %d -> %d\n",s_ctrl->curr_res,res);
if (curr_info.frame_length_lines > curr_frame_length_lines )
{
linecount = curr_info.frame_length_lines;
}else{
linecount = curr_frame_length_lines;
}
frame_time = 1000/(curr_info.vt_pixel_clk/(curr_info.line_length_pclk*linecount));
if( res != 0 )
{
IU091_LOG_DBG("current frame_out_time = %d line_length_pclk =%d linecount = %d vt_pixel_clk = %d\n", frame_time,curr_info.line_length_pclk,linecount,curr_info.vt_pixel_clk);
msleep(frame_time);
}
}
curr_frame_length_lines = new_info.frame_length_lines;
exposure_time = 1000/(new_info.vt_pixel_clk/(new_info.line_length_pclk*new_info.frame_length_lines));
if( ((s_ctrl->curr_res == MSM_SENSOR_RES_QTR) && (res == MSM_SENSOR_RES_FULL)) ||
((s_ctrl->curr_res == MSM_SENSOR_RES_2 ) && (res == MSM_SENSOR_RES_FULL)) )
{
rc = msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client,
(struct msm_camera_i2c_reg_conf *)
iu091_comm_confs[0].conf,
iu091_comm_confs[0].size,
iu091_comm_confs[0].data_type);
if(rc < 0){
return rc;
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
rc = msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client,
(struct msm_camera_i2c_reg_conf *)
iu091_comm_confs[1].conf,
iu091_comm_confs[1].size,
iu091_comm_confs[1].data_type);
if(rc < 0){
return rc;
}
rc = msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client,
(struct msm_camera_i2c_reg_conf *)
iu091_comm_confs[2].conf,
iu091_comm_confs[2].size,
iu091_comm_confs[2].data_type);
if(rc < 0){
return rc;
}
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(10);
rc = msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client,
(struct msm_camera_i2c_reg_conf *)
iu091_comm_confs[3].conf,
iu091_comm_confs[3].size,
iu091_comm_confs[3].data_type);
if(rc < 0){
return rc;
}
} else {
rc = msm_sensor_write_res_settings(s_ctrl, res);
if(rc < 0){
return rc;
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(exposure_time);
}
}
IU091_LOG_INF("END\n");
return rc;
}
int32_t mt9p017_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
static int csi_config;
struct msm_cam_media_controller *pmctl = NULL;
struct msm_actuator_ctrl_t *a_ctrl = NULL;
int16_t stored_step_pos=-1;
extern uint32_t my_mctl_handle;
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
printk("Register INIT\n");
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
if(s_ctrl->func_tbl->sensor_write_init_settings)
{
s_ctrl->func_tbl->sensor_write_init_settings(s_ctrl);
}
else
{
msm_sensor_write_init_settings(s_ctrl);
}
csi_config = 0;
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
printk("PERIODIC : %d\n", res);
/* here we need to get the actuator ctrl to do something to actuator
* before writing registers of preview or snapshot, move the actuator
* to init position 0, after sensor switched mode successfully, move
* to original position to get clear image
*/
pmctl = msm_camera_get_mctl(my_mctl_handle);
a_ctrl = get_actrl(pmctl->act_sdev);
stored_step_pos= a_ctrl->curr_step_pos;
printk("nowt the pos is %d\n", stored_step_pos);
msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
0x30F2, 0,
MSM_CAMERA_I2C_WORD_DATA);
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msm_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
s_ctrl->msm_sensor_reg->mode_settings, res);
msleep(30);
if (!csi_config) {
s_ctrl->curr_csic_params = s_ctrl->csic_params[res];
CDBG("CSI config in progress\n");
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIC_CFG,
s_ctrl->curr_csic_params);
CDBG("CSI config is done\n");
mb();
msleep(30);
csi_config = 1;
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE,
&s_ctrl->sensordata->pdata->ioclk.vfe_clk_rate);
msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
0x30F2, a_ctrl->step_position_table[stored_step_pos],
MSM_CAMERA_I2C_WORD_DATA);
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(50);
}
return rc;
}
int32_t mt9d113_sensor_setting1(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
static int csi_config;
SKYCDBG("%s: update_type = %d, res=%d E\n", __func__, update_type, res);
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
CDBG("Register INIT\n");
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
//needtocheck//
mt9d113_sensor_init(s_ctrl);//msm_sensor_write_init_settings(s_ctrl);
csi_config = 0;
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
CDBG("PERIODIC : %d\n", res);
//msm_sensor_write_conf_array(
// s_ctrl->sensor_i2c_client,
// s_ctrl->msm_sensor_reg->mode_settings, res);
msleep(30);
if (!csi_config) {
SKYCDBG("%s: ==> MIPI setting E %d\n", __func__, update_type);
s_ctrl->curr_csic_params = s_ctrl->csic_params[res];
CDBG("CSI config in progress\n");
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIC_CFG,
s_ctrl->curr_csic_params);
CDBG("CSI config is done\n");
mb();
msleep(30);
csi_config = 1;
SKYCDBG("%s: ==> MIPI setting X %d\n", __func__, update_type);
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE,
&s_ctrl->sensordata->pdata->ioclk.vfe_clk_rate);
//s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
#if 1//needtocheck
switch (res) {
case 0:
// rc = ce1612_snapshot_config(s_ctrl);
rc = si2c_write_param(SI2C_SA, SI2C_SNAPSHOT, mt9d113_params);
if (rc < 0) {
SKYCDBG("%s snapshot config err(%d)\n", __func__, rc);
return rc;
}
SKYCDBG("Sensor setting : Case 0 snapshot config");
break;
case 1:
// rc = ce1612_video_config(s_ctrl);
rc = si2c_write_param(SI2C_SA, SI2C_PREVIEW, mt9d113_params);
if (rc < 0) {
SKYCDBG("%s video config err(%d)\n", __func__, rc);
return rc;
}
#if 1//for_test
if(current_fps != 31)
mt9d113_sensor_set_preview_fps(s_ctrl ,current_fps);
#else
if ((previewFPS > C_PANTECH_CAMERA_MIN_PREVIEW_FPS) && (previewFPS < C_PANTECH_CAMERA_MAX_PREVIEW_FPS))
{
SKYCDBG("%s: preview_fps=%d\n", __func__, previewFPS);
mt9d113_sensor_set_preview_fps(NULL ,previewFPS);
}
#endif
SKYCDBG("Sensor setting : Case 1 Video config");
break;
//case 2:
// rc = ce1612_1080p_config(s_ctrl);
// break;
case 3:
// rc = ce1612_ZSL_config(s_ctrl);
SKYCDBG("Sensor setting : Case 3 ZSL config");
break;
default:
// rc = ce1612_video_config(s_ctrl);
SKYCDBG("Sensor setting : Default Video config");
break;
}
#endif
sensor_mode = res;
SKYCDBG("Sensor setting : Res = %d\n", res);
msleep(50);
}
return rc;
}
int32_t ov7695_raw_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
static int csi_config;
struct msm_camera_pip_ctl pip_ctl;
// s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
CDBG("Register INIT\n");
pip_ctl.sensor_i2c_client = s_ctrl->sensor_i2c_client;
/*OV7695 powerup and software reset*/
pip_ov5648_ctrl(PIP_CRL_POWERUP, &pip_ctl);
usleep_range(2000, 3000);
pip_ov5648_ctrl(PIP_CTL_RESET_HW_PULSE, &pip_ctl);
msleep(10);
msm_camera_i2c_write(
s_ctrl->sensor_i2c_client,
0x103, 0x1,
MSM_CAMERA_I2C_BYTE_DATA);
usleep_range(2000, 3000);
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
msm_sensor_write_init_settings(s_ctrl);
usleep_range(2000, 3000);
pip_ov5648_ctrl(PIP_CTL_RESET_SW, &pip_ctl);
usleep_range(2000, 3000);
/*OV5648 init settings*/
/*writing to OV5648, open lanes*/
pip_ctl.write_ctl = PIP_REG_SETTINGS_INIT;
pip_ov5648_ctrl(PIP_CRL_WRITE_SETTINGS, &pip_ctl);
msleep(60);
csi_config = 0;
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
CDBG("PERIODIC : %d\n", res);
if (!csi_config) {
pip_ctl.sensor_i2c_client = s_ctrl->sensor_i2c_client;
pip_ov5648_ctrl(PIP_CTL_STREAM_OFF, &pip_ctl);
msleep(70);
pip_ov5648_ctrl(PIP_CTL_STANDBY_SW, &pip_ctl);
msleep(10);
msm_sensor_write_all_conf_array(
s_ctrl->sensor_i2c_client, &ov7695_raw_confs[0],
ARRAY_SIZE(ov7695_raw_confs));
// msm_camera_i2c_write(
// s_ctrl->sensor_i2c_client,
// 0x100, 0x1,
// MSM_CAMERA_I2C_BYTE_DATA);
msleep(60);
pip_ctl.write_ctl = res;
pip_ov5648_ctrl(PIP_CRL_WRITE_SETTINGS, &pip_ctl);
msleep(30);
s_ctrl->curr_csic_params = s_ctrl->csic_params[res];
CDBG("CSI config in progress\n");
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIC_CFG,
s_ctrl->curr_csic_params);
CDBG("CSI config is done\n");
mb();
msleep(30);
csi_config = 1;
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE,
&s_ctrl->sensordata->pdata->ioclk.vfe_clk_rate);
// s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(50);
pip_ov5648_ctrl(PIP_CTL_STANDBY_EXIT, &pip_ctl);
msleep(50);
pip_ov5648_ctrl(PIP_CTL_STREAM_ON, &pip_ctl);
msleep(50);
}
}
return rc;
}
int32_t imx111_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
int linecount;
int frame_time,exposure_time;
struct msm_sensor_output_info_t curr_info,new_info;
curr_info = imx111_dimensions[s_ctrl->curr_res];
new_info = imx111_dimensions[res];
if( res != 0) {
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_OFF_IMMEDIATELY));
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
}
if (update_type == MSM_SENSOR_REG_INIT) {
curr_frame_length_lines = 0;
s_ctrl->curr_csi_params = NULL;
rc = msm_sensor_enable_debugfs(s_ctrl);
if(rc < 0){
CDBG("%s: msm_sensor_enable_debugfs (rc:%d)\n", __func__,rc);
}
rc = msm_sensor_write_init_settings(s_ctrl);
if (rc < 0) {
return rc;
}
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
if( s_ctrl->curr_res != MSM_SENSOR_INVALID_RES)
{
CDBG("imx111.c %s: setting change %d -> %d\n", __func__,
s_ctrl->curr_res,res);
if (curr_info.frame_length_lines > curr_frame_length_lines ) {
linecount = curr_info.frame_length_lines;
} else {
linecount = curr_frame_length_lines;
}
frame_time = 1000/(curr_info.vt_pixel_clk/(curr_info.line_length_pclk*linecount));
if ( res != 0 ) {
CDBG("imx111.c %s: current frame_out_time = %d line_length_pclk =%d linecount = %d vt_pixel_clk = %d\n", __func__,frame_time,curr_info.line_length_pclk,linecount,curr_info.vt_pixel_clk);
msleep(frame_time);
}
}
curr_frame_length_lines = new_info.frame_length_lines;
exposure_time = 1000/(new_info.vt_pixel_clk/(new_info.line_length_pclk*new_info.frame_length_lines));
if( s_ctrl->curr_res != 0 && res == 0) {
rc = msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client,
(struct msm_camera_i2c_reg_conf *)
imx111_comm_confs[0].conf,
imx111_comm_confs[0].size,
imx111_comm_confs[0].data_type);
if (rc < 0){
return rc;
}
rc = msm_sensor_write_res_settings(s_ctrl, res);
if (rc < 0){
return rc;
}
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CID_CHANGE, NULL);
mb();
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
msleep(20);
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_ON_FRAME_BOUNDARY));
rc = msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client,
(struct msm_camera_i2c_reg_conf *)
imx111_comm_confs[1].conf,
imx111_comm_confs[1].size,
imx111_comm_confs[1].data_type);
if (rc < 0){
return rc;
}
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(10);
rc = msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client,
(struct msm_camera_i2c_reg_conf *)
imx111_comm_confs[2].conf,
imx111_comm_confs[2].size,
imx111_comm_confs[2].data_type);
if (rc < 0){
return rc;
}
} else {
rc = msm_sensor_write_res_settings(s_ctrl, res);
if(rc < 0){
return rc;
}
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CID_CHANGE, NULL);
mb();
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
msleep(20);
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_ON_FRAME_BOUNDARY));
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
msleep(exposure_time);
}
}
return rc;
}
int32_t msm_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
#ifdef CONFIG_RAWCHIP
struct rawchip_sensor_data rawchip_data;
struct timespec ts_start, ts_end;
#endif
pr_info("%s update_type:%d\n", __func__,update_type);
v4l2_subdev_notify(s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX0, ISPIF_OFF_IMMEDIATELY));
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
if (update_type == MSM_SENSOR_REG_INIT) {
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
msm_sensor_write_init_settings(s_ctrl);
first_init = 1;
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
/*TODO : pointer to each sensor driver to get correct delay time*/
if(!first_init)
mdelay(50);
msm_sensor_write_res_settings(s_ctrl, res);
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
v4l2_subdev_notify(s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
v4l2_subdev_notify(s_ctrl->sensor_v4l2_subdev,
NOTIFY_CID_CHANGE, NULL);
mb();
v4l2_subdev_notify(s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
}
#ifdef CONFIG_RAWCHIP
if (s_ctrl->sensordata->use_rawchip) {
rawchip_data.sensor_name = s_ctrl->sensordata->sensor_name;
rawchip_data.datatype = s_ctrl->curr_csi_params->csid_params.lut_params.vc_cfg->dt;
rawchip_data.lane_cnt = s_ctrl->curr_csi_params->csid_params.lane_cnt;
rawchip_data.pixel_clk = s_ctrl->msm_sensor_reg->output_settings[res].op_pixel_clk;
rawchip_data.mirror_flip = s_ctrl->mirror_flip;
rawchip_data.width = s_ctrl->msm_sensor_reg->output_settings[res].x_output;
rawchip_data.height = s_ctrl->msm_sensor_reg->output_settings[res].y_output;
rawchip_data.line_length_pclk = s_ctrl->msm_sensor_reg->output_settings[res].line_length_pclk;
rawchip_data.frame_length_lines = s_ctrl->msm_sensor_reg->output_settings[res].frame_length_lines;
rawchip_data.x_addr_start = s_ctrl->msm_sensor_reg->output_settings[res].x_addr_start;
rawchip_data.y_addr_start = s_ctrl->msm_sensor_reg->output_settings[res].y_addr_start;
rawchip_data.x_addr_end = s_ctrl->msm_sensor_reg->output_settings[res].x_addr_end;
rawchip_data.y_addr_end = s_ctrl->msm_sensor_reg->output_settings[res].y_addr_end;
rawchip_data.x_even_inc = s_ctrl->msm_sensor_reg->output_settings[res].x_even_inc;
rawchip_data.x_odd_inc = s_ctrl->msm_sensor_reg->output_settings[res].x_odd_inc;
rawchip_data.y_even_inc = s_ctrl->msm_sensor_reg->output_settings[res].y_even_inc;
rawchip_data.y_odd_inc = s_ctrl->msm_sensor_reg->output_settings[res].y_odd_inc;
rawchip_data.binning_rawchip = s_ctrl->msm_sensor_reg->output_settings[res].binning_rawchip;
rawchip_data.fullsize_width = s_ctrl->msm_sensor_reg->output_settings[MSM_SENSOR_RES_FULL].x_output;
rawchip_data.fullsize_height = s_ctrl->msm_sensor_reg->output_settings[MSM_SENSOR_RES_FULL].y_output;
rawchip_data.fullsize_line_length_pclk =
s_ctrl->msm_sensor_reg->output_settings[MSM_SENSOR_RES_FULL].line_length_pclk;
rawchip_data.fullsize_frame_length_lines =
s_ctrl->msm_sensor_reg->output_settings[MSM_SENSOR_RES_FULL].frame_length_lines;
ktime_get_ts(&ts_start);
rawchip_set_size(rawchip_data);
ktime_get_ts(&ts_end);
pr_info("%s: %ld ms\n", __func__,
(ts_end.tv_sec-ts_start.tv_sec)*1000+(ts_end.tv_nsec-ts_start.tv_nsec)/1000000);
}
#endif
v4l2_subdev_notify(s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
v4l2_subdev_notify(s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX0, ISPIF_ON_FRAME_BOUNDARY));
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
first_init = 0;
}
return rc;
}
int32_t mt9m114_msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
pr_err("%s %s_i2c_probe \n", __func__, client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s %s i2c_check_functionality failed\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
s_ctrl->sensor_device_type = MSM_SENSOR_I2C_DEVICE;
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
pr_err("%s %s sensor_i2c_client NULL\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s %s NULL sensor data\n", __func__, client->name);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s %s power up failed\n", __func__, client->name);
return rc;
}
if (s_ctrl->func_tbl->sensor_match_id)
rc = s_ctrl->func_tbl->sensor_match_id(s_ctrl);
else
rc = msm_sensor_match_id(s_ctrl);
if (rc < 0)
goto probe_fail;
#ifdef CONFIG_SENSOR_INFO
msm_sensorinfo_set_front_sensor_id(s_ctrl->sensor_id_info->sensor_id);
#else
//do nothing here
#endif
if (!s_ctrl->wait_num_frames)
s_ctrl->wait_num_frames = 1 * Q10;
pr_err("%s %s probe succeeded\n", __func__, client->name);
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
s_ctrl->sensor_v4l2_subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_ctrl->sensor_v4l2_subdev.entity, 0, NULL, 0);
s_ctrl->sensor_v4l2_subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_ctrl->sensor_v4l2_subdev.entity.group_id = SENSOR_DEV;
s_ctrl->sensor_v4l2_subdev.entity.name =
s_ctrl->sensor_v4l2_subdev.name;
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
s_ctrl->sensor_v4l2_subdev.entity.revision =
s_ctrl->sensor_v4l2_subdev.devnode->num;
msm_sensor_enable_debugfs(s_ctrl);
goto power_down;
probe_fail:
pr_err("%s %s_i2c_probe failed\n", __func__, client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
s_ctrl->sensor_state = MSM_SENSOR_POWER_DOWN;
return rc;
}
//mt9d113_sensor_setting
int32_t mt9d113_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
SKYCDBG("%s: update_type = %d, res=%d E\n", __func__, update_type, res);
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
s_ctrl->curr_csi_params = NULL;
msm_sensor_enable_debugfs(s_ctrl);
//needtocheck//
mt9d113_sensor_init(s_ctrl);//msm_sensor_write_init_settings(s_ctrl);
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
//needtocheck//
//msm_sensor_write_res_settings(s_ctrl, res);
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
SKYCDBG("%s: ==> MIPI setting E %d\n", __func__, update_type);
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
s_ctrl->curr_csi_params->csid_params.lane_assign =
s_ctrl->sensordata->sensor_platform_info->
csi_lane_params->csi_lane_assign;
s_ctrl->curr_csi_params->csiphy_params.lane_mask =
s_ctrl->sensordata->sensor_platform_info->
csi_lane_params->csi_lane_mask;
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
mb();
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
msleep(20);
SKYCDBG("%s: ==> MIPI setting X %d\n", __func__, update_type);
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
//s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
#if 0//needtocheck
switch (res) {
case 0:
// rc = ce1612_snapshot_config(s_ctrl);
break;
case 1:
// rc = ce1612_video_config(s_ctrl);
si2c_write_param(SI2C_SA, SI2C_INIT, s5k6aafx13_params);
SKYCDBG("Sensor setting : Case 1 Video config");
break;
//case 2:
// rc = ce1612_1080p_config(s_ctrl);
// break;
case 3:
// rc = ce1612_ZSL_config(s_ctrl);
SKYCDBG("Sensor setting : Case 3 ZSL config");
break;
default:
// rc = ce1612_video_config(s_ctrl);
SKYCDBG("Sensor setting : Default Video config");
break;
}
#endif
sensor_mode = res;
SKYCDBG("Sensor setting : Res = %d\n", res);
msleep(30);
}
SKYCDBG("%s: %d x\n", __func__, __LINE__);
return rc;
}
int32_t msm_ov9740_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_OFF_IMMEDIATELY));
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
s_ctrl->curr_csi_params = NULL;
rc=msm_sensor_enable_debugfs(s_ctrl);
rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x0103, 0x01, MSM_CAMERA_I2C_BYTE_DATA);
if (rc < 0) {
pr_err("%s: i2c write failed\n", __func__);
return rc;
}
msleep(10);
rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client, OV9740_MODE_SELECT, 0x00, MSM_CAMERA_I2C_BYTE_DATA);
if (rc < 0) {
pr_err("%s: i2c write failed\n", __func__);
return rc;
}
}
else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
rc=gpio_direction_output(53, 1);
if (rc < 0)
pr_err("%s gpio direction 53 failed\n",__func__);
rc=gpio_direction_output(76, 0);
if (rc < 0)
pr_err("%s gpio direction 76 failed\n",__func__);
msleep(20);
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
pr_err("%s:mipi begin res=%d\n", __func__,res);
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CID_CHANGE, NULL);
mb();
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
msleep(20);
pr_err("%s:mipi end res=%d\n", __func__,res);
}
rc=gpio_direction_output(53, 0);
if (rc < 0)
pr_err("%s gpio direction 53 failed\n",__func__);
rc=gpio_direction_output(76, 1);
if (rc < 0)
pr_err("%s gpio direction 76 failed\n",__func__);
msleep(20);
pr_err("%s: msm_sensor_write_res_settings res=%d \n", __func__,res);
rc=msm_sensor_ov9740_write_res_settings(s_ctrl, res);
if (rc < 0) {
pr_err("%s: msm_sensor_write_res_settings failed\n", __func__);
return rc;
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_ON_FRAME_BOUNDARY));
rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client, OV9740_MODE_SELECT, 0x01, MSM_CAMERA_I2C_BYTE_DATA);
if (rc < 0) {
pr_err("%s: i2c write failed\n", __func__);
}
}
pr_err("%s: X %d\n", __func__, __LINE__);
return rc;
}
int32_t s5k5ca_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
printk("\n s5k5ca_sensor_setting() update_type:%d res:%d\n",update_type,res);
if (update_type == MSM_SENSOR_REG_INIT) {
//printk("PERIODIC : %d\n", res);
s_ctrl->curr_csic_params = s_ctrl->csic_params[res];
//printk("CSI config in progress\n");
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIC_CFG,
s_ctrl->curr_csic_params);
//printk("CSI config is done\n");
mb();
//printk("Register INIT\n");
s_ctrl->curr_csi_params = NULL;
rc=msm_sensor_enable_debugfs(s_ctrl);
if( rc!=0 )
printk("s5k5ca_sensor_setting()rc:%d",rc);
rc=msm_sensor_write_init_settings(s_ctrl);
if( rc!=0 )
printk("s5k5ca_sensor_setting()rc:%d",rc);
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
//CDBG("PERIODIC : %d\n", res);
//++ petershih -20130225 - tmp add ++
if(res == 0)
{
rc=msm_camera_i2c_write_tbl(
s5k5ca_s_ctrl.sensor_i2c_client,
s5k5ca_pre_capture_settings,
ARRAY_SIZE(s5k5ca_pre_capture_settings),
s5k5ca_s_ctrl.msm_sensor_reg->default_data_type);
if( rc!=0 )
printk("s5k5ca_sensor_setting()s5k5ca_pre_capture_settings rc:%d",rc);
msleep(140);
}
#if 0
else
{
rc=msm_camera_i2c_write_tbl(
s5k5ca_s_ctrl.sensor_i2c_client,
s5k5ca_pre_preview_settings,
ARRAY_SIZE(s5k5ca_pre_preview_settings),
s5k5ca_s_ctrl.msm_sensor_reg->default_data_type);
if( rc!=0 )
printk("s5k5ca_sensor_setting()s5k5ca_pre_preview_settings rc:%d",rc);
msleep(140);
}
#endif
//-- petershih -20130225 - tmp add --
if((res==0) &&(night_mode_flag==msm_v4l2_best_shot_night))
{
rc=msm_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
&s5k5ca_confs_night_mode[0], res);
if( rc!=0 )
printk("s5k5ca_sensor_setting()rc:%d",rc);
}
else
rc=msm_sensor_write_conf_array(
s_ctrl->sensor_i2c_client,
s_ctrl->msm_sensor_reg->mode_settings, res);
if( rc!=0 )
printk("s5k5ca_sensor_setting()rc:%d",rc);
if (res == MSM_SENSOR_RES_4)
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE,
&vfe_clk);
}
return rc;
}
/* msm_sensor_setting */
int32_t yacd5c1sbdbc_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl,
int update_type, int res)
{
int32_t rc = 0;
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_OFF_IMMEDIATELY));
SKYCDBG("%s:[F_PANTECH_CAMERA] %d, %d res=%d\n", __func__, __LINE__,update_type,res);
if (s_ctrl->func_tbl->sensor_stop_stream)
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(30);
if (update_type == MSM_SENSOR_REG_INIT) {
s_ctrl->curr_csi_params = NULL;
g_preview_fps= 0;
msm_sensor_enable_debugfs(s_ctrl);
#ifdef CONFIG_PANTECH_CAMERA_TUNER
SKYCDBG("[CONFIG_PANTECH_CAMERA_TUNER]%s PASS init_setting\n ",__func__);
tuner_init_check = 1;
#else
yacd5c1sbdbc_sensor_write_init_settings(s_ctrl);
#endif
} else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) {
#ifdef CONFIG_PANTECH_CAMERA_TUNER
if (tuner_init_check == 1) {
SKYCDBG("[CONFIG_PANTECH_CAMERA_TUNER]%s init_setting\n ",__func__);
yacd5c1sbdbc_sensor_write_init_settings(s_ctrl);
tuner_init_check = 0;
}
SKYCDBG("[CONFIG_PANTECH_CAMERA_TUNER]%s res=%d res_setting\n ",__func__,res);
yacd5c1sbdbc_sensor_write_res_settings(s_ctrl, res);
#else
yacd5c1sbdbc_sensor_write_res_settings(s_ctrl, res);
#endif
#ifdef CONFIG_PANTECH_CAMERA_YACD5C1SBDBC// for VTS
//if (strcmp(s_ctrl->sensordata->sensor_name, "yacd5c1sbdbc"))
if((s_ctrl->sensor_id_info->sensor_id == YACD5C1SBDBC_ID) &&
(preview_24fps_for_motion_detect_check == 1)){
//printk("[CONFIG_PANTECH_CAMERA for VTS] msleep(133)==>\n");
//msleep(133);
SKYCDBG("[CONFIG_PANTECH_CAMERA for VTS]preview_24fps_for_motion_detect_cfg_settings\n ");
rc = msm_camera_i2c_write_tbl(
s_ctrl->sensor_i2c_client,
s_ctrl->msm_sensor_reg->preview_24fps_for_motion_detect_cfg_settings[0],
s_ctrl->msm_sensor_reg->preview_24fps_for_motion_detect_cfg_settings_size,
s_ctrl->msm_sensor_reg->default_data_type);
preview_24fps_for_motion_detect_check = 0;
if (rc < 0)
{
SKYCERR("ERR:%s 24fps FAIL!!! rc=%d \n", __func__, rc);
return rc;
}
}
#if 0// for camif err
else {
if(res==1) yacd5c1sbdbc_sensor_set_preview_fps(s_ctrl , g_preview_fps);
}
#endif
#endif
if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) {
SKYCDBG("%s:[F_PANTECH_CAMERA] ==> MIPI setting E %d\n", __func__, update_type);
s_ctrl->curr_csi_params = s_ctrl->csi_params[res];
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSID_CFG,
&s_ctrl->curr_csi_params->csid_params);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CID_CHANGE, NULL);
mb();
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_CSIPHY_CFG,
&s_ctrl->curr_csi_params->csiphy_params);
mb();
msleep(20);
SKYCDBG("%s:[F_PANTECH_CAMERA] ==> MIPI setting X %d\n", __func__, update_type);
}
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg->
output_settings[res].op_pixel_clk);
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM(
PIX_0, ISPIF_ON_FRAME_BOUNDARY));
if (s_ctrl->func_tbl->sensor_start_stream)
s_ctrl->func_tbl->sensor_start_stream(s_ctrl);
#ifdef T_OSCAR
msleep(300); //msleep(150); //msleep(30);
#else
msleep(200);//msleep(150); //msleep(30);
#endif
}
SKYCDBG("%s: %d x\n", __func__, __LINE__);
return rc;
}
