[mirror_ubuntu-hirsute-kernel.git] / drivers / regulator / ab8500.c

/*
 * Copyright (C) ST-Ericsson SA 2010
 *
 * License Terms: GNU General Public License v2
 *
 * Author: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
 *
 * AB8500 peripheral regulators
 *
 * AB8500 supports the following regulators,
 * LDOs - VAUDIO, VANAMIC2/2, VDIGMIC, VINTCORE12, VTVOUT,
 *        VAUX1/2/3, VANA
 *
 * for DB8500 cut 1.0 and previous versions of the silicon, all accesses
 * to registers are through the DB8500 SPI. In cut 1.1 onwards, these
 * accesses are through the DB8500 PRCMU I2C
 *
 */
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/mfd/ab8500.h>
#include <linux/mfd/abx500.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/ab8500.h>

/**
 * struct ab8500_regulator_info - ab8500 regulator information
 * @desc: regulator description
 * @regulator_dev: regulator device
 * @max_uV: maximum voltage (for variable voltage supplies)
 * @min_uV: minimum voltage (for variable voltage supplies)
 * @fixed_uV: typical voltage (for fixed voltage supplies)
 * @update_bank: bank to control on/off
 * @update_reg: register to control on/off
 * @mask: mask to enable/disable regulator
 * @enable: bits to enable the regulator in normal(high power) mode
 * @voltage_bank: bank to control regulator voltage
 * @voltage_reg: register to control regulator voltage
 * @voltage_mask: mask to control regulator voltage
 * @supported_voltages: supported voltage table
 * @voltages_len: number of supported voltages for the regulator
 */
struct ab8500_regulator_info {
	struct device		*dev;
	struct regulator_desc	desc;
	struct regulator_dev	*regulator;
	int max_uV;
	int min_uV;
	int fixed_uV;
	u8 update_bank;
	u8 update_reg;
	u8 mask;
	u8 enable;
	u8 voltage_bank;
	u8 voltage_reg;
	u8 voltage_mask;
	int const *supported_voltages;
	int voltages_len;
};

/* voltage tables for the vauxn/vintcore supplies */
static const int ldo_vauxn_voltages[] = {
	1100000,
	1200000,
	1300000,
	1400000,
	1500000,
	1800000,
	1850000,
	1900000,
	2500000,
	2650000,
	2700000,
	2750000,
	2800000,
	2900000,
	3000000,
	3300000,
};

static const int ldo_vaux3_voltages[] = {
	1200000,
	1500000,
	1800000,
	2100000,
	2500000,
	2750000,
	2790000,
	2910000,
};

static const int ldo_vintcore_voltages[] = {
	1200000,
	1225000,
	1250000,
	1275000,
	1300000,
	1325000,
	1350000,
};

static int ab8500_regulator_enable(struct regulator_dev *rdev)
{
	int regulator_id, ret;
	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);

	regulator_id = rdev_get_id(rdev);
	if (regulator_id >= AB8500_NUM_REGULATORS)
		return -EINVAL;

	ret = abx500_mask_and_set_register_interruptible(info->dev,
		info->update_bank, info->update_reg, info->mask, info->enable);
	if (ret < 0)
		dev_err(rdev_get_dev(rdev),
			"couldn't set enable bits for regulator\n");
	return ret;
}

static int ab8500_regulator_disable(struct regulator_dev *rdev)
{
	int regulator_id, ret;
	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);

	regulator_id = rdev_get_id(rdev);
	if (regulator_id >= AB8500_NUM_REGULATORS)
		return -EINVAL;

	ret = abx500_mask_and_set_register_interruptible(info->dev,
		info->update_bank, info->update_reg, info->mask, 0x0);
	if (ret < 0)
		dev_err(rdev_get_dev(rdev),
			"couldn't set disable bits for regulator\n");
	return ret;
}

