blob: da00d88f94b7921b89384134d96a0d176cbfe999 [file] [log] [blame]
Margarita Olaya9260ad982011-06-09 14:50:27 -05001/*
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
Margarita Olaya9260ad982011-06-09 14:50:27 -050046/* 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
59struct tps_info {
60 const char *name;
61};
62
63static 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
108struct 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
125static 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
170static 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
178static 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
186static 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
194static 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
206static 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
220static 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
256static 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
302static 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
367static 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
393static 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
413static 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);
Dan Carpenter6daa6632011-07-06 21:57:18 +0300418 int reg;
Margarita Olaya9260ad982011-06-09 14:50:27 -0500419
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
430static 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
443static 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
485static 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
509static 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
569static 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
584static 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
599static 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
612static 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
656static 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 */
668static 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 */
680static 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
689static __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],
Rajendra Nayak2c043bc2011-11-18 16:47:19 +0530730 tps65912->dev, reg_data, pmic, NULL);
Margarita Olaya9260ad982011-06-09 14:50:27 -0500731 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
744err:
745 while (--i >= 0)
746 regulator_unregister(pmic->rdev[i]);
747
748 kfree(pmic);
749 return err;
750}
751
752static 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
764static 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 */
778static int __init tps65912_init(void)
779{
780 return platform_driver_register(&tps65912_driver);
781}
782subsys_initcall(tps65912_init);
783
784/**
785 * tps65912_cleanup
786 *
787 * Module exit function
788 */
789static void __exit tps65912_cleanup(void)
790{
791 platform_driver_unregister(&tps65912_driver);
792}
793module_exit(tps65912_cleanup);
794
795MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>");
796MODULE_DESCRIPTION("TPS65912 voltage regulator driver");
797MODULE_LICENSE("GPL v2");
798MODULE_ALIAS("platform:tps65912-pmic");