[linux-block.git] / drivers / regulator / tps6586x-regulator.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * 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.
 */

#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 const 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 const struct regulator_ops tps6586x_rw_linear_regulator_ops = {
	.list_voltage = regulator_list_voltage_linear,
	.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 const 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 const 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_ldo_voltages[] = {
	1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
};

static const unsigned int tps658640_rtc_voltages[] = {
	2500000, 2850000, 3100000, 3300000,
};

#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_REGULATOR_LINEAR(_id, _ops, _pin_name, n_volt, min_uv,	\
				  uv_step, 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 = n_volt,					\
		.min_uV = min_uv,					\
		.uV_step = uv_step,					\
		.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_LDO_LINEAR(_id, _pname, n_volt, min_uv, uv_step, vreg,	\
			    shift, nbits, ereg0, ebit0, ereg1, ebit1)	\
{									\
	TPS6586X_REGULATOR_LINEAR(_id, rw_linear, _pname, n_volt,	\
				  min_uv, uv_step, 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, n_volt, min_uv, uv_step, vreg, shift,	\
		     nbits, ereg0, ebit0, ereg1, ebit1, goreg, gobit)	\
{									\
	TPS6586X_REGULATOR_LINEAR(_id, rw_linear, _pname, n_volt,	\
				  min_uv, uv_step, 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_LINEAR(LDO_1, "vinldo01", 32, 725000, 25000, SUPPLYV1,
			    0, 5, ENC, 1, END, 1),
	TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 3000000, 50000, SUPPLYV2,
			    0, 5, ENC, 7, END, 7),
	TPS6586X_DVM(LDO_2, "vinldo23", 32, 725000, 25000, LDO2BV1, 0, 5,
		     ENA, 3, ENB, 3, TPS6586X_VCC2, BIT(6)),
	TPS6586X_DVM(LDO_4, "vinldo4", 32, 1700000, 25000, LDO4V1, 0, 5,
		     ENC, 3, END, 3, TPS6586X_VCC1, BIT(6)),
	TPS6586X_DVM(SM_0, "vin-sm0", 32, 725000, 25000, SM0V1, 0, 5,
		     ENA, 1, ENB, 1, TPS6586X_VCC1, BIT(2)),
	TPS6586X_DVM(SM_1, "vin-sm1", 32, 725000, 25000, SM1V1, 0, 5,
		     ENA, 0, ENB, 0, TPS6586X_VCC1, BIT(0)),
};

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

static struct tps6586x_regulator tps658640_regulator[] = {
	TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo0, SUPPLYV4, 0, 3,
					ENC, 2, END, 2),
	TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo0, SUPPLYV6, 0, 3,
					ENE, 6, ENE, 6),
	TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo0, SUPPLYV3, 0, 3,
					ENC, 4, END, 4),
	TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo0, SUPPLYV3, 3, 3,
					ENC, 5, END, 5),
	TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo0, SUPPLYV2, 5, 3,
					ENC, 6, END, 6),
	TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo0, SUPPLYV6, 3, 3,
					ENE, 7, ENE, 7),
	TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 2150000, 50000, SUPPLYV2,
			    0, 5, ENC, 7, END, 7),

	TPS6586X_FIXED_LDO(LDO_RTC, "REG-SYS", tps658640_rtc, SUPPLYV4, 3, 2,
					V4, 7, V4, 7),
};

