[deliverable/linux.git] / drivers / regulator / ab3100.c

/*
 * drivers/regulator/ab3100.c
 *
 * Copyright (C) 2008-2009 ST-Ericsson AB
 * License terms: GNU General Public License (GPL) version 2
 * Low-level control of the AB3100 IC Low Dropout (LDO)
 * regulators, external regulator and buck converter
 * Author: Mattias Wallin <mattias.wallin@stericsson.com>
 * Author: Linus Walleij <linus.walleij@stericsson.com>
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/mfd/abx500.h>

/* LDO registers and some handy masking definitions for AB3100 */
#define AB3100_LDO_A		0x40
#define AB3100_LDO_C		0x41
#define AB3100_LDO_D		0x42
#define AB3100_LDO_E		0x43
#define AB3100_LDO_E_SLEEP	0x44
#define AB3100_LDO_F		0x45
#define AB3100_LDO_G		0x46
#define AB3100_LDO_H		0x47
#define AB3100_LDO_H_SLEEP_MODE	0
#define AB3100_LDO_H_SLEEP_EN	2
#define AB3100_LDO_ON		4
#define AB3100_LDO_H_VSEL_AC	5
#define AB3100_LDO_K		0x48
#define AB3100_LDO_EXT		0x49
#define AB3100_BUCK		0x4A
#define AB3100_BUCK_SLEEP	0x4B
#define AB3100_REG_ON_MASK	0x10

/**
 * struct ab3100_regulator
 * A struct passed around the individual regulator functions
 * @platform_device: platform device holding this regulator
 * @dev: handle to the device
 * @plfdata: AB3100 platform data passed in at probe time
 * @regreg: regulator register number in the AB3100
 */
struct ab3100_regulator {
	struct regulator_dev *rdev;
	struct device *dev;
	struct ab3100_platform_data *plfdata;
	u8 regreg;
};

/* The order in which registers are initialized */
static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
	AB3100_LDO_A,
	AB3100_LDO_C,
	AB3100_LDO_E,
	AB3100_LDO_E_SLEEP,
	AB3100_LDO_F,
	AB3100_LDO_G,
	AB3100_LDO_H,
	AB3100_LDO_K,
	AB3100_LDO_EXT,
	AB3100_BUCK,
	AB3100_BUCK_SLEEP,
	AB3100_LDO_D,
};

/* Preset (hardware defined) voltages for these regulators */
#define LDO_A_VOLTAGE 2750000
#define LDO_C_VOLTAGE 2650000
#define LDO_D_VOLTAGE 2650000

static const unsigned int ldo_e_buck_typ_voltages[] = {
	1800000,
	1400000,
	1300000,
	1200000,
	1100000,
	1050000,
	900000,
};

static const unsigned int ldo_f_typ_voltages[] = {
	1800000,
	1400000,
	1300000,
	1200000,
	1100000,
	1050000,
	2500000,
	2650000,
};

static const unsigned int ldo_g_typ_voltages[] = {
	2850000,
	2750000,
	1800000,
	1500000,
};

static const unsigned int ldo_h_typ_voltages[] = {
	2750000,
	1800000,
	1500000,
	1200000,
};

static const unsigned int ldo_k_typ_voltages[] = {
	2750000,
	1800000,
};


/* The regulator devices */
static struct ab3100_regulator
ab3100_regulators[AB3100_NUM_REGULATORS] = {
	{
		.regreg = AB3100_LDO_A,
	},
	{
		.regreg = AB3100_LDO_C,
	},
	{
		.regreg = AB3100_LDO_D,
	},
	{
		.regreg = AB3100_LDO_E,
	},
	{
		.regreg = AB3100_LDO_F,
	},
	{
		.regreg = AB3100_LDO_G,
	},
	{
		.regreg = AB3100_LDO_H,
	},
	{
		.regreg = AB3100_LDO_K,
	},
	{
		.regreg = AB3100_LDO_EXT,
		/* No voltages for the external regulator */
	},
	{
		.regreg = AB3100_BUCK,
	},
};

/*
 * General functions for enable, disable and is_enabled used for
 * LDO: A,C,E,F,G,H,K,EXT and BUCK
 */
static int ab3100_enable_regulator(struct regulator_dev *reg)
{
	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
	int err;
	u8 regval;

	err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
						&regval);
	if (err) {
		dev_warn(&reg->dev, "failed to get regid %d value\n",
			 abreg->regreg);
		return err;
	}

	/* The regulator is already on, no reason to go further */
	if (regval & AB3100_REG_ON_MASK)
		return 0;

	regval |= AB3100_REG_ON_MASK;

	err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
						regval);
	if (err) {
		dev_warn(&reg->dev, "failed to set regid %d value\n",
			 abreg->regreg);
		return err;
	}

	return 0;
}

