[mirror_ubuntu-hirsute-kernel.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_rw_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_ro_regulator_ops = {
	.list_voltage = regulator_list_voltage_table,
	.map_voltage = regulator_map_voltage_ascend,
	.get_voltage_sel = regulator_get_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, _ops, _pin_name, vdata, vreg, shift, nbits, \
			   ereg0, ebit0, ereg1, ebit1, goreg, gobit)	\
	.desc	= {							\
		.supply_name = _pin_name,				\
		.name	= "REG-" #_id,					\
		.ops	= &tps6586x_## _ops ## _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, rw, _pname, vdata, vreg, shift, nbits,	\
			   ereg0, ebit0, ereg1, ebit1, 0, 0)		\
}

#define TPS6586X_FIXED_LDO(_id, _pname, vdata, vreg, shift, nbits,	\
			  ereg0, ebit0, ereg1, ebit1)			\
{									\
	TPS6586X_REGULATOR(_id, ro, _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, rw, _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)
		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;
	}

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

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