Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Split TWL6030 logic from twl-regulator.c:
4 * Copyright (C) 2008 David Brownell
5 *
6 * Copyright (C) 2016 Nicolae Rosia <nicolae.rosia@gmail.com>
7 */
8
9#include <linux/module.h>
10#include <linux/string.h>
11#include <linux/slab.h>
12#include <linux/init.h>
13#include <linux/err.h>
14#include <linux/platform_device.h>
15#include <linux/of.h>
16#include <linux/of_device.h>
17#include <linux/regulator/driver.h>
18#include <linux/regulator/machine.h>
19#include <linux/regulator/of_regulator.h>
20#include <linux/mfd/twl.h>
21#include <linux/delay.h>
22
23struct twlreg_info {
24 /* start of regulator's PM_RECEIVER control register bank */
25 u8 base;
26
27 /* twl resource ID, for resource control state machine */
28 u8 id;
29
30 u8 flags;
31
32 /* used by regulator core */
33 struct regulator_desc desc;
34
35 /* chip specific features */
36 unsigned long features;
37
38 /* data passed from board for external get/set voltage */
39 void *data;
40};
41
42
43/* LDO control registers ... offset is from the base of its register bank.
44 * The first three registers of all power resource banks help hardware to
45 * manage the various resource groups.
46 */
47/* Common offset in TWL4030/6030 */
48#define VREG_GRP 0
49/* TWL6030 register offsets */
50#define VREG_TRANS 1
51#define VREG_STATE 2
52#define VREG_VOLTAGE 3
53#define VREG_VOLTAGE_SMPS 4
54/* TWL6030 Misc register offsets */
55#define VREG_BC_ALL 1
56#define VREG_BC_REF 2
57#define VREG_BC_PROC 3
58#define VREG_BC_CLK_RST 4
59
60/* TWL6030 LDO register values for VREG_VOLTAGE */
61#define TWL6030_VREG_VOLTAGE_WR_S BIT(7)
62
63/* TWL6030 LDO register values for CFG_STATE */
64#define TWL6030_CFG_STATE_OFF 0x00
65#define TWL6030_CFG_STATE_ON 0x01
66#define TWL6030_CFG_STATE_OFF2 0x02
67#define TWL6030_CFG_STATE_SLEEP 0x03
68#define TWL6030_CFG_STATE_GRP_SHIFT 5
69#define TWL6030_CFG_STATE_APP_SHIFT 2
70#define TWL6030_CFG_STATE_MASK 0x03
71#define TWL6030_CFG_STATE_APP_MASK (0x03 << TWL6030_CFG_STATE_APP_SHIFT)
72#define TWL6030_CFG_STATE_APP(v) (((v) & TWL6030_CFG_STATE_APP_MASK) >>\
73 TWL6030_CFG_STATE_APP_SHIFT)
74
75/* Flags for SMPS Voltage reading and LDO reading*/
76#define SMPS_OFFSET_EN BIT(0)
77#define SMPS_EXTENDED_EN BIT(1)
78#define TWL_6030_WARM_RESET BIT(3)
79
80/* twl6032 SMPS EPROM values */
81#define TWL6030_SMPS_OFFSET 0xB0
82#define TWL6030_SMPS_MULT 0xB3
83#define SMPS_MULTOFFSET_SMPS4 BIT(0)
84#define SMPS_MULTOFFSET_VIO BIT(1)
85#define SMPS_MULTOFFSET_SMPS3 BIT(6)
86
87static inline int
88twlreg_read(struct twlreg_info *info, unsigned slave_subgp, unsigned offset)
89{
90 u8 value;
91 int status;
92
93 status = twl_i2c_read_u8(slave_subgp,
94 &value, info->base + offset);
95 return (status < 0) ? status : value;
96}
97
98static inline int
99twlreg_write(struct twlreg_info *info, unsigned slave_subgp, unsigned offset,
100 u8 value)
101{
102 return twl_i2c_write_u8(slave_subgp,
103 value, info->base + offset);
104}
105
106/* generic power resource operations, which work on all regulators */
107static int twlreg_grp(struct regulator_dev *rdev)
108{
109 return twlreg_read(rdev_get_drvdata(rdev), TWL_MODULE_PM_RECEIVER,
110 VREG_GRP);
111}
112
113/*
114 * Enable/disable regulators by joining/leaving the P1 (processor) group.
115 * We assume nobody else is updating the DEV_GRP registers.
116 */
117/* definition for 6030 family */
118#define P3_GRP_6030 BIT(2) /* secondary processor, modem, etc */
119#define P2_GRP_6030 BIT(1) /* "peripherals" */
120#define P1_GRP_6030 BIT(0) /* CPU/Linux */
121
122static int twl6030reg_is_enabled(struct regulator_dev *rdev)
123{
124 struct twlreg_info *info = rdev_get_drvdata(rdev);
125 int grp = 0, val;
126
127 if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS))) {
128 grp = twlreg_grp(rdev);
129 if (grp < 0)
130 return grp;
131 grp &= P1_GRP_6030;
132 val = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_STATE);
133 val = TWL6030_CFG_STATE_APP(val);
134 } else {
135 val = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_STATE);
136 val &= TWL6030_CFG_STATE_MASK;
137 grp = 1;
138 }
139
140 return grp && (val == TWL6030_CFG_STATE_ON);
141}
142
143#define PB_I2C_BUSY BIT(0)
144#define PB_I2C_BWEN BIT(1)
145
146
147static int twl6030reg_enable(struct regulator_dev *rdev)
148{
149 struct twlreg_info *info = rdev_get_drvdata(rdev);
150 int grp = 0;
151 int ret;
152
153 if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))
154 grp = twlreg_grp(rdev);
155 if (grp < 0)
156 return grp;
157
158 ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,
159 grp << TWL6030_CFG_STATE_GRP_SHIFT |
160 TWL6030_CFG_STATE_ON);
161 return ret;
162}
163
164static int twl6030reg_disable(struct regulator_dev *rdev)
165{
166 struct twlreg_info *info = rdev_get_drvdata(rdev);
167 int grp = 0;
168 int ret;
169
170 if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))
171 grp = P1_GRP_6030 | P2_GRP_6030 | P3_GRP_6030;
172
173 /* For 6030, set the off state for all grps enabled */
174 ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,
175 (grp) << TWL6030_CFG_STATE_GRP_SHIFT |
176 TWL6030_CFG_STATE_OFF);
177
178 return ret;
179}
180
181static int twl6030reg_get_status(struct regulator_dev *rdev)
182{
183 struct twlreg_info *info = rdev_get_drvdata(rdev);
184 int val;
185
186 val = twlreg_grp(rdev);
187 if (val < 0)
188 return val;
189
190 val = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_STATE);
191
192 if (info->features & TWL6032_SUBCLASS)
193 val &= TWL6030_CFG_STATE_MASK;
194 else
195 val = TWL6030_CFG_STATE_APP(val);
196
197 switch (val) {
198 case TWL6030_CFG_STATE_ON:
199 return REGULATOR_STATUS_NORMAL;
200
201 case TWL6030_CFG_STATE_SLEEP:
202 return REGULATOR_STATUS_STANDBY;
203
204 case TWL6030_CFG_STATE_OFF:
205 case TWL6030_CFG_STATE_OFF2:
206 default:
207 break;
208 }
209
210 return REGULATOR_STATUS_OFF;
211}
212
213static int twl6030reg_set_mode(struct regulator_dev *rdev, unsigned mode)
214{
215 struct twlreg_info *info = rdev_get_drvdata(rdev);
216 int grp = 0;
217 int val;
218
219 if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))
220 grp = twlreg_grp(rdev);
221
222 if (grp < 0)
223 return grp;
224
225 /* Compose the state register settings */
226 val = grp << TWL6030_CFG_STATE_GRP_SHIFT;
227 /* We can only set the mode through state machine commands... */
228 switch (mode) {
229 case REGULATOR_MODE_NORMAL:
230 val |= TWL6030_CFG_STATE_ON;
231 break;
232 case REGULATOR_MODE_STANDBY:
233 val |= TWL6030_CFG_STATE_SLEEP;
234 break;
235
236 default:
237 return -EINVAL;
238 }
239
240 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE, val);
241}
242
243static int twl6030coresmps_set_voltage(struct regulator_dev *rdev, int min_uV,
244 int max_uV, unsigned *selector)
245{
246 return -ENODEV;
247}
248
249static int twl6030coresmps_get_voltage(struct regulator_dev *rdev)
250{
251 return -ENODEV;
252}
253
254static const struct regulator_ops twl6030coresmps_ops = {
255 .set_voltage = twl6030coresmps_set_voltage,
256 .get_voltage = twl6030coresmps_get_voltage,
257};
258
259static int
260twl6030ldo_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
261{
262 struct twlreg_info *info = rdev_get_drvdata(rdev);
263
264 if (info->flags & TWL_6030_WARM_RESET)
265 selector |= TWL6030_VREG_VOLTAGE_WR_S;
266
267 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE,
268 selector);
269}
270
271static int twl6030ldo_get_voltage_sel(struct regulator_dev *rdev)
272{
273 struct twlreg_info *info = rdev_get_drvdata(rdev);
274 int vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE);
275
276 if (info->flags & TWL_6030_WARM_RESET)
277 vsel &= ~TWL6030_VREG_VOLTAGE_WR_S;
278
279 return vsel;
280}
281
282static const struct regulator_ops twl6030ldo_ops = {
283 .list_voltage = regulator_list_voltage_linear_range,
284
285 .set_voltage_sel = twl6030ldo_set_voltage_sel,
286 .get_voltage_sel = twl6030ldo_get_voltage_sel,
287
288 .enable = twl6030reg_enable,
289 .disable = twl6030reg_disable,
290 .is_enabled = twl6030reg_is_enabled,
291
292 .set_mode = twl6030reg_set_mode,
293
294 .get_status = twl6030reg_get_status,
295};
296
297static const struct regulator_ops twl6030fixed_ops = {
298 .list_voltage = regulator_list_voltage_linear,
299
300 .enable = twl6030reg_enable,
301 .disable = twl6030reg_disable,
302 .is_enabled = twl6030reg_is_enabled,
303
304 .set_mode = twl6030reg_set_mode,
305
306 .get_status = twl6030reg_get_status,
307};
308
309/*
310 * SMPS status and control
311 */
312
313static int twl6030smps_list_voltage(struct regulator_dev *rdev, unsigned index)
314{
315 struct twlreg_info *info = rdev_get_drvdata(rdev);
316
317 int voltage = 0;
318
319 switch (info->flags) {
320 case SMPS_OFFSET_EN:
321 voltage = 100000;
322 fallthrough;
323 case 0:
324 switch (index) {
325 case 0:
326 voltage = 0;
327 break;
328 case 58:
329 voltage = 1350 * 1000;
330 break;
331 case 59:
332 voltage = 1500 * 1000;
333 break;
334 case 60:
335 voltage = 1800 * 1000;
336 break;
337 case 61:
338 voltage = 1900 * 1000;
339 break;
340 case 62:
341 voltage = 2100 * 1000;
342 break;
343 default:
344 voltage += (600000 + (12500 * (index - 1)));
345 }
346 break;
347 case SMPS_EXTENDED_EN:
348 switch (index) {
349 case 0:
350 voltage = 0;
351 break;
352 case 58:
353 voltage = 2084 * 1000;
354 break;
355 case 59:
356 voltage = 2315 * 1000;
357 break;
358 case 60:
359 voltage = 2778 * 1000;
360 break;
361 case 61:
362 voltage = 2932 * 1000;
363 break;
364 case 62:
365 voltage = 3241 * 1000;
366 break;
367 default:
368 voltage = (1852000 + (38600 * (index - 1)));
369 }
370 break;
371 case SMPS_OFFSET_EN | SMPS_EXTENDED_EN:
372 switch (index) {
373 case 0:
374 voltage = 0;
375 break;
376 case 58:
377 voltage = 4167 * 1000;
378 break;
379 case 59:
380 voltage = 2315 * 1000;
381 break;
382 case 60:
383 voltage = 2778 * 1000;
384 break;
385 case 61:
386 voltage = 2932 * 1000;
387 break;
388 case 62:
389 voltage = 3241 * 1000;
390 break;
391 default:
392 voltage = (2161000 + (38600 * (index - 1)));
393 }
394 break;
395 }
396
397 return voltage;
398}
399
400static int twl6030smps_map_voltage(struct regulator_dev *rdev, int min_uV,
401 int max_uV)
402{
403 struct twlreg_info *info = rdev_get_drvdata(rdev);
404 int vsel = 0;
405
406 switch (info->flags) {
407 case 0:
408 if (min_uV == 0)
409 vsel = 0;
410 else if ((min_uV >= 600000) && (min_uV <= 1300000)) {
411 vsel = DIV_ROUND_UP(min_uV - 600000, 12500);
412 vsel++;
413 }
414 /* Values 1..57 for vsel are linear and can be calculated
415 * values 58..62 are non linear.
416 */
417 else if ((min_uV > 1900000) && (min_uV <= 2100000))
418 vsel = 62;
419 else if ((min_uV > 1800000) && (min_uV <= 1900000))
420 vsel = 61;
421 else if ((min_uV > 1500000) && (min_uV <= 1800000))
422 vsel = 60;
423 else if ((min_uV > 1350000) && (min_uV <= 1500000))
424 vsel = 59;
425 else if ((min_uV > 1300000) && (min_uV <= 1350000))
426 vsel = 58;
427 else
428 return -EINVAL;
429 break;
430 case SMPS_OFFSET_EN:
431 if (min_uV == 0)
432 vsel = 0;
433 else if ((min_uV >= 700000) && (min_uV <= 1420000)) {
434 vsel = DIV_ROUND_UP(min_uV - 700000, 12500);
435 vsel++;
436 }
437 /* Values 1..57 for vsel are linear and can be calculated
438 * values 58..62 are non linear.
439 */
440 else if ((min_uV > 1900000) && (min_uV <= 2100000))
441 vsel = 62;
442 else if ((min_uV > 1800000) && (min_uV <= 1900000))
443 vsel = 61;
444 else if ((min_uV > 1500000) && (min_uV <= 1800000))
445 vsel = 60;
446 else if ((min_uV > 1350000) && (min_uV <= 1500000))
447 vsel = 59;
448 else
449 return -EINVAL;
450 break;
451 case SMPS_EXTENDED_EN:
452 if (min_uV == 0) {
453 vsel = 0;
454 } else if ((min_uV >= 1852000) && (max_uV <= 4013600)) {
455 vsel = DIV_ROUND_UP(min_uV - 1852000, 38600);
456 vsel++;
457 }
458 break;
459 case SMPS_OFFSET_EN|SMPS_EXTENDED_EN:
460 if (min_uV == 0) {
461 vsel = 0;
462 } else if ((min_uV >= 2161000) && (min_uV <= 4321000)) {
463 vsel = DIV_ROUND_UP(min_uV - 2161000, 38600);
464 vsel++;
465 }
466 break;
467 }
468
469 return vsel;
470}
471
472static int twl6030smps_set_voltage_sel(struct regulator_dev *rdev,
473 unsigned int selector)
474{
475 struct twlreg_info *info = rdev_get_drvdata(rdev);
476
477 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE_SMPS,
478 selector);
479}
480
481static int twl6030smps_get_voltage_sel(struct regulator_dev *rdev)
482{
483 struct twlreg_info *info = rdev_get_drvdata(rdev);
484
485 return twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE_SMPS);
486}
487
488static const struct regulator_ops twlsmps_ops = {
489 .list_voltage = twl6030smps_list_voltage,
490 .map_voltage = twl6030smps_map_voltage,
491
492 .set_voltage_sel = twl6030smps_set_voltage_sel,
493 .get_voltage_sel = twl6030smps_get_voltage_sel,
494
495 .enable = twl6030reg_enable,
496 .disable = twl6030reg_disable,
497 .is_enabled = twl6030reg_is_enabled,
498
499 .set_mode = twl6030reg_set_mode,
500
501 .get_status = twl6030reg_get_status,
502};
503
504/*----------------------------------------------------------------------*/
505static const struct linear_range twl6030ldo_linear_range[] = {
506 REGULATOR_LINEAR_RANGE(0, 0, 0, 0),
507 REGULATOR_LINEAR_RANGE(1000000, 1, 24, 100000),
508 REGULATOR_LINEAR_RANGE(2750000, 31, 31, 0),
509};
510
511#define TWL6030_ADJUSTABLE_SMPS(label) \
512static const struct twlreg_info TWL6030_INFO_##label = { \
513 .desc = { \
514 .name = #label, \
515 .id = TWL6030_REG_##label, \
516 .ops = &twl6030coresmps_ops, \
517 .type = REGULATOR_VOLTAGE, \
518 .owner = THIS_MODULE, \
519 }, \
520 }
521
522#define TWL6030_ADJUSTABLE_LDO(label, offset) \
523static const struct twlreg_info TWL6030_INFO_##label = { \
524 .base = offset, \
525 .desc = { \
526 .name = #label, \
527 .id = TWL6030_REG_##label, \
528 .n_voltages = 32, \
529 .linear_ranges = twl6030ldo_linear_range, \
530 .n_linear_ranges = ARRAY_SIZE(twl6030ldo_linear_range), \
531 .ops = &twl6030ldo_ops, \
532 .type = REGULATOR_VOLTAGE, \
533 .owner = THIS_MODULE, \
534 }, \
535 }
536
537#define TWL6032_ADJUSTABLE_LDO(label, offset) \
538static const struct twlreg_info TWL6032_INFO_##label = { \
539 .base = offset, \
540 .features = TWL6032_SUBCLASS, \
541 .desc = { \
542 .name = #label, \
543 .id = TWL6032_REG_##label, \
544 .n_voltages = 32, \
545 .linear_ranges = twl6030ldo_linear_range, \
546 .n_linear_ranges = ARRAY_SIZE(twl6030ldo_linear_range), \
547 .ops = &twl6030ldo_ops, \
548 .type = REGULATOR_VOLTAGE, \
549 .owner = THIS_MODULE, \
550 }, \
551 }
552
553#define TWL6030_FIXED_LDO(label, offset, mVolts, turnon_delay) \
554static const struct twlreg_info TWLFIXED_INFO_##label = { \
555 .base = offset, \
556 .id = 0, \
557 .desc = { \
558 .name = #label, \
559 .id = TWL6030##_REG_##label, \
560 .n_voltages = 1, \
561 .ops = &twl6030fixed_ops, \
562 .type = REGULATOR_VOLTAGE, \
563 .owner = THIS_MODULE, \
564 .min_uV = mVolts * 1000, \
565 .enable_time = turnon_delay, \
566 .of_map_mode = NULL, \
567 }, \
568 }
569
570#define TWL6032_ADJUSTABLE_SMPS(label, offset) \
571static const struct twlreg_info TWLSMPS_INFO_##label = { \
572 .base = offset, \
573 .features = TWL6032_SUBCLASS, \
574 .desc = { \
575 .name = #label, \
576 .id = TWL6032_REG_##label, \
577 .n_voltages = 63, \
578 .ops = &twlsmps_ops, \
579 .type = REGULATOR_VOLTAGE, \
580 .owner = THIS_MODULE, \
581 }, \
582 }
583
584/* VUSBCP is managed *only* by the USB subchip */
585/* 6030 REG with base as PMC Slave Misc : 0x0030 */
586/* Turnon-delay and remap configuration values for 6030 are not
587 verified since the specification is not public */
588TWL6030_ADJUSTABLE_SMPS(VDD1);
589TWL6030_ADJUSTABLE_SMPS(VDD2);
590TWL6030_ADJUSTABLE_SMPS(VDD3);
591TWL6030_ADJUSTABLE_LDO(VAUX1_6030, 0x54);
592TWL6030_ADJUSTABLE_LDO(VAUX2_6030, 0x58);
593TWL6030_ADJUSTABLE_LDO(VAUX3_6030, 0x5c);
594TWL6030_ADJUSTABLE_LDO(VMMC, 0x68);
595TWL6030_ADJUSTABLE_LDO(VPP, 0x6c);
596TWL6030_ADJUSTABLE_LDO(VUSIM, 0x74);
597/* 6025 are renamed compared to 6030 versions */
598TWL6032_ADJUSTABLE_LDO(LDO2, 0x54);
599TWL6032_ADJUSTABLE_LDO(LDO4, 0x58);
600TWL6032_ADJUSTABLE_LDO(LDO3, 0x5c);
601TWL6032_ADJUSTABLE_LDO(LDO5, 0x68);
602TWL6032_ADJUSTABLE_LDO(LDO1, 0x6c);
603TWL6032_ADJUSTABLE_LDO(LDO7, 0x74);
604TWL6032_ADJUSTABLE_LDO(LDO6, 0x60);
605TWL6032_ADJUSTABLE_LDO(LDOLN, 0x64);
606TWL6032_ADJUSTABLE_LDO(LDOUSB, 0x70);
607TWL6030_FIXED_LDO(VANA, 0x50, 2100, 0);
608TWL6030_FIXED_LDO(VCXIO, 0x60, 1800, 0);
609TWL6030_FIXED_LDO(VDAC, 0x64, 1800, 0);
610TWL6030_FIXED_LDO(VUSB, 0x70, 3300, 0);
611TWL6030_FIXED_LDO(V1V8, 0x16, 1800, 0);
612TWL6030_FIXED_LDO(V2V1, 0x1c, 2100, 0);
613TWL6032_ADJUSTABLE_SMPS(SMPS3, 0x34);
614TWL6032_ADJUSTABLE_SMPS(SMPS4, 0x10);
615TWL6032_ADJUSTABLE_SMPS(VIO, 0x16);
616
617static u8 twl_get_smps_offset(void)
618{
619 u8 value;
620
621 twl_i2c_read_u8(TWL_MODULE_PM_RECEIVER, &value,
622 TWL6030_SMPS_OFFSET);
623 return value;
624}
625
626static u8 twl_get_smps_mult(void)
627{
628 u8 value;
629
630 twl_i2c_read_u8(TWL_MODULE_PM_RECEIVER, &value,
631 TWL6030_SMPS_MULT);
632 return value;
633}
634
635#define TWL_OF_MATCH(comp, family, label) \
636 { \
637 .compatible = comp, \
638 .data = &family##_INFO_##label, \
639 }
640
641#define TWL6030_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL6030, label)
642#define TWL6032_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL6032, label)
643#define TWLFIXED_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLFIXED, label)
644#define TWLSMPS_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLSMPS, label)
645
646static const struct of_device_id twl_of_match[] = {
647 TWL6030_OF_MATCH("ti,twl6030-vdd1", VDD1),
648 TWL6030_OF_MATCH("ti,twl6030-vdd2", VDD2),
649 TWL6030_OF_MATCH("ti,twl6030-vdd3", VDD3),
650 TWL6030_OF_MATCH("ti,twl6030-vaux1", VAUX1_6030),
651 TWL6030_OF_MATCH("ti,twl6030-vaux2", VAUX2_6030),
652 TWL6030_OF_MATCH("ti,twl6030-vaux3", VAUX3_6030),
653 TWL6030_OF_MATCH("ti,twl6030-vmmc", VMMC),
654 TWL6030_OF_MATCH("ti,twl6030-vpp", VPP),
655 TWL6030_OF_MATCH("ti,twl6030-vusim", VUSIM),
656 TWL6032_OF_MATCH("ti,twl6032-ldo2", LDO2),
657 TWL6032_OF_MATCH("ti,twl6032-ldo4", LDO4),
658 TWL6032_OF_MATCH("ti,twl6032-ldo3", LDO3),
659 TWL6032_OF_MATCH("ti,twl6032-ldo5", LDO5),
660 TWL6032_OF_MATCH("ti,twl6032-ldo1", LDO1),
661 TWL6032_OF_MATCH("ti,twl6032-ldo7", LDO7),
662 TWL6032_OF_MATCH("ti,twl6032-ldo6", LDO6),
663 TWL6032_OF_MATCH("ti,twl6032-ldoln", LDOLN),
664 TWL6032_OF_MATCH("ti,twl6032-ldousb", LDOUSB),
665 TWLFIXED_OF_MATCH("ti,twl6030-vana", VANA),
666 TWLFIXED_OF_MATCH("ti,twl6030-vcxio", VCXIO),
667 TWLFIXED_OF_MATCH("ti,twl6030-vdac", VDAC),
668 TWLFIXED_OF_MATCH("ti,twl6030-vusb", VUSB),
669 TWLFIXED_OF_MATCH("ti,twl6030-v1v8", V1V8),
670 TWLFIXED_OF_MATCH("ti,twl6030-v2v1", V2V1),
671 TWLSMPS_OF_MATCH("ti,twl6032-smps3", SMPS3),
672 TWLSMPS_OF_MATCH("ti,twl6032-smps4", SMPS4),
673 TWLSMPS_OF_MATCH("ti,twl6032-vio", VIO),
674 {},
675};
676MODULE_DEVICE_TABLE(of, twl_of_match);
677
678static int twlreg_probe(struct platform_device *pdev)
679{
680 int id;
681 struct twlreg_info *info;
682 const struct twlreg_info *template;
683 struct regulator_init_data *initdata;
684 struct regulation_constraints *c;
685 struct regulator_dev *rdev;
686 struct regulator_config config = { };
687 struct device_node *np = pdev->dev.of_node;
688
689 template = of_device_get_match_data(&pdev->dev);
690 if (!template)
691 return -ENODEV;
692
693 id = template->desc.id;
694 initdata = of_get_regulator_init_data(&pdev->dev, np, &template->desc);
695 if (!initdata)
696 return -EINVAL;
697
698 info = devm_kmemdup(&pdev->dev, template, sizeof(*info), GFP_KERNEL);
699 if (!info)
700 return -ENOMEM;
701
702 /* Constrain board-specific capabilities according to what
703 * this driver and the chip itself can actually do.
704 */
705 c = &initdata->constraints;
706 c->valid_modes_mask &= REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY;
707 c->valid_ops_mask &= REGULATOR_CHANGE_VOLTAGE
708 | REGULATOR_CHANGE_MODE
709 | REGULATOR_CHANGE_STATUS;
710
711 switch (id) {
712 case TWL6032_REG_SMPS3:
713 if (twl_get_smps_mult() & SMPS_MULTOFFSET_SMPS3)
714 info->flags |= SMPS_EXTENDED_EN;
715 if (twl_get_smps_offset() & SMPS_MULTOFFSET_SMPS3)
716 info->flags |= SMPS_OFFSET_EN;
717 break;
718 case TWL6032_REG_SMPS4:
719 if (twl_get_smps_mult() & SMPS_MULTOFFSET_SMPS4)
720 info->flags |= SMPS_EXTENDED_EN;
721 if (twl_get_smps_offset() & SMPS_MULTOFFSET_SMPS4)
722 info->flags |= SMPS_OFFSET_EN;
723 break;
724 case TWL6032_REG_VIO:
725 if (twl_get_smps_mult() & SMPS_MULTOFFSET_VIO)
726 info->flags |= SMPS_EXTENDED_EN;
727 if (twl_get_smps_offset() & SMPS_MULTOFFSET_VIO)
728 info->flags |= SMPS_OFFSET_EN;
729 break;
730 }
731
732 if (of_get_property(np, "ti,retain-on-reset", NULL))
733 info->flags |= TWL_6030_WARM_RESET;
734
735 config.dev = &pdev->dev;
736 config.init_data = initdata;
737 config.driver_data = info;
738 config.of_node = np;
739
740 rdev = devm_regulator_register(&pdev->dev, &info->desc, &config);
741 if (IS_ERR(rdev)) {
742 dev_err(&pdev->dev, "can't register %s, %ld\n",
743 info->desc.name, PTR_ERR(rdev));
744 return PTR_ERR(rdev);
745 }
746 platform_set_drvdata(pdev, rdev);
747
748 /* NOTE: many regulators support short-circuit IRQs (presentable
749 * as REGULATOR_OVER_CURRENT notifications?) configured via:
750 * - SC_CONFIG
751 * - SC_DETECT1 (vintana2, vmmc1/2, vaux1/2/3/4)
752 * - SC_DETECT2 (vusb, vdac, vio, vdd1/2, vpll2)
753 * - IT_CONFIG
754 */
755
756 return 0;
757}
758
759MODULE_ALIAS("platform:twl6030_reg");
760
761static struct platform_driver twlreg_driver = {
762 .probe = twlreg_probe,
763 /* NOTE: short name, to work around driver model truncation of
764 * "twl_regulator.12" (and friends) to "twl_regulator.1".
765 */
766 .driver = {
767 .name = "twl6030_reg",
768 .of_match_table = of_match_ptr(twl_of_match),
769 },
770};
771
772static int __init twlreg_init(void)
773{
774 return platform_driver_register(&twlreg_driver);
775}
776subsys_initcall(twlreg_init);
777
778static void __exit twlreg_exit(void)
779{
780 platform_driver_unregister(&twlreg_driver);
781}
782module_exit(twlreg_exit)
783
784MODULE_DESCRIPTION("TWL6030 regulator driver");
785MODULE_LICENSE("GPL");