Commit 08bf1c0a authored by Ashish Jangam's avatar Ashish Jangam Committed by Mark Brown
Browse files

regulator: DA9052/53 Regulator support 



The Dialog PMIC has below featured regulators:-
DA9052-BC - 4 DVS Buck converters 0.5V - 3.6V upto 1Amp.
DA9053-AA/BX - 4 DVS Buck converters 0.5V - 2.5V upto 3Amp.
DA9052/53 - 10 Programmable LDO's High PSSR, 1% accuracy.

This patch support all the DA9052 and Da9053 regulators. The output voltages are
fully programmable via I2C or SPI interface. The platform data with regulation
constraints is passed down from the board to the regulator.

Signed-off-by: default avatarDavid Dajun Chen <dchen@diasemi.com>
Signed-off-by: default avatarAshish Jangam <ashish.jangam@kpitcummins.com>
Tested-by: default avatarYing-Chun Liu (PaulLiu) <paul.liu@linaro.org>
Signed-off-by: default avatarMark Brown <broonie@opensource.wolfsonmicro.com>
parent 2f288efd

drivers/regulator/Kconfig

+7 −0
Original line number Diff line number Diff line
@@ -178,6 +178,13 @@ config REGULATOR_DA903X 
	  Say y here to support the BUCKs and LDOs regulators found on

	  Dialog Semiconductor DA9030/DA9034 PMIC.



config REGULATOR_DA9052

	tristate "Dialog DA9052/DA9053 regulators"

	depends on PMIC_DA9052

	help

	  This driver supports the voltage regulators of DA9052-BC and

	  DA9053-AA/Bx PMIC.



config REGULATOR_PCF50633

	tristate "PCF50633 regulator driver"

        depends on MFD_PCF50633

drivers/regulator/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ obj-$(CONFIG_REGULATOR_WM8400) += wm8400-regulator.o 
obj-$(CONFIG_REGULATOR_WM8994) += wm8994-regulator.o

obj-$(CONFIG_REGULATOR_TPS6586X) += tps6586x-regulator.o

obj-$(CONFIG_REGULATOR_DA903X)	+= da903x.o

obj-$(CONFIG_REGULATOR_DA9052)	+= da9052-regulator.o

obj-$(CONFIG_REGULATOR_PCF50633) += pcf50633-regulator.o

obj-$(CONFIG_REGULATOR_PCAP) += pcap-regulator.o

obj-$(CONFIG_REGULATOR_MC13783) += mc13783-regulator.o

drivers/regulator/da9052-regulator.c

0 → 100644
+600 −0
Original line number Diff line number Diff line 
/*

* da9052-regulator.c: Regulator driver for DA9052

*

* Copyright(c) 2011 Dialog Semiconductor Ltd.

*

* Author: David Dajun Chen <dchen@diasemi.com>

*

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

*

*/



#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/init.h>

#include <linux/err.h>

#include <linux/platform_device.h>

#include <linux/regulator/driver.h>

#include <linux/regulator/machine.h>



#include <linux/mfd/da9052/da9052.h>

#include <linux/mfd/da9052/reg.h>

#include <linux/mfd/da9052/pdata.h>



/* Buck step size */

#define DA9052_BUCK_PERI_3uV_STEP		100000

#define DA9052_BUCK_PERI_REG_MAP_UPTO_3uV	24

#define DA9052_CONST_3uV			3000000



#define DA9052_MIN_UA		0

#define DA9052_MAX_UA		3

#define DA9052_CURRENT_RANGE	4



/* Bit masks */

#define DA9052_BUCK_ILIM_MASK_EVEN	0x0c

#define DA9052_BUCK_ILIM_MASK_ODD	0xc0



static const u32 da9052_current_limits[3][4] = {

	{700000, 800000, 1000000, 1200000},	/* DA9052-BC BUCKs */

	{1600000, 2000000, 2400000, 3000000},	/* DA9053-AA/Bx BUCK-CORE */

	{800000, 1000000, 1200000, 1500000},	/* DA9053-AA/Bx BUCK-PRO,

						 * BUCK-MEM and BUCK-PERI

						*/

};



struct da9052_regulator_info {

	struct regulator_desc reg_desc;

	int step_uV;

	int min_uV;

	int max_uV;

	unsigned char volt_shift;

	unsigned char en_bit;

	unsigned char activate_bit;

};



struct da9052_regulator {

	struct da9052 *da9052;

	struct da9052_regulator_info *info;

	struct regulator_dev *rdev;

};



static int verify_range(struct da9052_regulator_info *info,

			 int min_uV, int max_uV)

