Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/regulator/wm831x-ldo.c

  1 /*
  2  * wm831x-ldo.c  --  LDO driver for the WM831x series
  3  *
  4  * Copyright 2009 Wolfson Microelectronics PLC.
  5  *
  6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
  7  *
  8  *  This program is free software; you can redistribute  it and/or modify it
  9  *  under  the terms of  the GNU General  Public License as published by the
 10  *  Free Software Foundation;  either version 2 of the  License, or (at your
 11  *  option) any later version.
 12  */
 13 
 14 #include <linux/module.h>
 15 #include <linux/moduleparam.h>
 16 #include <linux/init.h>
 17 #include <linux/bitops.h>
 18 #include <linux/err.h>
 19 #include <linux/i2c.h>
 20 #include <linux/platform_device.h>
 21 #include <linux/regulator/driver.h>
 22 #include <linux/slab.h>
 23 
 24 #include <linux/mfd/wm831x/core.h>
 25 #include <linux/mfd/wm831x/regulator.h>
 26 #include <linux/mfd/wm831x/pdata.h>
 27 
 28 #define WM831X_LDO_MAX_NAME 9
 29 
 30 #define WM831X_LDO_CONTROL       0
 31 #define WM831X_LDO_ON_CONTROL    1
 32 #define WM831X_LDO_SLEEP_CONTROL 2
 33 
 34 #define WM831X_ALIVE_LDO_ON_CONTROL    0
 35 #define WM831X_ALIVE_LDO_SLEEP_CONTROL 1
 36 
 37 struct wm831x_ldo {
 38         char name[WM831X_LDO_MAX_NAME];
 39         char supply_name[WM831X_LDO_MAX_NAME];
 40         struct regulator_desc desc;
 41         int base;
 42         struct wm831x *wm831x;
 43         struct regulator_dev *regulator;
 44 };
 45 
 46 /*
 47  * Shared
 48  */
 49 
 50 static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data)
 51 {
 52         struct wm831x_ldo *ldo = data;
 53 
 54         regulator_notifier_call_chain(ldo->regulator,
 55                                       REGULATOR_EVENT_UNDER_VOLTAGE,
 56                                       NULL);
 57 
 58         return IRQ_HANDLED;
 59 }
 60 
 61 /*
 62  * General purpose LDOs
 63  */
 64 
 65 static const struct regulator_linear_range wm831x_gp_ldo_ranges[] = {
 66         REGULATOR_LINEAR_RANGE(900000, 0, 14, 50000),
 67         REGULATOR_LINEAR_RANGE(1700000, 15, 31, 100000),
 68 };
 69 
 70 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
 71                                              int uV)
 72 {
 73         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 74         struct wm831x *wm831x = ldo->wm831x;
 75         int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
 76 
 77         sel = regulator_map_voltage_linear_range(rdev, uV, uV);
 78         if (sel < 0)
 79                 return sel;
 80 
 81         return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel);
 82 }
 83 
 84 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
 85 {
 86         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
 87         struct wm831x *wm831x = ldo->wm831x;
 88         int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
 89         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
 90         int ret;
 91 
 92         ret = wm831x_reg_read(wm831x, on_reg);
 93         if (ret < 0)
 94                 return ret;
 95 
 96         if (!(ret & WM831X_LDO1_ON_MODE))
 97                 return REGULATOR_MODE_NORMAL;
 98 
 99         ret = wm831x_reg_read(wm831x, ctrl_reg);
100         if (ret < 0)
101                 return ret;
102 
103         if (ret & WM831X_LDO1_LP_MODE)
104                 return REGULATOR_MODE_STANDBY;
105         else
106                 return REGULATOR_MODE_IDLE;
107 }
108 
109 static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev,
110                                   unsigned int mode)
111 {
112         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
113         struct wm831x *wm831x = ldo->wm831x;
114         int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
115         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
116         int ret;
117 
118 
119         switch (mode) {
120         case REGULATOR_MODE_NORMAL:
121                 ret = wm831x_set_bits(wm831x, on_reg,
122                                       WM831X_LDO1_ON_MODE, 0);
123                 if (ret < 0)
124                         return ret;
125                 break;
126 
127         case REGULATOR_MODE_IDLE:
128                 ret = wm831x_set_bits(wm831x, ctrl_reg,
129                                       WM831X_LDO1_LP_MODE, 0);
130                 if (ret < 0)
131                         return ret;
132 
133                 ret = wm831x_set_bits(wm831x, on_reg,
134                                       WM831X_LDO1_ON_MODE,
135                                       WM831X_LDO1_ON_MODE);
136                 if (ret < 0)
137                         return ret;
138                 break;
139 
140         case REGULATOR_MODE_STANDBY:
141                 ret = wm831x_set_bits(wm831x, ctrl_reg,
142                                       WM831X_LDO1_LP_MODE,
143                                       WM831X_LDO1_LP_MODE);
144                 if (ret < 0)
145                         return ret;
146 
147                 ret = wm831x_set_bits(wm831x, on_reg,
148                                       WM831X_LDO1_ON_MODE,
149                                       WM831X_LDO1_ON_MODE);
150                 if (ret < 0)
151                         return ret;
152                 break;
153 
154         default:
155                 return -EINVAL;
156         }
157 
158         return 0;
159 }
160 
161 static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
162 {
163         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
164         struct wm831x *wm831x = ldo->wm831x;
165         int mask = 1 << rdev_get_id(rdev);
166         int ret;
167 
168         /* Is the regulator on? */
169         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
170         if (ret < 0)
171                 return ret;
172         if (!(ret & mask))
173                 return REGULATOR_STATUS_OFF;
174 
175         /* Is it reporting under voltage? */
176         ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
177         if (ret < 0)
178                 return ret;
179         if (ret & mask)
180                 return REGULATOR_STATUS_ERROR;
181 
182         ret = wm831x_gp_ldo_get_mode(rdev);
183         if (ret < 0)
184                 return ret;
185         else
186                 return regulator_mode_to_status(ret);
187 }
188 
189 static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
190                                                    int input_uV,
191                                                    int output_uV, int load_uA)
192 {
193         if (load_uA < 20000)
194                 return REGULATOR_MODE_STANDBY;
195         if (load_uA < 50000)
196                 return REGULATOR_MODE_IDLE;
197         return REGULATOR_MODE_NORMAL;
198 }
199 
200 
201 static struct regulator_ops wm831x_gp_ldo_ops = {
202         .list_voltage = regulator_list_voltage_linear_range,
203         .map_voltage = regulator_map_voltage_linear_range,
204         .get_voltage_sel = regulator_get_voltage_sel_regmap,
205         .set_voltage_sel = regulator_set_voltage_sel_regmap,
206         .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
207         .get_mode = wm831x_gp_ldo_get_mode,
208         .set_mode = wm831x_gp_ldo_set_mode,
209         .get_status = wm831x_gp_ldo_get_status,
210         .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
211         .get_bypass = regulator_get_bypass_regmap,
212         .set_bypass = regulator_set_bypass_regmap,
213 
214         .is_enabled = regulator_is_enabled_regmap,
215         .enable = regulator_enable_regmap,
216         .disable = regulator_disable_regmap,
217 };
218 
219 static int wm831x_gp_ldo_probe(struct platform_device *pdev)
220 {
221         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
222         struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
223         struct regulator_config config = { };
224         int id;
225         struct wm831x_ldo *ldo;
226         struct resource *res;
227         int ret, irq;
228 
229         if (pdata && pdata->wm831x_num)
230                 id = (pdata->wm831x_num * 10) + 1;
231         else
232                 id = 0;
233         id = pdev->id - id;
234 
235         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
236 
237         ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
238         if (!ldo)
239                 return -ENOMEM;
240 
241         ldo->wm831x = wm831x;
242 
243         res = platform_get_resource(pdev, IORESOURCE_REG, 0);
244         if (res == NULL) {
245                 dev_err(&pdev->dev, "No REG resource\n");
246                 ret = -EINVAL;
247                 goto err;
248         }
249         ldo->base = res->start;
250 
251         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
252         ldo->desc.name = ldo->name;
253 
254         snprintf(ldo->supply_name, sizeof(ldo->supply_name),
255                  "LDO%dVDD", id + 1);
256         ldo->desc.supply_name = ldo->supply_name;
257 
258         ldo->desc.id = id;
259         ldo->desc.type = REGULATOR_VOLTAGE;
260         ldo->desc.n_voltages = 32;
261         ldo->desc.ops = &wm831x_gp_ldo_ops;
262         ldo->desc.owner = THIS_MODULE;
263         ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
264         ldo->desc.vsel_mask = WM831X_LDO1_ON_VSEL_MASK;
265         ldo->desc.enable_reg = WM831X_LDO_ENABLE;
266         ldo->desc.enable_mask = 1 << id;
267         ldo->desc.bypass_reg = ldo->base;
268         ldo->desc.bypass_mask = WM831X_LDO1_SWI;
269         ldo->desc.linear_ranges = wm831x_gp_ldo_ranges;
270         ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_gp_ldo_ranges);
271 
272         config.dev = pdev->dev.parent;
273         if (pdata)
274                 config.init_data = pdata->ldo[id];
275         config.driver_data = ldo;
276         config.regmap = wm831x->regmap;
277 
278         ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
279                                                  &config);
280         if (IS_ERR(ldo->regulator)) {
281                 ret = PTR_ERR(ldo->regulator);
282                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
283                         id + 1, ret);
284                 goto err;
285         }
286 
287         irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
288         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
289                                         wm831x_ldo_uv_irq,
290                                         IRQF_TRIGGER_RISING, ldo->name,
291                                         ldo);
292         if (ret != 0) {
293                 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
294                         irq, ret);
295                 goto err;
296         }
297 
298         platform_set_drvdata(pdev, ldo);
299 
300         return 0;
301 
302 err:
303         return ret;
304 }
305 
306 static struct platform_driver wm831x_gp_ldo_driver = {
307         .probe = wm831x_gp_ldo_probe,
308         .driver         = {
309                 .name   = "wm831x-ldo",
310                 .owner  = THIS_MODULE,
311         },
312 };
313 
314 /*
315  * Analogue LDOs
316  */
317 
318 static const struct regulator_linear_range wm831x_aldo_ranges[] = {
319         REGULATOR_LINEAR_RANGE(1000000, 0, 12, 50000),
320         REGULATOR_LINEAR_RANGE(1700000, 13, 31, 100000),
321 };
322 
323 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
324                                              int uV)
325 {
326         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
327         struct wm831x *wm831x = ldo->wm831x;
328         int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
329 
330         sel = regulator_map_voltage_linear_range(rdev, uV, uV);
331         if (sel < 0)
332                 return sel;
333 
334         return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel);
335 }
336 
337 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
338 {
339         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
340         struct wm831x *wm831x = ldo->wm831x;
341         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
342         int ret;
343 
344         ret = wm831x_reg_read(wm831x, on_reg);
345         if (ret < 0)
346                 return 0;
347 
348         if (ret & WM831X_LDO7_ON_MODE)
349                 return REGULATOR_MODE_IDLE;
350         else
351                 return REGULATOR_MODE_NORMAL;
352 }
353 
354 static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
355                                   unsigned int mode)
356 {
357         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
358         struct wm831x *wm831x = ldo->wm831x;
359         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
360         int ret;
361 
362 
363         switch (mode) {
364         case REGULATOR_MODE_NORMAL:
365                 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0);
366                 if (ret < 0)
367                         return ret;
368                 break;
369 
370         case REGULATOR_MODE_IDLE:
371                 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE,
372                                       WM831X_LDO7_ON_MODE);
373                 if (ret < 0)
374                         return ret;
375                 break;
376 
377         default:
378                 return -EINVAL;
379         }
380 
381         return 0;
382 }
383 
384 static int wm831x_aldo_get_status(struct regulator_dev *rdev)
385 {
386         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
387         struct wm831x *wm831x = ldo->wm831x;
388         int mask = 1 << rdev_get_id(rdev);
389         int ret;
390 
391         /* Is the regulator on? */
392         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
393         if (ret < 0)
394                 return ret;
395         if (!(ret & mask))
396                 return REGULATOR_STATUS_OFF;
397 
398         /* Is it reporting under voltage? */
399         ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
400         if (ret < 0)
401                 return ret;
402         if (ret & mask)
403                 return REGULATOR_STATUS_ERROR;
404 
405         ret = wm831x_aldo_get_mode(rdev);
406         if (ret < 0)
407                 return ret;
408         else
409                 return regulator_mode_to_status(ret);
410 }
411 
412 static struct regulator_ops wm831x_aldo_ops = {
413         .list_voltage = regulator_list_voltage_linear_range,
414         .map_voltage = regulator_map_voltage_linear_range,
415         .get_voltage_sel = regulator_get_voltage_sel_regmap,
416         .set_voltage_sel = regulator_set_voltage_sel_regmap,
417         .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
418         .get_mode = wm831x_aldo_get_mode,
419         .set_mode = wm831x_aldo_set_mode,
420         .get_status = wm831x_aldo_get_status,
421         .set_bypass = regulator_set_bypass_regmap,
422         .get_bypass = regulator_get_bypass_regmap,
423 
424         .is_enabled = regulator_is_enabled_regmap,
425         .enable = regulator_enable_regmap,
426         .disable = regulator_disable_regmap,
427 };
428 
429 static int wm831x_aldo_probe(struct platform_device *pdev)
430 {
431         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
432         struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
433         struct regulator_config config = { };
434         int id;
435         struct wm831x_ldo *ldo;
436         struct resource *res;
437         int ret, irq;
438 
439         if (pdata && pdata->wm831x_num)
440                 id = (pdata->wm831x_num * 10) + 1;
441         else
442                 id = 0;
443         id = pdev->id - id;
444 
445         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
446 
447         ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
448         if (!ldo)
449                 return -ENOMEM;
450 
451         ldo->wm831x = wm831x;
452 
453         res = platform_get_resource(pdev, IORESOURCE_REG, 0);
454         if (res == NULL) {
455                 dev_err(&pdev->dev, "No REG resource\n");
456                 ret = -EINVAL;
457                 goto err;
458         }
459         ldo->base = res->start;
460 
461         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
462         ldo->desc.name = ldo->name;
463 
464         snprintf(ldo->supply_name, sizeof(ldo->supply_name),
465                  "LDO%dVDD", id + 1);
466         ldo->desc.supply_name = ldo->supply_name;
467 
468         ldo->desc.id = id;
469         ldo->desc.type = REGULATOR_VOLTAGE;
470         ldo->desc.n_voltages = 32;
471         ldo->desc.linear_ranges = wm831x_aldo_ranges;
472         ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_aldo_ranges);
473         ldo->desc.ops = &wm831x_aldo_ops;
474         ldo->desc.owner = THIS_MODULE;
475         ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
476         ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK;
477         ldo->desc.enable_reg = WM831X_LDO_ENABLE;
478         ldo->desc.enable_mask = 1 << id;
479         ldo->desc.bypass_reg = ldo->base;
480         ldo->desc.bypass_mask = WM831X_LDO7_SWI;
481 
482         config.dev = pdev->dev.parent;
483         if (pdata)
484                 config.init_data = pdata->ldo[id];
485         config.driver_data = ldo;
486         config.regmap = wm831x->regmap;
487 
488         ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
489                                                  &config);
490         if (IS_ERR(ldo->regulator)) {
491                 ret = PTR_ERR(ldo->regulator);
492                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
493                         id + 1, ret);
494                 goto err;
495         }
496 
497         irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
498         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
499                                         wm831x_ldo_uv_irq,
500                                         IRQF_TRIGGER_RISING, ldo->name, ldo);
501         if (ret != 0) {
502                 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
503                         irq, ret);
504                 goto err;
505         }
506 
507         platform_set_drvdata(pdev, ldo);
508 
509         return 0;
510 
511 err:
512         return ret;
513 }
514 
515 static struct platform_driver wm831x_aldo_driver = {
516         .probe = wm831x_aldo_probe,
517         .driver         = {
518                 .name   = "wm831x-aldo",
519                 .owner  = THIS_MODULE,
520         },
521 };
522 
523 /*
524  * Alive LDO
525  */
526 
527 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
528 
529 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
530                                              int uV)
531 {
532         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
533         struct wm831x *wm831x = ldo->wm831x;
534         int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
535 
536         sel = regulator_map_voltage_linear(rdev, uV, uV);
537         if (sel < 0)
538                 return sel;
539 
540         return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel);
541 }
542 
543 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
544 {
545         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
546         struct wm831x *wm831x = ldo->wm831x;
547         int mask = 1 << rdev_get_id(rdev);
548         int ret;
549 
550         /* Is the regulator on? */
551         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
552         if (ret < 0)
553                 return ret;
554         if (ret & mask)
555                 return REGULATOR_STATUS_ON;
556         else
557                 return REGULATOR_STATUS_OFF;
558 }
559 
560 static struct regulator_ops wm831x_alive_ldo_ops = {
561         .list_voltage = regulator_list_voltage_linear,
562         .map_voltage = regulator_map_voltage_linear,
563         .get_voltage_sel = regulator_get_voltage_sel_regmap,
564         .set_voltage_sel = regulator_set_voltage_sel_regmap,
565         .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
566         .get_status = wm831x_alive_ldo_get_status,
567 
568         .is_enabled = regulator_is_enabled_regmap,
569         .enable = regulator_enable_regmap,
570         .disable = regulator_disable_regmap,
571 };
572 
573 static int wm831x_alive_ldo_probe(struct platform_device *pdev)
574 {
575         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
576         struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
577         struct regulator_config config = { };
578         int id;
579         struct wm831x_ldo *ldo;
580         struct resource *res;
581         int ret;
582 
583         if (pdata && pdata->wm831x_num)
584                 id = (pdata->wm831x_num * 10) + 1;
585         else
586                 id = 0;
587         id = pdev->id - id;
588 
589 
590         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
591 
592         ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
593         if (!ldo)
594                 return -ENOMEM;
595 
596         ldo->wm831x = wm831x;
597 
598         res = platform_get_resource(pdev, IORESOURCE_REG, 0);
599         if (res == NULL) {
600                 dev_err(&pdev->dev, "No REG resource\n");
601                 ret = -EINVAL;
602                 goto err;
603         }
604         ldo->base = res->start;
605 
606         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
607         ldo->desc.name = ldo->name;
608 
609         snprintf(ldo->supply_name, sizeof(ldo->supply_name),
610                  "LDO%dVDD", id + 1);
611         ldo->desc.supply_name = ldo->supply_name;
612 
613         ldo->desc.id = id;
614         ldo->desc.type = REGULATOR_VOLTAGE;
615         ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
616         ldo->desc.ops = &wm831x_alive_ldo_ops;
617         ldo->desc.owner = THIS_MODULE;
618         ldo->desc.vsel_reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
619         ldo->desc.vsel_mask = WM831X_LDO11_ON_VSEL_MASK;
620         ldo->desc.enable_reg = WM831X_LDO_ENABLE;
621         ldo->desc.enable_mask = 1 << id;
622         ldo->desc.min_uV = 800000;
623         ldo->desc.uV_step = 50000;
624         ldo->desc.enable_time = 1000;
625 
626         config.dev = pdev->dev.parent;
627         if (pdata)
628                 config.init_data = pdata->ldo[id];
629         config.driver_data = ldo;
630         config.regmap = wm831x->regmap;
631 
632         ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
633                                                  &config);
634         if (IS_ERR(ldo->regulator)) {
635                 ret = PTR_ERR(ldo->regulator);
636                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
637                         id + 1, ret);
638                 goto err;
639         }
640 
641         platform_set_drvdata(pdev, ldo);
642 
643         return 0;
644 
645 err:
646         return ret;
647 }
648 
649 static struct platform_driver wm831x_alive_ldo_driver = {
650         .probe = wm831x_alive_ldo_probe,
651         .driver         = {
652                 .name   = "wm831x-alive-ldo",
653                 .owner  = THIS_MODULE,
654         },
655 };
656 
657 static int __init wm831x_ldo_init(void)
658 {
659         int ret;
660 
661         ret = platform_driver_register(&wm831x_gp_ldo_driver);
662         if (ret != 0)
663                 pr_err("Failed to register WM831x GP LDO driver: %d\n", ret);
664 
665         ret = platform_driver_register(&wm831x_aldo_driver);
666         if (ret != 0)
667                 pr_err("Failed to register WM831x ALDO driver: %d\n", ret);
668 
669         ret = platform_driver_register(&wm831x_alive_ldo_driver);
670         if (ret != 0)
671                 pr_err("Failed to register WM831x alive LDO driver: %d\n",
672                        ret);
673 
674         return 0;
675 }
676 subsys_initcall(wm831x_ldo_init);
677 
678 static void __exit wm831x_ldo_exit(void)
679 {
680         platform_driver_unregister(&wm831x_alive_ldo_driver);
681         platform_driver_unregister(&wm831x_aldo_driver);
682         platform_driver_unregister(&wm831x_gp_ldo_driver);
683 }
684 module_exit(wm831x_ldo_exit);
685 
686 /* Module information */
687 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
688 MODULE_DESCRIPTION("WM831x LDO driver");
689 MODULE_LICENSE("GPL");
690 MODULE_ALIAS("platform:wm831x-ldo");
691 MODULE_ALIAS("platform:wm831x-aldo");
692 MODULE_ALIAS("platform:wm831x-aliveldo");
693 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us