static int32_t msm_flash_get_gpio_dt_data(struct device_node *of_node,
struct msm_flash_ctrl_t *fctrl)
{
int32_t rc = 0, i = 0;
uint16_t *gpio_array = NULL;
int16_t gpio_array_size = 0;
struct msm_camera_gpio_conf *gconf = NULL;
gpio_array_size = of_gpio_count(of_node);
CDBG("%s gpio count %d\n", __func__, gpio_array_size);
if (gpio_array_size > 0) {
fctrl->power_info.gpio_conf =
kzalloc(sizeof(struct msm_camera_gpio_conf),
GFP_KERNEL);
if (!fctrl->power_info.gpio_conf) {
pr_err("%s failed %d\n", __func__, __LINE__);
rc = -ENOMEM;
return rc;
}
gconf = fctrl->power_info.gpio_conf;
gpio_array = kzalloc(sizeof(uint16_t) * gpio_array_size,
GFP_KERNEL);
if (!gpio_array) {
pr_err("%s failed %d\n", __func__, __LINE__);
rc = -ENOMEM;
goto free_gpio_conf;
}
for (i = 0; i < gpio_array_size; i++) {
gpio_array[i] = of_get_gpio(of_node, i);
if (((int16_t)gpio_array[i]) < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
return -EINVAL;
}
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_array;
}
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_cam_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_cam_gpio_set_tbl;
}
if (fctrl->flash_driver_type == FLASH_DRIVER_DEFAULT)
fctrl->flash_driver_type = FLASH_DRIVER_GPIO;
CDBG("%s:%d fctrl->flash_driver_type = %d", __func__, __LINE__,
fctrl->flash_driver_type);
}
return 0;
free_cam_gpio_set_tbl:
kfree(gconf->cam_gpio_set_tbl);
free_cam_gpio_req_tbl:
kfree(gconf->cam_gpio_req_tbl);
free_gpio_array:
kfree(gpio_array);
free_gpio_conf:
kfree(fctrl->power_info.gpio_conf);
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 int32_t msm_led_get_dt_data(struct device_node *of_node,
struct msm_led_flash_ctrl_t *fctrl)
{
int32_t rc = 0, i = 0;
struct msm_camera_gpio_conf *gconf = NULL;
struct device_node *flash_src_node = NULL;
struct msm_camera_sensor_board_info *flashdata = NULL;
struct msm_camera_power_ctrl_t *power_info = NULL;
uint32_t count = 0;
uint16_t *gpio_array = NULL;
uint16_t gpio_array_size = 0;
uint32_t id_info[3];
CDBG("called\n");
if (!of_node) {
pr_err("of_node NULL\n");
return -EINVAL;
}
fctrl->flashdata = kzalloc(sizeof(
struct msm_camera_sensor_board_info),
GFP_KERNEL);
if (!fctrl->flashdata) {
pr_err("%s failed %d\n", __func__, __LINE__);
return -ENOMEM;
}
flashdata = fctrl->flashdata;
power_info = &flashdata->power_info;
rc = of_property_read_u32(of_node, "cell-index", &fctrl->subdev_id);
if (rc < 0) {
pr_err("failed\n");
return -EINVAL;
}
CDBG("subdev id %d\n", fctrl->subdev_id);
rc = of_property_read_string(of_node, "label",
&flashdata->sensor_name);
CDBG("%s label %s, rc %d\n", __func__,
flashdata->sensor_name, rc);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto ERROR1;
}
rc = of_property_read_u32(of_node, "qcom,cci-master",
&fctrl->cci_i2c_master);
CDBG("%s qcom,cci-master %d, rc %d\n", __func__, fctrl->cci_i2c_master,
rc);
if (rc < 0) {
/* Set default master 0 */
fctrl->cci_i2c_master = MASTER_0;
rc = 0;
}
if (of_get_property(of_node, "qcom,flash-source", &count)) {
count /= sizeof(uint32_t);
CDBG("count %d\n", count);
if (count > MAX_LED_TRIGGERS) {
pr_err("failed\n");
return -EINVAL;
}
for (i = 0; i < count; i++) {
flash_src_node = of_parse_phandle(of_node,
"qcom,flash-source", i);
if (!flash_src_node) {
pr_err("flash_src_node NULL\n");
continue;
}
rc = of_property_read_string(flash_src_node,
"linux,default-trigger",
&fctrl->flash_trigger_name[i]);
if (rc < 0) {
pr_err("failed\n");
of_node_put(flash_src_node);
continue;
}
CDBG("default trigger %s\n",
fctrl->flash_trigger_name[i]);
rc = of_property_read_u32(flash_src_node,
"qcom,max-current",
&fctrl->flash_op_current[i]);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
of_node_put(flash_src_node);
continue;
}
of_node_put(flash_src_node);
CDBG("max_current[%d] %d\n",
i, fctrl->flash_op_current[i]);
led_trigger_register_simple(
fctrl->flash_trigger_name[i],
&fctrl->flash_trigger[i]);
}
} else { /*Handle LED Flash Ctrl by GPIO*/
power_info->gpio_conf =
kzalloc(sizeof(struct msm_camera_gpio_conf),
GFP_KERNEL);
if (!power_info->gpio_conf) {
pr_err("%s failed %d\n", __func__, __LINE__);
rc = -ENOMEM;
return rc;
}
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__);
rc = -ENOMEM;
goto ERROR4;
}
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_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 ERROR5;
}
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 ERROR6;
}
}
/* Read the max current for an LED if present */
if (of_get_property(of_node, "qcom,max-current", &count)) {
count /= sizeof(uint32_t);
if (count > MAX_LED_TRIGGERS) {
pr_err("failed\n");
rc = -EINVAL;
goto ERROR8;
}
rc = of_property_read_u32_array(of_node,
"qcom,max-current",
fctrl->flash_max_current, count);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto ERROR8;
}
for (; count < MAX_LED_TRIGGERS; count++)
fctrl->flash_max_current[count] = 0;
}
/* Read the max duration for an LED if present */
if (of_get_property(of_node, "qcom,max-duration", &count)) {
count /= sizeof(uint32_t);
if (count > MAX_LED_TRIGGERS) {
pr_err("failed\n");
rc = -EINVAL;
goto ERROR8;
}
rc = of_property_read_u32_array(of_node,
"qcom,max-duration",
fctrl->flash_max_duration, count);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto ERROR8;
}
for (; count < MAX_LED_TRIGGERS; count++)
fctrl->flash_max_duration[count] = 0;
}
flashdata->slave_info =
kzalloc(sizeof(struct msm_camera_slave_info),
GFP_KERNEL);
if (!flashdata->slave_info) {
pr_err("%s failed %d\n", __func__, __LINE__);
rc = -ENOMEM;
goto ERROR8;
}
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 ERROR9;
}
fctrl->flashdata->slave_info->sensor_slave_addr = id_info[0];
fctrl->flashdata->slave_info->sensor_id_reg_addr = id_info[1];
fctrl->flashdata->slave_info->sensor_id = id_info[2];
kfree(gpio_array);
return rc;
ERROR9:
kfree(fctrl->flashdata->slave_info);
ERROR8:
kfree(fctrl->flashdata->power_info.gpio_conf->gpio_num_info);
ERROR6:
kfree(gconf->cam_gpio_set_tbl);
ERROR5:
kfree(gconf->cam_gpio_req_tbl);
ERROR4:
kfree(gconf);
ERROR1:
kfree(fctrl->flashdata);
kfree(gpio_array);
}
return rc;
}
