/*
* QCOM specific functions
*/
static int stmvl53l0_get_dt_data(struct device *dev, struct cci_data *data)
{
int rc = 0;
vl53l0_dbgmsg("Enter\n");
if (dev->of_node) {
struct device_node *of_node = dev->of_node;
struct msm_tof_vreg *vreg_cfg;
if (!of_node) {
vl53l0_errmsg("failed %d\n", __LINE__);
return -EINVAL;
}
rc = of_property_read_u32(of_node,
"cell-index", &data->pdev->id);
if (rc < 0) {
vl53l0_errmsg("failed %d\n", __LINE__);
return rc;
}
vl53l0_dbgmsg("cell-index: %d\n", data->pdev->id);
rc = of_property_read_u32(of_node, "qcom,cci-master",
&data->cci_master);
if (rc < 0) {
vl53l0_errmsg("failed %d\n", __LINE__);
/* Set default master 0 */
data->cci_master = MASTER_0;
rc = 0;
}
vl53l0_dbgmsg("cci_master: %d\n", data->cci_master);
if (of_find_property(of_node, "qcom,cam-vreg-name", NULL)) {
vreg_cfg = &data->vreg_cfg;
rc = msm_camera_get_dt_vreg_data(of_node,
&vreg_cfg->cam_vreg, &vreg_cfg->num_vreg);
if (rc < 0) {
vl53l0_errmsg("failed %d\n", __LINE__);
return rc;
}
}
vl53l0_dbgmsg("vreg-name: %s min_volt: %d max_volt: %d",
vreg_cfg->cam_vreg->reg_name,
vreg_cfg->cam_vreg->min_voltage,
vreg_cfg->cam_vreg->max_voltage);
}
vl53l0_dbgmsg("End rc =%d\n", rc);
return rc;
}
/*
* QCOM specific functions
*/
static int stmvl6180_get_dt_data(struct device *dev, struct cci_data *data)
{
int rc = 0;
vl6180_dbgmsg("Enter\n");
if (dev->of_node) {
struct device_node *of_node = dev->of_node;
struct msm_tof_vreg *vreg_cfg;
if (!of_node) {
vl6180_errmsg("failed %d\n", __LINE__);
return -EINVAL;
}
rc = of_property_read_u32(of_node, "cell-index", &data->pdev->id);
if (rc < 0) {
vl6180_errmsg("failed %d\n", __LINE__);
return rc;
}
vl6180_dbgmsg("cell-index: %d\n", data->pdev->id);
rc = of_property_read_u32(of_node, "qcom,cci-master", &data->cci_master);
if (rc < 0) {
vl6180_errmsg("failed %d\n", __LINE__);
/* Set default master 0 */
data->cci_master = MASTER_0;
rc = 0;
}
vl6180_dbgmsg("cci_master: %d\n", data->cci_master);
rc = of_property_read_u32(of_node, "qcom,slave-addr",&data->slave_addr);
if (rc < 0) {
vl6180_errmsg("failed %d\n", __LINE__);
data->slave_addr = 0x29;
rc = 0;
}
vl6180_dbgmsg("slave addr: %d\n", data->slave_addr);
if (of_find_property(of_node, "qcom,cam-vreg-name", NULL)) {
vreg_cfg = &data->vreg_cfg;
rc = msm_camera_get_dt_vreg_data(of_node,
&vreg_cfg->cam_vreg, &vreg_cfg->num_vreg);
if (rc < 0) {
vl6180_errmsg("failed %d\n", __LINE__);
return rc;
}
}
vl6180_dbgmsg("vreg-name: %s min_volt: %d max_volt: %d",
vreg_cfg->cam_vreg->reg_name,
vreg_cfg->cam_vreg->min_voltage,
vreg_cfg->cam_vreg->max_voltage);
data->en_gpio = of_get_named_gpio(of_node,
"stmvl6180,ldaf-en-gpio",0);
if (data->en_gpio < 0 || !gpio_is_valid(data->en_gpio)) {
vl6180_errmsg("en_gpio is unavailable or invalid\n");
return data->en_gpio;
}
data->int_gpio = of_get_named_gpio(of_node,
"stmvl6180,ldaf-int-gpio",0);
if (data->int_gpio < 0 || !gpio_is_valid(data->int_gpio)) {
vl6180_errmsg("en_gpio is unvailable or invalid\n");
return data->int_gpio;
}
vl6180_dbgmsg("ldaf_int: %u,ldaf_en: %u\n",
data->int_gpio,data->en_gpio);
rc = of_property_read_u32(of_node, "qcom,i2c-freq-mode",
&data->i2c_freq_mode);
if (rc < 0 || data->i2c_freq_mode >= I2C_MAX_MODES) {
data->i2c_freq_mode = 0;
vl6180_errmsg("invalid i2c frequency mode\n");
}
vl6180_dbgmsg("i2c_freq_mode: %u\n",data->i2c_freq_mode);
}
vl6180_dbgmsg("End rc =%d\n", rc);
return rc;
}
static int32_t msm_sensor_get_dt_data(struct device_node *of_node,
struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0, i = 0, ret = 0;
struct msm_camera_gpio_conf *gconf = NULL;
struct msm_camera_sensor_board_info *sensordata = NULL;
uint16_t *gpio_array = NULL;
uint16_t gpio_array_size = 0;
uint32_t id_info[3];
s_ctrl->sensordata = kzalloc(sizeof(
struct msm_camera_sensor_board_info),
GFP_KERNEL);
if (!s_ctrl->sensordata) {
pr_err("%s failed %d\n", __func__, __LINE__);
return -ENOMEM;
}
sensordata = s_ctrl->sensordata;
rc = of_property_read_string(of_node, "qcom,sensor-name",
&sensordata->sensor_name);
CDBG("%s qcom,sensor-name %s, rc %d\n", __func__,
sensordata->sensor_name, rc);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_SENSORDATA;
}
rc = of_property_read_u32(of_node, "qcom,cci-master",
&s_ctrl->cci_i2c_master);
CDBG("%s qcom,cci-master %d, rc %d\n", __func__, s_ctrl->cci_i2c_master,
rc);
if (rc < 0) {
/* Set default master 0 */
s_ctrl->cci_i2c_master = MASTER_0;
rc = 0;
}
rc = msm_sensor_get_sub_module_index(of_node, &sensordata->sensor_info);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_SENSORDATA;
}
/* Get sensor mount angle */
rc = of_property_read_u32(of_node, "qcom,mount-angle",
&sensordata->sensor_info->sensor_mount_angle);
CDBG("%s qcom,mount-angle %d, rc %d\n", __func__,
sensordata->sensor_info->sensor_mount_angle, rc);
if (rc < 0) {
/* Invalidate mount angle flag */
pr_err("%s Default sensor mount angle %d\n",
__func__, __LINE__);
sensordata->sensor_info->is_mount_angle_valid = 0;
sensordata->sensor_info->sensor_mount_angle = 0;
rc = 0;
} else {
sensordata->sensor_info->is_mount_angle_valid = 1;
}
rc = of_property_read_u32(of_node, "qcom,sensor-position",
&sensordata->sensor_info->position);
CDBG("%s qcom,sensor-position %d, rc %d\n", __func__,
sensordata->sensor_info->position, rc);
if (rc < 0) {
pr_err("%s Default sensor position %d\n", __func__, __LINE__);
sensordata->sensor_info->position = 0;
rc = 0;
}
rc = of_property_read_u32(of_node, "qcom,sensor-mode",
&sensordata->sensor_info->modes_supported);
CDBG("%s qcom,sensor-mode %d, rc %d\n", __func__,
sensordata->sensor_info->modes_supported, rc);
if (rc < 0) {
pr_err("%s Default sensor mode %d\n", __func__, __LINE__);
sensordata->sensor_info->modes_supported = 0;
rc = 0;
}
rc = msm_sensor_get_dt_csi_data(of_node, &sensordata->csi_lane_params);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_SENSOR_INFO;
}
rc = msm_camera_get_dt_vreg_data(of_node,
&sensordata->power_info.cam_vreg,
&sensordata->power_info.num_vreg);
if (rc < 0)
goto FREE_CSI;
rc = msm_camera_get_dt_power_setting_data(of_node,
sensordata->power_info.cam_vreg,
sensordata->power_info.num_vreg,
&sensordata->power_info);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_VREG;
}
rc = msm_camera_get_power_settimgs_from_sensor_lib(
&sensordata->power_info,
&s_ctrl->power_setting_array);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_VREG;
}
sensordata->power_info.gpio_conf = kzalloc(
sizeof(struct msm_camera_gpio_conf), GFP_KERNEL);
if (!sensordata->power_info.gpio_conf) {
pr_err("%s failed %d\n", __func__, __LINE__);
rc = -ENOMEM;
goto FREE_PS;
}
gconf = sensordata->power_info.gpio_conf;
gpio_array_size = of_gpio_count(of_node);
CDBG("%s gpio count %d\n", __func__, gpio_array_size);
if (gpio_array_size) {
gpio_array = kzalloc(sizeof(uint16_t) * gpio_array_size,
GFP_KERNEL);
if (!gpio_array) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_GPIO_CONF;
}
for (i = 0; i < gpio_array_size; i++) {
gpio_array[i] = of_get_gpio(of_node, i);
CDBG("%s gpio_array[%d] = %d\n", __func__, i,
gpio_array[i]);
}
rc = msm_camera_get_dt_gpio_req_tbl(of_node, gconf,
gpio_array, gpio_array_size);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_GPIO_CONF;
}
rc = msm_camera_get_dt_gpio_set_tbl(of_node, gconf,
gpio_array, gpio_array_size);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_GPIO_REQ_TBL;
}
rc = msm_camera_init_gpio_pin_tbl(of_node, gconf,
gpio_array, gpio_array_size);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_GPIO_SET_TBL;
}
}
rc = msm_sensor_get_dt_actuator_data(of_node,
&sensordata->actuator_info);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_GPIO_PIN_TBL;
}
sensordata->slave_info = kzalloc(sizeof(struct msm_camera_slave_info),
GFP_KERNEL);
if (!sensordata->slave_info) {
pr_err("%s failed %d\n", __func__, __LINE__);
rc = -ENOMEM;
goto FREE_ACTUATOR_INFO;
}
rc = of_property_read_u32_array(of_node, "qcom,slave-id",
id_info, 3);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto FREE_SLAVE_INFO;
}
sensordata->slave_info->sensor_slave_addr = id_info[0];
sensordata->slave_info->sensor_id_reg_addr = id_info[1];
sensordata->slave_info->sensor_id = id_info[2];
CDBG("%s:%d slave addr %x sensor reg %x id %x\n", __func__, __LINE__,
sensordata->slave_info->sensor_slave_addr,
sensordata->slave_info->sensor_id_reg_addr,
sensordata->slave_info->sensor_id);
/*Optional property, don't return error if absent */
ret = of_property_read_string(of_node, "qcom,vdd-cx-name",
&sensordata->misc_regulator);
CDBG("%s qcom,misc_regulator %s, rc %d\n", __func__,
sensordata->misc_regulator, ret);
kfree(gpio_array);
return rc;
FREE_SLAVE_INFO:
kfree(s_ctrl->sensordata->slave_info);
FREE_ACTUATOR_INFO:
kfree(s_ctrl->sensordata->actuator_info);
FREE_GPIO_PIN_TBL:
kfree(s_ctrl->sensordata->power_info.gpio_conf->gpio_num_info);
FREE_GPIO_SET_TBL:
kfree(s_ctrl->sensordata->power_info.gpio_conf->cam_gpio_set_tbl);
FREE_GPIO_REQ_TBL:
kfree(s_ctrl->sensordata->power_info.gpio_conf->cam_gpio_req_tbl);
FREE_GPIO_CONF:
kfree(s_ctrl->sensordata->power_info.gpio_conf);
FREE_PS:
kfree(s_ctrl->sensordata->power_info.power_setting);
kfree(s_ctrl->sensordata->power_info.power_down_setting);
FREE_VREG:
kfree(s_ctrl->sensordata->power_info.cam_vreg);
FREE_CSI:
kfree(s_ctrl->sensordata->csi_lane_params);
FREE_SENSOR_INFO:
kfree(s_ctrl->sensordata->sensor_info);
FREE_SENSORDATA:
kfree(s_ctrl->sensordata);
kfree(gpio_array);
return rc;
}
static int msm_eeprom_get_dt_data(struct msm_eeprom_ctrl_t *e_ctrl)
{
int rc = 0, i = 0;
struct msm_eeprom_board_info *eb_info;
struct msm_camera_power_ctrl_t *power_info =
&e_ctrl->eboard_info->power_info;
struct spi_device *spi = e_ctrl->i2c_client.spi_client->spi_master;
struct device_node *of_node = spi->dev.of_node;
struct msm_camera_gpio_conf *gconf = NULL;
uint16_t gpio_array_size = 0;
uint16_t *gpio_array = NULL;
eb_info = e_ctrl->eboard_info;
rc = msm_camera_get_dt_power_setting_data(spi->dev.of_node,
&power_info->power_setting, &power_info->power_setting_size);
if (rc)
return rc;
rc = msm_camera_get_dt_vreg_data(of_node, &power_info->cam_vreg,
&power_info->num_vreg);
if (rc)
goto ERROR1;
power_info->gpio_conf = kzalloc(sizeof(struct msm_camera_gpio_conf),
GFP_KERNEL);
if (!power_info->gpio_conf) {
rc = -ENOMEM;
goto ERROR2;
}
gconf = power_info->gpio_conf;
gpio_array_size = of_gpio_count(of_node);
CDBG("%s gpio count %d\n", __func__, gpio_array_size);
if (gpio_array_size) {
gpio_array = kzalloc(sizeof(uint16_t) * gpio_array_size,
GFP_KERNEL);
if (!gpio_array) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto ERROR3;
}
for (i = 0; i < gpio_array_size; i++) {
gpio_array[i] = of_get_gpio(of_node, i);
CDBG("%s gpio_array[%d] = %d\n", __func__, i,
gpio_array[i]);
}
rc = msm_camera_get_dt_gpio_req_tbl(of_node, gconf,
gpio_array, gpio_array_size);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto ERROR4;
}
rc = msm_camera_init_gpio_pin_tbl(of_node, gconf,
gpio_array, gpio_array_size);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto ERROR4;
}
kfree(gpio_array);
}
return rc;
ERROR4:
kfree(gpio_array);
ERROR3:
kfree(power_info->gpio_conf);
ERROR2:
kfree(power_info->cam_vreg);
ERROR1:
kfree(power_info->power_setting);
return rc;
}
static int msm_eeprom_get_dt_data(struct msm_eeprom_ctrl_t *e_ctrl)
{
int rc = 0, i = 0;
struct msm_eeprom_board_info *eb_info;
struct msm_camera_power_ctrl_t *power_info =
&e_ctrl->eboard_info->power_info;
struct device_node *of_node = NULL;
struct msm_camera_gpio_conf *gconf = NULL;
uint16_t gpio_array_size = 0;
uint16_t *gpio_array = NULL;
eb_info = e_ctrl->eboard_info;
if (e_ctrl->eeprom_device_type == MSM_CAMERA_SPI_DEVICE)
of_node = e_ctrl->i2c_client.
spi_client->spi_master->dev.of_node;
else if (e_ctrl->eeprom_device_type == MSM_CAMERA_PLATFORM_DEVICE)
of_node = e_ctrl->pdev->dev.of_node;
else if (e_ctrl->eeprom_device_type == MSM_CAMERA_I2C_DEVICE)
of_node = e_ctrl->i2c_client.client->dev.of_node;
rc = msm_camera_get_dt_vreg_data(of_node, &power_info->cam_vreg,
&power_info->num_vreg);
if (rc < 0)
return rc;
rc = msm_camera_get_dt_power_setting_data(of_node,
power_info->cam_vreg, power_info->num_vreg,
&power_info->power_setting, &power_info->power_setting_size);
if (rc < 0)
goto error1;
power_info->gpio_conf = kzalloc(sizeof(struct msm_camera_gpio_conf),
GFP_KERNEL);
if (!power_info->gpio_conf) {
rc = -ENOMEM;
goto error2;
}
gconf = power_info->gpio_conf;
gpio_array_size = of_gpio_count(of_node);
CDBG("%s gpio count %d\n", __func__, gpio_array_size);
if (gpio_array_size) {
gpio_array = kzalloc(sizeof(uint16_t) * gpio_array_size,
GFP_KERNEL);
if (!gpio_array) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto error3;
}
for (i = 0; i < gpio_array_size; i++) {
gpio_array[i] = of_get_gpio(of_node, i);
CDBG("%s gpio_array[%d] = %d\n", __func__, i,
gpio_array[i]);
}
rc = msm_camera_get_dt_gpio_req_tbl(of_node, gconf,
gpio_array, gpio_array_size);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto error4;
}
rc = msm_camera_init_gpio_pin_tbl(of_node, gconf,
gpio_array, gpio_array_size);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto error4;
}
kfree(gpio_array);
}
return rc;
error4:
kfree(gpio_array);
error3:
kfree(power_info->gpio_conf);
error2:
kfree(power_info->cam_vreg);
error1:
kfree(power_info->power_setting);
return rc;
}
static int32_t msm_sensor_driver_get_dt_data(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_board_info *sensordata = NULL;
struct device_node *of_node = s_ctrl->of_node;
uint32_t cell_id;
s_ctrl->sensordata = kzalloc(sizeof(*sensordata), GFP_KERNEL);
if (!s_ctrl->sensordata) {
pr_err("failed: no memory");
return -ENOMEM;
}
sensordata = s_ctrl->sensordata;
/*
* Read cell index - this cell index will be the camera slot where
* this camera will be mounted
*/
rc = of_property_read_u32(of_node, "cell-index", &cell_id);
if (rc < 0) {
pr_err("failed: cell-index rc %d", rc);
goto FREE_SENSOR_DATA;
}
s_ctrl->id = cell_id;
/* Validate cell_id */
if (cell_id >= MAX_CAMERAS) {
pr_err("failed: invalid cell_id %d", cell_id);
rc = -EINVAL;
goto FREE_SENSOR_DATA;
}
/* Check whether g_sctrl is already filled for this cell_id */
if (g_sctrl[cell_id]) {
pr_err("failed: sctrl already filled for cell_id %d", cell_id);
rc = -EINVAL;
goto FREE_SENSOR_DATA;
}
/* Read subdev info */
rc = msm_sensor_get_sub_module_index(of_node, &sensordata->sensor_info);
if (rc < 0) {
pr_err("failed");
goto FREE_SENSOR_DATA;
}
/* Read vreg information */
rc = msm_camera_get_dt_vreg_data(of_node,
&sensordata->power_info.cam_vreg,
&sensordata->power_info.num_vreg);
if (rc < 0) {
pr_err("failed: msm_camera_get_dt_vreg_data rc %d", rc);
goto FREE_SUB_MODULE_DATA;
}
/* Read gpio information */
rc = msm_sensor_driver_get_gpio_data(sensordata, of_node);
if (rc < 0) {
pr_err("failed: msm_sensor_driver_get_gpio_data rc %d", rc);
goto FREE_VREG_DATA;
}
/* Get CCI master */
rc = of_property_read_u32(of_node, "qcom,cci-master",
&s_ctrl->cci_i2c_master);
CDBG("qcom,cci-master %d, rc %d", s_ctrl->cci_i2c_master, rc);
if (rc < 0) {
/* Set default master 0 */
s_ctrl->cci_i2c_master = MASTER_0;
rc = 0;
}
/* Get mount angle */
if (0 > of_property_read_u32(of_node, "qcom,mount-angle",
&sensordata->sensor_info->sensor_mount_angle)) {
/* Invalidate mount angle flag */
sensordata->sensor_info->is_mount_angle_valid = 0;
sensordata->sensor_info->sensor_mount_angle = 0;
} else {
sensordata->sensor_info->is_mount_angle_valid = 1;
}
CDBG("%s qcom,mount-angle %d\n", __func__,
sensordata->sensor_info->sensor_mount_angle);
if (0 > of_property_read_u32(of_node, "qcom,sensor-position",
&sensordata->sensor_info->position)) {
CDBG("%s:%d Invalid sensor position\n", __func__, __LINE__);
sensordata->sensor_info->position = INVALID_CAMERA_B;
}
if (0 > of_property_read_u32(of_node, "qcom,sensor-mode",
&sensordata->sensor_info->modes_supported)) {
CDBG("%s:%d Invalid sensor mode supported\n",
__func__, __LINE__);
sensordata->sensor_info->modes_supported = CAMERA_MODE_INVALID;
}
/* Get vdd-cx regulator */
/*Optional property, don't return error if absent */
of_property_read_string(of_node, "qcom,vdd-cx-name",
&sensordata->misc_regulator);
CDBG("qcom,misc_regulator %s", sensordata->misc_regulator);
s_ctrl->set_mclk_23880000 = of_property_read_bool(of_node,
"qcom,mclk-23880000");
CDBG("%s qcom,mclk-23880000 = %d\n", __func__,
s_ctrl->set_mclk_23880000);
return rc;
FREE_VREG_DATA:
kfree(sensordata->power_info.cam_vreg);
FREE_SUB_MODULE_DATA:
kfree(sensordata->sensor_info);
FREE_SENSOR_DATA:
kfree(sensordata);
return rc;
}
static int32_t msm_sensor_driver_get_dt_data(struct msm_sensor_ctrl_t *s_ctrl,
struct platform_device *pdev)
{
int32_t rc = 0;
struct msm_camera_sensor_board_info *sensordata = NULL;
struct device_node *of_node = pdev->dev.of_node;
s_ctrl->sensordata = kzalloc(sizeof(*sensordata), GFP_KERNEL);
if (!s_ctrl->sensordata) {
pr_err("failed: no memory");
return -ENOMEM;
}
sensordata = s_ctrl->sensordata;
/*
* Read cell index - this cell index will be the camera slot where
* this camera will be mounted
*/
rc = of_property_read_u32(of_node, "cell-index", &pdev->id);
if (rc < 0) {
pr_err("failed: cell-index rc %d", rc);
goto FREE_SENSOR_DATA;
}
/* Validate pdev->id */
if (pdev->id >= MAX_CAMERAS) {
pr_err("failed: invalid pdev->id %d", pdev->id);
rc = -EINVAL;
goto FREE_SENSOR_DATA;
}
/* Check whether g_sctrl is already filled for this pdev id */
if (g_sctrl[pdev->id]) {
pr_err("failed: sctrl already filled for id %d", pdev->id);
rc = -EINVAL;
goto FREE_SENSOR_DATA;
}
/* Read subdev info */
rc = msm_sensor_get_sub_module_index(of_node, &sensordata->sensor_info);
if (rc < 0) {
pr_err("failed");
goto FREE_SENSOR_DATA;
}
/* Read vreg information */
rc = msm_camera_get_dt_vreg_data(of_node,
&sensordata->power_info.cam_vreg,
&sensordata->power_info.num_vreg);
if (rc < 0) {
pr_err("failed: msm_camera_get_dt_vreg_data rc %d", rc);
goto FREE_SUB_MODULE_DATA;
}
/* Read gpio information */
rc = msm_sensor_driver_get_gpio_data(sensordata, of_node);
if (rc < 0) {
pr_err("failed: msm_sensor_driver_get_gpio_data rc %d", rc);
goto FREE_VREG_DATA;
}
/* Get CCI master */
rc = of_property_read_u32(of_node, "qcom,cci-master",
&s_ctrl->cci_i2c_master);
CDBG("qcom,cci-master %d, rc %d", s_ctrl->cci_i2c_master, rc);
if (rc < 0) {
/* Set default master 0 */
s_ctrl->cci_i2c_master = MASTER_0;
rc = 0;
}
/* Get mount angle */
rc = of_property_read_u32(of_node, "qcom,mount-angle",
&sensordata->sensor_info->sensor_mount_angle);
CDBG("%s qcom,mount-angle %d, rc %d\n", __func__,
sensordata->sensor_info->sensor_mount_angle, rc);
if (rc < 0) {
sensordata->sensor_info->is_mount_angle_valid = 0;
sensordata->sensor_info->sensor_mount_angle = 0;
rc = 0;
} else {
sensordata->sensor_info->is_mount_angle_valid = 1;
}
/* Get vdd-cx regulator */
/*Optional property, don't return error if absent */
of_property_read_string(of_node, "qcom,vdd-cx-name",
&sensordata->misc_regulator);
CDBG("qcom,misc_regulator %s", sensordata->misc_regulator);
return rc;
FREE_VREG_DATA:
kfree(sensordata->power_info.cam_vreg);
FREE_SUB_MODULE_DATA:
kfree(sensordata->sensor_info);
FREE_SENSOR_DATA:
kfree(sensordata);
return rc;
}
static int32_t msm_ois_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
struct msm_camera_cci_client *cci_client = NULL;
struct msm_ois_ctrl_t *msm_ois_t = NULL;
struct msm_ois_vreg *vreg_cfg;
CDBG_I("Enter\n");
if (!pdev->dev.of_node) {
pr_err("of_node NULL\n");
return -EINVAL;
}
msm_ois_t = kzalloc(sizeof(struct msm_ois_ctrl_t),
GFP_KERNEL);
if (!msm_ois_t) {
pr_err("%s:%d failed no memory\n", __func__, __LINE__);
return -ENOMEM;
}
rc = of_property_read_u32((&pdev->dev)->of_node, "cell-index",
&pdev->id);
CDBG("cell-index %d, rc %d\n", pdev->id, rc);
if (rc < 0) {
kfree(msm_ois_t);
pr_err("failed rc %d\n", rc);
return rc;
}
msm_ois_t->subdev_id = pdev->id;
rc = of_property_read_u32((&pdev->dev)->of_node, "qcom,cci-master",
&msm_ois_t->cci_master);
CDBG("qcom,cci-master %d, rc %d\n", msm_ois_t->cci_master, rc);
if (rc < 0) {
kfree(msm_ois_t);
pr_err("failed rc %d\n", rc);
return rc;
}
if (of_find_property((&pdev->dev)->of_node,
"qcom,cam-vreg-name", NULL)) {
vreg_cfg = &msm_ois_t->vreg_cfg;
rc = msm_camera_get_dt_vreg_data((&pdev->dev)->of_node,
&vreg_cfg->cam_vreg, &vreg_cfg->num_vreg);
if (rc < 0) {
kfree(msm_ois_t);
pr_err("failed rc %d\n", rc);
return rc;
}
}
msm_ois_t->ois_v4l2_subdev_ops = &msm_ois_subdev_ops;
msm_ois_t->ois_mutex = &msm_ois_mutex;
msm_ois_t->cam_name = pdev->id;
/* Set platform device handle */
msm_ois_t->pdev = pdev;
/* Set device type as platform device */
msm_ois_t->ois_device_type = MSM_CAMERA_PLATFORM_DEVICE;
msm_ois_t->i2c_client.i2c_func_tbl = &msm_sensor_cci_func_tbl;
msm_ois_t->i2c_client.addr_type = MSM_CAMERA_I2C_WORD_ADDR;
msm_ois_t->i2c_client.cci_client = kzalloc(sizeof(
struct msm_camera_cci_client), GFP_KERNEL);
if (!msm_ois_t->i2c_client.cci_client) {
kfree(msm_ois_t->vreg_cfg.cam_vreg);
kfree(msm_ois_t);
pr_err("failed no memory\n");
return -ENOMEM;
}
cci_client = msm_ois_t->i2c_client.cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
cci_client->cci_i2c_master = MASTER_MAX;
v4l2_subdev_init(&msm_ois_t->msm_sd.sd,
msm_ois_t->ois_v4l2_subdev_ops);
v4l2_set_subdevdata(&msm_ois_t->msm_sd.sd, msm_ois_t);
msm_ois_t->msm_sd.sd.internal_ops = &msm_ois_internal_ops;
msm_ois_t->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(msm_ois_t->msm_sd.sd.name,
ARRAY_SIZE(msm_ois_t->msm_sd.sd.name), "msm_ois");
media_entity_init(&msm_ois_t->msm_sd.sd.entity, 0, NULL, 0);
msm_ois_t->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
msm_ois_t->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_OIS;
msm_ois_t->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0xB;
rc = msm_sd_register(&msm_ois_t->msm_sd);
//g_ois_i2c_client.cci_client = msm_ois_t->i2c_client.cci_client;
CDBG("Exit[rc::%d]\n", rc);
return rc;
}
static int32_t msm_ois_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_ois_ctrl_t *ois_ctrl_t = NULL;
struct msm_ois_vreg *vreg_cfg;
bool check_use_gpios;
CDBG_I("Enter\n");
if (client == NULL) {
pr_err("msm_ois_i2c_probe: client is null\n");
rc = -EINVAL;
goto probe_failure;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality failed\n");
goto probe_failure;
}
if (!client->dev.of_node) {
ois_ctrl_t = (struct msm_ois_ctrl_t *)(id->driver_data);
} else {
ois_ctrl_t = kzalloc(sizeof(struct msm_ois_ctrl_t),
GFP_KERNEL);
if (!ois_ctrl_t) {
pr_err("%s:%d no memory\n", __func__, __LINE__);
return -ENOMEM;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality failed\n");
goto probe_failure;
}
CDBG("client = 0x%p\n", client);
rc = of_property_read_u32(client->dev.of_node, "cell-index",
&ois_ctrl_t->subdev_id);
CDBG("cell-index %d, rc %d\n", ois_ctrl_t->subdev_id, rc);
ois_ctrl_t->cam_name = ois_ctrl_t->subdev_id;
if (rc < 0) {
pr_err("failed rc %d\n", rc);
kfree(ois_ctrl_t);//prevent
return rc;
}
check_use_gpios = of_property_read_bool(client->dev.of_node, "unuse-gpios");
CDBG("%s: check unuse-gpio flag(%d)\n",
__FUNCTION__, check_use_gpios);
if (!check_use_gpios) {
rc = msm_ois_get_gpio_data(ois_ctrl_t,
client->dev.of_node);
}
}
if (of_find_property(client->dev.of_node,
"qcom,cam-vreg-name", NULL)) {
vreg_cfg = &ois_ctrl_t->vreg_cfg;
rc = msm_camera_get_dt_vreg_data(client->dev.of_node,
&vreg_cfg->cam_vreg, &vreg_cfg->num_vreg);
if (rc < 0) {
kfree(ois_ctrl_t);
pr_err("failed rc %d\n", rc);
return rc;
}
}
ois_ctrl_t->ois_v4l2_subdev_ops = &msm_ois_subdev_ops;
ois_ctrl_t->ois_mutex = &msm_ois_mutex;
ois_ctrl_t->i2c_driver = &msm_ois_i2c_driver;
CDBG("client = %x\n", (unsigned int) client);
ois_ctrl_t->i2c_client.client = client;
ois_ctrl_t->i2c_client.addr_type = MSM_CAMERA_I2C_WORD_ADDR;
/* Set device type as I2C */
ois_ctrl_t->ois_device_type = MSM_CAMERA_I2C_DEVICE;
ois_ctrl_t->i2c_client.i2c_func_tbl = &msm_sensor_qup_func_tbl;
ois_ctrl_t->ois_v4l2_subdev_ops = &msm_ois_subdev_ops;
ois_ctrl_t->ois_mutex = &msm_ois_mutex;
ois_ctrl_t->cam_name = ois_ctrl_t->subdev_id;
CDBG("ois_ctrl_t->cam_name: %d", ois_ctrl_t->cam_name);
/* Assign name for sub device */
snprintf(ois_ctrl_t->msm_sd.sd.name, sizeof(ois_ctrl_t->msm_sd.sd.name),
"%s", ois_ctrl_t->i2c_driver->driver.name);
/* Initialize sub device */
v4l2_i2c_subdev_init(&ois_ctrl_t->msm_sd.sd,
ois_ctrl_t->i2c_client.client,
ois_ctrl_t->ois_v4l2_subdev_ops);
v4l2_set_subdevdata(&ois_ctrl_t->msm_sd.sd, ois_ctrl_t);
ois_ctrl_t->msm_sd.sd.internal_ops = &msm_ois_internal_ops;
ois_ctrl_t->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&ois_ctrl_t->msm_sd.sd.entity, 0, NULL, 0);
ois_ctrl_t->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
ois_ctrl_t->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_OIS;
ois_ctrl_t->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0xB;
msm_sd_register(&ois_ctrl_t->msm_sd);
//g_ois_i2c_client.client = ois_ctrl_t->i2c_client.client;
CDBG("Succeded Exit\n");
return rc;
probe_failure:
if (ois_ctrl_t)
kfree(ois_ctrl_t);
return rc;
}
