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(map: regmap, RT6190_REG_OUTV, val: &le_sel,
82 val_len: 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(map: regmap, RT6190_REG_OUTV, val: &le_sel, val_len: 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(dev: 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(map: regmap, RT6190_REG_OUTV, val: out_cfg,
110 val_len: 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(map: regmap, RT6190_REG_OUTV, val: out_cfg,
119 val_len: sizeof(out_cfg));
120 if (ret)
121 return ret;
122
123 return regmap_update_bits(map: 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(map: regmap, RT6190_REG_SET5, RT6190_ENGCP_MASK, val: 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(dev: 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(map: regmap, RT6190_REG_OUTC, val: &le_csel,
169 val_len: 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(map: regmap, RT6190_REG_OUTC, val: &le_csel,
179 val_len: 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(map: 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(map: regmap, RT6190_REG_SET1, val: &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(map: data->regmap, RT6190_REG_STAT1, val: &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(map: data->regmap, RT6190_REG_ALERT1, val: &alert);
326 if (ret)
327 return IRQ_NONE;
328
329 /* Write clear alert events */
330 ret = regmap_write(map: data->regmap, RT6190_REG_ALERT1, val: 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(map: regmap, RT6190_REG_SET4, val: 0x82);
354 if (ret)
355 return ret;
356
357 /* Config default VOUT ratio to be higher */
358 ret = regmap_write(map: regmap, RT6190_REG_RATIO, val: 0x20);
359
360 /* Mask unused alert */
361 ret = regmap_write(map: regmap, RT6190_REG_MASK2, val: 0);
362 if (ret)
363 return ret;
364
365 /* OCP config */
366 ret = regmap_write(map: regmap, RT6190_REG_OCPEN, val: 0);
367 if (ret)
368 return ret;
369
370 /* Enable VBUSC ADC */
371 return regmap_write(map: regmap, RT6190_REG_VBUSC_ADC, val: 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, size: sizeof(*data), GFP_KERNEL);
386 if (!data)
387 return -ENOMEM;
388
389 enable_gpio = devm_gpiod_get_optional(dev, con_id: "enable", flags: GPIOD_OUT_HIGH);
390 if (IS_ERR(ptr: enable_gpio))
391 return dev_err_probe(dev, err: PTR_ERR(ptr: enable_gpio), fmt: "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(ptr: regmap))
397 return dev_err_probe(dev, err: PTR_ERR(ptr: regmap), fmt: "Failed to init regmap\n");
398
399 data->dev = dev;
400 data->enable_gpio = enable_gpio;
401 data->regmap = regmap;
402 i2c_set_clientdata(client: i2c, data);
403
404 ret = regmap_read(map: regmap, RT6190_REG_VID, val: &vid);
405 if (ret)
406 return dev_err_probe(dev, err: ret, fmt: "Failed to read VID\n");
407
408 if (vid != RICHTEK_VID)
409 return dev_err_probe(dev, err: -ENODEV, fmt: "Incorrect VID 0x%02x\n", vid);
410
411 ret = rt6190_init_registers(regmap);
412 if (ret)
413 return dev_err_probe(dev, err: ret, fmt: "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, err: ret, fmt: "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, node: dev->of_node,
424 desc: &rt6190_regulator_desc);
425
426 rdev = devm_regulator_register(dev, regulator_desc: &rt6190_regulator_desc, config: &cfg);
427 if (IS_ERR(ptr: rdev))
428 return dev_err_probe(dev, err: PTR_ERR(ptr: rdev), fmt: "Failed to register regulator\n");
429
430 if (i2c->irq) {
431 ret = devm_request_threaded_irq(dev, irq: i2c->irq, NULL,
432 thread_fn: rt6190_irq_handler,
433 IRQF_ONESHOT, devname: dev_name(dev),
434 dev_id: rdev);
435 if (ret)
436 return dev_err_probe(dev, err: ret, fmt: "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(map: regmap, enable: true);
451 regcache_mark_dirty(map: regmap);
452
453 gpiod_set_value(desc: data->enable_gpio, value: 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(desc: data->enable_gpio, value: 1);
467 usleep_range(RT6190_EN_TIME_US, RT6190_EN_TIME_US * 2);
468
469 regcache_cache_only(map: regmap, enable: false);
470 return regcache_sync(map: 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

source code of linux/drivers/regulator/rt6190-regulator.c