Merge remote-tracking branches 'regulator/topic/88pm800',... (08aad16c) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/regulator/88pm800.c

+83 −153

Original line number	Original line	Diff line number	Diff line
	@@ -78,7 +78,6 @@ struct pm800_regulator_info {
	};		};

	struct pm800_regulators {		struct pm800_regulators {
	struct regulator_dev *regulators[PM800_ID_RG_MAX];
	struct pm80x_chip *chip;		struct pm80x_chip *chip;
	struct regmap *map;		struct regmap *map;
	};		};
	@@ -92,10 +91,12 @@ struct pm800_regulators {
	* not the constant voltage table.		* not the constant voltage table.
	* n_volt - Number of available selectors		* n_volt - Number of available selectors
	*/		*/
	#define PM800_BUCK(vreg, ereg, ebit, amax, volt_ranges, n_volt) \		#define PM800_BUCK(match, vreg, ereg, ebit, amax, volt_ranges, n_volt) \
	{ \		{ \
	.desc = { \		.desc = { \
	.name = #vreg, \		.name = #vreg, \
			.of_match = of_match_ptr(#match), \
			.regulators_node = of_match_ptr("regulators"), \
	.ops = &pm800_volt_range_ops, \		.ops = &pm800_volt_range_ops, \
	.type = REGULATOR_VOLTAGE, \		.type = REGULATOR_VOLTAGE, \
	.id = PM800_ID_##vreg, \		.id = PM800_ID_##vreg, \
	@@ -120,10 +121,12 @@ struct pm800_regulators {
	* For all the LDOes, there are too many ranges. Using volt_table will be		* For all the LDOes, there are too many ranges. Using volt_table will be
	* simpler and faster.		* simpler and faster.
	*/		*/
	#define PM800_LDO(vreg, ereg, ebit, amax, ldo_volt_table) \		#define PM800_LDO(match, vreg, ereg, ebit, amax, ldo_volt_table) \
	{ \		{ \
	.desc = { \		.desc = { \
	.name = #vreg, \		.name = #vreg, \
			.of_match = of_match_ptr(#match), \
			.regulators_node = of_match_ptr("regulators"), \
	.ops = &pm800_volt_table_ops, \		.ops = &pm800_volt_table_ops, \
	.type = REGULATOR_VOLTAGE, \		.type = REGULATOR_VOLTAGE, \
	.id = PM800_ID_##vreg, \		.id = PM800_ID_##vreg, \
	@@ -201,99 +204,43 @@ static struct regulator_ops pm800_volt_table_ops = {

	/* The array is indexed by id(PM800_ID_XXX) */		/* The array is indexed by id(PM800_ID_XXX) */
	static struct pm800_regulator_info pm800_regulator_info[] = {		static struct pm800_regulator_info pm800_regulator_info[] = {
	PM800_BUCK(BUCK1, BUCK_ENA, 0, 3000000, buck1_volt_range, 0x55),		PM800_BUCK(buck1, BUCK1, BUCK_ENA, 0, 3000000, buck1_volt_range, 0x55),
	PM800_BUCK(BUCK2, BUCK_ENA, 1, 1200000, buck2_5_volt_range, 0x73),		PM800_BUCK(buck2, BUCK2, BUCK_ENA, 1, 1200000, buck2_5_volt_range, 0x73),
	PM800_BUCK(BUCK3, BUCK_ENA, 2, 1200000, buck2_5_volt_range, 0x73),		PM800_BUCK(buck3, BUCK3, BUCK_ENA, 2, 1200000, buck2_5_volt_range, 0x73),
	PM800_BUCK(BUCK4, BUCK_ENA, 3, 1200000, buck2_5_volt_range, 0x73),		PM800_BUCK(buck4, BUCK4, BUCK_ENA, 3, 1200000, buck2_5_volt_range, 0x73),
	PM800_BUCK(BUCK5, BUCK_ENA, 4, 1200000, buck2_5_volt_range, 0x73),		PM800_BUCK(buck5, BUCK5, BUCK_ENA, 4, 1200000, buck2_5_volt_range, 0x73),

	PM800_LDO(LDO1, LDO_ENA1_1, 0, 200000, ldo1_volt_table),		PM800_LDO(ldo1, LDO1, LDO_ENA1_1, 0, 200000, ldo1_volt_table),
	PM800_LDO(LDO2, LDO_ENA1_1, 1, 10000, ldo2_volt_table),		PM800_LDO(ldo2, LDO2, LDO_ENA1_1, 1, 10000, ldo2_volt_table),
	PM800_LDO(LDO3, LDO_ENA1_1, 2, 300000, ldo3_17_volt_table),		PM800_LDO(ldo3, LDO3, LDO_ENA1_1, 2, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO4, LDO_ENA1_1, 3, 300000, ldo3_17_volt_table),		PM800_LDO(ldo4, LDO4, LDO_ENA1_1, 3, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO5, LDO_ENA1_1, 4, 300000, ldo3_17_volt_table),		PM800_LDO(ldo5, LDO5, LDO_ENA1_1, 4, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO6, LDO_ENA1_1, 5, 300000, ldo3_17_volt_table),		PM800_LDO(ldo6, LDO6, LDO_ENA1_1, 5, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO7, LDO_ENA1_1, 6, 300000, ldo3_17_volt_table),		PM800_LDO(ldo7, LDO7, LDO_ENA1_1, 6, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO8, LDO_ENA1_1, 7, 300000, ldo3_17_volt_table),		PM800_LDO(ldo8, LDO8, LDO_ENA1_1, 7, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO9, LDO_ENA1_2, 0, 300000, ldo3_17_volt_table),		PM800_LDO(ldo9, LDO9, LDO_ENA1_2, 0, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO10, LDO_ENA1_2, 1, 300000, ldo3_17_volt_table),		PM800_LDO(ldo10, LDO10, LDO_ENA1_2, 1, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO11, LDO_ENA1_2, 2, 300000, ldo3_17_volt_table),		PM800_LDO(ldo11, LDO11, LDO_ENA1_2, 2, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO12, LDO_ENA1_2, 3, 300000, ldo3_17_volt_table),		PM800_LDO(ldo12, LDO12, LDO_ENA1_2, 3, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO13, LDO_ENA1_2, 4, 300000, ldo3_17_volt_table),		PM800_LDO(ldo13, LDO13, LDO_ENA1_2, 4, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO14, LDO_ENA1_2, 5, 300000, ldo3_17_volt_table),		PM800_LDO(ldo14, LDO14, LDO_ENA1_2, 5, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO15, LDO_ENA1_2, 6, 300000, ldo3_17_volt_table),		PM800_LDO(ldo15, LDO15, LDO_ENA1_2, 6, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO16, LDO_ENA1_2, 7, 300000, ldo3_17_volt_table),		PM800_LDO(ldo16, LDO16, LDO_ENA1_2, 7, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO17, LDO_ENA1_3, 0, 300000, ldo3_17_volt_table),		PM800_LDO(ldo17, LDO17, LDO_ENA1_3, 0, 300000, ldo3_17_volt_table),
	PM800_LDO(LDO18, LDO_ENA1_3, 1, 200000, ldo18_19_volt_table),		PM800_LDO(ldo18, LDO18, LDO_ENA1_3, 1, 200000, ldo18_19_volt_table),
	PM800_LDO(LDO19, LDO_ENA1_3, 2, 200000, ldo18_19_volt_table),		PM800_LDO(ldo19, LDO19, LDO_ENA1_3, 2, 200000, ldo18_19_volt_table),
	};		};

	#define PM800_REGULATOR_OF_MATCH(_name, _id) \
	[PM800_ID_##_id] = { \
	.name = #_name, \
	.driver_data = &pm800_regulator_info[PM800_ID_##_id], \
	}

	static struct of_regulator_match pm800_regulator_matches[] = {
	PM800_REGULATOR_OF_MATCH(buck1, BUCK1),
	PM800_REGULATOR_OF_MATCH(buck2, BUCK2),
	PM800_REGULATOR_OF_MATCH(buck3, BUCK3),
	PM800_REGULATOR_OF_MATCH(buck4, BUCK4),
	PM800_REGULATOR_OF_MATCH(buck5, BUCK5),
	PM800_REGULATOR_OF_MATCH(ldo1, LDO1),
	PM800_REGULATOR_OF_MATCH(ldo2, LDO2),
	PM800_REGULATOR_OF_MATCH(ldo3, LDO3),
	PM800_REGULATOR_OF_MATCH(ldo4, LDO4),
	PM800_REGULATOR_OF_MATCH(ldo5, LDO5),
	PM800_REGULATOR_OF_MATCH(ldo6, LDO6),
	PM800_REGULATOR_OF_MATCH(ldo7, LDO7),
	PM800_REGULATOR_OF_MATCH(ldo8, LDO8),
	PM800_REGULATOR_OF_MATCH(ldo9, LDO9),
	PM800_REGULATOR_OF_MATCH(ldo10, LDO10),
	PM800_REGULATOR_OF_MATCH(ldo11, LDO11),
	PM800_REGULATOR_OF_MATCH(ldo12, LDO12),
	PM800_REGULATOR_OF_MATCH(ldo13, LDO13),
	PM800_REGULATOR_OF_MATCH(ldo14, LDO14),
	PM800_REGULATOR_OF_MATCH(ldo15, LDO15),
	PM800_REGULATOR_OF_MATCH(ldo16, LDO16),
	PM800_REGULATOR_OF_MATCH(ldo17, LDO17),
	PM800_REGULATOR_OF_MATCH(ldo18, LDO18),
	PM800_REGULATOR_OF_MATCH(ldo19, LDO19),
	};

	static int pm800_regulator_dt_init(struct platform_device *pdev)
	{
	struct device_node *np = pdev->dev.of_node;
	int ret;

	ret = of_regulator_match(&pdev->dev, np,
	pm800_regulator_matches,
	ARRAY_SIZE(pm800_regulator_matches));
	if (ret < 0)
	return ret;

	return 0;
	}

	static int pm800_regulator_probe(struct platform_device *pdev)		static int pm800_regulator_probe(struct platform_device *pdev)
	{		{
	struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent);		struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent);
	struct pm80x_platform_data *pdata = dev_get_platdata(pdev->dev.parent);		struct pm80x_platform_data *pdata = dev_get_platdata(pdev->dev.parent);
	struct pm800_regulators *pm800_data;		struct pm800_regulators *pm800_data;
	struct pm800_regulator_info *info;
	struct regulator_config config = { };		struct regulator_config config = { };
	struct regulator_init_data *init_data;		struct regulator_init_data *init_data;
	int i, ret;		int i, ret;

	if (!pdata \|\| pdata->num_regulators == 0) {		if (pdata && pdata->num_regulators) {
	if (IS_ENABLED(CONFIG_OF)) {
	ret = pm800_regulator_dt_init(pdev);
	if (ret)
	return ret;
	} else {
	return -ENODEV;
	}
	} else if (pdata->num_regulators) {
	unsigned int count = 0;		unsigned int count = 0;

	/* Check whether num_regulator is valid. */		/* Check whether num_regulator is valid. */
	@@ -303,8 +250,6 @@ static int pm800_regulator_probe(struct platform_device *pdev)
	}		}
	if (count != pdata->num_regulators)		if (count != pdata->num_regulators)
	return -EINVAL;		return -EINVAL;
	} else {
	return -EINVAL;
	}		}

	pm800_data = devm_kzalloc(&pdev->dev, sizeof(*pm800_data),		pm800_data = devm_kzalloc(&pdev->dev, sizeof(*pm800_data),
	@@ -317,30 +262,27 @@ static int pm800_regulator_probe(struct platform_device *pdev)

	platform_set_drvdata(pdev, pm800_data);		platform_set_drvdata(pdev, pm800_data);

			config.dev = chip->dev;
			config.regmap = pm800_data->map;
	for (i = 0; i < PM800_ID_RG_MAX; i++) {		for (i = 0; i < PM800_ID_RG_MAX; i++) {
	if (!pdata \|\| pdata->num_regulators == 0)		struct regulator_dev *regulator;
	init_data = pm800_regulator_matches[i].init_data;
	else		if (pdata && pdata->num_regulators) {
	init_data = pdata->regulators[i];		init_data = pdata->regulators[i];
	if (!init_data)		if (!init_data)
	continue;		continue;
	info = pm800_regulator_matches[i].driver_data;
	config.dev = &pdev->dev;
	config.init_data = init_data;
	config.driver_data = info;
	config.regmap = pm800_data->map;
	config.of_node = pm800_regulator_matches[i].of_node;

	pm800_data->regulators[i] =		config.init_data = init_data;
	regulator_register(&info->desc, &config);		}
	if (IS_ERR(pm800_data->regulators[i])) {
	ret = PTR_ERR(pm800_data->regulators[i]);
	dev_err(&pdev->dev, "Failed to register %s\n",
	info->desc.name);

	while (--i >= 0)		config.driver_data = &pm800_regulator_info[i];
	regulator_unregister(pm800_data->regulators[i]);

			regulator = devm_regulator_register(&pdev->dev,
			&pm800_regulator_info[i].desc, &config);
			if (IS_ERR(regulator)) {
			ret = PTR_ERR(regulator);
			dev_err(&pdev->dev, "Failed to register %s\n",
			pm800_regulator_info[i].desc.name);
	return ret;		return ret;
	}		}
	}		}
	@@ -348,23 +290,11 @@ static int pm800_regulator_probe(struct platform_device *pdev)
	return 0;		return 0;
	}		}

	static int pm800_regulator_remove(struct platform_device *pdev)
	{
	struct pm800_regulators *pm800_data = platform_get_drvdata(pdev);
	int i;

	for (i = 0; i < PM800_ID_RG_MAX; i++)
	regulator_unregister(pm800_data->regulators[i]);

	return 0;
	}

	static struct platform_driver pm800_regulator_driver = {		static struct platform_driver pm800_regulator_driver = {
	.driver = {		.driver = {
	.name = "88pm80x-regulator",		.name = "88pm80x-regulator",
	},		},
	.probe = pm800_regulator_probe,		.probe = pm800_regulator_probe,
	.remove = pm800_regulator_remove,
	};		};

	module_platform_driver(pm800_regulator_driver);		module_platform_driver(pm800_regulator_driver);

drivers/regulator/ad5398.c

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -275,4 +275,3 @@ module_exit(ad5398_exit);
	MODULE_DESCRIPTION("AD5398 and AD5821 current regulator driver");		MODULE_DESCRIPTION("AD5398 and AD5821 current regulator driver");
	MODULE_AUTHOR("Sonic Zhang");		MODULE_AUTHOR("Sonic Zhang");
	MODULE_LICENSE("GPL");		MODULE_LICENSE("GPL");
	MODULE_ALIAS("i2c:ad5398-regulator");

drivers/regulator/axp20x-regulator.c

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -405,3 +405,4 @@ module_platform_driver(axp20x_regulator_driver);
	MODULE_LICENSE("GPL v2");		MODULE_LICENSE("GPL v2");
	MODULE_AUTHOR("Carlo Caione <carlo@caione.org>");		MODULE_AUTHOR("Carlo Caione <carlo@caione.org>");
	MODULE_DESCRIPTION("Regulator Driver for AXP20X PMIC");		MODULE_DESCRIPTION("Regulator Driver for AXP20X PMIC");
			MODULE_ALIAS("platform:axp20x-regulator");

drivers/regulator/da9062-regulator.c

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -818,7 +818,6 @@ static int da9062_regulator_probe(struct platform_device *pdev)
	static struct platform_driver da9062_regulator_driver = {		static struct platform_driver da9062_regulator_driver = {
	.driver = {		.driver = {
	.name = "da9062-regulators",		.name = "da9062-regulators",
	.owner = THIS_MODULE,
	},		},
	.probe = da9062_regulator_probe,		.probe = da9062_regulator_probe,
	};		};