[deliverable/linux.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,
	.map_voltage = regulator_map_voltage_ascend,
	.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,
};

#define tps658623_sm2_voltages tps6586x_ldo4_voltages

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 tps658643_sm2_voltages[] = {
	1025000, 1050000, 1075000, 1100000, 1125000, 1150000, 1175000, 1200000,
	1225000, 1250000, 1275000, 1300000, 1325000, 1350000, 1375000, 1400000,
	1425000, 1450000, 1475000, 1500000, 1525000, 1550000, 1575000, 1600000,
	1625000, 1650000, 1675000, 1700000, 1725000, 1750000, 1775000, 1800000,
};

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(vdata##_voltages),		\
		.volt_table = 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", tps6586x_ldo0, SUPPLYV1, 5, 3, ENC, 0,
					END, 0),
	TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo, SUPPLYV4, 0, 3, ENC, 2,
					END, 2),
	TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo, SUPPLYV6, 0, 3, ENE, 6,
					ENE, 6),
	TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo, SUPPLYV3, 0, 3, ENC, 4,
					END, 4),
	TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo, SUPPLYV3, 3, 3, ENC, 5,
					END, 5),
	TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo, SUPPLYV2, 5, 3, ENC, 6,
					END, 6),
	TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo, SUPPLYV6, 3, 3, ENE, 7,
					ENE, 7),
	TPS6586X_LDO(LDO_RTC, "REG-SYS", tps6586x_ldo, SUPPLYV4, 3, 3, V4, 7,
					V4, 7),
	TPS6586X_LDO(LDO_1, "vinldo01", tps6586x_dvm, SUPPLYV1, 0, 5, ENC, 1,
					END, 1),
	TPS6586X_LDO(SM_2, "vin-sm2", tps6586x_sm2, SUPPLYV2, 0, 5, ENC, 7,
					END, 7),

	TPS6586X_DVM(LDO_2, "vinldo23", tps6586x_dvm, LDO2BV1, 0, 5, ENA, 3,
					ENB, 3, TPS6586X_VCC2, BIT(6)),
	TPS6586X_DVM(LDO_4, "vinldo4", tps6586x_ldo4, LDO4V1, 0, 5, ENC, 3,
					END, 3, TPS6586X_VCC1, BIT(6)),
	TPS6586X_DVM(SM_0, "vin-sm0", tps6586x_dvm, SM0V1, 0, 5, ENA, 1,
					ENB, 1, TPS6586X_VCC1, BIT(2)),
	TPS6586X_DVM(SM_1, "vin-sm1", tps6586x_dvm, SM1V1, 0, 5, ENA, 0,
					ENB, 0, TPS6586X_VCC1, BIT(0)),
};

static struct tps6586x_regulator tps658623_regulator[] = {
	TPS6586X_LDO(SM_2, "vin-sm2", tps658623_sm2, SUPPLYV2, 0, 5, ENC, 7,
					END, 7),
};

static struct tps6586x_regulator tps658643_regulator[] = {
	TPS6586X_LDO(SM_2, "vin-sm2", tps658643_sm2, SUPPLYV2, 0, 5, ENC, 7,
					END, 7),
};

/*
 * 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_err(&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 struct tps6586x_regulator *find_regulator_info(int id, int version)
{
	struct tps6586x_regulator *ri;
	struct tps6586x_regulator *table = NULL;
	int num;
	int i;

	switch (version) {
	case TPS658623:
		table = tps658623_regulator;
		num = ARRAY_SIZE(tps658623_regulator);
		break;
	case TPS658643:
		table = tps658643_regulator;
		num = ARRAY_SIZE(tps658643_regulator);
		break;
	}

	/* Search version specific table first */
	if (table) {
		for (i = 0; i < num; i++) {
			ri = &table[i];
			if (ri->desc.id == id)
				return ri;
		}
	}

	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_get_child_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);
	of_node_put(regs);
	if (err < 0) {
		dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
		return NULL;
	}

	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 version;
	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;
	}

	version = tps6586x_get_version(pdev->dev.parent);

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

		ri = find_regulator_info(id, version);

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

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

		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] = devm_regulator_register(&pdev->dev, &ri->desc,
						   &config);
		if (IS_ERR(rdev[id])) {
			dev_err(&pdev->dev, "failed to register regulator %s\n",
					ri->desc.name);
			return PTR_ERR(rdev[id]);
		}

		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);
				return err;
			}
		}
	}

	platform_set_drvdata(pdev, rdev);
	return 0;
}

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

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