static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
{
	int regulator_id, ret;
	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
	u8 value;

	regulator_id = rdev_get_id(rdev);
	if (regulator_id >= AB8500_NUM_REGULATORS)
		return -EINVAL;

	ret = abx500_get_register_interruptible(info->dev,
		info->update_bank, info->update_reg, &value);
	if (ret < 0) {
		dev_err(rdev_get_dev(rdev),
			"couldn't read 0x%x register\n", info->update_reg);
		return ret;
	}

	if (value & info->mask)
		return true;
	else
		return false;
}

static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
{
	int regulator_id;
	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);

	regulator_id = rdev_get_id(rdev);
	if (regulator_id >= AB8500_NUM_REGULATORS)
		return -EINVAL;

	/* return the uV for the fixed regulators */
	if (info->fixed_uV)
		return info->fixed_uV;

	if (selector >= info->voltages_len)
		return -EINVAL;

	return info->supported_voltages[selector];
}

static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
{
	int regulator_id, ret;
	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
	u8 value;

	regulator_id = rdev_get_id(rdev);
	if (regulator_id >= AB8500_NUM_REGULATORS)
		return -EINVAL;

	ret = abx500_get_register_interruptible(info->dev, info->voltage_bank,
		info->voltage_reg, &value);
	if (ret < 0) {
		dev_err(rdev_get_dev(rdev),
			"couldn't read voltage reg for regulator\n");
		return ret;
	}

	/* vintcore has a different layout */
	value &= info->voltage_mask;
	if (regulator_id == AB8500_LDO_INTCORE)
		ret = info->supported_voltages[value >> 0x3];
	else
		ret = info->supported_voltages[value];

	return ret;
}

static int ab8500_get_best_voltage_index(struct regulator_dev *rdev,
		int min_uV, int max_uV)
{
	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
	int i;

	/* check the supported voltage */
	for (i = 0; i < info->voltages_len; i++) {
		if ((info->supported_voltages[i] >= min_uV) &&
		    (info->supported_voltages[i] <= max_uV))
			return i;
	}

	return -EINVAL;
}

static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
					int min_uV, int max_uV,
					unsigned *selector)
{
	int regulator_id, ret;
	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);

	regulator_id = rdev_get_id(rdev);
	if (regulator_id >= AB8500_NUM_REGULATORS)
		return -EINVAL;

	/* get the appropriate voltages within the range */
	ret = ab8500_get_best_voltage_index(rdev, min_uV, max_uV);
	if (ret < 0) {
		dev_err(rdev_get_dev(rdev),
				"couldn't get best voltage for regulator\n");
		return ret;
	}

	*selector = ret;

	/* set the registers for the request */
	ret = abx500_mask_and_set_register_interruptible(info->dev,
		info->voltage_bank, info->voltage_reg,
		info->voltage_mask, (u8)ret);
	if (ret < 0)
		dev_err(rdev_get_dev(rdev),
		"couldn't set voltage reg for regulator\n");

	return ret;
}

static struct regulator_ops ab8500_regulator_ops = {
	.enable		= ab8500_regulator_enable,
	.disable	= ab8500_regulator_disable,
	.is_enabled	= ab8500_regulator_is_enabled,
	.get_voltage	= ab8500_regulator_get_voltage,
	.set_voltage	= ab8500_regulator_set_voltage,
	.list_voltage	= ab8500_list_voltage,
};

static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
{
	int regulator_id;
	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);

	regulator_id = rdev_get_id(rdev);
	if (regulator_id >= AB8500_NUM_REGULATORS)
		return -EINVAL;

	return info->fixed_uV;
}

static struct regulator_ops ab8500_ldo_fixed_ops = {
	.enable		= ab8500_regulator_enable,
	.disable	= ab8500_regulator_disable,
	.is_enabled	= ab8500_regulator_is_enabled,
	.get_voltage	= ab8500_fixed_get_voltage,
	.list_voltage	= ab8500_list_voltage,
};

