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