static int ab3100_disable_regulator(struct regulator_dev *reg)
{
	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
	int err;
	u8 regval;

	/*
	 * LDO D is a special regulator. When it is disabled, the entire
	 * system is shut down. So this is handled specially.
	 */
	pr_info("Called ab3100_disable_regulator\n");
	if (abreg->regreg == AB3100_LDO_D) {
		dev_info(&reg->dev, "disabling LDO D - shut down system\n");
		/* Setting LDO D to 0x00 cuts the power to the SoC */
		return abx500_set_register_interruptible(abreg->dev, 0,
							 AB3100_LDO_D, 0x00U);
	}

	/*
	 * All other regulators are handled here
	 */
	err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
						&regval);
	if (err) {
		dev_err(&reg->dev, "unable to get register 0x%x\n",
			abreg->regreg);
		return err;
	}
	regval &= ~AB3100_REG_ON_MASK;
	return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
						 regval);
}

static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
{
	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
	u8 regval;
	int err;

	err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
						&regval);
	if (err) {
		dev_err(&reg->dev, "unable to get register 0x%x\n",
			abreg->regreg);
		return err;
	}

	return regval & AB3100_REG_ON_MASK;
}

static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
{
	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
	u8 regval;
	int err;

	/*
	 * For variable types, read out setting and index into
	 * supplied voltage list.
	 */
	err = abx500_get_register_interruptible(abreg->dev, 0,
						abreg->regreg, &regval);
	if (err) {
		dev_warn(&reg->dev,
			 "failed to get regulator value in register %02x\n",
			 abreg->regreg);
		return err;
	}

	/* The 3 highest bits index voltages */
	regval &= 0xE0;
	regval >>= 5;

	if (regval >= reg->desc->n_voltages) {
		dev_err(&reg->dev,
			"regulator register %02x contains an illegal voltage setting\n",
			abreg->regreg);
		return -EINVAL;
	}

	return reg->desc->volt_table[regval];
}

static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
					    unsigned selector)
{
	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
	u8 regval;
	int err;

	err = abx500_get_register_interruptible(abreg->dev, 0,
						abreg->regreg, &regval);
	if (err) {
		dev_warn(&reg->dev,
			 "failed to get regulator register %02x\n",
			 abreg->regreg);
		return err;
	}

	/* The highest three bits control the variable regulators */
	regval &= ~0xE0;
	regval |= (selector << 5);

	err = abx500_set_register_interruptible(abreg->dev, 0,
						abreg->regreg, regval);
	if (err)
		dev_warn(&reg->dev, "failed to set regulator register %02x\n",
			abreg->regreg);

	return err;
}

static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
						int uV)
{
	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
	u8 regval;
	int err;
	int bestindex;
	u8 targetreg;

	if (abreg->regreg == AB3100_LDO_E)
		targetreg = AB3100_LDO_E_SLEEP;
	else if (abreg->regreg == AB3100_BUCK)
		targetreg = AB3100_BUCK_SLEEP;
	else
		return -EINVAL;

	/* LDO E and BUCK have special suspend voltages you can set */
	bestindex = regulator_map_voltage_iterate(reg, uV, uV);

	err = abx500_get_register_interruptible(abreg->dev, 0,
						targetreg, &regval);
	if (err) {
		dev_warn(&reg->dev,
			 "failed to get regulator register %02x\n",
			 targetreg);
		return err;
	}

	/* The highest three bits control the variable regulators */
	regval &= ~0xE0;
	regval |= (bestindex << 5);

	err = abx500_set_register_interruptible(abreg->dev, 0,
						targetreg, regval);
	if (err)
		dev_warn(&reg->dev, "failed to set regulator register %02x\n",
			abreg->regreg);

	return err;
}

/*
 * The external regulator can just define a fixed voltage.
 */
static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
{
	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);

	return abreg->plfdata->external_voltage;
}

static int ab3100_get_fixed_voltage_regulator(struct regulator_dev *reg)
{
	return reg->desc->min_uV;
}

static struct regulator_ops regulator_ops_fixed = {
	.list_voltage = regulator_list_voltage_linear,
	.enable      = ab3100_enable_regulator,
	.disable     = ab3100_disable_regulator,
	.is_enabled  = ab3100_is_enabled_regulator,
	.get_voltage = ab3100_get_fixed_voltage_regulator,
};

static struct regulator_ops regulator_ops_variable = {
	.enable      = ab3100_enable_regulator,
	.disable     = ab3100_disable_regulator,
	.is_enabled  = ab3100_is_enabled_regulator,
	.get_voltage = ab3100_get_voltage_regulator,
	.set_voltage_sel = ab3100_set_voltage_regulator_sel,
	.list_voltage = regulator_list_voltage_table,
};

static struct regulator_ops regulator_ops_variable_sleepable = {
	.enable      = ab3100_enable_regulator,
	.disable     = ab3100_disable_regulator,
	.is_enabled  = ab3100_is_enabled_regulator,
	.get_voltage = ab3100_get_voltage_regulator,
	.set_voltage_sel = ab3100_set_voltage_regulator_sel,
	.set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
	.list_voltage = regulator_list_voltage_table,
};

