?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fs/ecryptfs/file.c: introduce missing free
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / regulator / wm831x-ldo.c
blobe686cdb61b97cd8a54ab7fbecb1312a41e333595
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,
219 WM831X_LDO1_LP_MODE);
220 if (ret < 0)
221 return ret;
222
223 ret = wm831x_set_bits(wm831x, on_reg,
224 WM831X_LDO1_ON_MODE,
225 WM831X_LDO1_ON_MODE);
226 if (ret < 0)
227 return ret;
228
229 case REGULATOR_MODE_STANDBY:
230 ret = wm831x_set_bits(wm831x, ctrl_reg,
231 WM831X_LDO1_LP_MODE, 0);
232 if (ret < 0)
233 return ret;
234
235 ret = wm831x_set_bits(wm831x, on_reg,
236 WM831X_LDO1_ON_MODE,
237 WM831X_LDO1_ON_MODE);
238 if (ret < 0)
239 return ret;
240 break;
241
242 default:
243 return -EINVAL;
244 }
245
246 return 0;
247 }
248
249 static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
250 {
251 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
252 struct wm831x *wm831x = ldo->wm831x;
253 int mask = 1 << rdev_get_id(rdev);
254 int ret;
255
256 /* Is the regulator on? */
257 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
258 if (ret < 0)
259 return ret;
260 if (!(ret & mask))
261 return REGULATOR_STATUS_OFF;
262
263 /* Is it reporting under voltage? */
264 ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
265 if (ret & mask)
266 return REGULATOR_STATUS_ERROR;
267
268 ret = wm831x_gp_ldo_get_mode(rdev);
269 if (ret < 0)
270 return ret;
271 else
272 return regulator_mode_to_status(ret);
273 }
274
275 static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
276 int input_uV,
277 int output_uV, int load_uA)
278 {
279 if (load_uA < 20000)
280 return REGULATOR_MODE_STANDBY;
281 if (load_uA < 50000)
282 return REGULATOR_MODE_IDLE;
283 return REGULATOR_MODE_NORMAL;
284 }
285
286
287 static struct regulator_ops wm831x_gp_ldo_ops = {
288 .list_voltage = wm831x_gp_ldo_list_voltage,
289 .get_voltage = wm831x_gp_ldo_get_voltage,
290 .set_voltage = wm831x_gp_ldo_set_voltage,
291 .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
292 .get_mode = wm831x_gp_ldo_get_mode,
293 .set_mode = wm831x_gp_ldo_set_mode,
294 .get_status = wm831x_gp_ldo_get_status,
295 .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
296
297 .is_enabled = wm831x_ldo_is_enabled,
298 .enable = wm831x_ldo_enable,
299 .disable = wm831x_ldo_disable,
300 };
301
302 static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev)
303 {
304 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
305 struct wm831x_pdata *pdata = wm831x->dev->platform_data;
306 int id = pdev->id % ARRAY_SIZE(pdata->ldo);
307 struct wm831x_ldo *ldo;
308 struct resource *res;
309 int ret, irq;
310
311 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
312
313 if (pdata == NULL || pdata->ldo[id] == NULL)
314 return -ENODEV;
315
316 ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL);
317 if (ldo == NULL) {
318 dev_err(&pdev->dev, "Unable to allocate private data\n");
319 return -ENOMEM;
320 }
321
322 ldo->wm831x = wm831x;
323
324 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
325 if (res == NULL) {
326 dev_err(&pdev->dev, "No I/O resource\n");
327 ret = -EINVAL;
328 goto err;
329 }
330 ldo->base = res->start;
331
332 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
333 ldo->desc.name = ldo->name;
334 ldo->desc.id = id;
335 ldo->desc.type = REGULATOR_VOLTAGE;
336 ldo->desc.n_voltages = WM831X_GP_LDO_MAX_SELECTOR + 1;
337 ldo->desc.ops = &wm831x_gp_ldo_ops;
338 ldo->desc.owner = THIS_MODULE;
339
340 ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
341 pdata->ldo[id], ldo);
342 if (IS_ERR(ldo->regulator)) {
343 ret = PTR_ERR(ldo->regulator);
344 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
345 id + 1, ret);
346 goto err;
347 }
348
349 irq = platform_get_irq_byname(pdev, "UV");
350 ret = wm831x_request_irq(wm831x, irq, wm831x_ldo_uv_irq,
351 IRQF_TRIGGER_RISING, ldo->name,
352 ldo);
353 if (ret != 0) {
354 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
355 irq, ret);
356 goto err_regulator;
357 }
358
359 platform_set_drvdata(pdev, ldo);
360
361 return 0;
362
363 err_regulator:
364 regulator_unregister(ldo->regulator);
365 err:
366 kfree(ldo);
367 return ret;
368 }
369
370 static __devexit int wm831x_gp_ldo_remove(struct platform_device *pdev)
371 {
372 struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
373 struct wm831x *wm831x = ldo->wm831x;
374
375 platform_set_drvdata(pdev, NULL);
376
377 wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), ldo);
378 regulator_unregister(ldo->regulator);
379 kfree(ldo);
380
381 return 0;
382 }
383
384 static struct platform_driver wm831x_gp_ldo_driver = {
385 .probe = wm831x_gp_ldo_probe,
386 .remove = __devexit_p(wm831x_gp_ldo_remove),
387 .driver = {
388 .name = "wm831x-ldo",
389 .owner = THIS_MODULE,
390 },
391 };
392
393 /*
394 * Analogue LDOs
395 */
396
397
398 #define WM831X_ALDO_SELECTOR_LOW 0xc
399 #define WM831X_ALDO_MAX_SELECTOR 0x1f
400
401 static int wm831x_aldo_list_voltage(struct regulator_dev *rdev,
402 unsigned int selector)
403 {
404 /* 1-1.6V in 50mV steps */
405 if (selector <= WM831X_ALDO_SELECTOR_LOW)
406 return 1000000 + (selector * 50000);
407 /* 1.7-3.5V in 50mV steps */
408 if (selector <= WM831X_ALDO_MAX_SELECTOR)
409 return 1600000 + ((selector - WM831X_ALDO_SELECTOR_LOW)
410 * 100000);
411 return -EINVAL;
412 }
413
414 static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg,
415 int min_uV, int max_uV)
416 {
417 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
418 struct wm831x *wm831x = ldo->wm831x;
419 int vsel, ret;
420
421 if (min_uV < 1000000)
422 vsel = 0;
423 else if (min_uV < 1700000)
424 vsel = ((min_uV - 1000000) / 50000);
425 else
426 vsel = ((min_uV - 1700000) / 100000)
427 + WM831X_ALDO_SELECTOR_LOW + 1;
428
429 ret = wm831x_aldo_list_voltage(rdev, vsel);
430 if (ret < 0)
431 return ret;
432 if (ret < min_uV || ret > max_uV)
433 return -EINVAL;
434
435 return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, vsel);
436 }
437
438 static int wm831x_aldo_set_voltage(struct regulator_dev *rdev,
439 int min_uV, int max_uV)
440 {
441 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
442 int reg = ldo->base + WM831X_LDO_ON_CONTROL;
443
444 return wm831x_aldo_set_voltage_int(rdev, reg, min_uV, max_uV);
445 }
446
447 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
448 int uV)
449 {
450 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
451 int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
452
453 return wm831x_aldo_set_voltage_int(rdev, reg, uV, uV);
454 }
455
456 static int wm831x_aldo_get_voltage(struct regulator_dev *rdev)
457 {
458 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
459 struct wm831x *wm831x = ldo->wm831x;
460 int reg = ldo->base + WM831X_LDO_ON_CONTROL;
461 int ret;
462
463 ret = wm831x_reg_read(wm831x, reg);
464 if (ret < 0)
465 return ret;
466
467 ret &= WM831X_LDO7_ON_VSEL_MASK;
468
469 return wm831x_aldo_list_voltage(rdev, ret);
470 }
471
472 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
473 {
474 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
475 struct wm831x *wm831x = ldo->wm831x;
476 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
477 int ret;
478
479 ret = wm831x_reg_read(wm831x, on_reg);
480 if (ret < 0)
481 return 0;
482
483 if (ret & WM831X_LDO7_ON_MODE)
484 return REGULATOR_MODE_IDLE;
485 else
486 return REGULATOR_MODE_NORMAL;
487 }
488
489 static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
490 unsigned int mode)
491 {
492 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
493 struct wm831x *wm831x = ldo->wm831x;
494 int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
495 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
496 int ret;
497
498
499 switch (mode) {
500 case REGULATOR_MODE_NORMAL:
501 ret = wm831x_set_bits(wm831x, on_reg,
502 WM831X_LDO7_ON_MODE, 0);
503 if (ret < 0)
504 return ret;
505 break;
506
507 case REGULATOR_MODE_IDLE:
508 ret = wm831x_set_bits(wm831x, ctrl_reg,
509 WM831X_LDO7_ON_MODE,
510 WM831X_LDO7_ON_MODE);
511 if (ret < 0)
512 return ret;
513 break;
514
515 default:
516 return -EINVAL;
517 }
518
519 return 0;
520 }
521
522 static int wm831x_aldo_get_status(struct regulator_dev *rdev)
523 {
524 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
525 struct wm831x *wm831x = ldo->wm831x;
526 int mask = 1 << rdev_get_id(rdev);
527 int ret;
528
529 /* Is the regulator on? */
530 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
531 if (ret < 0)
532 return ret;
533 if (!(ret & mask))
534 return REGULATOR_STATUS_OFF;
535
536 /* Is it reporting under voltage? */
537 ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
538 if (ret & mask)
539 return REGULATOR_STATUS_ERROR;
540
541 ret = wm831x_aldo_get_mode(rdev);
542 if (ret < 0)
543 return ret;
544 else
545 return regulator_mode_to_status(ret);
546 }
547
548 static struct regulator_ops wm831x_aldo_ops = {
549 .list_voltage = wm831x_aldo_list_voltage,
550 .get_voltage = wm831x_aldo_get_voltage,
551 .set_voltage = wm831x_aldo_set_voltage,
552 .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
553 .get_mode = wm831x_aldo_get_mode,
554 .set_mode = wm831x_aldo_set_mode,
555 .get_status = wm831x_aldo_get_status,
556
557 .is_enabled = wm831x_ldo_is_enabled,
558 .enable = wm831x_ldo_enable,
559 .disable = wm831x_ldo_disable,
560 };
561
562 static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
563 {
564 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
565 struct wm831x_pdata *pdata = wm831x->dev->platform_data;
566 int id = pdev->id % ARRAY_SIZE(pdata->ldo);
567 struct wm831x_ldo *ldo;
568 struct resource *res;
569 int ret, irq;
570
571 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
572
573 if (pdata == NULL || pdata->ldo[id] == NULL)
574 return -ENODEV;
575
576 ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL);
577 if (ldo == NULL) {
578 dev_err(&pdev->dev, "Unable to allocate private data\n");
579 return -ENOMEM;
580 }
581
582 ldo->wm831x = wm831x;
583
584 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
585 if (res == NULL) {
586 dev_err(&pdev->dev, "No I/O resource\n");
587 ret = -EINVAL;
588 goto err;
589 }
590 ldo->base = res->start;
591
592 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
593 ldo->desc.name = ldo->name;
594 ldo->desc.id = id;
595 ldo->desc.type = REGULATOR_VOLTAGE;
596 ldo->desc.n_voltages = WM831X_ALDO_MAX_SELECTOR + 1;
597 ldo->desc.ops = &wm831x_aldo_ops;
598 ldo->desc.owner = THIS_MODULE;
599
600 ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
601 pdata->ldo[id], ldo);
602 if (IS_ERR(ldo->regulator)) {
603 ret = PTR_ERR(ldo->regulator);
604 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
605 id + 1, ret);
606 goto err;
607 }
608
609 irq = platform_get_irq_byname(pdev, "UV");
610 ret = wm831x_request_irq(wm831x, irq, wm831x_ldo_uv_irq,
611 IRQF_TRIGGER_RISING, ldo->name,
612 ldo);
613 if (ret != 0) {
614 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
615 irq, ret);
616 goto err_regulator;
617 }
618
619 platform_set_drvdata(pdev, ldo);
620
621 return 0;
622
623 err_regulator:
624 regulator_unregister(ldo->regulator);
625 err:
626 kfree(ldo);
627 return ret;
628 }
629
630 static __devexit int wm831x_aldo_remove(struct platform_device *pdev)
631 {
632 struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
633 struct wm831x *wm831x = ldo->wm831x;
634
635 wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), ldo);
636 regulator_unregister(ldo->regulator);
637 kfree(ldo);
638
639 return 0;
640 }
641
642 static struct platform_driver wm831x_aldo_driver = {
643 .probe = wm831x_aldo_probe,
644 .remove = __devexit_p(wm831x_aldo_remove),
645 .driver = {
646 .name = "wm831x-aldo",
647 .owner = THIS_MODULE,
648 },
649 };
650
651 /*
652 * Alive LDO
653 */
654
655 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
656
657 static int wm831x_alive_ldo_list_voltage(struct regulator_dev *rdev,
658 unsigned int selector)
659 {
660 /* 0.8-1.55V in 50mV steps */
661 if (selector <= WM831X_ALIVE_LDO_MAX_SELECTOR)
662 return 800000 + (selector * 50000);
663 return -EINVAL;
664 }
665
666 static int wm831x_alive_ldo_set_voltage_int(struct regulator_dev *rdev,
667 int reg,
668 int min_uV, int max_uV)
669 {
670 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
671 struct wm831x *wm831x = ldo->wm831x;
672 int vsel, ret;
673
674 vsel = (min_uV - 800000) / 50000;
675
676 ret = wm831x_alive_ldo_list_voltage(rdev, vsel);
677 if (ret < 0)
678 return ret;
679 if (ret < min_uV || ret > max_uV)
680 return -EINVAL;
681
682 return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, vsel);
683 }
684
685 static int wm831x_alive_ldo_set_voltage(struct regulator_dev *rdev,
686 int min_uV, int max_uV)
687 {
688 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
689 int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
690
691 return wm831x_alive_ldo_set_voltage_int(rdev, reg, min_uV, max_uV);
692 }
693
694 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
695 int uV)
696 {
697 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
698 int reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
699
700 return wm831x_alive_ldo_set_voltage_int(rdev, reg, uV, uV);
701 }
702
703 static int wm831x_alive_ldo_get_voltage(struct regulator_dev *rdev)
704 {
705 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
706 struct wm831x *wm831x = ldo->wm831x;
707 int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
708 int ret;
709
710 ret = wm831x_reg_read(wm831x, reg);
711 if (ret < 0)
712 return ret;
713
714 ret &= WM831X_LDO11_ON_VSEL_MASK;
715
716 return wm831x_alive_ldo_list_voltage(rdev, ret);
717 }
718
719 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
720 {
721 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
722 struct wm831x *wm831x = ldo->wm831x;
723 int mask = 1 << rdev_get_id(rdev);
724 int ret;
725
726 /* Is the regulator on? */
727 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
728 if (ret < 0)
729 return ret;
730 if (ret & mask)
731 return REGULATOR_STATUS_ON;
732 else
733 return REGULATOR_STATUS_OFF;
734 }
735
736 static struct regulator_ops wm831x_alive_ldo_ops = {
737 .list_voltage = wm831x_alive_ldo_list_voltage,
738 .get_voltage = wm831x_alive_ldo_get_voltage,
739 .set_voltage = wm831x_alive_ldo_set_voltage,
740 .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
741 .get_status = wm831x_alive_ldo_get_status,
742
743 .is_enabled = wm831x_ldo_is_enabled,
744 .enable = wm831x_ldo_enable,
745 .disable = wm831x_ldo_disable,
746 };
747
748 static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
749 {
750 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
751 struct wm831x_pdata *pdata = wm831x->dev->platform_data;
752 int id = pdev->id % ARRAY_SIZE(pdata->ldo);
753 struct wm831x_ldo *ldo;
754 struct resource *res;
755 int ret;
756
757 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
758
759 if (pdata == NULL || pdata->ldo[id] == NULL)
760 return -ENODEV;
761
762 ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL);
763 if (ldo == NULL) {
764 dev_err(&pdev->dev, "Unable to allocate private data\n");
765 return -ENOMEM;
766 }
767
768 ldo->wm831x = wm831x;
769
770 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
771 if (res == NULL) {
772 dev_err(&pdev->dev, "No I/O resource\n");
773 ret = -EINVAL;
774 goto err;
775 }
776 ldo->base = res->start;
777
778 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
779 ldo->desc.name = ldo->name;
780 ldo->desc.id = id;
781 ldo->desc.type = REGULATOR_VOLTAGE;
782 ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
783 ldo->desc.ops = &wm831x_alive_ldo_ops;
784 ldo->desc.owner = THIS_MODULE;
785
786 ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
787 pdata->ldo[id], ldo);
788 if (IS_ERR(ldo->regulator)) {
789 ret = PTR_ERR(ldo->regulator);
790 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
791 id + 1, ret);
792 goto err;
793 }
794
795 platform_set_drvdata(pdev, ldo);
796
797 return 0;
798
799 err:
800 kfree(ldo);
801 return ret;
802 }
803
804 static __devexit int wm831x_alive_ldo_remove(struct platform_device *pdev)
805 {
806 struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
807
808 regulator_unregister(ldo->regulator);
809 kfree(ldo);
810
811 return 0;
812 }
813
814 static struct platform_driver wm831x_alive_ldo_driver = {
815 .probe = wm831x_alive_ldo_probe,
816 .remove = __devexit_p(wm831x_alive_ldo_remove),
817 .driver = {
818 .name = "wm831x-alive-ldo",
819 .owner = THIS_MODULE,
820 },
821 };
822
823 static int __init wm831x_ldo_init(void)
824 {
825 int ret;
826
827 ret = platform_driver_register(&wm831x_gp_ldo_driver);
828 if (ret != 0)
829 pr_err("Failed to register WM831x GP LDO driver: %d\n", ret);
830
831 ret = platform_driver_register(&wm831x_aldo_driver);
832 if (ret != 0)
833 pr_err("Failed to register WM831x ALDO driver: %d\n", ret);
834
835 ret = platform_driver_register(&wm831x_alive_ldo_driver);
836 if (ret != 0)
837 pr_err("Failed to register WM831x alive LDO driver: %d\n",
838 ret);
839
840 return 0;
841 }
842 subsys_initcall(wm831x_ldo_init);
843
844 static void __exit wm831x_ldo_exit(void)
845 {
846 platform_driver_unregister(&wm831x_alive_ldo_driver);
847 platform_driver_unregister(&wm831x_aldo_driver);
848 platform_driver_unregister(&wm831x_gp_ldo_driver);
849 }
850 module_exit(wm831x_ldo_exit);
851
852 /* Module information */
853 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
854 MODULE_DESCRIPTION("WM831x LDO driver");
855 MODULE_LICENSE("GPL");
856 MODULE_ALIAS("platform:wm831x-ldo");
857 MODULE_ALIAS("platform:wm831x-aldo");
858 MODULE_ALIAS("platform:wm831x-aliveldo");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree