1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * tps51632-regulator.c -- TI TPS51632 |
4 | * |
5 | * Regulator driver for TPS51632 3-2-1 Phase D-Cap Step Down Driverless |
6 | * Controller with serial VID control and DVFS. |
7 | * |
8 | * Copyright (c) 2012, NVIDIA Corporation. |
9 | * |
10 | * Author: Laxman Dewangan <ldewangan@nvidia.com> |
11 | */ |
12 | |
13 | #include <linux/err.h> |
14 | #include <linux/i2c.h> |
15 | #include <linux/init.h> |
16 | #include <linux/kernel.h> |
17 | #include <linux/module.h> |
18 | #include <linux/of.h> |
19 | #include <linux/platform_device.h> |
20 | #include <linux/regmap.h> |
21 | #include <linux/regulator/driver.h> |
22 | #include <linux/regulator/machine.h> |
23 | #include <linux/regulator/of_regulator.h> |
24 | #include <linux/regulator/tps51632-regulator.h> |
25 | #include <linux/slab.h> |
26 | |
27 | /* Register definitions */ |
28 | #define TPS51632_VOLTAGE_SELECT_REG 0x0 |
29 | #define TPS51632_VOLTAGE_BASE_REG 0x1 |
30 | #define TPS51632_OFFSET_REG 0x2 |
31 | #define TPS51632_IMON_REG 0x3 |
32 | #define TPS51632_VMAX_REG 0x4 |
33 | #define TPS51632_DVFS_CONTROL_REG 0x5 |
34 | #define TPS51632_POWER_STATE_REG 0x6 |
35 | #define TPS51632_SLEW_REGS 0x7 |
36 | #define TPS51632_FAULT_REG 0x14 |
37 | |
38 | #define TPS51632_MAX_REG 0x15 |
39 | |
40 | #define TPS51632_VOUT_MASK 0x7F |
41 | #define TPS51632_VOUT_OFFSET_MASK 0x1F |
42 | #define TPS51632_VMAX_MASK 0x7F |
43 | #define TPS51632_VMAX_LOCK 0x80 |
44 | |
45 | /* TPS51632_DVFS_CONTROL_REG */ |
46 | #define TPS51632_DVFS_PWMEN 0x1 |
47 | #define TPS51632_DVFS_STEP_20 0x2 |
48 | #define TPS51632_DVFS_VMAX_PG 0x4 |
49 | #define TPS51632_DVFS_PWMRST 0x8 |
50 | #define TPS51632_DVFS_OCA_EN 0x10 |
51 | #define TPS51632_DVFS_FCCM 0x20 |
52 | |
53 | /* TPS51632_POWER_STATE_REG */ |
54 | #define TPS51632_POWER_STATE_MASK 0x03 |
55 | #define TPS51632_POWER_STATE_MULTI_PHASE_CCM 0x0 |
56 | #define TPS51632_POWER_STATE_SINGLE_PHASE_CCM 0x1 |
57 | #define TPS51632_POWER_STATE_SINGLE_PHASE_DCM 0x2 |
58 | |
59 | #define TPS51632_MIN_VOLTAGE 500000 |
60 | #define TPS51632_MAX_VOLTAGE 1520000 |
61 | #define TPS51632_VOLTAGE_STEP_10mV 10000 |
62 | #define TPS51632_VOLTAGE_STEP_20mV 20000 |
63 | #define TPS51632_MAX_VSEL 0x7F |
64 | #define TPS51632_MIN_VSEL 0x19 |
65 | #define TPS51632_DEFAULT_RAMP_DELAY 6000 |
66 | #define TPS51632_VOLT_VSEL(uV) \ |
67 | (DIV_ROUND_UP(uV - TPS51632_MIN_VOLTAGE, \ |
68 | TPS51632_VOLTAGE_STEP_10mV) + \ |
69 | TPS51632_MIN_VSEL) |
70 | |
71 | /* TPS51632 chip information */ |
72 | struct tps51632_chip { |
73 | struct device *dev; |
74 | struct regulator_desc desc; |
75 | struct regulator_dev *rdev; |
76 | struct regmap *regmap; |
77 | }; |
78 | |
79 | static int tps51632_dcdc_set_ramp_delay(struct regulator_dev *rdev, |
80 | int ramp_delay) |
81 | { |
82 | struct tps51632_chip *tps = rdev_get_drvdata(rdev); |
83 | int bit; |
84 | int ret; |
85 | |
86 | if (ramp_delay == 0) |
87 | bit = 0; |
88 | else |
89 | bit = DIV_ROUND_UP(ramp_delay, 6000) - 1; |
90 | |
91 | ret = regmap_write(map: tps->regmap, TPS51632_SLEW_REGS, BIT(bit)); |
92 | if (ret < 0) |
93 | dev_err(tps->dev, "SLEW reg write failed, err %d\n" , ret); |
94 | return ret; |
95 | } |
96 | |
97 | static const struct regulator_ops tps51632_dcdc_ops = { |
98 | .get_voltage_sel = regulator_get_voltage_sel_regmap, |
99 | .set_voltage_sel = regulator_set_voltage_sel_regmap, |
100 | .list_voltage = regulator_list_voltage_linear, |
101 | .set_voltage_time_sel = regulator_set_voltage_time_sel, |
102 | .set_ramp_delay = tps51632_dcdc_set_ramp_delay, |
103 | }; |
104 | |
105 | static int tps51632_init_dcdc(struct tps51632_chip *tps, |
106 | struct tps51632_regulator_platform_data *pdata) |
107 | { |
108 | int ret; |
109 | uint8_t control = 0; |
110 | int vsel; |
111 | |
112 | if (!pdata->enable_pwm_dvfs) |
113 | goto skip_pwm_config; |
114 | |
115 | control |= TPS51632_DVFS_PWMEN; |
116 | vsel = TPS51632_VOLT_VSEL(pdata->base_voltage_uV); |
117 | ret = regmap_write(map: tps->regmap, TPS51632_VOLTAGE_BASE_REG, val: vsel); |
118 | if (ret < 0) { |
119 | dev_err(tps->dev, "BASE reg write failed, err %d\n" , ret); |
120 | return ret; |
121 | } |
122 | |
123 | if (pdata->dvfs_step_20mV) |
124 | control |= TPS51632_DVFS_STEP_20; |
125 | |
126 | if (pdata->max_voltage_uV) { |
127 | unsigned int vmax; |
128 | /** |
129 | * TPS51632 hw behavior: VMAX register can be write only |
130 | * once as it get locked after first write. The lock get |
131 | * reset only when device is power-reset. |
132 | * Write register only when lock bit is not enabled. |
133 | */ |
134 | ret = regmap_read(map: tps->regmap, TPS51632_VMAX_REG, val: &vmax); |
135 | if (ret < 0) { |
136 | dev_err(tps->dev, "VMAX read failed, err %d\n" , ret); |
137 | return ret; |
138 | } |
139 | if (!(vmax & TPS51632_VMAX_LOCK)) { |
140 | vsel = TPS51632_VOLT_VSEL(pdata->max_voltage_uV); |
141 | ret = regmap_write(map: tps->regmap, TPS51632_VMAX_REG, |
142 | val: vsel); |
143 | if (ret < 0) { |
144 | dev_err(tps->dev, |
145 | "VMAX write failed, err %d\n" , ret); |
146 | return ret; |
147 | } |
148 | } |
149 | } |
150 | |
151 | skip_pwm_config: |
152 | ret = regmap_write(map: tps->regmap, TPS51632_DVFS_CONTROL_REG, val: control); |
153 | if (ret < 0) |
154 | dev_err(tps->dev, "DVFS reg write failed, err %d\n" , ret); |
155 | return ret; |
156 | } |
157 | |
158 | static bool is_volatile_reg(struct device *dev, unsigned int reg) |
159 | { |
160 | switch (reg) { |
161 | case TPS51632_OFFSET_REG: |
162 | case TPS51632_FAULT_REG: |
163 | case TPS51632_IMON_REG: |
164 | return true; |
165 | default: |
166 | return false; |
167 | } |
168 | } |
169 | |
170 | static bool is_read_reg(struct device *dev, unsigned int reg) |
171 | { |
172 | switch (reg) { |
173 | case 0x08 ... 0x0F: |
174 | return false; |
175 | default: |
176 | return true; |
177 | } |
178 | } |
179 | |
180 | static bool is_write_reg(struct device *dev, unsigned int reg) |
181 | { |
182 | switch (reg) { |
183 | case TPS51632_VOLTAGE_SELECT_REG: |
184 | case TPS51632_VOLTAGE_BASE_REG: |
185 | case TPS51632_VMAX_REG: |
186 | case TPS51632_DVFS_CONTROL_REG: |
187 | case TPS51632_POWER_STATE_REG: |
188 | case TPS51632_SLEW_REGS: |
189 | return true; |
190 | default: |
191 | return false; |
192 | } |
193 | } |
194 | |
195 | static const struct regmap_config tps51632_regmap_config = { |
196 | .reg_bits = 8, |
197 | .val_bits = 8, |
198 | .writeable_reg = is_write_reg, |
199 | .readable_reg = is_read_reg, |
200 | .volatile_reg = is_volatile_reg, |
201 | .max_register = TPS51632_MAX_REG - 1, |
202 | .cache_type = REGCACHE_RBTREE, |
203 | }; |
204 | |
205 | #if defined(CONFIG_OF) |
206 | static const struct of_device_id tps51632_of_match[] = { |
207 | { .compatible = "ti,tps51632" ,}, |
208 | {}, |
209 | }; |
210 | MODULE_DEVICE_TABLE(of, tps51632_of_match); |
211 | |
212 | static struct tps51632_regulator_platform_data * |
213 | of_get_tps51632_platform_data(struct device *dev, |
214 | const struct regulator_desc *desc) |
215 | { |
216 | struct tps51632_regulator_platform_data *pdata; |
217 | struct device_node *np = dev->of_node; |
218 | |
219 | pdata = devm_kzalloc(dev, size: sizeof(*pdata), GFP_KERNEL); |
220 | if (!pdata) |
221 | return NULL; |
222 | |
223 | pdata->reg_init_data = of_get_regulator_init_data(dev, node: dev->of_node, |
224 | desc); |
225 | if (!pdata->reg_init_data) { |
226 | dev_err(dev, "Not able to get OF regulator init data\n" ); |
227 | return NULL; |
228 | } |
229 | |
230 | pdata->enable_pwm_dvfs = |
231 | of_property_read_bool(np, propname: "ti,enable-pwm-dvfs" ); |
232 | pdata->dvfs_step_20mV = of_property_read_bool(np, propname: "ti,dvfs-step-20mV" ); |
233 | |
234 | pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? : |
235 | TPS51632_MIN_VOLTAGE; |
236 | pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? : |
237 | TPS51632_MAX_VOLTAGE; |
238 | return pdata; |
239 | } |
240 | #else |
241 | static struct tps51632_regulator_platform_data * |
242 | of_get_tps51632_platform_data(struct device *dev, |
243 | const struct regulator_desc *desc) |
244 | { |
245 | return NULL; |
246 | } |
247 | #endif |
248 | |
249 | static int tps51632_probe(struct i2c_client *client) |
250 | { |
251 | struct tps51632_regulator_platform_data *pdata; |
252 | struct regulator_dev *rdev; |
253 | struct tps51632_chip *tps; |
254 | int ret; |
255 | struct regulator_config config = { }; |
256 | |
257 | tps = devm_kzalloc(dev: &client->dev, size: sizeof(*tps), GFP_KERNEL); |
258 | if (!tps) |
259 | return -ENOMEM; |
260 | |
261 | tps->dev = &client->dev; |
262 | tps->desc.name = client->name; |
263 | tps->desc.id = 0; |
264 | tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY; |
265 | tps->desc.min_uV = TPS51632_MIN_VOLTAGE; |
266 | tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV; |
267 | tps->desc.linear_min_sel = TPS51632_MIN_VSEL; |
268 | tps->desc.n_voltages = TPS51632_MAX_VSEL + 1; |
269 | tps->desc.ops = &tps51632_dcdc_ops; |
270 | tps->desc.type = REGULATOR_VOLTAGE; |
271 | tps->desc.owner = THIS_MODULE; |
272 | |
273 | pdata = dev_get_platdata(dev: &client->dev); |
274 | if (!pdata && client->dev.of_node) |
275 | pdata = of_get_tps51632_platform_data(dev: &client->dev, desc: &tps->desc); |
276 | if (!pdata) { |
277 | dev_err(&client->dev, "No Platform data\n" ); |
278 | return -EINVAL; |
279 | } |
280 | |
281 | if (pdata->enable_pwm_dvfs) { |
282 | if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) || |
283 | (pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) { |
284 | dev_err(&client->dev, "Invalid base_voltage_uV setting\n" ); |
285 | return -EINVAL; |
286 | } |
287 | |
288 | if ((pdata->max_voltage_uV) && |
289 | ((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) || |
290 | (pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) { |
291 | dev_err(&client->dev, "Invalid max_voltage_uV setting\n" ); |
292 | return -EINVAL; |
293 | } |
294 | } |
295 | |
296 | if (pdata->enable_pwm_dvfs) |
297 | tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG; |
298 | else |
299 | tps->desc.vsel_reg = TPS51632_VOLTAGE_SELECT_REG; |
300 | tps->desc.vsel_mask = TPS51632_VOUT_MASK; |
301 | |
302 | tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config); |
303 | if (IS_ERR(ptr: tps->regmap)) { |
304 | ret = PTR_ERR(ptr: tps->regmap); |
305 | dev_err(&client->dev, "regmap init failed, err %d\n" , ret); |
306 | return ret; |
307 | } |
308 | i2c_set_clientdata(client, data: tps); |
309 | |
310 | ret = tps51632_init_dcdc(tps, pdata); |
311 | if (ret < 0) { |
312 | dev_err(tps->dev, "Init failed, err = %d\n" , ret); |
313 | return ret; |
314 | } |
315 | |
316 | /* Register the regulators */ |
317 | config.dev = &client->dev; |
318 | config.init_data = pdata->reg_init_data; |
319 | config.driver_data = tps; |
320 | config.regmap = tps->regmap; |
321 | config.of_node = client->dev.of_node; |
322 | |
323 | rdev = devm_regulator_register(dev: &client->dev, regulator_desc: &tps->desc, config: &config); |
324 | if (IS_ERR(ptr: rdev)) { |
325 | dev_err(tps->dev, "regulator register failed\n" ); |
326 | return PTR_ERR(ptr: rdev); |
327 | } |
328 | |
329 | tps->rdev = rdev; |
330 | return 0; |
331 | } |
332 | |
333 | static const struct i2c_device_id tps51632_id[] = { |
334 | {.name = "tps51632" ,}, |
335 | {}, |
336 | }; |
337 | |
338 | MODULE_DEVICE_TABLE(i2c, tps51632_id); |
339 | |
340 | static struct i2c_driver tps51632_i2c_driver = { |
341 | .driver = { |
342 | .name = "tps51632" , |
343 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
344 | .of_match_table = of_match_ptr(tps51632_of_match), |
345 | }, |
346 | .probe = tps51632_probe, |
347 | .id_table = tps51632_id, |
348 | }; |
349 | |
350 | static int __init tps51632_init(void) |
351 | { |
352 | return i2c_add_driver(&tps51632_i2c_driver); |
353 | } |
354 | subsys_initcall(tps51632_init); |
355 | |
356 | static void __exit tps51632_cleanup(void) |
357 | { |
358 | i2c_del_driver(driver: &tps51632_i2c_driver); |
359 | } |
360 | module_exit(tps51632_cleanup); |
361 | |
362 | MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>" ); |
363 | MODULE_DESCRIPTION("TPS51632 voltage regulator driver" ); |
364 | MODULE_LICENSE("GPL v2" ); |
365 | |