Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us