Merge remote-tracking branch 'regulator/topic/tps65090' into regulator-next (2730fd82) · Commits · e / devices / android_kernel_teracube_2e

drivers/regulator/tps65090-regulator.c

+101 −5

Original line number	Original line	Diff line number	Diff line
	@@ -19,11 +19,13 @@
	#include <linux/module.h>		#include <linux/module.h>
	#include <linux/init.h>		#include <linux/init.h>
	#include <linux/gpio.h>		#include <linux/gpio.h>
			#include <linux/of_gpio.h>
	#include <linux/slab.h>		#include <linux/slab.h>
	#include <linux/err.h>		#include <linux/err.h>
	#include <linux/platform_device.h>		#include <linux/platform_device.h>
	#include <linux/regulator/driver.h>		#include <linux/regulator/driver.h>
	#include <linux/regulator/machine.h>		#include <linux/regulator/machine.h>
			#include <linux/regulator/of_regulator.h>
	#include <linux/mfd/tps65090.h>		#include <linux/mfd/tps65090.h>

	struct tps65090_regulator {		struct tps65090_regulator {
	@@ -67,8 +69,8 @@ static struct regulator_desc tps65090_regulator_desc[] = {
	tps65090_REG_DESC(FET5, "infet5", 0x13, tps65090_reg_contol_ops),		tps65090_REG_DESC(FET5, "infet5", 0x13, tps65090_reg_contol_ops),
	tps65090_REG_DESC(FET6, "infet6", 0x14, tps65090_reg_contol_ops),		tps65090_REG_DESC(FET6, "infet6", 0x14, tps65090_reg_contol_ops),
	tps65090_REG_DESC(FET7, "infet7", 0x15, tps65090_reg_contol_ops),		tps65090_REG_DESC(FET7, "infet7", 0x15, tps65090_reg_contol_ops),
	tps65090_REG_DESC(LDO1, "vsys_l1", 0, tps65090_ldo_ops),		tps65090_REG_DESC(LDO1, "vsys-l1", 0, tps65090_ldo_ops),
	tps65090_REG_DESC(LDO2, "vsys_l2", 0, tps65090_ldo_ops),		tps65090_REG_DESC(LDO2, "vsys-l2", 0, tps65090_ldo_ops),
	};		};

	static inline bool is_dcdc(int id)		static inline bool is_dcdc(int id)
	@@ -138,6 +140,92 @@ static void tps65090_configure_regulator_config(
	}		}
	}		}

			#ifdef CONFIG_OF
			static struct of_regulator_match tps65090_matches[] = {
			{ .name = "dcdc1", },
			{ .name = "dcdc2", },
			{ .name = "dcdc3", },
			{ .name = "fet1", },
			{ .name = "fet2", },
			{ .name = "fet3", },
			{ .name = "fet4", },
			{ .name = "fet5", },
			{ .name = "fet6", },
			{ .name = "fet7", },
			{ .name = "ldo1", },
			{ .name = "ldo2", },
			};

			static struct tps65090_platform_data *tps65090_parse_dt_reg_data(
			struct platform_device *pdev,
			struct of_regulator_match **tps65090_reg_matches)
			{
			struct tps65090_platform_data *tps65090_pdata;
			struct device_node *np = pdev->dev.parent->of_node;
			struct device_node *regulators;
			int idx = 0, ret;
			struct tps65090_regulator_plat_data *reg_pdata;

			tps65090_pdata = devm_kzalloc(&pdev->dev, sizeof(*tps65090_pdata),
			GFP_KERNEL);
			if (!tps65090_pdata) {
			dev_err(&pdev->dev, "Memory alloc for tps65090_pdata failed\n");
			return ERR_PTR(-ENOMEM);
			}

			reg_pdata = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX *
			sizeof(*reg_pdata), GFP_KERNEL);
			if (!reg_pdata) {
			dev_err(&pdev->dev, "Memory alloc for reg_pdata failed\n");
			return ERR_PTR(-ENOMEM);
			}

			regulators = of_find_node_by_name(np, "regulators");
			if (!regulators) {
			dev_err(&pdev->dev, "regulator node not found\n");
			return ERR_PTR(-ENODEV);
			}

			ret = of_regulator_match(&pdev->dev, regulators, tps65090_matches,
			ARRAY_SIZE(tps65090_matches));
			if (ret < 0) {
			dev_err(&pdev->dev,
			"Error parsing regulator init data: %d\n", ret);
			return ERR_PTR(ret);
			}

			*tps65090_reg_matches = tps65090_matches;
			for (idx = 0; idx < ARRAY_SIZE(tps65090_matches); idx++) {
			struct regulator_init_data *ri_data;
			struct tps65090_regulator_plat_data *rpdata;

			rpdata = &reg_pdata[idx];
			ri_data = tps65090_matches[idx].init_data;
			if (!ri_data \|\| !tps65090_matches[idx].of_node)
			continue;

			rpdata->reg_init_data = ri_data;
			rpdata->enable_ext_control = of_property_read_bool(
			tps65090_matches[idx].of_node,
			"ti,enable-ext-control");
			if (rpdata->enable_ext_control)
			rpdata->gpio = of_get_named_gpio(np,
			"dcdc-ext-control-gpios", 0);

			tps65090_pdata->reg_pdata[idx] = rpdata;
			}
			return tps65090_pdata;
			}
			#else
			static inline struct tps65090_platform_data *tps65090_parse_dt_reg_data(
			struct platform_device *pdev,
			struct of_regulator_match **tps65090_reg_matches)
			{
			*tps65090_reg_matches = NULL;
			return NULL;
			}
			#endif

	static int tps65090_regulator_probe(struct platform_device *pdev)		static int tps65090_regulator_probe(struct platform_device *pdev)
	{		{
	struct tps65090 *tps65090_mfd = dev_get_drvdata(pdev->dev.parent);		struct tps65090 *tps65090_mfd = dev_get_drvdata(pdev->dev.parent);
	@@ -147,15 +235,19 @@ static int tps65090_regulator_probe(struct platform_device *pdev)
	struct tps65090_regulator_plat_data *tps_pdata;		struct tps65090_regulator_plat_data *tps_pdata;
	struct tps65090_regulator *pmic;		struct tps65090_regulator *pmic;
	struct tps65090_platform_data *tps65090_pdata;		struct tps65090_platform_data *tps65090_pdata;
			struct of_regulator_match *tps65090_reg_matches = NULL;
	int num;		int num;
	int ret;		int ret;

	dev_dbg(&pdev->dev, "Probing regulator\n");		dev_dbg(&pdev->dev, "Probing regulator\n");

	tps65090_pdata = dev_get_platdata(pdev->dev.parent);		tps65090_pdata = dev_get_platdata(pdev->dev.parent);
	if (!tps65090_pdata) {		if (!tps65090_pdata && tps65090_mfd->dev->of_node)
			tps65090_pdata = tps65090_parse_dt_reg_data(pdev,
			&tps65090_reg_matches);
			if (IS_ERR_OR_NULL(tps65090_pdata)) {
	dev_err(&pdev->dev, "Platform data missing\n");		dev_err(&pdev->dev, "Platform data missing\n");
	return -EINVAL;		return tps65090_pdata ? PTR_ERR(tps65090_pdata) : -EINVAL;
	}		}

	pmic = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX * sizeof(*pmic),		pmic = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX * sizeof(*pmic),
	@@ -192,13 +284,17 @@ static int tps65090_regulator_probe(struct platform_device *pdev)
	}		}
	}		}

	config.dev = &pdev->dev;		config.dev = pdev->dev.parent;
	config.driver_data = ri;		config.driver_data = ri;
	config.regmap = tps65090_mfd->rmap;		config.regmap = tps65090_mfd->rmap;
	if (tps_pdata)		if (tps_pdata)
	config.init_data = tps_pdata->reg_init_data;		config.init_data = tps_pdata->reg_init_data;
	else		else
	config.init_data = NULL;		config.init_data = NULL;
			if (tps65090_reg_matches)
			config.of_node = tps65090_reg_matches[num].of_node;
			else
			config.of_node = NULL;

	rdev = regulator_register(ri->desc, &config);		rdev = regulator_register(ri->desc, &config);
	if (IS_ERR(rdev)) {		if (IS_ERR(rdev)) {