]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/regulator/twl-regulator.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
regulator: twl: kill unused functions
[mirror_ubuntu-artful-kernel.git] / drivers / regulator / twl-regulator.c
1 /*
2 * twl-regulator.c -- support regulators in twl4030/twl6030 family chips
3 *
4 * Copyright (C) 2008 David Brownell
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 */
11
12 #include <linux/module.h>
13 #include <linux/string.h>
14 #include <linux/slab.h>
15 #include <linux/init.h>
16 #include <linux/err.h>
17 #include <linux/platform_device.h>
18 #include <linux/of.h>
19 #include <linux/of_device.h>
20 #include <linux/regulator/driver.h>
21 #include <linux/regulator/machine.h>
22 #include <linux/regulator/of_regulator.h>
23 #include <linux/i2c/twl.h>
24 #include <linux/delay.h>
25
26 /*
27 * The TWL4030/TW5030/TPS659x0/TWL6030 family chips include power management, a
28 * USB OTG transceiver, an RTC, ADC, PWM, and lots more. Some versions
29 * include an audio codec, battery charger, and more voltage regulators.
30 * These chips are often used in OMAP-based systems.
31 *
32 * This driver implements software-based resource control for various
33 * voltage regulators. This is usually augmented with state machine
34 * based control.
35 */
36
37 struct twlreg_info {
38 /* start of regulator's PM_RECEIVER control register bank */
39 u8 base;
40
41 /* twl resource ID, for resource control state machine */
42 u8 id;
43
44 /* voltage in mV = table[VSEL]; table_len must be a power-of-two */
45 u8 table_len;
46 const u16 *table;
47
48 /* State REMAP default configuration */
49 u8 remap;
50
51 /* chip constraints on regulator behavior */
52 u16 min_mV;
53 u16 max_mV;
54
55 u8 flags;
56
57 /* used by regulator core */
58 struct regulator_desc desc;
59
60 /* chip specific features */
61 unsigned long features;
62
63 /* data passed from board for external get/set voltage */
64 void *data;
65 };
66
67
68 /* LDO control registers ... offset is from the base of its register bank.
69 * The first three registers of all power resource banks help hardware to
70 * manage the various resource groups.
71 */
72 /* Common offset in TWL4030/6030 */
73 #define VREG_GRP 0
74 /* TWL4030 register offsets */
75 #define VREG_TYPE 1
76 #define VREG_REMAP 2
77 #define VREG_DEDICATED 3 /* LDO control */
78 #define VREG_VOLTAGE_SMPS_4030 9
79 /* TWL6030 register offsets */
80 #define VREG_TRANS 1
81 #define VREG_STATE 2
82 #define VREG_VOLTAGE 3
83 #define VREG_VOLTAGE_SMPS 4
84 /* TWL6030 Misc register offsets */
85 #define VREG_BC_ALL 1
86 #define VREG_BC_REF 2
87 #define VREG_BC_PROC 3
88 #define VREG_BC_CLK_RST 4
89
90 /* TWL6030 LDO register values for CFG_STATE */
91 #define TWL6030_CFG_STATE_OFF 0x00
92 #define TWL6030_CFG_STATE_ON 0x01
93 #define TWL6030_CFG_STATE_OFF2 0x02
94 #define TWL6030_CFG_STATE_SLEEP 0x03
95 #define TWL6030_CFG_STATE_GRP_SHIFT 5
96 #define TWL6030_CFG_STATE_APP_SHIFT 2
97 #define TWL6030_CFG_STATE_APP_MASK (0x03 << TWL6030_CFG_STATE_APP_SHIFT)
98 #define TWL6030_CFG_STATE_APP(v) (((v) & TWL6030_CFG_STATE_APP_MASK) >>\
99 TWL6030_CFG_STATE_APP_SHIFT)
100
101 /* Flags for SMPS Voltage reading */
102 #define SMPS_OFFSET_EN BIT(0)
103 #define SMPS_EXTENDED_EN BIT(1)
104
105 /* twl6032 SMPS EPROM values */
106 #define TWL6030_SMPS_OFFSET 0xB0
107 #define TWL6030_SMPS_MULT 0xB3
108 #define SMPS_MULTOFFSET_SMPS4 BIT(0)
109 #define SMPS_MULTOFFSET_VIO BIT(1)
110 #define SMPS_MULTOFFSET_SMPS3 BIT(6)
111
112 static inline int
113 twlreg_read(struct twlreg_info *info, unsigned slave_subgp, unsigned offset)
114 {
115 u8 value;
116 int status;
117
118 status = twl_i2c_read_u8(slave_subgp,
119 &value, info->base + offset);
120 return (status < 0) ? status : value;
121 }
122
123 static inline int
124 twlreg_write(struct twlreg_info *info, unsigned slave_subgp, unsigned offset,
125 u8 value)
126 {
127 return twl_i2c_write_u8(slave_subgp,
128 value, info->base + offset);
129 }
130
131 /*----------------------------------------------------------------------*/
132
133 /* generic power resource operations, which work on all regulators */
134
135 static int twlreg_grp(struct regulator_dev *rdev)
136 {
137 return twlreg_read(rdev_get_drvdata(rdev), TWL_MODULE_PM_RECEIVER,
138 VREG_GRP);
139 }
140
141 /*
142 * Enable/disable regulators by joining/leaving the P1 (processor) group.
143 * We assume nobody else is updating the DEV_GRP registers.
144 */
145 /* definition for 4030 family */
146 #define P3_GRP_4030 BIT(7) /* "peripherals" */
147 #define P2_GRP_4030 BIT(6) /* secondary processor, modem, etc */
148 #define P1_GRP_4030 BIT(5) /* CPU/Linux */
149 /* definition for 6030 family */
150 #define P3_GRP_6030 BIT(2) /* secondary processor, modem, etc */
151 #define P2_GRP_6030 BIT(1) /* "peripherals" */
152 #define P1_GRP_6030 BIT(0) /* CPU/Linux */
153
154 static int twl4030reg_is_enabled(struct regulator_dev *rdev)
155 {
156 int state = twlreg_grp(rdev);
157
158 if (state < 0)
159 return state;
160
161 return state & P1_GRP_4030;
162 }
163
164 static int twl6030reg_is_enabled(struct regulator_dev *rdev)
165 {
166 struct twlreg_info *info = rdev_get_drvdata(rdev);
167 int grp = 0, val;
168
169 if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS))) {
170 grp = twlreg_grp(rdev);
171 if (grp < 0)
172 return grp;
173 grp &= P1_GRP_6030;
174 } else {
175 grp = 1;
176 }
177
178 val = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_STATE);
179 val = TWL6030_CFG_STATE_APP(val);
180
181 return grp && (val == TWL6030_CFG_STATE_ON);
182 }
183
184 #define PB_I2C_BUSY BIT(0)
185 #define PB_I2C_BWEN BIT(1)
186
187 /* Wait until buffer empty/ready to send a word on power bus. */
188 static int twl4030_wait_pb_ready(void)
189 {
190
191 int ret;
192 int timeout = 10;
193 u8 val;
194
195 do {
196 ret = twl_i2c_read_u8(TWL_MODULE_PM_MASTER, &val,
197 TWL4030_PM_MASTER_PB_CFG);
198 if (ret < 0)
199 return ret;
200
201 if (!(val & PB_I2C_BUSY))
202 return 0;
203
204 mdelay(1);
205 timeout--;
206 } while (timeout);
207
208 return -ETIMEDOUT;
209 }
210
211 /* Send a word over the powerbus */
212 static int twl4030_send_pb_msg(unsigned msg)
213 {
214 u8 val;
215 int ret;
216
217 /* save powerbus configuration */
218 ret = twl_i2c_read_u8(TWL_MODULE_PM_MASTER, &val,
219 TWL4030_PM_MASTER_PB_CFG);
220 if (ret < 0)
221 return ret;
222
223 /* Enable i2c access to powerbus */
224 ret = twl_i2c_write_u8(TWL_MODULE_PM_MASTER, val | PB_I2C_BWEN,
225 TWL4030_PM_MASTER_PB_CFG);
226 if (ret < 0)
227 return ret;
228
229 ret = twl4030_wait_pb_ready();
230 if (ret < 0)
231 return ret;
232
233 ret = twl_i2c_write_u8(TWL_MODULE_PM_MASTER, msg >> 8,
234 TWL4030_PM_MASTER_PB_WORD_MSB);
235 if (ret < 0)
236 return ret;
237
238 ret = twl_i2c_write_u8(TWL_MODULE_PM_MASTER, msg & 0xff,
239 TWL4030_PM_MASTER_PB_WORD_LSB);
240 if (ret < 0)
241 return ret;
242
243 ret = twl4030_wait_pb_ready();
244 if (ret < 0)
245 return ret;
246
247 /* Restore powerbus configuration */
248 return twl_i2c_write_u8(TWL_MODULE_PM_MASTER, val,
249 TWL4030_PM_MASTER_PB_CFG);
250 }
251
252 static int twl4030reg_enable(struct regulator_dev *rdev)
253 {
254 struct twlreg_info *info = rdev_get_drvdata(rdev);
255 int grp;
256 int ret;
257
258 grp = twlreg_grp(rdev);
259 if (grp < 0)
260 return grp;
261
262 grp |= P1_GRP_4030;
263
264 ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_GRP, grp);
265
266 return ret;
267 }
268
269 static int twl6030reg_enable(struct regulator_dev *rdev)
270 {
271 struct twlreg_info *info = rdev_get_drvdata(rdev);
272 int grp = 0;
273 int ret;
274
275 if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))
276 grp = twlreg_grp(rdev);
277 if (grp < 0)
278 return grp;
279
280 ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,
281 grp << TWL6030_CFG_STATE_GRP_SHIFT |
282 TWL6030_CFG_STATE_ON);
283 return ret;
284 }
285
286 static int twl4030reg_disable(struct regulator_dev *rdev)
287 {
288 struct twlreg_info *info = rdev_get_drvdata(rdev);
289 int grp;
290 int ret;
291
292 grp = twlreg_grp(rdev);
293 if (grp < 0)
294 return grp;
295
296 grp &= ~(P1_GRP_4030 | P2_GRP_4030 | P3_GRP_4030);
297
298 ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_GRP, grp);
299
300 return ret;
301 }
302
303 static int twl6030reg_disable(struct regulator_dev *rdev)
304 {
305 struct twlreg_info *info = rdev_get_drvdata(rdev);
306 int grp = 0;
307 int ret;
308
309 if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))
310 grp = P1_GRP_6030 | P2_GRP_6030 | P3_GRP_6030;
311
312 /* For 6030, set the off state for all grps enabled */
313 ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,
314 (grp) << TWL6030_CFG_STATE_GRP_SHIFT |
315 TWL6030_CFG_STATE_OFF);
316
317 return ret;
318 }
319
320 static int twl4030reg_get_status(struct regulator_dev *rdev)
321 {
322 int state = twlreg_grp(rdev);
323
324 if (state < 0)
325 return state;
326 state &= 0x0f;
327
328 /* assume state != WARM_RESET; we'd not be running... */
329 if (!state)
330 return REGULATOR_STATUS_OFF;
331 return (state & BIT(3))
332 ? REGULATOR_STATUS_NORMAL
333 : REGULATOR_STATUS_STANDBY;
334 }
335
336 static int twl6030reg_get_status(struct regulator_dev *rdev)
337 {
338 struct twlreg_info *info = rdev_get_drvdata(rdev);
339 int val;
340
341 val = twlreg_grp(rdev);
342 if (val < 0)
343 return val;
344
345 val = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_STATE);
346
347 switch (TWL6030_CFG_STATE_APP(val)) {
348 case TWL6030_CFG_STATE_ON:
349 return REGULATOR_STATUS_NORMAL;
350
351 case TWL6030_CFG_STATE_SLEEP:
352 return REGULATOR_STATUS_STANDBY;
353
354 case TWL6030_CFG_STATE_OFF:
355 case TWL6030_CFG_STATE_OFF2:
356 default:
357 break;
358 }
359
360 return REGULATOR_STATUS_OFF;
361 }
362
363 static int twl4030reg_set_mode(struct regulator_dev *rdev, unsigned mode)
364 {
365 struct twlreg_info *info = rdev_get_drvdata(rdev);
366 unsigned message;
367
368 /* We can only set the mode through state machine commands... */
369 switch (mode) {
370 case REGULATOR_MODE_NORMAL:
371 message = MSG_SINGULAR(DEV_GRP_P1, info->id, RES_STATE_ACTIVE);
372 break;
373 case REGULATOR_MODE_STANDBY:
374 message = MSG_SINGULAR(DEV_GRP_P1, info->id, RES_STATE_SLEEP);
375 break;
376 default:
377 return -EINVAL;
378 }
379
380 return twl4030_send_pb_msg(message);
381 }
382
383 static inline unsigned int twl4030reg_map_mode(unsigned int mode)
384 {
385 switch (mode) {
386 case RES_STATE_ACTIVE:
387 return REGULATOR_MODE_NORMAL;
388 case RES_STATE_SLEEP:
389 return REGULATOR_MODE_STANDBY;
390 default:
391 return -EINVAL;
392 }
393 }
394
395 static int twl6030reg_set_mode(struct regulator_dev *rdev, unsigned mode)
396 {
397 struct twlreg_info *info = rdev_get_drvdata(rdev);
398 int grp = 0;
399 int val;
400
401 if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))
402 grp = twlreg_grp(rdev);
403
404 if (grp < 0)
405 return grp;
406
407 /* Compose the state register settings */
408 val = grp << TWL6030_CFG_STATE_GRP_SHIFT;
409 /* We can only set the mode through state machine commands... */
410 switch (mode) {
411 case REGULATOR_MODE_NORMAL:
412 val |= TWL6030_CFG_STATE_ON;
413 break;
414 case REGULATOR_MODE_STANDBY:
415 val |= TWL6030_CFG_STATE_SLEEP;
416 break;
417
418 default:
419 return -EINVAL;
420 }
421
422 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE, val);
423 }
424
425 /*----------------------------------------------------------------------*/
426
427 /*
428 * Support for adjustable-voltage LDOs uses a four bit (or less) voltage
429 * select field in its control register. We use tables indexed by VSEL
430 * to record voltages in milliVolts. (Accuracy is about three percent.)
431 *
432 * Note that VSEL values for VAUX2 changed in twl5030 and newer silicon;
433 * currently handled by listing two slightly different VAUX2 regulators,
434 * only one of which will be configured.
435 *
436 * VSEL values documented as "TI cannot support these values" are flagged
437 * in these tables as UNSUP() values; we normally won't assign them.
438 *
439 * VAUX3 at 3V is incorrectly listed in some TI manuals as unsupported.
440 * TI are revising the twl5030/tps659x0 specs to support that 3.0V setting.
441 */
442 #define UNSUP_MASK 0x8000
443
444 #define UNSUP(x) (UNSUP_MASK | (x))
445 #define IS_UNSUP(info, x) \
446 ((UNSUP_MASK & (x)) && \
447 !((info)->features & TWL4030_ALLOW_UNSUPPORTED))
448 #define LDO_MV(x) (~UNSUP_MASK & (x))
449
450
451 static const u16 VAUX1_VSEL_table[] = {
452 UNSUP(1500), UNSUP(1800), 2500, 2800,
453 3000, 3000, 3000, 3000,
454 };
455 static const u16 VAUX2_4030_VSEL_table[] = {
456 UNSUP(1000), UNSUP(1000), UNSUP(1200), 1300,
457 1500, 1800, UNSUP(1850), 2500,
458 UNSUP(2600), 2800, UNSUP(2850), UNSUP(3000),
459 UNSUP(3150), UNSUP(3150), UNSUP(3150), UNSUP(3150),
460 };
461 static const u16 VAUX2_VSEL_table[] = {
462 1700, 1700, 1900, 1300,
463 1500, 1800, 2000, 2500,
464 2100, 2800, 2200, 2300,
465 2400, 2400, 2400, 2400,
466 };
467 static const u16 VAUX3_VSEL_table[] = {
468 1500, 1800, 2500, 2800,
469 3000, 3000, 3000, 3000,
470 };
471 static const u16 VAUX4_VSEL_table[] = {
472 700, 1000, 1200, UNSUP(1300),
473 1500, 1800, UNSUP(1850), 2500,
474 UNSUP(2600), 2800, UNSUP(2850), UNSUP(3000),
475 UNSUP(3150), UNSUP(3150), UNSUP(3150), UNSUP(3150),
476 };
477 static const u16 VMMC1_VSEL_table[] = {
478 1850, 2850, 3000, 3150,
479 };
480 static const u16 VMMC2_VSEL_table[] = {
481 UNSUP(1000), UNSUP(1000), UNSUP(1200), UNSUP(1300),
482 UNSUP(1500), UNSUP(1800), 1850, UNSUP(2500),
483 2600, 2800, 2850, 3000,
484 3150, 3150, 3150, 3150,
485 };
486 static const u16 VPLL1_VSEL_table[] = {
487 1000, 1200, 1300, 1800,
488 UNSUP(2800), UNSUP(3000), UNSUP(3000), UNSUP(3000),
489 };
490 static const u16 VPLL2_VSEL_table[] = {
491 700, 1000, 1200, 1300,
492 UNSUP(1500), 1800, UNSUP(1850), UNSUP(2500),
493 UNSUP(2600), UNSUP(2800), UNSUP(2850), UNSUP(3000),
494 UNSUP(3150), UNSUP(3150), UNSUP(3150), UNSUP(3150),
495 };
496 static const u16 VSIM_VSEL_table[] = {
497 UNSUP(1000), UNSUP(1200), UNSUP(1300), 1800,
498 2800, 3000, 3000, 3000,
499 };
500 static const u16 VDAC_VSEL_table[] = {
501 1200, 1300, 1800, 1800,
502 };
503 static const u16 VIO_VSEL_table[] = {
504 1800, 1850,
505 };
506 static const u16 VINTANA2_VSEL_table[] = {
507 2500, 2750,
508 };
509
510 static int twl4030ldo_list_voltage(struct regulator_dev *rdev, unsigned index)
511 {
512 struct twlreg_info *info = rdev_get_drvdata(rdev);
513 int mV = info->table[index];
514
515 return IS_UNSUP(info, mV) ? 0 : (LDO_MV(mV) * 1000);
516 }
517
518 static int
519 twl4030ldo_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
520 {
521 struct twlreg_info *info = rdev_get_drvdata(rdev);
522
523 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE,
524 selector);
525 }
526
527 static int twl4030ldo_get_voltage_sel(struct regulator_dev *rdev)
528 {
529 struct twlreg_info *info = rdev_get_drvdata(rdev);
530 int vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE);
531
532 if (vsel < 0)
533 return vsel;
534
535 vsel &= info->table_len - 1;
536 return vsel;
537 }
538
539 static struct regulator_ops twl4030ldo_ops = {
540 .list_voltage = twl4030ldo_list_voltage,
541
542 .set_voltage_sel = twl4030ldo_set_voltage_sel,
543 .get_voltage_sel = twl4030ldo_get_voltage_sel,
544
545 .enable = twl4030reg_enable,
546 .disable = twl4030reg_disable,
547 .is_enabled = twl4030reg_is_enabled,
548
549 .set_mode = twl4030reg_set_mode,
550
551 .get_status = twl4030reg_get_status,
552 };
553
554 static int
555 twl4030smps_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
556 unsigned *selector)
557 {
558 struct twlreg_info *info = rdev_get_drvdata(rdev);
559 int vsel = DIV_ROUND_UP(min_uV - 600000, 12500);
560
561 twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE_SMPS_4030, vsel);
562
563 return 0;
564 }
565
566 static int twl4030smps_get_voltage(struct regulator_dev *rdev)
567 {
568 struct twlreg_info *info = rdev_get_drvdata(rdev);
569 int vsel;
570
571 vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER,
572 VREG_VOLTAGE_SMPS_4030);
573
574 return vsel * 12500 + 600000;
575 }
576
577 static struct regulator_ops twl4030smps_ops = {
578 .set_voltage = twl4030smps_set_voltage,
579 .get_voltage = twl4030smps_get_voltage,
580 };
581
582 static int twl6030coresmps_set_voltage(struct regulator_dev *rdev, int min_uV,
583 int max_uV, unsigned *selector)
584 {
585 return -ENODEV;
586 }
587
588 static int twl6030coresmps_get_voltage(struct regulator_dev *rdev)
589 {
590 return -ENODEV;
591 }
592
593 static struct regulator_ops twl6030coresmps_ops = {
594 .set_voltage = twl6030coresmps_set_voltage,
595 .get_voltage = twl6030coresmps_get_voltage,
596 };
597
598 static int twl6030ldo_list_voltage(struct regulator_dev *rdev, unsigned sel)
599 {
600 struct twlreg_info *info = rdev_get_drvdata(rdev);
601
602 switch (sel) {
603 case 0:
604 return 0;
605 case 1 ... 24:
606 /* Linear mapping from 00000001 to 00011000:
607 * Absolute voltage value = 1.0 V + 0.1 V × (sel – 00000001)
608 */
609 return (info->min_mV + 100 * (sel - 1)) * 1000;
610 case 25 ... 30:
611 return -EINVAL;
612 case 31:
613 return 2750000;
614 default:
615 return -EINVAL;
616 }
617 }
618
619 static int
620 twl6030ldo_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
621 {
622 struct twlreg_info *info = rdev_get_drvdata(rdev);
623
624 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE,
625 selector);
626 }
627
628 static int twl6030ldo_get_voltage_sel(struct regulator_dev *rdev)
629 {
630 struct twlreg_info *info = rdev_get_drvdata(rdev);
631 int vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE);
632
633 return vsel;
634 }
635
636 static struct regulator_ops twl6030ldo_ops = {
637 .list_voltage = twl6030ldo_list_voltage,
638
639 .set_voltage_sel = twl6030ldo_set_voltage_sel,
640 .get_voltage_sel = twl6030ldo_get_voltage_sel,
641
642 .enable = twl6030reg_enable,
643 .disable = twl6030reg_disable,
644 .is_enabled = twl6030reg_is_enabled,
645
646 .set_mode = twl6030reg_set_mode,
647
648 .get_status = twl6030reg_get_status,
649 };
650
651 /*----------------------------------------------------------------------*/
652
653 static struct regulator_ops twl4030fixed_ops = {
654 .list_voltage = regulator_list_voltage_linear,
655
656 .enable = twl4030reg_enable,
657 .disable = twl4030reg_disable,
658 .is_enabled = twl4030reg_is_enabled,
659
660 .set_mode = twl4030reg_set_mode,
661
662 .get_status = twl4030reg_get_status,
663 };
664
665 static struct regulator_ops twl6030fixed_ops = {
666 .list_voltage = regulator_list_voltage_linear,
667
668 .enable = twl6030reg_enable,
669 .disable = twl6030reg_disable,
670 .is_enabled = twl6030reg_is_enabled,
671
672 .set_mode = twl6030reg_set_mode,
673
674 .get_status = twl6030reg_get_status,
675 };
676
677 /*
678 * SMPS status and control
679 */
680
681 static int twl6030smps_list_voltage(struct regulator_dev *rdev, unsigned index)
682 {
683 struct twlreg_info *info = rdev_get_drvdata(rdev);
684
685 int voltage = 0;
686
687 switch (info->flags) {
688 case SMPS_OFFSET_EN:
689 voltage = 100000;
690 /* fall through */
691 case 0:
692 switch (index) {
693 case 0:
694 voltage = 0;
695 break;
696 case 58:
697 voltage = 1350 * 1000;
698 break;
699 case 59:
700 voltage = 1500 * 1000;
701 break;
702 case 60:
703 voltage = 1800 * 1000;
704 break;
705 case 61:
706 voltage = 1900 * 1000;
707 break;
708 case 62:
709 voltage = 2100 * 1000;
710 break;
711 default:
712 voltage += (600000 + (12500 * (index - 1)));
713 }
714 break;
715 case SMPS_EXTENDED_EN:
716 switch (index) {
717 case 0:
718 voltage = 0;
719 break;
720 case 58:
721 voltage = 2084 * 1000;
722 break;
723 case 59:
724 voltage = 2315 * 1000;
725 break;
726 case 60:
727 voltage = 2778 * 1000;
728 break;
729 case 61:
730 voltage = 2932 * 1000;
731 break;
732 case 62:
733 voltage = 3241 * 1000;
734 break;
735 default:
736 voltage = (1852000 + (38600 * (index - 1)));
737 }
738 break;
739 case SMPS_OFFSET_EN | SMPS_EXTENDED_EN:
740 switch (index) {
741 case 0:
742 voltage = 0;
743 break;
744 case 58:
745 voltage = 4167 * 1000;
746 break;
747 case 59:
748 voltage = 2315 * 1000;
749 break;
750 case 60:
751 voltage = 2778 * 1000;
752 break;
753 case 61:
754 voltage = 2932 * 1000;
755 break;
756 case 62:
757 voltage = 3241 * 1000;
758 break;
759 default:
760 voltage = (2161000 + (38600 * (index - 1)));
761 }
762 break;
763 }
764
765 return voltage;
766 }
767
768 static int twl6030smps_map_voltage(struct regulator_dev *rdev, int min_uV,
769 int max_uV)
770 {
771 struct twlreg_info *info = rdev_get_drvdata(rdev);
772 int vsel = 0;
773
774 switch (info->flags) {
775 case 0:
776 if (min_uV == 0)
777 vsel = 0;
778 else if ((min_uV >= 600000) && (min_uV <= 1300000)) {
779 vsel = DIV_ROUND_UP(min_uV - 600000, 12500);
780 vsel++;
781 }
782 /* Values 1..57 for vsel are linear and can be calculated
783 * values 58..62 are non linear.
784 */
785 else if ((min_uV > 1900000) && (min_uV <= 2100000))
786 vsel = 62;
787 else if ((min_uV > 1800000) && (min_uV <= 1900000))
788 vsel = 61;
789 else if ((min_uV > 1500000) && (min_uV <= 1800000))
790 vsel = 60;
791 else if ((min_uV > 1350000) && (min_uV <= 1500000))
792 vsel = 59;
793 else if ((min_uV > 1300000) && (min_uV <= 1350000))
794 vsel = 58;
795 else
796 return -EINVAL;
797 break;
798 case SMPS_OFFSET_EN:
799 if (min_uV == 0)
800 vsel = 0;
801 else if ((min_uV >= 700000) && (min_uV <= 1420000)) {
802 vsel = DIV_ROUND_UP(min_uV - 700000, 12500);
803 vsel++;
804 }
805 /* Values 1..57 for vsel are linear and can be calculated
806 * values 58..62 are non linear.
807 */
808 else if ((min_uV > 1900000) && (min_uV <= 2100000))
809 vsel = 62;
810 else if ((min_uV > 1800000) && (min_uV <= 1900000))
811 vsel = 61;
812 else if ((min_uV > 1350000) && (min_uV <= 1800000))
813 vsel = 60;
814 else if ((min_uV > 1350000) && (min_uV <= 1500000))
815 vsel = 59;
816 else if ((min_uV > 1300000) && (min_uV <= 1350000))
817 vsel = 58;
818 else
819 return -EINVAL;
820 break;
821 case SMPS_EXTENDED_EN:
822 if (min_uV == 0) {
823 vsel = 0;
824 } else if ((min_uV >= 1852000) && (max_uV <= 4013600)) {
825 vsel = DIV_ROUND_UP(min_uV - 1852000, 38600);
826 vsel++;
827 }
828 break;
829 case SMPS_OFFSET_EN|SMPS_EXTENDED_EN:
830 if (min_uV == 0) {
831 vsel = 0;
832 } else if ((min_uV >= 2161000) && (min_uV <= 4321000)) {
833 vsel = DIV_ROUND_UP(min_uV - 2161000, 38600);
834 vsel++;
835 }
836 break;
837 }
838
839 return vsel;
840 }
841
842 static int twl6030smps_set_voltage_sel(struct regulator_dev *rdev,
843 unsigned int selector)
844 {
845 struct twlreg_info *info = rdev_get_drvdata(rdev);
846
847 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE_SMPS,
848 selector);
849 }
850
851 static int twl6030smps_get_voltage_sel(struct regulator_dev *rdev)
852 {
853 struct twlreg_info *info = rdev_get_drvdata(rdev);
854
855 return twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE_SMPS);
856 }
857
858 static struct regulator_ops twlsmps_ops = {
859 .list_voltage = twl6030smps_list_voltage,
860 .map_voltage = twl6030smps_map_voltage,
861
862 .set_voltage_sel = twl6030smps_set_voltage_sel,
863 .get_voltage_sel = twl6030smps_get_voltage_sel,
864
865 .enable = twl6030reg_enable,
866 .disable = twl6030reg_disable,
867 .is_enabled = twl6030reg_is_enabled,
868
869 .set_mode = twl6030reg_set_mode,
870
871 .get_status = twl6030reg_get_status,
872 };
873
874 /*----------------------------------------------------------------------*/
875
876 #define TWL4030_ADJUSTABLE_LDO(label, offset, num, turnon_delay, remap_conf) \
877 static const struct twlreg_info TWL4030_INFO_##label = { \
878 .base = offset, \
879 .id = num, \
880 .table_len = ARRAY_SIZE(label##_VSEL_table), \
881 .table = label##_VSEL_table, \
882 .remap = remap_conf, \
883 .desc = { \
884 .name = #label, \
885 .id = TWL4030_REG_##label, \
886 .n_voltages = ARRAY_SIZE(label##_VSEL_table), \
887 .ops = &twl4030ldo_ops, \
888 .type = REGULATOR_VOLTAGE, \
889 .owner = THIS_MODULE, \
890 .enable_time = turnon_delay, \
891 .of_map_mode = twl4030reg_map_mode, \
892 }, \
893 }
894
895 #define TWL4030_ADJUSTABLE_SMPS(label, offset, num, turnon_delay, remap_conf) \
896 static const struct twlreg_info TWL4030_INFO_##label = { \
897 .base = offset, \
898 .id = num, \
899 .remap = remap_conf, \
900 .desc = { \
901 .name = #label, \
902 .id = TWL4030_REG_##label, \
903 .ops = &twl4030smps_ops, \
904 .type = REGULATOR_VOLTAGE, \
905 .owner = THIS_MODULE, \
906 .enable_time = turnon_delay, \
907 .of_map_mode = twl4030reg_map_mode, \
908 }, \
909 }
910
911 #define TWL6030_ADJUSTABLE_SMPS(label) \
912 static const struct twlreg_info TWL6030_INFO_##label = { \
913 .desc = { \
914 .name = #label, \
915 .id = TWL6030_REG_##label, \
916 .ops = &twl6030coresmps_ops, \
917 .type = REGULATOR_VOLTAGE, \
918 .owner = THIS_MODULE, \
919 }, \
920 }
921
922 #define TWL6030_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts) \
923 static const struct twlreg_info TWL6030_INFO_##label = { \
924 .base = offset, \
925 .min_mV = min_mVolts, \
926 .max_mV = max_mVolts, \
927 .desc = { \
928 .name = #label, \
929 .id = TWL6030_REG_##label, \
930 .n_voltages = 32, \
931 .ops = &twl6030ldo_ops, \
932 .type = REGULATOR_VOLTAGE, \
933 .owner = THIS_MODULE, \
934 }, \
935 }
936
937 #define TWL6032_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts) \
938 static const struct twlreg_info TWL6032_INFO_##label = { \
939 .base = offset, \
940 .min_mV = min_mVolts, \
941 .max_mV = max_mVolts, \
942 .desc = { \
943 .name = #label, \
944 .id = TWL6032_REG_##label, \
945 .n_voltages = 32, \
946 .ops = &twl6030ldo_ops, \
947 .type = REGULATOR_VOLTAGE, \
948 .owner = THIS_MODULE, \
949 }, \
950 }
951
952 #define TWL6030_FIXED_LDO(label, offset, mVolts, turnon_delay) \
953 static const struct twlreg_info TWLFIXED_INFO_##label = { \
954 .base = offset, \
955 .id = 0, \
956 .min_mV = mVolts, \
957 .remap = 0, \
958 .desc = { \
959 .name = #label, \
960 .id = TWL6030##_REG_##label, \
961 .n_voltages = 1, \
962 .ops = &twl6030fixed_ops, \
963 .type = REGULATOR_VOLTAGE, \
964 .owner = THIS_MODULE, \
965 .min_uV = mVolts * 1000, \
966 .enable_time = turnon_delay, \
967 .of_map_mode = NULL, \
968 }, \
969 }
970
971 #define TWL4030_FIXED_LDO(label, offset, mVolts, num, turnon_delay, \
972 remap_conf) \
973 static const struct twlreg_info TWLFIXED_INFO_##label = { \
974 .base = offset, \
975 .id = num, \
976 .min_mV = mVolts, \
977 .remap = remap_conf, \
978 .desc = { \
979 .name = #label, \
980 .id = TWL4030##_REG_##label, \
981 .n_voltages = 1, \
982 .ops = &twl4030fixed_ops, \
983 .type = REGULATOR_VOLTAGE, \
984 .owner = THIS_MODULE, \
985 .min_uV = mVolts * 1000, \
986 .enable_time = turnon_delay, \
987 .of_map_mode = twl4030reg_map_mode, \
988 }, \
989 }
990
991 #define TWL6032_ADJUSTABLE_SMPS(label, offset) \
992 static const struct twlreg_info TWLSMPS_INFO_##label = { \
993 .base = offset, \
994 .min_mV = 600, \
995 .max_mV = 2100, \
996 .desc = { \
997 .name = #label, \
998 .id = TWL6032_REG_##label, \
999 .n_voltages = 63, \
1000 .ops = &twlsmps_ops, \
1001 .type = REGULATOR_VOLTAGE, \
1002 .owner = THIS_MODULE, \
1003 }, \
1004 }
1005
1006 /*
1007 * We list regulators here if systems need some level of
1008 * software control over them after boot.
1009 */
1010 TWL4030_ADJUSTABLE_LDO(VAUX1, 0x17, 1, 100, 0x08);
1011 TWL4030_ADJUSTABLE_LDO(VAUX2_4030, 0x1b, 2, 100, 0x08);
1012 TWL4030_ADJUSTABLE_LDO(VAUX2, 0x1b, 2, 100, 0x08);
1013 TWL4030_ADJUSTABLE_LDO(VAUX3, 0x1f, 3, 100, 0x08);
1014 TWL4030_ADJUSTABLE_LDO(VAUX4, 0x23, 4, 100, 0x08);
1015 TWL4030_ADJUSTABLE_LDO(VMMC1, 0x27, 5, 100, 0x08);
1016 TWL4030_ADJUSTABLE_LDO(VMMC2, 0x2b, 6, 100, 0x08);
1017 TWL4030_ADJUSTABLE_LDO(VPLL1, 0x2f, 7, 100, 0x00);
1018 TWL4030_ADJUSTABLE_LDO(VPLL2, 0x33, 8, 100, 0x08);
1019 TWL4030_ADJUSTABLE_LDO(VSIM, 0x37, 9, 100, 0x00);
1020 TWL4030_ADJUSTABLE_LDO(VDAC, 0x3b, 10, 100, 0x08);
1021 TWL4030_ADJUSTABLE_LDO(VINTANA2, 0x43, 12, 100, 0x08);
1022 TWL4030_ADJUSTABLE_LDO(VIO, 0x4b, 14, 1000, 0x08);
1023 TWL4030_ADJUSTABLE_SMPS(VDD1, 0x55, 15, 1000, 0x08);
1024 TWL4030_ADJUSTABLE_SMPS(VDD2, 0x63, 16, 1000, 0x08);
1025 /* VUSBCP is managed *only* by the USB subchip */
1026 /* 6030 REG with base as PMC Slave Misc : 0x0030 */
1027 /* Turnon-delay and remap configuration values for 6030 are not
1028 verified since the specification is not public */
1029 TWL6030_ADJUSTABLE_SMPS(VDD1);
1030 TWL6030_ADJUSTABLE_SMPS(VDD2);
1031 TWL6030_ADJUSTABLE_SMPS(VDD3);
1032 TWL6030_ADJUSTABLE_LDO(VAUX1_6030, 0x54, 1000, 3300);
1033 TWL6030_ADJUSTABLE_LDO(VAUX2_6030, 0x58, 1000, 3300);
1034 TWL6030_ADJUSTABLE_LDO(VAUX3_6030, 0x5c, 1000, 3300);
1035 TWL6030_ADJUSTABLE_LDO(VMMC, 0x68, 1000, 3300);
1036 TWL6030_ADJUSTABLE_LDO(VPP, 0x6c, 1000, 3300);
1037 TWL6030_ADJUSTABLE_LDO(VUSIM, 0x74, 1000, 3300);
1038 /* 6025 are renamed compared to 6030 versions */
1039 TWL6032_ADJUSTABLE_LDO(LDO2, 0x54, 1000, 3300);
1040 TWL6032_ADJUSTABLE_LDO(LDO4, 0x58, 1000, 3300);
1041 TWL6032_ADJUSTABLE_LDO(LDO3, 0x5c, 1000, 3300);
1042 TWL6032_ADJUSTABLE_LDO(LDO5, 0x68, 1000, 3300);
1043 TWL6032_ADJUSTABLE_LDO(LDO1, 0x6c, 1000, 3300);
1044 TWL6032_ADJUSTABLE_LDO(LDO7, 0x74, 1000, 3300);
1045 TWL6032_ADJUSTABLE_LDO(LDO6, 0x60, 1000, 3300);
1046 TWL6032_ADJUSTABLE_LDO(LDOLN, 0x64, 1000, 3300);
1047 TWL6032_ADJUSTABLE_LDO(LDOUSB, 0x70, 1000, 3300);
1048 TWL4030_FIXED_LDO(VINTANA1, 0x3f, 1500, 11, 100, 0x08);
1049 TWL4030_FIXED_LDO(VINTDIG, 0x47, 1500, 13, 100, 0x08);
1050 TWL4030_FIXED_LDO(VUSB1V5, 0x71, 1500, 17, 100, 0x08);
1051 TWL4030_FIXED_LDO(VUSB1V8, 0x74, 1800, 18, 100, 0x08);
1052 TWL4030_FIXED_LDO(VUSB3V1, 0x77, 3100, 19, 150, 0x08);
1053 TWL6030_FIXED_LDO(VANA, 0x50, 2100, 0);
1054 TWL6030_FIXED_LDO(VCXIO, 0x60, 1800, 0);
1055 TWL6030_FIXED_LDO(VDAC, 0x64, 1800, 0);
1056 TWL6030_FIXED_LDO(VUSB, 0x70, 3300, 0);
1057 TWL6030_FIXED_LDO(V1V8, 0x16, 1800, 0);
1058 TWL6030_FIXED_LDO(V2V1, 0x1c, 2100, 0);
1059 TWL6032_ADJUSTABLE_SMPS(SMPS3, 0x34);
1060 TWL6032_ADJUSTABLE_SMPS(SMPS4, 0x10);
1061 TWL6032_ADJUSTABLE_SMPS(VIO, 0x16);
1062
1063 static u8 twl_get_smps_offset(void)
1064 {
1065 u8 value;
1066
1067 twl_i2c_read_u8(TWL_MODULE_PM_RECEIVER, &value,
1068 TWL6030_SMPS_OFFSET);
1069 return value;
1070 }
1071
1072 static u8 twl_get_smps_mult(void)
1073 {
1074 u8 value;
1075
1076 twl_i2c_read_u8(TWL_MODULE_PM_RECEIVER, &value,
1077 TWL6030_SMPS_MULT);
1078 return value;
1079 }
1080
1081 #define TWL_OF_MATCH(comp, family, label) \
1082 { \
1083 .compatible = comp, \
1084 .data = &family##_INFO_##label, \
1085 }
1086
1087 #define TWL4030_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL4030, label)
1088 #define TWL6030_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL6030, label)
1089 #define TWL6032_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL6032, label)
1090 #define TWLFIXED_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLFIXED, label)
1091 #define TWLSMPS_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLSMPS, label)
1092
1093 static const struct of_device_id twl_of_match[] = {
1094 TWL4030_OF_MATCH("ti,twl4030-vaux1", VAUX1),
1095 TWL4030_OF_MATCH("ti,twl4030-vaux2", VAUX2_4030),
1096 TWL4030_OF_MATCH("ti,twl5030-vaux2", VAUX2),
1097 TWL4030_OF_MATCH("ti,twl4030-vaux3", VAUX3),
1098 TWL4030_OF_MATCH("ti,twl4030-vaux4", VAUX4),
1099 TWL4030_OF_MATCH("ti,twl4030-vmmc1", VMMC1),
1100 TWL4030_OF_MATCH("ti,twl4030-vmmc2", VMMC2),
1101 TWL4030_OF_MATCH("ti,twl4030-vpll1", VPLL1),
1102 TWL4030_OF_MATCH("ti,twl4030-vpll2", VPLL2),
1103 TWL4030_OF_MATCH("ti,twl4030-vsim", VSIM),
1104 TWL4030_OF_MATCH("ti,twl4030-vdac", VDAC),
1105 TWL4030_OF_MATCH("ti,twl4030-vintana2", VINTANA2),
1106 TWL4030_OF_MATCH("ti,twl4030-vio", VIO),
1107 TWL4030_OF_MATCH("ti,twl4030-vdd1", VDD1),
1108 TWL4030_OF_MATCH("ti,twl4030-vdd2", VDD2),
1109 TWL6030_OF_MATCH("ti,twl6030-vdd1", VDD1),
1110 TWL6030_OF_MATCH("ti,twl6030-vdd2", VDD2),
1111 TWL6030_OF_MATCH("ti,twl6030-vdd3", VDD3),
1112 TWL6030_OF_MATCH("ti,twl6030-vaux1", VAUX1_6030),
1113 TWL6030_OF_MATCH("ti,twl6030-vaux2", VAUX2_6030),
1114 TWL6030_OF_MATCH("ti,twl6030-vaux3", VAUX3_6030),
1115 TWL6030_OF_MATCH("ti,twl6030-vmmc", VMMC),
1116 TWL6030_OF_MATCH("ti,twl6030-vpp", VPP),
1117 TWL6030_OF_MATCH("ti,twl6030-vusim", VUSIM),
1118 TWL6032_OF_MATCH("ti,twl6032-ldo2", LDO2),
1119 TWL6032_OF_MATCH("ti,twl6032-ldo4", LDO4),
1120 TWL6032_OF_MATCH("ti,twl6032-ldo3", LDO3),
1121 TWL6032_OF_MATCH("ti,twl6032-ldo5", LDO5),
1122 TWL6032_OF_MATCH("ti,twl6032-ldo1", LDO1),
1123 TWL6032_OF_MATCH("ti,twl6032-ldo7", LDO7),
1124 TWL6032_OF_MATCH("ti,twl6032-ldo6", LDO6),
1125 TWL6032_OF_MATCH("ti,twl6032-ldoln", LDOLN),
1126 TWL6032_OF_MATCH("ti,twl6032-ldousb", LDOUSB),
1127 TWLFIXED_OF_MATCH("ti,twl4030-vintana1", VINTANA1),
1128 TWLFIXED_OF_MATCH("ti,twl4030-vintdig", VINTDIG),
1129 TWLFIXED_OF_MATCH("ti,twl4030-vusb1v5", VUSB1V5),
1130 TWLFIXED_OF_MATCH("ti,twl4030-vusb1v8", VUSB1V8),
1131 TWLFIXED_OF_MATCH("ti,twl4030-vusb3v1", VUSB3V1),
1132 TWLFIXED_OF_MATCH("ti,twl6030-vana", VANA),
1133 TWLFIXED_OF_MATCH("ti,twl6030-vcxio", VCXIO),
1134 TWLFIXED_OF_MATCH("ti,twl6030-vdac", VDAC),
1135 TWLFIXED_OF_MATCH("ti,twl6030-vusb", VUSB),
1136 TWLFIXED_OF_MATCH("ti,twl6030-v1v8", V1V8),
1137 TWLFIXED_OF_MATCH("ti,twl6030-v2v1", V2V1),
1138 TWLSMPS_OF_MATCH("ti,twl6032-smps3", SMPS3),
1139 TWLSMPS_OF_MATCH("ti,twl6032-smps4", SMPS4),
1140 TWLSMPS_OF_MATCH("ti,twl6032-vio", VIO),
1141 {},
1142 };
1143 MODULE_DEVICE_TABLE(of, twl_of_match);
1144
1145 static int twlreg_probe(struct platform_device *pdev)
1146 {
1147 int id;
1148 struct twlreg_info *info;
1149 const struct twlreg_info *template;
1150 struct regulator_init_data *initdata;
1151 struct regulation_constraints *c;
1152 struct regulator_dev *rdev;
1153 const struct of_device_id *match;
1154 struct regulator_config config = { };
1155
1156 match = of_match_device(twl_of_match, &pdev->dev);
1157 if (!match)
1158 return -ENODEV;
1159
1160 template = match->data;
1161 if (!template)
1162 return -ENODEV;
1163
1164 id = template->desc.id;
1165 initdata = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node,
1166 &template->desc);
1167 if (!initdata)
1168 return -EINVAL;
1169
1170 info = devm_kmemdup(&pdev->dev, template, sizeof(*info), GFP_KERNEL);
1171 if (!info)
1172 return -ENOMEM;
1173
1174 /* Constrain board-specific capabilities according to what
1175 * this driver and the chip itself can actually do.
1176 */
1177 c = &initdata->constraints;
1178 c->valid_modes_mask &= REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY;
1179 c->valid_ops_mask &= REGULATOR_CHANGE_VOLTAGE
1180 | REGULATOR_CHANGE_MODE
1181 | REGULATOR_CHANGE_STATUS;
1182 switch (id) {
1183 case TWL4030_REG_VIO:
1184 case TWL4030_REG_VDD1:
1185 case TWL4030_REG_VDD2:
1186 case TWL4030_REG_VPLL1:
1187 case TWL4030_REG_VINTANA1:
1188 case TWL4030_REG_VINTANA2:
1189 case TWL4030_REG_VINTDIG:
1190 c->always_on = true;
1191 break;
1192 default:
1193 break;
1194 }
1195
1196 switch (id) {
1197 case TWL6032_REG_SMPS3:
1198 if (twl_get_smps_mult() & SMPS_MULTOFFSET_SMPS3)
1199 info->flags |= SMPS_EXTENDED_EN;
1200 if (twl_get_smps_offset() & SMPS_MULTOFFSET_SMPS3)
1201 info->flags |= SMPS_OFFSET_EN;
1202 break;
1203 case TWL6032_REG_SMPS4:
1204 if (twl_get_smps_mult() & SMPS_MULTOFFSET_SMPS4)
1205 info->flags |= SMPS_EXTENDED_EN;
1206 if (twl_get_smps_offset() & SMPS_MULTOFFSET_SMPS4)
1207 info->flags |= SMPS_OFFSET_EN;
1208 break;
1209 case TWL6032_REG_VIO:
1210 if (twl_get_smps_mult() & SMPS_MULTOFFSET_VIO)
1211 info->flags |= SMPS_EXTENDED_EN;
1212 if (twl_get_smps_offset() & SMPS_MULTOFFSET_VIO)
1213 info->flags |= SMPS_OFFSET_EN;
1214 break;
1215 }
1216
1217 config.dev = &pdev->dev;
1218 config.init_data = initdata;
1219 config.driver_data = info;
1220 config.of_node = pdev->dev.of_node;
1221
1222 rdev = devm_regulator_register(&pdev->dev, &info->desc, &config);
1223 if (IS_ERR(rdev)) {
1224 dev_err(&pdev->dev, "can't register %s, %ld\n",
1225 info->desc.name, PTR_ERR(rdev));
1226 return PTR_ERR(rdev);
1227 }
1228 platform_set_drvdata(pdev, rdev);
1229
1230 if (twl_class_is_4030())
1231 twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_REMAP,
1232 info->remap);
1233
1234 /* NOTE: many regulators support short-circuit IRQs (presentable
1235 * as REGULATOR_OVER_CURRENT notifications?) configured via:
1236 * - SC_CONFIG
1237 * - SC_DETECT1 (vintana2, vmmc1/2, vaux1/2/3/4)
1238 * - SC_DETECT2 (vusb, vdac, vio, vdd1/2, vpll2)
1239 * - IT_CONFIG
1240 */
1241
1242 return 0;
1243 }
1244
1245 MODULE_ALIAS("platform:twl_reg");
1246
1247 static struct platform_driver twlreg_driver = {
1248 .probe = twlreg_probe,
1249 /* NOTE: short name, to work around driver model truncation of
1250 * "twl_regulator.12" (and friends) to "twl_regulator.1".
1251 */
1252 .driver = {
1253 .name = "twl_reg",
1254 .of_match_table = of_match_ptr(twl_of_match),
1255 },
1256 };
1257
1258 static int __init twlreg_init(void)
1259 {
1260 return platform_driver_register(&twlreg_driver);
1261 }
1262 subsys_initcall(twlreg_init);
1263
1264 static void __exit twlreg_exit(void)
1265 {
1266 platform_driver_unregister(&twlreg_driver);
1267 }
1268 module_exit(twlreg_exit)
1269
1270 MODULE_DESCRIPTION("TWL regulator driver");
1271 MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror