[GitHub/mt8127/android_kernel_alcatel_ttab.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/of.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.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 enable_bit[2];
	int enable_reg[2];
};

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

static struct regulator_ops tps6586x_regulator_ops = {
	.list_voltage = regulator_list_voltage_table,
	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	.set_voltage_sel = regulator_set_voltage_sel_regmap,

	.is_enabled = regulator_is_enabled_regmap,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
};

static struct regulator_ops tps6586x_sys_regulator_ops = {
};

static const unsigned int tps6586x_ldo0_voltages[] = {
	1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
};

static const unsigned int tps6586x_ldo4_voltages[] = {
	1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
	1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000,
	2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000,
	2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
};

static const unsigned int tps6586x_ldo_voltages[] = {
	1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
};

static const unsigned int tps6586x_sm2_voltages[] = {
	3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000,
	3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000,
	3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000,
	4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
};

static const unsigned int tps6586x_dvm_voltages[] = {
	 725000,  750000,  775000,  800000,  825000,  850000,  875000,  900000,
	 925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
	1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
	1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
};

#define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits,	\
			   ereg0, ebit0, ereg1, ebit1, goreg, gobit)	\
	.desc	= {							\
		.supply_name = _pin_name,				\
		.name	= "REG-" #_id,					\
		.ops	= &tps6586x_regulator_ops,			\
		.type	= REGULATOR_VOLTAGE,				\
		.id	= TPS6586X_ID_##_id,				\
		.n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),	\
		.volt_table = tps6586x_##vdata##_voltages,		\
		.owner	= THIS_MODULE,					\
		.enable_reg = TPS6586X_SUPPLY##ereg0,			\
		.enable_mask = 1 << (ebit0),				\
		.vsel_reg = TPS6586X_##vreg,				\
		.vsel_mask = ((1 << (nbits)) - 1) << (shift),		\
		.apply_reg = (goreg),				\
		.apply_bit = (gobit),				\
	},								\
	.enable_reg[0]	= TPS6586X_SUPPLY##ereg0,			\
	.enable_bit[0]	= (ebit0),					\
	.enable_reg[1]	= TPS6586X_SUPPLY##ereg1,			\
	.enable_bit[1]	= (ebit1),

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

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

#define TPS6586X_SYS_REGULATOR()					\
{									\
	.desc	= {							\
		.supply_name = "sys",					\
		.name	= "REG-SYS",					\
		.ops	= &tps6586x_sys_regulator_ops,			\
		.type	= REGULATOR_VOLTAGE,				\
		.id	= TPS6586X_ID_SYS,				\
		.owner	= THIS_MODULE,					\
	},								\
}

static struct tps6586x_regulator tps6586x_regulator[] = {
	TPS6586X_SYS_REGULATOR(),
	TPS6586X_LDO(LDO_0, "vinldo01", ldo0, SUPPLYV1, 5, 3, ENC, 0, END, 0),
	TPS6586X_LDO(LDO_3, "vinldo23", ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
	TPS6586X_LDO(LDO_5, "REG-SYS", ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
	TPS6586X_LDO(LDO_6, "vinldo678", ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
	TPS6586X_LDO(LDO_7, "vinldo678", ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
	TPS6586X_LDO(LDO_8, "vinldo678", ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
	TPS6586X_LDO(LDO_9, "vinldo9", ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
	TPS6586X_LDO(LDO_RTC, "REG-SYS", ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
	TPS6586X_LDO(LDO_1, "vinldo01", dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
	TPS6586X_LDO(SM_2, "vin-sm2", sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),

	TPS6586X_DVM(LDO_2, "vinldo23", dvm, LDO2BV1, 0, 5, ENA, 3,
					ENB, 3, TPS6586X_VCC2, BIT(6)),
	TPS6586X_DVM(LDO_4, "vinldo4", ldo4, LDO4V1, 0, 5, ENC, 3,
					END, 3, TPS6586X_VCC1, BIT(6)),
	TPS6586X_DVM(SM_0, "vin-sm0", dvm, SM0V1, 0, 5, ENA, 1,
					ENB, 1, TPS6586X_VCC1, BIT(2)),
	TPS6586X_DVM(SM_1, "vin-sm1", dvm, SM1V1, 0, 5, ENA, 0,
					ENB, 0, TPS6586X_VCC1, BIT(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,
			int id, struct regulator_init_data *p)
{
	struct device *parent = pdev->dev.parent;
	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 (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;
}

#ifdef CONFIG_OF
static struct of_regulator_match tps6586x_matches[] = {
	{ .name = "sys",     .driver_data = (void *)TPS6586X_ID_SYS     },
	{ .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
	{ .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
	{ .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
	{ .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
	{ .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
	{ .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
	{ .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
	{ .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
	{ .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
	{ .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
	{ .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
	{ .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
	{ .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
	{ .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
};

static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
		struct platform_device *pdev,
		struct of_regulator_match **tps6586x_reg_matches)
{
	const unsigned int num = ARRAY_SIZE(tps6586x_matches);
	struct device_node *np = pdev->dev.parent->of_node;
	struct device_node *regs;
	const char *sys_rail = NULL;
	unsigned int i;
	struct tps6586x_platform_data *pdata;
	int err;

	regs = of_find_node_by_name(np, "regulators");
	if (!regs) {
		dev_err(&pdev->dev, "regulator node not found\n");
		return NULL;
	}

	err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
	if (err < 0) {
		dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
		of_node_put(regs);
		return NULL;
	}

	of_node_put(regs);

	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata) {
		dev_err(&pdev->dev, "Memory alloction failed\n");
		return NULL;
	}

	for (i = 0; i < num; i++) {
		int id;
		if (!tps6586x_matches[i].init_data)
			continue;

		pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
		id = (int)tps6586x_matches[i].driver_data;
		if (id == TPS6586X_ID_SYS)
			sys_rail = pdata->reg_init_data[i]->constraints.name;

		if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
			pdata->reg_init_data[i]->supply_regulator = sys_rail;
	}
	*tps6586x_reg_matches = tps6586x_matches;
	return pdata;
}
#else
static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
		struct platform_device *pdev,
		struct of_regulator_match **tps6586x_reg_matches)
{
	*tps6586x_reg_matches = NULL;
	return NULL;
}
#endif

static int tps6586x_regulator_probe(struct platform_device *pdev)
{
	struct tps6586x_regulator *ri = NULL;
	struct regulator_config config = { };
	struct regulator_dev **rdev;
	struct regulator_init_data *reg_data;
	struct tps6586x_platform_data *pdata;
	struct of_regulator_match *tps6586x_reg_matches = NULL;
	int id;
	int err;

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

	pdata = dev_get_platdata(pdev->dev.parent);
	if ((!pdata) && (pdev->dev.parent->of_node))
		pdata = tps6586x_parse_regulator_dt(pdev,
					&tps6586x_reg_matches);

	if (!pdata) {
		dev_err(&pdev->dev, "Platform data not available, exiting\n");
		return -ENODEV;
	}

	rdev = devm_kzalloc(&pdev->dev, TPS6586X_ID_MAX_REGULATOR *
				sizeof(*rdev), GFP_KERNEL);
	if (!rdev) {
		dev_err(&pdev->dev, "Mmemory alloc failed\n");
		return -ENOMEM;
	}

	for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
		reg_data = pdata->reg_init_data[id];

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

		err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
		if (err) {
			dev_err(&pdev->dev,
				"regulator %d preinit failed, e %d\n", id, err);
			goto fail;
		}

		config.dev = pdev->dev.parent;
		config.init_data = reg_data;
		config.driver_data = ri;

		if (tps6586x_reg_matches)
			config.of_node = tps6586x_reg_matches[id].of_node;

		rdev[id] = regulator_register(&ri->desc, &config);
		if (IS_ERR(rdev[id])) {
			dev_err(&pdev->dev, "failed to register regulator %s\n",
					ri->desc.name);
			err = PTR_ERR(rdev[id]);
			goto fail;
		}

		if (reg_data) {
			err = tps6586x_regulator_set_slew_rate(pdev, id,
					reg_data);
			if (err < 0) {
				dev_err(&pdev->dev,
					"Slew rate config failed, e %d\n", err);
				regulator_unregister(rdev[id]);
				goto fail;
			}
		}
	}

	platform_set_drvdata(pdev, rdev);
	return 0;

fail:
	while (--id >= 0)
		regulator_unregister(rdev[id]);
	return err;
}

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

	while (--id >= 0)
		regulator_unregister(rdev[id]);

	return 0;
}

static struct platform_driver tps6586x_regulator_driver = {
	.driver	= {
		.name	= "tps6586x-pmic",
		.owner	= THIS_MODULE,
	},
	.probe		= tps6586x_regulator_probe,
	.remove		= 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>
49610235 MR	19	#include <linux/err.h>
64e48160	20	#include <linux/of.h>
49610235 MR	21	#include <linux/slab.h>
	22	#include <linux/platform_device.h>
	23	#include <linux/regulator/driver.h>
	24	#include <linux/regulator/machine.h>
64e48160	25	#include <linux/regulator/of_regulator.h>
49610235 MR	26	#include <linux/mfd/tps6586x.h>
	27
	28	/* supply control and voltage setting */
	29	#define TPS6586X_SUPPLYENA 0x10
	30	#define TPS6586X_SUPPLYENB 0x11
	31	#define TPS6586X_SUPPLYENC 0x12
	32	#define TPS6586X_SUPPLYEND 0x13
	33	#define TPS6586X_SUPPLYENE 0x14
	34	#define TPS6586X_VCC1 0x20
	35	#define TPS6586X_VCC2 0x21
	36	#define TPS6586X_SM1V1 0x23
	37	#define TPS6586X_SM1V2 0x24
	38	#define TPS6586X_SM1SL 0x25
	39	#define TPS6586X_SM0V1 0x26
	40	#define TPS6586X_SM0V2 0x27
	41	#define TPS6586X_SM0SL 0x28
	42	#define TPS6586X_LDO2AV1 0x29
	43	#define TPS6586X_LDO2AV2 0x2A
	44	#define TPS6586X_LDO2BV1 0x2F
	45	#define TPS6586X_LDO2BV2 0x30
	46	#define TPS6586X_LDO4V1 0x32
	47	#define TPS6586X_LDO4V2 0x33
	48
	49	/* converter settings */
	50	#define TPS6586X_SUPPLYV1 0x41
	51	#define TPS6586X_SUPPLYV2 0x42
	52	#define TPS6586X_SUPPLYV3 0x43
	53	#define TPS6586X_SUPPLYV4 0x44
	54	#define TPS6586X_SUPPLYV5 0x45
	55	#define TPS6586X_SUPPLYV6 0x46
	56	#define TPS6586X_SMODE1 0x47
	57	#define TPS6586X_SMODE2 0x48
	58
	59	struct tps6586x_regulator {
	60	struct regulator_desc desc;
	61
49610235 MR	62	int enable_bit[2];
49610235 MR	63	int enable_reg[2];
49610235 MR	64	};
	65
	66	static inline struct device to_tps6586x_dev(struct regulator_dev rdev)
	67	{
7c7fac30	68	return rdev_get_dev(rdev)->parent;
49610235 MR	69	}
49610235 MR	70
e1816235	71	static struct regulator_ops tps6586x_regulator_ops = {
f4647037	72	.list_voltage = regulator_list_voltage_table,
7c7475c0	73	.get_voltage_sel = regulator_get_voltage_sel_regmap,
d645d591	74	.set_voltage_sel = regulator_set_voltage_sel_regmap,
49610235	75
7c7475c0 AL	76	.is_enabled = regulator_is_enabled_regmap,
	77	.enable = regulator_enable_regmap,
	78	.disable = regulator_disable_regmap,
49610235 MR	79	};
49610235 MR	80
9394b80c	81	static struct regulator_ops tps6586x_sys_regulator_ops = {
49610235 MR	82	};
49610235 MR	83
f4647037 AL	84	static const unsigned int tps6586x_ldo0_voltages[] = {
	85	1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
	86	};
	87
	88	static const unsigned int tps6586x_ldo4_voltages[] = {
	89	1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
	90	1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000,
	91	2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000,
	92	2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
49610235 MR	93	};
49610235 MR	94
f4647037 AL	95	static const unsigned int tps6586x_ldo_voltages[] = {
f4647037 AL	96	1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
49610235 MR	97	};
49610235 MR	98
f4647037 AL	99	static const unsigned int tps6586x_sm2_voltages[] = {
	100	3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000,
	101	3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000,
	102	3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000,
	103	4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
4cc2e393 GK	104	};
4cc2e393 GK	105
f4647037 AL	106	static const unsigned int tps6586x_dvm_voltages[] = {
	107	725000, 750000, 775000, 800000, 825000, 850000, 875000, 900000,
	108	925000, 950000, 975000, 1000000, 1025000, 1050000, 1075000, 1100000,
	109	1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
	110	1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
49610235 MR	111	};
49610235 MR	112
7c7fac30	113	#define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits, \
d645d591	114	ereg0, ebit0, ereg1, ebit1, goreg, gobit) \
49610235	115	.desc = { \
7c7fac30	116	.supply_name = _pin_name, \
49610235	117	.name = "REG-" #_id, \
e1816235	118	.ops = &tps6586x_regulator_ops, \
49610235 MR	119	.type = REGULATOR_VOLTAGE, \
	120	.id = TPS6586X_ID_##_id, \
	121	.n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages), \
f4647037	122	.volt_table = tps6586x_##vdata##_voltages, \
49610235	123	.owner = THIS_MODULE, \
7c7475c0 AL	124	.enable_reg = TPS6586X_SUPPLY##ereg0, \
	125	.enable_mask = 1 << (ebit0), \
	126	.vsel_reg = TPS6586X_##vreg, \
	127	.vsel_mask = ((1 << (nbits)) - 1) << (shift), \
d645d591 AL	128	.apply_reg = (goreg), \
d645d591 AL	129	.apply_bit = (gobit), \
49610235	130	}, \
49610235 MR	131	.enable_reg[0] = TPS6586X_SUPPLY##ereg0, \
	132	.enable_bit[0] = (ebit0), \
	133	.enable_reg[1] = TPS6586X_SUPPLY##ereg1, \
f4647037	134	.enable_bit[1] = (ebit1),
64db657b	135
7c7fac30	136	#define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits, \
49610235	137	ereg0, ebit0, ereg1, ebit1) \
64db657b	138	{ \
7c7fac30	139	TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits, \
d645d591	140	ereg0, ebit0, ereg1, ebit1, 0, 0) \
64db657b	141	}
49610235	142
7c7fac30	143	#define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits, \
49610235	144	ereg0, ebit0, ereg1, ebit1, goreg, gobit) \
64db657b	145	{ \
7c7fac30	146	TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits, \
d645d591	147	ereg0, ebit0, ereg1, ebit1, goreg, gobit) \
64db657b	148	}
49610235	149
9394b80c LD	150	#define TPS6586X_SYS_REGULATOR() \
	151	{ \
	152	.desc = { \
	153	.supply_name = "sys", \
	154	.name = "REG-SYS", \
	155	.ops = &tps6586x_sys_regulator_ops, \
	156	.type = REGULATOR_VOLTAGE, \
	157	.id = TPS6586X_ID_SYS, \
	158	.owner = THIS_MODULE, \
	159	}, \
	160	}
	161
49610235	162	static struct tps6586x_regulator tps6586x_regulator[] = {
9394b80c	163	TPS6586X_SYS_REGULATOR(),
7c7fac30 LD	164	TPS6586X_LDO(LDO_0, "vinldo01", ldo0, SUPPLYV1, 5, 3, ENC, 0, END, 0),
7c7fac30 LD	165	TPS6586X_LDO(LDO_3, "vinldo23", ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
9394b80c	166	TPS6586X_LDO(LDO_5, "REG-SYS", ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
7c7fac30 LD	167	TPS6586X_LDO(LDO_6, "vinldo678", ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
	168	TPS6586X_LDO(LDO_7, "vinldo678", ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
	169	TPS6586X_LDO(LDO_8, "vinldo678", ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
	170	TPS6586X_LDO(LDO_9, "vinldo9", ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
9394b80c	171	TPS6586X_LDO(LDO_RTC, "REG-SYS", ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
7c7fac30	172	TPS6586X_LDO(LDO_1, "vinldo01", dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
7f852e05	173	TPS6586X_LDO(SM_2, "vin-sm2", sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
7c7fac30 LD	174
7c7fac30 LD	175	TPS6586X_DVM(LDO_2, "vinldo23", dvm, LDO2BV1, 0, 5, ENA, 3,
d645d591	176	ENB, 3, TPS6586X_VCC2, BIT(6)),
7c7fac30	177	TPS6586X_DVM(LDO_4, "vinldo4", ldo4, LDO4V1, 0, 5, ENC, 3,
d645d591	178	END, 3, TPS6586X_VCC1, BIT(6)),
7f852e05	179	TPS6586X_DVM(SM_0, "vin-sm0", dvm, SM0V1, 0, 5, ENA, 1,
d645d591	180	ENB, 1, TPS6586X_VCC1, BIT(2)),
7f852e05	181	TPS6586X_DVM(SM_1, "vin-sm1", dvm, SM1V1, 0, 5, ENA, 0,
d645d591	182	ENB, 0, TPS6586X_VCC1, BIT(0)),
49610235 MR	183	};
	184
	185	/*
	186	* TPS6586X has 2 enable bits that are OR'ed to determine the actual
	187	* regulator state. Clearing one of this bits allows switching
	188	* regulator on and of with single register write.
	189	*/
	190	static inline int tps6586x_regulator_preinit(struct device *parent,
	191	struct tps6586x_regulator *ri)
	192	{
	193	uint8_t val1, val2;
	194	int ret;
	195
1dbcf35c DH	196	if (ri->enable_reg[0] == ri->enable_reg[1] &&
	197	ri->enable_bit[0] == ri->enable_bit[1])
	198	return 0;
	199
49610235 MR	200	ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
	201	if (ret)
	202	return ret;
	203
	204	ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
	205	if (ret)
	206	return ret;
	207
4f586707	208	if (!(val2 & (1 << ri->enable_bit[1])))
49610235 MR	209	return 0;
	210
	211	/*
	212	* The regulator is on, but it's enabled with the bit we don't
	213	* want to use, so we switch the enable bits
	214	*/
4f586707	215	if (!(val1 & (1 << ri->enable_bit[0]))) {
49610235 MR	216	ret = tps6586x_set_bits(parent, ri->enable_reg[0],
	217	1 << ri->enable_bit[0]);
	218	if (ret)
	219	return ret;
	220	}
	221
	222	return tps6586x_clr_bits(parent, ri->enable_reg[1],
	223	1 << ri->enable_bit[1]);
	224	}
	225
64e48160 LD	226	static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
64e48160 LD	227	int id, struct regulator_init_data *p)
500c524a XX	228	{
500c524a XX	229	struct device *parent = pdev->dev.parent;
500c524a XX	230	struct tps6586x_settings *setting = p->driver_data;
	231	uint8_t reg;
	232
	233	if (setting == NULL)
	234	return 0;
	235
	236	if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
	237	return 0;
	238
	239	/* only SM0 and SM1 can have the slew rate settings */
64e48160	240	switch (id) {
500c524a XX	241	case TPS6586X_ID_SM_0:
	242	reg = TPS6586X_SM0SL;
	243	break;
	244	case TPS6586X_ID_SM_1:
	245	reg = TPS6586X_SM1SL;
	246	break;
	247	default:
	248	dev_warn(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
	249	return -EINVAL;
	250	}
	251
	252	return tps6586x_write(parent, reg,
	253	setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
	254	}
	255
49610235 MR	256	static inline struct tps6586x_regulator *find_regulator_info(int id)
	257	{
	258	struct tps6586x_regulator *ri;
	259	int i;
	260
	261	for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
	262	ri = &tps6586x_regulator[i];
	263	if (ri->desc.id == id)
	264	return ri;
	265	}
	266	return NULL;
	267	}
	268
64e48160 LD	269	#ifdef CONFIG_OF
	270	static struct of_regulator_match tps6586x_matches[] = {
	271	{ .name = "sys", .driver_data = (void *)TPS6586X_ID_SYS },
	272	{ .name = "sm0", .driver_data = (void *)TPS6586X_ID_SM_0 },
	273	{ .name = "sm1", .driver_data = (void *)TPS6586X_ID_SM_1 },
	274	{ .name = "sm2", .driver_data = (void *)TPS6586X_ID_SM_2 },
	275	{ .name = "ldo0", .driver_data = (void *)TPS6586X_ID_LDO_0 },
	276	{ .name = "ldo1", .driver_data = (void *)TPS6586X_ID_LDO_1 },
	277	{ .name = "ldo2", .driver_data = (void *)TPS6586X_ID_LDO_2 },
	278	{ .name = "ldo3", .driver_data = (void *)TPS6586X_ID_LDO_3 },
	279	{ .name = "ldo4", .driver_data = (void *)TPS6586X_ID_LDO_4 },
	280	{ .name = "ldo5", .driver_data = (void *)TPS6586X_ID_LDO_5 },
	281	{ .name = "ldo6", .driver_data = (void *)TPS6586X_ID_LDO_6 },
	282	{ .name = "ldo7", .driver_data = (void *)TPS6586X_ID_LDO_7 },
	283	{ .name = "ldo8", .driver_data = (void *)TPS6586X_ID_LDO_8 },
	284	{ .name = "ldo9", .driver_data = (void *)TPS6586X_ID_LDO_9 },
	285	{ .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
	286	};
	287
	288	static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
	289	struct platform_device *pdev,
	290	struct of_regulator_match **tps6586x_reg_matches)
	291	{
	292	const unsigned int num = ARRAY_SIZE(tps6586x_matches);
	293	struct device_node *np = pdev->dev.parent->of_node;
	294	struct device_node *regs;
	295	const char *sys_rail = NULL;
	296	unsigned int i;
	297	struct tps6586x_platform_data *pdata;
	298	int err;
	299
	300	regs = of_find_node_by_name(np, "regulators");
	301	if (!regs) {
	302	dev_err(&pdev->dev, "regulator node not found\n");
	303	return NULL;
	304	}
	305
	306	err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
	307	if (err < 0) {
	308	dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
	309	of_node_put(regs);
	310	return NULL;
	311	}
	312
	313	of_node_put(regs);
	314
	315	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
	316	if (!pdata) {
	317	dev_err(&pdev->dev, "Memory alloction failed\n");
	318	return NULL;
	319	}
	320
	321	for (i = 0; i < num; i++) {
	322	int id;
	323	if (!tps6586x_matches[i].init_data)
	324	continue;
	325
	326	pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
	327	id = (int)tps6586x_matches[i].driver_data;
	328	if (id == TPS6586X_ID_SYS)
	329	sys_rail = pdata->reg_init_data[i]->constraints.name;
	330
	331	if ((id == TPS6586X_ID_LDO_5) \|\| (id == TPS6586X_ID_LDO_RTC))
	332	pdata->reg_init_data[i]->supply_regulator = sys_rail;
333	}
334	*tps6586x_reg_matches = tps6586x_matches;
335	return pdata;
336	}
337	#else
338	static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
339	struct platform_device *pdev,
340	struct of_regulator_match **tps6586x_reg_matches)
341	{
342	*tps6586x_reg_matches = NULL;
343	return NULL;
344	}
345	#endif
346
a5023574	347	static int tps6586x_regulator_probe(struct platform_device *pdev)
49610235 MR	348	{
49610235 MR	349	struct tps6586x_regulator *ri = NULL;
c172708d	350	struct regulator_config config = { };
64e48160 LD	351	struct regulator_dev **rdev;
	352	struct regulator_init_data *reg_data;
	353	struct tps6586x_platform_data *pdata;
	354	struct of_regulator_match *tps6586x_reg_matches = NULL;
	355	int id;
49610235 MR	356	int err;
49610235 MR	357
10835600	358	dev_dbg(&pdev->dev, "Probing regulator\n");
49610235	359
64e48160 LD	360	pdata = dev_get_platdata(pdev->dev.parent);
	361	if ((!pdata) && (pdev->dev.parent->of_node))
	362	pdata = tps6586x_parse_regulator_dt(pdev,
	363	&tps6586x_reg_matches);
49610235	364
64e48160 LD	365	if (!pdata) {
	366	dev_err(&pdev->dev, "Platform data not available, exiting\n");
	367	return -ENODEV;
	368	}
49610235	369
64e48160 LD	370	rdev = devm_kzalloc(&pdev->dev, TPS6586X_ID_MAX_REGULATOR *
	371	sizeof(*rdev), GFP_KERNEL);
	372	if (!rdev) {
	373	dev_err(&pdev->dev, "Mmemory alloc failed\n");
	374	return -ENOMEM;
	375	}
c172708d	376
64e48160 LD	377	for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
	378	reg_data = pdata->reg_init_data[id];
	379
	380	ri = find_regulator_info(id);
	381	if (!ri) {
	382	dev_err(&pdev->dev, "invalid regulator ID specified\n");
	383	err = -EINVAL;
	384	goto fail;
	385	}
	386
	387	err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
	388	if (err) {
	389	dev_err(&pdev->dev,
	390	"regulator %d preinit failed, e %d\n", id, err);
	391	goto fail;
	392	}
	393
	394	config.dev = pdev->dev.parent;
	395	config.init_data = reg_data;
	396	config.driver_data = ri;
	397
	398	if (tps6586x_reg_matches)
	399	config.of_node = tps6586x_reg_matches[id].of_node;
	400
	401	rdev[id] = regulator_register(&ri->desc, &config);
	402	if (IS_ERR(rdev[id])) {
	403	dev_err(&pdev->dev, "failed to register regulator %s\n",
	404	ri->desc.name);
	405	err = PTR_ERR(rdev[id]);
	406	goto fail;
	407	}
	408
	409	if (reg_data) {
	410	err = tps6586x_regulator_set_slew_rate(pdev, id,
	411	reg_data);
	412	if (err < 0) {
	413	dev_err(&pdev->dev,
	414	"Slew rate config failed, e %d\n", err);
	415	regulator_unregister(rdev[id]);
	416	goto fail;
	417	}
	418	}
49610235 MR	419	}
49610235 MR	420
e7973c3c	421	platform_set_drvdata(pdev, rdev);
64e48160	422	return 0;
49610235	423
64e48160 LD	424	fail:
	425	while (--id >= 0)
	426	regulator_unregister(rdev[id]);
	427	return err;
49610235 MR	428	}
49610235 MR	429
8dc995f5	430	static int tps6586x_regulator_remove(struct platform_device *pdev)
49610235	431	{
64e48160 LD	432	struct regulator_dev **rdev = platform_get_drvdata(pdev);
	433	int id = TPS6586X_ID_MAX_REGULATOR;
	434
	435	while (--id >= 0)
	436	regulator_unregister(rdev[id]);
e7973c3c	437
49610235 MR	438	return 0;
	439	}
	440
	441	static struct platform_driver tps6586x_regulator_driver = {
	442	.driver = {
64e48160	443	.name = "tps6586x-pmic",
49610235 MR	444	.owner = THIS_MODULE,
	445	},
	446	.probe = tps6586x_regulator_probe,
5eb9f2b9	447	.remove = tps6586x_regulator_remove,
49610235 MR	448	};
	449
	450	static int __init tps6586x_regulator_init(void)
	451	{
	452	return platform_driver_register(&tps6586x_regulator_driver);
	453	}
	454	subsys_initcall(tps6586x_regulator_init);
	455
	456	static void __exit tps6586x_regulator_exit(void)
	457	{
	458	platform_driver_unregister(&tps6586x_regulator_driver);
	459	}
	460	module_exit(tps6586x_regulator_exit);
	461
	462	MODULE_LICENSE("GPL");
	463	MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
	464	MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
	465	MODULE_ALIAS("platform:tps6586x-regulator");