static struct tps6586x_regulator tps658643_regulator[] = {
	TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 1025000, 25000, 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:
	case TPS658624:
		table = tps658623_regulator;
		num = ARRAY_SIZE(tps658623_regulator);
		break;
	case TPS658640:
	case TPS658640v2:
		table = tps658640_regulator;
		num = ARRAY_SIZE(tps658640_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++) {
		uintptr_t id;
		if (!tps6586x_matches[i].init_data)
			continue;

		pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
		id = (uintptr_t)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",
		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
	},
	.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
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
49610235 MR	2	/*
	3	* Regulator driver for TI TPS6586x
	4	*
	5	* Copyright (C) 2010 Compulab Ltd.
	6	* Author: Mike Rapoport <mike@compulab.co.il>
	7	*
	8	* Based on da903x
	9	* Copyright (C) 2006-2008 Marvell International Ltd.
	10	* Copyright (C) 2008 Compulab Ltd.
49610235 MR	11	*/
49610235 MR	12
49610235	13	#include <linux/kernel.h>
65602c32	14	#include <linux/module.h>
49610235 MR	15	#include <linux/init.h>
49610235 MR	16	#include <linux/err.h>
64e48160	17	#include <linux/of.h>
49610235 MR	18	#include <linux/slab.h>
	19	#include <linux/platform_device.h>
	20	#include <linux/regulator/driver.h>
	21	#include <linux/regulator/machine.h>
64e48160	22	#include <linux/regulator/of_regulator.h>
49610235 MR	23	#include <linux/mfd/tps6586x.h>
	24
	25	/* supply control and voltage setting */
	26	#define TPS6586X_SUPPLYENA 0x10
	27	#define TPS6586X_SUPPLYENB 0x11
	28	#define TPS6586X_SUPPLYENC 0x12
	29	#define TPS6586X_SUPPLYEND 0x13
	30	#define TPS6586X_SUPPLYENE 0x14
	31	#define TPS6586X_VCC1 0x20
	32	#define TPS6586X_VCC2 0x21
	33	#define TPS6586X_SM1V1 0x23
	34	#define TPS6586X_SM1V2 0x24
	35	#define TPS6586X_SM1SL 0x25
	36	#define TPS6586X_SM0V1 0x26
	37	#define TPS6586X_SM0V2 0x27
	38	#define TPS6586X_SM0SL 0x28
	39	#define TPS6586X_LDO2AV1 0x29
	40	#define TPS6586X_LDO2AV2 0x2A
	41	#define TPS6586X_LDO2BV1 0x2F
	42	#define TPS6586X_LDO2BV2 0x30
	43	#define TPS6586X_LDO4V1 0x32
	44	#define TPS6586X_LDO4V2 0x33
	45
	46	/* converter settings */
	47	#define TPS6586X_SUPPLYV1 0x41
	48	#define TPS6586X_SUPPLYV2 0x42
	49	#define TPS6586X_SUPPLYV3 0x43
	50	#define TPS6586X_SUPPLYV4 0x44
	51	#define TPS6586X_SUPPLYV5 0x45
	52	#define TPS6586X_SUPPLYV6 0x46
	53	#define TPS6586X_SMODE1 0x47
	54	#define TPS6586X_SMODE2 0x48
	55
	56	struct tps6586x_regulator {
	57	struct regulator_desc desc;
	58
49610235 MR	59	int enable_bit[2];
49610235 MR	60	int enable_reg[2];
49610235 MR	61	};
49610235 MR	62
25c80445	63	static const struct regulator_ops tps6586x_rw_regulator_ops = {
f4647037	64	.list_voltage = regulator_list_voltage_table,
4d673bbc	65	.map_voltage = regulator_map_voltage_ascend,
7c7475c0	66	.get_voltage_sel = regulator_get_voltage_sel_regmap,
d645d591	67	.set_voltage_sel = regulator_set_voltage_sel_regmap,
49610235	68
7c7475c0 AL	69	.is_enabled = regulator_is_enabled_regmap,
	70	.enable = regulator_enable_regmap,
	71	.disable = regulator_disable_regmap,
49610235 MR	72	};
49610235 MR	73
25c80445	74	static const struct regulator_ops tps6586x_rw_linear_regulator_ops = {
2628b100 AL	75	.list_voltage = regulator_list_voltage_linear,
	76	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	77	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	78
	79	.is_enabled = regulator_is_enabled_regmap,
	80	.enable = regulator_enable_regmap,
	81	.disable = regulator_disable_regmap,
	82	};
	83
25c80445	84	static const struct regulator_ops tps6586x_ro_regulator_ops = {
ad0b40fe AB	85	.list_voltage = regulator_list_voltage_table,
	86	.map_voltage = regulator_map_voltage_ascend,
	87	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	88
	89	.is_enabled = regulator_is_enabled_regmap,
	90	.enable = regulator_enable_regmap,
	91	.disable = regulator_disable_regmap,
	92	};
	93
25c80445	94	static const struct regulator_ops tps6586x_sys_regulator_ops = {
49610235 MR	95	};
49610235 MR	96
f4647037 AL	97	static const unsigned int tps6586x_ldo0_voltages[] = {
	98	1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
	99	};
	100
f4647037 AL	101	static const unsigned int tps6586x_ldo_voltages[] = {
f4647037 AL	102	1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
49610235 MR	103	};
49610235 MR	104
2628b100	105	static const unsigned int tps658640_rtc_voltages[] = {
6c46ccc8 AB	106	2500000, 2850000, 3100000, 3300000,
	107	};
	108
ad0b40fe	109	#define TPS6586X_REGULATOR(_id, _ops, _pin_name, vdata, vreg, shift, nbits, \
d645d591	110	ereg0, ebit0, ereg1, ebit1, goreg, gobit) \
49610235	111	.desc = { \
7c7fac30	112	.supply_name = _pin_name, \
49610235	113	.name = "REG-" #_id, \
ad0b40fe	114	.ops = &tps6586x_## _ops ## _regulator_ops, \
49610235 MR	115	.type = REGULATOR_VOLTAGE, \
49610235 MR	116	.id = TPS6586X_ID_##_id, \
844a4f0d SA	117	.n_voltages = ARRAY_SIZE(vdata##_voltages), \
844a4f0d SA	118	.volt_table = vdata##_voltages, \
49610235	119	.owner = THIS_MODULE, \
7c7475c0 AL	120	.enable_reg = TPS6586X_SUPPLY##ereg0, \
	121	.enable_mask = 1 << (ebit0), \
	122	.vsel_reg = TPS6586X_##vreg, \
	123	.vsel_mask = ((1 << (nbits)) - 1) << (shift), \
d645d591 AL	124	.apply_reg = (goreg), \
d645d591 AL	125	.apply_bit = (gobit), \
49610235	126	}, \
49610235 MR	127	.enable_reg[0] = TPS6586X_SUPPLY##ereg0, \
	128	.enable_bit[0] = (ebit0), \
	129	.enable_reg[1] = TPS6586X_SUPPLY##ereg1, \
f4647037	130	.enable_bit[1] = (ebit1),
64db657b	131
2628b100 AL	132	#define TPS6586X_REGULATOR_LINEAR(_id, _ops, _pin_name, n_volt, min_uv, \
	133	uv_step, vreg, shift, nbits, ereg0, \
	134	ebit0, ereg1, ebit1, goreg, gobit) \
	135	.desc = { \
	136	.supply_name = _pin_name, \
	137	.name = "REG-" #_id, \
	138	.ops = &tps6586x_## _ops ## _regulator_ops, \
	139	.type = REGULATOR_VOLTAGE, \
	140	.id = TPS6586X_ID_##_id, \
	141	.n_voltages = n_volt, \
	142	.min_uV = min_uv, \
	143	.uV_step = uv_step, \
	144	.owner = THIS_MODULE, \
	145	.enable_reg = TPS6586X_SUPPLY##ereg0, \
	146	.enable_mask = 1 << (ebit0), \
	147	.vsel_reg = TPS6586X_##vreg, \
	148	.vsel_mask = ((1 << (nbits)) - 1) << (shift), \
	149	.apply_reg = (goreg), \
	150	.apply_bit = (gobit), \
	151	}, \
	152	.enable_reg[0] = TPS6586X_SUPPLY##ereg0, \
	153	.enable_bit[0] = (ebit0), \
	154	.enable_reg[1] = TPS6586X_SUPPLY##ereg1, \
	155	.enable_bit[1] = (ebit1),
	156
