drivers/regulator/cpcap-regulator.c

   1 /*
   2  * Motorola CPCAP PMIC regulator driver
   3  *
   4  * Based on cpcap-regulator.c from Motorola Linux kernel tree
   5  * Copyright (C) 2009-2011 Motorola, Inc.
   6  *
   7  * Rewritten for mainline kernel to use device tree and regmap
   8  * Copyright (C) 2017 Tony Lindgren <tony@atomide.com>
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License as
  12  * published by the Free Software Foundation version 2.
  13  *
  14  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  15  * kind, whether express or implied; without even the implied warranty
  16  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU General Public License for more details.
  18  */
  19
  20 #include <linux/err.h>
  21 #include <linux/module.h>
  22 #include <linux/of.h>
  23 #include <linux/of_platform.h>
  24 #include <linux/regmap.h>
  25 #include <linux/regulator/driver.h>
  26 #include <linux/regulator/machine.h>
  27 #include <linux/regulator/of_regulator.h>
  28 #include <linux/mfd/motorola-cpcap.h>
  29
  30 /*
  31  * Resource assignment register bits. These seem to control the state
  32  * idle modes adn are used at least for omap4.
  33  */
  34
  35 /* CPCAP_REG_ASSIGN2 bits - Resource Assignment 2 */
  36 #define CPCAP_BIT_VSDIO_SEL             BIT(15)
  37 #define CPCAP_BIT_VDIG_SEL              BIT(14)
  38 #define CPCAP_BIT_VCAM_SEL              BIT(13)
  39 #define CPCAP_BIT_SW6_SEL               BIT(12)
  40 #define CPCAP_BIT_SW5_SEL               BIT(11)
  41 #define CPCAP_BIT_SW4_SEL               BIT(10)
  42 #define CPCAP_BIT_SW3_SEL               BIT(9)
  43 #define CPCAP_BIT_SW2_SEL               BIT(8)
  44 #define CPCAP_BIT_SW1_SEL               BIT(7)
  45
  46 /* CPCAP_REG_ASSIGN3 bits - Resource Assignment 3 */
  47 #define CPCAP_BIT_VUSBINT2_SEL          BIT(15)
  48 #define CPCAP_BIT_VUSBINT1_SEL          BIT(14)
  49 #define CPCAP_BIT_VVIB_SEL              BIT(13)
  50 #define CPCAP_BIT_VWLAN1_SEL            BIT(12)
  51 #define CPCAP_BIT_VRF1_SEL              BIT(11)
  52 #define CPCAP_BIT_VHVIO_SEL             BIT(10)
  53 #define CPCAP_BIT_VDAC_SEL              BIT(9)
  54 #define CPCAP_BIT_VUSB_SEL              BIT(8)
  55 #define CPCAP_BIT_VSIM_SEL              BIT(7)
  56 #define CPCAP_BIT_VRFREF_SEL            BIT(6)
  57 #define CPCAP_BIT_VPLL_SEL              BIT(5)
  58 #define CPCAP_BIT_VFUSE_SEL             BIT(4)
  59 #define CPCAP_BIT_VCSI_SEL              BIT(3)
  60 #define CPCAP_BIT_SPARE_14_2            BIT(2)
  61 #define CPCAP_BIT_VWLAN2_SEL            BIT(1)
  62 #define CPCAP_BIT_VRF2_SEL              BIT(0)
  63
  64 /* CPCAP_REG_ASSIGN4 bits - Resource Assignment 4 */
  65 #define CPCAP_BIT_VAUDIO_SEL            BIT(0)
  66
  67 /*
  68  * Enable register bits. At least CPCAP_BIT_AUDIO_LOW_PWR is generic,
  69  * and not limited to audio regulator. Let's use the Motorola kernel
  70  * naming for now until we have a better understanding of the other
  71  * enable register bits. No idea why BIT(3) is not defined.
  72  */
  73 #define CPCAP_BIT_AUDIO_LOW_PWR         BIT(6)
  74 #define CPCAP_BIT_AUD_LOWPWR_SPEED      BIT(5)
  75 #define CPCAP_BIT_VAUDIOPRISTBY         BIT(4)
  76 #define CPCAP_BIT_VAUDIO_MODE1          BIT(2)
  77 #define CPCAP_BIT_VAUDIO_MODE0          BIT(1)
  78 #define CPCAP_BIT_V_AUDIO_EN            BIT(0)
  79
  80 #define CPCAP_BIT_AUDIO_NORMAL_MODE     0x00
  81
  82 /*
  83  * Off mode configuration bit. Used currently only by SW5 on omap4. There's
  84  * the following comment in Motorola Linux kernel tree for it:
  85  *
  86  * When set in the regulator mode, the regulator assignment will be changed
  87  * to secondary when the regulator is disabled. The mode will be set back to
  88  * primary when the regulator is turned on.
  89  */
  90 #define CPCAP_REG_OFF_MODE_SEC          BIT(15)
  91
  92 /**
  93  * SoC specific configuraion for CPCAP regulator. There are at least three
  94  * different SoCs each with their own parameters: omap3, omap4 and tegra2.
  95  *
  96  * The assign_reg and assign_mask seem to allow toggling between primary
  97  * and secondary mode that at least omap4 uses for off mode.
  98  */
  99 struct cpcap_regulator {
 100         struct regulator_desc rdesc;
 101         const u16 assign_reg;
 102         const u16 assign_mask;
 103 };
 104
 105 #define CPCAP_REG(_ID, reg, assignment_reg, assignment_mask, val_tbl,   \
 106                 mode_mask, volt_mask, mode_val, off_val,                \
 107                 volt_trans_time) {                                      \
 108         .rdesc = {                                                      \
 109                 .name = #_ID,                                           \
 110                 .of_match = of_match_ptr(#_ID),                         \
 111                 .ops = &cpcap_regulator_ops,                            \
 112                 .regulators_node = of_match_ptr("regulators"),          \
 113                 .type = REGULATOR_VOLTAGE,                              \
 114                 .id = CPCAP_##_ID,                                      \
 115                 .owner = THIS_MODULE,                                   \
 116                 .n_voltages = ARRAY_SIZE(val_tbl),                      \
 117                 .volt_table = (val_tbl),                                \
 118                 .vsel_reg = (reg),                                      \
 119                 .vsel_mask = (volt_mask),                               \
 120                 .enable_reg = (reg),                                    \
 121                 .enable_mask = (mode_mask),                             \
 122                 .enable_val = (mode_val),                               \
 123                 .disable_val = (off_val),                               \
 124                 .ramp_delay = (volt_trans_time),                        \
 125                 .of_map_mode = cpcap_map_mode,                          \
 126         },                                                              \
 127         .assign_reg = (assignment_reg),                                 \
 128         .assign_mask = (assignment_mask),                               \
 129 }
 130
 131 struct cpcap_ddata {
 132         struct regmap *reg;
 133         struct device *dev;
 134         const struct cpcap_regulator *soc;
 135 };
 136
 137 enum cpcap_regulator_id {
 138         CPCAP_SW1,
 139         CPCAP_SW2,
 140         CPCAP_SW3,
 141         CPCAP_SW4,
 142         CPCAP_SW5,
 143         CPCAP_SW6,
 144         CPCAP_VCAM,
 145         CPCAP_VCSI,
 146         CPCAP_VDAC,
 147         CPCAP_VDIG,
 148         CPCAP_VFUSE,
 149         CPCAP_VHVIO,
 150         CPCAP_VSDIO,
 151         CPCAP_VPLL,
 152         CPCAP_VRF1,
 153         CPCAP_VRF2,
 154         CPCAP_VRFREF,
 155         CPCAP_VWLAN1,
 156         CPCAP_VWLAN2,
 157         CPCAP_VSIM,
 158         CPCAP_VSIMCARD,
 159         CPCAP_VVIB,
 160         CPCAP_VUSB,
 161         CPCAP_VAUDIO,
 162         CPCAP_NR_REGULATORS,
 163 };
 164
 165 /*
 166  * We need to also configure regulator idle mode for SoC off mode if
 167  * CPCAP_REG_OFF_MODE_SEC is set.
 168  */
 169 static int cpcap_regulator_enable(struct regulator_dev *rdev)
 170 {
 171         struct cpcap_regulator *regulator = rdev_get_drvdata(rdev);
 172         int error, ignore;
 173
 174         error = regulator_enable_regmap(rdev);
 175         if (error)
 176                 return error;
 177
 178         if (rdev->desc->enable_val & CPCAP_REG_OFF_MODE_SEC) {
 179                 error = regmap_update_bits(rdev->regmap, regulator->assign_reg,
 180                                            regulator->assign_mask,
 181                                            regulator->assign_mask);
 182                 if (error)
 183                         ignore = regulator_disable_regmap(rdev);
 184         }
 185
 186         return error;
 187 }
 188
 189 /*
 190  * We need to also configure regulator idle mode for SoC off mode if
 191  * CPCAP_REG_OFF_MODE_SEC is set.
 192  */
 193 static int cpcap_regulator_disable(struct regulator_dev *rdev)
 194 {
 195         struct cpcap_regulator *regulator = rdev_get_drvdata(rdev);
 196         int error, ignore;
 197
 198         if (rdev->desc->enable_val & CPCAP_REG_OFF_MODE_SEC) {
 199                 error = regmap_update_bits(rdev->regmap, regulator->assign_reg,
 200                                            regulator->assign_mask, 0);
 201                 if (error)
 202                         return error;
 203         }
 204
 205         error = regulator_disable_regmap(rdev);
 206         if (error && (rdev->desc->enable_val & CPCAP_REG_OFF_MODE_SEC)) {
 207                 ignore = regmap_update_bits(rdev->regmap, regulator->assign_reg,
 208                                             regulator->assign_mask,
 209                                             regulator->assign_mask);
 210         }
 211
 212         return error;
 213 }
 214
 215 static unsigned int cpcap_map_mode(unsigned int mode)
 216 {
 217         switch (mode) {
 218         case CPCAP_BIT_AUDIO_NORMAL_MODE:
 219                 return REGULATOR_MODE_NORMAL;
 220         case CPCAP_BIT_AUDIO_LOW_PWR:
 221                 return REGULATOR_MODE_STANDBY;
 222         default:
 223                 return REGULATOR_MODE_INVALID;
 224         }
 225 }
 226
 227 static unsigned int cpcap_regulator_get_mode(struct regulator_dev *rdev)
 228 {
 229         int value;
 230
 231         regmap_read(rdev->regmap, rdev->desc->enable_reg, &value);
 232
 233         if (value & CPCAP_BIT_AUDIO_LOW_PWR)
 234                 return REGULATOR_MODE_STANDBY;
 235
 236         return REGULATOR_MODE_NORMAL;
 237 }
 238
 239 static int cpcap_regulator_set_mode(struct regulator_dev *rdev,
 240                                     unsigned int mode)
 241 {
 242         int value;
 243
 244         switch (mode) {
 245         case REGULATOR_MODE_NORMAL:
 246                 value = CPCAP_BIT_AUDIO_NORMAL_MODE;
 247                 break;
 248         case REGULATOR_MODE_STANDBY:
 249                 value = CPCAP_BIT_AUDIO_LOW_PWR;
 250                 break;
 251         default:
 252                 return -EINVAL;
 253         }
 254
 255         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 256                                   CPCAP_BIT_AUDIO_LOW_PWR, value);
 257 }
 258
 259 static struct regulator_ops cpcap_regulator_ops = {
 260         .enable = cpcap_regulator_enable,
 261         .disable = cpcap_regulator_disable,
 262         .is_enabled = regulator_is_enabled_regmap,
 263         .list_voltage = regulator_list_voltage_table,
 264         .map_voltage = regulator_map_voltage_iterate,
 265         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 266         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 267         .get_mode = cpcap_regulator_get_mode,
 268         .set_mode = cpcap_regulator_set_mode,
 269 };
 270
 271 static const unsigned int unknown_val_tbl[] = { 0, };
 272 static const unsigned int sw2_sw4_val_tbl[] = { 612500, 625000, 637500,
 273                                                 650000, 662500, 675000,
 274                                                 687500, 700000, 712500,
 275                                                 725000, 737500, 750000,
 276                                                 762500, 775000, 787500,
 277                                                 800000, 812500, 825000,
 278                                                 837500, 850000, 862500,
 279                                                 875000, 887500, 900000,
 280                                                 912500, 925000, 937500,
 281                                                 950000, 962500, 975000,
 282                                                 987500, 1000000, 1012500,
 283                                                 1025000, 1037500, 1050000,
 284                                                 1062500, 1075000, 1087500,
 285                                                 1100000, 1112500, 1125000,
 286                                                 1137500, 1150000, 1162500,
 287                                                 1175000, 1187500, 1200000,
 288                                                 1212500, 1225000, 1237500,
 289                                                 1250000, 1262500, 1275000,
 290                                                 1287500, 1300000, 1312500,
 291                                                 1325000, 1337500, 1350000,
 292                                                 1362500, 1375000, 1387500,
 293                                                 1400000, 1412500, 1425000,
 294                                                 1437500, 1450000, 1462500, };
 295 static const unsigned int sw5_val_tbl[] = { 0, 5050000, };
 296 static const unsigned int vcam_val_tbl[] = { 2600000, 2700000, 2800000,
 297                                              2900000, };
 298 static const unsigned int vcsi_val_tbl[] = { 1200000, 1800000, };
 299 static const unsigned int vdac_val_tbl[] = { 1200000, 1500000, 1800000,
 300                                              2500000,};
 301 static const unsigned int vdig_val_tbl[] = { 1200000, 1350000, 1500000,
 302                                              1875000, };
 303 static const unsigned int vfuse_val_tbl[] = { 1500000, 1600000, 1700000,
 304                                               1800000, 1900000, 2000000,
 305                                               2100000, 2200000, 2300000,
 306                                               2400000, 2500000, 2600000,
 307                                               2700000, 3150000, };
 308 static const unsigned int vhvio_val_tbl[] = { 2775000, };
 309 static const unsigned int vsdio_val_tbl[] = { 1500000, 1600000, 1800000,
 310                                               2600000, 2700000, 2800000,
 311                                               2900000, 3000000, };
 312 static const unsigned int vpll_val_tbl[] = { 1200000, 1300000, 1400000,
 313                                              1800000, };
 314 /* Quirk: 2775000 is before 2500000 for vrf1 regulator */
 315 static const unsigned int vrf1_val_tbl[] = { 2775000, 2500000, };
 316 static const unsigned int vrf2_val_tbl[] = { 0, 2775000, };
 317 static const unsigned int vrfref_val_tbl[] = { 2500000, 2775000, };
 318 static const unsigned int vwlan1_val_tbl[] = { 1800000, 1900000, };
 319 static const unsigned int vwlan2_val_tbl[] = { 2775000, 3000000, 3300000,
 320                                                3300000, };
 321 static const unsigned int vsim_val_tbl[] = { 1800000, 2900000, };
 322 static const unsigned int vsimcard_val_tbl[] = { 1800000, 2900000, };
 323 static const unsigned int vvib_val_tbl[] = { 1300000, 1800000, 2000000,
 324                                              3000000, };
 325 static const unsigned int vusb_val_tbl[] = { 0, 3300000, };
 326 static const unsigned int vaudio_val_tbl[] = { 0, 2775000, };
 327
 328 /**
 329  * SoC specific configuration for omap4. The data below is comes from Motorola
 330  * Linux kernel tree. It's basically the values of cpcap_regltr_data,
 331  * cpcap_regulator_mode_values and cpcap_regulator_off_mode_values, see
 332  * CPCAP_REG macro above.
 333  *
 334  * SW1 to SW4 and SW6 seems to be unused for mapphone. Note that VSIM and
 335  * VSIMCARD have a shared resource assignment bit.
 336  */
 337 static const struct cpcap_regulator omap4_regulators[] = {
 338         CPCAP_REG(SW1, CPCAP_REG_S1C1, CPCAP_REG_ASSIGN2,
 339                   CPCAP_BIT_SW1_SEL, unknown_val_tbl,
 340                   0, 0, 0, 0, 0),
 341         CPCAP_REG(SW2, CPCAP_REG_S2C1, CPCAP_REG_ASSIGN2,
 342                   CPCAP_BIT_SW2_SEL, unknown_val_tbl,
 343                   0, 0, 0, 0, 0),
 344         CPCAP_REG(SW3, CPCAP_REG_S3C, CPCAP_REG_ASSIGN2,
 345                   CPCAP_BIT_SW3_SEL, unknown_val_tbl,
 346                   0, 0, 0, 0, 0),
 347         CPCAP_REG(SW4, CPCAP_REG_S4C1, CPCAP_REG_ASSIGN2,
 348                   CPCAP_BIT_SW4_SEL, unknown_val_tbl,
 349                   0, 0, 0, 0, 0),
 350         CPCAP_REG(SW5, CPCAP_REG_S5C, CPCAP_REG_ASSIGN2,
 351                   CPCAP_BIT_SW5_SEL, sw5_val_tbl,
 352                   0x28, 0, 0x20 | CPCAP_REG_OFF_MODE_SEC, 0, 0),
 353         CPCAP_REG(SW6, CPCAP_REG_S6C, CPCAP_REG_ASSIGN2,
 354                   CPCAP_BIT_SW6_SEL, unknown_val_tbl,
 355                   0, 0, 0, 0, 0),
 356         CPCAP_REG(VCAM, CPCAP_REG_VCAMC, CPCAP_REG_ASSIGN2,
 357                   CPCAP_BIT_VCAM_SEL, vcam_val_tbl,
 358                   0x87, 0x30, 0x3, 0, 420),
 359         CPCAP_REG(VCSI, CPCAP_REG_VCSIC, CPCAP_REG_ASSIGN3,
 360                   CPCAP_BIT_VCSI_SEL, vcsi_val_tbl,
 361                   0x47, 0x10, 0x43, 0x41, 350),
 362         CPCAP_REG(VDAC, CPCAP_REG_VDACC, CPCAP_REG_ASSIGN3,
 363                   CPCAP_BIT_VDAC_SEL, vdac_val_tbl,
 364                   0x87, 0x30, 0x3, 0, 420),
 365         CPCAP_REG(VDIG, CPCAP_REG_VDIGC, CPCAP_REG_ASSIGN2,
 366                   CPCAP_BIT_VDIG_SEL, vdig_val_tbl,
 367                   0x87, 0x30, 0x82, 0, 420),
 368         CPCAP_REG(VFUSE, CPCAP_REG_VFUSEC, CPCAP_REG_ASSIGN3,
 369                   CPCAP_BIT_VFUSE_SEL, vfuse_val_tbl,
 370                   0x80, 0xf, 0x80, 0, 420),
 371         CPCAP_REG(VHVIO, CPCAP_REG_VHVIOC, CPCAP_REG_ASSIGN3,
 372                   CPCAP_BIT_VHVIO_SEL, vhvio_val_tbl,
 373                   0x17, 0, 0, 0x12, 0),
 374         CPCAP_REG(VSDIO, CPCAP_REG_VSDIOC, CPCAP_REG_ASSIGN2,
 375                   CPCAP_BIT_VSDIO_SEL, vsdio_val_tbl,
 376                   0x87, 0x38, 0x82, 0, 420),
 377         CPCAP_REG(VPLL, CPCAP_REG_VPLLC, CPCAP_REG_ASSIGN3,
 378                   CPCAP_BIT_VPLL_SEL, vpll_val_tbl,
 379                   0x43, 0x18, 0x2, 0, 420),
 380         CPCAP_REG(VRF1, CPCAP_REG_VRF1C, CPCAP_REG_ASSIGN3,
 381                   CPCAP_BIT_VRF1_SEL, vrf1_val_tbl,
 382                   0xac, 0x2, 0x4, 0, 10),
 383         CPCAP_REG(VRF2, CPCAP_REG_VRF2C, CPCAP_REG_ASSIGN3,
 384                   CPCAP_BIT_VRF2_SEL, vrf2_val_tbl,
 385                   0x23, 0x8, 0, 0, 10),
 386         CPCAP_REG(VRFREF, CPCAP_REG_VRFREFC, CPCAP_REG_ASSIGN3,
 387                   CPCAP_BIT_VRFREF_SEL, vrfref_val_tbl,
 388                   0x23, 0x8, 0, 0, 420),
 389         CPCAP_REG(VWLAN1, CPCAP_REG_VWLAN1C, CPCAP_REG_ASSIGN3,
 390                   CPCAP_BIT_VWLAN1_SEL, vwlan1_val_tbl,
 391                   0x47, 0x10, 0, 0, 420),
 392         CPCAP_REG(VWLAN2, CPCAP_REG_VWLAN2C, CPCAP_REG_ASSIGN3,
 393                   CPCAP_BIT_VWLAN2_SEL, vwlan2_val_tbl,
 394                   0x20c, 0xc0, 0x20c, 0, 420),
 395         CPCAP_REG(VSIM, CPCAP_REG_VSIMC, CPCAP_REG_ASSIGN3,
 396                   0xffff, vsim_val_tbl,
 397                   0x23, 0x8, 0x3, 0, 420),
 398         CPCAP_REG(VSIMCARD, CPCAP_REG_VSIMC, CPCAP_REG_ASSIGN3,
 399                   0xffff, vsimcard_val_tbl,
 400                   0x1e80, 0x8, 0x1e00, 0, 420),
 401         CPCAP_REG(VVIB, CPCAP_REG_VVIBC, CPCAP_REG_ASSIGN3,
 402                   CPCAP_BIT_VVIB_SEL, vvib_val_tbl,
 403                   0x1, 0xc, 0x1, 0, 500),
 404         CPCAP_REG(VUSB, CPCAP_REG_VUSBC, CPCAP_REG_ASSIGN3,
 405                   CPCAP_BIT_VUSB_SEL, vusb_val_tbl,
 406                   0x11c, 0x40, 0xc, 0, 0),
 407         CPCAP_REG(VAUDIO, CPCAP_REG_VAUDIOC, CPCAP_REG_ASSIGN4,
 408                   CPCAP_BIT_VAUDIO_SEL, vaudio_val_tbl,
 409                   0x16, 0x1, 0x4, 0, 0),
 410         { /* sentinel */ },
 411 };
 412
 413 static const struct cpcap_regulator xoom_regulators[] = {
 414         CPCAP_REG(SW1, CPCAP_REG_S1C1, CPCAP_REG_ASSIGN2,
 415                   CPCAP_BIT_SW1_SEL, unknown_val_tbl,
 416                   0, 0, 0, 0, 0),
 417         CPCAP_REG(SW2, CPCAP_REG_S2C1, CPCAP_REG_ASSIGN2,
 418                   CPCAP_BIT_SW2_SEL, sw2_sw4_val_tbl,
 419                   0xf00, 0x7f, 0x800, 0, 120),
 420         CPCAP_REG(SW3, CPCAP_REG_S3C, CPCAP_REG_ASSIGN2,
 421                   CPCAP_BIT_SW3_SEL, unknown_val_tbl,
 422                   0, 0, 0, 0, 0),
 423         CPCAP_REG(SW4, CPCAP_REG_S4C1, CPCAP_REG_ASSIGN2,
 424                   CPCAP_BIT_SW4_SEL, sw2_sw4_val_tbl,
 425                   0xf00, 0x7f, 0x900, 0, 100),
 426         CPCAP_REG(SW5, CPCAP_REG_S5C, CPCAP_REG_ASSIGN2,
 427                   CPCAP_BIT_SW5_SEL, sw5_val_tbl,
 428                   0x2a, 0, 0x22, 0, 0),
 429         CPCAP_REG(SW6, CPCAP_REG_S6C, CPCAP_REG_ASSIGN2,
 430                   CPCAP_BIT_SW6_SEL, unknown_val_tbl,
 431                   0, 0, 0, 0, 0),
 432         CPCAP_REG(VCAM, CPCAP_REG_VCAMC, CPCAP_REG_ASSIGN2,
 433                   CPCAP_BIT_VCAM_SEL, vcam_val_tbl,
 434                   0x87, 0x30, 0x7, 0, 420),
 435         CPCAP_REG(VCSI, CPCAP_REG_VCSIC, CPCAP_REG_ASSIGN3,
 436                   CPCAP_BIT_VCSI_SEL, vcsi_val_tbl,
 437                   0x47, 0x10, 0x7, 0, 350),
 438         CPCAP_REG(VDAC, CPCAP_REG_VDACC, CPCAP_REG_ASSIGN3,
 439                   CPCAP_BIT_VDAC_SEL, vdac_val_tbl,
 440                   0x87, 0x30, 0x3, 0, 420),
 441         CPCAP_REG(VDIG, CPCAP_REG_VDIGC, CPCAP_REG_ASSIGN2,
 442                   CPCAP_BIT_VDIG_SEL, vdig_val_tbl,
 443                   0x87, 0x30, 0x5, 0, 420),
 444         CPCAP_REG(VFUSE, CPCAP_REG_VFUSEC, CPCAP_REG_ASSIGN3,
 445                   CPCAP_BIT_VFUSE_SEL, vfuse_val_tbl,
 446                   0x80, 0xf, 0x80, 0, 420),
 447         CPCAP_REG(VHVIO, CPCAP_REG_VHVIOC, CPCAP_REG_ASSIGN3,
 448                   CPCAP_BIT_VHVIO_SEL, vhvio_val_tbl,
 449                   0x17, 0, 0x2, 0, 0),
 450         CPCAP_REG(VSDIO, CPCAP_REG_VSDIOC, CPCAP_REG_ASSIGN2,
 451                   CPCAP_BIT_VSDIO_SEL, vsdio_val_tbl,
 452                   0x87, 0x38, 0x2, 0, 420),
 453         CPCAP_REG(VPLL, CPCAP_REG_VPLLC, CPCAP_REG_ASSIGN3,
 454                   CPCAP_BIT_VPLL_SEL, vpll_val_tbl,
 455                   0x43, 0x18, 0x1, 0, 420),
 456         CPCAP_REG(VRF1, CPCAP_REG_VRF1C, CPCAP_REG_ASSIGN3,
 457                   CPCAP_BIT_VRF1_SEL, vrf1_val_tbl,
 458                   0xac, 0x2, 0xc, 0, 10),
 459         CPCAP_REG(VRF2, CPCAP_REG_VRF2C, CPCAP_REG_ASSIGN3,
 460                   CPCAP_BIT_VRF2_SEL, vrf2_val_tbl,
 461                   0x23, 0x8, 0x3, 0, 10),
 462         CPCAP_REG(VRFREF, CPCAP_REG_VRFREFC, CPCAP_REG_ASSIGN3,
 463                   CPCAP_BIT_VRFREF_SEL, vrfref_val_tbl,
 464                   0x23, 0x8, 0x3, 0, 420),
 465         CPCAP_REG(VWLAN1, CPCAP_REG_VWLAN1C, CPCAP_REG_ASSIGN3,
 466                   CPCAP_BIT_VWLAN1_SEL, vwlan1_val_tbl,
 467                   0x47, 0x10, 0x5, 0, 420),
 468         CPCAP_REG(VWLAN2, CPCAP_REG_VWLAN2C, CPCAP_REG_ASSIGN3,
 469                   CPCAP_BIT_VWLAN2_SEL, vwlan2_val_tbl,
 470                   0x20c, 0xc0, 0x8, 0, 420),
 471         CPCAP_REG(VSIM, CPCAP_REG_VSIMC, CPCAP_REG_ASSIGN3,
 472                   0xffff, vsim_val_tbl,
 473                   0x23, 0x8, 0x3, 0, 420),
 474         CPCAP_REG(VSIMCARD, CPCAP_REG_VSIMC, CPCAP_REG_ASSIGN3,
 475                   0xffff, vsimcard_val_tbl,
 476                   0x1e80, 0x8, 0x1e00, 0, 420),
 477         CPCAP_REG(VVIB, CPCAP_REG_VVIBC, CPCAP_REG_ASSIGN3,
 478                   CPCAP_BIT_VVIB_SEL, vvib_val_tbl,
 479                   0x1, 0xc, 0, 0x1, 500),
 480         CPCAP_REG(VUSB, CPCAP_REG_VUSBC, CPCAP_REG_ASSIGN3,
 481                   CPCAP_BIT_VUSB_SEL, vusb_val_tbl,
 482                   0x11c, 0x40, 0xc, 0, 0),
 483         CPCAP_REG(VAUDIO, CPCAP_REG_VAUDIOC, CPCAP_REG_ASSIGN4,
 484                   CPCAP_BIT_VAUDIO_SEL, vaudio_val_tbl,
 485                   0x16, 0x1, 0x4, 0, 0),
 486         { /* sentinel */ },
 487 };
 488
 489 static const struct of_device_id cpcap_regulator_id_table[] = {
 490         {
 491                 .compatible = "motorola,cpcap-regulator",
 492         },
 493         {
 494                 .compatible = "motorola,mapphone-cpcap-regulator",
 495                 .data = omap4_regulators,
 496         },
 497         {
 498                 .compatible = "motorola,xoom-cpcap-regulator",
 499                 .data = xoom_regulators,
 500         },
 501         {},
 502 };
 503 MODULE_DEVICE_TABLE(of, cpcap_regulator_id_table);
 504
 505 static int cpcap_regulator_probe(struct platform_device *pdev)
 506 {
 507         struct cpcap_ddata *ddata;
 508         const struct of_device_id *match;
 509         struct regulator_config config;
 510         struct regulator_init_data init_data;
 511         int i;
 512
 513         match = of_match_device(of_match_ptr(cpcap_regulator_id_table),
 514                                 &pdev->dev);
 515         if (!match)
 516                 return -EINVAL;
 517
 518         if (!match->data) {
 519                 dev_err(&pdev->dev, "no configuration data found\n");
 520
 521                 return -ENODEV;
 522         }
 523
 524         ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
 525         if (!ddata)
 526                 return -ENOMEM;
 527
 528         ddata->reg = dev_get_regmap(pdev->dev.parent, NULL);
 529         if (!ddata->reg)
 530                 return -ENODEV;
 531
 532         ddata->dev = &pdev->dev;
 533         ddata->soc = match->data;
 534         platform_set_drvdata(pdev, ddata);
 535
 536         memset(&config, 0, sizeof(config));
 537         memset(&init_data, 0, sizeof(init_data));
 538         config.dev = &pdev->dev;
 539         config.regmap = ddata->reg;
 540         config.init_data = &init_data;
 541
 542         for (i = 0; i < CPCAP_NR_REGULATORS; i++) {
 543                 const struct cpcap_regulator *regulator = &ddata->soc[i];
 544                 struct regulator_dev *rdev;
 545
 546                 if (!regulator->rdesc.name)
 547                         break;
 548
 549                 if (regulator->rdesc.volt_table == unknown_val_tbl)
 550                         continue;
 551
 552                 config.driver_data = (void *)regulator;
 553                 rdev = devm_regulator_register(&pdev->dev,
 554                                                &regulator->rdesc,
 555                                                &config);
 556                 if (IS_ERR(rdev)) {
 557                         dev_err(&pdev->dev, "failed to register regulator %s\n",
 558                                 regulator->rdesc.name);
 559
 560                         return PTR_ERR(rdev);
 561                 }
 562         }
 563
 564         return 0;
 565 }
 566
 567 static struct platform_driver cpcap_regulator_driver = {
 568         .probe          = cpcap_regulator_probe,
 569         .driver         = {
 570                 .name   = "cpcap-regulator",
 571                 .of_match_table = of_match_ptr(cpcap_regulator_id_table),
 572         },
 573 };
 574
 575 module_platform_driver(cpcap_regulator_driver);
 576
 577 MODULE_ALIAS("platform:cpcap-regulator");
 578 MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
 579 MODULE_DESCRIPTION("CPCAP regulator driver");
 580 MODULE_LICENSE("GPL v2");