{

	if (min_uV > info->max_uV || max_uV < info->min_uV)

		return -EINVAL;



	return 0;

}



static int da9052_regulator_enable(struct regulator_dev *rdev)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int offset = rdev_get_id(rdev);



	return da9052_reg_update(regulator->da9052,

				 DA9052_BUCKCORE_REG + offset,

				 1 << info->en_bit, 1 << info->en_bit);

}



static int da9052_regulator_disable(struct regulator_dev *rdev)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int offset = rdev_get_id(rdev);



	return da9052_reg_update(regulator->da9052,

				 DA9052_BUCKCORE_REG + offset,

				 1 << info->en_bit, 0);

}



static int da9052_regulator_is_enabled(struct regulator_dev *rdev)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int offset = rdev_get_id(rdev);

	int ret;



	ret = da9052_reg_read(regulator->da9052, DA9052_BUCKCORE_REG + offset);

	if (ret < 0)

		return ret;



	return ret & (1 << info->en_bit);

}



static int da9052_dcdc_get_current_limit(struct regulator_dev *rdev)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	int offset = rdev_get_id(rdev);

	int ret, row = 2;



	ret = da9052_reg_read(regulator->da9052, DA9052_BUCKA_REG + offset/2);

	if (ret < 0)

		return ret;



	/* Determine the even or odd position of the buck current limit

	 * register field

	*/

	if (offset % 2 == 0)

		ret = (ret & DA9052_BUCK_ILIM_MASK_EVEN) >> 2;

	else

		ret = (ret & DA9052_BUCK_ILIM_MASK_ODD) >> 6;



	/* Select the appropriate current limit range */

	if (regulator->da9052->chip_id == DA9052)

		row = 0;

	else if (offset == 0)

		row = 1;



	return da9052_current_limits[row][ret];

}



static int da9052_dcdc_set_current_limit(struct regulator_dev *rdev, int min_uA,

					  int max_uA)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	int offset = rdev_get_id(rdev);

	int reg_val = 0;

	int i, row = 2;



	/* Select the appropriate current limit range */

	if (regulator->da9052->chip_id == DA9052)

		row = 0;

	else if (offset == 0)

		row = 1;



	if (min_uA > da9052_current_limits[row][DA9052_MAX_UA] ||

	    max_uA < da9052_current_limits[row][DA9052_MIN_UA])

		return -EINVAL;



	for (i = 0; i < DA9052_CURRENT_RANGE; i++) {

		if (min_uA <= da9052_current_limits[row][i]) {

			reg_val = i;

			break;

		}

	}



	/* Determine the even or odd position of the buck current limit

	 * register field

	*/

	if (offset % 2 == 0)

		return da9052_reg_update(regulator->da9052,

					 DA9052_BUCKA_REG + offset/2,

					 DA9052_BUCK_ILIM_MASK_EVEN,

					 reg_val << 2);

	else

		return da9052_reg_update(regulator->da9052,

					 DA9052_BUCKA_REG + offset/2,

					 DA9052_BUCK_ILIM_MASK_ODD,

					 reg_val << 6);

}



static int da9052_list_buckperi_voltage(struct regulator_dev *rdev,

					 unsigned int selector)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int volt_uV;



	if ((regulator->da9052->chip_id == DA9052) &&

	    (selector >= DA9052_BUCK_PERI_REG_MAP_UPTO_3uV)) {

		volt_uV = ((DA9052_BUCK_PERI_REG_MAP_UPTO_3uV * info->step_uV)

			    + info->min_uV);

		volt_uV += (selector - DA9052_BUCK_PERI_REG_MAP_UPTO_3uV)

			    * (DA9052_BUCK_PERI_3uV_STEP);

	} else

			volt_uV = (selector * info->step_uV) + info->min_uV;



	if (volt_uV > info->max_uV)

		return -EINVAL;



	return volt_uV;

}



static int da9052_list_voltage(struct regulator_dev *rdev,

				unsigned int selector)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int volt_uV;



	volt_uV = info->min_uV + info->step_uV * selector;



	if (volt_uV > info->max_uV)

		return -EINVAL;



	return volt_uV;

}



static int da9052_regulator_set_voltage_int(struct regulator_dev *rdev,

					     int min_uV, int max_uV,

					     unsigned int *selector)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int offset = rdev_get_id(rdev);

	int ret;



	ret = verify_range(info, min_uV, max_uV);

	if (ret < 0)

		return ret;



	if (min_uV < info->min_uV)

		min_uV = info->min_uV;



	*selector = (min_uV - info->min_uV) / info->step_uV;



	ret = da9052_list_voltage(rdev, *selector);

	if (ret < 0)

		return ret;



	return da9052_reg_update(regulator->da9052,

				 DA9052_BUCKCORE_REG + offset,

				 (1 << info->volt_shift) - 1, *selector);

}