/*
 * LDO EXT is an external regulator so it is really
 * not possible to set any voltage locally here, AB3100
 * is an on/off switch plain an simple. The external
 * voltage is defined in the board set-up if any.
 */
static struct regulator_ops regulator_ops_external = {
	.enable      = ab3100_enable_regulator,
	.disable     = ab3100_disable_regulator,
	.is_enabled  = ab3100_is_enabled_regulator,
	.get_voltage = ab3100_get_voltage_regulator_external,
};

static struct regulator_desc
ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
	{
		.name = "LDO_A",
		.id   = AB3100_LDO_A,
		.ops  = &regulator_ops_fixed,
		.n_voltages = 1,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.min_uV = LDO_A_VOLTAGE,
		.enable_time = 200,
	},
	{
		.name = "LDO_C",
		.id   = AB3100_LDO_C,
		.ops  = &regulator_ops_fixed,
		.n_voltages = 1,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.min_uV = LDO_C_VOLTAGE,
		.enable_time = 200,
	},
	{
		.name = "LDO_D",
		.id   = AB3100_LDO_D,
		.ops  = &regulator_ops_fixed,
		.n_voltages = 1,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.min_uV = LDO_D_VOLTAGE,
		.enable_time = 200,
	},
	{
		.name = "LDO_E",
		.id   = AB3100_LDO_E,
		.ops  = &regulator_ops_variable_sleepable,
		.n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
		.volt_table = ldo_e_buck_typ_voltages,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.enable_time = 200,
	},
	{
		.name = "LDO_F",
		.id   = AB3100_LDO_F,
		.ops  = &regulator_ops_variable,
		.n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
		.volt_table = ldo_f_typ_voltages,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.enable_time = 600,
	},
	{
		.name = "LDO_G",
		.id   = AB3100_LDO_G,
		.ops  = &regulator_ops_variable,
		.n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
		.volt_table = ldo_g_typ_voltages,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.enable_time = 400,
	},
	{
		.name = "LDO_H",
		.id   = AB3100_LDO_H,
		.ops  = &regulator_ops_variable,
		.n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
		.volt_table = ldo_h_typ_voltages,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.enable_time = 200,
	},
	{
		.name = "LDO_K",
		.id   = AB3100_LDO_K,
		.ops  = &regulator_ops_variable,
		.n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
		.volt_table = ldo_k_typ_voltages,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.enable_time = 200,
	},
	{
		.name = "LDO_EXT",
		.id   = AB3100_LDO_EXT,
		.ops  = &regulator_ops_external,
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
	},
	{
		.name = "BUCK",
		.id   = AB3100_BUCK,
		.ops  = &regulator_ops_variable_sleepable,
		.n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
		.type = REGULATOR_VOLTAGE,
		.owner = THIS_MODULE,
		.enable_time = 1000,
	},
};

/*
 * NOTE: the following functions are regulators pluralis - it is the
 * binding to the AB3100 core driver and the parent platform device
 * for all the different regulators.
 */

static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
{
	struct ab3100_platform_data *plfdata = pdev->dev.platform_data;
	struct regulator_config config = { };
	int err = 0;
	u8 data;
	int i;

	/* Check chip state */
	err = abx500_get_register_interruptible(&pdev->dev, 0,
						AB3100_LDO_D, &data);
	if (err) {
		dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
		return err;
	}
	if (data & 0x10)
		dev_notice(&pdev->dev,
			   "chip is already in active mode (Warm start)\n");
	else
		dev_notice(&pdev->dev,
			   "chip is in inactive mode (Cold start)\n");

	/* Set up regulators */
	for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
		err = abx500_set_register_interruptible(&pdev->dev, 0,
					ab3100_reg_init_order[i],
					plfdata->reg_initvals[i]);
		if (err) {
			dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
				err);
			return err;
		}
	}

	/* Register the regulators */
	for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
		struct ab3100_regulator *reg = &ab3100_regulators[i];
		struct regulator_dev *rdev;

		/*
		 * Initialize per-regulator struct.
		 * Inherit platform data, this comes down from the
		 * i2c boarddata, from the machine. So if you want to
		 * see what it looks like for a certain machine, go
		 * into the machine I2C setup.
		 */
		reg->dev = &pdev->dev;
		reg->plfdata = plfdata;

		config.dev = &pdev->dev;
		config.driver_data = reg;
		config.init_data = &plfdata->reg_constraints[i];

		/*
		 * Register the regulator, pass around
		 * the ab3100_regulator struct
		 */
		rdev = regulator_register(&ab3100_regulator_desc[i], &config);
		if (IS_ERR(rdev)) {
			err = PTR_ERR(rdev);
			dev_err(&pdev->dev,
				"%s: failed to register regulator %s err %d\n",
				__func__, ab3100_regulator_desc[i].name,
				err);
			/* remove the already registered regulators */
			while (--i >= 0)
				regulator_unregister(ab3100_regulators[i].rdev);
			return err;
		}

		/* Then set a pointer back to the registered regulator */
		reg->rdev = rdev;
	}

	return 0;
}

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

	for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
		struct ab3100_regulator *reg = &ab3100_regulators[i];

		regulator_unregister(reg->rdev);
	}
	return 0;
}