#define AB8500_LDO(_id, min, max, bank, reg, reg_mask,		\
		reg_enable, volt_bank, volt_reg, volt_mask,	\
		voltages, len_volts)				\
{								\
	.desc	= {						\
		.name	= "LDO-" #_id,				\
		.ops	= &ab8500_regulator_ops,		\
		.type	= REGULATOR_VOLTAGE,			\
		.id	= AB8500_LDO_##_id,			\
		.owner	= THIS_MODULE,				\
	},							\
	.min_uV		= (min) * 1000,				\
	.max_uV		= (max) * 1000,				\
	.update_bank	= bank,					\
	.update_reg	= reg,					\
	.mask		= reg_mask,				\
	.enable		= reg_enable,				\
	.voltage_bank	= volt_bank,				\
	.voltage_reg	= volt_reg,				\
	.voltage_mask	= volt_mask,				\
	.supported_voltages = voltages,				\
	.voltages_len	= len_volts,				\
	.fixed_uV	= 0,					\
}

#define AB8500_FIXED_LDO(_id, fixed, bank, reg,		\
			reg_mask, reg_enable)		\
{							\
	.desc	= {					\
		.name	= "LDO-" #_id,			\
		.ops	= &ab8500_ldo_fixed_ops,	\
		.type	= REGULATOR_VOLTAGE,		\
		.id	= AB8500_LDO_##_id,		\
		.owner	= THIS_MODULE,			\
	},						\
	.fixed_uV	= fixed * 1000,			\
	.update_bank	= bank,				\
	.update_reg	= reg,				\
	.mask		= reg_mask,			\
	.enable		= reg_enable,			\
}

static struct ab8500_regulator_info ab8500_regulator_info[] = {
	/*
	 * Variable Voltage LDOs
	 * name, min uV, max uV, ctrl bank, ctrl reg, reg mask, enable mask,
	 *      volt ctrl bank, volt ctrl reg, volt ctrl mask, volt table,
	 *      num supported volts
	 */
	AB8500_LDO(AUX1, 1100, 3300, 0x04, 0x09, 0x3, 0x1, 0x04, 0x1f, 0xf,
			ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
	AB8500_LDO(AUX2, 1100, 3300, 0x04, 0x09, 0xc, 0x4, 0x04, 0x20, 0xf,
			ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
	AB8500_LDO(AUX3, 1100, 3300, 0x04, 0x0a, 0x3, 0x1, 0x04, 0x21, 0x7,
			ldo_vaux3_voltages, ARRAY_SIZE(ldo_vaux3_voltages)),
	AB8500_LDO(INTCORE, 1100, 3300, 0x03, 0x80, 0x44, 0x4, 0x03, 0x80, 0x38,
		ldo_vintcore_voltages, ARRAY_SIZE(ldo_vintcore_voltages)),

	/*
	 * Fixed Voltage LDOs
	 *		 name,	o/p uV, ctrl bank, ctrl reg, enable, disable
	 */
	AB8500_FIXED_LDO(TVOUT,	  2000, 0x03,      0x80,     0x82,    0x2),
	AB8500_FIXED_LDO(AUDIO,   2000, 0x03,      0x83,     0x2,    0x2),
	AB8500_FIXED_LDO(ANAMIC1, 2050, 0x03,      0x83,     0x08,    0x08),
	AB8500_FIXED_LDO(ANAMIC2, 2050, 0x03,      0x83,     0x10,    0x10),
	AB8500_FIXED_LDO(DMIC,    1800, 0x03,      0x83,     0x04,   0x04),
	AB8500_FIXED_LDO(ANA,     1200, 0x04,      0x06,     0xc,    0x4),
};

static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
{
	struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
	struct ab8500_platform_data *pdata;
	int i, err;

	if (!ab8500) {
		dev_err(&pdev->dev, "null mfd parent\n");
		return -EINVAL;
	}
	pdata = dev_get_platdata(ab8500->dev);

	/* make sure the platform data has the correct size */
	if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
		dev_err(&pdev->dev, "platform configuration error\n");
		return -EINVAL;
	}

	/* register all regulators */
	for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
		struct ab8500_regulator_info *info = NULL;

		/* assign per-regulator data */
		info = &ab8500_regulator_info[i];
		info->dev = &pdev->dev;

		/* fix for hardware before ab8500v2.0 */
		if (abx500_get_chip_id(info->dev) < 0x20) {
			if (info->desc.id == AB8500_LDO_AUX3) {
				info->desc.n_voltages =
					ARRAY_SIZE(ldo_vauxn_voltages);
				info->supported_voltages = ldo_vauxn_voltages;
				info->voltages_len =
					ARRAY_SIZE(ldo_vauxn_voltages);
				info->voltage_mask = 0xf;
			}
		}

		/* register regulator with framework */
		info->regulator = regulator_register(&info->desc, &pdev->dev,
				&pdata->regulator[i], info);
		if (IS_ERR(info->regulator)) {
			err = PTR_ERR(info->regulator);
			dev_err(&pdev->dev, "failed to register regulator %s\n",
					info->desc.name);
			/* when we fail, un-register all earlier regulators */
			while (--i >= 0) {
				info = &ab8500_regulator_info[i];
				regulator_unregister(info->regulator);
			}
			return err;
		}
	}