static int da9052_set_ldo_voltage(struct regulator_dev *rdev,

				   int min_uV, int max_uV,

				   unsigned int *selector)

{

	return da9052_regulator_set_voltage_int(rdev, min_uV, max_uV, selector);

}



static int da9052_set_ldo5_6_voltage(struct regulator_dev *rdev,

				      int min_uV, int max_uV,

				      unsigned int *selector)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int ret;



	ret = da9052_regulator_set_voltage_int(rdev, min_uV, max_uV, selector);

	if (ret < 0)

		return ret;



	/* Some LDOs are DVC controlled which requires enabling of

	 * the LDO activate bit to implment the changes on the

	 * LDO output.

	*/

	return da9052_reg_update(regulator->da9052, DA9052_SUPPLY_REG, 0,

				 info->activate_bit);

}



static int da9052_set_dcdc_voltage(struct regulator_dev *rdev,

				    int min_uV, int max_uV,

				    unsigned int *selector)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int ret;



	ret = da9052_regulator_set_voltage_int(rdev, min_uV, max_uV, selector);

	if (ret < 0)

		return ret;



	/* Some DCDCs are DVC controlled which requires enabling of

	 * the DCDC activate bit to implment the changes on the

	 * DCDC output.

	*/

	return da9052_reg_update(regulator->da9052, DA9052_SUPPLY_REG, 0,

				 info->activate_bit);

}



static int da9052_get_regulator_voltage_sel(struct regulator_dev *rdev)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int offset = rdev_get_id(rdev);

	int ret;



	ret = da9052_reg_read(regulator->da9052, DA9052_BUCKCORE_REG + offset);

	if (ret < 0)

		return ret;



	ret &= ((1 << info->volt_shift) - 1);



	return ret;

}



static int da9052_set_buckperi_voltage(struct regulator_dev *rdev, int min_uV,

					int max_uV, unsigned int *selector)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int offset = rdev_get_id(rdev);

	int ret;



	ret = verify_range(info, min_uV, max_uV);

	if (ret < 0)

		return ret;



	if (min_uV < info->min_uV)

		min_uV = info->min_uV;



	if ((regulator->da9052->chip_id == DA9052) &&

	    (min_uV >= DA9052_CONST_3uV))

		*selector = DA9052_BUCK_PERI_REG_MAP_UPTO_3uV +

			    ((min_uV - DA9052_CONST_3uV) /

			    (DA9052_BUCK_PERI_3uV_STEP));

	else

		*selector = (min_uV - info->min_uV) / info->step_uV;



	ret = da9052_list_buckperi_voltage(rdev, *selector);

	if (ret < 0)

		return ret;



	return da9052_reg_update(regulator->da9052,

				 DA9052_BUCKCORE_REG + offset,

				 (1 << info->volt_shift) - 1, *selector);

}



static int da9052_get_buckperi_voltage_sel(struct regulator_dev *rdev)

{

	struct da9052_regulator *regulator = rdev_get_drvdata(rdev);

	struct da9052_regulator_info *info = regulator->info;

	int offset = rdev_get_id(rdev);

	int ret;



	ret = da9052_reg_read(regulator->da9052, DA9052_BUCKCORE_REG + offset);

	if (ret < 0)

		return ret;



	ret &= ((1 << info->volt_shift) - 1);



	return ret;

}



static struct regulator_ops da9052_buckperi_ops = {

	.list_voltage = da9052_list_buckperi_voltage,

	.get_voltage_sel = da9052_get_buckperi_voltage_sel,

	.set_voltage = da9052_set_buckperi_voltage,



	.get_current_limit = da9052_dcdc_get_current_limit,

	.set_current_limit = da9052_dcdc_set_current_limit,



	.is_enabled = da9052_regulator_is_enabled,

	.enable = da9052_regulator_enable,

	.disable = da9052_regulator_disable,

};



static struct regulator_ops da9052_dcdc_ops = {

	.set_voltage = da9052_set_dcdc_voltage,

	.get_current_limit = da9052_dcdc_get_current_limit,

	.set_current_limit = da9052_dcdc_set_current_limit,



	.list_voltage = da9052_list_voltage,

	.get_voltage_sel = da9052_get_regulator_voltage_sel,

	.is_enabled = da9052_regulator_is_enabled,