static struct platform_driver ab3100_regulators_driver = {
	.driver = {
		.name  = "ab3100-regulators",
		.owner = THIS_MODULE,
	},
	.probe = ab3100_regulators_probe,
	.remove = __devexit_p(ab3100_regulators_remove),
};

static __init int ab3100_regulators_init(void)
{
	return platform_driver_register(&ab3100_regulators_driver);
}

static __exit void ab3100_regulators_exit(void)
{
	platform_driver_unregister(&ab3100_regulators_driver);
}

subsys_initcall(ab3100_regulators_init);
module_exit(ab3100_regulators_exit);

MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
MODULE_DESCRIPTION("AB3100 Regulator driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:ab3100-regulators");
Commit	Line	Data
d619bc14 LW	1	/*
	2	* drivers/regulator/ab3100.c
	3	*
	4	* Copyright (C) 2008-2009 ST-Ericsson AB
	5	* License terms: GNU General Public License (GPL) version 2
	6	* Low-level control of the AB3100 IC Low Dropout (LDO)
	7	* regulators, external regulator and buck converter
	8	* Author: Mattias Wallin <mattias.wallin@stericsson.com>
	9	* Author: Linus Walleij <linus.walleij@stericsson.com>
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/kernel.h>
	14	#include <linux/init.h>
	15	#include <linux/err.h>
d619bc14 LW	16	#include <linux/platform_device.h>
d619bc14 LW	17	#include <linux/regulator/driver.h>
812f9e9d	18	#include <linux/mfd/abx500.h>
d619bc14 LW	19
	20	/* LDO registers and some handy masking definitions for AB3100 */
	21	#define AB3100_LDO_A 0x40
	22	#define AB3100_LDO_C 0x41
	23	#define AB3100_LDO_D 0x42
	24	#define AB3100_LDO_E 0x43
	25	#define AB3100_LDO_E_SLEEP 0x44
	26	#define AB3100_LDO_F 0x45
	27	#define AB3100_LDO_G 0x46
	28	#define AB3100_LDO_H 0x47
	29	#define AB3100_LDO_H_SLEEP_MODE 0
	30	#define AB3100_LDO_H_SLEEP_EN 2
	31	#define AB3100_LDO_ON 4
	32	#define AB3100_LDO_H_VSEL_AC 5
	33	#define AB3100_LDO_K 0x48
	34	#define AB3100_LDO_EXT 0x49
	35	#define AB3100_BUCK 0x4A
	36	#define AB3100_BUCK_SLEEP 0x4B
	37	#define AB3100_REG_ON_MASK 0x10
	38
	39	/**
	40	* struct ab3100_regulator
	41	* A struct passed around the individual regulator functions
	42	* @platform_device: platform device holding this regulator
fa661258	43	* @dev: handle to the device
d619bc14 LW	44	* @plfdata: AB3100 platform data passed in at probe time
d619bc14 LW	45	* @regreg: regulator register number in the AB3100
d619bc14 LW	46	*/
	47	struct ab3100_regulator {
	48	struct regulator_dev *rdev;
fa661258	49	struct device *dev;
d619bc14 LW	50	struct ab3100_platform_data *plfdata;
d619bc14 LW	51	u8 regreg;
d619bc14 LW	52	};
	53
	54	/* The order in which registers are initialized */
	55	static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
	56	AB3100_LDO_A,
	57	AB3100_LDO_C,
	58	AB3100_LDO_E,
	59	AB3100_LDO_E_SLEEP,
	60	AB3100_LDO_F,
	61	AB3100_LDO_G,
	62	AB3100_LDO_H,
	63	AB3100_LDO_K,
	64	AB3100_LDO_EXT,
	65	AB3100_BUCK,
	66	AB3100_BUCK_SLEEP,
	67	AB3100_LDO_D,
	68	};
	69
	70	/* Preset (hardware defined) voltages for these regulators */
	71	#define LDO_A_VOLTAGE 2750000
	72	#define LDO_C_VOLTAGE 2650000
	73	#define LDO_D_VOLTAGE 2650000
	74
a3beb742	75	static const unsigned int ldo_e_buck_typ_voltages[] = {
d619bc14 LW	76	1800000,
	77	1400000,
	78	1300000,
	79	1200000,
	80	1100000,
	81	1050000,
	82	900000,
	83	};
	84
