1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2022 Richtek Technology Corp.
4 *
5 * Author: ChiYuan Huang <cy_huang@richtek.com>
6 *
7 */
8
9#include <linux/bits.h>
10#include <linux/delay.h>
11#include <linux/gpio/consumer.h>
12#include <linux/i2c.h>
13#include <linux/interrupt.h>
14#include <linux/kernel.h>
15#include <linux/mod_devicetable.h>
16#include <linux/module.h>
17#include <linux/pm_runtime.h>
18#include <linux/regmap.h>
19#include <linux/regulator/consumer.h>
20#include <linux/regulator/driver.h>
21#include <linux/regulator/of_regulator.h>
22
23#define RT6190_REG_VID		0x00
24#define RT6190_REG_OUTV		0x01
25#define RT6190_REG_OUTC		0x03
26#define RT6190_REG_SET1		0x0D
27#define RT6190_REG_SET2		0x0E
28#define RT6190_REG_SET4		0x10
29#define RT6190_REG_RATIO	0x11
30#define RT6190_REG_OUT_VOLT_L	0x12
31#define RT6190_REG_TEMP_H	0x1B
32#define RT6190_REG_STAT1	0x1C
33#define RT6190_REG_ALERT1	0x1E
34#define RT6190_REG_ALERT2	0x1F
35#define RT6190_REG_MASK2	0x21
36#define RT6190_REG_OCPEN	0x28
37#define RT6190_REG_SET5		0x29
38#define RT6190_REG_VBUSC_ADC	0x32
39#define RT6190_REG_BUSC_VOLT_L	0x33
40#define RT6190_REG_BUSC_VOLT_H	0x34
41#define RT6190_REG_STAT3	0x37
42#define RT6190_REG_ALERT3	0x38
43#define RT6190_REG_MASK3	0x39
44
45#define RT6190_ENPWM_MASK	BIT(7)
46#define RT6190_ENDCHG_MASK	BIT(4)
47#define RT6190_ALERT_OTPEVT	BIT(6)
48#define RT6190_ALERT_UVPEVT	BIT(5)
49#define RT6190_ALERT_OVPEVT	BIT(4)
50#define RT6190_ENGCP_MASK	BIT(1)
51#define RT6190_FCCM_MASK	BIT(7)
52
53#define RICHTEK_VID		0x82
54#define RT6190_OUT_MIN_UV	3000000
55#define RT6190_OUT_MAX_UV	32000000
56#define RT6190_OUT_STEP_UV	20000
57#define RT6190_OUT_N_VOLT	(RT6190_OUT_MAX_UV / RT6190_OUT_STEP_UV + 1)
58#define RT6190_OUTV_MINSEL	150
59#define RT6190_OUT_MIN_UA	306000
60#define RT6190_OUT_MAX_UA	12114000
61#define RT6190_OUT_STEP_UA	24000
62#define RT6190_OUTC_MINSEL	19
63#define RT6190_EN_TIME_US	500
64
65#define RT6190_PSM_MODE		0
66#define RT6190_FCCM_MODE	1
67
68struct rt6190_data {
69	struct device *dev;
70	struct regmap *regmap;
71	struct gpio_desc *enable_gpio;
72	unsigned int cached_alert_evt;
73};
74
75static int rt6190_out_set_voltage_sel(struct regulator_dev *rdev,
76				      unsigned int selector)
77{
78	struct regmap *regmap = rdev_get_regmap(rdev);
79	__le16 le_sel = cpu_to_le16(selector);
80
81	return regmap_raw_write(regmap, RT6190_REG_OUTV, &le_sel,
82				sizeof(le_sel));
83}
84
85static int rt6190_out_get_voltage_sel(struct regulator_dev *rdev)
86{
87	struct regmap *regmap = rdev_get_regmap(rdev);
88	__le16 le_sel;
89	int ret;
90
91	ret = regmap_raw_read(regmap, RT6190_REG_OUTV, &le_sel, sizeof(le_sel));
92
93	return ret ?: le16_to_cpu(le_sel);
94}
95
96static int rt6190_out_enable(struct regulator_dev *rdev)
97{
98	struct rt6190_data *data = rdev_get_drvdata(rdev);
99	struct regmap *regmap = rdev_get_regmap(rdev);
100	u8 out_cfg[4];
101	int ret;
102
103	pm_runtime_get_sync(data->dev);
104
105	/*
106	 * From off to on, vout config will restore to IC default.
107	 * Read vout configs before enable, and restore them after enable
108	 */
109	ret = regmap_raw_read(regmap, RT6190_REG_OUTV, out_cfg,
110			      sizeof(out_cfg));
111	if (ret)
112		return ret;
113
114	ret = regulator_enable_regmap(rdev);
115	if (ret)
116		return ret;
117
118	ret = regmap_raw_write(regmap, RT6190_REG_OUTV, out_cfg,
119			       sizeof(out_cfg));
120	if (ret)
121		return ret;
122
123	return regmap_update_bits(regmap, RT6190_REG_SET5, RT6190_ENGCP_MASK,
124				  RT6190_ENGCP_MASK);
125}
126
127static int rt6190_out_disable(struct regulator_dev *rdev)
128{
129	struct rt6190_data *data = rdev_get_drvdata(rdev);
130	struct regmap *regmap = rdev_get_regmap(rdev);
131	int ret;
132
133	ret = regmap_update_bits(regmap, RT6190_REG_SET5, RT6190_ENGCP_MASK, 0);
134	if (ret)
135		return ret;
136
137	ret = regulator_disable_regmap(rdev);
138	if (ret)
139		return ret;
140
141	/* cleared cached alert event */
142	data->cached_alert_evt = 0;
143
144	pm_runtime_put(data->dev);
145
146	return 0;
147}
148
149static int rt6190_out_set_current_limit(struct regulator_dev *rdev, int min_uA,
150					int max_uA)
151{
152	struct regmap *regmap = rdev_get_regmap(rdev);
153	int csel, clim;
154	__le16 le_csel;
155
156	if (min_uA < RT6190_OUT_MIN_UA || max_uA > RT6190_OUT_MAX_UA)
157		return -EINVAL;
158
159	csel = DIV_ROUND_UP(min_uA - RT6190_OUT_MIN_UA, RT6190_OUT_STEP_UA);
160
161	clim = RT6190_OUT_MIN_UA + RT6190_OUT_STEP_UA * csel;
162	if (clim > max_uA)
163		return -EINVAL;
164
165	csel += RT6190_OUTC_MINSEL;
166	le_csel = cpu_to_le16(csel);
167
168	return regmap_raw_write(regmap, RT6190_REG_OUTC, &le_csel,
169				sizeof(le_csel));
170}
171
172static int rt6190_out_get_current_limit(struct regulator_dev *rdev)
173{
174	struct regmap *regmap = rdev_get_regmap(rdev);
175	__le16 le_csel;
176	int csel, ret;
177
178	ret = regmap_raw_read(regmap, RT6190_REG_OUTC, &le_csel,
179			      sizeof(le_csel));
180	if (ret)
181		return ret;
182
183	csel = le16_to_cpu(le_csel);
184	csel -= RT6190_OUTC_MINSEL;
185
186	return RT6190_OUT_MIN_UA + RT6190_OUT_STEP_UA * csel;
187}
188
189static int rt6190_out_set_mode(struct regulator_dev *rdev, unsigned int mode)
190{
191	struct regmap *regmap = rdev_get_regmap(rdev);
192	unsigned int val;
193
194	switch (mode) {
195	case REGULATOR_MODE_FAST:
196		val = RT6190_FCCM_MASK;
197		break;
198	case REGULATOR_MODE_NORMAL:
199		val = 0;
200		break;
201	default:
202		return -EINVAL;
203	}
204
205	return regmap_update_bits(regmap, RT6190_REG_SET1, RT6190_FCCM_MASK,
206				  val);
207}
208
209static unsigned int rt6190_out_get_mode(struct regulator_dev *rdev)
210{
211	struct regmap *regmap = rdev_get_regmap(rdev);
212	unsigned int config;
213	int ret;
214
215	ret = regmap_read(regmap, RT6190_REG_SET1, &config);
216	if (ret)
217		return REGULATOR_MODE_INVALID;
218
219	if (config & RT6190_FCCM_MASK)
220		return REGULATOR_MODE_FAST;
221
222	return REGULATOR_MODE_NORMAL;
223}
224
225static int rt6190_out_get_error_flags(struct regulator_dev *rdev,
226				      unsigned int *flags)
227{
228	struct rt6190_data *data = rdev_get_drvdata(rdev);
229	unsigned int state, rpt_flags = 0;
230	int ret;
231
232	ret = regmap_read(data->regmap, RT6190_REG_STAT1, &state);
233	if (ret)
234		return ret;
235
236	state |= data->cached_alert_evt;
237
238	if (state & RT6190_ALERT_OTPEVT)
239		rpt_flags |= REGULATOR_ERROR_OVER_TEMP;
240
241	if (state & RT6190_ALERT_UVPEVT)
242		rpt_flags |= REGULATOR_ERROR_UNDER_VOLTAGE;
243
244	if (state & RT6190_ALERT_OVPEVT)
245		rpt_flags |= REGULATOR_ERROR_REGULATION_OUT;
246
247	*flags = rpt_flags;
248
249	return 0;
250}
251
252static unsigned int rt6190_out_of_map_mode(unsigned int mode)
253{
254	switch (mode) {
255	case RT6190_PSM_MODE:
256		return REGULATOR_MODE_NORMAL;
257	case RT6190_FCCM_MODE:
258		return REGULATOR_MODE_FAST;
259	default:
260		return REGULATOR_MODE_INVALID;
261	}
262}
263
264static const struct regulator_ops rt6190_regulator_ops = {
265	.list_voltage = regulator_list_voltage_linear,
266	.set_voltage_sel = rt6190_out_set_voltage_sel,
267	.get_voltage_sel = rt6190_out_get_voltage_sel,
268	.enable = rt6190_out_enable,
269	.disable = rt6190_out_disable,
270	.is_enabled = regulator_is_enabled_regmap,
271	.set_current_limit = rt6190_out_set_current_limit,
272	.get_current_limit = rt6190_out_get_current_limit,
273	.set_active_discharge = regulator_set_active_discharge_regmap,
274	.set_mode = rt6190_out_set_mode,
275	.get_mode = rt6190_out_get_mode,
276	.get_error_flags = rt6190_out_get_error_flags,
277};
278
279static const struct regulator_desc rt6190_regulator_desc = {
280	.name = "rt6190-regulator",
281	.type = REGULATOR_VOLTAGE,
282	.owner = THIS_MODULE,
283	.ops = &rt6190_regulator_ops,
284	.min_uV = RT6190_OUT_MIN_UV,
285	.uV_step = RT6190_OUT_STEP_UV,
286	.n_voltages = RT6190_OUT_N_VOLT,
287	.linear_min_sel = RT6190_OUTV_MINSEL,
288	.enable_reg = RT6190_REG_SET2,
289	.enable_mask = RT6190_ENPWM_MASK,
290	.active_discharge_reg = RT6190_REG_SET2,
291	.active_discharge_mask = RT6190_ENDCHG_MASK,
292	.active_discharge_on = RT6190_ENDCHG_MASK,
293	.of_map_mode = rt6190_out_of_map_mode,
294};
295
296static bool rt6190_is_volatile_reg(struct device *dev, unsigned int reg)
297{
298	switch (reg) {
299	case RT6190_REG_OUT_VOLT_L ... RT6190_REG_ALERT2:
300	case RT6190_REG_BUSC_VOLT_L ... RT6190_REG_BUSC_VOLT_H:
301	case RT6190_REG_STAT3 ... RT6190_REG_ALERT3:
302		return true;
303	default:
304		return false;
305	}
306}
307
308static const struct regmap_config rt6190_regmap_config = {
309	.name = "rt6190",
310	.cache_type = REGCACHE_FLAT,
311	.reg_bits = 8,
312	.val_bits = 8,
313	.max_register = RT6190_REG_MASK3,
314	.num_reg_defaults_raw = RT6190_REG_MASK3 + 1,
315	.volatile_reg = rt6190_is_volatile_reg,
316};
317
318static irqreturn_t rt6190_irq_handler(int irq, void *devid)
319{
320	struct regulator_dev *rdev = devid;
321	struct rt6190_data *data = rdev_get_drvdata(rdev);
322	unsigned int alert;
323	int ret;
324
325	ret = regmap_read(data->regmap, RT6190_REG_ALERT1, &alert);
326	if (ret)
327		return IRQ_NONE;
328
329	/* Write clear alert events */
330	ret = regmap_write(data->regmap, RT6190_REG_ALERT1, alert);
331	if (ret)
332		return IRQ_NONE;
333
334	data->cached_alert_evt |= alert;
335
336	if (alert & RT6190_ALERT_OTPEVT)
337		regulator_notifier_call_chain(rdev, REGULATOR_EVENT_OVER_TEMP, NULL);
338
339	if (alert & RT6190_ALERT_UVPEVT)
340		regulator_notifier_call_chain(rdev, REGULATOR_EVENT_UNDER_VOLTAGE, NULL);
341
342	if (alert & RT6190_ALERT_OVPEVT)
343		regulator_notifier_call_chain(rdev, REGULATOR_EVENT_REGULATION_OUT, NULL);
344
345	return IRQ_HANDLED;
346}
347
348static int rt6190_init_registers(struct regmap *regmap)
349{
350	int ret;
351
352	/* Enable_ADC = 1 */
353	ret = regmap_write(regmap, RT6190_REG_SET4, 0x82);
354	if (ret)
355		return ret;
356
357	/* Config default VOUT ratio to be higher */
358	ret = regmap_write(regmap, RT6190_REG_RATIO, 0x20);
359
360	/* Mask unused alert */
361	ret = regmap_write(regmap, RT6190_REG_MASK2, 0);
362	if (ret)
363		return ret;
364
365	/* OCP config */
366	ret = regmap_write(regmap, RT6190_REG_OCPEN, 0);
367	if (ret)
368		return ret;
369
370	/* Enable VBUSC ADC */
371	return regmap_write(regmap, RT6190_REG_VBUSC_ADC, 0x02);
372}
373
374static int rt6190_probe(struct i2c_client *i2c)
375{
376	struct device *dev = &i2c->dev;
377	struct rt6190_data *data;
378	struct gpio_desc *enable_gpio;
379	struct regmap *regmap;
380	struct regulator_dev *rdev;
381	struct regulator_config cfg = {};
382	unsigned int vid;
383	int ret;
384
385	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
386	if (!data)
387		return -ENOMEM;
388
389	enable_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH);
390	if (IS_ERR(enable_gpio))
391		return dev_err_probe(dev, PTR_ERR(enable_gpio), "Failed to get 'enable' gpio\n");
392	else if (enable_gpio)
393		usleep_range(RT6190_EN_TIME_US, RT6190_EN_TIME_US * 2);
394
395	regmap = devm_regmap_init_i2c(i2c, &rt6190_regmap_config);
396	if (IS_ERR(regmap))
397		return dev_err_probe(dev, PTR_ERR(regmap), "Failed to init regmap\n");
398
399	data->dev = dev;
400	data->enable_gpio = enable_gpio;
401	data->regmap = regmap;
402	i2c_set_clientdata(i2c, data);
403
404	ret = regmap_read(regmap, RT6190_REG_VID, &vid);
405	if (ret)
406		return dev_err_probe(dev, ret, "Failed to read VID\n");
407
408	if (vid != RICHTEK_VID)
409		return dev_err_probe(dev, -ENODEV, "Incorrect VID 0x%02x\n", vid);
410
411	ret = rt6190_init_registers(regmap);
412	if (ret)
413		return dev_err_probe(dev, ret, "Failed to init registers\n");
414
415	pm_runtime_set_active(dev);
416	ret = devm_pm_runtime_enable(dev);
417	if (ret)
418		return dev_err_probe(dev, ret, "Failed to set pm_runtime enable\n");
419
420	cfg.dev = dev;
421	cfg.of_node = dev->of_node;
422	cfg.driver_data = data;
423	cfg.init_data = of_get_regulator_init_data(dev, dev->of_node,
424						   &rt6190_regulator_desc);
425
426	rdev = devm_regulator_register(dev, &rt6190_regulator_desc, &cfg);
427	if (IS_ERR(rdev))
428		return dev_err_probe(dev, PTR_ERR(rdev), "Failed to register regulator\n");
429
430	if (i2c->irq) {
431		ret = devm_request_threaded_irq(dev, i2c->irq, NULL,
432						rt6190_irq_handler,
433						IRQF_ONESHOT, dev_name(dev),
434						rdev);
435		if (ret)
436			return dev_err_probe(dev, ret, "Failed to register interrupt\n");
437	}
438
439	return 0;
440}
441
442static int rt6190_runtime_suspend(struct device *dev)
443{
444	struct rt6190_data *data = dev_get_drvdata(dev);
445	struct regmap *regmap = data->regmap;
446
447	if (!data->enable_gpio)
448		return 0;
449
450	regcache_cache_only(regmap, true);
451	regcache_mark_dirty(regmap);
452
453	gpiod_set_value(data->enable_gpio, 0);
454
455	return 0;
456}
457
458static int rt6190_runtime_resume(struct device *dev)
459{
460	struct rt6190_data *data = dev_get_drvdata(dev);
461	struct regmap *regmap = data->regmap;
462
463	if (!data->enable_gpio)
464		return 0;
465
466	gpiod_set_value(data->enable_gpio, 1);
467	usleep_range(RT6190_EN_TIME_US, RT6190_EN_TIME_US * 2);
468
469	regcache_cache_only(regmap, false);
470	return regcache_sync(regmap);
471}
472
473static const struct dev_pm_ops __maybe_unused rt6190_dev_pm = {
474	RUNTIME_PM_OPS(rt6190_runtime_suspend, rt6190_runtime_resume, NULL)
475};
476
477static const struct of_device_id rt6190_of_dev_table[] = {
478	{ .compatible = "richtek,rt6190" },
479	{}
480};
481MODULE_DEVICE_TABLE(of, rt6190_of_dev_table);
482
483static struct i2c_driver rt6190_driver = {
484	.driver = {
485		.name = "rt6190",
486		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
487		.of_match_table = rt6190_of_dev_table,
488		.pm = pm_ptr(&rt6190_dev_pm),
489	},
490	.probe = rt6190_probe,
491};
492module_i2c_driver(rt6190_driver);
493
494MODULE_DESCRIPTION("Richtek RT6190 regulator driver");
495MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
496MODULE_LICENSE("GPL");
497