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