projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fix mali API_VERSION grep
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / regulator / palmas-regulator.c
1 /*
2 * Driver for Regulator part of Palmas PMIC Chips
3 *
4 * Copyright 2011-2013 Texas Instruments Inc.
5 *
6 * Author: Graeme Gregory <gg@slimlogic.co.uk>
7 * Author: Ian Lartey <ian@slimlogic.co.uk>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
13 *
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/slab.h>
24 #include <linux/regmap.h>
25 #include <linux/mfd/palmas.h>
26 #include <linux/of.h>
27 #include <linux/of_platform.h>
28 #include <linux/regulator/of_regulator.h>
29
30 struct regs_info {
31 char *name;
32 char *sname;
33 u8 vsel_addr;
34 u8 ctrl_addr;
35 u8 tstep_addr;
36 };
37
38 static const struct regs_info palmas_regs_info[] = {
39 {
40 .name = "SMPS12",
41 .sname = "smps1-in",
42 .vsel_addr = PALMAS_SMPS12_VOLTAGE,
43 .ctrl_addr = PALMAS_SMPS12_CTRL,
44 .tstep_addr = PALMAS_SMPS12_TSTEP,
45 },
46 {
47 .name = "SMPS123",
48 .sname = "smps1-in",
49 .vsel_addr = PALMAS_SMPS12_VOLTAGE,
50 .ctrl_addr = PALMAS_SMPS12_CTRL,
51 .tstep_addr = PALMAS_SMPS12_TSTEP,
52 },
53 {
54 .name = "SMPS3",
55 .sname = "smps3-in",
56 .vsel_addr = PALMAS_SMPS3_VOLTAGE,
57 .ctrl_addr = PALMAS_SMPS3_CTRL,
58 },
59 {
60 .name = "SMPS45",
61 .sname = "smps4-in",
62 .vsel_addr = PALMAS_SMPS45_VOLTAGE,
63 .ctrl_addr = PALMAS_SMPS45_CTRL,
64 .tstep_addr = PALMAS_SMPS45_TSTEP,
65 },
66 {
67 .name = "SMPS457",
68 .sname = "smps4-in",
69 .vsel_addr = PALMAS_SMPS45_VOLTAGE,
70 .ctrl_addr = PALMAS_SMPS45_CTRL,
71 .tstep_addr = PALMAS_SMPS45_TSTEP,
72 },
73 {
74 .name = "SMPS6",
75 .sname = "smps6-in",
76 .vsel_addr = PALMAS_SMPS6_VOLTAGE,
77 .ctrl_addr = PALMAS_SMPS6_CTRL,
78 .tstep_addr = PALMAS_SMPS6_TSTEP,
79 },
80 {
81 .name = "SMPS7",
82 .sname = "smps7-in",
83 .vsel_addr = PALMAS_SMPS7_VOLTAGE,
84 .ctrl_addr = PALMAS_SMPS7_CTRL,
85 },
86 {
87 .name = "SMPS8",
88 .sname = "smps8-in",
89 .vsel_addr = PALMAS_SMPS8_VOLTAGE,
90 .ctrl_addr = PALMAS_SMPS8_CTRL,
91 .tstep_addr = PALMAS_SMPS8_TSTEP,
92 },
93 {
94 .name = "SMPS9",
95 .sname = "smps9-in",
96 .vsel_addr = PALMAS_SMPS9_VOLTAGE,
97 .ctrl_addr = PALMAS_SMPS9_CTRL,
98 },
99 {
100 .name = "SMPS10",
101 .sname = "smps10-in",
102 .ctrl_addr = PALMAS_SMPS10_CTRL,
103 },
104 {
105 .name = "LDO1",
106 .sname = "ldo1-in",
107 .vsel_addr = PALMAS_LDO1_VOLTAGE,
108 .ctrl_addr = PALMAS_LDO1_CTRL,
109 },
110 {
111 .name = "LDO2",
112 .sname = "ldo2-in",
113 .vsel_addr = PALMAS_LDO2_VOLTAGE,
114 .ctrl_addr = PALMAS_LDO2_CTRL,
115 },
116 {
117 .name = "LDO3",
118 .sname = "ldo3-in",
119 .vsel_addr = PALMAS_LDO3_VOLTAGE,
120 .ctrl_addr = PALMAS_LDO3_CTRL,
121 },
122 {
123 .name = "LDO4",
124 .sname = "ldo4-in",
125 .vsel_addr = PALMAS_LDO4_VOLTAGE,
126 .ctrl_addr = PALMAS_LDO4_CTRL,
127 },
128 {
129 .name = "LDO5",
130 .sname = "ldo5-in",
131 .vsel_addr = PALMAS_LDO5_VOLTAGE,
132 .ctrl_addr = PALMAS_LDO5_CTRL,
133 },
134 {
135 .name = "LDO6",
136 .sname = "ldo6-in",
137 .vsel_addr = PALMAS_LDO6_VOLTAGE,
138 .ctrl_addr = PALMAS_LDO6_CTRL,
139 },
140 {
141 .name = "LDO7",
142 .sname = "ldo7-in",
143 .vsel_addr = PALMAS_LDO7_VOLTAGE,
144 .ctrl_addr = PALMAS_LDO7_CTRL,
145 },
146 {
147 .name = "LDO8",
148 .sname = "ldo8-in",
149 .vsel_addr = PALMAS_LDO8_VOLTAGE,
150 .ctrl_addr = PALMAS_LDO8_CTRL,
151 },
152 {
153 .name = "LDO9",
154 .sname = "ldo9-in",
155 .vsel_addr = PALMAS_LDO9_VOLTAGE,
156 .ctrl_addr = PALMAS_LDO9_CTRL,
157 },
158 {
159 .name = "LDOLN",
160 .sname = "ldoln-in",
161 .vsel_addr = PALMAS_LDOLN_VOLTAGE,
162 .ctrl_addr = PALMAS_LDOLN_CTRL,
163 },
164 {
165 .name = "LDOUSB",
166 .sname = "ldousb-in",
167 .vsel_addr = PALMAS_LDOUSB_VOLTAGE,
168 .ctrl_addr = PALMAS_LDOUSB_CTRL,
169 },
170 {
171 .name = "REGEN1",
172 .ctrl_addr = PALMAS_REGEN1_CTRL,
173 },
174 {
175 .name = "REGEN2",
176 .ctrl_addr = PALMAS_REGEN2_CTRL,
177 },
178 {
179 .name = "REGEN3",
180 .ctrl_addr = PALMAS_REGEN3_CTRL,
181 },
182 {
183 .name = "SYSEN1",
184 .ctrl_addr = PALMAS_SYSEN1_CTRL,
185 },
186 {
187 .name = "SYSEN2",
188 .ctrl_addr = PALMAS_SYSEN2_CTRL,
189 },
190 };
191
192 static unsigned int palmas_smps_ramp_delay[4] = {0, 10000, 5000, 2500};
193
194 #define SMPS_CTRL_MODE_OFF 0x00
195 #define SMPS_CTRL_MODE_ON 0x01
196 #define SMPS_CTRL_MODE_ECO 0x02
197 #define SMPS_CTRL_MODE_PWM 0x03
198
199 /* These values are derived from the data sheet. And are the number of steps
200 * where there is a voltage change, the ranges at beginning and end of register
201 * max/min values where there are no change are ommitted.
202 *
203 * So they are basically (maxV-minV)/stepV
204 */
205 #define PALMAS_SMPS_NUM_VOLTAGES 117
206 #define PALMAS_SMPS10_NUM_VOLTAGES 2
207 #define PALMAS_LDO_NUM_VOLTAGES 50
208
209 #define SMPS10_VSEL (1<<3)
210 #define SMPS10_BOOST_EN (1<<2)
211 #define SMPS10_BYPASS_EN (1<<1)
212 #define SMPS10_SWITCH_EN (1<<0)
213
214 #define REGULATOR_SLAVE 0
215
216 static int palmas_smps_read(struct palmas *palmas, unsigned int reg,
217 unsigned int *dest)
218 {
219 unsigned int addr;
220
221 addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
222
223 return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
224 }
225
226 static int palmas_smps_write(struct palmas *palmas, unsigned int reg,
227 unsigned int value)
228 {
229 unsigned int addr;
230
231 addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
232
233 return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
234 }
235
236 static int palmas_ldo_read(struct palmas *palmas, unsigned int reg,
237 unsigned int *dest)
238 {
239 unsigned int addr;
240
241 addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
242
243 return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
244 }
245
246 static int palmas_ldo_write(struct palmas *palmas, unsigned int reg,
247 unsigned int value)
248 {
249 unsigned int addr;
250
251 addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
252
253 return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
254 }
255
256 static int palmas_is_enabled_smps(struct regulator_dev *dev)
257 {
258 struct palmas_pmic *pmic = rdev_get_drvdata(dev);
259 int id = rdev_get_id(dev);
260 unsigned int reg;
261
262 palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
263
264 reg &= PALMAS_SMPS12_CTRL_STATUS_MASK;
265 reg >>= PALMAS_SMPS12_CTRL_STATUS_SHIFT;
266
267 return !!(reg);
268 }
269
270 static int palmas_enable_smps(struct regulator_dev *dev)
271 {
272 struct palmas_pmic *pmic = rdev_get_drvdata(dev);
273 int id = rdev_get_id(dev);
274 unsigned int reg;
275
276 palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
277
278 reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
279 if (pmic->current_reg_mode[id])
280 reg |= pmic->current_reg_mode[id];
281 else
282 reg |= SMPS_CTRL_MODE_ON;
283
284 palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg);
285
286 return 0;
287 }
288
289 static int palmas_disable_smps(struct regulator_dev *dev)
290 {
291 struct palmas_pmic *pmic = rdev_get_drvdata(dev);
292 int id = rdev_get_id(dev);
293 unsigned int reg;
294
295 palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
296
297 reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
298
299 palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg);
300
301 return 0;
302 }
303
304 static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode)
305 {
306 struct palmas_pmic *pmic = rdev_get_drvdata(dev);
307 int id = rdev_get_id(dev);
308 unsigned int reg;
309 bool rail_enable = true;
310
311 palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
312 reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
313
314 if (reg == SMPS_CTRL_MODE_OFF)
315 rail_enable = false;
316
317 switch (mode) {
318 case REGULATOR_MODE_NORMAL:
319 reg |= SMPS_CTRL_MODE_ON;
320 break;
321 case REGULATOR_MODE_IDLE:
322 reg |= SMPS_CTRL_MODE_ECO;
323 break;
324 case REGULATOR_MODE_FAST:
325 reg |= SMPS_CTRL_MODE_PWM;
326 break;
327 default:
328 return -EINVAL;
329 }
330
331 pmic->current_reg_mode[id] = reg & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
332 if (rail_enable)
333 palmas_smps_write(pmic->palmas,
334 palmas_regs_info[id].ctrl_addr, reg);
335 return 0;
336 }
337
338 static unsigned int palmas_get_mode_smps(struct regulator_dev *dev)
339 {
340 struct palmas_pmic *pmic = rdev_get_drvdata(dev);
341 int id = rdev_get_id(dev);
342 unsigned int reg;
343
344 reg = pmic->current_reg_mode[id] & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
345
346 switch (reg) {
347 case SMPS_CTRL_MODE_ON:
348 return REGULATOR_MODE_NORMAL;
349 case SMPS_CTRL_MODE_ECO:
350 return REGULATOR_MODE_IDLE;
351 case SMPS_CTRL_MODE_PWM:
352 return REGULATOR_MODE_FAST;
353 }
354
355 return 0;
356 }
357
358 static int palmas_list_voltage_smps(struct regulator_dev *dev,
359 unsigned selector)
360 {
361 struct palmas_pmic *pmic = rdev_get_drvdata(dev);
362 int id = rdev_get_id(dev);
363 int mult = 1;
364
365 /* Read the multiplier set in VSEL register to return
366 * the correct voltage.
367 */
368 if (pmic->range[id])
369 mult = 2;
370
371 if (selector == 0)
372 return 0;
373 else if (selector < 6)
374 return 500000 * mult;
375 else
376 /* Voltage is linear mapping starting from selector 6,
377 * volt = (0.49V + ((selector - 5) * 0.01V)) * RANGE
378 * RANGE is either x1 or x2
379 */
380 return (490000 + ((selector - 5) * 10000)) * mult;
381 }
382
383 static int palmas_map_voltage_smps(struct regulator_dev *rdev,
384 int min_uV, int max_uV)
385 {
386 struct palmas_pmic *pmic = rdev_get_drvdata(rdev);
387 int id = rdev_get_id(rdev);
388 int ret, voltage;
389
390 if (min_uV == 0)
391 return 0;
392
393 if (pmic->range[id]) { /* RANGE is x2 */
394 if (min_uV < 1000000)
395 min_uV = 1000000;
396 ret = DIV_ROUND_UP(min_uV - 1000000, 20000) + 6;
397 } else { /* RANGE is x1 */
398 if (min_uV < 500000)
399 min_uV = 500000;
400 ret = DIV_ROUND_UP(min_uV - 500000, 10000) + 6;
401 }
402
403 /* Map back into a voltage to verify we're still in bounds */
404 voltage = palmas_list_voltage_smps(rdev, ret);
405 if (voltage < min_uV || voltage > max_uV)
406 return -EINVAL;
407
408 return ret;
409 }
410
411 static int palma_smps_set_voltage_smps_time_sel(struct regulator_dev *rdev,
412 unsigned int old_selector, unsigned int new_selector)
413 {
414 struct palmas_pmic *pmic = rdev_get_drvdata(rdev);
415 int id = rdev_get_id(rdev);
416 int old_uv, new_uv;
417 unsigned int ramp_delay = pmic->ramp_delay[id];
418
419 if (!ramp_delay)
420 return 0;
421
422 old_uv = palmas_list_voltage_smps(rdev, old_selector);
423 if (old_uv < 0)
424 return old_uv;
425
426 new_uv = palmas_list_voltage_smps(rdev, new_selector);
427 if (new_uv < 0)
428 return new_uv;
429
430 return DIV_ROUND_UP(abs(old_uv - new_uv), ramp_delay);
431 }
432
433 static int palmas_smps_set_ramp_delay(struct regulator_dev *rdev,
434 int ramp_delay)
435 {
436 struct palmas_pmic *pmic = rdev_get_drvdata(rdev);
437 int id = rdev_get_id(rdev);
438 unsigned int reg = 0;
439 unsigned int addr = palmas_regs_info[id].tstep_addr;
440 int ret;
441
442 /* SMPS3 and SMPS7 do not have tstep_addr setting */
443 switch (id) {
444 case PALMAS_REG_SMPS3:
445 case PALMAS_REG_SMPS7:
446 return 0;
447 }
448
449 if (ramp_delay <= 0)
450 reg = 0;
451 else if (ramp_delay <= 2500)
452 reg = 3;
453 else if (ramp_delay <= 5000)
454 reg = 2;
455 else
456 reg = 1;
457
458 ret = palmas_smps_write(pmic->palmas, addr, reg);
459 if (ret < 0) {
460 dev_err(pmic->palmas->dev, "TSTEP write failed: %d\n", ret);
461 return ret;
462 }
463
464 pmic->ramp_delay[id] = palmas_smps_ramp_delay[reg];
465 return ret;
466 }
467
468 static struct regulator_ops palmas_ops_smps = {
469 .is_enabled = palmas_is_enabled_smps,
470 .enable = palmas_enable_smps,
471 .disable = palmas_disable_smps,
472 .set_mode = palmas_set_mode_smps,
473 .get_mode = palmas_get_mode_smps,
474 .get_voltage_sel = regulator_get_voltage_sel_regmap,
475 .set_voltage_sel = regulator_set_voltage_sel_regmap,
476 .list_voltage = palmas_list_voltage_smps,
477 .map_voltage = palmas_map_voltage_smps,
478 .set_voltage_time_sel = palma_smps_set_voltage_smps_time_sel,
479 .set_ramp_delay = palmas_smps_set_ramp_delay,
480 };
481
482 static struct regulator_ops palmas_ops_smps10 = {
483 .is_enabled = regulator_is_enabled_regmap,
484 .enable = regulator_enable_regmap,
485 .disable = regulator_disable_regmap,
486 .get_voltage_sel = regulator_get_voltage_sel_regmap,
487 .set_voltage_sel = regulator_set_voltage_sel_regmap,
488 .list_voltage = regulator_list_voltage_linear,
489 .map_voltage = regulator_map_voltage_linear,
490 };
491
492 static int palmas_is_enabled_ldo(struct regulator_dev *dev)
493 {
494 struct palmas_pmic *pmic = rdev_get_drvdata(dev);
495 int id = rdev_get_id(dev);
496 unsigned int reg;
497
498 palmas_ldo_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
499
500 reg &= PALMAS_LDO1_CTRL_STATUS;
501
502 return !!(reg);
503 }
504
505 static struct regulator_ops palmas_ops_ldo = {
506 .is_enabled = palmas_is_enabled_ldo,
507 .enable = regulator_enable_regmap,
508 .disable = regulator_disable_regmap,
509 .get_voltage_sel = regulator_get_voltage_sel_regmap,
510 .set_voltage_sel = regulator_set_voltage_sel_regmap,
511 .list_voltage = regulator_list_voltage_linear,
512 .map_voltage = regulator_map_voltage_linear,
513 };
514
515 static struct regulator_ops palmas_ops_extreg = {
516 .is_enabled = regulator_is_enabled_regmap,
517 .enable = regulator_enable_regmap,
518 .disable = regulator_disable_regmap,
519 };
520
521 /*
522 * setup the hardware based sleep configuration of the SMPS/LDO regulators
523 * from the platform data. This is different to the software based control
524 * supported by the regulator framework as it is controlled by toggling
525 * pins on the PMIC such as PREQ, SYSEN, ...
526 */
527 static int palmas_smps_init(struct palmas *palmas, int id,
528 struct palmas_reg_init *reg_init)
529 {
530 unsigned int reg;
531 unsigned int addr;
532 int ret;
533
534 addr = palmas_regs_info[id].ctrl_addr;
535
536 ret = palmas_smps_read(palmas, addr, &reg);
537 if (ret)
538 return ret;
539
540 switch (id) {
541 case PALMAS_REG_SMPS10:
542 reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK;
543 if (reg_init->mode_sleep)
544 reg |= reg_init->mode_sleep <<
545 PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT;
546 break;
547 default:
548 if (reg_init->warm_reset)
549 reg |= PALMAS_SMPS12_CTRL_WR_S;
550 else
551 reg &= ~PALMAS_SMPS12_CTRL_WR_S;
552
553 if (reg_init->roof_floor)
554 reg |= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN;
555 else
556 reg &= ~PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN;
557
558 reg &= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK;
559 if (reg_init->mode_sleep)
560 reg |= reg_init->mode_sleep <<
561 PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT;
562 }
563
564 ret = palmas_smps_write(palmas, addr, reg);
565 if (ret)
566 return ret;
567
568 if (palmas_regs_info[id].vsel_addr && reg_init->vsel) {
569 addr = palmas_regs_info[id].vsel_addr;
570
571 reg = reg_init->vsel;
572
573 ret = palmas_smps_write(palmas, addr, reg);
574 if (ret)
575 return ret;
576 }
577
578
579 return 0;
580 }
581
582 static int palmas_ldo_init(struct palmas *palmas, int id,
583 struct palmas_reg_init *reg_init)
584 {
585 unsigned int reg;
586 unsigned int addr;
587 int ret;
588
589 addr = palmas_regs_info[id].ctrl_addr;
590
591 ret = palmas_ldo_read(palmas, addr, &reg);
592 if (ret)
593 return ret;
594
595 if (reg_init->warm_reset)
596 reg |= PALMAS_LDO1_CTRL_WR_S;
597 else
598 reg &= ~PALMAS_LDO1_CTRL_WR_S;
599
600 if (reg_init->mode_sleep)
601 reg |= PALMAS_LDO1_CTRL_MODE_SLEEP;
602 else
603 reg &= ~PALMAS_LDO1_CTRL_MODE_SLEEP;
604
605 ret = palmas_ldo_write(palmas, addr, reg);
606 if (ret)
607 return ret;
608
609 return 0;
610 }
611
612 static int palmas_extreg_init(struct palmas *palmas, int id,
613 struct palmas_reg_init *reg_init)
614 {
615 unsigned int addr;
616 int ret;
617 unsigned int val = 0;
618
619 addr = palmas_regs_info[id].ctrl_addr;
620
621 if (reg_init->mode_sleep)
622 val = PALMAS_REGEN1_CTRL_MODE_SLEEP;
623
624 ret = palmas_update_bits(palmas, PALMAS_RESOURCE_BASE,
625 addr, PALMAS_REGEN1_CTRL_MODE_SLEEP, val);
626 if (ret < 0) {
627 dev_err(palmas->dev, "Resource reg 0x%02x update failed %d\n",
628 addr, ret);
629 return ret;
630 }
631 return 0;
632 }
633
634 static void palmas_enable_ldo8_track(struct palmas *palmas)
635 {
636 unsigned int reg;
637 unsigned int addr;
638 int ret;
639
640 addr = palmas_regs_info[PALMAS_REG_LDO8].ctrl_addr;
641
642 ret = palmas_ldo_read(palmas, addr, &reg);
643 if (ret) {
644 dev_err(palmas->dev, "Error in reading ldo8 control reg\n");
645 return;
646 }
647
648 reg |= PALMAS_LDO8_CTRL_LDO_TRACKING_EN;
649 ret = palmas_ldo_write(palmas, addr, reg);
650 if (ret < 0) {
651 dev_err(palmas->dev, "Error in enabling tracking mode\n");
652 return;
653 }
654 /*
655 * When SMPS45 is set to off and LDO8 tracking is enabled, the LDO8
656 * output is defined by the LDO8_VOLTAGE.VSEL register divided by two,
657 * and can be set from 0.45 to 1.65 V.
658 */
659 addr = palmas_regs_info[PALMAS_REG_LDO8].vsel_addr;
660 ret = palmas_ldo_read(palmas, addr, &reg);
661 if (ret) {
662 dev_err(palmas->dev, "Error in reading ldo8 voltage reg\n");
663 return;
664 }
665
666 reg = (reg << 1) & PALMAS_LDO8_VOLTAGE_VSEL_MASK;
667 ret = palmas_ldo_write(palmas, addr, reg);
668 if (ret < 0)
669 dev_err(palmas->dev, "Error in setting ldo8 voltage reg\n");
670
671 return;
672 }
673
674 static struct of_regulator_match palmas_matches[] = {
675 { .name = "smps12", },
676 { .name = "smps123", },
677 { .name = "smps3", },
678 { .name = "smps45", },
679 { .name = "smps457", },
680 { .name = "smps6", },
681 { .name = "smps7", },
682 { .name = "smps8", },
683 { .name = "smps9", },
684 { .name = "smps10", },
685 { .name = "ldo1", },
686 { .name = "ldo2", },
687 { .name = "ldo3", },
688 { .name = "ldo4", },
689 { .name = "ldo5", },
690 { .name = "ldo6", },
691 { .name = "ldo7", },
692 { .name = "ldo8", },
693 { .name = "ldo9", },
694 { .name = "ldoln", },
695 { .name = "ldousb", },
696 { .name = "regen1", },
697 { .name = "regen2", },
698 { .name = "regen3", },
699 { .name = "sysen1", },
700 { .name = "sysen2", },
701 };
702
703 static void palmas_dt_to_pdata(struct device *dev,
704 struct device_node *node,
705 struct palmas_pmic_platform_data *pdata)
706 {
707 struct device_node *regulators;
708 u32 prop;
709 int idx, ret;
710
711 node = of_node_get(node);
712 regulators = of_find_node_by_name(node, "regulators");
713 if (!regulators) {
714 dev_info(dev, "regulator node not found\n");
715 return;
716 }
717
718 ret = of_regulator_match(dev, regulators, palmas_matches,
719 PALMAS_NUM_REGS);
720 of_node_put(regulators);
721 if (ret < 0) {
722 dev_err(dev, "Error parsing regulator init data: %d\n", ret);
723 return;
724 }
725
726 for (idx = 0; idx < PALMAS_NUM_REGS; idx++) {
727 if (!palmas_matches[idx].init_data ||
728 !palmas_matches[idx].of_node)
729 continue;
730
731 pdata->reg_data[idx] = palmas_matches[idx].init_data;
732
733 pdata->reg_init[idx] = devm_kzalloc(dev,
734 sizeof(struct palmas_reg_init), GFP_KERNEL);
735
736 pdata->reg_init[idx]->warm_reset =
737 of_property_read_bool(palmas_matches[idx].of_node,
738 "ti,warm-reset");
739
740 pdata->reg_init[idx]->roof_floor =
741 of_property_read_bool(palmas_matches[idx].of_node,
742 "ti,roof-floor");
743
744 ret = of_property_read_u32(palmas_matches[idx].of_node,
745 "ti,mode-sleep", &prop);
746 if (!ret)
747 pdata->reg_init[idx]->mode_sleep = prop;
748
749 ret = of_property_read_bool(palmas_matches[idx].of_node,
750 "ti,smps-range");
751 if (ret)
752 pdata->reg_init[idx]->vsel =
753 PALMAS_SMPS12_VOLTAGE_RANGE;
754
755 if (idx == PALMAS_REG_LDO8)
756 pdata->enable_ldo8_tracking = of_property_read_bool(
757 palmas_matches[idx].of_node,
758 "ti,enable-ldo8-tracking");
759 }
760
761 pdata->ldo6_vibrator = of_property_read_bool(node, "ti,ldo6-vibrator");
762 }
763
764
765 static int palmas_regulators_probe(struct platform_device *pdev)
766 {
767 struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
768 struct palmas_pmic_platform_data *pdata = pdev->dev.platform_data;
769 struct device_node *node = pdev->dev.of_node;
770 struct regulator_dev *rdev;
771 struct regulator_config config = { };
772 struct palmas_pmic *pmic;
773 struct palmas_reg_init *reg_init;
774 int id = 0, ret;
775 unsigned int addr, reg;
776
777 if (node && !pdata) {
778 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
779
780 if (!pdata)
781 return -ENOMEM;
782
783 palmas_dt_to_pdata(&pdev->dev, node, pdata);
784 }
785
786 pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
787 if (!pmic)
788 return -ENOMEM;
789
790 pmic->dev = &pdev->dev;
791 pmic->palmas = palmas;
792 palmas->pmic = pmic;
793 platform_set_drvdata(pdev, pmic);
794
795 ret = palmas_smps_read(palmas, PALMAS_SMPS_CTRL, &reg);
796 if (ret)
797 return ret;
798
799 if (reg & PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN)
800 pmic->smps123 = 1;
801
802 if (reg & PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN)
803 pmic->smps457 = 1;
804
805 config.regmap = palmas->regmap[REGULATOR_SLAVE];
806 config.dev = &pdev->dev;
807 config.driver_data = pmic;
808
809 for (id = 0; id < PALMAS_REG_LDO1; id++) {
810 bool ramp_delay_support = false;
811
812 /*
813 * Miss out regulators which are not available due
814 * to slaving configurations.
815 */
816 switch (id) {
817 case PALMAS_REG_SMPS12:
818 case PALMAS_REG_SMPS3:
819 if (pmic->smps123)
820 continue;
821 if (id == PALMAS_REG_SMPS12)
822 ramp_delay_support = true;
823 break;
824 case PALMAS_REG_SMPS123:
825 if (!pmic->smps123)
826 continue;
827 ramp_delay_support = true;
828 break;
829 case PALMAS_REG_SMPS45:
830 case PALMAS_REG_SMPS7:
831 if (pmic->smps457)
832 continue;
833 if (id == PALMAS_REG_SMPS45)
834 ramp_delay_support = true;
835 break;
836 case PALMAS_REG_SMPS457:
837 if (!pmic->smps457)
838 continue;
839 ramp_delay_support = true;
840 break;
841 }
842
843 if ((id == PALMAS_REG_SMPS6) || (id == PALMAS_REG_SMPS8))
844 ramp_delay_support = true;
845
846 if (ramp_delay_support) {
847 addr = palmas_regs_info[id].tstep_addr;
848 ret = palmas_smps_read(pmic->palmas, addr, &reg);
849 if (ret < 0) {
850 dev_err(&pdev->dev,
851 "reading TSTEP reg failed: %d\n", ret);
852 goto err_unregister_regulator;
853 }
854 pmic->desc[id].ramp_delay =
855 palmas_smps_ramp_delay[reg & 0x3];
856 pmic->ramp_delay[id] = pmic->desc[id].ramp_delay;
857 }
858
859 /* Initialise sleep/init values from platform data */
860 if (pdata && pdata->reg_init[id]) {
861 reg_init = pdata->reg_init[id];
862 ret = palmas_smps_init(palmas, id, reg_init);
863 if (ret)
864 goto err_unregister_regulator;
865 }
866
867 /* Register the regulators */
868 pmic->desc[id].name = palmas_regs_info[id].name;
869 pmic->desc[id].id = id;
870
871 switch (id) {
872 case PALMAS_REG_SMPS10:
873 pmic->desc[id].n_voltages = PALMAS_SMPS10_NUM_VOLTAGES;
874 pmic->desc[id].ops = &palmas_ops_smps10;
875 pmic->desc[id].vsel_reg =
876 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
877 PALMAS_SMPS10_CTRL);
878 pmic->desc[id].vsel_mask = SMPS10_VSEL;
879 pmic->desc[id].enable_reg =
880 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
881 PALMAS_SMPS10_CTRL);
882 pmic->desc[id].enable_mask = SMPS10_BOOST_EN;
883 pmic->desc[id].min_uV = 3750000;
884 pmic->desc[id].uV_step = 1250000;
885 break;
886 default:
887 /*
888 * Read and store the RANGE bit for later use
889 * This must be done before regulator is probed,
890 * otherwise we error in probe with unsupportable
891 * ranges. Read the current smps mode for later use.
892 */
893 addr = palmas_regs_info[id].vsel_addr;
894
895 ret = palmas_smps_read(pmic->palmas, addr, &reg);
896 if (ret)
897 goto err_unregister_regulator;
898 if (reg & PALMAS_SMPS12_VOLTAGE_RANGE)
899 pmic->range[id] = 1;
900
901 pmic->desc[id].ops = &palmas_ops_smps;
902 pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
903 pmic->desc[id].vsel_reg =
904 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
905 palmas_regs_info[id].vsel_addr);
906 pmic->desc[id].vsel_mask =
907 PALMAS_SMPS12_VOLTAGE_VSEL_MASK;
908
909 /* Read the smps mode for later use. */
910 addr = palmas_regs_info[id].ctrl_addr;
911 ret = palmas_smps_read(pmic->palmas, addr, &reg);
912 if (ret)
913 goto err_unregister_regulator;
914 pmic->current_reg_mode[id] = reg &
915 PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
916 }
917
918 pmic->desc[id].type = REGULATOR_VOLTAGE;
919 pmic->desc[id].owner = THIS_MODULE;
920
921 if (pdata)
922 config.init_data = pdata->reg_data[id];
923 else
924 config.init_data = NULL;
925
926 pmic->desc[id].supply_name = palmas_regs_info[id].sname;
927 config.of_node = palmas_matches[id].of_node;
928
929 rdev = regulator_register(&pmic->desc[id], &config);
930 if (IS_ERR(rdev)) {
931 dev_err(&pdev->dev,
932 "failed to register %s regulator\n",
933 pdev->name);
934 ret = PTR_ERR(rdev);
935 goto err_unregister_regulator;
936 }
937
938 /* Save regulator for cleanup */
939 pmic->rdev[id] = rdev;
940 }
941
942 /* Start this loop from the id left from previous loop */
943 for (; id < PALMAS_NUM_REGS; id++) {
944
945 /* Miss out regulators which are not available due
946 * to alternate functions.
947 */
948
949 /* Register the regulators */
950 pmic->desc[id].name = palmas_regs_info[id].name;
951 pmic->desc[id].id = id;
952 pmic->desc[id].type = REGULATOR_VOLTAGE;
953 pmic->desc[id].owner = THIS_MODULE;
954
955 if (id < PALMAS_REG_REGEN1) {
956 pmic->desc[id].n_voltages = PALMAS_LDO_NUM_VOLTAGES;
957 pmic->desc[id].ops = &palmas_ops_ldo;
958 pmic->desc[id].min_uV = 900000;
959 pmic->desc[id].uV_step = 50000;
960 pmic->desc[id].linear_min_sel = 1;
961 pmic->desc[id].vsel_reg =
962 PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
963 palmas_regs_info[id].vsel_addr);
964 pmic->desc[id].vsel_mask =
965 PALMAS_LDO1_VOLTAGE_VSEL_MASK;
966 pmic->desc[id].enable_reg =
967 PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
968 palmas_regs_info[id].ctrl_addr);
969 pmic->desc[id].enable_mask =
970 PALMAS_LDO1_CTRL_MODE_ACTIVE;
971
972 /* Check if LDO8 is in tracking mode or not */
973 if (pdata && (id == PALMAS_REG_LDO8) &&
974 pdata->enable_ldo8_tracking) {
975 palmas_enable_ldo8_track(palmas);
976 pmic->desc[id].min_uV = 450000;
977 pmic->desc[id].uV_step = 25000;
978 }
979 } else {
980 pmic->desc[id].n_voltages = 1;
981 pmic->desc[id].ops = &palmas_ops_extreg;
982 pmic->desc[id].enable_reg =
983 PALMAS_BASE_TO_REG(PALMAS_RESOURCE_BASE,
984 palmas_regs_info[id].ctrl_addr);
985 pmic->desc[id].enable_mask =
986 PALMAS_REGEN1_CTRL_MODE_ACTIVE;
987 }
988
989 if (pdata)
990 config.init_data = pdata->reg_data[id];
991 else
992 config.init_data = NULL;
993
994 pmic->desc[id].supply_name = palmas_regs_info[id].sname;
995 config.of_node = palmas_matches[id].of_node;
996
997 rdev = regulator_register(&pmic->desc[id], &config);
998 if (IS_ERR(rdev)) {
999 dev_err(&pdev->dev,
1000 "failed to register %s regulator\n",
1001 pdev->name);
1002 ret = PTR_ERR(rdev);
1003 goto err_unregister_regulator;
1004 }
1005
1006 /* Save regulator for cleanup */
1007 pmic->rdev[id] = rdev;
1008
1009 /* Initialise sleep/init values from platform data */
1010 if (pdata) {
1011 reg_init = pdata->reg_init[id];
1012 if (reg_init) {
1013 if (id < PALMAS_REG_REGEN1)
1014 ret = palmas_ldo_init(palmas,
1015 id, reg_init);
1016 else
1017 ret = palmas_extreg_init(palmas,
1018 id, reg_init);
1019 if (ret) {
1020 regulator_unregister(pmic->rdev[id]);
1021 goto err_unregister_regulator;
1022 }
1023 }
1024 }
1025 }
1026
1027
1028 return 0;
1029
1030 err_unregister_regulator:
1031 while (--id >= 0)
1032 regulator_unregister(pmic->rdev[id]);
1033 return ret;
1034 }
1035
1036 static int palmas_regulators_remove(struct platform_device *pdev)
1037 {
1038 struct palmas_pmic *pmic = platform_get_drvdata(pdev);
1039 int id;
1040
1041 for (id = 0; id < PALMAS_NUM_REGS; id++)
1042 regulator_unregister(pmic->rdev[id]);
1043 return 0;
1044 }
1045
1046 static struct of_device_id of_palmas_match_tbl[] = {
1047 { .compatible = "ti,palmas-pmic", },
1048 { .compatible = "ti,twl6035-pmic", },
1049 { .compatible = "ti,twl6036-pmic", },
1050 { .compatible = "ti,twl6037-pmic", },
1051 { .compatible = "ti,tps65913-pmic", },
1052 { .compatible = "ti,tps65914-pmic", },
1053 { .compatible = "ti,tps80036-pmic", },
1054 { /* end */ }
1055 };
1056
1057 static struct platform_driver palmas_driver = {
1058 .driver = {
1059 .name = "palmas-pmic",
1060 .of_match_table = of_palmas_match_tbl,
1061 .owner = THIS_MODULE,
1062 },
1063 .probe = palmas_regulators_probe,
1064 .remove = palmas_regulators_remove,
1065 };
1066
1067 static int __init palmas_init(void)
1068 {
1069 return platform_driver_register(&palmas_driver);
1070 }
1071 subsys_initcall(palmas_init);
1072
1073 static void __exit palmas_exit(void)
1074 {
1075 platform_driver_unregister(&palmas_driver);
1076 }
1077 module_exit(palmas_exit);
1078
1079 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
1080 MODULE_DESCRIPTION("Palmas voltage regulator driver");
1081 MODULE_LICENSE("GPL");
1082 MODULE_ALIAS("platform:palmas-pmic");
1083 MODULE_DEVICE_TABLE(of, of_palmas_match_tbl);
kernel source for telekom puls (alcatel/mediatek)