a3beb742	85	static const unsigned int ldo_f_typ_voltages[] = {
d619bc14 LW	86	1800000,
	87	1400000,
	88	1300000,
	89	1200000,
	90	1100000,
	91	1050000,
	92	2500000,
	93	2650000,
	94	};
	95
a3beb742	96	static const unsigned int ldo_g_typ_voltages[] = {
d619bc14 LW	97	2850000,
	98	2750000,
	99	1800000,
	100	1500000,
	101	};
	102
a3beb742	103	static const unsigned int ldo_h_typ_voltages[] = {
d619bc14 LW	104	2750000,
	105	1800000,
	106	1500000,
	107	1200000,
	108	};
	109
a3beb742	110	static const unsigned int ldo_k_typ_voltages[] = {
d619bc14 LW	111	2750000,
	112	1800000,
	113	};
	114
	115
	116	/* The regulator devices */
	117	static struct ab3100_regulator
	118	ab3100_regulators[AB3100_NUM_REGULATORS] = {
	119	{
	120	.regreg = AB3100_LDO_A,
d619bc14 LW	121	},
	122	{
	123	.regreg = AB3100_LDO_C,
d619bc14 LW	124	},
	125	{
	126	.regreg = AB3100_LDO_D,
d619bc14 LW	127	},
	128	{
	129	.regreg = AB3100_LDO_E,
d619bc14 LW	130	},
	131	{
	132	.regreg = AB3100_LDO_F,
d619bc14 LW	133	},
	134	{
	135	.regreg = AB3100_LDO_G,
d619bc14 LW	136	},
	137	{
	138	.regreg = AB3100_LDO_H,
d619bc14 LW	139	},
	140	{
	141	.regreg = AB3100_LDO_K,
d619bc14 LW	142	},
	143	{
	144	.regreg = AB3100_LDO_EXT,
	145	/* No voltages for the external regulator */
	146	},
	147	{
	148	.regreg = AB3100_BUCK,
d619bc14 LW	149	},
	150	};
	151
	152	/*
	153	* General functions for enable, disable and is_enabled used for
	154	* LDO: A,C,E,F,G,H,K,EXT and BUCK
	155	*/
	156	static int ab3100_enable_regulator(struct regulator_dev *reg)
	157	{
6c3b956b	158	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
d619bc14 LW	159	int err;
	160	u8 regval;
	161
fa661258	162	err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
d619bc14 LW	163	&regval);
	164	if (err) {
	165	dev_warn(&reg->dev, "failed to get regid %d value\n",
	166	abreg->regreg);
	167	return err;
	168	}
	169
	170	/* The regulator is already on, no reason to go further */
	171	if (regval & AB3100_REG_ON_MASK)
	172	return 0;
	173
	174	regval \|= AB3100_REG_ON_MASK;
	175
fa661258	176	err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
d619bc14 LW	177	regval);
	178	if (err) {
	179	dev_warn(&reg->dev, "failed to set regid %d value\n",
	180	abreg->regreg);
	181	return err;
	182	}
	183
d619bc14 LW	184	return 0;
	185	}
	186
	187	static int ab3100_disable_regulator(struct regulator_dev *reg)
	188	{
6c3b956b	189	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
d619bc14 LW	190	int err;
	191	u8 regval;
	192
	193	/*
	194	* LDO D is a special regulator. When it is disabled, the entire
	195	* system is shut down. So this is handled specially.
	196	*/
176f45b9	197	pr_info("Called ab3100_disable_regulator\n");
d619bc14	198	if (abreg->regreg == AB3100_LDO_D) {
d619bc14	199	dev_info(&reg->dev, "disabling LDO D - shut down system\n");
d619bc14	200	/* Setting LDO D to 0x00 cuts the power to the SoC */
fa661258	201	return abx500_set_register_interruptible(abreg->dev, 0,
d619bc14	202	AB3100_LDO_D, 0x00U);
d619bc14 LW	203	}
	204
	205	/*
	206	* All other regulators are handled here
	207	*/
fa661258	208	err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
d619bc14 LW	209	&regval);
	210	if (err) {
	211	dev_err(&reg->dev, "unable to get register 0x%x\n",
	212	abreg->regreg);
	213	return err;
	214	}
	215	regval &= ~AB3100_REG_ON_MASK;
fa661258	216	return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
d619bc14 LW	217	regval);
	218	}
	219
	220	static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
	221	{
6c3b956b	222	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
d619bc14 LW	223	u8 regval;
	224	int err;
	225
fa661258	226	err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
d619bc14 LW	227	&regval);
	228	if (err) {
	229	dev_err(&reg->dev, "unable to get register 0x%x\n",
	230	abreg->regreg);
	231	return err;
	232	}
	233
	234	return regval & AB3100_REG_ON_MASK;
	235	}
	236