7c7fac30	157	#define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits, \
49610235	158	ereg0, ebit0, ereg1, ebit1) \
64db657b	159	{ \
ad0b40fe AB	160	TPS6586X_REGULATOR(_id, rw, _pname, vdata, vreg, shift, nbits, \
	161	ereg0, ebit0, ereg1, ebit1, 0, 0) \
	162	}
	163
2628b100 AL	164	#define TPS6586X_LDO_LINEAR(_id, _pname, n_volt, min_uv, uv_step, vreg, \
	165	shift, nbits, ereg0, ebit0, ereg1, ebit1) \
	166	{ \
	167	TPS6586X_REGULATOR_LINEAR(_id, rw_linear, _pname, n_volt, \
	168	min_uv, uv_step, vreg, shift, nbits, \
	169	ereg0, ebit0, ereg1, ebit1, 0, 0) \
	170	}
	171
ad0b40fe AB	172	#define TPS6586X_FIXED_LDO(_id, _pname, vdata, vreg, shift, nbits, \
	173	ereg0, ebit0, ereg1, ebit1) \
	174	{ \
	175	TPS6586X_REGULATOR(_id, ro, _pname, vdata, vreg, shift, nbits, \
d645d591	176	ereg0, ebit0, ereg1, ebit1, 0, 0) \
64db657b	177	}
49610235	178
2628b100 AL	179	#define TPS6586X_DVM(_id, _pname, n_volt, min_uv, uv_step, vreg, shift, \
2628b100 AL	180	nbits, ereg0, ebit0, ereg1, ebit1, goreg, gobit) \
64db657b	181	{ \
2628b100 AL	182	TPS6586X_REGULATOR_LINEAR(_id, rw_linear, _pname, n_volt, \
	183	min_uv, uv_step, vreg, shift, nbits, \
	184	ereg0, ebit0, ereg1, ebit1, goreg, \
	185	gobit) \
64db657b	186	}
49610235	187
9394b80c LD	188	#define TPS6586X_SYS_REGULATOR() \
	189	{ \
	190	.desc = { \
	191	.supply_name = "sys", \
	192	.name = "REG-SYS", \
	193	.ops = &tps6586x_sys_regulator_ops, \
	194	.type = REGULATOR_VOLTAGE, \
	195	.id = TPS6586X_ID_SYS, \
	196	.owner = THIS_MODULE, \
	197	}, \
	198	}
	199