	return 0;
}

static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
		struct ab8500_regulator_info *info = NULL;
		info = &ab8500_regulator_info[i];
		regulator_unregister(info->regulator);
	}

	return 0;
}

static struct platform_driver ab8500_regulator_driver = {
	.probe = ab8500_regulator_probe,
	.remove = __devexit_p(ab8500_regulator_remove),
	.driver         = {
		.name   = "ab8500-regulator",
		.owner  = THIS_MODULE,
	},
};

static int __init ab8500_regulator_init(void)
{
	int ret;

	ret = platform_driver_register(&ab8500_regulator_driver);
	if (ret != 0)
		pr_err("Failed to register ab8500 regulator: %d\n", ret);

	return ret;
}
subsys_initcall(ab8500_regulator_init);

static void __exit ab8500_regulator_exit(void)
{
	platform_driver_unregister(&ab8500_regulator_driver);
}
module_exit(ab8500_regulator_exit);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC");
MODULE_ALIAS("platform:ab8500-regulator");
Commit	Line	Data
c789ca20 SI	1	/*
	2	* Copyright (C) ST-Ericsson SA 2010
	3	*
	4	* License Terms: GNU General Public License v2
	5	*
	6	* Author: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
	7	*
	8	* AB8500 peripheral regulators
	9	*
	10	* AB8500 supports the following regulators,
	11	* LDOs - VAUDIO, VANAMIC2/2, VDIGMIC, VINTCORE12, VTVOUT,
	12	* VAUX1/2/3, VANA
	13	*
	14	* for DB8500 cut 1.0 and previous versions of the silicon, all accesses
	15	* to registers are through the DB8500 SPI. In cut 1.1 onwards, these
	16	* accesses are through the DB8500 PRCMU I2C
	17	*
	18	*/
	19	#include <linux/init.h>
	20	#include <linux/kernel.h>
	21	#include <linux/err.h>
	22	#include <linux/platform_device.h>
	23	#include <linux/mfd/ab8500.h>
47c16975	24	#include <linux/mfd/abx500.h>
c789ca20 SI	25	#include <linux/regulator/driver.h>
	26	#include <linux/regulator/machine.h>
	27	#include <linux/regulator/ab8500.h>
	28
	29	/**
	30	* struct ab8500_regulator_info - ab8500 regulator information
	31	* @desc: regulator description
c789ca20 SI	32	* @regulator_dev: regulator device
	33	* @max_uV: maximum voltage (for variable voltage supplies)
	34	* @min_uV: minimum voltage (for variable voltage supplies)
	35	* @fixed_uV: typical voltage (for fixed voltage supplies)
47c16975	36	* @update_bank: bank to control on/off
c789ca20 SI	37	* @update_reg: register to control on/off
	38	* @mask: mask to enable/disable regulator
	39	* @enable: bits to enable the regulator in normal(high power) mode
47c16975	40	* @voltage_bank: bank to control regulator voltage
c789ca20 SI	41	* @voltage_reg: register to control regulator voltage
	42	* @voltage_mask: mask to control regulator voltage
	43	* @supported_voltages: supported voltage table
	44	* @voltages_len: number of supported voltages for the regulator
	45	*/
	46	struct ab8500_regulator_info {
	47	struct device *dev;
	48	struct regulator_desc desc;
c789ca20 SI	49	struct regulator_dev *regulator;
	50	int max_uV;
	51	int min_uV;
	52	int fixed_uV;
47c16975 MW	53	u8 update_bank;
	54	u8 update_reg;
	55	u8 mask;
	56	u8 enable;
	57	u8 voltage_bank;
	58	u8 voltage_reg;
	59	u8 voltage_mask;
c789ca20 SI	60	int const *supported_voltages;
	61	int voltages_len;
	62	};
	63
	64	/* voltage tables for the vauxn/vintcore supplies */
	65	static const int ldo_vauxn_voltages[] = {
	66	1100000,
	67	1200000,
	68	1300000,
	69	1400000,
	70	1500000,
	71	1800000,
	72	1850000,
	73	1900000,
	74	2500000,
	75	2650000,
	76	2700000,
	77	2750000,
	78	2800000,
	79	2900000,
	80	3000000,
	81	3300000,
	82	};
	83