d619bc14 LW	237	static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
d619bc14 LW	238	{
6c3b956b	239	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
d619bc14 LW	240	u8 regval;
	241	int err;
	242
d619bc14 LW	243	/*
	244	* For variable types, read out setting and index into
	245	* supplied voltage list.
	246	*/
fa661258	247	err = abx500_get_register_interruptible(abreg->dev, 0,
d619bc14 LW	248	abreg->regreg, &regval);
	249	if (err) {
	250	dev_warn(&reg->dev,
	251	"failed to get regulator value in register %02x\n",
	252	abreg->regreg);
	253	return err;
	254	}
	255
	256	/* The 3 highest bits index voltages */
	257	regval &= 0xE0;
	258	regval >>= 5;
	259
a3beb742	260	if (regval >= reg->desc->n_voltages) {
d619bc14 LW	261	dev_err(&reg->dev,
	262	"regulator register %02x contains an illegal voltage setting\n",
	263	abreg->regreg);
	264	return -EINVAL;
	265	}
	266
a3beb742	267	return reg->desc->volt_table[regval];
d619bc14 LW	268	}
d619bc14 LW	269
1f793ff2 AL	270	static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
1f793ff2 AL	271	unsigned selector)
d619bc14	272	{
6c3b956b	273	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
d619bc14 LW	274	u8 regval;
d619bc14 LW	275	int err;
3a93f2a9	276
fa661258	277	err = abx500_get_register_interruptible(abreg->dev, 0,
d619bc14 LW	278	abreg->regreg, &regval);
	279	if (err) {
	280	dev_warn(&reg->dev,
	281	"failed to get regulator register %02x\n",
	282	abreg->regreg);
	283	return err;
	284	}
	285
	286	/* The highest three bits control the variable regulators */
	287	regval &= ~0xE0;
1f793ff2	288	regval \|= (selector << 5);
d619bc14	289
fa661258	290	err = abx500_set_register_interruptible(abreg->dev, 0,
d619bc14 LW	291	abreg->regreg, regval);
	292	if (err)
	293	dev_warn(&reg->dev, "failed to set regulator register %02x\n",
	294	abreg->regreg);
	295
	296	return err;
	297	}
	298
	299	static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
	300	int uV)
	301	{
6c3b956b	302	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
d619bc14 LW	303	u8 regval;
	304	int err;
	305	int bestindex;
	306	u8 targetreg;
	307
	308	if (abreg->regreg == AB3100_LDO_E)
	309	targetreg = AB3100_LDO_E_SLEEP;
	310	else if (abreg->regreg == AB3100_BUCK)
	311	targetreg = AB3100_BUCK_SLEEP;
	312	else
	313	return -EINVAL;
	314
	315	/* LDO E and BUCK have special suspend voltages you can set */
b13296d0	316	bestindex = regulator_map_voltage_iterate(reg, uV, uV);
d619bc14	317
fa661258	318	err = abx500_get_register_interruptible(abreg->dev, 0,
d619bc14 LW	319	targetreg, &regval);
	320	if (err) {
	321	dev_warn(&reg->dev,
	322	"failed to get regulator register %02x\n",
	323	targetreg);
	324	return err;
	325	}
	326
	327	/* The highest three bits control the variable regulators */
	328	regval &= ~0xE0;
	329	regval \|= (bestindex << 5);
	330
fa661258	331	err = abx500_set_register_interruptible(abreg->dev, 0,
d619bc14 LW	332	targetreg, regval);
	333	if (err)
	334	dev_warn(&reg->dev, "failed to set regulator register %02x\n",
	335	abreg->regreg);
	336
	337	return err;
	338	}
	339
	340	/*
	341	* The external regulator can just define a fixed voltage.
	342	*/
	343	static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
	344	{
6c3b956b	345	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
d619bc14 LW	346
	347	return abreg->plfdata->external_voltage;
	348	}
	349
1bd1955a AL	350	static int ab3100_get_fixed_voltage_regulator(struct regulator_dev *reg)
	351	{
	352	return reg->desc->min_uV;
	353	}
	354