49610235	200	static struct tps6586x_regulator tps6586x_regulator[] = {
9394b80c	201	TPS6586X_SYS_REGULATOR(),
844a4f0d SA	202	TPS6586X_LDO(LDO_0, "vinldo01", tps6586x_ldo0, SUPPLYV1, 5, 3, ENC, 0,
	203	END, 0),
	204	TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo, SUPPLYV4, 0, 3, ENC, 2,
	205	END, 2),
	206	TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo, SUPPLYV6, 0, 3, ENE, 6,
	207	ENE, 6),
	208	TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo, SUPPLYV3, 0, 3, ENC, 4,
	209	END, 4),
	210	TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo, SUPPLYV3, 3, 3, ENC, 5,
	211	END, 5),
	212	TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo, SUPPLYV2, 5, 3, ENC, 6,
	213	END, 6),
	214	TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo, SUPPLYV6, 3, 3, ENE, 7,
	215	ENE, 7),
	216	TPS6586X_LDO(LDO_RTC, "REG-SYS", tps6586x_ldo, SUPPLYV4, 3, 3, V4, 7,
	217	V4, 7),
2628b100 AL	218	TPS6586X_LDO_LINEAR(LDO_1, "vinldo01", 32, 725000, 25000, SUPPLYV1,
	219	0, 5, ENC, 1, END, 1),
	220	TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 3000000, 50000, SUPPLYV2,
	221	0, 5, ENC, 7, END, 7),
	222	TPS6586X_DVM(LDO_2, "vinldo23", 32, 725000, 25000, LDO2BV1, 0, 5,
	223	ENA, 3, ENB, 3, TPS6586X_VCC2, BIT(6)),
	224	TPS6586X_DVM(LDO_4, "vinldo4", 32, 1700000, 25000, LDO4V1, 0, 5,
	225	ENC, 3, END, 3, TPS6586X_VCC1, BIT(6)),
	226	TPS6586X_DVM(SM_0, "vin-sm0", 32, 725000, 25000, SM0V1, 0, 5,
	227	ENA, 1, ENB, 1, TPS6586X_VCC1, BIT(2)),
	228	TPS6586X_DVM(SM_1, "vin-sm1", 32, 725000, 25000, SM1V1, 0, 5,
	229	ENA, 0, ENB, 0, TPS6586X_VCC1, BIT(0)),
