perf: Do not export power_frequency, but power_start event
[linux-2.6.git] / 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 6
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         struct regulator_desc desc;
40         int base;
41         struct wm831x *wm831x;
42         struct regulator_dev *regulator;
43 };
44
45 /*
46  * Shared
47  */
48
49 static int wm831x_ldo_is_enabled(struct regulator_dev *rdev)
50 {
51         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
52         struct wm831x *wm831x = ldo->wm831x;
53         int mask = 1 << rdev_get_id(rdev);
54         int reg;
55
56         reg = wm831x_reg_read(wm831x, WM831X_LDO_ENABLE);
57         if (reg < 0)
58                 return reg;
59
60         if (reg & mask)
61                 return 1;
62         else
63                 return 0;
64 }
65
66 static int wm831x_ldo_enable(struct regulator_dev *rdev)
67 {
68         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
69         struct wm831x *wm831x = ldo->wm831x;
70         int mask = 1 << rdev_get_id(rdev);
71
72         return wm831x_set_bits(wm831x, WM831X_LDO_ENABLE, mask, mask);
73 }
74
75 static int wm831x_ldo_disable(struct regulator_dev *rdev)
76 {
77         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
78         struct wm831x *wm831x = ldo->wm831x;
79         int mask = 1 << rdev_get_id(rdev);
80
81         return wm831x_set_bits(wm831x, WM831X_LDO_ENABLE, mask, 0);
82 }
83
84 static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data)
85 {
86         struct wm831x_ldo *ldo = data;
87
88         regulator_notifier_call_chain(ldo->regulator,
89                                       REGULATOR_EVENT_UNDER_VOLTAGE,
90                                       NULL);
91
92         return IRQ_HANDLED;
93 }
94
95 /*
96  * General purpose LDOs
97  */
98
99 #define WM831X_GP_LDO_SELECTOR_LOW 0xe
100 #define WM831X_GP_LDO_MAX_SELECTOR 0x1f
101
102 static int wm831x_gp_ldo_list_voltage(struct regulator_dev *rdev,
103                                       unsigned int selector)
104 {
105         /* 0.9-1.6V in 50mV steps */
106         if (selector <= WM831X_GP_LDO_SELECTOR_LOW)
107                 return 900000 + (selector * 50000);
108         /* 1.7-3.3V in 50mV steps */
109         if (selector <= WM831X_GP_LDO_MAX_SELECTOR)
110                 return 1600000 + ((selector - WM831X_GP_LDO_SELECTOR_LOW)
111                                   * 100000);
112         return -EINVAL;
113 }
114
115 static int wm831x_gp_ldo_set_voltage_int(struct regulator_dev *rdev, int reg,
116                                          int min_uV, int max_uV)
117 {
118         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
119         struct wm831x *wm831x = ldo->wm831x;
120         int vsel, ret;
121
122         if (min_uV < 900000)
123                 vsel = 0;
124         else if (min_uV < 1700000)
125                 vsel = ((min_uV - 900000) / 50000);
126         else
127                 vsel = ((min_uV - 1700000) / 100000)
128                         + WM831X_GP_LDO_SELECTOR_LOW + 1;
129
130         ret = wm831x_gp_ldo_list_voltage(rdev, vsel);
131         if (ret < 0)
132                 return ret;
133         if (ret < min_uV || ret > max_uV)
134                 return -EINVAL;
135
136         return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, vsel);
137 }
138
139 static int wm831x_gp_ldo_set_voltage(struct regulator_dev *rdev,
140                                      int min_uV, int max_uV)
141 {
142         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
143         int reg = ldo->base + WM831X_LDO_ON_CONTROL;
144
145         return wm831x_gp_ldo_set_voltage_int(rdev, reg, min_uV, max_uV);
146 }
147
148 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
149                                              int uV)
150 {
151         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
152         int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
153
154         return wm831x_gp_ldo_set_voltage_int(rdev, reg, uV, uV);
155 }
156
157 static int wm831x_gp_ldo_get_voltage(struct regulator_dev *rdev)
158 {
159         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
160         struct wm831x *wm831x = ldo->wm831x;
161         int reg = ldo->base + WM831X_LDO_ON_CONTROL;
162         int ret;
163
164         ret = wm831x_reg_read(wm831x, reg);
165         if (ret < 0)
166                 return ret;
167
168         ret &= WM831X_LDO1_ON_VSEL_MASK;
169
170         return wm831x_gp_ldo_list_voltage(rdev, ret);
171 }
172
173 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
174 {
175         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
176         struct wm831x *wm831x = ldo->wm831x;
177         int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
178         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
179         int ret;
180
181         ret = wm831x_reg_read(wm831x, on_reg);
182         if (ret < 0)
183                 return ret;
184
185         if (!(ret & WM831X_LDO1_ON_MODE))
186                 return REGULATOR_MODE_NORMAL;
187
188         ret = wm831x_reg_read(wm831x, ctrl_reg);
189         if (ret < 0)
190                 return ret;
191
192         if (ret & WM831X_LDO1_LP_MODE)
193                 return REGULATOR_MODE_STANDBY;
194         else
195                 return REGULATOR_MODE_IDLE;
196 }
197
198 static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev,
199                                   unsigned int mode)
200 {
201         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
202         struct wm831x *wm831x = ldo->wm831x;
203         int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
204         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
205         int ret;
206
207
208         switch (mode) {
209         case REGULATOR_MODE_NORMAL:
210                 ret = wm831x_set_bits(wm831x, on_reg,
211                                       WM831X_LDO1_ON_MODE, 0);
212                 if (ret < 0)
213                         return ret;
214                 break;
215
216         case REGULATOR_MODE_IDLE:
217                 ret = wm831x_set_bits(wm831x, ctrl_reg,
218                                       WM831X_LDO1_LP_MODE, 0);
219                 if (ret < 0)
220                         return ret;
221
222                 ret = wm831x_set_bits(wm831x, on_reg,
223                                       WM831X_LDO1_ON_MODE,
224                                       WM831X_LDO1_ON_MODE);
225                 if (ret < 0)
226                         return ret;
227                 break;
228
229         case REGULATOR_MODE_STANDBY:
230                 ret = wm831x_set_bits(wm831x, ctrl_reg,
231                                       WM831X_LDO1_LP_MODE,
232                                       WM831X_LDO1_LP_MODE);
233                 if (ret < 0)
234                         return ret;
235
236                 ret = wm831x_set_bits(wm831x, on_reg,
237                                       WM831X_LDO1_ON_MODE,
238                                       WM831X_LDO1_ON_MODE);
239                 if (ret < 0)
240                         return ret;
241                 break;
242
243         default:
244                 return -EINVAL;
245         }
246
247         return 0;
248 }
249
250 static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
251 {
252         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
253         struct wm831x *wm831x = ldo->wm831x;
254         int mask = 1 << rdev_get_id(rdev);
255         int ret;
256
257         /* Is the regulator on? */
258         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
259         if (ret < 0)
260                 return ret;
261         if (!(ret & mask))
262                 return REGULATOR_STATUS_OFF;
263
264         /* Is it reporting under voltage? */
265         ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
266         if (ret & mask)
267                 return REGULATOR_STATUS_ERROR;
268
269         ret = wm831x_gp_ldo_get_mode(rdev);
270         if (ret < 0)
271                 return ret;
272         else
273                 return regulator_mode_to_status(ret);
274 }
275
276 static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
277                                                    int input_uV,
278                                                    int output_uV, int load_uA)
279 {
280         if (load_uA < 20000)
281                 return REGULATOR_MODE_STANDBY;
282         if (load_uA < 50000)
283                 return REGULATOR_MODE_IDLE;
284         return REGULATOR_MODE_NORMAL;
285 }
286
287
288 static struct regulator_ops wm831x_gp_ldo_ops = {
289         .list_voltage = wm831x_gp_ldo_list_voltage,
290         .get_voltage = wm831x_gp_ldo_get_voltage,
291         .set_voltage = wm831x_gp_ldo_set_voltage,
292         .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
293         .get_mode = wm831x_gp_ldo_get_mode,
294         .set_mode = wm831x_gp_ldo_set_mode,
295         .get_status = wm831x_gp_ldo_get_status,
296         .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
297
298         .is_enabled = wm831x_ldo_is_enabled,
299         .enable = wm831x_ldo_enable,
300         .disable = wm831x_ldo_disable,
301 };
302
303 static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev)
304 {
305         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
306         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
307         int id = pdev->id % ARRAY_SIZE(pdata->ldo);
308         struct wm831x_ldo *ldo;
309         struct resource *res;
310         int ret, irq;
311
312         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
313
314         if (pdata == NULL || pdata->ldo[id] == NULL)
315                 return -ENODEV;
316
317         ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL);
318         if (ldo == NULL) {
319                 dev_err(&pdev->dev, "Unable to allocate private data\n");
320                 return -ENOMEM;
321         }
322
323         ldo->wm831x = wm831x;
324
325         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
326         if (res == NULL) {
327                 dev_err(&pdev->dev, "No I/O resource\n");
328                 ret = -EINVAL;
329                 goto err;
330         }
331         ldo->base = res->start;
332
333         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
334         ldo->desc.name = ldo->name;
335         ldo->desc.id = id;
336         ldo->desc.type = REGULATOR_VOLTAGE;
337         ldo->desc.n_voltages = WM831X_GP_LDO_MAX_SELECTOR + 1;
338         ldo->desc.ops = &wm831x_gp_ldo_ops;
339         ldo->desc.owner = THIS_MODULE;
340
341         ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
342                                              pdata->ldo[id], ldo);
343         if (IS_ERR(ldo->regulator)) {
344                 ret = PTR_ERR(ldo->regulator);
345                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
346                         id + 1, ret);
347                 goto err;
348         }
349
350         irq = platform_get_irq_byname(pdev, "UV");
351         ret = wm831x_request_irq(wm831x, irq, wm831x_ldo_uv_irq,
352                                  IRQF_TRIGGER_RISING, ldo->name,
353                                  ldo);
354         if (ret != 0) {
355                 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
356                         irq, ret);
357                 goto err_regulator;
358         }
359
360         platform_set_drvdata(pdev, ldo);
361
362         return 0;
363
364 err_regulator:
365         regulator_unregister(ldo->regulator);
366 err:
367         kfree(ldo);
368         return ret;
369 }
370
371 static __devexit int wm831x_gp_ldo_remove(struct platform_device *pdev)
372 {
373         struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
374         struct wm831x *wm831x = ldo->wm831x;
375
376         platform_set_drvdata(pdev, NULL);
377
378         wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), ldo);
379         regulator_unregister(ldo->regulator);
380         kfree(ldo);
381
382         return 0;
383 }
384
385 static struct platform_driver wm831x_gp_ldo_driver = {
386         .probe = wm831x_gp_ldo_probe,
387         .remove = __devexit_p(wm831x_gp_ldo_remove),
388         .driver         = {
389                 .name   = "wm831x-ldo",
390                 .owner  = THIS_MODULE,
391         },
392 };
393
394 /*
395  * Analogue LDOs
396  */
397
398
399 #define WM831X_ALDO_SELECTOR_LOW 0xc
400 #define WM831X_ALDO_MAX_SELECTOR 0x1f
401
402 static int wm831x_aldo_list_voltage(struct regulator_dev *rdev,
403                                       unsigned int selector)
404 {
405         /* 1-1.6V in 50mV steps */
406         if (selector <= WM831X_ALDO_SELECTOR_LOW)
407                 return 1000000 + (selector * 50000);
408         /* 1.7-3.5V in 50mV steps */
409         if (selector <= WM831X_ALDO_MAX_SELECTOR)
410                 return 1600000 + ((selector - WM831X_ALDO_SELECTOR_LOW)
411                                   * 100000);
412         return -EINVAL;
413 }
414
415 static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg,
416                                          int min_uV, int max_uV)
417 {
418         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
419         struct wm831x *wm831x = ldo->wm831x;
420         int vsel, ret;
421
422         if (min_uV < 1000000)
423                 vsel = 0;
424         else if (min_uV < 1700000)
425                 vsel = ((min_uV - 1000000) / 50000);
426         else
427                 vsel = ((min_uV - 1700000) / 100000)
428                         + WM831X_ALDO_SELECTOR_LOW + 1;
429
430         ret = wm831x_aldo_list_voltage(rdev, vsel);
431         if (ret < 0)
432                 return ret;
433         if (ret < min_uV || ret > max_uV)
434                 return -EINVAL;
435
436         return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, vsel);
437 }
438
439 static int wm831x_aldo_set_voltage(struct regulator_dev *rdev,
440                                      int min_uV, int max_uV)
441 {
442         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
443         int reg = ldo->base + WM831X_LDO_ON_CONTROL;
444
445         return wm831x_aldo_set_voltage_int(rdev, reg, min_uV, max_uV);
446 }
447
448 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
449                                              int uV)
450 {
451         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
452         int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
453
454         return wm831x_aldo_set_voltage_int(rdev, reg, uV, uV);
455 }
456
457 static int wm831x_aldo_get_voltage(struct regulator_dev *rdev)
458 {
459         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
460         struct wm831x *wm831x = ldo->wm831x;
461         int reg = ldo->base + WM831X_LDO_ON_CONTROL;
462         int ret;
463
464         ret = wm831x_reg_read(wm831x, reg);
465         if (ret < 0)
466                 return ret;
467
468         ret &= WM831X_LDO7_ON_VSEL_MASK;
469
470         return wm831x_aldo_list_voltage(rdev, ret);
471 }
472
473 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
474 {
475         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
476         struct wm831x *wm831x = ldo->wm831x;
477         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
478         int ret;
479
480         ret = wm831x_reg_read(wm831x, on_reg);
481         if (ret < 0)
482                 return 0;
483
484         if (ret & WM831X_LDO7_ON_MODE)
485                 return REGULATOR_MODE_IDLE;
486         else
487                 return REGULATOR_MODE_NORMAL;
488 }
489
490 static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
491                                   unsigned int mode)
492 {
493         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
494         struct wm831x *wm831x = ldo->wm831x;
495         int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
496         int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
497         int ret;
498
499
500         switch (mode) {
501         case REGULATOR_MODE_NORMAL:
502                 ret = wm831x_set_bits(wm831x, on_reg,
503                                       WM831X_LDO7_ON_MODE, 0);
504                 if (ret < 0)
505                         return ret;
506                 break;
507
508         case REGULATOR_MODE_IDLE:
509                 ret = wm831x_set_bits(wm831x, ctrl_reg,
510                                       WM831X_LDO7_ON_MODE,
511                                       WM831X_LDO7_ON_MODE);
512                 if (ret < 0)
513                         return ret;
514                 break;
515
516         default:
517                 return -EINVAL;
518         }
519
520         return 0;
521 }
522
523 static int wm831x_aldo_get_status(struct regulator_dev *rdev)
524 {
525         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
526         struct wm831x *wm831x = ldo->wm831x;
527         int mask = 1 << rdev_get_id(rdev);
528         int ret;
529
530         /* Is the regulator on? */
531         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
532         if (ret < 0)
533                 return ret;
534         if (!(ret & mask))
535                 return REGULATOR_STATUS_OFF;
536
537         /* Is it reporting under voltage? */
538         ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
539         if (ret & mask)
540                 return REGULATOR_STATUS_ERROR;
541
542         ret = wm831x_aldo_get_mode(rdev);
543         if (ret < 0)
544                 return ret;
545         else
546                 return regulator_mode_to_status(ret);
547 }
548
549 static struct regulator_ops wm831x_aldo_ops = {
550         .list_voltage = wm831x_aldo_list_voltage,
551         .get_voltage = wm831x_aldo_get_voltage,
552         .set_voltage = wm831x_aldo_set_voltage,
553         .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
554         .get_mode = wm831x_aldo_get_mode,
555         .set_mode = wm831x_aldo_set_mode,
556         .get_status = wm831x_aldo_get_status,
557
558         .is_enabled = wm831x_ldo_is_enabled,
559         .enable = wm831x_ldo_enable,
560         .disable = wm831x_ldo_disable,
561 };
562
563 static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
564 {
565         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
566         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
567         int id = pdev->id % ARRAY_SIZE(pdata->ldo);
568         struct wm831x_ldo *ldo;
569         struct resource *res;
570         int ret, irq;
571
572         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
573
574         if (pdata == NULL || pdata->ldo[id] == NULL)
575                 return -ENODEV;
576
577         ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL);
578         if (ldo == NULL) {
579                 dev_err(&pdev->dev, "Unable to allocate private data\n");
580                 return -ENOMEM;
581         }
582
583         ldo->wm831x = wm831x;
584
585         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
586         if (res == NULL) {
587                 dev_err(&pdev->dev, "No I/O resource\n");
588                 ret = -EINVAL;
589                 goto err;
590         }
591         ldo->base = res->start;
592
593         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
594         ldo->desc.name = ldo->name;
595         ldo->desc.id = id;
596         ldo->desc.type = REGULATOR_VOLTAGE;
597         ldo->desc.n_voltages = WM831X_ALDO_MAX_SELECTOR + 1;
598         ldo->desc.ops = &wm831x_aldo_ops;
599         ldo->desc.owner = THIS_MODULE;
600
601         ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
602                                              pdata->ldo[id], ldo);
603         if (IS_ERR(ldo->regulator)) {
604                 ret = PTR_ERR(ldo->regulator);
605                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
606                         id + 1, ret);
607                 goto err;
608         }
609
610         irq = platform_get_irq_byname(pdev, "UV");
611         ret = wm831x_request_irq(wm831x, irq, wm831x_ldo_uv_irq,
612                                  IRQF_TRIGGER_RISING, ldo->name,
613                                  ldo);
614         if (ret != 0) {
615                 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
616                         irq, ret);
617                 goto err_regulator;
618         }
619
620         platform_set_drvdata(pdev, ldo);
621
622         return 0;
623
624 err_regulator:
625         regulator_unregister(ldo->regulator);
626 err:
627         kfree(ldo);
628         return ret;
629 }
630
631 static __devexit int wm831x_aldo_remove(struct platform_device *pdev)
632 {
633         struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
634         struct wm831x *wm831x = ldo->wm831x;
635
636         wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), ldo);
637         regulator_unregister(ldo->regulator);
638         kfree(ldo);
639
640         return 0;
641 }
642
643 static struct platform_driver wm831x_aldo_driver = {
644         .probe = wm831x_aldo_probe,
645         .remove = __devexit_p(wm831x_aldo_remove),
646         .driver         = {
647                 .name   = "wm831x-aldo",
648                 .owner  = THIS_MODULE,
649         },
650 };
651
652 /*
653  * Alive LDO
654  */
655
656 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
657
658 static int wm831x_alive_ldo_list_voltage(struct regulator_dev *rdev,
659                                       unsigned int selector)
660 {
661         /* 0.8-1.55V in 50mV steps */
662         if (selector <= WM831X_ALIVE_LDO_MAX_SELECTOR)
663                 return 800000 + (selector * 50000);
664         return -EINVAL;
665 }
666
667 static int wm831x_alive_ldo_set_voltage_int(struct regulator_dev *rdev,
668                                             int reg,
669                                             int min_uV, int max_uV)
670 {
671         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
672         struct wm831x *wm831x = ldo->wm831x;
673         int vsel, ret;
674
675         vsel = (min_uV - 800000) / 50000;
676
677         ret = wm831x_alive_ldo_list_voltage(rdev, vsel);
678         if (ret < 0)
679                 return ret;
680         if (ret < min_uV || ret > max_uV)
681                 return -EINVAL;
682
683         return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, vsel);
684 }
685
686 static int wm831x_alive_ldo_set_voltage(struct regulator_dev *rdev,
687                                      int min_uV, int max_uV)
688 {
689         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
690         int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
691
692         return wm831x_alive_ldo_set_voltage_int(rdev, reg, min_uV, max_uV);
693 }
694
695 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
696                                              int uV)
697 {
698         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
699         int reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
700
701         return wm831x_alive_ldo_set_voltage_int(rdev, reg, uV, uV);
702 }
703
704 static int wm831x_alive_ldo_get_voltage(struct regulator_dev *rdev)
705 {
706         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
707         struct wm831x *wm831x = ldo->wm831x;
708         int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
709         int ret;
710
711         ret = wm831x_reg_read(wm831x, reg);
712         if (ret < 0)
713                 return ret;
714
715         ret &= WM831X_LDO11_ON_VSEL_MASK;
716
717         return wm831x_alive_ldo_list_voltage(rdev, ret);
718 }
719
720 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
721 {
722         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
723         struct wm831x *wm831x = ldo->wm831x;
724         int mask = 1 << rdev_get_id(rdev);
725         int ret;
726
727         /* Is the regulator on? */
728         ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
729         if (ret < 0)
730                 return ret;
731         if (ret & mask)
732                 return REGULATOR_STATUS_ON;
733         else
734                 return REGULATOR_STATUS_OFF;
735 }
736
737 static struct regulator_ops wm831x_alive_ldo_ops = {
738         .list_voltage = wm831x_alive_ldo_list_voltage,
739         .get_voltage = wm831x_alive_ldo_get_voltage,
740         .set_voltage = wm831x_alive_ldo_set_voltage,
741         .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
742         .get_status = wm831x_alive_ldo_get_status,
743
744         .is_enabled = wm831x_ldo_is_enabled,
745         .enable = wm831x_ldo_enable,
746         .disable = wm831x_ldo_disable,
747 };
748
749 static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
750 {
751         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
752         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
753         int id = pdev->id % ARRAY_SIZE(pdata->ldo);
754         struct wm831x_ldo *ldo;
755         struct resource *res;
756         int ret;
757
758         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
759
760         if (pdata == NULL || pdata->ldo[id] == NULL)
761                 return -ENODEV;
762
763         ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL);
764         if (ldo == NULL) {
765                 dev_err(&pdev->dev, "Unable to allocate private data\n");
766                 return -ENOMEM;
767         }
768
769         ldo->wm831x = wm831x;
770
771         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
772         if (res == NULL) {
773                 dev_err(&pdev->dev, "No I/O resource\n");
774                 ret = -EINVAL;
775                 goto err;
776         }
777         ldo->base = res->start;
778
779         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
780         ldo->desc.name = ldo->name;
781         ldo->desc.id = id;
782         ldo->desc.type = REGULATOR_VOLTAGE;
783         ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
784         ldo->desc.ops = &wm831x_alive_ldo_ops;
785         ldo->desc.owner = THIS_MODULE;
786
787         ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
788                                              pdata->ldo[id], ldo);
789         if (IS_ERR(ldo->regulator)) {
790                 ret = PTR_ERR(ldo->regulator);
791                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
792                         id + 1, ret);
793                 goto err;
794         }
795
796         platform_set_drvdata(pdev, ldo);
797
798         return 0;
799
800 err:
801         kfree(ldo);
802         return ret;
803 }
804
805 static __devexit int wm831x_alive_ldo_remove(struct platform_device *pdev)
806 {
807         struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
808
809         regulator_unregister(ldo->regulator);
810         kfree(ldo);
811
812         return 0;
813 }
814
815 static struct platform_driver wm831x_alive_ldo_driver = {
816         .probe = wm831x_alive_ldo_probe,
817         .remove = __devexit_p(wm831x_alive_ldo_remove),
818         .driver         = {
819                 .name   = "wm831x-alive-ldo",
820                 .owner  = THIS_MODULE,
821         },
822 };
823
824 static int __init wm831x_ldo_init(void)
825 {
826         int ret;
827
828         ret = platform_driver_register(&wm831x_gp_ldo_driver);
829         if (ret != 0)
830                 pr_err("Failed to register WM831x GP LDO driver: %d\n", ret);
831
832         ret = platform_driver_register(&wm831x_aldo_driver);
833         if (ret != 0)
834                 pr_err("Failed to register WM831x ALDO driver: %d\n", ret);
835
836         ret = platform_driver_register(&wm831x_alive_ldo_driver);
837         if (ret != 0)
838                 pr_err("Failed to register WM831x alive LDO driver: %d\n",
839                        ret);
840
841         return 0;
842 }
843 subsys_initcall(wm831x_ldo_init);
844
845 static void __exit wm831x_ldo_exit(void)
846 {
847         platform_driver_unregister(&wm831x_alive_ldo_driver);
848         platform_driver_unregister(&wm831x_aldo_driver);
849         platform_driver_unregister(&wm831x_gp_ldo_driver);
850 }
851 module_exit(wm831x_ldo_exit);
852
853 /* Module information */
854 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
855 MODULE_DESCRIPTION("WM831x LDO driver");
856 MODULE_LICENSE("GPL");
857 MODULE_ALIAS("platform:wm831x-ldo");
858 MODULE_ALIAS("platform:wm831x-aldo");
859 MODULE_ALIAS("platform:wm831x-aliveldo");