2b75151a BJ	84	static const int ldo_vaux3_voltages[] = {
	85	1200000,
	86	1500000,
	87	1800000,
	88	2100000,
	89	2500000,
	90	2750000,
	91	2790000,
	92	2910000,
	93	};
	94
c789ca20 SI	95	static const int ldo_vintcore_voltages[] = {
	96	1200000,
	97	1225000,
	98	1250000,
	99	1275000,
	100	1300000,
	101	1325000,
	102	1350000,
	103	};
	104
	105	static int ab8500_regulator_enable(struct regulator_dev *rdev)
	106	{
	107	int regulator_id, ret;
	108	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
	109
	110	regulator_id = rdev_get_id(rdev);
	111	if (regulator_id >= AB8500_NUM_REGULATORS)
	112	return -EINVAL;
	113
47c16975 MW	114	ret = abx500_mask_and_set_register_interruptible(info->dev,
47c16975 MW	115	info->update_bank, info->update_reg, info->mask, info->enable);
c789ca20 SI	116	if (ret < 0)
	117	dev_err(rdev_get_dev(rdev),
	118	"couldn't set enable bits for regulator\n");
	119	return ret;
	120	}
	121
	122	static int ab8500_regulator_disable(struct regulator_dev *rdev)
	123	{
	124	int regulator_id, ret;
	125	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
	126
	127	regulator_id = rdev_get_id(rdev);
	128	if (regulator_id >= AB8500_NUM_REGULATORS)
	129	return -EINVAL;
	130
47c16975 MW	131	ret = abx500_mask_and_set_register_interruptible(info->dev,
47c16975 MW	132	info->update_bank, info->update_reg, info->mask, 0x0);
c789ca20 SI	133	if (ret < 0)
	134	dev_err(rdev_get_dev(rdev),
	135	"couldn't set disable bits for regulator\n");
	136	return ret;
	137	}
	138
	139	static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
	140	{
	141	int regulator_id, ret;
	142	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
47c16975	143	u8 value;
c789ca20 SI	144
	145	regulator_id = rdev_get_id(rdev);
	146	if (regulator_id >= AB8500_NUM_REGULATORS)
	147	return -EINVAL;
	148
47c16975 MW	149	ret = abx500_get_register_interruptible(info->dev,
47c16975 MW	150	info->update_bank, info->update_reg, &value);
c789ca20 SI	151	if (ret < 0) {
	152	dev_err(rdev_get_dev(rdev),
	153	"couldn't read 0x%x register\n", info->update_reg);
	154	return ret;
	155	}
	156
47c16975	157	if (value & info->mask)
c789ca20 SI	158	return true;
	159	else
	160	return false;
	161	}
	162
	163	static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
	164	{
	165	int regulator_id;
	166	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
	167
	168	regulator_id = rdev_get_id(rdev);
	169	if (regulator_id >= AB8500_NUM_REGULATORS)
	170	return -EINVAL;
	171
	172	/* return the uV for the fixed regulators */
	173	if (info->fixed_uV)
	174	return info->fixed_uV;
	175
49990e6e	176	if (selector >= info->voltages_len)
c789ca20 SI	177	return -EINVAL;
	178
	179	return info->supported_voltages[selector];
	180	}
	181
	182	static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
	183	{
47c16975	184	int regulator_id, ret;
c789ca20	185	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
47c16975	186	u8 value;
c789ca20 SI	187
	188	regulator_id = rdev_get_id(rdev);
	189	if (regulator_id >= AB8500_NUM_REGULATORS)
	190	return -EINVAL;
	191
47c16975 MW	192	ret = abx500_get_register_interruptible(info->dev, info->voltage_bank,
47c16975 MW	193	info->voltage_reg, &value);
c789ca20 SI	194	if (ret < 0) {
	195	dev_err(rdev_get_dev(rdev),
	196	"couldn't read voltage reg for regulator\n");
	197	return ret;
	198	}
	199
	200	/* vintcore has a different layout */
47c16975	201	value &= info->voltage_mask;
c789ca20	202	if (regulator_id == AB8500_LDO_INTCORE)
47c16975	203	ret = info->supported_voltages[value >> 0x3];
c789ca20	204	else
47c16975	205	ret = info->supported_voltages[value];
c789ca20 SI	206
	207	return ret;
	208	}
	209
	210	static int ab8500_get_best_voltage_index(struct regulator_dev *rdev,
	211	int min_uV, int max_uV)
	212	{
	213	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
	214	int i;
	215
	216	/* check the supported voltage */
	217	for (i = 0; i < info->voltages_len; i++) {
	218	if ((info->supported_voltages[i] >= min_uV) &&
	219	(info->supported_voltages[i] <= max_uV))
	220	return i;
	221	}
	222
	223	return -EINVAL;
	224	}
	225
	226	static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
