static int sensor_sr200_init(struct v4l2_subdev *subdev, u32 val)
{
int ret = 0;
u8 id;
struct sr200_state *state = to_state(subdev);
struct i2c_client *client = to_client(subdev);
cam_info("%s : E \n", __func__);
state->system_clock = 146 * 1000 * 1000;
state->line_length_pck = 146 * 1000 * 1000;
#ifdef CONFIG_LOAD_FILE
ret = sr200_regs_table_init();
CHECK_ERR_MSG(ret, "[CONFIG_LOAD_FILE] init fail \n");
#endif
sensor_sr200_apply_set(subdev, "sr200_Init_Reg", &sr200_regset_table.init);
sensor_sr200_apply_set(subdev, "sr200_stop_stream", &sr200_regset_table.stop_stream);
fimc_is_sr200_read8(client, 0x4, &id);
state->initialized = 1;
state->power_on = SR200_HW_POWER_ON;
state->runmode = RUNMODE_INIT;
state->preview.update_frmsize = 1;
cam_info("%s(id : %X) : X \n", __func__, id);
return ret;
}
int32_t sr200pc20_sensor_config(struct msm_sensor_ctrl_t *s_ctrl,
void __user *argp)
{
struct sensorb_cfg_data *cdata = (struct sensorb_cfg_data *)argp;
int32_t rc = 0;
int32_t i = 0;
mutex_lock(s_ctrl->msm_sensor_mutex);
CDBG("ENTER \n ");
switch (cdata->cfgtype) {
case CFG_GET_SENSOR_INFO:
CDBG("CFG_GET_SENSOR_INFO\n");
memcpy(cdata->cfg.sensor_info.sensor_name,
s_ctrl->sensordata->sensor_name,
sizeof(cdata->cfg.sensor_info.sensor_name));
cdata->cfg.sensor_info.session_id =
s_ctrl->sensordata->sensor_info->session_id;
for (i = 0; i < SUB_MODULE_MAX; i++)
cdata->cfg.sensor_info.subdev_id[i] =
s_ctrl->sensordata->sensor_info->subdev_id[i];
CDBG("%s:%d sensor name %s\n", __func__, __LINE__,
cdata->cfg.sensor_info.sensor_name);
CDBG("%s:%d session id %d\n", __func__, __LINE__,
cdata->cfg.sensor_info.session_id);
for (i = 0; i < SUB_MODULE_MAX; i++)
CDBG("%s:%d subdev_id[%d] %d\n", __func__, __LINE__, i,
cdata->cfg.sensor_info.subdev_id[i]);
break;
case CFG_SET_INIT_SETTING:
CDBG("CFG_SET_INIT_SETTING\n");
#ifdef CONFIG_LOAD_FILE /* this call should be always called first */
sr200_regs_table_init("/data/sr200pc20_yuv_t8.h");
pr_err("/data/sr200pc20_yuv_t8.h inside CFG_SET_INIT_SETTING");
#endif
rc = sr200pc20_WRT_LIST(s_ctrl,sr200pc20_Init_Reg);
#if 0
rc = sr200pc20_WRT_LIST(s_ctrl,sr200pc20_stop_stream);
#endif
break;
case CFG_SET_RESOLUTION:
sr200pc20_ctrl.settings.resolution = *((int32_t *)cdata->cfg.setting);
CDBG("CFG_SET_RESOLUTION - res = %d\n" , sr200pc20_ctrl.settings.resolution);
CDBG("sr200pc20_ctrl.op_mode = %d\n " , sr200pc20_ctrl.op_mode);
break;
case CFG_SET_STOP_STREAM:
CDBG("CFG_SET_STOP_STREAM - res = %d\n ", sr200pc20_ctrl.settings.resolution);
if(streamon == 1){
CDBG("CFG_SET_STOP_STREAM *** res = %d - streamon == 1\n " , sr200pc20_ctrl.settings.resolution);
#if 0
CDBG(" CFG_SET_STOP_STREAM writing stop stream registers: sr200pc20_stop_stream \n");
rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->
i2c_write_conf_tbl(
s_ctrl->sensor_i2c_client, sr200pc20_stop_stream,
ARRAY_SIZE(sr200pc20_stop_stream),
MSM_CAMERA_I2C_BYTE_DATA);
//rc = sr200pc20_WRT_LIST(s_ctrl,sr200pc20_stop_stream);
#endif
rc=0;
streamon = 0;
}
break;
case CFG_SET_START_STREAM:
CDBG("CFG_SET_START_STREAM\n");
CDBG("sr200pc20_ctrl.op_mode = %d,sr200pc20_ctrl.prev_mode = %d \n", sr200pc20_ctrl.op_mode, sr200pc20_ctrl.prev_mode);
switch (sr200pc20_ctrl.op_mode) {
case CAMERA_MODE_PREVIEW:
if (sr200pc20_ctrl.prev_mode != CAMERA_MODE_CAPTURE) {
switch (sr200pc20_ctrl.prev_mode) {
case CAMERA_MODE_INIT:
scene_mode_chg = 1;
sr200pc20_set_scene_mode(s_ctrl, sr200pc20_ctrl.settings.scenemode);
sr200pc20_set_effect( s_ctrl , sr200pc20_ctrl.settings.effect);
sr200pc20_set_white_balance( s_ctrl, sr200pc20_ctrl.settings.wb);
sr200pc20_set_exposure_compensation( s_ctrl , sr200pc20_ctrl.settings.exposure );
sr200pc20_set_metering(s_ctrl, sr200pc20_ctrl.settings.metering);
break;
case CAMERA_MODE_RECORDING:
sr200pc20_WRT_LIST(s_ctrl,sr200pc20_Init_Reg);
scene_mode_chg = 1;
sr200pc20_set_scene_mode(s_ctrl, sr200pc20_ctrl.settings.scenemode);
sr200pc20_set_effect( s_ctrl , sr200pc20_ctrl.settings.effect);
sr200pc20_set_white_balance( s_ctrl, sr200pc20_ctrl.settings.wb);
sr200pc20_set_exposure_compensation( s_ctrl , sr200pc20_ctrl.settings.exposure);
sr200pc20_set_metering(s_ctrl, sr200pc20_ctrl.settings.metering);
break;
case CAMERA_MODE_PREVIEW:
sr200pc20_set_scene_mode(s_ctrl, sr200pc20_ctrl.settings.scenemode);
break;
default:
pr_err("Invalid previous mode");
break;
}
}
if (sr200pc20_ctrl.op_mode != sr200pc20_ctrl.prev_mode) {
sr200pc20_set_resolution(s_ctrl , sr200pc20_ctrl.settings.resolution);
}
streamon = 1;
break;
case CAMERA_MODE_CAPTURE:
case CAMERA_MODE_RECORDING:
if (sr200pc20_ctrl.op_mode != sr200pc20_ctrl.prev_mode) {
sr200pc20_set_resolution(s_ctrl , sr200pc20_ctrl.settings.resolution );
}
streamon = 1;
break;
default:
pr_err("%s: CFG_SET_START_STREAM - %d INVALID mode\n", __func__, sr200pc20_ctrl.op_mode);
break;
}
break;
case CFG_SET_SLAVE_INFO: {
struct msm_camera_sensor_slave_info sensor_slave_info;
struct msm_camera_power_ctrl_t *p_ctrl;
uint16_t size;
int slave_index = 0;
CDBG("CFG_SET_SLAVE_INFO\n");
if (copy_from_user(&sensor_slave_info,
(void *)cdata->cfg.setting,
sizeof(sensor_slave_info))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
/* Update sensor slave address */
if (sensor_slave_info.slave_addr) {
s_ctrl->sensor_i2c_client->cci_client->sid =
sensor_slave_info.slave_addr >> 1;
}
/* Update sensor address type */
s_ctrl->sensor_i2c_client->addr_type =
sensor_slave_info.addr_type;
/* Update power up / down sequence */
p_ctrl = &s_ctrl->sensordata->power_info;
size = sensor_slave_info.power_setting_array.size;
if (p_ctrl->power_setting_size < size) {
struct msm_sensor_power_setting *tmp;
tmp = kmalloc(sizeof(*tmp) * size, GFP_KERNEL);
if (!tmp) {
pr_err("%s: failed to alloc mem\n", __func__);
rc = -ENOMEM;
break;
}
kfree(p_ctrl->power_setting);
p_ctrl->power_setting = tmp;
}
p_ctrl->power_setting_size = size;
rc = copy_from_user(p_ctrl->power_setting, (void *)
sensor_slave_info.power_setting_array.power_setting,
size * sizeof(struct msm_sensor_power_setting));
if (rc) {
pr_err("%s:%d failed\n", __func__, __LINE__);
kfree(sensor_slave_info.power_setting_array.
power_setting);
rc = -EFAULT;
break;
}
CDBG("%s sensor id %x\n", __func__,
sensor_slave_info.slave_addr);
CDBG("%s sensor addr type %d\n", __func__,
sensor_slave_info.addr_type);
CDBG("%s sensor reg %x\n", __func__,
sensor_slave_info.sensor_id_info.sensor_id_reg_addr);
CDBG("%s sensor id %x\n", __func__,
sensor_slave_info.sensor_id_info.sensor_id);
for (slave_index = 0; slave_index <
p_ctrl->power_setting_size; slave_index++) {
CDBG("%s i %d power setting %d %d %ld %d\n", __func__,
slave_index,
p_ctrl->power_setting[slave_index].seq_type,
p_ctrl->power_setting[slave_index].seq_val,
p_ctrl->power_setting[slave_index].config_val,
p_ctrl->power_setting[slave_index].delay);
}
break;
}
case CFG_WRITE_I2C_ARRAY: {
struct msm_camera_i2c_reg_setting conf_array;
struct msm_camera_i2c_reg_array *reg_setting = NULL;
CDBG("CFG_WRITE_I2C_ARRAY\n");
if (copy_from_user(&conf_array,
(void *)cdata->cfg.setting,
sizeof(struct msm_camera_i2c_reg_setting))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
reg_setting = kzalloc(conf_array.size *
(sizeof(struct msm_camera_i2c_reg_array)), GFP_KERNEL);
if (!reg_setting) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -ENOMEM;
break;
}
if (copy_from_user(reg_setting, (void *)conf_array.reg_setting,
conf_array.size *
sizeof(struct msm_camera_i2c_reg_array))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
kfree(reg_setting);
rc = -EFAULT;
break;
}
conf_array.reg_setting = reg_setting;
rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_write_table(
s_ctrl->sensor_i2c_client, &conf_array);
kfree(reg_setting);
break;
}
case CFG_WRITE_I2C_SEQ_ARRAY: {
struct msm_camera_i2c_seq_reg_setting conf_array;
struct msm_camera_i2c_seq_reg_array *reg_setting = NULL;
CDBG("CFG_WRITE_I2C_SEQ_ARRAY\n");
if (copy_from_user(&conf_array,
(void *)cdata->cfg.setting,
sizeof(struct msm_camera_i2c_seq_reg_setting))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
reg_setting = kzalloc(conf_array.size *
(sizeof(struct msm_camera_i2c_seq_reg_array)),
GFP_KERNEL);
if (!reg_setting) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -ENOMEM;
break;
}
if (copy_from_user(reg_setting, (void *)conf_array.reg_setting,
conf_array.size *
sizeof(struct msm_camera_i2c_seq_reg_array))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
kfree(reg_setting);
rc = -EFAULT;
break;
}
conf_array.reg_setting = reg_setting;
rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->
i2c_write_seq_table(s_ctrl->sensor_i2c_client,
&conf_array);
kfree(reg_setting);
break;
}
case CFG_POWER_UP:
CDBG("CFG_POWER_UP\n");
streamon = 0;
sr200pc20_ctrl.op_mode = CAMERA_MODE_INIT;
sr200pc20_ctrl.prev_mode = CAMERA_MODE_INIT;
sr200pc20_ctrl.settings.metering = CAMERA_CENTER_WEIGHT;
sr200pc20_ctrl.settings.exposure = CAMERA_EV_DEFAULT;
sr200pc20_ctrl.settings.wb = CAMERA_WHITE_BALANCE_AUTO;
sr200pc20_ctrl.settings.iso = CAMERA_ISO_MODE_AUTO;
sr200pc20_ctrl.settings.effect = CAMERA_EFFECT_OFF;
sr200pc20_ctrl.settings.scenemode = CAMERA_SCENE_AUTO;
if (s_ctrl->func_tbl->sensor_power_up) {
CDBG("CFG_POWER_UP");
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl,
&s_ctrl->sensordata->power_info,
s_ctrl->sensor_i2c_client,
s_ctrl->sensordata->slave_info,
s_ctrl->sensordata->sensor_name);
} else
rc = -EFAULT;
break;
case CFG_POWER_DOWN:
CDBG("CFG_POWER_DOWN\n");
if (s_ctrl->func_tbl->sensor_power_down) {
CDBG("CFG_POWER_DOWN");
rc = s_ctrl->func_tbl->sensor_power_down(
s_ctrl,
&s_ctrl->sensordata->power_info,
s_ctrl->sensor_device_type,
s_ctrl->sensor_i2c_client);
} else
rc = -EFAULT;
break;
case CFG_SET_STOP_STREAM_SETTING: {
struct msm_camera_i2c_reg_setting *stop_setting =
&s_ctrl->stop_setting;
struct msm_camera_i2c_reg_array *reg_setting = NULL;
CDBG("CFG_SET_STOP_STREAM_SETTING\n");
if (copy_from_user(stop_setting, (void *)cdata->cfg.setting,
sizeof(struct msm_camera_i2c_reg_setting))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
reg_setting = stop_setting->reg_setting;
stop_setting->reg_setting = kzalloc(stop_setting->size *
(sizeof(struct msm_camera_i2c_reg_array)), GFP_KERNEL);
if (!stop_setting->reg_setting) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -ENOMEM;
break;
}
if (copy_from_user(stop_setting->reg_setting,
(void *)reg_setting, stop_setting->size *
sizeof(struct msm_camera_i2c_reg_array))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
kfree(stop_setting->reg_setting);
stop_setting->reg_setting = NULL;
stop_setting->size = 0;
rc = -EFAULT;
break;
}
break;
}
default:
break;
}
