drivers/regulator/palmas-regulator.c

   1 /*
   2  * Driver for Regulator part of Palmas PMIC Chips
   3  *
   4  * Copyright 2011-2013 Texas Instruments Inc.
   5  *
   6  * Author: Graeme Gregory <gg@slimlogic.co.uk>
   7  * Author: Ian Lartey <ian@slimlogic.co.uk>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify it
  10  *  under  the terms of the GNU General  Public License as published by the
  11  *  Free Software Foundation;  either version 2 of the License, or (at your
  12  *  option) any later version.
  13  *
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/err.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/regulator/driver.h>
  22 #include <linux/regulator/machine.h>
  23 #include <linux/slab.h>
  24 #include <linux/regmap.h>
  25 #include <linux/mfd/palmas.h>
  26 #include <linux/of.h>
  27 #include <linux/of_platform.h>
  28 #include <linux/regulator/of_regulator.h>
  29
  30 static const struct regulator_linear_range smps_low_ranges[] = {
  31         REGULATOR_LINEAR_RANGE(0, 0x0, 0x0, 0),
  32         REGULATOR_LINEAR_RANGE(500000, 0x1, 0x6, 0),
  33         REGULATOR_LINEAR_RANGE(510000, 0x7, 0x79, 10000),
  34         REGULATOR_LINEAR_RANGE(1650000, 0x7A, 0x7f, 0),
  35 };
  36
  37 static const struct regulator_linear_range smps_high_ranges[] = {
  38         REGULATOR_LINEAR_RANGE(0, 0x0, 0x0, 0),
  39         REGULATOR_LINEAR_RANGE(1000000, 0x1, 0x6, 0),
  40         REGULATOR_LINEAR_RANGE(1020000, 0x7, 0x79, 20000),
  41         REGULATOR_LINEAR_RANGE(3300000, 0x7A, 0x7f, 0),
  42 };
  43
  44 static struct regs_info palmas_regs_info[] = {
  45         {
  46                 .name           = "SMPS12",
  47                 .sname          = "smps1-in",
  48                 .vsel_addr      = PALMAS_SMPS12_VOLTAGE,
  49                 .ctrl_addr      = PALMAS_SMPS12_CTRL,
  50                 .tstep_addr     = PALMAS_SMPS12_TSTEP,
  51                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS12,
  52         },
  53         {
  54                 .name           = "SMPS123",
  55                 .sname          = "smps1-in",
  56                 .vsel_addr      = PALMAS_SMPS12_VOLTAGE,
  57                 .ctrl_addr      = PALMAS_SMPS12_CTRL,
  58                 .tstep_addr     = PALMAS_SMPS12_TSTEP,
  59                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS12,
  60         },
  61         {
  62                 .name           = "SMPS3",
  63                 .sname          = "smps3-in",
  64                 .vsel_addr      = PALMAS_SMPS3_VOLTAGE,
  65                 .ctrl_addr      = PALMAS_SMPS3_CTRL,
  66                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS3,
  67         },
  68         {
  69                 .name           = "SMPS45",
  70                 .sname          = "smps4-in",
  71                 .vsel_addr      = PALMAS_SMPS45_VOLTAGE,
  72                 .ctrl_addr      = PALMAS_SMPS45_CTRL,
  73                 .tstep_addr     = PALMAS_SMPS45_TSTEP,
  74                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS45,
  75         },
  76         {
  77                 .name           = "SMPS457",
  78                 .sname          = "smps4-in",
  79                 .vsel_addr      = PALMAS_SMPS45_VOLTAGE,
  80                 .ctrl_addr      = PALMAS_SMPS45_CTRL,
  81                 .tstep_addr     = PALMAS_SMPS45_TSTEP,
  82                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS45,
  83         },
  84         {
  85                 .name           = "SMPS6",
  86                 .sname          = "smps6-in",
  87                 .vsel_addr      = PALMAS_SMPS6_VOLTAGE,
  88                 .ctrl_addr      = PALMAS_SMPS6_CTRL,
  89                 .tstep_addr     = PALMAS_SMPS6_TSTEP,
  90                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS6,
  91         },
  92         {
  93                 .name           = "SMPS7",
  94                 .sname          = "smps7-in",
  95                 .vsel_addr      = PALMAS_SMPS7_VOLTAGE,
  96                 .ctrl_addr      = PALMAS_SMPS7_CTRL,
  97                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS7,
  98         },
  99         {
 100                 .name           = "SMPS8",
 101                 .sname          = "smps8-in",
 102                 .vsel_addr      = PALMAS_SMPS8_VOLTAGE,
 103                 .ctrl_addr      = PALMAS_SMPS8_CTRL,
 104                 .tstep_addr     = PALMAS_SMPS8_TSTEP,
 105                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS8,
 106         },
 107         {
 108                 .name           = "SMPS9",
 109                 .sname          = "smps9-in",
 110                 .vsel_addr      = PALMAS_SMPS9_VOLTAGE,
 111                 .ctrl_addr      = PALMAS_SMPS9_CTRL,
 112                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS9,
 113         },
 114         {
 115                 .name           = "SMPS10_OUT2",
 116                 .sname          = "smps10-in",
 117                 .ctrl_addr      = PALMAS_SMPS10_CTRL,
 118                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS10,
 119         },
 120         {
 121                 .name           = "SMPS10_OUT1",
 122                 .sname          = "smps10-out2",
 123                 .ctrl_addr      = PALMAS_SMPS10_CTRL,
 124                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS10,
 125         },
 126         {
 127                 .name           = "LDO1",
 128                 .sname          = "ldo1-in",
 129                 .vsel_addr      = PALMAS_LDO1_VOLTAGE,
 130                 .ctrl_addr      = PALMAS_LDO1_CTRL,
 131                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO1,
 132         },
 133         {
 134                 .name           = "LDO2",
 135                 .sname          = "ldo2-in",
 136                 .vsel_addr      = PALMAS_LDO2_VOLTAGE,
 137                 .ctrl_addr      = PALMAS_LDO2_CTRL,
 138                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO2,
 139         },
 140         {
 141                 .name           = "LDO3",
 142                 .sname          = "ldo3-in",
 143                 .vsel_addr      = PALMAS_LDO3_VOLTAGE,
 144                 .ctrl_addr      = PALMAS_LDO3_CTRL,
 145                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO3,
 146         },
 147         {
 148                 .name           = "LDO4",
 149                 .sname          = "ldo4-in",
 150                 .vsel_addr      = PALMAS_LDO4_VOLTAGE,
 151                 .ctrl_addr      = PALMAS_LDO4_CTRL,
 152                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO4,
 153         },
 154         {
 155                 .name           = "LDO5",
 156                 .sname          = "ldo5-in",
 157                 .vsel_addr      = PALMAS_LDO5_VOLTAGE,
 158                 .ctrl_addr      = PALMAS_LDO5_CTRL,
 159                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO5,
 160         },
 161         {
 162                 .name           = "LDO6",
 163                 .sname          = "ldo6-in",
 164                 .vsel_addr      = PALMAS_LDO6_VOLTAGE,
 165                 .ctrl_addr      = PALMAS_LDO6_CTRL,
 166                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO6,
 167         },
 168         {
 169                 .name           = "LDO7",
 170                 .sname          = "ldo7-in",
 171                 .vsel_addr      = PALMAS_LDO7_VOLTAGE,
 172                 .ctrl_addr      = PALMAS_LDO7_CTRL,
 173                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO7,
 174         },
 175         {
 176                 .name           = "LDO8",
 177                 .sname          = "ldo8-in",
 178                 .vsel_addr      = PALMAS_LDO8_VOLTAGE,
 179                 .ctrl_addr      = PALMAS_LDO8_CTRL,
 180                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO8,
 181         },
 182         {
 183                 .name           = "LDO9",
 184                 .sname          = "ldo9-in",
 185                 .vsel_addr      = PALMAS_LDO9_VOLTAGE,
 186                 .ctrl_addr      = PALMAS_LDO9_CTRL,
 187                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO9,
 188         },
 189         {
 190                 .name           = "LDOLN",
 191                 .sname          = "ldoln-in",
 192                 .vsel_addr      = PALMAS_LDOLN_VOLTAGE,
 193                 .ctrl_addr      = PALMAS_LDOLN_CTRL,
 194                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDOLN,
 195         },
 196         {
 197                 .name           = "LDOUSB",
 198                 .sname          = "ldousb-in",
 199                 .vsel_addr      = PALMAS_LDOUSB_VOLTAGE,
 200                 .ctrl_addr      = PALMAS_LDOUSB_CTRL,
 201                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDOUSB,
 202         },
 203         {
 204                 .name           = "REGEN1",
 205                 .ctrl_addr      = PALMAS_REGEN1_CTRL,
 206                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_REGEN1,
 207         },
 208         {
 209                 .name           = "REGEN2",
 210                 .ctrl_addr      = PALMAS_REGEN2_CTRL,
 211                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_REGEN2,
 212         },
 213         {
 214                 .name           = "REGEN3",
 215                 .ctrl_addr      = PALMAS_REGEN3_CTRL,
 216                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_REGEN3,
 217         },
 218         {
 219                 .name           = "SYSEN1",
 220                 .ctrl_addr      = PALMAS_SYSEN1_CTRL,
 221                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SYSEN1,
 222         },
 223         {
 224                 .name           = "SYSEN2",
 225                 .ctrl_addr      = PALMAS_SYSEN2_CTRL,
 226                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SYSEN2,
 227         },
 228 };
 229
 230 #define EXTERNAL_REQUESTOR(_id, _offset, _pos)          \
 231         [PALMAS_EXTERNAL_REQSTR_ID_##_id] = {           \
 232                 .id = PALMAS_EXTERNAL_REQSTR_ID_##_id,  \
 233                 .reg_offset = _offset,                  \
 234                 .bit_pos = _pos,                        \
 235         }
 236
 237 struct palmas_sleep_requestor_info palma_sleep_req_info[] = {
 238         EXTERNAL_REQUESTOR(REGEN1, 0, 0),
 239         EXTERNAL_REQUESTOR(REGEN2, 0, 1),
 240         EXTERNAL_REQUESTOR(SYSEN1, 0, 2),
 241         EXTERNAL_REQUESTOR(SYSEN2, 0, 3),
 242         EXTERNAL_REQUESTOR(CLK32KG, 0, 4),
 243         EXTERNAL_REQUESTOR(CLK32KGAUDIO, 0, 5),
 244         EXTERNAL_REQUESTOR(REGEN3, 0, 6),
 245         EXTERNAL_REQUESTOR(SMPS12, 1, 0),
 246         EXTERNAL_REQUESTOR(SMPS3, 1, 1),
 247         EXTERNAL_REQUESTOR(SMPS45, 1, 2),
 248         EXTERNAL_REQUESTOR(SMPS6, 1, 3),
 249         EXTERNAL_REQUESTOR(SMPS7, 1, 4),
 250         EXTERNAL_REQUESTOR(SMPS8, 1, 5),
 251         EXTERNAL_REQUESTOR(SMPS9, 1, 6),
 252         EXTERNAL_REQUESTOR(SMPS10, 1, 7),
 253         EXTERNAL_REQUESTOR(LDO1, 2, 0),
 254         EXTERNAL_REQUESTOR(LDO2, 2, 1),
 255         EXTERNAL_REQUESTOR(LDO3, 2, 2),
 256         EXTERNAL_REQUESTOR(LDO4, 2, 3),
 257         EXTERNAL_REQUESTOR(LDO5, 2, 4),
 258         EXTERNAL_REQUESTOR(LDO6, 2, 5),
 259         EXTERNAL_REQUESTOR(LDO7, 2, 6),
 260         EXTERNAL_REQUESTOR(LDO8, 2, 7),
 261         EXTERNAL_REQUESTOR(LDO9, 3, 0),
 262         EXTERNAL_REQUESTOR(LDOLN, 3, 1),
 263         EXTERNAL_REQUESTOR(LDOUSB, 3, 2),
 264 };
 265
 266 static unsigned int palmas_smps_ramp_delay[4] = {0, 10000, 5000, 2500};
 267
 268 #define SMPS_CTRL_MODE_OFF              0x00
 269 #define SMPS_CTRL_MODE_ON               0x01
 270 #define SMPS_CTRL_MODE_ECO              0x02
 271 #define SMPS_CTRL_MODE_PWM              0x03
 272
 273 #define PALMAS_SMPS_NUM_VOLTAGES        122
 274 #define PALMAS_SMPS10_NUM_VOLTAGES      2
 275 #define PALMAS_LDO_NUM_VOLTAGES         50
 276
 277 #define SMPS10_VSEL                     (1<<3)
 278 #define SMPS10_BOOST_EN                 (1<<2)
 279 #define SMPS10_BYPASS_EN                (1<<1)
 280 #define SMPS10_SWITCH_EN                (1<<0)
 281
 282 #define REGULATOR_SLAVE                 0
 283
 284 static int palmas_smps_read(struct palmas *palmas, unsigned int reg,
 285                 unsigned int *dest)
 286 {
 287         unsigned int addr;
 288
 289         addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
 290
 291         return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
 292 }
 293
 294 static int palmas_smps_write(struct palmas *palmas, unsigned int reg,
 295                 unsigned int value)
 296 {
 297         unsigned int addr;
 298
 299         addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
 300
 301         return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
 302 }
 303
 304 static int palmas_ldo_read(struct palmas *palmas, unsigned int reg,
 305                 unsigned int *dest)
 306 {
 307         unsigned int addr;
 308
 309         addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
 310
 311         return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
 312 }
 313
 314 static int palmas_ldo_write(struct palmas *palmas, unsigned int reg,
 315                 unsigned int value)
 316 {
 317         unsigned int addr;
 318
 319         addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
 320
 321         return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
 322 }
 323
 324 static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode)
 325 {
 326         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 327         struct palmas_pmic_driver_data *ddata = pmic->palmas->pmic_ddata;
 328         int id = rdev_get_id(dev);
 329         unsigned int reg;
 330         bool rail_enable = true;
 331
 332         palmas_smps_read(pmic->palmas, ddata->palmas_regs_info[id].ctrl_addr,
 333                          &reg);
 334
 335         reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 336
 337         if (reg == SMPS_CTRL_MODE_OFF)
 338                 rail_enable = false;
 339
 340         switch (mode) {
 341         case REGULATOR_MODE_NORMAL:
 342                 reg |= SMPS_CTRL_MODE_ON;
 343                 break;
 344         case REGULATOR_MODE_IDLE:
 345                 reg |= SMPS_CTRL_MODE_ECO;
 346                 break;
 347         case REGULATOR_MODE_FAST:
 348                 reg |= SMPS_CTRL_MODE_PWM;
 349                 break;
 350         default:
 351                 return -EINVAL;
 352         }
 353
 354         pmic->current_reg_mode[id] = reg & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 355         if (rail_enable)
 356                 palmas_smps_write(pmic->palmas,
 357                                   ddata->palmas_regs_info[id].ctrl_addr, reg);
 358         return 0;
 359 }
 360
 361 static unsigned int palmas_get_mode_smps(struct regulator_dev *dev)
 362 {
 363         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 364         int id = rdev_get_id(dev);
 365         unsigned int reg;
 366
 367         reg = pmic->current_reg_mode[id] & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 368
 369         switch (reg) {
 370         case SMPS_CTRL_MODE_ON:
 371                 return REGULATOR_MODE_NORMAL;
 372         case SMPS_CTRL_MODE_ECO:
 373                 return REGULATOR_MODE_IDLE;
 374         case SMPS_CTRL_MODE_PWM:
 375                 return REGULATOR_MODE_FAST;
 376         }
 377
 378         return 0;
 379 }
 380
 381 static int palmas_smps_set_ramp_delay(struct regulator_dev *rdev,
 382                  int ramp_delay)
 383 {
 384         struct palmas_pmic *pmic = rdev_get_drvdata(rdev);
 385         struct palmas_pmic_driver_data *ddata = pmic->palmas->pmic_ddata;
 386         int id = rdev_get_id(rdev);
 387         unsigned int reg = 0;
 388         unsigned int addr = ddata->palmas_regs_info[id].tstep_addr;
 389         int ret;
 390
 391         /* SMPS3 and SMPS7 do not have tstep_addr setting */
 392         switch (id) {
 393         case PALMAS_REG_SMPS3:
 394         case PALMAS_REG_SMPS7:
 395                 return 0;
 396         }
 397
 398         if (ramp_delay <= 0)
 399                 reg = 0;
 400         else if (ramp_delay <= 2500)
 401                 reg = 3;
 402         else if (ramp_delay <= 5000)
 403                 reg = 2;
 404         else
 405                 reg = 1;
 406
 407         ret = palmas_smps_write(pmic->palmas, addr, reg);
 408         if (ret < 0) {
 409                 dev_err(pmic->palmas->dev, "TSTEP write failed: %d\n", ret);
 410                 return ret;
 411         }
 412
 413         pmic->ramp_delay[id] = palmas_smps_ramp_delay[reg];
 414         return ret;
 415 }
 416
 417 static struct regulator_ops palmas_ops_smps = {
 418         .is_enabled             = regulator_is_enabled_regmap,
 419         .enable                 = regulator_enable_regmap,
 420         .disable                = regulator_disable_regmap,
 421         .set_mode               = palmas_set_mode_smps,
 422         .get_mode               = palmas_get_mode_smps,
 423         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 424         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 425         .list_voltage           = regulator_list_voltage_linear_range,
 426         .map_voltage            = regulator_map_voltage_linear_range,
 427         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 428         .set_ramp_delay         = palmas_smps_set_ramp_delay,
 429 };
 430
 431 static struct regulator_ops palmas_ops_ext_control_smps = {
 432         .set_mode               = palmas_set_mode_smps,
 433         .get_mode               = palmas_get_mode_smps,
 434         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 435         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 436         .list_voltage           = regulator_list_voltage_linear_range,
 437         .map_voltage            = regulator_map_voltage_linear_range,
 438         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 439         .set_ramp_delay         = palmas_smps_set_ramp_delay,
 440 };
 441
 442 static struct regulator_ops palmas_ops_smps10 = {
 443         .is_enabled             = regulator_is_enabled_regmap,
 444         .enable                 = regulator_enable_regmap,
 445         .disable                = regulator_disable_regmap,
 446         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 447         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 448         .list_voltage           = regulator_list_voltage_linear,
 449         .map_voltage            = regulator_map_voltage_linear,
 450         .set_bypass             = regulator_set_bypass_regmap,
 451         .get_bypass             = regulator_get_bypass_regmap,
 452 };
 453
 454 static int palmas_is_enabled_ldo(struct regulator_dev *dev)
 455 {
 456         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 457         struct palmas_pmic_driver_data *ddata = pmic->palmas->pmic_ddata;
 458         int id = rdev_get_id(dev);
 459         unsigned int reg;
 460
 461         palmas_ldo_read(pmic->palmas,
 462                         ddata->palmas_regs_info[id].ctrl_addr, &reg);
 463
 464         reg &= PALMAS_LDO1_CTRL_STATUS;
 465
 466         return !!(reg);
 467 }
 468
 469 static struct regulator_ops palmas_ops_ldo = {
 470         .is_enabled             = palmas_is_enabled_ldo,
 471         .enable                 = regulator_enable_regmap,
 472         .disable                = regulator_disable_regmap,
 473         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 474         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 475         .list_voltage           = regulator_list_voltage_linear,
 476         .map_voltage            = regulator_map_voltage_linear,
 477 };
 478
 479 static struct regulator_ops palmas_ops_ext_control_ldo = {
 480         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 481         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 482         .list_voltage           = regulator_list_voltage_linear,
 483         .map_voltage            = regulator_map_voltage_linear,
 484 };
 485
 486 static struct regulator_ops palmas_ops_extreg = {
 487         .is_enabled             = regulator_is_enabled_regmap,
 488         .enable                 = regulator_enable_regmap,
 489         .disable                = regulator_disable_regmap,
 490 };
 491
 492 static struct regulator_ops palmas_ops_ext_control_extreg = {
 493 };
 494
 495 static int palmas_regulator_config_external(struct palmas *palmas, int id,
 496                 struct palmas_reg_init *reg_init)
 497 {
 498         int sleep_id = palmas_regs_info[id].sleep_id;
 499         int ret;
 500
 501         ret = palmas_ext_control_req_config(palmas, sleep_id,
 502                                         reg_init->roof_floor, true);
 503         if (ret < 0)
 504                 dev_err(palmas->dev,
 505                         "Ext control config for regulator %d failed %d\n",
 506                         id, ret);
 507         return ret;
 508 }
 509
 510 /*
 511  * setup the hardware based sleep configuration of the SMPS/LDO regulators
 512  * from the platform data. This is different to the software based control
 513  * supported by the regulator framework as it is controlled by toggling
 514  * pins on the PMIC such as PREQ, SYSEN, ...
 515  */
 516 static int palmas_smps_init(struct palmas *palmas, int id,
 517                 struct palmas_reg_init *reg_init)
 518 {
 519         unsigned int reg;
 520         unsigned int addr;
 521         int ret;
 522
 523         struct palmas_pmic_driver_data *ddata = palmas->pmic_ddata;
 524
 525         addr = ddata->palmas_regs_info[id].ctrl_addr;
 526
 527         ret = palmas_smps_read(palmas, addr, &reg);
 528         if (ret)
 529                 return ret;
 530
 531         switch (id) {
 532         case PALMAS_REG_SMPS10_OUT1:
 533         case PALMAS_REG_SMPS10_OUT2:
 534                 reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK;
 535                 if (reg_init->mode_sleep)
 536                         reg |= reg_init->mode_sleep <<
 537                                         PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT;
 538                 break;
 539         default:
 540                 if (reg_init->warm_reset)
 541                         reg |= PALMAS_SMPS12_CTRL_WR_S;
 542                 else
 543                         reg &= ~PALMAS_SMPS12_CTRL_WR_S;
 544
 545                 if (reg_init->roof_floor)
 546                         reg |= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN;
 547                 else
 548                         reg &= ~PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN;
 549
 550                 reg &= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK;
 551                 if (reg_init->mode_sleep)
 552                         reg |= reg_init->mode_sleep <<
 553                                         PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT;
 554         }
 555
 556         ret = palmas_smps_write(palmas, addr, reg);
 557         if (ret)
 558                 return ret;
 559
 560         if (ddata->palmas_regs_info[id].vsel_addr && reg_init->vsel) {
 561                 addr = ddata->palmas_regs_info[id].vsel_addr;
 562
 563                 reg = reg_init->vsel;
 564
 565                 ret = palmas_smps_write(palmas, addr, reg);
 566                 if (ret)
 567                         return ret;
 568         }
 569
 570         if (reg_init->roof_floor && (id != PALMAS_REG_SMPS10_OUT1) &&
 571                         (id != PALMAS_REG_SMPS10_OUT2)) {
 572                 /* Enable externally controlled regulator */
 573                 addr = ddata->palmas_regs_info[id].ctrl_addr;
 574                 ret = palmas_smps_read(palmas, addr, &reg);
 575                 if (ret < 0)
 576                         return ret;
 577
 578                 if (!(reg & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK)) {
 579                         reg |= SMPS_CTRL_MODE_ON;
 580                         ret = palmas_smps_write(palmas, addr, reg);
 581                         if (ret < 0)
 582                                 return ret;
 583                 }
 584                 return palmas_regulator_config_external(palmas, id, reg_init);
 585         }
 586         return 0;
 587 }
 588
 589 static int palmas_ldo_init(struct palmas *palmas, int id,
 590                 struct palmas_reg_init *reg_init)
 591 {
 592         unsigned int reg;
 593         unsigned int addr;
 594         int ret;
 595
 596         struct palmas_pmic_driver_data *ddata = palmas->pmic_ddata;
 597
 598         addr = ddata->palmas_regs_info[id].ctrl_addr;
 599
 600         ret = palmas_ldo_read(palmas, addr, &reg);
 601         if (ret)
 602                 return ret;
 603
 604         if (reg_init->warm_reset)
 605                 reg |= PALMAS_LDO1_CTRL_WR_S;
 606         else
 607                 reg &= ~PALMAS_LDO1_CTRL_WR_S;
 608
 609         if (reg_init->mode_sleep)
 610                 reg |= PALMAS_LDO1_CTRL_MODE_SLEEP;
 611         else
 612                 reg &= ~PALMAS_LDO1_CTRL_MODE_SLEEP;
 613
 614         ret = palmas_ldo_write(palmas, addr, reg);
 615         if (ret)
 616                 return ret;
 617
 618         if (reg_init->roof_floor) {
 619                 /* Enable externally controlled regulator */
 620                 addr = ddata->palmas_regs_info[id].ctrl_addr;
 621                 ret = palmas_update_bits(palmas, PALMAS_LDO_BASE,
 622                                 addr, PALMAS_LDO1_CTRL_MODE_ACTIVE,
 623                                 PALMAS_LDO1_CTRL_MODE_ACTIVE);
 624                 if (ret < 0) {
 625                         dev_err(palmas->dev,
 626                                 "LDO Register 0x%02x update failed %d\n",
 627                                 addr, ret);
 628                         return ret;
 629                 }
 630                 return palmas_regulator_config_external(palmas, id, reg_init);
 631         }
 632         return 0;
 633 }
 634
 635 static int palmas_extreg_init(struct palmas *palmas, int id,
 636                 struct palmas_reg_init *reg_init)
 637 {
 638         unsigned int addr;
 639         int ret;
 640         unsigned int val = 0;
 641
 642         struct palmas_pmic_driver_data *ddata = palmas->pmic_ddata;
 643
 644         addr = ddata->palmas_regs_info[id].ctrl_addr;
 645
 646         if (reg_init->mode_sleep)
 647                 val = PALMAS_REGEN1_CTRL_MODE_SLEEP;
 648
 649         ret = palmas_update_bits(palmas, PALMAS_RESOURCE_BASE,
 650                         addr, PALMAS_REGEN1_CTRL_MODE_SLEEP, val);
 651         if (ret < 0) {
 652                 dev_err(palmas->dev, "Resource reg 0x%02x update failed %d\n",
 653                         addr, ret);
 654                 return ret;
 655         }
 656
 657         if (reg_init->roof_floor) {
 658                 /* Enable externally controlled regulator */
 659                 addr = ddata->palmas_regs_info[id].ctrl_addr;
 660                 ret = palmas_update_bits(palmas, PALMAS_RESOURCE_BASE,
 661                                 addr, PALMAS_REGEN1_CTRL_MODE_ACTIVE,
 662                                 PALMAS_REGEN1_CTRL_MODE_ACTIVE);
 663                 if (ret < 0) {
 664                         dev_err(palmas->dev,
 665                                 "Resource Register 0x%02x update failed %d\n",
 666                                 addr, ret);
 667                         return ret;
 668                 }
 669                 return palmas_regulator_config_external(palmas, id, reg_init);
 670         }
 671         return 0;
 672 }
 673
 674 static void palmas_enable_ldo8_track(struct palmas *palmas)
 675 {
 676         unsigned int reg;
 677         unsigned int addr;
 678         int ret;
 679
 680         struct palmas_pmic_driver_data *ddata = palmas->pmic_ddata;
 681
 682         addr = ddata->palmas_regs_info[PALMAS_REG_LDO8].ctrl_addr;
 683
 684         ret = palmas_ldo_read(palmas, addr, &reg);
 685         if (ret) {
 686                 dev_err(palmas->dev, "Error in reading ldo8 control reg\n");
 687                 return;
 688         }
 689
 690         reg |= PALMAS_LDO8_CTRL_LDO_TRACKING_EN;
 691         ret = palmas_ldo_write(palmas, addr, reg);
 692         if (ret < 0) {
 693                 dev_err(palmas->dev, "Error in enabling tracking mode\n");
 694                 return;
 695         }
 696         /*
 697          * When SMPS45 is set to off and LDO8 tracking is enabled, the LDO8
 698          * output is defined by the LDO8_VOLTAGE.VSEL register divided by two,
 699          * and can be set from 0.45 to 1.65 V.
 700          */
 701         addr = ddata->palmas_regs_info[PALMAS_REG_LDO8].vsel_addr;
 702         ret = palmas_ldo_read(palmas, addr, &reg);
 703         if (ret) {
 704                 dev_err(palmas->dev, "Error in reading ldo8 voltage reg\n");
 705                 return;
 706         }
 707
 708         reg = (reg << 1) & PALMAS_LDO8_VOLTAGE_VSEL_MASK;
 709         ret = palmas_ldo_write(palmas, addr, reg);
 710         if (ret < 0)
 711                 dev_err(palmas->dev, "Error in setting ldo8 voltage reg\n");
 712
 713         return;
 714 }
 715
 716 static int palmas_ldo_registration(struct palmas_pmic *pmic,
 717                                    struct palmas_pmic_driver_data *ddata,
 718                                    struct palmas_pmic_platform_data *pdata,
 719                                    const char *pdev_name,
 720                                    struct regulator_config config)
 721 {
 722         int id, ret;
 723         struct regulator_dev *rdev;
 724         struct palmas_reg_init *reg_init;
 725
 726         for (id = ddata->ldo_begin; id < ddata->max_reg; id++) {
 727                 if (pdata && pdata->reg_init[id])
 728                         reg_init = pdata->reg_init[id];
 729                 else
 730                         reg_init = NULL;
 731
 732                 /* Miss out regulators which are not available due
 733                  * to alternate functions.
 734                  */
 735
 736                 /* Register the regulators */
 737                 pmic->desc[id].name = ddata->palmas_regs_info[id].name;
 738                 pmic->desc[id].id = id;
 739                 pmic->desc[id].type = REGULATOR_VOLTAGE;
 740                 pmic->desc[id].owner = THIS_MODULE;
 741
 742                 if (id < PALMAS_REG_REGEN1) {
 743                         pmic->desc[id].n_voltages = PALMAS_LDO_NUM_VOLTAGES;
 744                         if (reg_init && reg_init->roof_floor)
 745                                 pmic->desc[id].ops =
 746                                         &palmas_ops_ext_control_ldo;
 747                         else
 748                                 pmic->desc[id].ops = &palmas_ops_ldo;
 749                         pmic->desc[id].min_uV = 900000;
 750                         pmic->desc[id].uV_step = 50000;
 751                         pmic->desc[id].linear_min_sel = 1;
 752                         pmic->desc[id].enable_time = 500;
 753                         pmic->desc[id].vsel_reg =
 754                                         PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
 755                                                            ddata->palmas_regs_info[id].vsel_addr);
 756                         pmic->desc[id].vsel_mask =
 757                                         PALMAS_LDO1_VOLTAGE_VSEL_MASK;
 758                         pmic->desc[id].enable_reg =
 759                                         PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
 760                                                            ddata->palmas_regs_info[id].ctrl_addr);
 761                         pmic->desc[id].enable_mask =
 762                                         PALMAS_LDO1_CTRL_MODE_ACTIVE;
 763
 764                         /* Check if LDO8 is in tracking mode or not */
 765                         if (pdata && (id == PALMAS_REG_LDO8) &&
 766                             pdata->enable_ldo8_tracking) {
 767                                 palmas_enable_ldo8_track(pmic->palmas);
 768                                 pmic->desc[id].min_uV = 450000;
 769                                 pmic->desc[id].uV_step = 25000;
 770                         }
 771
 772                         /* LOD6 in vibrator mode will have enable time 2000us */
 773                         if (pdata && pdata->ldo6_vibrator &&
 774                             (id == PALMAS_REG_LDO6))
 775                                 pmic->desc[id].enable_time = 2000;
 776                 } else {
 777                         pmic->desc[id].n_voltages = 1;
 778                         if (reg_init && reg_init->roof_floor)
 779                                 pmic->desc[id].ops =
 780                                         &palmas_ops_ext_control_extreg;
 781                         else
 782                                 pmic->desc[id].ops = &palmas_ops_extreg;
 783                         pmic->desc[id].enable_reg =
 784                                         PALMAS_BASE_TO_REG(PALMAS_RESOURCE_BASE,
 785                                                            ddata->palmas_regs_info[id].ctrl_addr);
 786                         pmic->desc[id].enable_mask =
 787                                         PALMAS_REGEN1_CTRL_MODE_ACTIVE;
 788                 }
 789
 790                 if (pdata)
 791                         config.init_data = pdata->reg_data[id];
 792                 else
 793                         config.init_data = NULL;
 794
 795                 pmic->desc[id].supply_name = ddata->palmas_regs_info[id].sname;
 796                 config.of_node = ddata->palmas_matches[id].of_node;
 797
 798                 rdev = devm_regulator_register(pmic->dev, &pmic->desc[id],
 799                                                &config);
 800                 if (IS_ERR(rdev)) {
 801                         dev_err(pmic->dev,
 802                                 "failed to register %s regulator\n",
 803                                 pdev_name);
 804                         return PTR_ERR(rdev);
 805                 }
 806
 807                 /* Save regulator for cleanup */
 808                 pmic->rdev[id] = rdev;
 809
 810                 /* Initialise sleep/init values from platform data */
 811                 if (pdata) {
 812                         reg_init = pdata->reg_init[id];
 813                         if (reg_init) {
 814                                 if (id <= ddata->ldo_end)
 815                                         ret = palmas_ldo_init(pmic->palmas, id,
 816                                                               reg_init);
 817                                 else
 818                                         ret = palmas_extreg_init(pmic->palmas,
 819                                                                  id, reg_init);
 820                                 if (ret)
 821                                         return ret;
 822                         }
 823                 }
 824         }
 825
 826         return 0;
 827 }
 828
 829 static int palmas_smps_registration(struct palmas_pmic *pmic,
 830                                     struct palmas_pmic_driver_data *ddata,
 831                                     struct palmas_pmic_platform_data *pdata,
 832                                     const char *pdev_name,
 833                                     struct regulator_config config)
 834 {
 835         int id, ret;
 836         unsigned int addr, reg;
 837         struct regulator_dev *rdev;
 838         struct palmas_reg_init *reg_init;
 839
 840         for (id = ddata->smps_start; id <= ddata->smps_end; id++) {
 841                 bool ramp_delay_support = false;
 842
 843                 /*
 844                  * Miss out regulators which are not available due
 845                  * to slaving configurations.
 846                  */
 847                 switch (id) {
 848                 case PALMAS_REG_SMPS12:
 849                 case PALMAS_REG_SMPS3:
 850                         if (pmic->smps123)
 851                                 continue;
 852                         if (id == PALMAS_REG_SMPS12)
 853                                 ramp_delay_support = true;
 854                         break;
 855                 case PALMAS_REG_SMPS123:
 856                         if (!pmic->smps123)
 857                                 continue;
 858                         ramp_delay_support = true;
 859                         break;
 860                 case PALMAS_REG_SMPS45:
 861                 case PALMAS_REG_SMPS7:
 862                         if (pmic->smps457)
 863                                 continue;
 864                         if (id == PALMAS_REG_SMPS45)
 865                                 ramp_delay_support = true;
 866                         break;
 867                 case PALMAS_REG_SMPS457:
 868                         if (!pmic->smps457)
 869                                 continue;
 870                         ramp_delay_support = true;
 871                         break;
 872                 case PALMAS_REG_SMPS10_OUT1:
 873                 case PALMAS_REG_SMPS10_OUT2:
 874                         if (!PALMAS_PMIC_HAS(pmic->palmas, SMPS10_BOOST))
 875                                 continue;
 876                 }
 877
 878                 if ((id == PALMAS_REG_SMPS6) || (id == PALMAS_REG_SMPS8))
 879                         ramp_delay_support = true;
 880
 881                 if (ramp_delay_support) {
 882                         addr = ddata->palmas_regs_info[id].tstep_addr;
 883                         ret = palmas_smps_read(pmic->palmas, addr, &reg);
 884                         if (ret < 0) {
 885                                 dev_err(pmic->dev,
 886                                         "reading TSTEP reg failed: %d\n", ret);
 887                                 return ret;
 888                         }
 889                         pmic->desc[id].ramp_delay =
 890                                         palmas_smps_ramp_delay[reg & 0x3];
 891                         pmic->ramp_delay[id] = pmic->desc[id].ramp_delay;
 892                 }
 893
 894                 /* Initialise sleep/init values from platform data */
 895                 if (pdata && pdata->reg_init[id]) {
 896                         reg_init = pdata->reg_init[id];
 897                         ret = palmas_smps_init(pmic->palmas, id, reg_init);
 898                         if (ret)
 899                                 return ret;
 900                 } else {
 901                         reg_init = NULL;
 902                 }
 903
 904                 /* Register the regulators */
 905                 pmic->desc[id].name = ddata->palmas_regs_info[id].name;
 906                 pmic->desc[id].id = id;
 907
 908                 switch (id) {
 909                 case PALMAS_REG_SMPS10_OUT1:
 910                 case PALMAS_REG_SMPS10_OUT2:
 911                         pmic->desc[id].n_voltages = PALMAS_SMPS10_NUM_VOLTAGES;
 912                         pmic->desc[id].ops = &palmas_ops_smps10;
 913                         pmic->desc[id].vsel_reg =
 914                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
 915                                                         PALMAS_SMPS10_CTRL);
 916                         pmic->desc[id].vsel_mask = SMPS10_VSEL;
 917                         pmic->desc[id].enable_reg =
 918                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
 919                                                         PALMAS_SMPS10_CTRL);
 920                         if (id == PALMAS_REG_SMPS10_OUT1)
 921                                 pmic->desc[id].enable_mask = SMPS10_SWITCH_EN;
 922                         else
 923                                 pmic->desc[id].enable_mask = SMPS10_BOOST_EN;
 924                         pmic->desc[id].bypass_reg =
 925                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
 926                                                         PALMAS_SMPS10_CTRL);
 927                         pmic->desc[id].bypass_mask = SMPS10_BYPASS_EN;
 928                         pmic->desc[id].min_uV = 3750000;
 929                         pmic->desc[id].uV_step = 1250000;
 930                         break;
 931                 default:
 932                         /*
 933                          * Read and store the RANGE bit for later use
 934                          * This must be done before regulator is probed,
 935                          * otherwise we error in probe with unsupportable
 936                          * ranges. Read the current smps mode for later use.
 937                          */
 938                         addr = palmas_regs_info[id].vsel_addr;
 939                         pmic->desc[id].n_linear_ranges = 3;
 940
 941                         ret = palmas_smps_read(pmic->palmas, addr, &reg);
 942                         if (ret)
 943                                 return ret;
 944                         if (reg & PALMAS_SMPS12_VOLTAGE_RANGE)
 945                                 pmic->range[id] = 1;
 946                         if (pmic->range[id])
 947                                 pmic->desc[id].linear_ranges = smps_high_ranges;
 948                         else
 949                                 pmic->desc[id].linear_ranges = smps_low_ranges;
 950
 951                         if (reg_init && reg_init->roof_floor)
 952                                 pmic->desc[id].ops =
 953                                                 &palmas_ops_ext_control_smps;
 954                         else
 955                                 pmic->desc[id].ops = &palmas_ops_smps;
 956                         pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
 957                         pmic->desc[id].vsel_reg =
 958                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
 959                                                 palmas_regs_info[id].vsel_addr);
 960                         pmic->desc[id].vsel_mask =
 961                                         PALMAS_SMPS12_VOLTAGE_VSEL_MASK;
 962
 963                         /* Read the smps mode for later use. */
 964                         addr = palmas_regs_info[id].ctrl_addr;
 965                         ret = palmas_smps_read(pmic->palmas, addr, &reg);
 966                         if (ret)
 967                                 return ret;
 968                         pmic->current_reg_mode[id] = reg &
 969                                         PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 970                 }
 971
 972                 pmic->desc[id].type = REGULATOR_VOLTAGE;
 973                 pmic->desc[id].owner = THIS_MODULE;
 974
 975                 if (pdata)
 976                         config.init_data = pdata->reg_data[id];
 977                 else
 978                         config.init_data = NULL;
 979
 980                 pmic->desc[id].supply_name = ddata->palmas_regs_info[id].sname;
 981                 config.of_node = ddata->palmas_matches[id].of_node;
 982
 983                 rdev = devm_regulator_register(pmic->dev, &pmic->desc[id],
 984                                                &config);
 985                 if (IS_ERR(rdev)) {
 986                         dev_err(pmic->dev,
 987                                 "failed to register %s regulator\n",
 988                                 pdev_name);
 989                         return PTR_ERR(rdev);
 990                 }
 991
 992                 /* Save regulator for cleanup */
 993                 pmic->rdev[id] = rdev;
 994         }
 995
 996         return 0;
 997 }
 998
 999 static struct of_regulator_match palmas_matches[] = {
1000         { .name = "smps12", },
1001         { .name = "smps123", },
1002         { .name = "smps3", },
1003         { .name = "smps45", },
1004         { .name = "smps457", },
1005         { .name = "smps6", },
1006         { .name = "smps7", },
1007         { .name = "smps8", },
1008         { .name = "smps9", },
1009         { .name = "smps10_out2", },
1010         { .name = "smps10_out1", },
1011         { .name = "ldo1", },
1012         { .name = "ldo2", },
1013         { .name = "ldo3", },
1014         { .name = "ldo4", },
1015         { .name = "ldo5", },
1016         { .name = "ldo6", },
1017         { .name = "ldo7", },
1018         { .name = "ldo8", },
1019         { .name = "ldo9", },
1020         { .name = "ldoln", },
1021         { .name = "ldousb", },
1022         { .name = "regen1", },
1023         { .name = "regen2", },
1024         { .name = "regen3", },
1025         { .name = "sysen1", },
1026         { .name = "sysen2", },
1027 };
1028
1029 struct palmas_pmic_driver_data palmas_ddata = {
1030         .smps_start = PALMAS_REG_SMPS12,
1031         .smps_end = PALMAS_REG_SMPS10_OUT1,
1032         .ldo_begin = PALMAS_REG_LDO1,
1033         .ldo_end = PALMAS_REG_LDOUSB,
1034         .max_reg = PALMAS_NUM_REGS,
1035         .palmas_regs_info = palmas_regs_info,
1036         .palmas_matches = palmas_matches,
1037         .sleep_req_info = palma_sleep_req_info,
1038         .smps_register = palmas_smps_registration,
1039         .ldo_register = palmas_ldo_registration,
1040 };
1041
1042 static void palmas_dt_to_pdata(struct device *dev,
1043                                struct device_node *node,
1044                                struct palmas_pmic_platform_data *pdata,
1045                                struct palmas_pmic_driver_data *ddata)
1046 {
1047         struct device_node *regulators;
1048         u32 prop;
1049         int idx, ret;
1050
1051         node = of_node_get(node);
1052         regulators = of_get_child_by_name(node, "regulators");
1053         if (!regulators) {
1054                 dev_info(dev, "regulator node not found\n");
1055                 return;
1056         }
1057
1058         ret = of_regulator_match(dev, regulators, ddata->palmas_matches,
1059                                  ddata->max_reg);
1060         of_node_put(regulators);
1061         if (ret < 0) {
1062                 dev_err(dev, "Error parsing regulator init data: %d\n", ret);
1063                 return;
1064         }
1065
1066         for (idx = 0; idx < ddata->max_reg; idx++) {
1067                 if (!ddata->palmas_matches[idx].init_data ||
1068                     !ddata->palmas_matches[idx].of_node)
1069                         continue;
1070
1071                 pdata->reg_data[idx] = ddata->palmas_matches[idx].init_data;
1072
1073                 pdata->reg_init[idx] = devm_kzalloc(dev,
1074                                 sizeof(struct palmas_reg_init), GFP_KERNEL);
1075
1076                 pdata->reg_init[idx]->warm_reset =
1077                         of_property_read_bool(ddata->palmas_matches[idx].of_node,
1078                                               "ti,warm-reset");
1079
1080                 ret = of_property_read_u32(ddata->palmas_matches[idx].of_node,
1081                                            "ti,roof-floor", &prop);
1082                 /* EINVAL: Property not found */
1083                 if (ret != -EINVAL) {
1084                         int econtrol;
1085
1086                         /* use default value, when no value is specified */
1087                         econtrol = PALMAS_EXT_CONTROL_NSLEEP;
1088                         if (!ret) {
1089                                 switch (prop) {
1090                                 case 1:
1091                                         econtrol = PALMAS_EXT_CONTROL_ENABLE1;
1092                                         break;
1093                                 case 2:
1094                                         econtrol = PALMAS_EXT_CONTROL_ENABLE2;
1095                                         break;
1096                                 case 3:
1097                                         econtrol = PALMAS_EXT_CONTROL_NSLEEP;
1098                                         break;
1099                                 default:
1100                                         WARN_ON(1);
1101                                         dev_warn(dev,
1102                                                  "%s: Invalid roof-floor option: %u\n",
1103                                              palmas_matches[idx].name, prop);
1104                                         break;
1105                                 }
1106                         }
1107                         pdata->reg_init[idx]->roof_floor = econtrol;
1108                 }
1109
1110                 ret = of_property_read_u32(ddata->palmas_matches[idx].of_node,
1111                                            "ti,mode-sleep", &prop);
1112                 if (!ret)
1113                         pdata->reg_init[idx]->mode_sleep = prop;
1114
1115                 ret = of_property_read_bool(ddata->palmas_matches[idx].of_node,
1116                                             "ti,smps-range");
1117                 if (ret)
1118                         pdata->reg_init[idx]->vsel =
1119                                 PALMAS_SMPS12_VOLTAGE_RANGE;
1120
1121                 if (idx == PALMAS_REG_LDO8)
1122                         pdata->enable_ldo8_tracking = of_property_read_bool(
1123                                                 ddata->palmas_matches[idx].of_node,
1124                                                 "ti,enable-ldo8-tracking");
1125         }
1126
1127         pdata->ldo6_vibrator = of_property_read_bool(node, "ti,ldo6-vibrator");
1128 }
1129
1130 static struct of_device_id of_palmas_match_tbl[] = {
1131         {
1132                 .compatible = "ti,palmas-pmic",
1133                 .data = &palmas_ddata,
1134         },
1135         {
1136                 .compatible = "ti,twl6035-pmic",
1137                 .data = &palmas_ddata,
1138         },
1139         {
1140                 .compatible = "ti,twl6036-pmic",
1141                 .data = &palmas_ddata,
1142         },
1143         {
1144                 .compatible = "ti,twl6037-pmic",
1145                 .data = &palmas_ddata,
1146         },
1147         {
1148                 .compatible = "ti,tps65913-pmic",
1149                 .data = &palmas_ddata,
1150         },
1151         {
1152                 .compatible = "ti,tps65914-pmic",
1153                 .data = &palmas_ddata,
1154         },
1155         {
1156                 .compatible = "ti,tps80036-pmic",
1157                 .data = &palmas_ddata,
1158         },
1159         {
1160                 .compatible = "ti,tps659038-pmic",
1161                 .data = &palmas_ddata,
1162         },
1163         { /* end */ }
1164 };
1165
1166 static int palmas_regulators_probe(struct platform_device *pdev)
1167 {
1168         struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
1169         struct palmas_pmic_platform_data *pdata = dev_get_platdata(&pdev->dev);
1170         struct device_node *node = pdev->dev.of_node;
1171         struct palmas_pmic_driver_data *driver_data;
1172         struct regulator_config config = { };
1173         struct palmas_pmic *pmic;
1174         const char *pdev_name;
1175         const struct of_device_id *match;
1176         int ret = 0;
1177         unsigned int reg;
1178
1179         match = of_match_device(of_match_ptr(of_palmas_match_tbl), &pdev->dev);
1180
1181         if (!match)
1182                 return -ENODATA;
1183
1184         driver_data = (struct palmas_pmic_driver_data *)match->data;
1185         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1186         if (!pdata)
1187                 return -ENOMEM;
1188
1189         pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
1190         if (!pmic)
1191                 return -ENOMEM;
1192
1193         pmic->dev = &pdev->dev;
1194         pmic->palmas = palmas;
1195         palmas->pmic = pmic;
1196         platform_set_drvdata(pdev, pmic);
1197         pmic->palmas->pmic_ddata = driver_data;
1198
1199         palmas_dt_to_pdata(&pdev->dev, node, pdata, driver_data);
1200
1201         ret = palmas_smps_read(palmas, PALMAS_SMPS_CTRL, &reg);
1202         if (ret)
1203                 return ret;
1204
1205         if (reg & PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN)
1206                 pmic->smps123 = 1;
1207
1208         if (reg & PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN)
1209                 pmic->smps457 = 1;
1210
1211         config.regmap = palmas->regmap[REGULATOR_SLAVE];
1212         config.dev = &pdev->dev;
1213         config.driver_data = pmic;
1214         pdev_name = pdev->name;
1215
1216         ret = driver_data->smps_register(pmic, driver_data, pdata, pdev_name,
1217                                          config);
1218         if (ret)
1219                 return ret;
1220
1221         ret = driver_data->ldo_register(pmic, driver_data, pdata, pdev_name,
1222                                         config);
1223
1224         return ret;
1225 }
1226
1227 static struct platform_driver palmas_driver = {
1228         .driver = {
1229                 .name = "palmas-pmic",
1230                 .of_match_table = of_palmas_match_tbl,
1231                 .owner = THIS_MODULE,
1232         },
1233         .probe = palmas_regulators_probe,
1234 };
1235
1236 static int __init palmas_init(void)
1237 {
1238         return platform_driver_register(&palmas_driver);
1239 }
1240 subsys_initcall(palmas_init);
1241
1242 static void __exit palmas_exit(void)
1243 {
1244         platform_driver_unregister(&palmas_driver);
1245 }
1246 module_exit(palmas_exit);
1247
1248 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
1249 MODULE_DESCRIPTION("Palmas voltage regulator driver");
1250 MODULE_LICENSE("GPL");
1251 MODULE_ALIAS("platform:palmas-pmic");
1252 MODULE_DEVICE_TABLE(of, of_palmas_match_tbl);