3a93f2a9 MB	227	int min_uV, int max_uV,
3a93f2a9 MB	228	unsigned *selector)
c789ca20 SI	229	{
	230	int regulator_id, ret;
	231	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
	232
	233	regulator_id = rdev_get_id(rdev);
	234	if (regulator_id >= AB8500_NUM_REGULATORS)
	235	return -EINVAL;
	236
	237	/* get the appropriate voltages within the range */
	238	ret = ab8500_get_best_voltage_index(rdev, min_uV, max_uV);
	239	if (ret < 0) {
	240	dev_err(rdev_get_dev(rdev),
	241	"couldn't get best voltage for regulator\n");
	242	return ret;
	243	}
	244
3a93f2a9 MB	245	*selector = ret;
3a93f2a9 MB	246
c789ca20	247	/* set the registers for the request */
47c16975 MW	248	ret = abx500_mask_and_set_register_interruptible(info->dev,
	249	info->voltage_bank, info->voltage_reg,
	250	info->voltage_mask, (u8)ret);
c789ca20 SI	251	if (ret < 0)
	252	dev_err(rdev_get_dev(rdev),
	253	"couldn't set voltage reg for regulator\n");
	254
	255	return ret;
	256	}
	257
	258	static struct regulator_ops ab8500_regulator_ops = {
	259	.enable = ab8500_regulator_enable,
	260	.disable = ab8500_regulator_disable,
	261	.is_enabled = ab8500_regulator_is_enabled,
	262	.get_voltage = ab8500_regulator_get_voltage,
	263	.set_voltage = ab8500_regulator_set_voltage,
	264	.list_voltage = ab8500_list_voltage,
	265	};
	266
	267	static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
	268	{
	269	int regulator_id;
	270	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
	271
	272	regulator_id = rdev_get_id(rdev);
	273	if (regulator_id >= AB8500_NUM_REGULATORS)
	274	return -EINVAL;
	275
	276	return info->fixed_uV;
	277	}
	278
	279	static struct regulator_ops ab8500_ldo_fixed_ops = {
	280	.enable = ab8500_regulator_enable,
	281	.disable = ab8500_regulator_disable,
	282	.is_enabled = ab8500_regulator_is_enabled,
	283	.get_voltage = ab8500_fixed_get_voltage,
	284	.list_voltage = ab8500_list_voltage,
	285	};
	286
