1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Device driver for RT5739 regulator
4 *
5 * Copyright (C) 2023 Richtek Technology Corp.
6 *
7 * Author: ChiYuan Huang <cy_huang@richtek.com>
8 */
9
10 #include <linux/bits.h>
11 #include <linux/gpio/consumer.h>
12 #include <linux/i2c.h>
13 #include <linux/kernel.h>
14 #include <linux/mod_devicetable.h>
15 #include <linux/property.h>
16 #include <linux/regmap.h>
17 #include <linux/regulator/driver.h>
18 #include <linux/regulator/of_regulator.h>
19
20 #define RT5739_AUTO_MODE 0
21 #define RT5739_FPWM_MODE 1
22
23 #define RT5739_REG_NSEL0 0x00
24 #define RT5739_REG_NSEL1 0x01
25 #define RT5739_REG_CNTL1 0x02
26 #define RT5739_REG_ID1 0x03
27 #define RT5739_REG_ID2 0x04
28 #define RT5739_REG_MON 0x05
29 #define RT5739_REG_CNTL2 0x06
30 #define RT5739_REG_CNTL4 0x08
31
32 #define RT5739_VSEL_MASK GENMASK(7, 0)
33 #define RT5739_MODEVSEL1_MASK BIT(1)
34 #define RT5739_MODEVSEL0_MASK BIT(0)
35 #define RT5739_VID_MASK GENMASK(7, 5)
36 #define RT5739_DID_MASK GENMASK(3, 0)
37 #define RT5739_ACTD_MASK BIT(7)
38 #define RT5739_ENVSEL1_MASK BIT(1)
39 #define RT5739_ENVSEL0_MASK BIT(0)
40
41 #define RT5733_CHIPDIE_ID 0x1
42 #define RT5733_VOLT_MINUV 270000
43 #define RT5733_VOLT_MAXUV 1401250
44 #define RT5733_VOLT_STPUV 6250
45 #define RT5733_N_VOLTS 182
46
47 #define RT5739_VOLT_MINUV 300000
48 #define RT5739_VOLT_MAXUV 1300000
49 #define RT5739_VOLT_STPUV 5000
50 #define RT5739_N_VOLTS 201
51 #define RT5739_I2CRDY_TIMEUS 1000
52
rt5739_set_mode(struct regulator_dev * rdev,unsigned int mode)53 static int rt5739_set_mode(struct regulator_dev *rdev, unsigned int mode)
54 {
55 const struct regulator_desc *desc = rdev->desc;
56 struct regmap *regmap = rdev_get_regmap(rdev);
57 unsigned int mask, val;
58
59 if (desc->vsel_reg == RT5739_REG_NSEL0)
60 mask = RT5739_MODEVSEL0_MASK;
61 else
62 mask = RT5739_MODEVSEL1_MASK;
63
64 switch (mode) {
65 case REGULATOR_MODE_FAST:
66 val = mask;
67 break;
68 case REGULATOR_MODE_NORMAL:
69 val = 0;
70 break;
71 default:
72 return -EINVAL;
73 }
74
75 return regmap_update_bits(regmap, RT5739_REG_CNTL1, mask, val);
76 }
77
rt5739_get_mode(struct regulator_dev * rdev)78 static unsigned int rt5739_get_mode(struct regulator_dev *rdev)
79 {
80 const struct regulator_desc *desc = rdev->desc;
81 struct regmap *regmap = rdev_get_regmap(rdev);
82 unsigned int mask, val;
83 int ret;
84
85 if (desc->vsel_reg == RT5739_REG_NSEL0)
86 mask = RT5739_MODEVSEL0_MASK;
87 else
88 mask = RT5739_MODEVSEL1_MASK;
89
90 ret = regmap_read(regmap, RT5739_REG_CNTL1, &val);
91 if (ret)
92 return REGULATOR_MODE_INVALID;
93
94 if (val & mask)
95 return REGULATOR_MODE_FAST;
96
97 return REGULATOR_MODE_NORMAL;
98 }
99
rt5739_set_suspend_voltage(struct regulator_dev * rdev,int uV)100 static int rt5739_set_suspend_voltage(struct regulator_dev *rdev, int uV)
101 {
102 const struct regulator_desc *desc = rdev->desc;
103 struct regmap *regmap = rdev_get_regmap(rdev);
104 unsigned int reg, vsel;
105 int max_uV;
106
107 max_uV = desc->min_uV + desc->uV_step * (desc->n_voltages - 1);
108
109 if (uV < desc->min_uV || uV > max_uV)
110 return -EINVAL;
111
112 if (desc->vsel_reg == RT5739_REG_NSEL0)
113 reg = RT5739_REG_NSEL1;
114 else
115 reg = RT5739_REG_NSEL0;
116
117 vsel = (uV - desc->min_uV) / desc->uV_step;
118 return regmap_write(regmap, reg, vsel);
119 }
120
rt5739_set_suspend_enable(struct regulator_dev * rdev)121 static int rt5739_set_suspend_enable(struct regulator_dev *rdev)
122 {
123 const struct regulator_desc *desc = rdev->desc;
124 struct regmap *regmap = rdev_get_regmap(rdev);
125 unsigned int mask;
126
127 if (desc->vsel_reg == RT5739_REG_NSEL0)
128 mask = RT5739_ENVSEL1_MASK;
129 else
130 mask = RT5739_ENVSEL0_MASK;
131
132 return regmap_update_bits(regmap, desc->enable_reg, mask, mask);
133 }
134
rt5739_set_suspend_disable(struct regulator_dev * rdev)135 static int rt5739_set_suspend_disable(struct regulator_dev *rdev)
136 {
137 const struct regulator_desc *desc = rdev->desc;
138 struct regmap *regmap = rdev_get_regmap(rdev);
139 unsigned int mask;
140
141 if (desc->vsel_reg == RT5739_REG_NSEL0)
142 mask = RT5739_ENVSEL1_MASK;
143 else
144 mask = RT5739_ENVSEL0_MASK;
145
146 return regmap_update_bits(regmap, desc->enable_reg, mask, 0);
147 }
148
rt5739_set_suspend_mode(struct regulator_dev * rdev,unsigned int mode)149 static int rt5739_set_suspend_mode(struct regulator_dev *rdev,
150 unsigned int mode)
151 {
152 const struct regulator_desc *desc = rdev->desc;
153 struct regmap *regmap = rdev_get_regmap(rdev);
154 unsigned int mask, val;
155
156 if (desc->vsel_reg == RT5739_REG_NSEL0)
157 mask = RT5739_MODEVSEL1_MASK;
158 else
159 mask = RT5739_MODEVSEL0_MASK;
160
161 switch (mode) {
162 case REGULATOR_MODE_FAST:
163 val = mask;
164 break;
165 case REGULATOR_MODE_NORMAL:
166 val = 0;
167 break;
168 default:
169 return -EINVAL;
170 }
171
172 return regmap_update_bits(regmap, RT5739_REG_CNTL1, mask, val);
173 }
174
175 static const struct regulator_ops rt5739_regulator_ops = {
176 .list_voltage = regulator_list_voltage_linear,
177 .get_voltage_sel = regulator_get_voltage_sel_regmap,
178 .set_voltage_sel = regulator_set_voltage_sel_regmap,
179 .enable = regulator_enable_regmap,
180 .disable = regulator_disable_regmap,
181 .is_enabled = regulator_is_enabled_regmap,
182 .set_active_discharge = regulator_set_active_discharge_regmap,
183 .set_mode = rt5739_set_mode,
184 .get_mode = rt5739_get_mode,
185 .set_suspend_voltage = rt5739_set_suspend_voltage,
186 .set_suspend_enable = rt5739_set_suspend_enable,
187 .set_suspend_disable = rt5739_set_suspend_disable,
188 .set_suspend_mode = rt5739_set_suspend_mode,
189 };
190
rt5739_of_map_mode(unsigned int mode)191 static unsigned int rt5739_of_map_mode(unsigned int mode)
192 {
193 switch (mode) {
194 case RT5739_AUTO_MODE:
195 return REGULATOR_MODE_NORMAL;
196 case RT5739_FPWM_MODE:
197 return REGULATOR_MODE_FAST;
198 default:
199 return REGULATOR_MODE_INVALID;
200 }
201 }
202
rt5739_init_regulator_desc(struct regulator_desc * desc,bool vsel_active_high,u8 did)203 static void rt5739_init_regulator_desc(struct regulator_desc *desc,
204 bool vsel_active_high, u8 did)
205 {
206 /* Fixed */
207 desc->name = "rt5739-regulator";
208 desc->owner = THIS_MODULE;
209 desc->ops = &rt5739_regulator_ops;
210 desc->vsel_mask = RT5739_VSEL_MASK;
211 desc->enable_reg = RT5739_REG_CNTL2;
212 desc->active_discharge_reg = RT5739_REG_CNTL1;
213 desc->active_discharge_mask = RT5739_ACTD_MASK;
214 desc->active_discharge_on = RT5739_ACTD_MASK;
215 desc->of_map_mode = rt5739_of_map_mode;
216
217 /* Assigned by vsel level */
218 if (vsel_active_high) {
219 desc->vsel_reg = RT5739_REG_NSEL1;
220 desc->enable_mask = RT5739_ENVSEL1_MASK;
221 } else {
222 desc->vsel_reg = RT5739_REG_NSEL0;
223 desc->enable_mask = RT5739_ENVSEL0_MASK;
224 }
225
226 /* Assigned by CHIPDIE ID */
227 switch (did) {
228 case RT5733_CHIPDIE_ID:
229 desc->n_voltages = RT5733_N_VOLTS;
230 desc->min_uV = RT5733_VOLT_MINUV;
231 desc->uV_step = RT5733_VOLT_STPUV;
232 break;
233 default:
234 desc->n_voltages = RT5739_N_VOLTS;
235 desc->min_uV = RT5739_VOLT_MINUV;
236 desc->uV_step = RT5739_VOLT_STPUV;
237 break;
238 }
239 }
240
rt5739_volatile_reg(struct device * dev,unsigned int reg)241 static bool rt5739_volatile_reg(struct device *dev, unsigned int reg)
242 {
243 return reg == RT5739_REG_MON;
244 }
245
246 static const struct regmap_config rt5739_regmap_config = {
247 .name = "rt5739",
248 .reg_bits = 8,
249 .val_bits = 8,
250 .max_register = RT5739_REG_CNTL4,
251 .cache_type = REGCACHE_MAPLE,
252 .volatile_reg = rt5739_volatile_reg,
253 };
254
rt5739_probe(struct i2c_client * i2c)255 static int rt5739_probe(struct i2c_client *i2c)
256 {
257 struct device *dev = &i2c->dev;
258 struct regulator_desc *desc;
259 struct regmap *regmap;
260 struct gpio_desc *enable_gpio;
261 struct regulator_config cfg = {};
262 struct regulator_dev *rdev;
263 bool vsel_acth;
264 unsigned int vid;
265 int ret;
266
267 desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
268 if (!desc)
269 return -ENOMEM;
270
271 enable_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH);
272 if (IS_ERR(enable_gpio))
273 return dev_err_probe(dev, PTR_ERR(enable_gpio), "Failed to get 'enable' gpio\n");
274 else if (enable_gpio)
275 usleep_range(RT5739_I2CRDY_TIMEUS, RT5739_I2CRDY_TIMEUS + 1000);
276
277 regmap = devm_regmap_init_i2c(i2c, &rt5739_regmap_config);
278 if (IS_ERR(regmap))
279 return dev_err_probe(dev, PTR_ERR(regmap), "Failed to init regmap\n");
280
281 ret = regmap_read(regmap, RT5739_REG_ID1, &vid);
282 if (ret)
283 return dev_err_probe(dev, ret, "Failed to read VID\n");
284
285 /* RT5739: (VID & MASK) must be 0 */
286 if (vid & RT5739_VID_MASK)
287 return dev_err_probe(dev, -ENODEV, "Incorrect VID (0x%02x)\n", vid);
288
289 vsel_acth = device_property_read_bool(dev, "richtek,vsel-active-high");
290
291 rt5739_init_regulator_desc(desc, vsel_acth, vid & RT5739_DID_MASK);
292
293 cfg.dev = dev;
294 cfg.of_node = dev_of_node(dev);
295 cfg.init_data = of_get_regulator_init_data(dev, dev_of_node(dev), desc);
296 rdev = devm_regulator_register(dev, desc, &cfg);
297 if (IS_ERR(rdev))
298 return dev_err_probe(dev, PTR_ERR(rdev), "Failed to register regulator\n");
299
300 return 0;
301 }
302
303 static const struct of_device_id rt5739_device_table[] = {
304 { .compatible = "richtek,rt5733" },
305 { .compatible = "richtek,rt5739" },
306 { /* sentinel */ }
307 };
308 MODULE_DEVICE_TABLE(of, rt5739_device_table);
309
310 static struct i2c_driver rt5739_driver = {
311 .driver = {
312 .name = "rt5739",
313 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
314 .of_match_table = rt5739_device_table,
315 },
316 .probe = rt5739_probe,
317 };
318 module_i2c_driver(rt5739_driver);
319
320 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
321 MODULE_DESCRIPTION("Richtek RT5739 regulator driver");
322 MODULE_LICENSE("GPL");
323