]>
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 | ||
ed11f1ea | 195 | #define tps65090_REG_DESC(_id, _sname, _en_reg, _en_bits, _ops) \ |
452534e5 | 196 | { \ |
24282a1c LD |
197 | .name = "TPS65090_RAILS"#_id, \ |
198 | .supply_name = _sname, \ | |
8620ca9f | 199 | .id = TPS65090_REGULATOR_##_id, \ |
24282a1c LD |
200 | .ops = &_ops, \ |
201 | .enable_reg = _en_reg, \ | |
ed11f1ea DA |
202 | .enable_val = _en_bits, \ |
203 | .enable_mask = _en_bits, \ | |
24282a1c LD |
204 | .type = REGULATOR_VOLTAGE, \ |
205 | .owner = THIS_MODULE, \ | |
452534e5 VB |
206 | } |
207 | ||
24282a1c | 208 | static struct regulator_desc tps65090_regulator_desc[] = { |
ed11f1ea DA |
209 | tps65090_REG_DESC(DCDC1, "vsys1", 0x0C, BIT(CTRL_EN_BIT), |
210 | tps65090_reg_control_ops), | |
211 | tps65090_REG_DESC(DCDC2, "vsys2", 0x0D, BIT(CTRL_EN_BIT), | |
212 | tps65090_reg_control_ops), | |
213 | tps65090_REG_DESC(DCDC3, "vsys3", 0x0E, BIT(CTRL_EN_BIT), | |
214 | tps65090_reg_control_ops), | |
215 | ||
216 | tps65090_REG_DESC(FET1, "infet1", 0x0F, | |
217 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
218 | tps65090_fet_control_ops), | |
219 | tps65090_REG_DESC(FET2, "infet2", 0x10, | |
220 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
221 | tps65090_fet_control_ops), | |
222 | tps65090_REG_DESC(FET3, "infet3", 0x11, | |
223 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
224 | tps65090_fet_control_ops), | |
225 | tps65090_REG_DESC(FET4, "infet4", 0x12, | |
226 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
227 | tps65090_fet_control_ops), | |
228 | tps65090_REG_DESC(FET5, "infet5", 0x13, | |
229 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
230 | tps65090_fet_control_ops), | |
231 | tps65090_REG_DESC(FET6, "infet6", 0x14, | |
232 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
233 | tps65090_fet_control_ops), | |
234 | tps65090_REG_DESC(FET7, "infet7", 0x15, | |
235 | BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT), | |
236 | tps65090_fet_control_ops), | |
237 | ||
238 | tps65090_REG_DESC(LDO1, "vsys-l1", 0, 0, | |
239 | tps65090_ldo_ops), | |
240 | tps65090_REG_DESC(LDO2, "vsys-l2", 0, 0, | |
241 | tps65090_ldo_ops), | |
452534e5 VB |
242 | }; |
243 | ||
24282a1c | 244 | static inline bool is_dcdc(int id) |
452534e5 | 245 | { |
24282a1c | 246 | switch (id) { |
8620ca9f LD |
247 | case TPS65090_REGULATOR_DCDC1: |
248 | case TPS65090_REGULATOR_DCDC2: | |
249 | case TPS65090_REGULATOR_DCDC3: | |
24282a1c LD |
250 | return true; |
251 | default: | |
252 | return false; | |
253 | } | |
254 | } | |
452534e5 | 255 | |
a5023574 | 256 | static int tps65090_config_ext_control( |
24282a1c LD |
257 | struct tps65090_regulator *ri, bool enable) |
258 | { | |
259 | int ret; | |
260 | struct device *parent = ri->dev->parent; | |
261 | unsigned int reg_en_reg = ri->desc->enable_reg; | |
262 | ||
263 | if (enable) | |
264 | ret = tps65090_set_bits(parent, reg_en_reg, 1); | |
265 | else | |
266 | ret = tps65090_clr_bits(parent, reg_en_reg, 1); | |
267 | if (ret < 0) | |
268 | dev_err(ri->dev, "Error in updating reg 0x%x\n", reg_en_reg); | |
269 | return ret; | |
270 | } | |
271 | ||
a5023574 | 272 | static int tps65090_regulator_disable_ext_control( |
24282a1c LD |
273 | struct tps65090_regulator *ri, |
274 | struct tps65090_regulator_plat_data *tps_pdata) | |
275 | { | |
276 | int ret = 0; | |
277 | struct device *parent = ri->dev->parent; | |
278 | unsigned int reg_en_reg = ri->desc->enable_reg; | |
279 | ||
280 | /* | |
281 | * First enable output for internal control if require. | |
282 | * And then disable external control. | |
283 | */ | |
284 | if (tps_pdata->reg_init_data->constraints.always_on || | |
285 | tps_pdata->reg_init_data->constraints.boot_on) { | |
286 | ret = tps65090_set_bits(parent, reg_en_reg, 0); | |
287 | if (ret < 0) { | |
288 | dev_err(ri->dev, "Error in set reg 0x%x\n", reg_en_reg); | |
289 | return ret; | |
290 | } | |
452534e5 | 291 | } |
24282a1c | 292 | return tps65090_config_ext_control(ri, false); |
452534e5 VB |
293 | } |
294 | ||
a5023574 | 295 | static void tps65090_configure_regulator_config( |
f329b175 LD |
296 | struct tps65090_regulator_plat_data *tps_pdata, |
297 | struct regulator_config *config) | |
298 | { | |
299 | if (gpio_is_valid(tps_pdata->gpio)) { | |
300 | int gpio_flag = GPIOF_OUT_INIT_LOW; | |
301 | ||
302 | if (tps_pdata->reg_init_data->constraints.always_on || | |
303 | tps_pdata->reg_init_data->constraints.boot_on) | |
304 | gpio_flag = GPIOF_OUT_INIT_HIGH; | |
305 | ||
306 | config->ena_gpio = tps_pdata->gpio; | |
307 | config->ena_gpio_flags = gpio_flag; | |
308 | } | |
309 | } | |
310 | ||
6c7a7a0e LD |
311 | #ifdef CONFIG_OF |
312 | static struct of_regulator_match tps65090_matches[] = { | |
313 | { .name = "dcdc1", }, | |
314 | { .name = "dcdc2", }, | |
315 | { .name = "dcdc3", }, | |
316 | { .name = "fet1", }, | |
317 | { .name = "fet2", }, | |
318 | { .name = "fet3", }, | |
319 | { .name = "fet4", }, | |
320 | { .name = "fet5", }, | |
321 | { .name = "fet6", }, | |
322 | { .name = "fet7", }, | |
323 | { .name = "ldo1", }, | |
324 | { .name = "ldo2", }, | |
325 | }; | |
326 | ||
327 | static struct tps65090_platform_data *tps65090_parse_dt_reg_data( | |
328 | struct platform_device *pdev, | |
329 | struct of_regulator_match **tps65090_reg_matches) | |
330 | { | |
331 | struct tps65090_platform_data *tps65090_pdata; | |
332 | struct device_node *np = pdev->dev.parent->of_node; | |
333 | struct device_node *regulators; | |
334 | int idx = 0, ret; | |
335 | struct tps65090_regulator_plat_data *reg_pdata; | |
336 | ||
337 | tps65090_pdata = devm_kzalloc(&pdev->dev, sizeof(*tps65090_pdata), | |
338 | GFP_KERNEL); | |
0ad91c69 | 339 | if (!tps65090_pdata) |
6c7a7a0e | 340 | return ERR_PTR(-ENOMEM); |
6c7a7a0e LD |
341 | |
342 | reg_pdata = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX * | |
343 | sizeof(*reg_pdata), GFP_KERNEL); | |
0ad91c69 | 344 | if (!reg_pdata) |
6c7a7a0e | 345 | return ERR_PTR(-ENOMEM); |
6c7a7a0e | 346 | |
4c850ead | 347 | regulators = of_get_child_by_name(np, "regulators"); |
6c7a7a0e LD |
348 | if (!regulators) { |
349 | dev_err(&pdev->dev, "regulator node not found\n"); | |
350 | return ERR_PTR(-ENODEV); | |
351 | } | |
352 | ||
09a228e7 | 353 | ret = of_regulator_match(&pdev->dev, regulators, tps65090_matches, |
6c7a7a0e | 354 | ARRAY_SIZE(tps65090_matches)); |
026cdfe6 | 355 | of_node_put(regulators); |
6c7a7a0e LD |
356 | if (ret < 0) { |
357 | dev_err(&pdev->dev, | |
358 | "Error parsing regulator init data: %d\n", ret); | |
359 | return ERR_PTR(ret); | |
360 | } | |
361 | ||
362 | *tps65090_reg_matches = tps65090_matches; | |
363 | for (idx = 0; idx < ARRAY_SIZE(tps65090_matches); idx++) { | |
364 | struct regulator_init_data *ri_data; | |
365 | struct tps65090_regulator_plat_data *rpdata; | |
366 | ||
367 | rpdata = ®_pdata[idx]; | |
368 | ri_data = tps65090_matches[idx].init_data; | |
369 | if (!ri_data || !tps65090_matches[idx].of_node) | |
370 | continue; | |
371 | ||
372 | rpdata->reg_init_data = ri_data; | |
373 | rpdata->enable_ext_control = of_property_read_bool( | |
374 | tps65090_matches[idx].of_node, | |
375 | "ti,enable-ext-control"); | |
376 | if (rpdata->enable_ext_control) | |
377 | rpdata->gpio = of_get_named_gpio(np, | |
378 | "dcdc-ext-control-gpios", 0); | |
379 | ||
29041449 DA |
380 | if (of_property_read_u32(tps65090_matches[idx].of_node, |
381 | "ti,overcurrent-wait", | |
382 | &rpdata->overcurrent_wait) == 0) | |
383 | rpdata->overcurrent_wait_valid = true; | |
384 | ||
6c7a7a0e LD |
385 | tps65090_pdata->reg_pdata[idx] = rpdata; |
386 | } | |
387 | return tps65090_pdata; | |
388 | } | |
389 | #else | |
390 | static inline struct tps65090_platform_data *tps65090_parse_dt_reg_data( | |
391 | struct platform_device *pdev, | |
392 | struct of_regulator_match **tps65090_reg_matches) | |
393 | { | |
394 | *tps65090_reg_matches = NULL; | |
395 | return NULL; | |
396 | } | |
397 | #endif | |
398 | ||
a5023574 | 399 | static int tps65090_regulator_probe(struct platform_device *pdev) |
452534e5 | 400 | { |
06c4998b | 401 | struct tps65090 *tps65090_mfd = dev_get_drvdata(pdev->dev.parent); |
452534e5 | 402 | struct tps65090_regulator *ri = NULL; |
c172708d | 403 | struct regulator_config config = { }; |
452534e5 | 404 | struct regulator_dev *rdev; |
24282a1c LD |
405 | struct tps65090_regulator_plat_data *tps_pdata; |
406 | struct tps65090_regulator *pmic; | |
407 | struct tps65090_platform_data *tps65090_pdata; | |
6c7a7a0e | 408 | struct of_regulator_match *tps65090_reg_matches = NULL; |
24282a1c LD |
409 | int num; |
410 | int ret; | |
452534e5 | 411 | |
24282a1c | 412 | dev_dbg(&pdev->dev, "Probing regulator\n"); |
452534e5 | 413 | |
24282a1c | 414 | tps65090_pdata = dev_get_platdata(pdev->dev.parent); |
6c7a7a0e LD |
415 | if (!tps65090_pdata && tps65090_mfd->dev->of_node) |
416 | tps65090_pdata = tps65090_parse_dt_reg_data(pdev, | |
417 | &tps65090_reg_matches); | |
418 | if (IS_ERR_OR_NULL(tps65090_pdata)) { | |
24282a1c | 419 | dev_err(&pdev->dev, "Platform data missing\n"); |
6c7a7a0e | 420 | return tps65090_pdata ? PTR_ERR(tps65090_pdata) : -EINVAL; |
452534e5 | 421 | } |
24282a1c | 422 | |
8620ca9f | 423 | pmic = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX * sizeof(*pmic), |
24282a1c | 424 | GFP_KERNEL); |
0ad91c69 | 425 | if (!pmic) |
24282a1c | 426 | return -ENOMEM; |
24282a1c | 427 | |
8620ca9f | 428 | for (num = 0; num < TPS65090_REGULATOR_MAX; num++) { |
24282a1c LD |
429 | tps_pdata = tps65090_pdata->reg_pdata[num]; |
430 | ||
431 | ri = &pmic[num]; | |
432 | ri->dev = &pdev->dev; | |
433 | ri->desc = &tps65090_regulator_desc[num]; | |
29041449 DA |
434 | ri->overcurrent_wait_valid = tps_pdata->overcurrent_wait_valid; |
435 | ri->overcurrent_wait = tps_pdata->overcurrent_wait; | |
24282a1c LD |
436 | |
437 | /* | |
438 | * TPS5090 DCDC support the control from external digital input. | |
f329b175 | 439 | * Configure it as per platform data. |
24282a1c LD |
440 | */ |
441 | if (tps_pdata && is_dcdc(num) && tps_pdata->reg_init_data) { | |
f329b175 LD |
442 | if (tps_pdata->enable_ext_control) { |
443 | tps65090_configure_regulator_config( | |
444 | tps_pdata, &config); | |
445 | ri->desc->ops = &tps65090_ext_control_ops; | |
446 | } else { | |
447 | ret = tps65090_regulator_disable_ext_control( | |
24282a1c | 448 | ri, tps_pdata); |
f329b175 LD |
449 | if (ret < 0) { |
450 | dev_err(&pdev->dev, | |
24282a1c | 451 | "failed disable ext control\n"); |
9738efae | 452 | return ret; |
f329b175 | 453 | } |
24282a1c LD |
454 | } |
455 | } | |
f329b175 | 456 | |
6c7a7a0e | 457 | config.dev = pdev->dev.parent; |
24282a1c LD |
458 | config.driver_data = ri; |
459 | config.regmap = tps65090_mfd->rmap; | |
460 | if (tps_pdata) | |
461 | config.init_data = tps_pdata->reg_init_data; | |
462 | else | |
463 | config.init_data = NULL; | |
6c7a7a0e LD |
464 | if (tps65090_reg_matches) |
465 | config.of_node = tps65090_reg_matches[num].of_node; | |
466 | else | |
467 | config.of_node = NULL; | |
24282a1c | 468 | |
9738efae | 469 | rdev = devm_regulator_register(&pdev->dev, ri->desc, &config); |
24282a1c LD |
470 | if (IS_ERR(rdev)) { |
471 | dev_err(&pdev->dev, "failed to register regulator %s\n", | |
472 | ri->desc->name); | |
9738efae | 473 | return PTR_ERR(rdev); |
24282a1c LD |
474 | } |
475 | ri->rdev = rdev; | |
f329b175 | 476 | |
29041449 DA |
477 | if (ri->overcurrent_wait_valid) { |
478 | ret = tps65090_reg_set_overcurrent_wait(ri, rdev); | |
479 | if (ret < 0) | |
480 | return ret; | |
481 | } | |
482 | ||
f329b175 LD |
483 | /* Enable external control if it is require */ |
484 | if (tps_pdata && is_dcdc(num) && tps_pdata->reg_init_data && | |
485 | tps_pdata->enable_ext_control) { | |
486 | ret = tps65090_config_ext_control(ri, true); | |
9738efae SK |
487 | if (ret < 0) |
488 | return ret; | |
f329b175 | 489 | } |
452534e5 VB |
490 | } |
491 | ||
24282a1c | 492 | platform_set_drvdata(pdev, pmic); |
452534e5 | 493 | return 0; |
452534e5 VB |
494 | } |
495 | ||
496 | static struct platform_driver tps65090_regulator_driver = { | |
497 | .driver = { | |
8620ca9f | 498 | .name = "tps65090-pmic", |
452534e5 VB |
499 | .owner = THIS_MODULE, |
500 | }, | |
501 | .probe = tps65090_regulator_probe, | |
452534e5 VB |
502 | }; |
503 | ||
504 | static int __init tps65090_regulator_init(void) | |
505 | { | |
506 | return platform_driver_register(&tps65090_regulator_driver); | |
507 | } | |
508 | subsys_initcall(tps65090_regulator_init); | |
509 | ||
510 | static void __exit tps65090_regulator_exit(void) | |
511 | { | |
512 | platform_driver_unregister(&tps65090_regulator_driver); | |
513 | } | |
514 | module_exit(tps65090_regulator_exit); | |
515 | ||
516 | MODULE_DESCRIPTION("tps65090 regulator driver"); | |
517 | MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>"); | |
518 | MODULE_LICENSE("GPL v2"); | |
d95420b8 | 519 | MODULE_ALIAS("platform:tps65090-pmic"); |