49610235 MR	230	};
49610235 MR	231
844a4f0d	232	static struct tps6586x_regulator tps658623_regulator[] = {
2628b100 AL	233	TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 1700000, 25000, SUPPLYV2,
2628b100 AL	234	0, 5, ENC, 7, END, 7),
844a4f0d SA	235	};
844a4f0d SA	236
6c46ccc8 AB	237	static struct tps6586x_regulator tps658640_regulator[] = {
	238	TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo0, SUPPLYV4, 0, 3,
	239	ENC, 2, END, 2),
	240	TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo0, SUPPLYV6, 0, 3,
	241	ENE, 6, ENE, 6),
	242	TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo0, SUPPLYV3, 0, 3,
	243	ENC, 4, END, 4),
	244	TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo0, SUPPLYV3, 3, 3,
	245	ENC, 5, END, 5),
	246	TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo0, SUPPLYV2, 5, 3,
	247	ENC, 6, END, 6),
	248	TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo0, SUPPLYV6, 3, 3,
	249	ENE, 7, ENE, 7),
2628b100 AL	250	TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 2150000, 50000, SUPPLYV2,
2628b100 AL	251	0, 5, ENC, 7, END, 7),
6c46ccc8 AB	252
	253	TPS6586X_FIXED_LDO(LDO_RTC, "REG-SYS", tps658640_rtc, SUPPLYV4, 3, 2,
	254	V4, 7, V4, 7),
	255	};
	256
844a4f0d	257	static struct tps6586x_regulator tps658643_regulator[] = {
2628b100 AL	258	TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 1025000, 25000, SUPPLYV2,
2628b100 AL	259	0, 5, ENC, 7, END, 7),
844a4f0d SA	260	};
844a4f0d SA	261
49610235 MR	262	/*
	263	* TPS6586X has 2 enable bits that are OR'ed to determine the actual
	264	* regulator state. Clearing one of this bits allows switching
	265	* regulator on and of with single register write.
	266	*/
	267	static inline int tps6586x_regulator_preinit(struct device *parent,
	268	struct tps6586x_regulator *ri)
	269	{
	270	uint8_t val1, val2;
	271	int ret;
	272
1dbcf35c DH	273	if (ri->enable_reg[0] == ri->enable_reg[1] &&
	274	ri->enable_bit[0] == ri->enable_bit[1])
	275	return 0;
	276
49610235 MR	277	ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
	278	if (ret)
	279	return ret;
	280
	281	ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
	282	if (ret)
	283	return ret;
	284
4f586707	285	if (!(val2 & (1 << ri->enable_bit[1])))
49610235 MR	286	return 0;
	287
	288	/*
	289	* The regulator is on, but it's enabled with the bit we don't
	290	* want to use, so we switch the enable bits
	291	*/
4f586707	292	if (!(val1 & (1 << ri->enable_bit[0]))) {
49610235 MR	293	ret = tps6586x_set_bits(parent, ri->enable_reg[0],
	294	1 << ri->enable_bit[0]);
	295	if (ret)
	296	return ret;
	297	}
	298
	299	return tps6586x_clr_bits(parent, ri->enable_reg[1],
	300	1 << ri->enable_bit[1]);
	301	}
	302