	.enable = da9052_regulator_enable,

	.disable = da9052_regulator_disable,

};



static struct regulator_ops da9052_ldo5_6_ops = {

	.set_voltage = da9052_set_ldo5_6_voltage,



	.list_voltage = da9052_list_voltage,

	.get_voltage_sel = da9052_get_regulator_voltage_sel,

	.is_enabled = da9052_regulator_is_enabled,

	.enable = da9052_regulator_enable,

	.disable = da9052_regulator_disable,

};



static struct regulator_ops da9052_ldo_ops = {

	.set_voltage = da9052_set_ldo_voltage,



	.list_voltage = da9052_list_voltage,

	.get_voltage_sel = da9052_get_regulator_voltage_sel,

	.is_enabled = da9052_regulator_is_enabled,

	.enable = da9052_regulator_enable,

	.disable = da9052_regulator_disable,

};



#define DA9052_LDO5_6(_id, step, min, max, sbits, ebits, abits) \

{\

	.reg_desc = {\

		.name = "LDO" #_id,\

		.ops = &da9052_ldo5_6_ops,\

		.type = REGULATOR_VOLTAGE,\

		.id = _id,\

		.owner = THIS_MODULE,\

	},\

	.min_uV = (min) * 1000,\

	.max_uV = (max) * 1000,\

	.step_uV = (step) * 1000,\

	.volt_shift = (sbits),\

	.en_bit = (ebits),\

	.activate_bit = (abits),\

}



#define DA9052_LDO(_id, step, min, max, sbits, ebits, abits) \

{\

	.reg_desc = {\

		.name = "LDO" #_id,\

		.ops = &da9052_ldo_ops,\

		.type = REGULATOR_VOLTAGE,\

		.id = _id,\

		.owner = THIS_MODULE,\

	},\

	.min_uV = (min) * 1000,\

	.max_uV = (max) * 1000,\

	.step_uV = (step) * 1000,\

	.volt_shift = (sbits),\

	.en_bit = (ebits),\

	.activate_bit = (abits),\

}



#define DA9052_DCDC(_id, step, min, max, sbits, ebits, abits) \

{\

	.reg_desc = {\

		.name = "BUCK" #_id,\

		.ops = &da9052_dcdc_ops,\

		.type = REGULATOR_VOLTAGE,\

		.id = _id,\

		.owner = THIS_MODULE,\

	},\

	.min_uV = (min) * 1000,\

	.max_uV = (max) * 1000,\

	.step_uV = (step) * 1000,\

	.volt_shift = (sbits),\

	.en_bit = (ebits),\

	.activate_bit = (abits),\

}



#define DA9052_BUCKPERI(_id, step, min, max, sbits, ebits, abits) \

{\

	.reg_desc = {\

		.name = "BUCK" #_id,\

		.ops = &da9052_buckperi_ops,\

		.type = REGULATOR_VOLTAGE,\

		.id = _id,\

		.owner = THIS_MODULE,\

	},\

	.min_uV = (min) * 1000,\

	.max_uV = (max) * 1000,\

	.step_uV = (step) * 1000,\

	.volt_shift = (sbits),\

	.en_bit = (ebits),\

	.activate_bit = (abits),\

}



struct da9052_regulator_info da9052_regulator_info[] = {

	/* Buck1 - 4 */

	DA9052_DCDC(0, 25, 500, 2075, 6, 6, DA9052_SUPPLY_VBCOREGO),

	DA9052_DCDC(1, 25, 500, 2075, 6, 6, DA9052_SUPPLY_VBPROGO),

	DA9052_DCDC(2, 25, 925, 2500, 6, 6, DA9052_SUPPLY_VBMEMGO),

	DA9052_BUCKPERI(3, 50, 1800, 3600, 5, 6, 0),

	/* LD01 - LDO10 */

	DA9052_LDO(4, 50, 600, 1800, 5, 6, 0),

	DA9052_LDO5_6(5, 25, 600, 1800, 6, 6, DA9052_SUPPLY_VLDO2GO),

	DA9052_LDO5_6(6, 25, 1725, 3300, 6, 6, DA9052_SUPPLY_VLDO3GO),

	DA9052_LDO(7, 25, 1725, 3300, 6, 6, 0),

	DA9052_LDO(8, 50, 1200, 3600, 6, 6, 0),

	DA9052_LDO(9, 50, 1200, 3600, 6, 6, 0),

	DA9052_LDO(10, 50, 1200, 3600, 6, 6, 0),

	DA9052_LDO(11, 50, 1200, 3600, 6, 6, 0),

