[linux-2.6-block.git] / drivers / regulator / mp886x.c

// SPDX-License-Identifier: GPL-2.0
//
// MP8867/MP8869 regulator driver
//
// Copyright (C) 2020 Synaptics Incorporated
//
// Author: Jisheng Zhang <jszhang@kernel.org>

#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/regmap.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/of_regulator.h>

#define MP886X_VSEL		0x00
#define  MP886X_V_BOOT		(1 << 7)
#define MP886X_SYSCNTLREG1	0x01
#define  MP886X_MODE		(1 << 0)
#define  MP886X_GO		(1 << 6)
#define  MP886X_EN		(1 << 7)

struct mp886x_device_info {
	struct device *dev;
	struct regulator_desc desc;
	struct regulator_init_data *regulator;
	struct gpio_desc *en_gpio;
	u32 r[2];
	unsigned int sel;
};

static int mp886x_set_mode(struct regulator_dev *rdev, unsigned int mode)
{
	switch (mode) {
	case REGULATOR_MODE_FAST:
		regmap_update_bits(rdev->regmap, MP886X_SYSCNTLREG1,
				   MP886X_MODE, MP886X_MODE);
		break;
	case REGULATOR_MODE_NORMAL:
		regmap_update_bits(rdev->regmap, MP886X_SYSCNTLREG1,
				   MP886X_MODE, 0);
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

static unsigned int mp886x_get_mode(struct regulator_dev *rdev)
{
	u32 val;
	int ret;

	ret = regmap_read(rdev->regmap, MP886X_SYSCNTLREG1, &val);
	if (ret < 0)
		return ret;
	if (val & MP886X_MODE)
		return REGULATOR_MODE_FAST;
	else
		return REGULATOR_MODE_NORMAL;
}

static int mp8869_set_voltage_sel(struct regulator_dev *rdev, unsigned int sel)
{
	int ret;

	ret = regmap_update_bits(rdev->regmap, MP886X_SYSCNTLREG1,
				 MP886X_GO, MP886X_GO);
	if (ret < 0)
		return ret;

	sel <<= ffs(rdev->desc->vsel_mask) - 1;
	return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
				  MP886X_V_BOOT | rdev->desc->vsel_mask, sel);
}

static inline unsigned int mp8869_scale(unsigned int uv, u32 r1, u32 r2)
{
	u32 tmp = uv * r1 / r2;

	return uv + tmp;
}

static int mp8869_get_voltage_sel(struct regulator_dev *rdev)
{
	struct mp886x_device_info *di = rdev_get_drvdata(rdev);
	int ret, uv;
	unsigned int val;
	bool fbloop;

	ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
	if (ret)
		return ret;

	fbloop = val & MP886X_V_BOOT;
	if (fbloop) {
		uv = rdev->desc->min_uV;
		uv = mp8869_scale(uv, di->r[0], di->r[1]);
		return regulator_map_voltage_linear(rdev, uv, uv);
	}

	val &= rdev->desc->vsel_mask;
	val >>= ffs(rdev->desc->vsel_mask) - 1;

	return val;
}

static const struct regulator_ops mp8869_regulator_ops = {
	.set_voltage_sel = mp8869_set_voltage_sel,
	.get_voltage_sel = mp8869_get_voltage_sel,
	.set_voltage_time_sel = regulator_set_voltage_time_sel,
	.map_voltage = regulator_map_voltage_linear,
	.list_voltage = regulator_list_voltage_linear,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.is_enabled = regulator_is_enabled_regmap,
	.set_mode = mp886x_set_mode,
	.get_mode = mp886x_get_mode,
};

static int mp8867_set_voltage_sel(struct regulator_dev *rdev, unsigned int sel)
{
	struct mp886x_device_info *di = rdev_get_drvdata(rdev);
	int ret, delta;

	ret = mp8869_set_voltage_sel(rdev, sel);
	if (ret < 0)
		return ret;

	delta = di->sel - sel;
	if (abs(delta) <= 5)
		ret = regmap_update_bits(rdev->regmap, MP886X_SYSCNTLREG1,
					 MP886X_GO, 0);
	di->sel = sel;

	return ret;
}

static int mp8867_get_voltage_sel(struct regulator_dev *rdev)
{
	struct mp886x_device_info *di = rdev_get_drvdata(rdev);
	int ret, uv;
	unsigned int val;
	bool fbloop;

	ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
	if (ret)
		return ret;

	fbloop = val & MP886X_V_BOOT;

	val &= rdev->desc->vsel_mask;
	val >>= ffs(rdev->desc->vsel_mask) - 1;

	if (fbloop) {
		uv = regulator_list_voltage_linear(rdev, val);
		uv = mp8869_scale(uv, di->r[0], di->r[1]);
		return regulator_map_voltage_linear(rdev, uv, uv);
	}

	return val;
}

static const struct regulator_ops mp8867_regulator_ops = {
	.set_voltage_sel = mp8867_set_voltage_sel,
	.get_voltage_sel = mp8867_get_voltage_sel,
	.set_voltage_time_sel = regulator_set_voltage_time_sel,
	.map_voltage = regulator_map_voltage_linear,
	.list_voltage = regulator_list_voltage_linear,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.is_enabled = regulator_is_enabled_regmap,
	.set_mode = mp886x_set_mode,
	.get_mode = mp886x_get_mode,
};

static int mp886x_regulator_register(struct mp886x_device_info *di,
				     struct regulator_config *config)
{
	struct regulator_desc *rdesc = &di->desc;
	struct regulator_dev *rdev;

	rdesc->name = "mp886x-reg";
	rdesc->supply_name = "vin";
	rdesc->ops = of_device_get_match_data(di->dev);
	rdesc->type = REGULATOR_VOLTAGE;
	rdesc->n_voltages = 128;
	rdesc->enable_reg = MP886X_SYSCNTLREG1;
	rdesc->enable_mask = MP886X_EN;
	rdesc->min_uV = 600000;
	rdesc->uV_step = 10000;
	rdesc->vsel_reg = MP886X_VSEL;
	rdesc->vsel_mask = 0x3f;
	rdesc->owner = THIS_MODULE;

	rdev = devm_regulator_register(di->dev, &di->desc, config);
	if (IS_ERR(rdev))
		return PTR_ERR(rdev);
	di->sel = rdesc->ops->get_voltage_sel(rdev);
	return 0;
}

static const struct regmap_config mp886x_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
};

