int32_t msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
CDBG("%s %s_i2c_probe called\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);
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;
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;
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;
}
int32_t msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
CDBG("%s_i2c_probe called\n", client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
CDBG("i2c_check_functionality failed\n");
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
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 {
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s: NULL sensor data\n", __func__);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0)
goto probe_fail;
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;
if (s_ctrl->sensor_eeprom_client != NULL) {
struct msm_camera_eeprom_client *eeprom_client =
s_ctrl->sensor_eeprom_client;
if (eeprom_client->func_tbl.eeprom_init != NULL &&
eeprom_client->func_tbl.eeprom_release != NULL) {
rc = eeprom_client->func_tbl.eeprom_init(
eeprom_client,
s_ctrl->sensor_i2c_client->client->adapter);
if (rc < 0)
goto probe_fail;
rc = msm_camera_eeprom_read_tbl(eeprom_client,
eeprom_client->read_tbl, eeprom_client->read_tbl_size);
eeprom_client->func_tbl.eeprom_release(eeprom_client);
if (rc < 0)
goto probe_fail;
}
}
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);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto power_down;
probe_fail:
pr_err("%s_i2c_probe failed\n", client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
return rc;
}
int32_t msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
CDBG("%s %s_i2c_probe called\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);
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_MACH_ACER_A9
if (s_ctrl->sensor_info) {
if (create_device_info(s_ctrl->sensor_info))
pr_err("%s: create_device_info failed\n", __func__);
} else {
pr_err("%s: %s doesn't contain device info\n",
__func__, s_ctrl->sensor_i2c_driver->driver.name);
}
#endif
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);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
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);
pr_err("%s %s success\n", __func__,client->name);
return rc;
}
int32_t gc0339_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0, index = 0;
struct msm_sensor_power_setting_array *power_setting_array = NULL;
struct msm_sensor_power_setting *power_setting = NULL;
struct msm_camera_sensor_board_info *data = s_ctrl->sensordata;
CDBG("%s:%d\n", __func__, __LINE__);
power_setting_array = &s_ctrl->power_setting_array;
if (data->gpio_conf->cam_gpiomux_conf_tbl != NULL) {
pr_err("%s:%d mux install\n", __func__, __LINE__);
msm_gpiomux_install(
(struct msm_gpiomux_config *)
data->gpio_conf->cam_gpiomux_conf_tbl,
data->gpio_conf->cam_gpiomux_conf_tbl_size);
}
rc = msm_camera_request_gpio_table(
data->gpio_conf->cam_gpio_req_tbl,
data->gpio_conf->cam_gpio_req_tbl_size, 1);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
return rc;
}
for (index = 0; index < power_setting_array->size; index++) {
CDBG("%s index %d\n", __func__, index);
power_setting = &power_setting_array->power_setting[index];
CDBG("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
if (power_setting->seq_val >= s_ctrl->clk_info_size) {
pr_err("%s clk index %d >= max %d\n", __func__,
power_setting->seq_val,
s_ctrl->clk_info_size);
goto power_up_failed;
}
if (power_setting->config_val)
s_ctrl->clk_info[power_setting->seq_val].
clk_rate = power_setting->config_val;
rc = msm_cam_clk_enable(s_ctrl->dev,
&s_ctrl->clk_info[0],
(struct clk **)&power_setting->data[0],
s_ctrl->clk_info_size,
1);
if (rc < 0) {
pr_err("%s: clk enable failed\n",
__func__);
goto power_up_failed;
}
break;
case SENSOR_GPIO:
if (power_setting->seq_val >= SENSOR_GPIO_MAX ||
!data->gpio_conf->gpio_num_info) {
pr_err("%s gpio index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
goto power_up_failed;
}
pr_debug("%s:%d gpio set val %d\n", __func__, __LINE__,
data->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val]);
if (data->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val])
gpio_set_value_cansleep(
data->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val],
power_setting->config_val);
break;
case SENSOR_VREG:
if (power_setting->seq_val >= CAM_VREG_MAX) {
pr_err("%s vreg index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
goto power_up_failed;
}
msm_camera_config_single_vreg(s_ctrl->dev,
&data->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
1);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
power_setting->seq_type);
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
if (s_ctrl->sensor_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_util(
s_ctrl->sensor_i2c_client, MSM_CCI_INIT);
if (rc < 0) {
pr_err("%s cci_init failed\n", __func__);
goto power_up_failed;
}
}
s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_write(
s_ctrl->sensor_i2c_client,
0xfc,
0x10, MSM_CAMERA_I2C_BYTE_DATA);
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) {
pr_err("%s:%d match id failed rc %d\n", __func__, __LINE__, rc);
goto power_up_failed;
}
CDBG("%s exit\n", __func__);
return 0;
power_up_failed:
pr_err("%s:%d failed\n", __func__, __LINE__);
if (s_ctrl->sensor_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_util(
s_ctrl->sensor_i2c_client, MSM_CCI_RELEASE);
}
for (index--; index >= 0; index--) {
CDBG("%s index %d\n", __func__, index);
power_setting = &power_setting_array->power_setting[index];
CDBG("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
msm_cam_clk_enable(s_ctrl->dev,
&s_ctrl->clk_info[0],
(struct clk **)&power_setting->data[0],
s_ctrl->clk_info_size,
0);
break;
case SENSOR_GPIO:
if (data->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val])
gpio_set_value_cansleep(
data->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val],
GPIOF_OUT_INIT_LOW);
break;
case SENSOR_VREG:
msm_camera_config_single_vreg(s_ctrl->dev,
&data->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
0);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
power_setting->seq_type);
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
msm_camera_request_gpio_table(
data->gpio_conf->cam_gpio_req_tbl,
data->gpio_conf->cam_gpio_req_tbl_size, 0);
return rc;
}
int32_t msm_sensor_probe(struct msm_sensor_ctrl_t *s_ctrl,
const struct msm_camera_sensor_info *info,
struct msm_sensor_ctrl *s)
{
int rc = 0;
pr_info("%s\n", __func__);
rc = i2c_add_driver(s_ctrl->sensor_i2c_driver);
if (rc < 0 || s_ctrl->sensor_i2c_client->client == NULL) {
rc = -ENOTSUPP;
#if 1 /* HTC_START */
pr_err("%s: _probe_failure I2C add driver failed\n", __func__);
i2c_del_driver(s_ctrl->sensor_i2c_driver);
return rc;
#else
CDBG("I2C add driver failed");
goto probe_fail;
#endif /* HTC_END */
}
rc = s_ctrl->func_tbl->sensor_power_up(info);
if (rc < 0)
goto probe_fail;
rc = msm_sensor_match_id(s_ctrl);
if (rc < 0)
goto probe_fail;
if (s_ctrl->sensor_eeprom_client != NULL) {
struct msm_camera_eeprom_client *eeprom_client =
s_ctrl->sensor_eeprom_client;
if (eeprom_client->func_tbl.eeprom_init != NULL &&
eeprom_client->func_tbl.eeprom_release != NULL) {
rc = eeprom_client->func_tbl.eeprom_init(
eeprom_client,
s_ctrl->sensor_i2c_client->client->adapter);
if (rc < 0)
goto probe_fail;
rc = msm_camera_eeprom_read_tbl(eeprom_client,
eeprom_client->read_tbl, eeprom_client->read_tbl_size);
eeprom_client->func_tbl.eeprom_release(eeprom_client);
if (rc < 0)
goto probe_fail;
}
}
s->s_init = s_ctrl->func_tbl->sensor_open_init;
s->s_release = s_ctrl->func_tbl->sensor_release;
s->s_config = s_ctrl->func_tbl->sensor_config;
s->s_camera_type = info->camera_type;
if (info->sensor_platform_info != NULL)
s->s_mount_angle = info->sensor_platform_info->mount_angle;
else
s->s_mount_angle = 0;
pr_info("%s: probe_done\n", __func__);
goto power_down;
probe_fail:
pr_err("%s: _probe_failure\n", __func__);
i2c_del_driver(s_ctrl->sensor_i2c_driver);
power_down:
s_ctrl->func_tbl->sensor_power_down(info);
return rc;
}
int32_t mt9d113_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
#if 0
uint16_t chipid = 999;
#endif
struct msm_sensor_ctrl_t *s_ctrl;
pr_err("%s i2c_probe called\n", __func__); //build
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;
}
#if 1
mt9d113_client = client;
#else
mt9d113_work = kzalloc(sizeof(s5k6aafx13_work_t), GFP_KERNEL);
if (!mt9d113_work) {
pr_err("%s (-ENOMEM)\n", __func__);
return -ENOMEM;
}
i2c_set_clientdata(client, s5k6aafx13_work);
mt9d113_client = client;
#endif
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
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 0//check
pr_err("msm_sensor id: %d\n", chipid);
// msleep(3000);
// pr_err("msleep(3000);\n");
rc = msm_camera_i2c_read(
s_ctrl->sensor_i2c_client,
s_ctrl->sensor_id_info->sensor_id_reg_addr, &chipid,
MSM_CAMERA_I2C_WORD_DATA);
pr_err("msm_sensor id: %d\n", chipid);
if (rc < 0) {
pr_err("%s: %s: read id failed\n", __func__,
s_ctrl->sensordata->sensor_name);
//return rc;
goto probe_fail;
}
#else
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;
#endif
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);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto i2c_probe_end;
probe_fail:
pr_err("%s %s_i2c_probe failed\n", __func__, client->name);
i2c_probe_end:
#if 1
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
#endif
CDBG("%s_i2c_probe end\n", client->name);
return rc;
}