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> |
f329b175 | 22 | #include <linux/gpio.h> |
6c7a7a0e | 23 | #include <linux/of_gpio.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 | ||
a5023574 | 303 | static void tps65090_configure_regulator_config( |
f329b175 LD |
304 | struct tps65090_regulator_plat_data *tps_pdata, |
305 | struct regulator_config *config) | |
306 | { | |
307 | if (gpio_is_valid(tps_pdata->gpio)) { | |
308 | int gpio_flag = GPIOF_OUT_INIT_LOW; | |
309 | ||
310 | if (tps_pdata->reg_init_data->constraints.always_on || | |
311 | tps_pdata->reg_init_data->constraints.boot_on) | |
312 | gpio_flag = GPIOF_OUT_INIT_HIGH; | |
313 | ||
314 | config->ena_gpio = tps_pdata->gpio; | |
1de3821a | 315 | config->ena_gpio_initialized = true; |
f329b175 | 316 | config->ena_gpio_flags = gpio_flag; |
679c038f MP |
317 | } else { |
318 | config->ena_gpio = -EINVAL; | |
319 | config->ena_gpio_initialized = false; | |
f329b175 LD |
320 | } |
321 | } | |
322 | ||
6c7a7a0e LD |
323 | #ifdef CONFIG_OF |
324 | static struct of_regulator_match tps65090_matches[] = { | |
325 | { .name = "dcdc1", }, | |
326 | { .name = "dcdc2", }, | |
327 | { .name = "dcdc3", }, | |
328 | { .name = "fet1", }, | |
329 | { .name = "fet2", }, | |
330 | { .name = "fet3", }, | |
331 | { .name = "fet4", }, | |
332 | { .name = "fet5", }, | |
333 | { .name = "fet6", }, | |
334 | { .name = "fet7", }, | |
335 | { .name = "ldo1", }, | |
336 | { .name = "ldo2", }, | |
337 | }; | |
338 | ||
339 | static struct tps65090_platform_data *tps65090_parse_dt_reg_data( | |
340 | struct platform_device *pdev, | |
341 | struct of_regulator_match **tps65090_reg_matches) | |
342 | { | |
343 | struct tps65090_platform_data *tps65090_pdata; | |
344 | struct device_node *np = pdev->dev.parent->of_node; | |
345 | struct device_node *regulators; | |
346 | int idx = 0, ret; | |
347 | struct tps65090_regulator_plat_data *reg_pdata; | |
348 | ||
349 | tps65090_pdata = devm_kzalloc(&pdev->dev, sizeof(*tps65090_pdata), | |
350 | GFP_KERNEL); | |
0ad91c69 | 351 | if (!tps65090_pdata) |
6c7a7a0e | 352 | return ERR_PTR(-ENOMEM); |
6c7a7a0e LD |
353 | |
354 | reg_pdata = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX * | |
355 | sizeof(*reg_pdata), GFP_KERNEL); | |
0ad91c69 | 356 | if (!reg_pdata) |
6c7a7a0e | 357 | return ERR_PTR(-ENOMEM); |
6c7a7a0e | 358 | |
4c850ead | 359 | regulators = of_get_child_by_name(np, "regulators"); |
6c7a7a0e LD |
360 | if (!regulators) { |
361 | dev_err(&pdev->dev, "regulator node not found\n"); | |
362 | return ERR_PTR(-ENODEV); | |
363 | } | |
364 | ||
09a228e7 | 365 | ret = of_regulator_match(&pdev->dev, regulators, tps65090_matches, |
6c7a7a0e | 366 | ARRAY_SIZE(tps65090_matches)); |
026cdfe6 | 367 | of_node_put(regulators); |
6c7a7a0e LD |
368 | if (ret < 0) { |
369 | dev_err(&pdev->dev, | |
370 | "Error parsing regulator init data: %d\n", ret); | |
371 | return ERR_PTR(ret); | |
372 | } | |
373 | ||
374 | *tps65090_reg_matches = tps65090_matches; | |
375 | for (idx = 0; idx < ARRAY_SIZE(tps65090_matches); idx++) { | |
376 | struct regulator_init_data *ri_data; | |
377 | struct tps65090_regulator_plat_data *rpdata; | |
378 | ||
379 | rpdata = ®_pdata[idx]; | |
380 | ri_data = tps65090_matches[idx].init_data; | |
381 | if (!ri_data || !tps65090_matches[idx].of_node) | |
382 | continue; | |
383 | ||
384 | rpdata->reg_init_data = ri_data; | |
385 | rpdata->enable_ext_control = of_property_read_bool( | |
386 | tps65090_matches[idx].of_node, | |
387 | "ti,enable-ext-control"); | |
388 | if (rpdata->enable_ext_control) | |
389 | rpdata->gpio = of_get_named_gpio(np, | |
390 | "dcdc-ext-control-gpios", 0); | |
391 | ||
29041449 DA |
392 | if (of_property_read_u32(tps65090_matches[idx].of_node, |
393 | "ti,overcurrent-wait", | |
394 | &rpdata->overcurrent_wait) == 0) | |
395 | rpdata->overcurrent_wait_valid = true; | |
396 | ||
6c7a7a0e LD |
397 | tps65090_pdata->reg_pdata[idx] = rpdata; |
398 | } | |
399 | return tps65090_pdata; | |
400 | } | |
401 | #else | |
402 | static inline struct tps65090_platform_data *tps65090_parse_dt_reg_data( | |
403 | struct platform_device *pdev, | |
404 | struct of_regulator_match **tps65090_reg_matches) | |
405 | { | |
406 | *tps65090_reg_matches = NULL; | |
407 | return NULL; | |
408 | } | |
409 | #endif | |
410 | ||
a5023574 | 411 | static int tps65090_regulator_probe(struct platform_device *pdev) |
452534e5 | 412 | { |
06c4998b | 413 | struct tps65090 *tps65090_mfd = dev_get_drvdata(pdev->dev.parent); |
452534e5 | 414 | struct tps65090_regulator *ri = NULL; |
c172708d | 415 | struct regulator_config config = { }; |
452534e5 | 416 | struct regulator_dev *rdev; |
24282a1c LD |
417 | struct tps65090_regulator_plat_data *tps_pdata; |
418 | struct tps65090_regulator *pmic; | |
419 | struct tps65090_platform_data *tps65090_pdata; | |
6c7a7a0e | 420 | struct of_regulator_match *tps65090_reg_matches = NULL; |
24282a1c LD |
421 | int num; |
422 | int ret; | |
452534e5 | 423 | |
24282a1c | 424 | dev_dbg(&pdev->dev, "Probing regulator\n"); |
452534e5 | 425 | |
24282a1c | 426 | tps65090_pdata = dev_get_platdata(pdev->dev.parent); |
6c7a7a0e LD |
427 | if (!tps65090_pdata && tps65090_mfd->dev->of_node) |
428 | tps65090_pdata = tps65090_parse_dt_reg_data(pdev, | |
429 | &tps65090_reg_matches); | |
430 | if (IS_ERR_OR_NULL(tps65090_pdata)) { | |
24282a1c | 431 | dev_err(&pdev->dev, "Platform data missing\n"); |
6c7a7a0e | 432 | return tps65090_pdata ? PTR_ERR(tps65090_pdata) : -EINVAL; |
452534e5 | 433 | } |
24282a1c | 434 | |
8620ca9f | 435 | pmic = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX * sizeof(*pmic), |
24282a1c | 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 LD |
457 | if (tps_pdata->enable_ext_control) { |
458 | tps65090_configure_regulator_config( | |
459 | tps_pdata, &config); | |
460 | ri->desc->ops = &tps65090_ext_control_ops; | |
461 | } else { | |
462 | ret = tps65090_regulator_disable_ext_control( | |
24282a1c | 463 | ri, tps_pdata); |
f329b175 LD |
464 | if (ret < 0) { |
465 | dev_err(&pdev->dev, | |
24282a1c | 466 | "failed disable ext control\n"); |
9738efae | 467 | return ret; |
f329b175 | 468 | } |
24282a1c LD |
469 | } |
470 | } | |
f329b175 | 471 | |
6c7a7a0e | 472 | config.dev = pdev->dev.parent; |
24282a1c LD |
473 | config.driver_data = ri; |
474 | config.regmap = tps65090_mfd->rmap; | |
475 | if (tps_pdata) | |
476 | config.init_data = tps_pdata->reg_init_data; | |
477 | else | |
478 | config.init_data = NULL; | |
6c7a7a0e LD |
479 | if (tps65090_reg_matches) |
480 | config.of_node = tps65090_reg_matches[num].of_node; | |
481 | else | |
482 | config.of_node = NULL; | |
24282a1c | 483 | |
9738efae | 484 | rdev = devm_regulator_register(&pdev->dev, ri->desc, &config); |
24282a1c LD |
485 | if (IS_ERR(rdev)) { |
486 | dev_err(&pdev->dev, "failed to register regulator %s\n", | |
487 | ri->desc->name); | |
9738efae | 488 | return PTR_ERR(rdev); |
24282a1c LD |
489 | } |
490 | ri->rdev = rdev; | |
f329b175 | 491 | |
29041449 DA |
492 | if (ri->overcurrent_wait_valid) { |
493 | ret = tps65090_reg_set_overcurrent_wait(ri, rdev); | |
494 | if (ret < 0) | |
495 | return ret; | |
496 | } | |
497 | ||
f329b175 LD |
498 | /* Enable external control if it is require */ |
499 | if (tps_pdata && is_dcdc(num) && tps_pdata->reg_init_data && | |
500 | tps_pdata->enable_ext_control) { | |
501 | ret = tps65090_config_ext_control(ri, true); | |
9738efae SK |
502 | if (ret < 0) |
503 | return ret; | |
f329b175 | 504 | } |
452534e5 VB |
505 | } |
506 | ||
24282a1c | 507 | platform_set_drvdata(pdev, pmic); |
452534e5 | 508 | return 0; |
452534e5 VB |
509 | } |
510 | ||
511 | static struct platform_driver tps65090_regulator_driver = { | |
512 | .driver = { | |
8620ca9f | 513 | .name = "tps65090-pmic", |
452534e5 VB |
514 | }, |
515 | .probe = tps65090_regulator_probe, | |
452534e5 VB |
516 | }; |
517 | ||
518 | static int __init tps65090_regulator_init(void) | |
519 | { | |
520 | return platform_driver_register(&tps65090_regulator_driver); | |
521 | } | |
522 | subsys_initcall(tps65090_regulator_init); | |
523 | ||
524 | static void __exit tps65090_regulator_exit(void) | |
525 | { | |
526 | platform_driver_unregister(&tps65090_regulator_driver); | |
527 | } | |
528 | module_exit(tps65090_regulator_exit); | |
529 | ||
530 | MODULE_DESCRIPTION("tps65090 regulator driver"); | |
531 | MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>"); | |
532 | MODULE_LICENSE("GPL v2"); | |
d95420b8 | 533 | MODULE_ALIAS("platform:tps65090-pmic"); |