static int mp886x_i2c_probe(struct i2c_client *client,
			    const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct device_node *np = dev->of_node;
	struct mp886x_device_info *di;
	struct regulator_config config = { };
	struct regmap *regmap;
	int ret;

	di = devm_kzalloc(dev, sizeof(struct mp886x_device_info), GFP_KERNEL);
	if (!di)
		return -ENOMEM;

	di->regulator = of_get_regulator_init_data(dev, np, &di->desc);
	if (!di->regulator) {
		dev_err(dev, "Platform data not found!\n");
		return -EINVAL;
	}

	ret = of_property_read_u32_array(np, "mps,fb-voltage-divider",
					 di->r, 2);
	if (ret)
		return ret;

	di->en_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_HIGH);
	if (IS_ERR(di->en_gpio))
		return PTR_ERR(di->en_gpio);

	di->dev = dev;

	regmap = devm_regmap_init_i2c(client, &mp886x_regmap_config);
	if (IS_ERR(regmap)) {
		dev_err(dev, "Failed to allocate regmap!\n");
		return PTR_ERR(regmap);
	}
	i2c_set_clientdata(client, di);

	config.dev = di->dev;
	config.init_data = di->regulator;
	config.regmap = regmap;
	config.driver_data = di;
	config.of_node = np;

	ret = mp886x_regulator_register(di, &config);
	if (ret < 0)
		dev_err(dev, "Failed to register regulator!\n");
	return ret;
}