	DA9052_LDO(12, 50, 1250, 3650, 6, 6, 0),

	DA9052_LDO(13, 50, 1200, 3600, 6, 6, 0),

};



struct da9052_regulator_info da9053_regulator_info[] = {

	/* Buck1 - 4 */

	DA9052_DCDC(0, 25, 500, 2075, 6, 6, DA9052_SUPPLY_VBCOREGO),

	DA9052_DCDC(1, 25, 500, 2075, 6, 6, DA9052_SUPPLY_VBPROGO),

	DA9052_DCDC(2, 25, 925, 2500, 6, 6, DA9052_SUPPLY_VBMEMGO),

	DA9052_BUCKPERI(3, 25, 925, 2500, 6, 6, 0),

	/* LD01 - LDO10 */

	DA9052_LDO(4, 50, 600, 1800, 5, 6, 0),

	DA9052_LDO5_6(5, 25, 600, 1800, 6, 6, DA9052_SUPPLY_VLDO2GO),

	DA9052_LDO5_6(6, 25, 1725, 3300, 6, 6, DA9052_SUPPLY_VLDO3GO),

	DA9052_LDO(7, 25, 1725, 3300, 6, 6, 0),

	DA9052_LDO(8, 50, 1200, 3600, 6, 6, 0),

	DA9052_LDO(9, 50, 1200, 3600, 6, 6, 0),

	DA9052_LDO(10, 50, 1200, 3600, 6, 6, 0),

	DA9052_LDO(11, 50, 1200, 3600, 6, 6, 0),

	DA9052_LDO(12, 50, 1250, 3650, 6, 6, 0),

	DA9052_LDO(13, 50, 1200, 3600, 6, 6, 0),

};



static inline struct da9052_regulator_info *find_regulator_info(u8 chip_id,

								 int id)

{

	struct da9052_regulator_info *info;

	int i;



	if (chip_id == DA9052) {

		for (i = 0; i < ARRAY_SIZE(da9052_regulator_info); i++) {

			info = &da9052_regulator_info[i];

			if (info->reg_desc.id == id)

				return info;

		}

	} else {

		for (i = 0; i < ARRAY_SIZE(da9053_regulator_info); i++) {

			info = &da9053_regulator_info[i];

			if (info->reg_desc.id == id)

				return info;

		}

	}



	return NULL;

}



static int __devinit da9052_regulator_probe(struct platform_device *pdev)

{

	struct da9052_regulator *regulator;

	struct da9052 *da9052;

	struct da9052_pdata *pdata;

	int ret;



	regulator = kzalloc(sizeof(struct da9052_regulator), GFP_KERNEL);

	if (!regulator)

		return -ENOMEM;



	da9052 = dev_get_drvdata(pdev->dev.parent);

	pdata = da9052->dev->platform_data;

	regulator->da9052 = da9052;



	regulator->info = find_regulator_info(regulator->da9052->chip_id,

					      pdev->id);

	if (regulator->info == NULL) {

		dev_err(&pdev->dev, "invalid regulator ID specified\n");

		ret = -EINVAL;

		goto err;

	}

	regulator->rdev = regulator_register(&regulator->info->reg_desc,

					     &pdev->dev,

					     pdata->regulators[pdev->id],

					     regulator);

	if (IS_ERR(regulator->rdev)) {

		dev_err(&pdev->dev, "failed to register regulator %s\n",

			regulator->info->reg_desc.name);

		ret = PTR_ERR(regulator->rdev);

		goto err;

	}



	platform_set_drvdata(pdev, regulator);



	return 0;

err:

	kfree(regulator);

	return ret;

}



static int __devexit da9052_regulator_remove(struct platform_device *pdev)

{

	struct da9052_regulator *regulator = platform_get_drvdata(pdev);



	regulator_unregister(regulator->rdev);

	kfree(regulator);



	return 0;

}



static struct platform_driver da9052_regulator_driver = {

	.probe = da9052_regulator_probe,

	.remove = __devexit_p(da9052_regulator_remove),

	.driver = {

		.name = "da9052-regulator",

		.owner = THIS_MODULE,

	},

};



static int __init da9052_regulator_init(void)

{

	return platform_driver_register(&da9052_regulator_driver);

}

subsys_initcall(da9052_regulator_init);



static void __exit da9052_regulator_exit(void)

{

	platform_driver_unregister(&da9052_regulator_driver);

}

module_exit(da9052_regulator_exit);



MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");

MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9052 PMIC");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:da9052-regulator");

CRA Git | Maintained and supported by SUSTech CRA and CCSE