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 
68 struct rt6190_data {
69 	struct device *dev;
70 	struct regmap *regmap;
71 	struct gpio_desc *enable_gpio;
72 	unsigned int cached_alert_evt;
73 };
74 
rt6190_out_set_voltage_sel(struct regulator_dev * rdev,unsigned int selector)75 static 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 
rt6190_out_get_voltage_sel(struct regulator_dev * rdev)85 static 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 
rt6190_out_enable(struct regulator_dev * rdev)96 static 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 
rt6190_out_disable(struct regulator_dev * rdev)127 static 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 
rt6190_out_set_current_limit(struct regulator_dev * rdev,int min_uA,int max_uA)149 static 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 
rt6190_out_get_current_limit(struct regulator_dev * rdev)172 static 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 
rt6190_out_set_mode(struct regulator_dev * rdev,unsigned int mode)189 static 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 
rt6190_out_get_mode(struct regulator_dev * rdev)209 static 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 
rt6190_out_get_error_flags(struct regulator_dev * rdev,unsigned int * flags)225 static 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 
rt6190_out_of_map_mode(unsigned int mode)252 static 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 
264 static 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 
279 static 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 
rt6190_is_volatile_reg(struct device * dev,unsigned int reg)296 static 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 
308 static 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 
rt6190_irq_handler(int irq,void * devid)318 static 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 
rt6190_init_registers(struct regmap * regmap)348 static 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 
rt6190_probe(struct i2c_client * i2c)374 static 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 
rt6190_runtime_suspend(struct device * dev)442 static 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 
rt6190_runtime_resume(struct device * dev)458 static 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 
473 static const struct dev_pm_ops __maybe_unused rt6190_dev_pm = {
474 	RUNTIME_PM_OPS(rt6190_runtime_suspend, rt6190_runtime_resume, NULL)
475 };
476 
477 static const struct of_device_id rt6190_of_dev_table[] = {
478 	{ .compatible = "richtek,rt6190" },
479 	{}
480 };
481 MODULE_DEVICE_TABLE(of, rt6190_of_dev_table);
482 
483 static 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 };
492 module_i2c_driver(rt6190_driver);
493 
494 MODULE_DESCRIPTION("Richtek RT6190 regulator driver");
495 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
496 MODULE_LICENSE("GPL");
497