64e48160 LD	303	static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
64e48160 LD	304	int id, struct regulator_init_data *p)
500c524a XX	305	{
500c524a XX	306	struct device *parent = pdev->dev.parent;
500c524a XX	307	struct tps6586x_settings *setting = p->driver_data;
	308	uint8_t reg;
	309
	310	if (setting == NULL)
	311	return 0;
	312
	313	if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
	314	return 0;
	315
	316	/* only SM0 and SM1 can have the slew rate settings */
64e48160	317	switch (id) {
500c524a XX	318	case TPS6586X_ID_SM_0:
	319	reg = TPS6586X_SM0SL;
	320	break;
	321	case TPS6586X_ID_SM_1:
	322	reg = TPS6586X_SM1SL;
	323	break;
	324	default:
6673d66e	325	dev_err(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
500c524a XX	326	return -EINVAL;
	327	}
	328
	329	return tps6586x_write(parent, reg,
	330	setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
	331	}
	332
844a4f0d	333	static struct tps6586x_regulator *find_regulator_info(int id, int version)
49610235 MR	334	{
49610235 MR	335	struct tps6586x_regulator *ri;
844a4f0d SA	336	struct tps6586x_regulator *table = NULL;
844a4f0d SA	337	int num;
49610235 MR	338	int i;
49610235 MR	339
844a4f0d SA	340	switch (version) {
844a4f0d SA	341	case TPS658623:
669ca030	342	case TPS658624:
844a4f0d SA	343	table = tps658623_regulator;
	344	num = ARRAY_SIZE(tps658623_regulator);
	345	break;
6c46ccc8 AB	346	case TPS658640:
	347	case TPS658640v2:
	348	table = tps658640_regulator;
	349	num = ARRAY_SIZE(tps658640_regulator);
	350	break;
844a4f0d SA	351	case TPS658643:
	352	table = tps658643_regulator;
	353	num = ARRAY_SIZE(tps658643_regulator);
	354	break;
	355	}
	356
	357	/* Search version specific table first */
	358	if (table) {
	359	for (i = 0; i < num; i++) {
	360	ri = &table[i];
	361	if (ri->desc.id == id)
	362	return ri;
	363	}
	364	}
	365
49610235 MR	366	for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
	367	ri = &tps6586x_regulator[i];
	368	if (ri->desc.id == id)
	369	return ri;
	370	}
	371	return NULL;
	372	}
	373
64e48160 LD	374	#ifdef CONFIG_OF
	375	static struct of_regulator_match tps6586x_matches[] = {
	376	{ .name = "sys", .driver_data = (void *)TPS6586X_ID_SYS },
	377	{ .name = "sm0", .driver_data = (void *)TPS6586X_ID_SM_0 },
	378	{ .name = "sm1", .driver_data = (void *)TPS6586X_ID_SM_1 },
	379	{ .name = "sm2", .driver_data = (void *)TPS6586X_ID_SM_2 },
	380	{ .name = "ldo0", .driver_data = (void *)TPS6586X_ID_LDO_0 },
	381	{ .name = "ldo1", .driver_data = (void *)TPS6586X_ID_LDO_1 },
	382	{ .name = "ldo2", .driver_data = (void *)TPS6586X_ID_LDO_2 },
	383	{ .name = "ldo3", .driver_data = (void *)TPS6586X_ID_LDO_3 },
	384	{ .name = "ldo4", .driver_data = (void *)TPS6586X_ID_LDO_4 },
	385	{ .name = "ldo5", .driver_data = (void *)TPS6586X_ID_LDO_5 },
	386	{ .name = "ldo6", .driver_data = (void *)TPS6586X_ID_LDO_6 },
	387	{ .name = "ldo7", .driver_data = (void *)TPS6586X_ID_LDO_7 },
	388	{ .name = "ldo8", .driver_data = (void *)TPS6586X_ID_LDO_8 },
	389	{ .name = "ldo9", .driver_data = (void *)TPS6586X_ID_LDO_9 },
	390	{ .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
	391	};
	392
	393	static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
	394	struct platform_device *pdev,
	395	struct of_regulator_match **tps6586x_reg_matches)
	396	{
	397	const unsigned int num = ARRAY_SIZE(tps6586x_matches);
	398	struct device_node *np = pdev->dev.parent->of_node;
	399	struct device_node *regs;
	400	const char *sys_rail = NULL;
	401	unsigned int i;
	402	struct tps6586x_platform_data *pdata;
	403	int err;
	404
712c967f	405	regs = of_get_child_by_name(np, "regulators");
64e48160 LD	406	if (!regs) {
	407	dev_err(&pdev->dev, "regulator node not found\n");
	408	return NULL;
	409	}
	410
	411	err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
0a4cccaa	412	of_node_put(regs);
64e48160 LD	413	if (err < 0) {
64e48160 LD	414	dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
64e48160 LD	415	return NULL;
	416	}
	417
64e48160	418	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
02e90584	419	if (!pdata)
64e48160	420	return NULL;
64e48160 LD	421
64e48160 LD	422	for (i = 0; i < num; i++) {
a70f0d02	423	uintptr_t id;
64e48160 LD	424	if (!tps6586x_matches[i].init_data)
	425	continue;
	426
	427	pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
a70f0d02	428	id = (uintptr_t)tps6586x_matches[i].driver_data;
64e48160 LD	429	if (id == TPS6586X_ID_SYS)
	430	sys_rail = pdata->reg_init_data[i]->constraints.name;
	431
	432	if ((id == TPS6586X_ID_LDO_5) \|\| (id == TPS6586X_ID_LDO_RTC))
	433	pdata->reg_init_data[i]->supply_regulator = sys_rail;
	434	}
	435	*tps6586x_reg_matches = tps6586x_matches;
	436	return pdata;
	437	}
	438	#else
	439	static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
	440	struct platform_device *pdev,
	441	struct of_regulator_match **tps6586x_reg_matches)
	442	{
	443	*tps6586x_reg_matches = NULL;
	444	return NULL;
	445	}
	446	#endif
	447
