Commit | Line | Data |
---|---|---|
452534e5 VB |
1 | /* |
2 | * Regulator driver for tps65090 power management chip. | |
3 | * | |
4 | * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved. | |
5 | ||
6 | * This program is free software; you can redistribute it and/or modify it | |
7 | * under the terms and conditions of the GNU General Public License, | |
8 | * version 2, as published by the Free Software Foundation. | |
9 | ||
10 | * This program is distributed in the hope it will be useful, but WITHOUT | |
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
13 | * more details. | |
14 | ||
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program. If not, see <http://www.gnu.org/licenses/> | |
17 | */ | |
18 | ||
19 | #include <linux/module.h> | |
ed11f1ea | 20 | #include <linux/delay.h> |
452534e5 | 21 | #include <linux/init.h> |
3012e814 LW |
22 | #include <linux/of.h> |
23 | #include <linux/gpio/consumer.h> | |
452534e5 VB |
24 | #include <linux/slab.h> |
25 | #include <linux/err.h> | |
26 | #include <linux/platform_device.h> | |
27 | #include <linux/regulator/driver.h> | |
28 | #include <linux/regulator/machine.h> | |
6c7a7a0e | 29 | #include <linux/regulator/of_regulator.h> |
452534e5 | 30 | #include <linux/mfd/tps65090.h> |
452534e5 | 31 | |
ed11f1ea DA |
32 | #define MAX_CTRL_READ_TRIES 5 |
33 | #define MAX_FET_ENABLE_TRIES 1000 | |
34 | ||
35 | #define CTRL_EN_BIT 0 /* Regulator enable bit, active high */ | |
29041449 | 36 | #define CTRL_WT_BIT 2 /* Regulator wait time 0 bit */ |
ed11f1ea DA |
37 | #define CTRL_PG_BIT 4 /* Regulator power good bit, 1=good */ |
38 | #define CTRL_TO_BIT 7 /* Regulator timeout bit, 1=wait */ | |
29041449 DA |
39 | |
40 | #define MAX_OVERCURRENT_WAIT 3 /* Overcurrent wait must be <= this */ | |
41 | ||
42 | /** | |
43 | * struct tps65090_regulator - Per-regulator data for a tps65090 regulator | |
44 | * | |
45 | * @dev: Pointer to our device. | |
46 | * @desc: The struct regulator_desc for the regulator. | |
47 | * @rdev: The struct regulator_dev for the regulator. | |
48 | * @overcurrent_wait_valid: True if overcurrent_wait is valid. | |
49 | * @overcurrent_wait: For FETs, the value to put in the WTFET bitfield. | |
50 | */ | |
51 | ||
452534e5 | 52 | struct tps65090_regulator { |
452534e5 | 53 | struct device *dev; |
24282a1c LD |
54 | struct regulator_desc *desc; |
55 | struct regulator_dev *rdev; | |
29041449 DA |
56 | bool overcurrent_wait_valid; |
57 | int overcurrent_wait; | |
452534e5 VB |
58 | }; |
59 | ||
f329b175 LD |
60 | static struct regulator_ops tps65090_ext_control_ops = { |
61 | }; | |
62 | ||
29041449 DA |
63 | /** |
64 | * tps65090_reg_set_overcurrent_wait - Setup overcurrent wait | |
65 | * | |
66 | * This will set the overcurrent wait time based on what's in the regulator | |
67 | * info. | |
68 | * | |
69 | * @ri: Overall regulator data | |
70 | * @rdev: Regulator device | |
71 | * | |
72 | * Return: 0 if no error, non-zero if there was an error writing the register. | |
73 | */ | |
74 | static int tps65090_reg_set_overcurrent_wait(struct tps65090_regulator *ri, | |
75 | struct regulator_dev *rdev) | |
76 | { | |
77 | int ret; | |
78 | ||
79 | ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, | |
80 | MAX_OVERCURRENT_WAIT << CTRL_WT_BIT, | |
81 | ri->overcurrent_wait << CTRL_WT_BIT); | |
82 | if (ret) { | |
83 | dev_err(&rdev->dev, "Error updating overcurrent wait %#x\n", | |
84 | rdev->desc->enable_reg); | |
85 | } | |
86 | ||
87 | return ret; | |
88 | } | |
89 | ||
ed11f1ea DA |
90 | /** |
91 | * tps65090_try_enable_fet - Try to enable a FET | |
92 | * | |
93 | * @rdev: Regulator device | |
94 | * | |
95 | * Return: 0 if ok, -ENOTRECOVERABLE if the FET power good bit did not get | |
96 | * set, or some other -ve value if another error occurred (e.g. i2c error) | |
97 | */ | |
98 | static int tps65090_try_enable_fet(struct regulator_dev *rdev) | |
99 | { | |
100 | unsigned int control; | |
101 | int ret, i; | |
102 | ||
103 | ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, | |
104 | rdev->desc->enable_mask, | |
105 | rdev->desc->enable_mask); | |
106 | if (ret < 0) { | |
107 | dev_err(&rdev->dev, "Error in updating reg %#x\n", | |
108 | rdev->desc->enable_reg); | |
109 | return ret; | |
110 | } | |
111 | ||
112 | for (i = 0; i < MAX_CTRL_READ_TRIES; i++) { | |
113 | ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, | |
114 | &control); | |
115 | if (ret < 0) | |
116 | return ret; | |
117 | ||
118 | if (!(control & BIT(CTRL_TO_BIT))) | |
119 | break; | |
120 | ||
121 | usleep_range(1000, 1500); | |
122 | } | |
123 | if (!(control & BIT(CTRL_PG_BIT))) | |
124 | return -ENOTRECOVERABLE; | |
125 | ||
126 | return 0; | |
127 | } | |
128 | ||
129 | /** | |
130 | * tps65090_fet_enable - Enable a FET, trying a few times if it fails | |
131 | * | |
132 | * Some versions of the tps65090 have issues when turning on the FETs. | |
133 | * This function goes through several steps to ensure the best chance of the | |
134 | * FET going on. Specifically: | |
135 | * - We'll make sure that we bump the "overcurrent wait" to the maximum, which | |
136 | * increases the chances that we'll turn on properly. | |
137 | * - We'll retry turning the FET on multiple times (turning off in between). | |
138 | * | |
139 | * @rdev: Regulator device | |
140 | * | |
141 | * Return: 0 if ok, non-zero if it fails. | |
142 | */ | |
143 | static int tps65090_fet_enable(struct regulator_dev *rdev) | |
144 | { | |
145 | int ret, tries; | |
146 | ||
147 | /* | |
148 | * Try enabling multiple times until we succeed since sometimes the | |
149 | * first try times out. | |
150 | */ | |
151 | tries = 0; | |
152 | while (true) { | |
153 | ret = tps65090_try_enable_fet(rdev); | |
154 | if (!ret) | |
155 | break; | |
156 | if (ret != -ENOTRECOVERABLE || tries == MAX_FET_ENABLE_TRIES) | |
157 | goto err; | |
158 | ||
159 | /* Try turning the FET off (and then on again) */ | |
160 | ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, | |
161 | rdev->desc->enable_mask, 0); | |
162 | if (ret) | |
163 | goto err; | |
164 | ||
165 | tries++; | |
166 | } | |
167 | ||
168 | if (tries) | |
169 | dev_warn(&rdev->dev, "reg %#x enable ok after %d tries\n", | |
170 | rdev->desc->enable_reg, tries); | |
171 | ||
172 | return 0; | |
173 | err: | |
174 | dev_warn(&rdev->dev, "reg %#x enable failed\n", rdev->desc->enable_reg); | |
175 | WARN_ON(1); | |
176 | ||
177 | return ret; | |
178 | } | |
179 | ||
180 | static struct regulator_ops tps65090_reg_control_ops = { | |
f329b175 LD |
181 | .enable = regulator_enable_regmap, |
182 | .disable = regulator_disable_regmap, | |
183 | .is_enabled = regulator_is_enabled_regmap, | |
452534e5 VB |
184 | }; |
185 | ||
ed11f1ea DA |
186 | static struct regulator_ops tps65090_fet_control_ops = { |
187 | .enable = tps65090_fet_enable, | |
188 | .disable = regulator_disable_regmap, | |
189 | .is_enabled = regulator_is_enabled_regmap, | |
190 | }; | |
191 | ||
3a81ef8c LD |
192 | static struct regulator_ops tps65090_ldo_ops = { |
193 | }; | |
194 | ||
4f2352cf | 195 | #define tps65090_REG_DESC(_id, _sname, _en_reg, _en_bits, _nvolt, _volt, _ops) \ |
452534e5 | 196 | { \ |
24282a1c LD |
197 | .name = "TPS65090_RAILS"#_id, \ |
198 | .supply_name = _sname, \ | |
8620ca9f | 199 | .id = TPS65090_REGULATOR_##_id, \ |
4f2352cf | 200 | .n_voltages = _nvolt, \ |
24282a1c | 201 | .ops = &_ops, \ |
4f2352cf | 202 | .fixed_uV = _volt, \ |
24282a1c | 203 | .enable_reg = _en_reg, \ |
ed11f1ea DA |
204 | .enable_val = _en_bits, \ |
205 | .enable_mask = _en_bits, \ | |
24282a1c LD |
206 | .type = REGULATOR_VOLTAGE, \ |
207 | .owner = THIS_MODULE, \ | |
452534e5 VB |
208 | } |
209 | ||
4f2352cf JMC |
210 | #define tps65090_REG_FIXEDV(_id, _sname, en_reg, _en_bits, _volt, _ops) \ |
211 | tps65090_REG_DESC(_id, _sname, en_reg, _en_bits, 1, _volt, _ops) | |
212 | ||
213 | #define tps65090_REG_SWITCH(_id, _sname, en_reg, _en_bits, _ops) \ | |
214 | tps65090_REG_DESC(_id, _sname, en_reg, _en_bits, 0, 0, _ops) | |
215 | ||
24282a1c | 216 | static struct regulator_desc tps65090_regulator_desc[] = { |
4f2352cf JMC |
217 | tps65090_REG_FIXEDV(DCDC1, "vsys1", 0x0C, BIT(CTRL_EN_BIT), 5000000, |
218 | tps65090_reg_control_ops), | |
219 | tps65090_REG_FIXEDV(DCDC2, "vsys2", 0x0D, BIT(CTRL_EN_BIT), 3300000, | |
220 | tps65090_reg_control_ops), | |
221 | tps65090_REG_SWITCH(DCDC3, "vsys3", 0x0E, BIT(CTRL_EN_BIT), | |
222 | tps65090_reg_control_ops), | |
223 | ||
224 | tps65090_REG_SWITCH(FET1, "infet1", 0x0F, | |
225 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
226 | tps65090_fet_control_ops), | |
227 | tps65090_REG_SWITCH(FET2, "infet2", 0x10, | |
228 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
229 | tps65090_fet_control_ops), | |
230 | tps65090_REG_SWITCH(FET3, "infet3", 0x11, | |
231 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
232 | tps65090_fet_control_ops), | |
233 | tps65090_REG_SWITCH(FET4, "infet4", 0x12, | |
234 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
235 | tps65090_fet_control_ops), | |
236 | tps65090_REG_SWITCH(FET5, "infet5", 0x13, | |
237 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
238 | tps65090_fet_control_ops), | |
239 | tps65090_REG_SWITCH(FET6, "infet6", 0x14, | |
240 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
241 | tps65090_fet_control_ops), | |
242 | tps65090_REG_SWITCH(FET7, "infet7", 0x15, | |
243 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
244 | tps65090_fet_control_ops), | |
245 | ||
246 | tps65090_REG_FIXEDV(LDO1, "vsys-l1", 0, 0, 5000000, | |
247 | tps65090_ldo_ops), | |
248 | tps65090_REG_FIXEDV(LDO2, "vsys-l2", 0, 0, 3300000, | |
249 | tps65090_ldo_ops), | |
452534e5 VB |
250 | }; |
251 | ||
24282a1c | 252 | static inline bool is_dcdc(int id) |
452534e5 | 253 | { |
24282a1c | 254 | switch (id) { |
8620ca9f LD |
255 | case TPS65090_REGULATOR_DCDC1: |
256 | case TPS65090_REGULATOR_DCDC2: | |
257 | case TPS65090_REGULATOR_DCDC3: | |
24282a1c LD |
258 | return true; |
259 | default: | |
260 | return false; | |
261 | } | |
262 | } | |
452534e5 | 263 | |
a5023574 | 264 | static int tps65090_config_ext_control( |
24282a1c LD |
265 | struct tps65090_regulator *ri, bool enable) |
266 | { | |
267 | int ret; | |
268 | struct device *parent = ri->dev->parent; | |
269 | unsigned int reg_en_reg = ri->desc->enable_reg; | |
270 | ||
271 | if (enable) | |
272 | ret = tps65090_set_bits(parent, reg_en_reg, 1); | |
273 | else | |
274 | ret = tps65090_clr_bits(parent, reg_en_reg, 1); | |
275 | if (ret < 0) | |
276 | dev_err(ri->dev, "Error in updating reg 0x%x\n", reg_en_reg); | |
277 | return ret; | |
278 | } | |
279 | ||
a5023574 | 280 | static int tps65090_regulator_disable_ext_control( |
24282a1c LD |
281 | struct tps65090_regulator *ri, |
282 | struct tps65090_regulator_plat_data *tps_pdata) | |
283 | { | |
284 | int ret = 0; | |
285 | struct device *parent = ri->dev->parent; | |
286 | unsigned int reg_en_reg = ri->desc->enable_reg; | |
287 | ||
288 | /* | |
289 | * First enable output for internal control if require. | |
290 | * And then disable external control. | |
291 | */ | |
292 | if (tps_pdata->reg_init_data->constraints.always_on || | |
293 | tps_pdata->reg_init_data->constraints.boot_on) { | |
294 | ret = tps65090_set_bits(parent, reg_en_reg, 0); | |
295 | if (ret < 0) { | |
296 | dev_err(ri->dev, "Error in set reg 0x%x\n", reg_en_reg); | |
297 | return ret; | |
298 | } | |
452534e5 | 299 | } |
24282a1c | 300 | return tps65090_config_ext_control(ri, false); |
452534e5 VB |
301 | } |
302 | ||
6c7a7a0e LD |
303 | #ifdef CONFIG_OF |
304 | static struct of_regulator_match tps65090_matches[] = { | |
305 | { .name = "dcdc1", }, | |
306 | { .name = "dcdc2", }, | |
307 | { .name = "dcdc3", }, | |
308 | { .name = "fet1", }, | |
309 | { .name = "fet2", }, | |
310 | { .name = "fet3", }, | |
311 | { .name = "fet4", }, | |
312 | { .name = "fet5", }, | |
313 | { .name = "fet6", }, | |
314 | { .name = "fet7", }, | |
315 | { .name = "ldo1", }, | |
316 | { .name = "ldo2", }, | |
317 | }; | |
318 | ||
319 | static struct tps65090_platform_data *tps65090_parse_dt_reg_data( | |
320 | struct platform_device *pdev, | |
321 | struct of_regulator_match **tps65090_reg_matches) | |
322 | { | |
323 | struct tps65090_platform_data *tps65090_pdata; | |
324 | struct device_node *np = pdev->dev.parent->of_node; | |
325 | struct device_node *regulators; | |
326 | int idx = 0, ret; | |
327 | struct tps65090_regulator_plat_data *reg_pdata; | |
328 | ||
329 | tps65090_pdata = devm_kzalloc(&pdev->dev, sizeof(*tps65090_pdata), | |
330 | GFP_KERNEL); | |
0ad91c69 | 331 | if (!tps65090_pdata) |
6c7a7a0e | 332 | return ERR_PTR(-ENOMEM); |
6c7a7a0e | 333 | |
a86854d0 KC |
334 | reg_pdata = devm_kcalloc(&pdev->dev, |
335 | TPS65090_REGULATOR_MAX, sizeof(*reg_pdata), | |
336 | GFP_KERNEL); | |
0ad91c69 | 337 | if (!reg_pdata) |
6c7a7a0e | 338 | return ERR_PTR(-ENOMEM); |
6c7a7a0e | 339 | |
4c850ead | 340 | regulators = of_get_child_by_name(np, "regulators"); |
6c7a7a0e LD |
341 | if (!regulators) { |
342 | dev_err(&pdev->dev, "regulator node not found\n"); | |
343 | return ERR_PTR(-ENODEV); | |
344 | } | |
345 | ||
09a228e7 | 346 | ret = of_regulator_match(&pdev->dev, regulators, tps65090_matches, |
6c7a7a0e | 347 | ARRAY_SIZE(tps65090_matches)); |
026cdfe6 | 348 | of_node_put(regulators); |
6c7a7a0e LD |
349 | if (ret < 0) { |
350 | dev_err(&pdev->dev, | |
351 | "Error parsing regulator init data: %d\n", ret); | |
352 | return ERR_PTR(ret); | |
353 | } | |
354 | ||
355 | *tps65090_reg_matches = tps65090_matches; | |
356 | for (idx = 0; idx < ARRAY_SIZE(tps65090_matches); idx++) { | |
357 | struct regulator_init_data *ri_data; | |
358 | struct tps65090_regulator_plat_data *rpdata; | |
359 | ||
360 | rpdata = ®_pdata[idx]; | |
361 | ri_data = tps65090_matches[idx].init_data; | |
362 | if (!ri_data || !tps65090_matches[idx].of_node) | |
363 | continue; | |
364 | ||
365 | rpdata->reg_init_data = ri_data; | |
366 | rpdata->enable_ext_control = of_property_read_bool( | |
367 | tps65090_matches[idx].of_node, | |
368 | "ti,enable-ext-control"); | |
3012e814 LW |
369 | if (rpdata->enable_ext_control) { |
370 | enum gpiod_flags gflags; | |
371 | ||
372 | if (ri_data->constraints.always_on || | |
373 | ri_data->constraints.boot_on) | |
374 | gflags = GPIOD_OUT_HIGH; | |
375 | else | |
376 | gflags = GPIOD_OUT_LOW; | |
63239e4b | 377 | gflags |= GPIOD_FLAGS_BIT_NONEXCLUSIVE; |
3012e814 LW |
378 | |
379 | rpdata->gpiod = devm_gpiod_get_from_of_node(&pdev->dev, | |
380 | tps65090_matches[idx].of_node, | |
381 | "dcdc-ext-control-gpios", 0, | |
382 | gflags, | |
383 | "tps65090"); | |
384 | if (IS_ERR(rpdata->gpiod)) | |
385 | return ERR_CAST(rpdata->gpiod); | |
386 | if (!rpdata->gpiod) | |
387 | dev_err(&pdev->dev, | |
388 | "could not find DCDC external control GPIO\n"); | |
389 | } | |
6c7a7a0e | 390 | |
29041449 DA |
391 | if (of_property_read_u32(tps65090_matches[idx].of_node, |
392 | "ti,overcurrent-wait", | |
393 | &rpdata->overcurrent_wait) == 0) | |
394 | rpdata->overcurrent_wait_valid = true; | |
395 | ||
6c7a7a0e LD |
396 | tps65090_pdata->reg_pdata[idx] = rpdata; |
397 | } | |
398 | return tps65090_pdata; | |
399 | } | |
400 | #else | |
401 | static inline struct tps65090_platform_data *tps65090_parse_dt_reg_data( | |
402 | struct platform_device *pdev, | |
403 | struct of_regulator_match **tps65090_reg_matches) | |
404 | { | |
405 | *tps65090_reg_matches = NULL; | |
406 | return NULL; | |
407 | } | |
408 | #endif | |
409 | ||
a5023574 | 410 | static int tps65090_regulator_probe(struct platform_device *pdev) |
452534e5 | 411 | { |
06c4998b | 412 | struct tps65090 *tps65090_mfd = dev_get_drvdata(pdev->dev.parent); |
452534e5 | 413 | struct tps65090_regulator *ri = NULL; |
c172708d | 414 | struct regulator_config config = { }; |
452534e5 | 415 | struct regulator_dev *rdev; |
24282a1c LD |
416 | struct tps65090_regulator_plat_data *tps_pdata; |
417 | struct tps65090_regulator *pmic; | |
418 | struct tps65090_platform_data *tps65090_pdata; | |
6c7a7a0e | 419 | struct of_regulator_match *tps65090_reg_matches = NULL; |
24282a1c LD |
420 | int num; |
421 | int ret; | |
452534e5 | 422 | |
24282a1c | 423 | dev_dbg(&pdev->dev, "Probing regulator\n"); |
452534e5 | 424 | |
24282a1c | 425 | tps65090_pdata = dev_get_platdata(pdev->dev.parent); |
6c7a7a0e LD |
426 | if (!tps65090_pdata && tps65090_mfd->dev->of_node) |
427 | tps65090_pdata = tps65090_parse_dt_reg_data(pdev, | |
428 | &tps65090_reg_matches); | |
429 | if (IS_ERR_OR_NULL(tps65090_pdata)) { | |
24282a1c | 430 | dev_err(&pdev->dev, "Platform data missing\n"); |
6c7a7a0e | 431 | return tps65090_pdata ? PTR_ERR(tps65090_pdata) : -EINVAL; |
452534e5 | 432 | } |
24282a1c | 433 | |
a86854d0 KC |
434 | pmic = devm_kcalloc(&pdev->dev, |
435 | TPS65090_REGULATOR_MAX, sizeof(*pmic), | |
436 | GFP_KERNEL); | |
0ad91c69 | 437 | if (!pmic) |
24282a1c | 438 | return -ENOMEM; |
24282a1c | 439 | |
8620ca9f | 440 | for (num = 0; num < TPS65090_REGULATOR_MAX; num++) { |
24282a1c LD |
441 | tps_pdata = tps65090_pdata->reg_pdata[num]; |
442 | ||
443 | ri = &pmic[num]; | |
444 | ri->dev = &pdev->dev; | |
445 | ri->desc = &tps65090_regulator_desc[num]; | |
c122c5b6 DA |
446 | if (tps_pdata) { |
447 | ri->overcurrent_wait_valid = | |
448 | tps_pdata->overcurrent_wait_valid; | |
449 | ri->overcurrent_wait = tps_pdata->overcurrent_wait; | |
450 | } | |
24282a1c LD |
451 | |
452 | /* | |
453 | * TPS5090 DCDC support the control from external digital input. | |
f329b175 | 454 | * Configure it as per platform data. |
24282a1c LD |
455 | */ |
456 | if (tps_pdata && is_dcdc(num) && tps_pdata->reg_init_data) { | |
f329b175 | 457 | if (tps_pdata->enable_ext_control) { |
3012e814 | 458 | config.ena_gpiod = tps_pdata->gpiod; |
f329b175 LD |
459 | ri->desc->ops = &tps65090_ext_control_ops; |
460 | } else { | |
461 | ret = tps65090_regulator_disable_ext_control( | |
24282a1c | 462 | ri, tps_pdata); |
f329b175 LD |
463 | if (ret < 0) { |
464 | dev_err(&pdev->dev, | |
24282a1c | 465 | "failed disable ext control\n"); |
9738efae | 466 | return ret; |
f329b175 | 467 | } |
24282a1c LD |
468 | } |
469 | } | |
f329b175 | 470 | |
6c7a7a0e | 471 | config.dev = pdev->dev.parent; |
24282a1c LD |
472 | config.driver_data = ri; |
473 | config.regmap = tps65090_mfd->rmap; | |
474 | if (tps_pdata) | |
475 | config.init_data = tps_pdata->reg_init_data; | |
476 | else | |
477 | config.init_data = NULL; | |
6c7a7a0e LD |
478 | if (tps65090_reg_matches) |
479 | config.of_node = tps65090_reg_matches[num].of_node; | |
480 | else | |
481 | config.of_node = NULL; | |
24282a1c | 482 | |
870311e5 LW |
483 | /* |
484 | * Hand the GPIO descriptor management over to the regulator | |
485 | * core, remove it from devres management. | |
486 | */ | |
487 | if (config.ena_gpiod) | |
488 | devm_gpiod_unhinge(&pdev->dev, config.ena_gpiod); | |
9738efae | 489 | rdev = devm_regulator_register(&pdev->dev, ri->desc, &config); |
24282a1c LD |
490 | if (IS_ERR(rdev)) { |
491 | dev_err(&pdev->dev, "failed to register regulator %s\n", | |
492 | ri->desc->name); | |
9738efae | 493 | return PTR_ERR(rdev); |
24282a1c LD |
494 | } |
495 | ri->rdev = rdev; | |
f329b175 | 496 | |
29041449 DA |
497 | if (ri->overcurrent_wait_valid) { |
498 | ret = tps65090_reg_set_overcurrent_wait(ri, rdev); | |
499 | if (ret < 0) | |
500 | return ret; | |
501 | } | |
502 | ||
f329b175 LD |
503 | /* Enable external control if it is require */ |
504 | if (tps_pdata && is_dcdc(num) && tps_pdata->reg_init_data && | |
505 | tps_pdata->enable_ext_control) { | |
506 | ret = tps65090_config_ext_control(ri, true); | |
9738efae SK |
507 | if (ret < 0) |
508 | return ret; | |
f329b175 | 509 | } |
452534e5 VB |
510 | } |
511 | ||
24282a1c | 512 | platform_set_drvdata(pdev, pmic); |
452534e5 | 513 | return 0; |
452534e5 VB |
514 | } |
515 | ||
516 | static struct platform_driver tps65090_regulator_driver = { | |
517 | .driver = { | |
8620ca9f | 518 | .name = "tps65090-pmic", |
452534e5 VB |
519 | }, |
520 | .probe = tps65090_regulator_probe, | |
452534e5 VB |
521 | }; |
522 | ||
523 | static int __init tps65090_regulator_init(void) | |
524 | { | |
525 | return platform_driver_register(&tps65090_regulator_driver); | |
526 | } | |
527 | subsys_initcall(tps65090_regulator_init); | |
528 | ||
529 | static void __exit tps65090_regulator_exit(void) | |
530 | { | |
531 | platform_driver_unregister(&tps65090_regulator_driver); | |
532 | } | |
533 | module_exit(tps65090_regulator_exit); | |
534 | ||
535 | MODULE_DESCRIPTION("tps65090 regulator driver"); | |
536 | MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>"); | |
537 | MODULE_LICENSE("GPL v2"); | |
d95420b8 | 538 | MODULE_ALIAS("platform:tps65090-pmic"); |