static const struct of_device_id mp886x_dt_ids[] = {
	{
		.compatible = "mps,mp8867",
		.data = &mp8867_regulator_ops
	},
	{
		.compatible = "mps,mp8869",
		.data = &mp8869_regulator_ops
	},
	{ }
};
MODULE_DEVICE_TABLE(of, mp886x_dt_ids);

static const struct i2c_device_id mp886x_id[] = {
	{ "mp886x", },
	{ },
};
MODULE_DEVICE_TABLE(i2c, mp886x_id);

static struct i2c_driver mp886x_regulator_driver = {
	.driver = {
		.name = "mp886x-regulator",
		.of_match_table = of_match_ptr(mp886x_dt_ids),
	},
	.probe = mp886x_i2c_probe,
	.id_table = mp886x_id,
};
module_i2c_driver(mp886x_regulator_driver);

MODULE_AUTHOR("Jisheng Zhang <jszhang@kernel.org>");
MODULE_DESCRIPTION("MP886x regulator driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
97be8288 JZ	1	// SPDX-License-Identifier: GPL-2.0
97be8288 JZ	2	//
751ca3aa	3	// MP8867/MP8869 regulator driver
97be8288 JZ	4	//
	5	// Copyright (C) 2020 Synaptics Incorporated
	6	//
	7	// Author: Jisheng Zhang <jszhang@kernel.org>
	8
	9	#include <linux/gpio/consumer.h>
	10	#include <linux/i2c.h>
	11	#include <linux/module.h>
	12	#include <linux/of_device.h>
	13	#include <linux/regmap.h>
	14	#include <linux/regulator/driver.h>
	15	#include <linux/regulator/of_regulator.h>
	16
	17	#define MP886X_VSEL 0x00
	18	#define MP886X_V_BOOT (1 << 7)
	19	#define MP886X_SYSCNTLREG1 0x01
	20	#define MP886X_MODE (1 << 0)
	21	#define MP886X_GO (1 << 6)
	22	#define MP886X_EN (1 << 7)
	23
	24	struct mp886x_device_info {
	25	struct device *dev;
	26	struct regulator_desc desc;
	27	struct regulator_init_data *regulator;
	28	struct gpio_desc *en_gpio;
	29	u32 r[2];
	30	unsigned int sel;
	31	};
	32
	33	static int mp886x_set_mode(struct regulator_dev *rdev, unsigned int mode)
	34	{
	35	switch (mode) {
	36	case REGULATOR_MODE_FAST:
	37	regmap_update_bits(rdev->regmap, MP886X_SYSCNTLREG1,
	38	MP886X_MODE, MP886X_MODE);
	39	break;
	40	case REGULATOR_MODE_NORMAL:
	41	regmap_update_bits(rdev->regmap, MP886X_SYSCNTLREG1,
	42	MP886X_MODE, 0);
	43	break;
	44	default:
	45	return -EINVAL;
	46	}
	47	return 0;
	48	}
	49
	50	static unsigned int mp886x_get_mode(struct regulator_dev *rdev)
	51	{
	52	u32 val;
	53	int ret;
	54
	55	ret = regmap_read(rdev->regmap, MP886X_SYSCNTLREG1, &val);
	56	if (ret < 0)
	57	return ret;
	58	if (val & MP886X_MODE)
	59	return REGULATOR_MODE_FAST;
	60	else
	61	return REGULATOR_MODE_NORMAL;
	62	}
	63
	64	static int mp8869_set_voltage_sel(struct regulator_dev *rdev, unsigned int sel)
	65	{
	66	int ret;
	67
68	ret = regmap_update_bits(rdev->regmap, MP886X_SYSCNTLREG1,
69	MP886X_GO, MP886X_GO);
70	if (ret < 0)
71	return ret;
72
73	sel <<= ffs(rdev->desc->vsel_mask) - 1;
74	return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
75	MP886X_V_BOOT \| rdev->desc->vsel_mask, sel);
76	}
77
78	static inline unsigned int mp8869_scale(unsigned int uv, u32 r1, u32 r2)
79	{
80	u32 tmp = uv * r1 / r2;
81
82	return uv + tmp;
83	}
84
85	static int mp8869_get_voltage_sel(struct regulator_dev *rdev)
86	{
87	struct mp886x_device_info *di = rdev_get_drvdata(rdev);
88	int ret, uv;
89	unsigned int val;
90	bool fbloop;
91
92	ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
93	if (ret)
94	return ret;
95
96	fbloop = val & MP886X_V_BOOT;
97	if (fbloop) {
98	uv = rdev->desc->min_uV;
99	uv = mp8869_scale(uv, di->r[0], di->r[1]);
100	return regulator_map_voltage_linear(rdev, uv, uv);
101	}
102
103	val &= rdev->desc->vsel_mask;
104	val >>= ffs(rdev->desc->vsel_mask) - 1;
105
106	return val;
107	}
108
109	static const struct regulator_ops mp8869_regulator_ops = {
110	.set_voltage_sel = mp8869_set_voltage_sel,
111	.get_voltage_sel = mp8869_get_voltage_sel,
112	.set_voltage_time_sel = regulator_set_voltage_time_sel,
113	.map_voltage = regulator_map_voltage_linear,
114	.list_voltage = regulator_list_voltage_linear,
115	.enable = regulator_enable_regmap,
116	.disable = regulator_disable_regmap,
117	.is_enabled = regulator_is_enabled_regmap,
118	.set_mode = mp886x_set_mode,
119	.get_mode = mp886x_get_mode,
120	};
121
751ca3aa JZ	122	static int mp8867_set_voltage_sel(struct regulator_dev *rdev, unsigned int sel)
	123	{
	124	struct mp886x_device_info *di = rdev_get_drvdata(rdev);
	125	int ret, delta;
	126
	127	ret = mp8869_set_voltage_sel(rdev, sel);
	128	if (ret < 0)
	129	return ret;
	130
	131	delta = di->sel - sel;
	132	if (abs(delta) <= 5)
	133	ret = regmap_update_bits(rdev->regmap, MP886X_SYSCNTLREG1,
	134	MP886X_GO, 0);
	135	di->sel = sel;
	136
	137	return ret;
	138	}
	139
	140	static int mp8867_get_voltage_sel(struct regulator_dev *rdev)
	141	{
	142	struct mp886x_device_info *di = rdev_get_drvdata(rdev);
	143	int ret, uv;
	144	unsigned int val;
	145	bool fbloop;
	146
	147	ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
	148	if (ret)
	149	return ret;
	150
	151	fbloop = val & MP886X_V_BOOT;
	152
	153	val &= rdev->desc->vsel_mask;
	154	val >>= ffs(rdev->desc->vsel_mask) - 1;
	155
	156	if (fbloop) {
	157	uv = regulator_list_voltage_linear(rdev, val);
	158	uv = mp8869_scale(uv, di->r[0], di->r[1]);
	159	return regulator_map_voltage_linear(rdev, uv, uv);
	160	}
	161
	162	return val;
	163	}
	164
	165	static const struct regulator_ops mp8867_regulator_ops = {
	166	.set_voltage_sel = mp8867_set_voltage_sel,
	167	.get_voltage_sel = mp8867_get_voltage_sel,
	168	.set_voltage_time_sel = regulator_set_voltage_time_sel,
	169	.map_voltage = regulator_map_voltage_linear,
	170	.list_voltage = regulator_list_voltage_linear,
	171	.enable = regulator_enable_regmap,
	172	.disable = regulator_disable_regmap,
	173	.is_enabled = regulator_is_enabled_regmap,
	174	.set_mode = mp886x_set_mode,
	175	.get_mode = mp886x_get_mode,
	176	};
	177