a5023574	448	static int tps6586x_regulator_probe(struct platform_device *pdev)
49610235 MR	449	{
49610235 MR	450	struct tps6586x_regulator *ri = NULL;
c172708d	451	struct regulator_config config = { };
d6fe2c72	452	struct regulator_dev *rdev;
64e48160 LD	453	struct regulator_init_data *reg_data;
	454	struct tps6586x_platform_data *pdata;
	455	struct of_regulator_match *tps6586x_reg_matches = NULL;
844a4f0d	456	int version;
64e48160	457	int id;
49610235 MR	458	int err;
49610235 MR	459
10835600	460	dev_dbg(&pdev->dev, "Probing regulator\n");
49610235	461
64e48160 LD	462	pdata = dev_get_platdata(pdev->dev.parent);
	463	if ((!pdata) && (pdev->dev.parent->of_node))
	464	pdata = tps6586x_parse_regulator_dt(pdev,
	465	&tps6586x_reg_matches);
49610235	466
64e48160 LD	467	if (!pdata) {
	468	dev_err(&pdev->dev, "Platform data not available, exiting\n");
	469	return -ENODEV;
	470	}
49610235	471
844a4f0d SA	472	version = tps6586x_get_version(pdev->dev.parent);
844a4f0d SA	473
64e48160 LD	474	for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
	475	reg_data = pdata->reg_init_data[id];
	476
844a4f0d SA	477	ri = find_regulator_info(id, version);
844a4f0d SA	478
64e48160 LD	479	if (!ri) {
64e48160 LD	480	dev_err(&pdev->dev, "invalid regulator ID specified\n");
884ea557	481	return -EINVAL;
64e48160 LD	482	}
	483
	484	err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
	485	if (err) {
	486	dev_err(&pdev->dev,
	487	"regulator %d preinit failed, e %d\n", id, err);
884ea557	488	return err;
64e48160 LD	489	}
	490
	491	config.dev = pdev->dev.parent;
	492	config.init_data = reg_data;
	493	config.driver_data = ri;
	494
	495	if (tps6586x_reg_matches)
	496	config.of_node = tps6586x_reg_matches[id].of_node;
	497
d6fe2c72 AL	498	rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
d6fe2c72 AL	499	if (IS_ERR(rdev)) {
64e48160 LD	500	dev_err(&pdev->dev, "failed to register regulator %s\n",
64e48160 LD	501	ri->desc.name);
d6fe2c72	502	return PTR_ERR(rdev);
64e48160 LD	503	}
	504
	505	if (reg_data) {
	506	err = tps6586x_regulator_set_slew_rate(pdev, id,
	507	reg_data);
	508	if (err < 0) {
	509	dev_err(&pdev->dev,
	510	"Slew rate config failed, e %d\n", err);
884ea557	511	return err;
64e48160 LD	512	}
64e48160 LD	513	}
49610235 MR	514	}
49610235 MR	515
e7973c3c	516	platform_set_drvdata(pdev, rdev);
64e48160	517	return 0;
49610235 MR	518	}
	519
	520	static struct platform_driver tps6586x_regulator_driver = {
	521	.driver = {
ec8da805	522	.name = "tps6586x-regulator",
259b93b2	523	.probe_type = PROBE_PREFER_ASYNCHRONOUS,
49610235 MR	524	},
49610235 MR	525	.probe = tps6586x_regulator_probe,
49610235 MR	526	};
	527
	528	static int __init tps6586x_regulator_init(void)
	529	{
	530	return platform_driver_register(&tps6586x_regulator_driver);
	531	}
	532	subsys_initcall(tps6586x_regulator_init);
	533
	534	static void __exit tps6586x_regulator_exit(void)
	535	{
	536	platform_driver_unregister(&tps6586x_regulator_driver);
	537	}
	538	module_exit(tps6586x_regulator_exit);
	539
	540	MODULE_LICENSE("GPL");
	541	MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
	542	MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
	543	MODULE_ALIAS("platform:tps6586x-regulator");