regulator: tps65912: Remove unused define of TPS65912_MAX_REG_ID
[linux-2.6.git] / drivers / regulator / tps65912-regulator.c
1 /*
2  * tps65912.c  --  TI tps65912
3  *
4  * Copyright 2011 Texas Instruments Inc.
5  *
6  * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
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  * This driver is based on wm8350 implementation.
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/err.h>
20 #include <linux/platform_device.h>
21 #include <linux/regulator/driver.h>
22 #include <linux/regulator/machine.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/gpio.h>
26 #include <linux/mfd/tps65912.h>
27
28 /* DCDC's */
29 #define TPS65912_REG_DCDC1      0
30 #define TPS65912_REG_DCDC2      1
31 #define TPS65912_REG_DCDC3      2
32 #define TPS65912_REG_DCDC4      3
33
34 /* LDOs */
35 #define TPS65912_REG_LDO1       4
36 #define TPS65912_REG_LDO2       5
37 #define TPS65912_REG_LDO3       6
38 #define TPS65912_REG_LDO4       7
39 #define TPS65912_REG_LDO5       8
40 #define TPS65912_REG_LDO6       9
41 #define TPS65912_REG_LDO7       10
42 #define TPS65912_REG_LDO8       11
43 #define TPS65912_REG_LDO9       12
44 #define TPS65912_REG_LDO10      13
45
46 /* Number of step-down converters available */
47 #define TPS65912_NUM_DCDC       4
48
49 /* Number of LDO voltage regulators  available */
50 #define TPS65912_NUM_LDO        10
51
52 /* Number of total regulators available */
53 #define TPS65912_NUM_REGULATOR          (TPS65912_NUM_DCDC + TPS65912_NUM_LDO)
54
55 #define TPS65912_REG_ENABLED    0x80
56 #define OP_SELREG_MASK          0x40
57 #define OP_SELREG_SHIFT         6
58
59 struct tps_info {
60         const char *name;
61 };
62
63 static struct tps_info tps65912_regs[] = {
64         {
65                 .name = "DCDC1",
66         },
67         {
68                 .name = "DCDC2",
69         },
70         {
71                 .name = "DCDC3",
72         },
73         {
74                 .name = "DCDC4",
75         },
76         {
77                 .name = "LDO1",
78         },
79         {
80                 .name = "LDO2",
81         },
82         {
83                 .name = "LDO3",
84         },
85         {
86                 .name = "LDO4",
87         },
88         {
89                 .name = "LDO5",
90         },
91         {
92                 .name = "LDO6",
93         },
94         {
95                 .name = "LDO7",
96         },
97         {
98                 .name = "LDO8",
99         },
100         {
101                 .name = "LDO9",
102         },
103         {
104                 .name = "LDO10",
105         },
106 };
107
108 struct tps65912_reg {
109         struct regulator_desc desc[TPS65912_NUM_REGULATOR];
110         struct tps65912 *mfd;
111         struct regulator_dev *rdev[TPS65912_NUM_REGULATOR];
112         struct tps_info *info[TPS65912_NUM_REGULATOR];
113         /* for read/write access */
114         struct mutex io_lock;
115         int mode;
116         int (*get_ctrl_reg)(int);
117         int dcdc1_range;
118         int dcdc2_range;
119         int dcdc3_range;
120         int dcdc4_range;
121         int pwm_mode_reg;
122         int eco_reg;
123 };
124
125 static int tps65912_get_range(struct tps65912_reg *pmic, int id)
126 {
127         struct tps65912 *mfd = pmic->mfd;
128
129         if (id > TPS65912_REG_DCDC4)
130                 return 0;
131
132         switch (id) {
133         case TPS65912_REG_DCDC1:
134                 pmic->dcdc1_range = tps65912_reg_read(mfd,
135                                                         TPS65912_DCDC1_LIMIT);
136                 if (pmic->dcdc1_range < 0)
137                         return pmic->dcdc1_range;
138                 pmic->dcdc1_range = (pmic->dcdc1_range &
139                         DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
140                 return pmic->dcdc1_range;
141         case TPS65912_REG_DCDC2:
142                 pmic->dcdc2_range = tps65912_reg_read(mfd,
143                                                         TPS65912_DCDC2_LIMIT);
144                 if (pmic->dcdc2_range < 0)
145                         return pmic->dcdc2_range;
146                 pmic->dcdc2_range = (pmic->dcdc2_range &
147                         DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
148                 return pmic->dcdc2_range;
149         case TPS65912_REG_DCDC3:
150                 pmic->dcdc3_range = tps65912_reg_read(mfd,
151                                                         TPS65912_DCDC3_LIMIT);
152                 if (pmic->dcdc3_range < 0)
153                         return pmic->dcdc3_range;
154                 pmic->dcdc3_range = (pmic->dcdc3_range &
155                         DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
156                 return pmic->dcdc3_range;
157         case TPS65912_REG_DCDC4:
158                 pmic->dcdc4_range = tps65912_reg_read(mfd,
159                                                         TPS65912_DCDC4_LIMIT);
160                 if (pmic->dcdc4_range < 0)
161                         return pmic->dcdc4_range;
162                 pmic->dcdc4_range = (pmic->dcdc4_range &
163                         DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
164                 return pmic->dcdc4_range;
165         default:
166                 return 0;
167         }
168 }
169
170 static unsigned long tps65912_vsel_to_uv_range0(u8 vsel)
171 {
172         unsigned long uv;
173
174         uv = ((vsel * 12500) + 500000);
175         return uv;
176 }
177
178 static unsigned long tps65912_vsel_to_uv_range1(u8 vsel)
179 {
180         unsigned long uv;
181
182          uv = ((vsel * 12500) + 700000);
183         return uv;
184 }
185
186 static unsigned long tps65912_vsel_to_uv_range2(u8 vsel)
187 {
188         unsigned long uv;
189
190         uv = ((vsel * 25000) + 500000);
191         return uv;
192 }
193
194 static unsigned long tps65912_vsel_to_uv_range3(u8 vsel)
195 {
196         unsigned long uv;
197
198         if (vsel == 0x3f)
199                 uv = 3800000;
200         else
201                 uv = ((vsel * 50000) + 500000);
202
203         return uv;
204 }
205
206 static unsigned long tps65912_vsel_to_uv_ldo(u8 vsel)
207 {
208         unsigned long uv = 0;
209
210         if (vsel <= 32)
211                 uv = ((vsel * 25000) + 800000);
212         else if (vsel > 32 && vsel <= 60)
213                 uv = (((vsel - 32) * 50000) + 1600000);
214         else if (vsel > 60)
215                 uv = (((vsel - 60) * 100000) + 3000000);
216
217         return uv;
218 }
219
220 static int tps65912_get_ctrl_register(int id)
221 {
222         switch (id) {
223         case TPS65912_REG_DCDC1:
224                 return TPS65912_DCDC1_AVS;
225         case TPS65912_REG_DCDC2:
226                 return TPS65912_DCDC2_AVS;
227         case TPS65912_REG_DCDC3:
228                 return TPS65912_DCDC3_AVS;
229         case TPS65912_REG_DCDC4:
230                 return TPS65912_DCDC4_AVS;
231         case TPS65912_REG_LDO1:
232                 return TPS65912_LDO1_AVS;
233         case TPS65912_REG_LDO2:
234                 return TPS65912_LDO2_AVS;
235         case TPS65912_REG_LDO3:
236                 return TPS65912_LDO3_AVS;
237         case TPS65912_REG_LDO4:
238                 return TPS65912_LDO4_AVS;
239         case TPS65912_REG_LDO5:
240                 return TPS65912_LDO5;
241         case TPS65912_REG_LDO6:
242                 return TPS65912_LDO6;
243         case TPS65912_REG_LDO7:
244                 return TPS65912_LDO7;
245         case TPS65912_REG_LDO8:
246                 return TPS65912_LDO8;
247         case TPS65912_REG_LDO9:
248                 return TPS65912_LDO9;
249         case TPS65912_REG_LDO10:
250                 return TPS65912_LDO10;
251         default:
252                 return -EINVAL;
253         }
254 }
255
256 static int tps65912_get_dcdc_sel_register(struct tps65912_reg *pmic, int id)
257 {
258         struct tps65912 *mfd = pmic->mfd;
259         int opvsel = 0, sr = 0;
260         u8 reg = 0;
261
262         if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_DCDC4)
263                 return -EINVAL;
264
265         switch (id) {
266         case TPS65912_REG_DCDC1:
267                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC1_OP);
268                 sr = ((opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT);
269                 if (sr)
270                         reg = TPS65912_DCDC1_AVS;
271                 else
272                         reg = TPS65912_DCDC1_OP;
273                 break;
274         case TPS65912_REG_DCDC2:
275                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC2_OP);
276                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
277                 if (sr)
278                         reg = TPS65912_DCDC2_AVS;
279                 else
280                         reg = TPS65912_DCDC2_OP;
281                 break;
282         case TPS65912_REG_DCDC3:
283                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC3_OP);
284                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
285                 if (sr)
286                         reg = TPS65912_DCDC3_AVS;
287                 else
288                         reg = TPS65912_DCDC3_OP;
289                 break;
290         case TPS65912_REG_DCDC4:
291                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC4_OP);
292                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
293                 if (sr)
294                         reg = TPS65912_DCDC4_AVS;
295                 else
296                         reg = TPS65912_DCDC4_OP;
297                 break;
298         }
299         return reg;
300 }
301
302 static int tps65912_get_ldo_sel_register(struct tps65912_reg *pmic, int id)
303 {
304         struct tps65912 *mfd = pmic->mfd;
305         int opvsel = 0, sr = 0;
306         u8 reg = 0;
307
308         if (id < TPS65912_REG_LDO1 || id > TPS65912_REG_LDO10)
309                 return -EINVAL;
310
311         switch (id) {
312         case TPS65912_REG_LDO1:
313                 opvsel = tps65912_reg_read(mfd, TPS65912_LDO1_OP);
314                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
315                 if (sr)
316                         reg = TPS65912_LDO1_AVS;
317                 else
318                         reg = TPS65912_LDO1_OP;
319                 break;
320         case TPS65912_REG_LDO2:
321                 opvsel = tps65912_reg_read(mfd, TPS65912_LDO2_OP);
322                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
323                 if (sr)
324                         reg = TPS65912_LDO2_AVS;
325                 else
326                         reg = TPS65912_LDO2_OP;
327                 break;
328         case TPS65912_REG_LDO3:
329                 opvsel = tps65912_reg_read(mfd, TPS65912_LDO3_OP);
330                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
331                 if (sr)
332                         reg = TPS65912_LDO3_AVS;
333                 else
334                         reg = TPS65912_LDO3_OP;
335                 break;
336         case TPS65912_REG_LDO4:
337                 opvsel = tps65912_reg_read(mfd, TPS65912_LDO4_OP);
338                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
339                 if (sr)
340                         reg = TPS65912_LDO4_AVS;
341                 else
342                         reg = TPS65912_LDO4_OP;
343                 break;
344         case TPS65912_REG_LDO5:
345                 reg = TPS65912_LDO5;
346                 break;
347         case TPS65912_REG_LDO6:
348                 reg = TPS65912_LDO6;
349                 break;
350         case TPS65912_REG_LDO7:
351                 reg = TPS65912_LDO7;
352                 break;
353         case TPS65912_REG_LDO8:
354                 reg = TPS65912_LDO8;
355                 break;
356         case TPS65912_REG_LDO9:
357                 reg = TPS65912_LDO9;
358                 break;
359         case TPS65912_REG_LDO10:
360                 reg = TPS65912_LDO10;
361                 break;
362         }
363
364         return reg;
365 }
366
367 static int tps65912_get_mode_regiters(struct tps65912_reg *pmic, int id)
368 {
369         switch (id) {
370         case TPS65912_REG_DCDC1:
371                 pmic->pwm_mode_reg = TPS65912_DCDC1_CTRL;
372                 pmic->eco_reg = TPS65912_DCDC1_AVS;
373                 break;
374         case TPS65912_REG_DCDC2:
375                 pmic->pwm_mode_reg = TPS65912_DCDC2_CTRL;
376                 pmic->eco_reg = TPS65912_DCDC2_AVS;
377                 break;
378         case TPS65912_REG_DCDC3:
379                 pmic->pwm_mode_reg = TPS65912_DCDC3_CTRL;
380                 pmic->eco_reg = TPS65912_DCDC3_AVS;
381                 break;
382         case TPS65912_REG_DCDC4:
383                 pmic->pwm_mode_reg = TPS65912_DCDC4_CTRL;
384                 pmic->eco_reg = TPS65912_DCDC4_AVS;
385                 break;
386         default:
387                 return -EINVAL;
388         }
389
390         return 0;
391 }
392
393 static int tps65912_reg_is_enabled(struct regulator_dev *dev)
394 {
395         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
396         struct tps65912 *mfd = pmic->mfd;
397         int reg, value, id = rdev_get_id(dev);
398
399         if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
400                 return -EINVAL;
401
402         reg = pmic->get_ctrl_reg(id);
403         if (reg < 0)
404                 return reg;
405
406         value = tps65912_reg_read(mfd, reg);
407         if (value < 0)
408                 return value;
409
410         return value & TPS65912_REG_ENABLED;
411 }
412
413 static int tps65912_reg_enable(struct regulator_dev *dev)
414 {
415         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
416         struct tps65912 *mfd = pmic->mfd;
417         int id = rdev_get_id(dev);
418         int reg;
419
420         if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
421                 return -EINVAL;
422
423         reg = pmic->get_ctrl_reg(id);
424         if (reg < 0)
425                 return reg;
426
427         return tps65912_set_bits(mfd, reg, TPS65912_REG_ENABLED);
428 }
429
430 static int tps65912_reg_disable(struct regulator_dev *dev)
431 {
432         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
433         struct tps65912 *mfd = pmic->mfd;
434         int id = rdev_get_id(dev), reg;
435
436         reg = pmic->get_ctrl_reg(id);
437         if (reg < 0)
438                 return reg;
439
440         return tps65912_clear_bits(mfd, reg, TPS65912_REG_ENABLED);
441 }
442
443 static int tps65912_set_mode(struct regulator_dev *dev, unsigned int mode)
444 {
445         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
446         struct tps65912 *mfd = pmic->mfd;
447         int pwm_mode, eco, id = rdev_get_id(dev);
448
449         tps65912_get_mode_regiters(pmic, id);
450
451         pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
452         eco = tps65912_reg_read(mfd, pmic->eco_reg);
453
454         pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
455         eco &= DCDC_AVS_ECO_MASK;
456
457         switch (mode) {
458         case REGULATOR_MODE_FAST:
459                 /* Verify if mode alredy set */
460                 if (pwm_mode && !eco)
461                         break;
462                 tps65912_set_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
463                 tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
464                 break;
465         case REGULATOR_MODE_NORMAL:
466         case REGULATOR_MODE_IDLE:
467                 if (!pwm_mode && !eco)
468                         break;
469                 tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
470                 tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
471                 break;
472         case REGULATOR_MODE_STANDBY:
473                 if (!pwm_mode && eco)
474                         break;
475                 tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
476                 tps65912_set_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
477                 break;
478         default:
479                 return -EINVAL;
480         }
481
482         return 0;
483 }
484
485 static unsigned int tps65912_get_mode(struct regulator_dev *dev)
486 {
487         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
488         struct tps65912 *mfd = pmic->mfd;
489         int pwm_mode, eco, mode = 0, id = rdev_get_id(dev);
490
491         tps65912_get_mode_regiters(pmic, id);
492
493         pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
494         eco = tps65912_reg_read(mfd, pmic->eco_reg);
495
496         pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
497         eco &= DCDC_AVS_ECO_MASK;
498
499         if (pwm_mode && !eco)
500                 mode = REGULATOR_MODE_FAST;
501         else if (!pwm_mode && !eco)
502                 mode = REGULATOR_MODE_NORMAL;
503         else if (!pwm_mode && eco)
504                 mode = REGULATOR_MODE_STANDBY;
505
506         return mode;
507 }
508
509 static int tps65912_get_voltage_dcdc(struct regulator_dev *dev)
510 {
511         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
512         struct tps65912 *mfd = pmic->mfd;
513         int id = rdev_get_id(dev), voltage = 0, range;
514         int opvsel = 0, avsel = 0, sr, vsel;
515
516         switch (id) {
517         case TPS65912_REG_DCDC1:
518                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC1_OP);
519                 avsel = tps65912_reg_read(mfd, TPS65912_DCDC1_AVS);
520                 range = pmic->dcdc1_range;
521                 break;
522         case TPS65912_REG_DCDC2:
523                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC2_OP);
524                 avsel = tps65912_reg_read(mfd, TPS65912_DCDC2_AVS);
525                 range = pmic->dcdc2_range;
526                 break;
527         case TPS65912_REG_DCDC3:
528                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC3_OP);
529                 avsel = tps65912_reg_read(mfd, TPS65912_DCDC3_AVS);
530                 range = pmic->dcdc3_range;
531                 break;
532         case TPS65912_REG_DCDC4:
533                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC4_OP);
534                 avsel = tps65912_reg_read(mfd, TPS65912_DCDC4_AVS);
535                 range = pmic->dcdc4_range;
536                 break;
537         default:
538                 return -EINVAL;
539         }
540
541         sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
542         if (sr)
543                 vsel = avsel;
544         else
545                 vsel = opvsel;
546         vsel &= 0x3F;
547
548         switch (range) {
549         case 0:
550                 /* 0.5 - 1.2875V in 12.5mV steps */
551                 voltage = tps65912_vsel_to_uv_range0(vsel);
552                 break;
553         case 1:
554                 /* 0.7 - 1.4875V in 12.5mV steps */
555                 voltage = tps65912_vsel_to_uv_range1(vsel);
556                 break;
557         case 2:
558                 /* 0.5 - 2.075V in 25mV steps */
559                 voltage = tps65912_vsel_to_uv_range2(vsel);
560                 break;
561         case 3:
562                 /* 0.5 - 3.8V in 50mV steps */
563                 voltage = tps65912_vsel_to_uv_range3(vsel);
564                 break;
565         }
566         return voltage;
567 }
568
569 static int tps65912_set_voltage_dcdc(struct regulator_dev *dev,
570                                                 unsigned selector)
571 {
572         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
573         struct tps65912 *mfd = pmic->mfd;
574         int id = rdev_get_id(dev);
575         int value;
576         u8 reg;
577
578         reg = tps65912_get_dcdc_sel_register(pmic, id);
579         value = tps65912_reg_read(mfd, reg);
580         value &= 0xC0;
581         return tps65912_reg_write(mfd, reg, selector | value);
582 }
583
584 static int tps65912_get_voltage_ldo(struct regulator_dev *dev)
585 {
586         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
587         struct tps65912 *mfd = pmic->mfd;
588         int id = rdev_get_id(dev);
589         int vsel = 0;
590         u8 reg;
591
592         reg = tps65912_get_ldo_sel_register(pmic, id);
593         vsel = tps65912_reg_read(mfd, reg);
594         vsel &= 0x3F;
595
596         return tps65912_vsel_to_uv_ldo(vsel);
597 }
598
599 static int tps65912_set_voltage_ldo(struct regulator_dev *dev,
600                                                 unsigned selector)
601 {
602         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
603         struct tps65912 *mfd = pmic->mfd;
604         int id = rdev_get_id(dev), reg, value;
605
606         reg = tps65912_get_ldo_sel_register(pmic, id);
607         value = tps65912_reg_read(mfd, reg);
608         value &= 0xC0;
609         return tps65912_reg_write(mfd, reg, selector | value);
610 }
611
612 static int tps65912_list_voltage_dcdc(struct regulator_dev *dev,
613                                         unsigned selector)
614 {
615         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
616         int range, voltage = 0, id = rdev_get_id(dev);
617
618         switch (id) {
619         case TPS65912_REG_DCDC1:
620                 range = pmic->dcdc1_range;
621                 break;
622         case TPS65912_REG_DCDC2:
623                 range = pmic->dcdc2_range;
624                 break;
625         case TPS65912_REG_DCDC3:
626                 range = pmic->dcdc3_range;
627                 break;
628         case TPS65912_REG_DCDC4:
629                 range = pmic->dcdc4_range;
630                 break;
631         default:
632                 return -EINVAL;
633         }
634
635         switch (range) {
636         case 0:
637                 /* 0.5 - 1.2875V in 12.5mV steps */
638                 voltage = tps65912_vsel_to_uv_range0(selector);
639                 break;
640         case 1:
641                 /* 0.7 - 1.4875V in 12.5mV steps */
642                 voltage = tps65912_vsel_to_uv_range1(selector);
643                 break;
644         case 2:
645                 /* 0.5 - 2.075V in 25mV steps */
646                 voltage = tps65912_vsel_to_uv_range2(selector);
647                 break;
648         case 3:
649                 /* 0.5 - 3.8V in 50mV steps */
650                 voltage = tps65912_vsel_to_uv_range3(selector);
651                 break;
652         }
653         return voltage;
654 }
655
656 static int tps65912_list_voltage_ldo(struct regulator_dev *dev,
657                                         unsigned selector)
658 {
659         int ldo = rdev_get_id(dev);
660
661         if (ldo < TPS65912_REG_LDO1 || ldo > TPS65912_REG_LDO10)
662                 return -EINVAL;
663
664         return tps65912_vsel_to_uv_ldo(selector);
665 }
666
667 /* Operations permitted on DCDCx */
668 static struct regulator_ops tps65912_ops_dcdc = {
669         .is_enabled = tps65912_reg_is_enabled,
670         .enable = tps65912_reg_enable,
671         .disable = tps65912_reg_disable,
672         .set_mode = tps65912_set_mode,
673         .get_mode = tps65912_get_mode,
674         .get_voltage = tps65912_get_voltage_dcdc,
675         .set_voltage_sel = tps65912_set_voltage_dcdc,
676         .list_voltage = tps65912_list_voltage_dcdc,
677 };
678
679 /* Operations permitted on LDOx */
680 static struct regulator_ops tps65912_ops_ldo = {
681         .is_enabled = tps65912_reg_is_enabled,
682         .enable = tps65912_reg_enable,
683         .disable = tps65912_reg_disable,
684         .get_voltage = tps65912_get_voltage_ldo,
685         .set_voltage_sel = tps65912_set_voltage_ldo,
686         .list_voltage = tps65912_list_voltage_ldo,
687 };
688
689 static __devinit int tps65912_probe(struct platform_device *pdev)
690 {
691         struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent);
692         struct tps_info *info;
693         struct regulator_init_data *reg_data;
694         struct regulator_dev *rdev;
695         struct tps65912_reg *pmic;
696         struct tps65912_board *pmic_plat_data;
697         int i, err;
698
699         pmic_plat_data = dev_get_platdata(tps65912->dev);
700         if (!pmic_plat_data)
701                 return -EINVAL;
702
703         reg_data = pmic_plat_data->tps65912_pmic_init_data;
704
705         pmic = kzalloc(sizeof(*pmic), GFP_KERNEL);
706         if (!pmic)
707                 return -ENOMEM;
708
709         mutex_init(&pmic->io_lock);
710         pmic->mfd = tps65912;
711         platform_set_drvdata(pdev, pmic);
712
713         pmic->get_ctrl_reg = &tps65912_get_ctrl_register;
714         info = tps65912_regs;
715
716         for (i = 0; i < TPS65912_NUM_REGULATOR; i++, info++, reg_data++) {
717                 int range = 0;
718                 /* Register the regulators */
719                 pmic->info[i] = info;
720
721                 pmic->desc[i].name = info->name;
722                 pmic->desc[i].id = i;
723                 pmic->desc[i].n_voltages = 64;
724                 pmic->desc[i].ops = (i > TPS65912_REG_DCDC4 ?
725                         &tps65912_ops_ldo : &tps65912_ops_dcdc);
726                 pmic->desc[i].type = REGULATOR_VOLTAGE;
727                 pmic->desc[i].owner = THIS_MODULE;
728                 range = tps65912_get_range(pmic, i);
729                 rdev = regulator_register(&pmic->desc[i],
730                                         tps65912->dev, reg_data, pmic);
731                 if (IS_ERR(rdev)) {
732                         dev_err(tps65912->dev,
733                                 "failed to register %s regulator\n",
734                                 pdev->name);
735                         err = PTR_ERR(rdev);
736                         goto err;
737                 }
738
739                 /* Save regulator for cleanup */
740                 pmic->rdev[i] = rdev;
741         }
742         return 0;
743
744 err:
745         while (--i >= 0)
746                 regulator_unregister(pmic->rdev[i]);
747
748         kfree(pmic);
749         return err;
750 }
751
752 static int __devexit tps65912_remove(struct platform_device *pdev)
753 {
754         struct tps65912_reg *tps65912_reg = platform_get_drvdata(pdev);
755         int i;
756
757         for (i = 0; i < TPS65912_NUM_REGULATOR; i++)
758                 regulator_unregister(tps65912_reg->rdev[i]);
759
760         kfree(tps65912_reg);
761         return 0;
762 }
763
764 static struct platform_driver tps65912_driver = {
765         .driver = {
766                 .name = "tps65912-pmic",
767                 .owner = THIS_MODULE,
768         },
769         .probe = tps65912_probe,
770         .remove = __devexit_p(tps65912_remove),
771 };
772
773 /**
774  * tps65912_init
775  *
776  * Module init function
777  */
778 static int __init tps65912_init(void)
779 {
780         return platform_driver_register(&tps65912_driver);
781 }
782 subsys_initcall(tps65912_init);
783
784 /**
785  * tps65912_cleanup
786  *
787  * Module exit function
788  */
789 static void __exit tps65912_cleanup(void)
790 {
791         platform_driver_unregister(&tps65912_driver);
792 }
793 module_exit(tps65912_cleanup);
794
795 MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>");
796 MODULE_DESCRIPTION("TPS65912 voltage regulator driver");
797 MODULE_LICENSE("GPL v2");
798 MODULE_ALIAS("platform:tps65912-pmic");