d619bc14	355	static struct regulator_ops regulator_ops_fixed = {
1bd1955a	356	.list_voltage = regulator_list_voltage_linear,
d619bc14 LW	357	.enable = ab3100_enable_regulator,
	358	.disable = ab3100_disable_regulator,
	359	.is_enabled = ab3100_is_enabled_regulator,
1bd1955a	360	.get_voltage = ab3100_get_fixed_voltage_regulator,
d619bc14 LW	361	};
	362
	363	static struct regulator_ops regulator_ops_variable = {
	364	.enable = ab3100_enable_regulator,
	365	.disable = ab3100_disable_regulator,
	366	.is_enabled = ab3100_is_enabled_regulator,
	367	.get_voltage = ab3100_get_voltage_regulator,
1f793ff2	368	.set_voltage_sel = ab3100_set_voltage_regulator_sel,
a3beb742	369	.list_voltage = regulator_list_voltage_table,
d619bc14 LW	370	};
	371
	372	static struct regulator_ops regulator_ops_variable_sleepable = {
	373	.enable = ab3100_enable_regulator,
	374	.disable = ab3100_disable_regulator,
	375	.is_enabled = ab3100_is_enabled_regulator,
	376	.get_voltage = ab3100_get_voltage_regulator,
1f793ff2	377	.set_voltage_sel = ab3100_set_voltage_regulator_sel,
d619bc14	378	.set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
a3beb742	379	.list_voltage = regulator_list_voltage_table,
d619bc14 LW	380	};
	381
	382	/*
	383	* LDO EXT is an external regulator so it is really
	384	* not possible to set any voltage locally here, AB3100
	385	* is an on/off switch plain an simple. The external
	386	* voltage is defined in the board set-up if any.
	387	*/
	388	static struct regulator_ops regulator_ops_external = {
	389	.enable = ab3100_enable_regulator,
	390	.disable = ab3100_disable_regulator,
	391	.is_enabled = ab3100_is_enabled_regulator,
	392	.get_voltage = ab3100_get_voltage_regulator_external,
	393	};
	394
	395	static struct regulator_desc
	396	ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
	397	{
	398	.name = "LDO_A",
	399	.id = AB3100_LDO_A,
	400	.ops = &regulator_ops_fixed,
1bd1955a	401	.n_voltages = 1,
d619bc14	402	.type = REGULATOR_VOLTAGE,
64714354	403	.owner = THIS_MODULE,
1bd1955a	404	.min_uV = LDO_A_VOLTAGE,
f8568cbd	405	.enable_time = 200,
d619bc14 LW	406	},
	407	{
	408	.name = "LDO_C",
	409	.id = AB3100_LDO_C,
	410	.ops = &regulator_ops_fixed,
1bd1955a	411	.n_voltages = 1,
d619bc14	412	.type = REGULATOR_VOLTAGE,
64714354	413	.owner = THIS_MODULE,
1bd1955a	414	.min_uV = LDO_C_VOLTAGE,
f8568cbd	415	.enable_time = 200,
d619bc14 LW	416	},
	417	{
	418	.name = "LDO_D",
	419	.id = AB3100_LDO_D,
	420	.ops = &regulator_ops_fixed,
1bd1955a	421	.n_voltages = 1,
d619bc14	422	.type = REGULATOR_VOLTAGE,
64714354	423	.owner = THIS_MODULE,
1bd1955a	424	.min_uV = LDO_D_VOLTAGE,
f8568cbd	425	.enable_time = 200,
d619bc14 LW	426	},
	427	{
	428	.name = "LDO_E",
	429	.id = AB3100_LDO_E,
	430	.ops = &regulator_ops_variable_sleepable,
75f2ba8f	431	.n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
a3beb742	432	.volt_table = ldo_e_buck_typ_voltages,
d619bc14	433	.type = REGULATOR_VOLTAGE,
64714354	434	.owner = THIS_MODULE,
f8568cbd	435	.enable_time = 200,
d619bc14 LW	436	},
	437	{
	438	.name = "LDO_F",
	439	.id = AB3100_LDO_F,
	440	.ops = &regulator_ops_variable,
75f2ba8f	441	.n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
a3beb742	442	.volt_table = ldo_f_typ_voltages,
d619bc14	443	.type = REGULATOR_VOLTAGE,
64714354	444	.owner = THIS_MODULE,
f8568cbd	445	.enable_time = 600,
d619bc14 LW	446	},
	447	{
	448	.name = "LDO_G",
	449	.id = AB3100_LDO_G,
	450	.ops = &regulator_ops_variable,
75f2ba8f	451	.n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
a3beb742	452	.volt_table = ldo_g_typ_voltages,
d619bc14	453	.type = REGULATOR_VOLTAGE,
64714354	454	.owner = THIS_MODULE,
f8568cbd	455	.enable_time = 400,
d619bc14 LW	456	},
	457	{
	458	.name = "LDO_H",
	459	.id = AB3100_LDO_H,
	460	.ops = &regulator_ops_variable,
75f2ba8f	461	.n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
a3beb742	462	.volt_table = ldo_h_typ_voltages,
d619bc14	463	.type = REGULATOR_VOLTAGE,
64714354	464	.owner = THIS_MODULE,
f8568cbd	465	.enable_time = 200,
d619bc14 LW	466	},
	467	{
	468	.name = "LDO_K",
	469	.id = AB3100_LDO_K,
	470	.ops = &regulator_ops_variable,
75f2ba8f	471	.n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
a3beb742	472	.volt_table = ldo_k_typ_voltages,
d619bc14	473	.type = REGULATOR_VOLTAGE,
64714354	474	.owner = THIS_MODULE,
f8568cbd	475	.enable_time = 200,
d619bc14 LW	476	},
	477	{
	478	.name = "LDO_EXT",
	479	.id = AB3100_LDO_EXT,
	480	.ops = &regulator_ops_external,
	481	.type = REGULATOR_VOLTAGE,
64714354	482	.owner = THIS_MODULE,
d619bc14 LW	483	},
	484	{
	485	.name = "BUCK",
	486	.id = AB3100_BUCK,
	487	.ops = &regulator_ops_variable_sleepable,
75f2ba8f	488	.n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
d619bc14	489	.type = REGULATOR_VOLTAGE,
64714354	490	.owner = THIS_MODULE,
f8568cbd	491	.enable_time = 1000,
d619bc14 LW	492	},
	493	};
	494
	495	/*
	496	* NOTE: the following functions are regulators pluralis - it is the
	497	* binding to the AB3100 core driver and the parent platform device
	498	* for all the different regulators.
	499	*/
	500
