drivers/regulator/palmas-regulator.c

   1 /*
   2  * Driver for Regulator part of Palmas PMIC Chips
   3  *
   4  * Copyright 2011-2012 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 struct regs_info {
  31         char    *name;
  32         u8      vsel_addr;
  33         u8      ctrl_addr;
  34         u8      tstep_addr;
  35 };
  36
  37 static const struct regs_info palmas_regs_info[] = {
  38         {
  39                 .name           = "SMPS12",
  40                 .vsel_addr      = PALMAS_SMPS12_VOLTAGE,
  41                 .ctrl_addr      = PALMAS_SMPS12_CTRL,
  42                 .tstep_addr     = PALMAS_SMPS12_TSTEP,
  43         },
  44         {
  45                 .name           = "SMPS123",
  46                 .vsel_addr      = PALMAS_SMPS12_VOLTAGE,
  47                 .ctrl_addr      = PALMAS_SMPS12_CTRL,
  48                 .tstep_addr     = PALMAS_SMPS12_TSTEP,
  49         },
  50         {
  51                 .name           = "SMPS3",
  52                 .vsel_addr      = PALMAS_SMPS3_VOLTAGE,
  53                 .ctrl_addr      = PALMAS_SMPS3_CTRL,
  54         },
  55         {
  56                 .name           = "SMPS45",
  57                 .vsel_addr      = PALMAS_SMPS45_VOLTAGE,
  58                 .ctrl_addr      = PALMAS_SMPS45_CTRL,
  59                 .tstep_addr     = PALMAS_SMPS45_TSTEP,
  60         },
  61         {
  62                 .name           = "SMPS457",
  63                 .vsel_addr      = PALMAS_SMPS45_VOLTAGE,
  64                 .ctrl_addr      = PALMAS_SMPS45_CTRL,
  65                 .tstep_addr     = PALMAS_SMPS45_TSTEP,
  66         },
  67         {
  68                 .name           = "SMPS6",
  69                 .vsel_addr      = PALMAS_SMPS6_VOLTAGE,
  70                 .ctrl_addr      = PALMAS_SMPS6_CTRL,
  71                 .tstep_addr     = PALMAS_SMPS6_TSTEP,
  72         },
  73         {
  74                 .name           = "SMPS7",
  75                 .vsel_addr      = PALMAS_SMPS7_VOLTAGE,
  76                 .ctrl_addr      = PALMAS_SMPS7_CTRL,
  77         },
  78         {
  79                 .name           = "SMPS8",
  80                 .vsel_addr      = PALMAS_SMPS8_VOLTAGE,
  81                 .ctrl_addr      = PALMAS_SMPS8_CTRL,
  82                 .tstep_addr     = PALMAS_SMPS8_TSTEP,
  83         },
  84         {
  85                 .name           = "SMPS9",
  86                 .vsel_addr      = PALMAS_SMPS9_VOLTAGE,
  87                 .ctrl_addr      = PALMAS_SMPS9_CTRL,
  88         },
  89         {
  90                 .name           = "SMPS10",
  91         },
  92         {
  93                 .name           = "LDO1",
  94                 .vsel_addr      = PALMAS_LDO1_VOLTAGE,
  95                 .ctrl_addr      = PALMAS_LDO1_CTRL,
  96         },
  97         {
  98                 .name           = "LDO2",
  99                 .vsel_addr      = PALMAS_LDO2_VOLTAGE,
 100                 .ctrl_addr      = PALMAS_LDO2_CTRL,
 101         },
 102         {
 103                 .name           = "LDO3",
 104                 .vsel_addr      = PALMAS_LDO3_VOLTAGE,
 105                 .ctrl_addr      = PALMAS_LDO3_CTRL,
 106         },
 107         {
 108                 .name           = "LDO4",
 109                 .vsel_addr      = PALMAS_LDO4_VOLTAGE,
 110                 .ctrl_addr      = PALMAS_LDO4_CTRL,
 111         },
 112         {
 113                 .name           = "LDO5",
 114                 .vsel_addr      = PALMAS_LDO5_VOLTAGE,
 115                 .ctrl_addr      = PALMAS_LDO5_CTRL,
 116         },
 117         {
 118                 .name           = "LDO6",
 119                 .vsel_addr      = PALMAS_LDO6_VOLTAGE,
 120                 .ctrl_addr      = PALMAS_LDO6_CTRL,
 121         },
 122         {
 123                 .name           = "LDO7",
 124                 .vsel_addr      = PALMAS_LDO7_VOLTAGE,
 125                 .ctrl_addr      = PALMAS_LDO7_CTRL,
 126         },
 127         {
 128                 .name           = "LDO8",
 129                 .vsel_addr      = PALMAS_LDO8_VOLTAGE,
 130                 .ctrl_addr      = PALMAS_LDO8_CTRL,
 131         },
 132         {
 133                 .name           = "LDO9",
 134                 .vsel_addr      = PALMAS_LDO9_VOLTAGE,
 135                 .ctrl_addr      = PALMAS_LDO9_CTRL,
 136         },
 137         {
 138                 .name           = "LDOLN",
 139                 .vsel_addr      = PALMAS_LDOLN_VOLTAGE,
 140                 .ctrl_addr      = PALMAS_LDOLN_CTRL,
 141         },
 142         {
 143                 .name           = "LDOUSB",
 144                 .vsel_addr      = PALMAS_LDOUSB_VOLTAGE,
 145                 .ctrl_addr      = PALMAS_LDOUSB_CTRL,
 146         },
 147 };
 148
 149 #define SMPS_CTRL_MODE_OFF              0x00
 150 #define SMPS_CTRL_MODE_ON               0x01
 151 #define SMPS_CTRL_MODE_ECO              0x02
 152 #define SMPS_CTRL_MODE_PWM              0x03
 153
 154 /* These values are derived from the data sheet. And are the number of steps
 155  * where there is a voltage change, the ranges at beginning and end of register
 156  * max/min values where there are no change are ommitted.
 157  *
 158  * So they are basically (maxV-minV)/stepV
 159  */
 160 #define PALMAS_SMPS_NUM_VOLTAGES        117
 161 #define PALMAS_SMPS10_NUM_VOLTAGES      2
 162 #define PALMAS_LDO_NUM_VOLTAGES         50
 163
 164 #define SMPS10_VSEL                     (1<<3)
 165 #define SMPS10_BOOST_EN                 (1<<2)
 166 #define SMPS10_BYPASS_EN                (1<<1)
 167 #define SMPS10_SWITCH_EN                (1<<0)
 168
 169 #define REGULATOR_SLAVE                 0
 170
 171 static int palmas_smps_read(struct palmas *palmas, unsigned int reg,
 172                 unsigned int *dest)
 173 {
 174         unsigned int addr;
 175
 176         addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
 177
 178         return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
 179 }
 180
 181 static int palmas_smps_write(struct palmas *palmas, unsigned int reg,
 182                 unsigned int value)
 183 {
 184         unsigned int addr;
 185
 186         addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
 187
 188         return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
 189 }
 190
 191 static int palmas_ldo_read(struct palmas *palmas, unsigned int reg,
 192                 unsigned int *dest)
 193 {
 194         unsigned int addr;
 195
 196         addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
 197
 198         return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
 199 }
 200
 201 static int palmas_ldo_write(struct palmas *palmas, unsigned int reg,
 202                 unsigned int value)
 203 {
 204         unsigned int addr;
 205
 206         addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
 207
 208         return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
 209 }
 210
 211 static int palmas_is_enabled_smps(struct regulator_dev *dev)
 212 {
 213         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 214         int id = rdev_get_id(dev);
 215         unsigned int reg;
 216
 217         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 218
 219         reg &= PALMAS_SMPS12_CTRL_STATUS_MASK;
 220         reg >>= PALMAS_SMPS12_CTRL_STATUS_SHIFT;
 221
 222         return !!(reg);
 223 }
 224
 225 static int palmas_enable_smps(struct regulator_dev *dev)
 226 {
 227         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 228         int id = rdev_get_id(dev);
 229         unsigned int reg;
 230
 231         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 232
 233         reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 234         reg |= SMPS_CTRL_MODE_ON;
 235
 236         palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg);
 237
 238         return 0;
 239 }
 240
 241 static int palmas_disable_smps(struct regulator_dev *dev)
 242 {
 243         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 244         int id = rdev_get_id(dev);
 245         unsigned int reg;
 246
 247         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 248
 249         reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 250
 251         palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg);
 252
 253         return 0;
 254 }
 255
 256
 257 static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode)
 258 {
 259         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 260         int id = rdev_get_id(dev);
 261         unsigned int reg;
 262
 263         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 264         reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 265
 266         switch (mode) {
 267         case REGULATOR_MODE_NORMAL:
 268                 reg |= SMPS_CTRL_MODE_ON;
 269                 break;
 270         case REGULATOR_MODE_IDLE:
 271                 reg |= SMPS_CTRL_MODE_ECO;
 272                 break;
 273         case REGULATOR_MODE_FAST:
 274                 reg |= SMPS_CTRL_MODE_PWM;
 275                 break;
 276         default:
 277                 return -EINVAL;
 278         }
 279         palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg);
 280
 281         return 0;
 282 }
 283
 284 static unsigned int palmas_get_mode_smps(struct regulator_dev *dev)
 285 {
 286         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 287         int id = rdev_get_id(dev);
 288         unsigned int reg;
 289
 290         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 291         reg &= PALMAS_SMPS12_CTRL_STATUS_MASK;
 292         reg >>= PALMAS_SMPS12_CTRL_STATUS_SHIFT;
 293
 294         switch (reg) {
 295         case SMPS_CTRL_MODE_ON:
 296                 return REGULATOR_MODE_NORMAL;
 297         case SMPS_CTRL_MODE_ECO:
 298                 return REGULATOR_MODE_IDLE;
 299         case SMPS_CTRL_MODE_PWM:
 300                 return REGULATOR_MODE_FAST;
 301         }
 302
 303         return 0;
 304 }
 305
 306 static int palmas_list_voltage_smps(struct regulator_dev *dev,
 307                                         unsigned selector)
 308 {
 309         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 310         int id = rdev_get_id(dev);
 311         int mult = 1;
 312
 313         /* Read the multiplier set in VSEL register to return
 314          * the correct voltage.
 315          */
 316         if (pmic->range[id])
 317                 mult = 2;
 318
 319         if (selector == 0)
 320                 return 0;
 321         else if (selector < 6)
 322                 return 500000 * mult;
 323         else
 324                 /* Voltage is linear mapping starting from selector 6,
 325                  * volt = (0.49V + ((selector - 5) * 0.01V)) * RANGE
 326                  * RANGE is either x1 or x2
 327                  */
 328                 return (490000 + ((selector - 5) * 10000)) * mult;
 329 }
 330
 331 static int palmas_map_voltage_smps(struct regulator_dev *rdev,
 332                 int min_uV, int max_uV)
 333 {
 334         struct palmas_pmic *pmic = rdev_get_drvdata(rdev);
 335         int id = rdev_get_id(rdev);
 336         int ret, voltage;
 337
 338         if (min_uV == 0)
 339                 return 0;
 340
 341         if (pmic->range[id]) { /* RANGE is x2 */
 342                 if (min_uV < 1000000)
 343                         min_uV = 1000000;
 344                 ret = DIV_ROUND_UP(min_uV - 1000000, 20000) + 6;
 345         } else {                /* RANGE is x1 */
 346                 if (min_uV < 500000)
 347                         min_uV = 500000;
 348                 ret = DIV_ROUND_UP(min_uV - 500000, 10000) + 6;
 349         }
 350
 351         /* Map back into a voltage to verify we're still in bounds */
 352         voltage = palmas_list_voltage_smps(rdev, ret);
 353         if (voltage < min_uV || voltage > max_uV)
 354                 return -EINVAL;
 355
 356         return ret;
 357 }
 358
 359 static struct regulator_ops palmas_ops_smps = {
 360         .is_enabled             = palmas_is_enabled_smps,
 361         .enable                 = palmas_enable_smps,
 362         .disable                = palmas_disable_smps,
 363         .set_mode               = palmas_set_mode_smps,
 364         .get_mode               = palmas_get_mode_smps,
 365         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 366         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 367         .list_voltage           = palmas_list_voltage_smps,
 368         .map_voltage            = palmas_map_voltage_smps,
 369 };
 370
 371 static struct regulator_ops palmas_ops_smps10 = {
 372         .is_enabled             = regulator_is_enabled_regmap,
 373         .enable                 = regulator_enable_regmap,
 374         .disable                = regulator_disable_regmap,
 375         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 376         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 377         .list_voltage           = regulator_list_voltage_linear,
 378         .map_voltage            = regulator_map_voltage_linear,
 379 };
 380
 381 static int palmas_is_enabled_ldo(struct regulator_dev *dev)
 382 {
 383         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
 384         int id = rdev_get_id(dev);
 385         unsigned int reg;
 386
 387         palmas_ldo_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
 388
 389         reg &= PALMAS_LDO1_CTRL_STATUS;
 390
 391         return !!(reg);
 392 }
 393
 394 static struct regulator_ops palmas_ops_ldo = {
 395         .is_enabled             = palmas_is_enabled_ldo,
 396         .enable                 = regulator_enable_regmap,
 397         .disable                = regulator_disable_regmap,
 398         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 399         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 400         .list_voltage           = regulator_list_voltage_linear,
 401         .map_voltage            = regulator_map_voltage_linear,
 402 };
 403
 404 /*
 405  * setup the hardware based sleep configuration of the SMPS/LDO regulators
 406  * from the platform data. This is different to the software based control
 407  * supported by the regulator framework as it is controlled by toggling
 408  * pins on the PMIC such as PREQ, SYSEN, ...
 409  */
 410 static int palmas_smps_init(struct palmas *palmas, int id,
 411                 struct palmas_reg_init *reg_init)
 412 {
 413         unsigned int reg;
 414         unsigned int addr;
 415         int ret;
 416
 417         addr = palmas_regs_info[id].ctrl_addr;
 418
 419         ret = palmas_smps_read(palmas, addr, &reg);
 420         if (ret)
 421                 return ret;
 422
 423         switch (id) {
 424         case PALMAS_REG_SMPS10:
 425                 if (reg_init->mode_sleep) {
 426                         reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK;
 427                         reg |= reg_init->mode_sleep <<
 428                                         PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT;
 429                 }
 430                 break;
 431         default:
 432                 if (reg_init->warm_reset)
 433                         reg |= PALMAS_SMPS12_CTRL_WR_S;
 434
 435                 if (reg_init->roof_floor)
 436                         reg |= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN;
 437
 438                 if (reg_init->mode_sleep) {
 439                         reg &= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK;
 440                         reg |= reg_init->mode_sleep <<
 441                                         PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT;
 442                 }
 443         }
 444
 445         ret = palmas_smps_write(palmas, addr, reg);
 446         if (ret)
 447                 return ret;
 448
 449         if (palmas_regs_info[id].tstep_addr && reg_init->tstep) {
 450                 addr = palmas_regs_info[id].tstep_addr;
 451
 452                 reg = reg_init->tstep & PALMAS_SMPS12_TSTEP_TSTEP_MASK;
 453
 454                 ret = palmas_smps_write(palmas, addr, reg);
 455                 if (ret)
 456                         return ret;
 457         }
 458
 459         if (palmas_regs_info[id].vsel_addr && reg_init->vsel) {
 460                 addr = palmas_regs_info[id].vsel_addr;
 461
 462                 reg = reg_init->vsel;
 463
 464                 ret = palmas_smps_write(palmas, addr, reg);
 465                 if (ret)
 466                         return ret;
 467         }
 468
 469
 470         return 0;
 471 }
 472
 473 static int palmas_ldo_init(struct palmas *palmas, int id,
 474                 struct palmas_reg_init *reg_init)
 475 {
 476         unsigned int reg;
 477         unsigned int addr;
 478         int ret;
 479
 480         addr = palmas_regs_info[id].ctrl_addr;
 481
 482         ret = palmas_ldo_read(palmas, addr, &reg);
 483         if (ret)
 484                 return ret;
 485
 486         if (reg_init->warm_reset)
 487                 reg |= PALMAS_LDO1_CTRL_WR_S;
 488
 489         if (reg_init->mode_sleep)
 490                 reg |= PALMAS_LDO1_CTRL_MODE_SLEEP;
 491
 492         ret = palmas_ldo_write(palmas, addr, reg);
 493         if (ret)
 494                 return ret;
 495
 496         return 0;
 497 }
 498
 499 static struct of_regulator_match palmas_matches[] = {
 500         { .name = "smps12", },
 501         { .name = "smps123", },
 502         { .name = "smps3", },
 503         { .name = "smps45", },
 504         { .name = "smps457", },
 505         { .name = "smps6", },
 506         { .name = "smps7", },
 507         { .name = "smps8", },
 508         { .name = "smps9", },
 509         { .name = "smps10", },
 510         { .name = "ldo1", },
 511         { .name = "ldo2", },
 512         { .name = "ldo3", },
 513         { .name = "ldo4", },
 514         { .name = "ldo5", },
 515         { .name = "ldo6", },
 516         { .name = "ldo7", },
 517         { .name = "ldo8", },
 518         { .name = "ldo9", },
 519         { .name = "ldoln", },
 520         { .name = "ldousb", },
 521 };
 522
 523 static void palmas_dt_to_pdata(struct device *dev,
 524                 struct device_node *node,
 525                 struct palmas_pmic_platform_data *pdata)
 526 {
 527         struct device_node *regulators;
 528         u32 prop;
 529         int idx, ret;
 530
 531         node = of_node_get(node);
 532         regulators = of_find_node_by_name(node, "regulators");
 533         if (!regulators) {
 534                 dev_info(dev, "regulator node not found\n");
 535                 return;
 536         }
 537
 538         ret = of_regulator_match(dev, regulators, palmas_matches,
 539                         PALMAS_NUM_REGS);
 540         of_node_put(regulators);
 541         if (ret < 0) {
 542                 dev_err(dev, "Error parsing regulator init data: %d\n", ret);
 543                 return;
 544         }
 545
 546         for (idx = 0; idx < PALMAS_NUM_REGS; idx++) {
 547                 if (!palmas_matches[idx].init_data ||
 548                                 !palmas_matches[idx].of_node)
 549                         continue;
 550
 551                 pdata->reg_data[idx] = palmas_matches[idx].init_data;
 552
 553                 pdata->reg_init[idx] = devm_kzalloc(dev,
 554                                 sizeof(struct palmas_reg_init), GFP_KERNEL);
 555
 556                 ret = of_property_read_u32(palmas_matches[idx].of_node,
 557                                 "ti,warm_reset", &prop);
 558                 if (!ret)
 559                         pdata->reg_init[idx]->warm_reset = prop;
 560
 561                 ret = of_property_read_u32(palmas_matches[idx].of_node,
 562                                 "ti,roof_floor", &prop);
 563                 if (!ret)
 564                         pdata->reg_init[idx]->roof_floor = prop;
 565
 566                 ret = of_property_read_u32(palmas_matches[idx].of_node,
 567                                 "ti,mode_sleep", &prop);
 568                 if (!ret)
 569                         pdata->reg_init[idx]->mode_sleep = prop;
 570
 571                 ret = of_property_read_u32(palmas_matches[idx].of_node,
 572                                 "ti,tstep", &prop);
 573                 if (!ret)
 574                         pdata->reg_init[idx]->tstep = prop;
 575
 576                 ret = of_property_read_u32(palmas_matches[idx].of_node,
 577                                 "ti,vsel", &prop);
 578                 if (!ret)
 579                         pdata->reg_init[idx]->vsel = prop;
 580         }
 581
 582         ret = of_property_read_u32(node, "ti,ldo6_vibrator", &prop);
 583         if (!ret)
 584                 pdata->ldo6_vibrator = prop;
 585 }
 586
 587
 588 static int palmas_probe(struct platform_device *pdev)
 589 {
 590         struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
 591         struct palmas_pmic_platform_data *pdata = pdev->dev.platform_data;
 592         struct device_node *node = pdev->dev.of_node;
 593         struct regulator_dev *rdev;
 594         struct regulator_config config = { };
 595         struct palmas_pmic *pmic;
 596         struct palmas_reg_init *reg_init;
 597         int id = 0, ret;
 598         unsigned int addr, reg;
 599
 600         if (node && !pdata) {
 601                 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
 602
 603                 if (!pdata)
 604                         return -ENOMEM;
 605
 606                 palmas_dt_to_pdata(&pdev->dev, node, pdata);
 607         }
 608
 609         pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
 610         if (!pmic)
 611                 return -ENOMEM;
 612
 613         pmic->dev = &pdev->dev;
 614         pmic->palmas = palmas;
 615         palmas->pmic = pmic;
 616         platform_set_drvdata(pdev, pmic);
 617
 618         ret = palmas_smps_read(palmas, PALMAS_SMPS_CTRL, &reg);
 619         if (ret)
 620                 return ret;
 621
 622         if (reg & PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN)
 623                 pmic->smps123 = 1;
 624
 625         if (reg & PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN)
 626                 pmic->smps457 = 1;
 627
 628         config.regmap = palmas->regmap[REGULATOR_SLAVE];
 629         config.dev = &pdev->dev;
 630         config.driver_data = pmic;
 631
 632         for (id = 0; id < PALMAS_REG_LDO1; id++) {
 633
 634                 /*
 635                  * Miss out regulators which are not available due
 636                  * to slaving configurations.
 637                  */
 638                 switch (id) {
 639                 case PALMAS_REG_SMPS12:
 640                 case PALMAS_REG_SMPS3:
 641                         if (pmic->smps123)
 642                                 continue;
 643                         break;
 644                 case PALMAS_REG_SMPS123:
 645                         if (!pmic->smps123)
 646                                 continue;
 647                         break;
 648                 case PALMAS_REG_SMPS45:
 649                 case PALMAS_REG_SMPS7:
 650                         if (pmic->smps457)
 651                                 continue;
 652                         break;
 653                 case PALMAS_REG_SMPS457:
 654                         if (!pmic->smps457)
 655                                 continue;
 656                 }
 657
 658                 /* Initialise sleep/init values from platform data */
 659                 if (pdata && pdata->reg_init[id]) {
 660                         reg_init = pdata->reg_init[id];
 661                         ret = palmas_smps_init(palmas, id, reg_init);
 662                         if (ret)
 663                                 goto err_unregister_regulator;
 664                 }
 665
 666                 /* Register the regulators */
 667                 pmic->desc[id].name = palmas_regs_info[id].name;
 668                 pmic->desc[id].id = id;
 669
 670                 switch (id) {
 671                 case PALMAS_REG_SMPS10:
 672                         pmic->desc[id].n_voltages = PALMAS_SMPS10_NUM_VOLTAGES;
 673                         pmic->desc[id].ops = &palmas_ops_smps10;
 674                         pmic->desc[id].vsel_reg =
 675                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
 676                                                         PALMAS_SMPS10_CTRL);
 677                         pmic->desc[id].vsel_mask = SMPS10_VSEL;
 678                         pmic->desc[id].enable_reg =
 679                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
 680                                                         PALMAS_SMPS10_STATUS);
 681                         pmic->desc[id].enable_mask = SMPS10_BOOST_EN;
 682                         pmic->desc[id].min_uV = 3750000;
 683                         pmic->desc[id].uV_step = 1250000;
 684                         break;
 685                 default:
 686                         /*
 687                          * Read and store the RANGE bit for later use
 688                          * This must be done before regulator is probed,
 689                          * otherwise we error in probe with unsupportable ranges.
 690                          */
 691                         addr = palmas_regs_info[id].vsel_addr;
 692
 693                         ret = palmas_smps_read(pmic->palmas, addr, &reg);
 694                         if (ret)
 695                                 goto err_unregister_regulator;
 696                         if (reg & PALMAS_SMPS12_VOLTAGE_RANGE)
 697                                 pmic->range[id] = 1;
 698
 699                         pmic->desc[id].ops = &palmas_ops_smps;
 700                         pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
 701                         pmic->desc[id].vsel_reg =
 702                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
 703                                                 palmas_regs_info[id].vsel_addr);
 704                         pmic->desc[id].vsel_mask =
 705                                         PALMAS_SMPS12_VOLTAGE_VSEL_MASK;
 706                 }
 707
 708                 pmic->desc[id].type = REGULATOR_VOLTAGE;
 709                 pmic->desc[id].owner = THIS_MODULE;
 710
 711                 if (pdata)
 712                         config.init_data = pdata->reg_data[id];
 713                 else
 714                         config.init_data = NULL;
 715
 716                 config.of_node = palmas_matches[id].of_node;
 717
 718                 rdev = regulator_register(&pmic->desc[id], &config);
 719                 if (IS_ERR(rdev)) {
 720                         dev_err(&pdev->dev,
 721                                 "failed to register %s regulator\n",
 722                                 pdev->name);
 723                         ret = PTR_ERR(rdev);
 724                         goto err_unregister_regulator;
 725                 }
 726
 727                 /* Save regulator for cleanup */
 728                 pmic->rdev[id] = rdev;
 729         }
 730
 731         /* Start this loop from the id left from previous loop */
 732         for (; id < PALMAS_NUM_REGS; id++) {
 733
 734                 /* Miss out regulators which are not available due
 735                  * to alternate functions.
 736                  */
 737
 738                 /* Register the regulators */
 739                 pmic->desc[id].name = palmas_regs_info[id].name;
 740                 pmic->desc[id].id = id;
 741                 pmic->desc[id].n_voltages = PALMAS_LDO_NUM_VOLTAGES;
 742
 743                 pmic->desc[id].ops = &palmas_ops_ldo;
 744
 745                 pmic->desc[id].type = REGULATOR_VOLTAGE;
 746                 pmic->desc[id].owner = THIS_MODULE;
 747                 pmic->desc[id].min_uV = 900000;
 748                 pmic->desc[id].uV_step = 50000;
 749                 pmic->desc[id].linear_min_sel = 1;
 750                 pmic->desc[id].vsel_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
 751                                                 palmas_regs_info[id].vsel_addr);
 752                 pmic->desc[id].vsel_mask = PALMAS_LDO1_VOLTAGE_VSEL_MASK;
 753                 pmic->desc[id].enable_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
 754                                                 palmas_regs_info[id].ctrl_addr);
 755                 pmic->desc[id].enable_mask = PALMAS_LDO1_CTRL_MODE_ACTIVE;
 756
 757                 if (pdata)
 758                         config.init_data = pdata->reg_data[id];
 759                 else
 760                         config.init_data = NULL;
 761
 762                 config.of_node = palmas_matches[id].of_node;
 763
 764                 rdev = regulator_register(&pmic->desc[id], &config);
 765                 if (IS_ERR(rdev)) {
 766                         dev_err(&pdev->dev,
 767                                 "failed to register %s regulator\n",
 768                                 pdev->name);
 769                         ret = PTR_ERR(rdev);
 770                         goto err_unregister_regulator;
 771                 }
 772
 773                 /* Save regulator for cleanup */
 774                 pmic->rdev[id] = rdev;
 775
 776                 /* Initialise sleep/init values from platform data */
 777                 if (pdata) {
 778                         reg_init = pdata->reg_init[id];
 779                         if (reg_init) {
 780                                 ret = palmas_ldo_init(palmas, id, reg_init);
 781                                 if (ret) {
 782                                         regulator_unregister(pmic->rdev[id]);
 783                                         goto err_unregister_regulator;
 784                                 }
 785                         }
 786                 }
 787         }
 788
 789         return 0;
 790
 791 err_unregister_regulator:
 792         while (--id >= 0)
 793                 regulator_unregister(pmic->rdev[id]);
 794         return ret;
 795 }
 796
 797 static int palmas_remove(struct platform_device *pdev)
 798 {
 799         struct palmas_pmic *pmic = platform_get_drvdata(pdev);
 800         int id;
 801
 802         for (id = 0; id < PALMAS_NUM_REGS; id++)
 803                 regulator_unregister(pmic->rdev[id]);
 804         return 0;
 805 }
 806
 807 static struct of_device_id of_palmas_match_tbl[] = {
 808         { .compatible = "ti,palmas-pmic", },
 809         { /* end */ }
 810 };
 811
 812 static struct platform_driver palmas_driver = {
 813         .driver = {
 814                 .name = "palmas-pmic",
 815                 .of_match_table = of_palmas_match_tbl,
 816                 .owner = THIS_MODULE,
 817         },
 818         .probe = palmas_probe,
 819         .remove = palmas_remove,
 820 };
 821
 822 static int __init palmas_init(void)
 823 {
 824         return platform_driver_register(&palmas_driver);
 825 }
 826 subsys_initcall(palmas_init);
 827
 828 static void __exit palmas_exit(void)
 829 {
 830         platform_driver_unregister(&palmas_driver);
 831 }
 832 module_exit(palmas_exit);
 833
 834 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
 835 MODULE_DESCRIPTION("Palmas voltage regulator driver");
 836 MODULE_LICENSE("GPL");
 837 MODULE_ALIAS("platform:palmas-pmic");
 838 MODULE_DEVICE_TABLE(of, of_palmas_match_tbl);