Merge "msm: camera: Add support to enable eLDOs through GPIOs" (8fa4e15a) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/media/platform/msm/camera_v2/sensor/actuator/msm_actuator.c

+81 −1

Original line number	Diff line number	Diff line
		@@ -1022,7 +1022,7 @@ static int32_t msm_actuator_vreg_control(struct msm_actuator_ctrl_t *a_ctrl,
		if (!cnt)
		return 0;

		if (cnt >= MSM_ACTUATOT_MAX_VREGS) {
		if (cnt >= MSM_ACTUATOR_MAX_VREGS) {
		pr_err("%s failed %d cnt %d\n", __func__, __LINE__, cnt);
		return -EINVAL;
		}
		@@ -1048,6 +1048,8 @@ static int32_t msm_actuator_vreg_control(struct msm_actuator_ctrl_t *a_ctrl,
		static int32_t msm_actuator_power_down(struct msm_actuator_ctrl_t *a_ctrl)
		{
		int32_t rc = 0;
		enum msm_sensor_power_seq_gpio_t gpio;

		CDBG("Enter\n");
		if (a_ctrl->actuator_state != ACT_DISABLE_STATE) {

		@@ -1064,6 +1066,41 @@ static int32_t msm_actuator_power_down(struct msm_actuator_ctrl_t *a_ctrl)
		return rc;
		}

		for (gpio = SENSOR_GPIO_AF_PWDM;
		gpio < SENSOR_GPIO_MAX; gpio++) {
		if (a_ctrl->gconf &&
		a_ctrl->gconf->gpio_num_info &&
		a_ctrl->gconf->gpio_num_info->
		valid[gpio] == 1) {

		gpio_set_value_cansleep(
		a_ctrl->gconf->gpio_num_info->
		gpio_num[gpio],
		GPIOF_OUT_INIT_LOW);

		if (a_ctrl->cam_pinctrl_status) {
		rc = pinctrl_select_state(
		a_ctrl->pinctrl_info.pinctrl,
		a_ctrl->pinctrl_info.
		gpio_state_suspend);
		if (rc < 0)
		pr_err("ERR:%s:%d cannot set pin to suspend state: %d",
		__func__, __LINE__, rc);

		devm_pinctrl_put(
		a_ctrl->pinctrl_info.pinctrl);
		}
		a_ctrl->cam_pinctrl_status = 0;
		rc = msm_camera_request_gpio_table(
		a_ctrl->gconf->cam_gpio_req_tbl,
		a_ctrl->gconf->cam_gpio_req_tbl_size,
		0);
		if (rc < 0)
		pr_err("ERR:%s:Failed in selecting state in actuator power down: %d\n",
		__func__, rc);
		}
		}

		kfree(a_ctrl->step_position_table);
		a_ctrl->step_position_table = NULL;
		kfree(a_ctrl->i2c_reg_tbl);
		@@ -1657,6 +1694,8 @@ static long msm_actuator_subdev_fops_ioctl(struct file *file, unsigned int cmd,
		static int32_t msm_actuator_power_up(struct msm_actuator_ctrl_t *a_ctrl)
		{
		int rc = 0;
		enum msm_sensor_power_seq_gpio_t gpio;

		CDBG("%s called\n", __func__);

		rc = msm_actuator_vreg_control(a_ctrl, 1);
		@@ -1665,6 +1704,33 @@ static int32_t msm_actuator_power_up(struct msm_actuator_ctrl_t *a_ctrl)
		return rc;
		}

		for (gpio = SENSOR_GPIO_AF_PWDM; gpio < SENSOR_GPIO_MAX; gpio++) {
		if (a_ctrl->gconf &&
		a_ctrl->gconf->gpio_num_info &&
		a_ctrl->gconf->gpio_num_info->valid[gpio] == 1) {
		rc = msm_camera_request_gpio_table(
		a_ctrl->gconf->cam_gpio_req_tbl,
		a_ctrl->gconf->cam_gpio_req_tbl_size, 1);
		if (rc < 0) {
		pr_err("ERR:%s:Failed in selecting state for actuator: %d\n",
		__func__, rc);
		return rc;
		}
		if (a_ctrl->cam_pinctrl_status) {
		rc = pinctrl_select_state(
		a_ctrl->pinctrl_info.pinctrl,
		a_ctrl->pinctrl_info.gpio_state_active);
		if (rc < 0)
		pr_err("ERR:%s:%d cannot set pin to active state: %d",
		__func__, __LINE__, rc);
		}

		gpio_set_value_cansleep(
		a_ctrl->gconf->gpio_num_info->gpio_num[gpio],
		1);
		}
		}

		/* VREG needs some delay to power up */
		usleep_range(2000, 3000);
		a_ctrl->actuator_state = ACT_ENABLE_STATE;
		@@ -1825,6 +1891,20 @@ static int32_t msm_actuator_platform_probe(struct platform_device *pdev)
		return rc;
		}
		}
		rc = msm_sensor_driver_get_gpio_data(&(msm_actuator_t->gconf),
		(&pdev->dev)->of_node);
		if (rc < 0) {
		pr_err("%s: No/Error Actuator GPIOs\n", __func__);
		} else {
		msm_actuator_t->cam_pinctrl_status = 1;
		rc = msm_camera_pinctrl_init(
		&(msm_actuator_t->pinctrl_info), &(pdev->dev));
		if (rc < 0) {
		pr_err("ERR:%s: Error in reading actuator pinctrl\n",
		__func__);
		msm_actuator_t->cam_pinctrl_status = 0;
		}
		}

		msm_actuator_t->act_v4l2_subdev_ops = &msm_actuator_subdev_ops;
		msm_actuator_t->actuator_mutex = &msm_actuator_mutex;

drivers/media/platform/msm/camera_v2/sensor/actuator/msm_actuator.h

+6 −3

Original line number	Diff line number	Diff line
		/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
		/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 and
		@@ -25,7 +25,7 @@
		#define DEFINE_MSM_MUTEX(mutexname) \
		static struct mutex mutexname = __MUTEX_INITIALIZER(mutexname)

		#define MSM_ACTUATOT_MAX_VREGS (10)
		#define MSM_ACTUATOR_MAX_VREGS (10)
		#define ACTUATOR_MAX_POLL_COUNT 10

		struct msm_actuator_ctrl_t;
		@@ -68,7 +68,7 @@ struct msm_actuator {

		struct msm_actuator_vreg {
		struct camera_vreg_t *cam_vreg;
		void *data[MSM_ACTUATOT_MAX_VREGS];
		void *data[MSM_ACTUATOR_MAX_VREGS];
		int num_vreg;
		};

		@@ -105,6 +105,9 @@ struct msm_actuator_ctrl_t {
		struct msm_actuator_vreg vreg_cfg;
		struct park_lens_data_t park_lens;
		uint32_t max_code_size;
		struct msm_camera_gpio_conf *gconf;
		struct msm_pinctrl_info pinctrl_info;
		uint8_t cam_pinctrl_status;
		};

		#endif

drivers/media/platform/msm/camera_v2/sensor/flash/msm_flash.c

+8 −73

Original line number	Diff line number	Diff line
		@@ -681,77 +681,6 @@ static struct v4l2_subdev_ops msm_flash_subdev_ops = {

		static const struct v4l2_subdev_internal_ops msm_flash_internal_ops;

		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__);
		rc = -EINVAL;
		goto free_gpio_array;
		}
		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_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_req_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_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_flash_get_pmic_source_info(
		struct device_node *of_node,
		struct msm_flash_ctrl_t *fctrl)
		@@ -977,13 +906,19 @@ static int32_t msm_flash_get_dt_data(struct device_node *of_node,
		}

		/* Read the gpio information from device tree */
		rc = msm_flash_get_gpio_dt_data(of_node, fctrl);
		rc = msm_sensor_driver_get_gpio_data(
		&(fctrl->power_info.gpio_conf), of_node);
		if (rc < 0) {
		pr_err("%s:%d msm_flash_get_gpio_dt_data failed rc %d\n",
		pr_err("%s:%d msm_sensor_driver_get_gpio_data failed rc %d\n",
		__func__, __LINE__, rc);
		return rc;
		}

		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);

		/* Read the flash and torch source info from device tree node */
		rc = msm_flash_get_pmic_source_info(of_node, fctrl);
		if (rc < 0) {

drivers/media/platform/msm/camera_v2/sensor/io/msm_camera_dt_util.c

+137 −25

Original line number	Diff line number	Diff line
		@@ -67,8 +67,6 @@ int msm_camera_fill_vreg_params(struct camera_vreg_t *cam_vreg,
		break;
		}
		}
		if (j == num_vreg)
		power_setting[i].seq_val = INVALID_VREG;
		break;

		case CAM_VIO:
		@@ -88,8 +86,6 @@ int msm_camera_fill_vreg_params(struct camera_vreg_t *cam_vreg,
		break;
		}
		}
		if (j == num_vreg)
		power_setting[i].seq_val = INVALID_VREG;
		break;

		case CAM_VANA:
		@@ -109,8 +105,6 @@ int msm_camera_fill_vreg_params(struct camera_vreg_t *cam_vreg,
		break;
		}
		}
		if (j == num_vreg)
		power_setting[i].seq_val = INVALID_VREG;
		break;

		case CAM_VAF:
		@@ -130,8 +124,6 @@ int msm_camera_fill_vreg_params(struct camera_vreg_t *cam_vreg,
		break;
		}
		}
		if (j == num_vreg)
		power_setting[i].seq_val = INVALID_VREG;
		break;

		case CAM_V_CUSTOM1:
		@@ -152,9 +144,6 @@ int msm_camera_fill_vreg_params(struct camera_vreg_t *cam_vreg,
		break;
		}
		}
		if (j == num_vreg)
		power_setting[i].seq_val = INVALID_VREG;
		break;

		case CAM_V_CUSTOM2:
		for (j = 0; j < num_vreg; j++) {
		@@ -174,8 +163,6 @@ int msm_camera_fill_vreg_params(struct camera_vreg_t *cam_vreg,
		break;
		}
		}
		if (j == num_vreg)
		power_setting[i].seq_val = INVALID_VREG;
		break;

		default:
		@@ -184,7 +171,6 @@ int msm_camera_fill_vreg_params(struct camera_vreg_t *cam_vreg,
		break;
		}
		}

		return 0;
		}

		@@ -762,7 +748,6 @@ int msm_camera_init_gpio_pin_tbl(struct device_node *of_node,
		rc = -ENOMEM;
		return rc;
		}

		rc = of_property_read_u32(of_node, "qcom,gpio-vana", &val);
		if (rc != -EINVAL) {
		if (rc < 0) {
		@@ -1036,6 +1021,7 @@ int msm_camera_get_dt_vreg_data(struct device_node *of_node,
		if (!count \|\| (count == -EINVAL)) {
		pr_err("%s:%d number of entries is 0 or not present in dts\n",
		__func__, __LINE__);
		*num_vreg = 0;
		return 0;
		}

		@@ -1190,12 +1176,10 @@ static int msm_camera_disable_i2c_mux(struct msm_camera_i2c_conf *i2c_conf)
		return 0;
		}

		static int msm_camera_pinctrl_init(struct msm_camera_power_ctrl_t *ctrl)
		{
		struct msm_pinctrl_info *sensor_pctrl = NULL;
		int msm_camera_pinctrl_init(
		struct msm_pinctrl_info sensor_pctrl, struct device dev) {

		sensor_pctrl = &ctrl->pinctrl_info;
		sensor_pctrl->pinctrl = devm_pinctrl_get(ctrl->dev);
		sensor_pctrl->pinctrl = devm_pinctrl_get(dev);
		if (IS_ERR_OR_NULL(sensor_pctrl->pinctrl)) {
		pr_err("%s:%d Getting pinctrl handle failed\n",
		__func__, __LINE__);
		@@ -1220,6 +1204,120 @@ static int msm_camera_pinctrl_init(struct msm_camera_power_ctrl_t *ctrl)
		return 0;
		}

		int msm_cam_sensor_handle_reg_gpio(int seq_val,
		struct msm_camera_gpio_conf *gconf, int val) {

		int gpio_offset = -1;

		if (!gconf) {
		pr_err("ERR:%s: Input Parameters are not proper\n", __func__);
		return -EINVAL;
		}
		CDBG("%s: %d Seq val: %d, config: %d", __func__, __LINE__,
		seq_val, val);

		switch (seq_val) {
		case CAM_VDIG:
		gpio_offset = SENSOR_GPIO_VDIG;
		break;

		case CAM_VIO:
		gpio_offset = SENSOR_GPIO_VIO;
		break;

		case CAM_VANA:
		gpio_offset = SENSOR_GPIO_VANA;
		break;

		case CAM_VAF:
		gpio_offset = SENSOR_GPIO_VAF;
		break;

		case CAM_V_CUSTOM1:
		gpio_offset = SENSOR_GPIO_CUSTOM1;
		break;

		case CAM_V_CUSTOM2:
		gpio_offset = SENSOR_GPIO_CUSTOM2;
		break;

		default:
		pr_err("%s:%d Invalid VREG seq val %d\n", __func__,
		__LINE__, seq_val);
		return -EINVAL;
		}

		CDBG("%s: %d GPIO offset: %d, seq_val: %d\n", __func__, __LINE__,
		gpio_offset, seq_val);

		if ((gconf->gpio_num_info->valid[gpio_offset] == 1)) {
		gpio_set_value_cansleep(
		gconf->gpio_num_info->gpio_num
		[gpio_offset], val);
		}
		return 0;
		}

		int32_t msm_sensor_driver_get_gpio_data(
		struct msm_camera_gpio_conf **gpio_conf,
		struct device_node *of_node)
		{
		int32_t rc = 0, i = 0;
		uint16_t *gpio_array = NULL;
		int16_t gpio_array_size = 0;
		struct msm_camera_gpio_conf *gconf = NULL;

		/* Validate input parameters */
		if (!of_node) {
		pr_err("failed: invalid param of_node %pK", of_node);
		return -EINVAL;
		}

		gpio_array_size = of_gpio_count(of_node);
		CDBG("gpio count %d\n", gpio_array_size);
		if (gpio_array_size <= 0)
		return 0;

		gconf = kzalloc(sizeof(struct msm_camera_gpio_conf),
		GFP_KERNEL);
		if (!gconf)
		return -ENOMEM;

		*gpio_conf = gconf;

		gpio_array = kcalloc(gpio_array_size, sizeof(uint16_t), GFP_KERNEL);
		if (!gpio_array)
		goto FREE_GPIO_CONF;

		for (i = 0; i < gpio_array_size; i++) {
		gpio_array[i] = of_get_gpio(of_node, i);
		CDBG("gpio_array[%d] = %d", 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("failed in msm_camera_get_dt_gpio_req_tbl\n");
		goto FREE_GPIO_CONF;
		}

		rc = msm_camera_init_gpio_pin_tbl(of_node, gconf, gpio_array,
		gpio_array_size);
		if (rc < 0) {
		pr_err("failed in msm_camera_init_gpio_pin_tbl\n");
		goto FREE_GPIO_REQ_TBL;
		}
		kfree(gpio_array);
		return rc;

		FREE_GPIO_REQ_TBL:
		kfree(gconf->cam_gpio_req_tbl);
		FREE_GPIO_CONF:
		kfree(gconf);
		kfree(gpio_array);
		*gpio_conf = NULL;
		return rc;
		}

		int msm_camera_power_up(struct msm_camera_power_ctrl_t *ctrl,
		enum msm_camera_device_type_t device_type,
		struct msm_camera_i2c_client *sensor_i2c_client)
		@@ -1236,7 +1334,7 @@ int msm_camera_power_up(struct msm_camera_power_ctrl_t *ctrl,
		if (ctrl->gpio_conf->cam_gpiomux_conf_tbl != NULL)
		pr_err("%s:%d mux install\n", __func__, __LINE__);

		ret = msm_camera_pinctrl_init(ctrl);
		ret = msm_camera_pinctrl_init(&(ctrl->pinctrl_info), ctrl->dev);
		if (ret < 0) {
		pr_err("%s:%d Initialization of pinctrl failed\n",
		__func__, __LINE__);
		@@ -1303,8 +1401,6 @@ int msm_camera_power_up(struct msm_camera_power_ctrl_t *ctrl,
		(int) power_setting->config_val);
		break;
		case SENSOR_VREG:
		if (power_setting->seq_val == INVALID_VREG)
		break;
		if (power_setting->seq_val >= CAM_VREG_MAX) {
		pr_err("%s vreg index %d >= max %d\n", __func__,
		power_setting->seq_val,
		@@ -1319,9 +1415,18 @@ int msm_camera_power_up(struct msm_camera_power_ctrl_t *ctrl,
		&power_setting->data[0],
		1);
		else
		pr_err("ERR:%s: %d usr_idx:%d dts_idx:%d\n",
		pr_err("%s: %d usr_idx:%d dts_idx:%d\n",
		__func__, __LINE__,
		power_setting->seq_val, ctrl->num_vreg);

		rc = msm_cam_sensor_handle_reg_gpio(
		power_setting->seq_val,
		ctrl->gpio_conf, 1);
		if (rc < 0) {
		pr_err("ERR:%s Error in handling VREG GPIO\n",
		__func__);
		goto power_up_failed;
		}
		break;
		case SENSOR_I2C_MUX:
		if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux)
		@@ -1348,7 +1453,6 @@ int msm_camera_power_up(struct msm_camera_power_ctrl_t *ctrl,
		goto power_up_failed;
		}
		}

		CDBG("%s exit\n", __func__);
		return 0;
		power_up_failed:
		@@ -1380,6 +1484,9 @@ power_up_failed:
		pr_err("%s:%d:seq_val: %d > num_vreg: %d\n",
		__func__, __LINE__,
		power_setting->seq_val, ctrl->num_vreg);

		msm_cam_sensor_handle_reg_gpio(power_setting->seq_val,
		ctrl->gpio_conf, GPIOF_OUT_INIT_LOW);
		break;
		case SENSOR_I2C_MUX:
		if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux)
		@@ -1505,6 +1612,11 @@ int msm_camera_power_down(struct msm_camera_power_ctrl_t *ctrl,
		} else
		pr_err("%s error in power up/down seq data\n",
		__func__);
		ret = msm_cam_sensor_handle_reg_gpio(pd->seq_val,
		ctrl->gpio_conf, GPIOF_OUT_INIT_LOW);
		if (ret < 0)
		pr_err("ERR:%s Error while disabling VREG GPIO\n",
		__func__);
		break;
		case SENSOR_I2C_MUX:
		if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux)

drivers/media/platform/msm/camera_v2/sensor/io/msm_camera_dt_util.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -15,6 +15,7 @@

		#include <soc/qcom/camera2.h>
		#include <linux/gpio.h>
		#include <linux/of_gpio.h>
		#include <linux/of.h>
		#include "msm_camera_i2c.h"
		#include "cam_soc_api.h"
		@@ -58,4 +59,10 @@ int msm_camera_fill_vreg_params(struct camera_vreg_t *cam_vreg,
		int num_vreg, struct msm_sensor_power_setting *power_setting,
		uint16_t power_setting_size);

		int msm_camera_pinctrl_init
		(struct msm_pinctrl_info sensor_pctrl, struct device dev);

		int32_t msm_sensor_driver_get_gpio_data(
		struct msm_camera_gpio_conf **gpio_conf,
		struct device_node *of_node);
		#endif