47c16975 MW	287	#define AB8500_LDO(_id, min, max, bank, reg, reg_mask, \
	288	reg_enable, volt_bank, volt_reg, volt_mask, \
	289	voltages, len_volts) \
c789ca20 SI	290	{ \
	291	.desc = { \
	292	.name = "LDO-" #_id, \
	293	.ops = &ab8500_regulator_ops, \
	294	.type = REGULATOR_VOLTAGE, \
	295	.id = AB8500_LDO_##_id, \
	296	.owner = THIS_MODULE, \
	297	}, \
	298	.min_uV = (min) * 1000, \
	299	.max_uV = (max) * 1000, \
47c16975	300	.update_bank = bank, \
c789ca20 SI	301	.update_reg = reg, \
	302	.mask = reg_mask, \
	303	.enable = reg_enable, \
47c16975	304	.voltage_bank = volt_bank, \
c789ca20 SI	305	.voltage_reg = volt_reg, \
	306	.voltage_mask = volt_mask, \
	307	.supported_voltages = voltages, \
	308	.voltages_len = len_volts, \
	309	.fixed_uV = 0, \
	310	}
	311
47c16975 MW	312	#define AB8500_FIXED_LDO(_id, fixed, bank, reg, \
47c16975 MW	313	reg_mask, reg_enable) \
c789ca20 SI	314	{ \
	315	.desc = { \
	316	.name = "LDO-" #_id, \
	317	.ops = &ab8500_ldo_fixed_ops, \
	318	.type = REGULATOR_VOLTAGE, \
	319	.id = AB8500_LDO_##_id, \
	320	.owner = THIS_MODULE, \
	321	}, \
	322	.fixed_uV = fixed * 1000, \
47c16975	323	.update_bank = bank, \
c789ca20 SI	324	.update_reg = reg, \
	325	.mask = reg_mask, \
	326	.enable = reg_enable, \
	327	}
	328
	329	static struct ab8500_regulator_info ab8500_regulator_info[] = {
	330	/*
	331	* Variable Voltage LDOs
47c16975 MW	332	* name, min uV, max uV, ctrl bank, ctrl reg, reg mask, enable mask,
	333	* volt ctrl bank, volt ctrl reg, volt ctrl mask, volt table,
	334	* num supported volts
c789ca20	335	*/
47c16975	336	AB8500_LDO(AUX1, 1100, 3300, 0x04, 0x09, 0x3, 0x1, 0x04, 0x1f, 0xf,
c789ca20	337	ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
47c16975	338	AB8500_LDO(AUX2, 1100, 3300, 0x04, 0x09, 0xc, 0x4, 0x04, 0x20, 0xf,
c789ca20	339	ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
2b75151a BJ	340	AB8500_LDO(AUX3, 1100, 3300, 0x04, 0x0a, 0x3, 0x1, 0x04, 0x21, 0x7,
2b75151a BJ	341	ldo_vaux3_voltages, ARRAY_SIZE(ldo_vaux3_voltages)),
65e03ed2	342	AB8500_LDO(INTCORE, 1100, 3300, 0x03, 0x80, 0x44, 0x4, 0x03, 0x80, 0x38,
c789ca20 SI	343	ldo_vintcore_voltages, ARRAY_SIZE(ldo_vintcore_voltages)),
	344
	345	/*
	346	* Fixed Voltage LDOs
47c16975	347	* name, o/p uV, ctrl bank, ctrl reg, enable, disable
c789ca20	348	*/
65e03ed2	349	AB8500_FIXED_LDO(TVOUT, 2000, 0x03, 0x80, 0x82, 0x2),
47c16975	350	AB8500_FIXED_LDO(AUDIO, 2000, 0x03, 0x83, 0x2, 0x2),
65e03ed2 BJ	351	AB8500_FIXED_LDO(ANAMIC1, 2050, 0x03, 0x83, 0x08, 0x08),
	352	AB8500_FIXED_LDO(ANAMIC2, 2050, 0x03, 0x83, 0x10, 0x10),
	353	AB8500_FIXED_LDO(DMIC, 1800, 0x03, 0x83, 0x04, 0x04),
	354	AB8500_FIXED_LDO(ANA, 1200, 0x04, 0x06, 0xc, 0x4),
c789ca20 SI	355	};
c789ca20 SI	356
c789ca20 SI	357	static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
	358	{
	359	struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
af54decd	360	struct ab8500_platform_data *pdata;
c789ca20 SI	361	int i, err;
	362
	363	if (!ab8500) {
	364	dev_err(&pdev->dev, "null mfd parent\n");
	365	return -EINVAL;
	366	}
af54decd	367	pdata = dev_get_platdata(ab8500->dev);
c789ca20	368
cb189b07 BJ	369	/* make sure the platform data has the correct size */
	370	if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
	371	dev_err(&pdev->dev, "platform configuration error\n");
	372	return -EINVAL;
	373	}
	374
c789ca20 SI	375	/* register all regulators */
	376	for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
	377	struct ab8500_regulator_info *info = NULL;
	378
	379	/* assign per-regulator data */
	380	info = &ab8500_regulator_info[i];
	381	info->dev = &pdev->dev;
c789ca20	382
2b75151a BJ	383	/* fix for hardware before ab8500v2.0 */
	384	if (abx500_get_chip_id(info->dev) < 0x20) {
	385	if (info->desc.id == AB8500_LDO_AUX3) {
	386	info->desc.n_voltages =
	387	ARRAY_SIZE(ldo_vauxn_voltages);
	388	info->supported_voltages = ldo_vauxn_voltages;
	389	info->voltages_len =
	390	ARRAY_SIZE(ldo_vauxn_voltages);
	391	info->voltage_mask = 0xf;
	392	}
	393	}
	394
	395	/* register regulator with framework */
c789ca20	396	info->regulator = regulator_register(&info->desc, &pdev->dev,
cb189b07	397	&pdata->regulator[i], info);
c789ca20 SI	398	if (IS_ERR(info->regulator)) {
	399	err = PTR_ERR(info->regulator);
	400	dev_err(&pdev->dev, "failed to register regulator %s\n",
	401	info->desc.name);
	402	/* when we fail, un-register all earlier regulators */
d4876a3b	403	while (--i >= 0) {
c789ca20 SI	404	info = &ab8500_regulator_info[i];
c789ca20 SI	405	regulator_unregister(info->regulator);
c789ca20 SI	406	}
	407	return err;
	408	}
	409	}
	410
	411	return 0;
	412	}
	413
	414	static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
	415	{
	416	int i;
	417
	418	for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
	419	struct ab8500_regulator_info *info = NULL;
	420	info = &ab8500_regulator_info[i];
	421	regulator_unregister(info->regulator);
	422	}
	423
	424	return 0;
	425	}
	426
	427	static struct platform_driver ab8500_regulator_driver = {
	428	.probe = ab8500_regulator_probe,
	429	.remove = __devexit_p(ab8500_regulator_remove),
	430	.driver = {
	431	.name = "ab8500-regulator",
	432	.owner = THIS_MODULE,
	433	},
	434	};
	435
	436	static int __init ab8500_regulator_init(void)
	437	{
	438	int ret;
	439
	440	ret = platform_driver_register(&ab8500_regulator_driver);
	441	if (ret != 0)
	442	pr_err("Failed to register ab8500 regulator: %d\n", ret);
	443
	444	return ret;
	445	}
	446	subsys_initcall(ab8500_regulator_init);
	447
	448	static void __exit ab8500_regulator_exit(void)
	449	{
	450	platform_driver_unregister(&ab8500_regulator_driver);
	451	}
	452	module_exit(ab8500_regulator_exit);
	453
	454	MODULE_LICENSE("GPL v2");
	455	MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
	456	MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC");
	457	MODULE_ALIAS("platform:ab8500-regulator");