[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / drivers / regulator / tps6586x-regulator.c

/*
 * Regulator driver for TI TPS6586x
 *
 * Copyright (C) 2010 Compulab Ltd.
 * Author: Mike Rapoport <mike@compulab.co.il>
 *
 * Based on da903x
 * Copyright (C) 2006-2008 Marvell International Ltd.
 * Copyright (C) 2008 Compulab Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

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

/* supply control and voltage setting  */
#define TPS6586X_SUPPLYENA	0x10
#define TPS6586X_SUPPLYENB	0x11
#define TPS6586X_SUPPLYENC	0x12
#define TPS6586X_SUPPLYEND	0x13
#define TPS6586X_SUPPLYENE	0x14
#define TPS6586X_VCC1		0x20
#define TPS6586X_VCC2		0x21
#define TPS6586X_SM1V1		0x23
#define TPS6586X_SM1V2		0x24
#define TPS6586X_SM1SL		0x25
#define TPS6586X_SM0V1		0x26
#define TPS6586X_SM0V2		0x27
#define TPS6586X_SM0SL		0x28
#define TPS6586X_LDO2AV1	0x29
#define TPS6586X_LDO2AV2	0x2A
#define TPS6586X_LDO2BV1	0x2F
#define TPS6586X_LDO2BV2	0x30
#define TPS6586X_LDO4V1		0x32
#define TPS6586X_LDO4V2		0x33

/* converter settings  */
#define TPS6586X_SUPPLYV1	0x41
#define TPS6586X_SUPPLYV2	0x42
#define TPS6586X_SUPPLYV3	0x43
#define TPS6586X_SUPPLYV4	0x44
#define TPS6586X_SUPPLYV5	0x45
#define TPS6586X_SUPPLYV6	0x46
#define TPS6586X_SMODE1		0x47
#define TPS6586X_SMODE2		0x48

struct tps6586x_regulator {
	struct regulator_desc desc;

	int volt_reg;
	int volt_shift;
	int volt_nbits;
	int enable_bit[2];
	int enable_reg[2];

	int *voltages;

	/* for DVM regulators */
	int go_reg;
	int go_bit;
};

static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
{
	return rdev_get_dev(rdev)->parent->parent;
}

static int tps6586x_ldo_list_voltage(struct regulator_dev *rdev,
				     unsigned selector)
{
	struct tps6586x_regulator *info = rdev_get_drvdata(rdev);
	int rid = rdev_get_id(rdev);

	/* LDO0 has minimal voltage 1.2V rather than 1.25V */
	if ((rid == TPS6586X_ID_LDO_0) && (selector == 0))
		return (info->voltages[0] - 50) * 1000;

	return info->voltages[selector] * 1000;
}


static int __tps6586x_ldo_set_voltage(struct device *parent,
				      struct tps6586x_regulator *ri,
				      int min_uV, int max_uV,
				      unsigned *selector)
{
	int val, uV;
	uint8_t mask;

	for (val = 0; val < ri->desc.n_voltages; val++) {
		uV = ri->voltages[val] * 1000;

		/* LDO0 has minimal voltage 1.2 rather than 1.25 */
		if (ri->desc.id == TPS6586X_ID_LDO_0 && val == 0)
			uV -= 50 * 1000;

		/* use the first in-range value */
		if (min_uV <= uV && uV <= max_uV) {

			*selector = val;

			val <<= ri->volt_shift;
			mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;

			return tps6586x_update(parent, ri->volt_reg, val, mask);
		}
	}

	return -EINVAL;
}

static int tps6586x_ldo_set_voltage(struct regulator_dev *rdev,
				    int min_uV, int max_uV, unsigned *selector)
{
	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	struct device *parent = to_tps6586x_dev(rdev);

	return __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
					  selector);
}

static int tps6586x_ldo_get_voltage(struct regulator_dev *rdev)
{
	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	struct device *parent = to_tps6586x_dev(rdev);
	uint8_t val, mask;
	int ret;

	ret = tps6586x_read(parent, ri->volt_reg, &val);
	if (ret)
		return ret;

	mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
	val = (val & mask) >> ri->volt_shift;

	if (val >= ri->desc.n_voltages)
		BUG();

	return ri->voltages[val] * 1000;
}