98bf7c05	501	static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
d619bc14	502	{
a771e36e	503	struct ab3100_platform_data *plfdata = pdev->dev.platform_data;
c172708d	504	struct regulator_config config = { };
d619bc14 LW	505	int err = 0;
	506	u8 data;
	507	int i;
	508
	509	/* Check chip state */
fa661258	510	err = abx500_get_register_interruptible(&pdev->dev, 0,
d619bc14 LW	511	AB3100_LDO_D, &data);
	512	if (err) {
	513	dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
	514	return err;
	515	}
	516	if (data & 0x10)
	517	dev_notice(&pdev->dev,
	518	"chip is already in active mode (Warm start)\n");
	519	else
	520	dev_notice(&pdev->dev,
	521	"chip is in inactive mode (Cold start)\n");
	522
	523	/* Set up regulators */
	524	for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
fa661258	525	err = abx500_set_register_interruptible(&pdev->dev, 0,
d619bc14 LW	526	ab3100_reg_init_order[i],
	527	plfdata->reg_initvals[i]);
	528	if (err) {
	529	dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
	530	err);
	531	return err;
	532	}
	533	}
	534
d619bc14 LW	535	/* Register the regulators */
	536	for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
	537	struct ab3100_regulator *reg = &ab3100_regulators[i];
	538	struct regulator_dev *rdev;
	539
	540	/*
	541	* Initialize per-regulator struct.
	542	* Inherit platform data, this comes down from the
	543	* i2c boarddata, from the machine. So if you want to
	544	* see what it looks like for a certain machine, go
	545	* into the machine I2C setup.
	546	*/
fa661258	547	reg->dev = &pdev->dev;
d619bc14 LW	548	reg->plfdata = plfdata;
d619bc14 LW	549
c172708d MB	550	config.dev = &pdev->dev;
	551	config.driver_data = reg;
	552	config.init_data = &plfdata->reg_constraints[i];
	553
d619bc14 LW	554	/*
	555	* Register the regulator, pass around
	556	* the ab3100_regulator struct
	557	*/
c172708d	558	rdev = regulator_register(&ab3100_regulator_desc[i], &config);
d619bc14 LW	559	if (IS_ERR(rdev)) {
	560	err = PTR_ERR(rdev);
	561	dev_err(&pdev->dev,
	562	"%s: failed to register regulator %s err %d\n",
	563	__func__, ab3100_regulator_desc[i].name,
	564	err);
d619bc14	565	/* remove the already registered regulators */
b3fcf3e5	566	while (--i >= 0)
d619bc14	567	regulator_unregister(ab3100_regulators[i].rdev);
d619bc14 LW	568	return err;
	569	}
	570
	571	/* Then set a pointer back to the registered regulator */
	572	reg->rdev = rdev;
	573	}
	574
	575	return 0;
	576	}
	577
98bf7c05	578	static int __devexit ab3100_regulators_remove(struct platform_device *pdev)
d619bc14 LW	579	{
	580	int i;
	581
	582	for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
	583	struct ab3100_regulator *reg = &ab3100_regulators[i];
	584
	585	regulator_unregister(reg->rdev);
	586	}
	587	return 0;
	588	}
	589
	590	static struct platform_driver ab3100_regulators_driver = {
	591	.driver = {
	592	.name = "ab3100-regulators",
	593	.owner = THIS_MODULE,
	594	},
	595	.probe = ab3100_regulators_probe,
98bf7c05	596	.remove = __devexit_p(ab3100_regulators_remove),
d619bc14 LW	597	};
	598
	599	static __init int ab3100_regulators_init(void)
	600	{
	601	return platform_driver_register(&ab3100_regulators_driver);
	602	}
	603
	604	static __exit void ab3100_regulators_exit(void)
	605	{
176f45b9	606	platform_driver_unregister(&ab3100_regulators_driver);
d619bc14 LW	607	}
	608
	609	subsys_initcall(ab3100_regulators_init);
	610	module_exit(ab3100_regulators_exit);
	611
	612	MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
	613	MODULE_DESCRIPTION("AB3100 Regulator driver");
	614	MODULE_LICENSE("GPL");
	615	MODULE_ALIAS("platform:ab3100-regulators");