97be8288 JZ	178	static int mp886x_regulator_register(struct mp886x_device_info *di,
	179	struct regulator_config *config)
	180	{
	181	struct regulator_desc *rdesc = &di->desc;
	182	struct regulator_dev *rdev;
	183
	184	rdesc->name = "mp886x-reg";
	185	rdesc->supply_name = "vin";
	186	rdesc->ops = of_device_get_match_data(di->dev);
	187	rdesc->type = REGULATOR_VOLTAGE;
	188	rdesc->n_voltages = 128;
	189	rdesc->enable_reg = MP886X_SYSCNTLREG1;
	190	rdesc->enable_mask = MP886X_EN;
	191	rdesc->min_uV = 600000;
	192	rdesc->uV_step = 10000;
	193	rdesc->vsel_reg = MP886X_VSEL;
	194	rdesc->vsel_mask = 0x3f;
	195	rdesc->owner = THIS_MODULE;
	196
	197	rdev = devm_regulator_register(di->dev, &di->desc, config);
	198	if (IS_ERR(rdev))
	199	return PTR_ERR(rdev);
	200	di->sel = rdesc->ops->get_voltage_sel(rdev);
	201	return 0;
	202	}
	203
	204	static const struct regmap_config mp886x_regmap_config = {
	205	.reg_bits = 8,
	206	.val_bits = 8,
	207	};
	208
	209	static int mp886x_i2c_probe(struct i2c_client *client,
	210	const struct i2c_device_id *id)
	211	{
	212	struct device *dev = &client->dev;
	213	struct device_node *np = dev->of_node;
	214	struct mp886x_device_info *di;
	215	struct regulator_config config = { };
	216	struct regmap *regmap;
	217	int ret;
	218
	219	di = devm_kzalloc(dev, sizeof(struct mp886x_device_info), GFP_KERNEL);
	220	if (!di)
	221	return -ENOMEM;
	222
	223	di->regulator = of_get_regulator_init_data(dev, np, &di->desc);
	224	if (!di->regulator) {
	225	dev_err(dev, "Platform data not found!\n");
	226	return -EINVAL;
	227	}
	228
	229	ret = of_property_read_u32_array(np, "mps,fb-voltage-divider",
	230	di->r, 2);
	231	if (ret)
	232	return ret;
	233
	234	di->en_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_HIGH);
	235	if (IS_ERR(di->en_gpio))
	236	return PTR_ERR(di->en_gpio);
	237
	238	di->dev = dev;
	239
	240	regmap = devm_regmap_init_i2c(client, &mp886x_regmap_config);
	241	if (IS_ERR(regmap)) {
242	dev_err(dev, "Failed to allocate regmap!\n");
243	return PTR_ERR(regmap);
244	}
245	i2c_set_clientdata(client, di);
246
247	config.dev = di->dev;
248	config.init_data = di->regulator;
249	config.regmap = regmap;
250	config.driver_data = di;
251	config.of_node = np;
252
253	ret = mp886x_regulator_register(di, &config);
254	if (ret < 0)
255	dev_err(dev, "Failed to register regulator!\n");
256	return ret;
257	}
258
259	static const struct of_device_id mp886x_dt_ids[] = {
751ca3aa JZ	260	{
	261	.compatible = "mps,mp8867",
	262	.data = &mp8867_regulator_ops
	263	},
97be8288 JZ	264	{
	265	.compatible = "mps,mp8869",
	266	.data = &mp8869_regulator_ops
	267	},
	268	{ }
	269	};
	270	MODULE_DEVICE_TABLE(of, mp886x_dt_ids);
	271
	272	static const struct i2c_device_id mp886x_id[] = {
	273	{ "mp886x", },
	274	{ },
	275	};
	276	MODULE_DEVICE_TABLE(i2c, mp886x_id);
	277
	278	static struct i2c_driver mp886x_regulator_driver = {
	279	.driver = {
	280	.name = "mp886x-regulator",
	281	.of_match_table = of_match_ptr(mp886x_dt_ids),
	282	},
	283	.probe = mp886x_i2c_probe,
	284	.id_table = mp886x_id,
	285	};
	286	module_i2c_driver(mp886x_regulator_driver);
	287
	288	MODULE_AUTHOR("Jisheng Zhang <jszhang@kernel.org>");
	289	MODULE_DESCRIPTION("MP886x regulator driver");
	290	MODULE_LICENSE("GPL v2");