static int tps6586x_dvm_set_voltage(struct regulator_dev *rdev,
				    int min_uV, int max_uV, unsigned *selector)
{
	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	struct device *parent = to_tps6586x_dev(rdev);
	int ret;

	ret = __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
					 selector);
	if (ret)
		return ret;

	return tps6586x_set_bits(parent, ri->go_reg, 1 << ri->go_bit);
}

static int tps6586x_regulator_enable(struct regulator_dev *rdev)
{
	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	struct device *parent = to_tps6586x_dev(rdev);

	return tps6586x_set_bits(parent, ri->enable_reg[0],
				 1 << ri->enable_bit[0]);
}

static int tps6586x_regulator_disable(struct regulator_dev *rdev)
{
	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	struct device *parent = to_tps6586x_dev(rdev);

	return tps6586x_clr_bits(parent, ri->enable_reg[0],
				 1 << ri->enable_bit[0]);
}

static int tps6586x_regulator_is_enabled(struct regulator_dev *rdev)
{
	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	struct device *parent = to_tps6586x_dev(rdev);
	uint8_t reg_val;
	int ret;

	ret = tps6586x_read(parent, ri->enable_reg[0], &reg_val);
	if (ret)
		return ret;

	return !!(reg_val & (1 << ri->enable_bit[0]));
}

static struct regulator_ops tps6586x_regulator_ldo_ops = {
	.list_voltage = tps6586x_ldo_list_voltage,
	.get_voltage = tps6586x_ldo_get_voltage,
	.set_voltage = tps6586x_ldo_set_voltage,

	.is_enabled = tps6586x_regulator_is_enabled,
	.enable = tps6586x_regulator_enable,
	.disable = tps6586x_regulator_disable,
};

static struct regulator_ops tps6586x_regulator_dvm_ops = {
	.list_voltage = tps6586x_ldo_list_voltage,
	.get_voltage = tps6586x_ldo_get_voltage,
	.set_voltage = tps6586x_dvm_set_voltage,

	.is_enabled = tps6586x_regulator_is_enabled,
	.enable = tps6586x_regulator_enable,
	.disable = tps6586x_regulator_disable,
};

static int tps6586x_ldo_voltages[] = {
	1250, 1500, 1800, 2500, 2700, 2850, 3100, 3300,
};

static int tps6586x_ldo4_voltages[] = {
	1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
	1900, 1925, 1950, 1975, 2000, 2025, 2050, 2075,
	2100, 2125, 2150, 2175, 2200, 2225, 2250, 2275,
	2300, 2325, 2350, 2375, 2400, 2425, 2450, 2475,
};

static int tps6586x_sm2_voltages[] = {
	3000, 3050, 3100, 3150, 3200, 3250, 3300, 3350,
	3400, 3450, 3500, 3550, 3600, 3650, 3700, 3750,
	3800, 3850, 3900, 3950, 4000, 4050, 4100, 4150,
	4200, 4250, 4300, 4350, 4400, 4450, 4500, 4550,
};

static int tps6586x_dvm_voltages[] = {
	 725,  750,  775,  800,  825,  850,  875,  900,
	 925,  950,  975, 1000, 1025, 1050, 1075, 1100,
	1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
	1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
};

#define TPS6586X_REGULATOR(_id, vdata, _ops, vreg, shift, nbits,	\
			   ereg0, ebit0, ereg1, ebit1)			\
	.desc	= {							\
		.name	= "REG-" #_id,					\
		.ops	= &tps6586x_regulator_##_ops,			\
		.type	= REGULATOR_VOLTAGE,				\
		.id	= TPS6586X_ID_##_id,				\
		.n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),	\
		.owner	= THIS_MODULE,					\
	},								\
	.volt_reg	= TPS6586X_##vreg,				\
	.volt_shift	= (shift),					\
	.volt_nbits	= (nbits),					\
	.enable_reg[0]	= TPS6586X_SUPPLY##ereg0,			\
	.enable_bit[0]	= (ebit0),					\
	.enable_reg[1]	= TPS6586X_SUPPLY##ereg1,			\
	.enable_bit[1]	= (ebit1),					\
	.voltages	= tps6586x_##vdata##_voltages,

#define TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)			\
	.go_reg = TPS6586X_##goreg,					\
	.go_bit = (gobit),

#define TPS6586X_LDO(_id, vdata, vreg, shift, nbits,			\
		     ereg0, ebit0, ereg1, ebit1)			\
{									\
	TPS6586X_REGULATOR(_id, vdata, ldo_ops, vreg, shift, nbits,	\
			   ereg0, ebit0, ereg1, ebit1)			\
}

#define TPS6586X_DVM(_id, vdata, vreg, shift, nbits,			\
		     ereg0, ebit0, ereg1, ebit1, goreg, gobit)		\
{									\
	TPS6586X_REGULATOR(_id, vdata, dvm_ops, vreg, shift, nbits,	\
			   ereg0, ebit0, ereg1, ebit1)			\
	TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)			\
}

static struct tps6586x_regulator tps6586x_regulator[] = {
	TPS6586X_LDO(LDO_0, ldo, SUPPLYV1, 5, 3, ENC, 0, END, 0),
	TPS6586X_LDO(LDO_3, ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
	TPS6586X_LDO(LDO_5, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
	TPS6586X_LDO(LDO_6, ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
	TPS6586X_LDO(LDO_7, ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
	TPS6586X_LDO(LDO_8, ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
	TPS6586X_LDO(LDO_9, ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
	TPS6586X_LDO(LDO_RTC, ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
	TPS6586X_LDO(LDO_1, dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
	TPS6586X_LDO(SM_2, sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),

	TPS6586X_DVM(LDO_2, dvm, LDO2BV1, 0, 5, ENA, 3, ENB, 3, VCC2, 6),
	TPS6586X_DVM(LDO_4, ldo4, LDO4V1, 0, 5, ENC, 3, END, 3, VCC1, 6),
	TPS6586X_DVM(SM_0, dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2),
	TPS6586X_DVM(SM_1, dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0),
};

/*
 * TPS6586X has 2 enable bits that are OR'ed to determine the actual
 * regulator state. Clearing one of this bits allows switching
 * regulator on and of with single register write.
 */
static inline int tps6586x_regulator_preinit(struct device *parent,
					     struct tps6586x_regulator *ri)
{
	uint8_t val1, val2;
	int ret;

	if (ri->enable_reg[0] == ri->enable_reg[1] &&
	    ri->enable_bit[0] == ri->enable_bit[1])
			return 0;

	ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
	if (ret)
		return ret;

	ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
	if (ret)
		return ret;

	if (!(val2 & (1 << ri->enable_bit[1])))
		return 0;

	/*
	 * The regulator is on, but it's enabled with the bit we don't
	 * want to use, so we switch the enable bits
	 */
	if (!(val1 & (1 << ri->enable_bit[0]))) {
		ret = tps6586x_set_bits(parent, ri->enable_reg[0],
					1 << ri->enable_bit[0]);
		if (ret)
			return ret;
	}

	return tps6586x_clr_bits(parent, ri->enable_reg[1],
				 1 << ri->enable_bit[1]);
}

static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev)
{
	struct device *parent = pdev->dev.parent;
	struct regulator_init_data *p = pdev->dev.platform_data;
	struct tps6586x_settings *setting = p->driver_data;
	uint8_t reg;

	if (setting == NULL)
		return 0;

	if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
		return 0;

	/* only SM0 and SM1 can have the slew rate settings */
	switch (pdev->id) {
	case TPS6586X_ID_SM_0:
		reg = TPS6586X_SM0SL;
		break;
	case TPS6586X_ID_SM_1:
		reg = TPS6586X_SM1SL;
		break;
	default:
		dev_warn(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
		return -EINVAL;
	}

	return tps6586x_write(parent, reg,
			setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
}

static inline struct tps6586x_regulator *find_regulator_info(int id)
{
	struct tps6586x_regulator *ri;
	int i;

	for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
		ri = &tps6586x_regulator[i];
		if (ri->desc.id == id)
			return ri;
	}
	return NULL;
}

static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
{
	struct tps6586x_regulator *ri = NULL;
	struct regulator_dev *rdev;
	int id = pdev->id;
	int err;

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

	ri = find_regulator_info(id);
	if (ri == NULL) {
		dev_err(&pdev->dev, "invalid regulator ID specified\n");
		return -EINVAL;
	}

	err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
	if (err)
		return err;

	rdev = regulator_register(&ri->desc, &pdev->dev,
				  pdev->dev.platform_data, ri, NULL);
	if (IS_ERR(rdev)) {
		dev_err(&pdev->dev, "failed to register regulator %s\n",
				ri->desc.name);
		return PTR_ERR(rdev);
	}

	platform_set_drvdata(pdev, rdev);

	return tps6586x_regulator_set_slew_rate(pdev);
}

static int __devexit tps6586x_regulator_remove(struct platform_device *pdev)
{
	struct regulator_dev *rdev = platform_get_drvdata(pdev);

	regulator_unregister(rdev);
	return 0;
}

static struct platform_driver tps6586x_regulator_driver = {
	.driver	= {
		.name	= "tps6586x-regulator",
		.owner	= THIS_MODULE,
	},
	.probe		= tps6586x_regulator_probe,
	.remove		= __devexit_p(tps6586x_regulator_remove),
};

static int __init tps6586x_regulator_init(void)
{
	return platform_driver_register(&tps6586x_regulator_driver);
}
subsys_initcall(tps6586x_regulator_init);

static void __exit tps6586x_regulator_exit(void)
{
	platform_driver_unregister(&tps6586x_regulator_driver);
}
module_exit(tps6586x_regulator_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
MODULE_ALIAS("platform:tps6586x-regulator");
Commit	Line	Data
49610235 MR	1	/*
	2	* Regulator driver for TI TPS6586x
	3	*
	4	* Copyright (C) 2010 Compulab Ltd.
	5	* Author: Mike Rapoport <mike@compulab.co.il>
	6	*
	7	* Based on da903x
	8	* Copyright (C) 2006-2008 Marvell International Ltd.
	9	* Copyright (C) 2008 Compulab Ltd.
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License version 2 as
	13	* published by the Free Software Foundation.
	14	*/
	15
49610235	16	#include <linux/kernel.h>
65602c32	17	#include <linux/module.h>
49610235 MR	18	#include <linux/init.h>
	19	#include <linux/err.h>
	20	#include <linux/slab.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/regulator/driver.h>
	23	#include <linux/regulator/machine.h>
	24	#include <linux/mfd/tps6586x.h>
	25
	26	/* supply control and voltage setting */
	27	#define TPS6586X_SUPPLYENA 0x10
	28	#define TPS6586X_SUPPLYENB 0x11
	29	#define TPS6586X_SUPPLYENC 0x12
	30	#define TPS6586X_SUPPLYEND 0x13
	31	#define TPS6586X_SUPPLYENE 0x14
	32	#define TPS6586X_VCC1 0x20
	33	#define TPS6586X_VCC2 0x21
	34	#define TPS6586X_SM1V1 0x23
	35	#define TPS6586X_SM1V2 0x24
	36	#define TPS6586X_SM1SL 0x25
	37	#define TPS6586X_SM0V1 0x26
	38	#define TPS6586X_SM0V2 0x27
	39	#define TPS6586X_SM0SL 0x28
	40	#define TPS6586X_LDO2AV1 0x29
	41	#define TPS6586X_LDO2AV2 0x2A
	42	#define TPS6586X_LDO2BV1 0x2F
	43	#define TPS6586X_LDO2BV2 0x30
	44	#define TPS6586X_LDO4V1 0x32
	45	#define TPS6586X_LDO4V2 0x33
	46
	47	/* converter settings */
	48	#define TPS6586X_SUPPLYV1 0x41
	49	#define TPS6586X_SUPPLYV2 0x42
	50	#define TPS6586X_SUPPLYV3 0x43
	51	#define TPS6586X_SUPPLYV4 0x44
	52	#define TPS6586X_SUPPLYV5 0x45
	53	#define TPS6586X_SUPPLYV6 0x46
	54	#define TPS6586X_SMODE1 0x47
	55	#define TPS6586X_SMODE2 0x48
	56
	57	struct tps6586x_regulator {
	58	struct regulator_desc desc;
	59
	60	int volt_reg;
	61	int volt_shift;
	62	int volt_nbits;
	63	int enable_bit[2];
	64	int enable_reg[2];
	65
	66	int *voltages;
	67
	68	/* for DVM regulators */
	69	int go_reg;
	70	int go_bit;
	71	};
	72
	73	static inline struct device to_tps6586x_dev(struct regulator_dev rdev)
	74	{
	75	return rdev_get_dev(rdev)->parent->parent;
	76	}
	77
	78	static int tps6586x_ldo_list_voltage(struct regulator_dev *rdev,
	79	unsigned selector)
	80	{
	81	struct tps6586x_regulator *info = rdev_get_drvdata(rdev);
51579137 AL	82	int rid = rdev_get_id(rdev);
	83
	84	/* LDO0 has minimal voltage 1.2V rather than 1.25V */
	85	if ((rid == TPS6586X_ID_LDO_0) && (selector == 0))
	86	return (info->voltages[0] - 50) * 1000;
49610235	87
4cc2e393	88	return info->voltages[selector] * 1000;
49610235 MR	89	}
	90
	91
	92	static int __tps6586x_ldo_set_voltage(struct device *parent,
	93	struct tps6586x_regulator *ri,
3a93f2a9 MB	94	int min_uV, int max_uV,
3a93f2a9 MB	95	unsigned *selector)
49610235 MR	96	{
	97	int val, uV;
	98	uint8_t mask;
	99
	100	for (val = 0; val < ri->desc.n_voltages; val++) {
	101	uV = ri->voltages[val] * 1000;
	102
	103	/* LDO0 has minimal voltage 1.2 rather than 1.25 */
	104	if (ri->desc.id == TPS6586X_ID_LDO_0 && val == 0)
	105	uV -= 50 * 1000;
	106
	107	/* use the first in-range value */
	108	if (min_uV <= uV && uV <= max_uV) {
	109
3a93f2a9 MB	110	*selector = val;
3a93f2a9 MB	111
49610235 MR	112	val <<= ri->volt_shift;
	113	mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
	114
	115	return tps6586x_update(parent, ri->volt_reg, val, mask);
	116	}
	117	}
	118
	119	return -EINVAL;
	120	}
	121
	122	static int tps6586x_ldo_set_voltage(struct regulator_dev *rdev,
3a93f2a9	123	int min_uV, int max_uV, unsigned *selector)
49610235 MR	124	{
	125	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	126	struct device *parent = to_tps6586x_dev(rdev);
	127
3a93f2a9 MB	128	return __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
3a93f2a9 MB	129	selector);
49610235 MR	130	}
	131
	132	static int tps6586x_ldo_get_voltage(struct regulator_dev *rdev)
	133	{
	134	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	135	struct device *parent = to_tps6586x_dev(rdev);
	136	uint8_t val, mask;
	137	int ret;
	138
	139	ret = tps6586x_read(parent, ri->volt_reg, &val);
	140	if (ret)
	141	return ret;
	142
	143	mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
	144	val = (val & mask) >> ri->volt_shift;
	145
327531ba	146	if (val >= ri->desc.n_voltages)
49610235 MR	147	BUG();
49610235 MR	148
4cc2e393	149	return ri->voltages[val] * 1000;
49610235 MR	150	}
	151
	152	static int tps6586x_dvm_set_voltage(struct regulator_dev *rdev,
3a93f2a9	153	int min_uV, int max_uV, unsigned *selector)
49610235 MR	154	{
	155	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	156	struct device *parent = to_tps6586x_dev(rdev);
	157	int ret;
	158
3a93f2a9 MB	159	ret = __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
3a93f2a9 MB	160	selector);
49610235 MR	161	if (ret)
	162	return ret;
	163
938b4592	164	return tps6586x_set_bits(parent, ri->go_reg, 1 << ri->go_bit);
49610235 MR	165	}
	166
	167	static int tps6586x_regulator_enable(struct regulator_dev *rdev)
	168	{
	169	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	170	struct device *parent = to_tps6586x_dev(rdev);
	171
	172	return tps6586x_set_bits(parent, ri->enable_reg[0],
	173	1 << ri->enable_bit[0]);
	174	}
	175
	176	static int tps6586x_regulator_disable(struct regulator_dev *rdev)
	177	{
	178	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	179	struct device *parent = to_tps6586x_dev(rdev);
	180
	181	return tps6586x_clr_bits(parent, ri->enable_reg[0],
	182	1 << ri->enable_bit[0]);
	183	}
	184
	185	static int tps6586x_regulator_is_enabled(struct regulator_dev *rdev)
	186	{
	187	struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
	188	struct device *parent = to_tps6586x_dev(rdev);
	189	uint8_t reg_val;
	190	int ret;
	191
	192	ret = tps6586x_read(parent, ri->enable_reg[0], &reg_val);
	193	if (ret)
	194	return ret;
	195
	196	return !!(reg_val & (1 << ri->enable_bit[0]));
	197	}
	198
	199	static struct regulator_ops tps6586x_regulator_ldo_ops = {
	200	.list_voltage = tps6586x_ldo_list_voltage,
	201	.get_voltage = tps6586x_ldo_get_voltage,
	202	.set_voltage = tps6586x_ldo_set_voltage,
	203
	204	.is_enabled = tps6586x_regulator_is_enabled,
	205	.enable = tps6586x_regulator_enable,
	206	.disable = tps6586x_regulator_disable,
	207	};
	208
	209	static struct regulator_ops tps6586x_regulator_dvm_ops = {
	210	.list_voltage = tps6586x_ldo_list_voltage,
	211	.get_voltage = tps6586x_ldo_get_voltage,
	212	.set_voltage = tps6586x_dvm_set_voltage,
	213
	214	.is_enabled = tps6586x_regulator_is_enabled,
	215	.enable = tps6586x_regulator_enable,
	216	.disable = tps6586x_regulator_disable,
	217	};
	218
	219	static int tps6586x_ldo_voltages[] = {
	220	1250, 1500, 1800, 2500, 2700, 2850, 3100, 3300,
	221	};
	222
	223	static int tps6586x_ldo4_voltages[] = {
	224	1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
	225	1900, 1925, 1950, 1975, 2000, 2025, 2050, 2075,
	226	2100, 2125, 2150, 2175, 2200, 2225, 2250, 2275,
	227	2300, 2325, 2350, 2375, 2400, 2425, 2450, 2475,
	228	};
229
4cc2e393 GK	230	static int tps6586x_sm2_voltages[] = {
	231	3000, 3050, 3100, 3150, 3200, 3250, 3300, 3350,
	232	3400, 3450, 3500, 3550, 3600, 3650, 3700, 3750,
	233	3800, 3850, 3900, 3950, 4000, 4050, 4100, 4150,
	234	4200, 4250, 4300, 4350, 4400, 4450, 4500, 4550,
	235	};
	236
49610235 MR	237	static int tps6586x_dvm_voltages[] = {
	238	725, 750, 775, 800, 825, 850, 875, 900,
	239	925, 950, 975, 1000, 1025, 1050, 1075, 1100,
	240	1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
	241	1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
	242	};
	243
	244	#define TPS6586X_REGULATOR(_id, vdata, _ops, vreg, shift, nbits, \
64db657b	245	ereg0, ebit0, ereg1, ebit1) \
49610235 MR	246	.desc = { \
	247	.name = "REG-" #_id, \
	248	.ops = &tps6586x_regulator_##_ops, \
	249	.type = REGULATOR_VOLTAGE, \
	250	.id = TPS6586X_ID_##_id, \
	251	.n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages), \
	252	.owner = THIS_MODULE, \
	253	}, \
	254	.volt_reg = TPS6586X_##vreg, \
	255	.volt_shift = (shift), \
	256	.volt_nbits = (nbits), \
	257	.enable_reg[0] = TPS6586X_SUPPLY##ereg0, \
	258	.enable_bit[0] = (ebit0), \
	259	.enable_reg[1] = TPS6586X_SUPPLY##ereg1, \
	260	.enable_bit[1] = (ebit1), \
64db657b DH	261	.voltages = tps6586x_##vdata##_voltages,
	262
	263	#define TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit) \
	264	.go_reg = TPS6586X_##goreg, \
	265	.go_bit = (gobit),
49610235 MR	266
	267	#define TPS6586X_LDO(_id, vdata, vreg, shift, nbits, \
	268	ereg0, ebit0, ereg1, ebit1) \
64db657b	269	{ \
49610235	270	TPS6586X_REGULATOR(_id, vdata, ldo_ops, vreg, shift, nbits, \
64db657b DH	271	ereg0, ebit0, ereg1, ebit1) \
64db657b DH	272	}
49610235 MR	273
	274	#define TPS6586X_DVM(_id, vdata, vreg, shift, nbits, \
	275	ereg0, ebit0, ereg1, ebit1, goreg, gobit) \
64db657b	276	{ \
49610235	277	TPS6586X_REGULATOR(_id, vdata, dvm_ops, vreg, shift, nbits, \
64db657b DH	278	ereg0, ebit0, ereg1, ebit1) \
	279	TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit) \
	280	}
49610235 MR	281
	282	static struct tps6586x_regulator tps6586x_regulator[] = {
	283	TPS6586X_LDO(LDO_0, ldo, SUPPLYV1, 5, 3, ENC, 0, END, 0),
	284	TPS6586X_LDO(LDO_3, ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
	285	TPS6586X_LDO(LDO_5, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
	286	TPS6586X_LDO(LDO_6, ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
	287	TPS6586X_LDO(LDO_7, ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
1b39ed0c	288	TPS6586X_LDO(LDO_8, ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
49610235	289	TPS6586X_LDO(LDO_9, ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
1b39ed0c	290	TPS6586X_LDO(LDO_RTC, ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
49610235	291	TPS6586X_LDO(LDO_1, dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
1b39ed0c	292	TPS6586X_LDO(SM_2, sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
49610235 MR	293
	294	TPS6586X_DVM(LDO_2, dvm, LDO2BV1, 0, 5, ENA, 3, ENB, 3, VCC2, 6),
	295	TPS6586X_DVM(LDO_4, ldo4, LDO4V1, 0, 5, ENC, 3, END, 3, VCC1, 6),
	296	TPS6586X_DVM(SM_0, dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2),
	297	TPS6586X_DVM(SM_1, dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0),
	298	};
	299
	300	/*
	301	* TPS6586X has 2 enable bits that are OR'ed to determine the actual
	302	* regulator state. Clearing one of this bits allows switching
	303	* regulator on and of with single register write.
	304	*/
	305	static inline int tps6586x_regulator_preinit(struct device *parent,
	306	struct tps6586x_regulator *ri)
	307	{
	308	uint8_t val1, val2;
	309	int ret;
	310
1dbcf35c DH	311	if (ri->enable_reg[0] == ri->enable_reg[1] &&
	312	ri->enable_bit[0] == ri->enable_bit[1])
	313	return 0;
	314
49610235 MR	315	ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
	316	if (ret)
	317	return ret;
	318
	319	ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
	320	if (ret)
	321	return ret;
	322
4f586707	323	if (!(val2 & (1 << ri->enable_bit[1])))
49610235 MR	324	return 0;
	325
	326	/*
	327	* The regulator is on, but it's enabled with the bit we don't
	328	* want to use, so we switch the enable bits
	329	*/
4f586707	330	if (!(val1 & (1 << ri->enable_bit[0]))) {
49610235 MR	331	ret = tps6586x_set_bits(parent, ri->enable_reg[0],
	332	1 << ri->enable_bit[0]);
	333	if (ret)
	334	return ret;
	335	}
	336
	337	return tps6586x_clr_bits(parent, ri->enable_reg[1],
	338	1 << ri->enable_bit[1]);
	339	}
	340
500c524a XX	341	static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev)
	342	{
	343	struct device *parent = pdev->dev.parent;
	344	struct regulator_init_data *p = pdev->dev.platform_data;
	345	struct tps6586x_settings *setting = p->driver_data;
	346	uint8_t reg;
	347
	348	if (setting == NULL)
	349	return 0;
	350
	351	if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
	352	return 0;
	353
	354	/* only SM0 and SM1 can have the slew rate settings */
	355	switch (pdev->id) {
	356	case TPS6586X_ID_SM_0:
	357	reg = TPS6586X_SM0SL;
	358	break;
	359	case TPS6586X_ID_SM_1:
	360	reg = TPS6586X_SM1SL;
	361	break;
	362	default:
	363	dev_warn(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
	364	return -EINVAL;
	365	}
	366
	367	return tps6586x_write(parent, reg,
	368	setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
	369	}
	370
49610235 MR	371	static inline struct tps6586x_regulator *find_regulator_info(int id)
	372	{
	373	struct tps6586x_regulator *ri;
	374	int i;
	375
	376	for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
	377	ri = &tps6586x_regulator[i];
	378	if (ri->desc.id == id)
	379	return ri;
	380	}
	381	return NULL;
	382	}
	383
	384	static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
	385	{
	386	struct tps6586x_regulator *ri = NULL;
	387	struct regulator_dev *rdev;
	388	int id = pdev->id;
	389	int err;
	390
394ee3d5	391	dev_dbg(&pdev->dev, "Probing regulator %d\n", id);
49610235 MR	392
	393	ri = find_regulator_info(id);
	394	if (ri == NULL) {
	395	dev_err(&pdev->dev, "invalid regulator ID specified\n");
	396	return -EINVAL;
	397	}
	398
	399	err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
	400	if (err)
	401	return err;
	402
	403	rdev = regulator_register(&ri->desc, &pdev->dev,
2c043bcb	404	pdev->dev.platform_data, ri, NULL);
49610235 MR	405	if (IS_ERR(rdev)) {
	406	dev_err(&pdev->dev, "failed to register regulator %s\n",
	407	ri->desc.name);
	408	return PTR_ERR(rdev);
	409	}
	410
e7973c3c	411	platform_set_drvdata(pdev, rdev);
49610235	412
500c524a	413	return tps6586x_regulator_set_slew_rate(pdev);
49610235 MR	414	}
	415
	416	static int __devexit tps6586x_regulator_remove(struct platform_device *pdev)
	417	{
e7973c3c AL	418	struct regulator_dev *rdev = platform_get_drvdata(pdev);
	419
	420	regulator_unregister(rdev);
49610235 MR	421	return 0;
	422	}
	423
	424	static struct platform_driver tps6586x_regulator_driver = {
	425	.driver = {
	426	.name = "tps6586x-regulator",
	427	.owner = THIS_MODULE,
	428	},
	429	.probe = tps6586x_regulator_probe,
	430	.remove = __devexit_p(tps6586x_regulator_remove),
	431	};
	432
	433	static int __init tps6586x_regulator_init(void)
	434	{
	435	return platform_driver_register(&tps6586x_regulator_driver);
	436	}
	437	subsys_initcall(tps6586x_regulator_init);
	438
	439	static void __exit tps6586x_regulator_exit(void)
	440	{
	441	platform_driver_unregister(&tps6586x_regulator_driver);
	442	}
	443	module_exit(tps6586x_regulator_exit);
	444
	445	MODULE_LICENSE("GPL");
	446	MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
	447	MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
	448	MODULE_ALIAS("platform:tps6586x-regulator");