root/drivers/regulator/ab3100.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. ab3100_enable_regulator
  2. ab3100_disable_regulator
  3. ab3100_is_enabled_regulator
  4. ab3100_get_voltage_regulator
  5. ab3100_set_voltage_regulator_sel
  6. ab3100_set_suspend_voltage_regulator
  7. ab3100_get_voltage_regulator_external
  8. ab3100_regulator_register
  9. ab3100_regulator_of_probe
  10. ab3100_regulators_probe
  11. ab3100_regulators_init
  12. ab3100_regulators_exit
   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * drivers/regulator/ab3100.c
   4  *
   5  * Copyright (C) 2008-2009 ST-Ericsson AB
   6  * Low-level control of the AB3100 IC Low Dropout (LDO)
   7  * regulators, external regulator and buck converter
   8  * Author: Mattias Wallin <mattias.wallin@stericsson.com>
   9  * Author: Linus Walleij <linus.walleij@stericsson.com>
  10  */
  11 
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/err.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/regulator/driver.h>
  18 #include <linux/mfd/ab3100.h>
  19 #include <linux/mfd/abx500.h>
  20 #include <linux/of.h>
  21 #include <linux/regulator/of_regulator.h>
  22 
  23 /* LDO registers and some handy masking definitions for AB3100 */
  24 #define AB3100_LDO_A            0x40
  25 #define AB3100_LDO_C            0x41
  26 #define AB3100_LDO_D            0x42
  27 #define AB3100_LDO_E            0x43
  28 #define AB3100_LDO_E_SLEEP      0x44
  29 #define AB3100_LDO_F            0x45
  30 #define AB3100_LDO_G            0x46
  31 #define AB3100_LDO_H            0x47
  32 #define AB3100_LDO_H_SLEEP_MODE 0
  33 #define AB3100_LDO_H_SLEEP_EN   2
  34 #define AB3100_LDO_ON           4
  35 #define AB3100_LDO_H_VSEL_AC    5
  36 #define AB3100_LDO_K            0x48
  37 #define AB3100_LDO_EXT          0x49
  38 #define AB3100_BUCK             0x4A
  39 #define AB3100_BUCK_SLEEP       0x4B
  40 #define AB3100_REG_ON_MASK      0x10
  41 
  42 /**
  43  * struct ab3100_regulator
  44  * A struct passed around the individual regulator functions
  45  * @platform_device: platform device holding this regulator
  46  * @dev: handle to the device
  47  * @plfdata: AB3100 platform data passed in at probe time
  48  * @regreg: regulator register number in the AB3100
  49  */
  50 struct ab3100_regulator {
  51         struct device *dev;
  52         struct ab3100_platform_data *plfdata;
  53         u8 regreg;
  54 };
  55 
  56 /* The order in which registers are initialized */
  57 static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
  58         AB3100_LDO_A,
  59         AB3100_LDO_C,
  60         AB3100_LDO_E,
  61         AB3100_LDO_E_SLEEP,
  62         AB3100_LDO_F,
  63         AB3100_LDO_G,
  64         AB3100_LDO_H,
  65         AB3100_LDO_K,
  66         AB3100_LDO_EXT,
  67         AB3100_BUCK,
  68         AB3100_BUCK_SLEEP,
  69         AB3100_LDO_D,
  70 };
  71 
  72 /* Preset (hardware defined) voltages for these regulators */
  73 #define LDO_A_VOLTAGE 2750000
  74 #define LDO_C_VOLTAGE 2650000
  75 #define LDO_D_VOLTAGE 2650000
  76 
  77 static const unsigned int ldo_e_buck_typ_voltages[] = {
  78         1800000,
  79         1400000,
  80         1300000,
  81         1200000,
  82         1100000,
  83         1050000,
  84         900000,
  85 };
  86 
  87 static const unsigned int ldo_f_typ_voltages[] = {
  88         1800000,
  89         1400000,
  90         1300000,
  91         1200000,
  92         1100000,
  93         1050000,
  94         2500000,
  95         2650000,
  96 };
  97 
  98 static const unsigned int ldo_g_typ_voltages[] = {
  99         2850000,
 100         2750000,
 101         1800000,
 102         1500000,
 103 };
 104 
 105 static const unsigned int ldo_h_typ_voltages[] = {
 106         2750000,
 107         1800000,
 108         1500000,
 109         1200000,
 110 };
 111 
 112 static const unsigned int ldo_k_typ_voltages[] = {
 113         2750000,
 114         1800000,
 115 };
 116 
 117 
 118 /* The regulator devices */
 119 static struct ab3100_regulator
 120 ab3100_regulators[AB3100_NUM_REGULATORS] = {
 121         {
 122                 .regreg = AB3100_LDO_A,
 123         },
 124         {
 125                 .regreg = AB3100_LDO_C,
 126         },
 127         {
 128                 .regreg = AB3100_LDO_D,
 129         },
 130         {
 131                 .regreg = AB3100_LDO_E,
 132         },
 133         {
 134                 .regreg = AB3100_LDO_F,
 135         },
 136         {
 137                 .regreg = AB3100_LDO_G,
 138         },
 139         {
 140                 .regreg = AB3100_LDO_H,
 141         },
 142         {
 143                 .regreg = AB3100_LDO_K,
 144         },
 145         {
 146                 .regreg = AB3100_LDO_EXT,
 147                 /* No voltages for the external regulator */
 148         },
 149         {
 150                 .regreg = AB3100_BUCK,
 151         },
 152 };
 153 
 154 /*
 155  * General functions for enable, disable and is_enabled used for
 156  * LDO: A,C,E,F,G,H,K,EXT and BUCK
 157  */
 158 static int ab3100_enable_regulator(struct regulator_dev *reg)
 159 {
 160         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 161         int err;
 162         u8 regval;
 163 
 164         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 165                                                 &regval);
 166         if (err) {
 167                 dev_warn(&reg->dev, "failed to get regid %d value\n",
 168                          abreg->regreg);
 169                 return err;
 170         }
 171 
 172         /* The regulator is already on, no reason to go further */
 173         if (regval & AB3100_REG_ON_MASK)
 174                 return 0;
 175 
 176         regval |= AB3100_REG_ON_MASK;
 177 
 178         err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
 179                                                 regval);
 180         if (err) {
 181                 dev_warn(&reg->dev, "failed to set regid %d value\n",
 182                          abreg->regreg);
 183                 return err;
 184         }
 185 
 186         return 0;
 187 }
 188 
 189 static int ab3100_disable_regulator(struct regulator_dev *reg)
 190 {
 191         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 192         int err;
 193         u8 regval;
 194 
 195         /*
 196          * LDO D is a special regulator. When it is disabled, the entire
 197          * system is shut down. So this is handled specially.
 198          */
 199         pr_info("Called ab3100_disable_regulator\n");
 200         if (abreg->regreg == AB3100_LDO_D) {
 201                 dev_info(&reg->dev, "disabling LDO D - shut down system\n");
 202                 /* Setting LDO D to 0x00 cuts the power to the SoC */
 203                 return abx500_set_register_interruptible(abreg->dev, 0,
 204                                                          AB3100_LDO_D, 0x00U);
 205         }
 206 
 207         /*
 208          * All other regulators are handled here
 209          */
 210         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 211                                                 &regval);
 212         if (err) {
 213                 dev_err(&reg->dev, "unable to get register 0x%x\n",
 214                         abreg->regreg);
 215                 return err;
 216         }
 217         regval &= ~AB3100_REG_ON_MASK;
 218         return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
 219                                                  regval);
 220 }
 221 
 222 static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
 223 {
 224         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 225         u8 regval;
 226         int err;
 227 
 228         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
 229                                                 &regval);
 230         if (err) {
 231                 dev_err(&reg->dev, "unable to get register 0x%x\n",
 232                         abreg->regreg);
 233                 return err;
 234         }
 235 
 236         return regval & AB3100_REG_ON_MASK;
 237 }
 238 
 239 static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
 240 {
 241         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 242         u8 regval;
 243         int err;
 244 
 245         /*
 246          * For variable types, read out setting and index into
 247          * supplied voltage list.
 248          */
 249         err = abx500_get_register_interruptible(abreg->dev, 0,
 250                                                 abreg->regreg, &regval);
 251         if (err) {
 252                 dev_warn(&reg->dev,
 253                          "failed to get regulator value in register %02x\n",
 254                          abreg->regreg);
 255                 return err;
 256         }
 257 
 258         /* The 3 highest bits index voltages */
 259         regval &= 0xE0;
 260         regval >>= 5;
 261 
 262         if (regval >= reg->desc->n_voltages) {
 263                 dev_err(&reg->dev,
 264                         "regulator register %02x contains an illegal voltage setting\n",
 265                         abreg->regreg);
 266                 return -EINVAL;
 267         }
 268 
 269         return reg->desc->volt_table[regval];
 270 }
 271 
 272 static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
 273                                             unsigned selector)
 274 {
 275         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 276         u8 regval;
 277         int err;
 278 
 279         err = abx500_get_register_interruptible(abreg->dev, 0,
 280                                                 abreg->regreg, &regval);
 281         if (err) {
 282                 dev_warn(&reg->dev,
 283                          "failed to get regulator register %02x\n",
 284                          abreg->regreg);
 285                 return err;
 286         }
 287 
 288         /* The highest three bits control the variable regulators */
 289         regval &= ~0xE0;
 290         regval |= (selector << 5);
 291 
 292         err = abx500_set_register_interruptible(abreg->dev, 0,
 293                                                 abreg->regreg, regval);
 294         if (err)
 295                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
 296                         abreg->regreg);
 297 
 298         return err;
 299 }
 300 
 301 static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
 302                                                 int uV)
 303 {
 304         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 305         u8 regval;
 306         int err;
 307         int bestindex;
 308         u8 targetreg;
 309 
 310         if (abreg->regreg == AB3100_LDO_E)
 311                 targetreg = AB3100_LDO_E_SLEEP;
 312         else if (abreg->regreg == AB3100_BUCK)
 313                 targetreg = AB3100_BUCK_SLEEP;
 314         else
 315                 return -EINVAL;
 316 
 317         /* LDO E and BUCK have special suspend voltages you can set */
 318         bestindex = regulator_map_voltage_iterate(reg, uV, uV);
 319 
 320         err = abx500_get_register_interruptible(abreg->dev, 0,
 321                                                 targetreg, &regval);
 322         if (err) {
 323                 dev_warn(&reg->dev,
 324                          "failed to get regulator register %02x\n",
 325                          targetreg);
 326                 return err;
 327         }
 328 
 329         /* The highest three bits control the variable regulators */
 330         regval &= ~0xE0;
 331         regval |= (bestindex << 5);
 332 
 333         err = abx500_set_register_interruptible(abreg->dev, 0,
 334                                                 targetreg, regval);
 335         if (err)
 336                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
 337                         abreg->regreg);
 338 
 339         return err;
 340 }
 341 
 342 /*
 343  * The external regulator can just define a fixed voltage.
 344  */
 345 static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
 346 {
 347         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 348 
 349         if (abreg->plfdata)
 350                 return abreg->plfdata->external_voltage;
 351         else
 352                 /* TODO: encode external voltage into device tree */
 353                 return 0;
 354 }
 355 
 356 static const struct regulator_ops regulator_ops_fixed = {
 357         .enable      = ab3100_enable_regulator,
 358         .disable     = ab3100_disable_regulator,
 359         .is_enabled  = ab3100_is_enabled_regulator,
 360 };
 361 
 362 static const struct regulator_ops regulator_ops_variable = {
 363         .enable      = ab3100_enable_regulator,
 364         .disable     = ab3100_disable_regulator,
 365         .is_enabled  = ab3100_is_enabled_regulator,
 366         .get_voltage = ab3100_get_voltage_regulator,
 367         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
 368         .list_voltage = regulator_list_voltage_table,
 369 };
 370 
 371 static const struct regulator_ops regulator_ops_variable_sleepable = {
 372         .enable      = ab3100_enable_regulator,
 373         .disable     = ab3100_disable_regulator,
 374         .is_enabled  = ab3100_is_enabled_regulator,
 375         .get_voltage = ab3100_get_voltage_regulator,
 376         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
 377         .set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
 378         .list_voltage = regulator_list_voltage_table,
 379 };
 380 
 381 /*
 382  * LDO EXT is an external regulator so it is really
 383  * not possible to set any voltage locally here, AB3100
 384  * is an on/off switch plain an simple. The external
 385  * voltage is defined in the board set-up if any.
 386  */
 387 static const struct regulator_ops regulator_ops_external = {
 388         .enable      = ab3100_enable_regulator,
 389         .disable     = ab3100_disable_regulator,
 390         .is_enabled  = ab3100_is_enabled_regulator,
 391         .get_voltage = ab3100_get_voltage_regulator_external,
 392 };
 393 
 394 static const struct regulator_desc
 395 ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
 396         {
 397                 .name = "LDO_A",
 398                 .id   = AB3100_LDO_A,
 399                 .ops  = &regulator_ops_fixed,
 400                 .n_voltages = 1,
 401                 .type = REGULATOR_VOLTAGE,
 402                 .owner = THIS_MODULE,
 403                 .fixed_uV = LDO_A_VOLTAGE,
 404                 .enable_time = 200,
 405         },
 406         {
 407                 .name = "LDO_C",
 408                 .id   = AB3100_LDO_C,
 409                 .ops  = &regulator_ops_fixed,
 410                 .n_voltages = 1,
 411                 .type = REGULATOR_VOLTAGE,
 412                 .owner = THIS_MODULE,
 413                 .fixed_uV = LDO_C_VOLTAGE,
 414                 .enable_time = 200,
 415         },
 416         {
 417                 .name = "LDO_D",
 418                 .id   = AB3100_LDO_D,
 419                 .ops  = &regulator_ops_fixed,
 420                 .n_voltages = 1,
 421                 .type = REGULATOR_VOLTAGE,
 422                 .owner = THIS_MODULE,
 423                 .fixed_uV = LDO_D_VOLTAGE,
 424                 .enable_time = 200,
 425         },
 426         {
 427                 .name = "LDO_E",
 428                 .id   = AB3100_LDO_E,
 429                 .ops  = &regulator_ops_variable_sleepable,
 430                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
 431                 .volt_table = ldo_e_buck_typ_voltages,
 432                 .type = REGULATOR_VOLTAGE,
 433                 .owner = THIS_MODULE,
 434                 .enable_time = 200,
 435         },
 436         {
 437                 .name = "LDO_F",
 438                 .id   = AB3100_LDO_F,
 439                 .ops  = &regulator_ops_variable,
 440                 .n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
 441                 .volt_table = ldo_f_typ_voltages,
 442                 .type = REGULATOR_VOLTAGE,
 443                 .owner = THIS_MODULE,
 444                 .enable_time = 600,
 445         },
 446         {
 447                 .name = "LDO_G",
 448                 .id   = AB3100_LDO_G,
 449                 .ops  = &regulator_ops_variable,
 450                 .n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
 451                 .volt_table = ldo_g_typ_voltages,
 452                 .type = REGULATOR_VOLTAGE,
 453                 .owner = THIS_MODULE,
 454                 .enable_time = 400,
 455         },
 456         {
 457                 .name = "LDO_H",
 458                 .id   = AB3100_LDO_H,
 459                 .ops  = &regulator_ops_variable,
 460                 .n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
 461                 .volt_table = ldo_h_typ_voltages,
 462                 .type = REGULATOR_VOLTAGE,
 463                 .owner = THIS_MODULE,
 464                 .enable_time = 200,
 465         },
 466         {
 467                 .name = "LDO_K",
 468                 .id   = AB3100_LDO_K,
 469                 .ops  = &regulator_ops_variable,
 470                 .n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
 471                 .volt_table = ldo_k_typ_voltages,
 472                 .type = REGULATOR_VOLTAGE,
 473                 .owner = THIS_MODULE,
 474                 .enable_time = 200,
 475         },
 476         {
 477                 .name = "LDO_EXT",
 478                 .id   = AB3100_LDO_EXT,
 479                 .ops  = &regulator_ops_external,
 480                 .type = REGULATOR_VOLTAGE,
 481                 .owner = THIS_MODULE,
 482         },
 483         {
 484                 .name = "BUCK",
 485                 .id   = AB3100_BUCK,
 486                 .ops  = &regulator_ops_variable_sleepable,
 487                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
 488                 .volt_table = ldo_e_buck_typ_voltages,
 489                 .type = REGULATOR_VOLTAGE,
 490                 .owner = THIS_MODULE,
 491                 .enable_time = 1000,
 492         },
 493 };
 494 
 495 static int ab3100_regulator_register(struct platform_device *pdev,
 496                                      struct ab3100_platform_data *plfdata,
 497                                      struct regulator_init_data *init_data,
 498                                      struct device_node *np,
 499                                      unsigned long id)
 500 {
 501         const struct regulator_desc *desc;
 502         struct ab3100_regulator *reg;
 503         struct regulator_dev *rdev;
 504         struct regulator_config config = { };
 505         int err, i;
 506 
 507         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
 508                 desc = &ab3100_regulator_desc[i];
 509                 if (desc->id == id)
 510                         break;
 511         }
 512         if (desc->id != id)
 513                 return -ENODEV;
 514 
 515         /* Same index used for this array */
 516         reg = &ab3100_regulators[i];
 517 
 518         /*
 519          * Initialize per-regulator struct.
 520          * Inherit platform data, this comes down from the
 521          * i2c boarddata, from the machine. So if you want to
 522          * see what it looks like for a certain machine, go
 523          * into the machine I2C setup.
 524          */
 525         reg->dev = &pdev->dev;
 526         if (plfdata) {
 527                 reg->plfdata = plfdata;
 528                 config.init_data = &plfdata->reg_constraints[i];
 529         } else if (np) {
 530                 config.of_node = np;
 531                 config.init_data = init_data;
 532         }
 533         config.dev = &pdev->dev;
 534         config.driver_data = reg;
 535 
 536         rdev = devm_regulator_register(&pdev->dev, desc, &config);
 537         if (IS_ERR(rdev)) {
 538                 err = PTR_ERR(rdev);
 539                 dev_err(&pdev->dev,
 540                         "%s: failed to register regulator %s err %d\n",
 541                         __func__, desc->name,
 542                         err);
 543                 return err;
 544         }
 545 
 546         return 0;
 547 }
 548 
 549 static struct of_regulator_match ab3100_regulator_matches[] = {
 550         { .name = "ab3100_ldo_a", .driver_data = (void *) AB3100_LDO_A, },
 551         { .name = "ab3100_ldo_c", .driver_data = (void *) AB3100_LDO_C, },
 552         { .name = "ab3100_ldo_d", .driver_data = (void *) AB3100_LDO_D, },
 553         { .name = "ab3100_ldo_e", .driver_data = (void *) AB3100_LDO_E, },
 554         { .name = "ab3100_ldo_f", .driver_data = (void *) AB3100_LDO_F },
 555         { .name = "ab3100_ldo_g", .driver_data = (void *) AB3100_LDO_G },
 556         { .name = "ab3100_ldo_h", .driver_data = (void *) AB3100_LDO_H },
 557         { .name = "ab3100_ldo_k", .driver_data = (void *) AB3100_LDO_K },
 558         { .name = "ab3100_ext", .driver_data = (void *) AB3100_LDO_EXT },
 559         { .name = "ab3100_buck", .driver_data = (void *) AB3100_BUCK },
 560 };
 561 
 562 /*
 563  * Initial settings of ab3100 registers.
 564  * Common for below LDO regulator settings are that
 565  * bit 7-5 controls voltage. Bit 4 turns regulator ON(1) or OFF(0).
 566  * Bit 3-2 controls sleep enable and bit 1-0 controls sleep mode.
 567  */
 568 /* LDO_A 0x16: 2.75V, ON, SLEEP_A, SLEEP OFF GND */
 569 #define LDO_A_SETTING           0x16
 570 /* LDO_C 0x10: 2.65V, ON, SLEEP_A or B, SLEEP full power */
 571 #define LDO_C_SETTING           0x10
 572 /* LDO_D 0x10: 2.65V, ON, sleep mode not used */
 573 #define LDO_D_SETTING           0x10
 574 /* LDO_E 0x10: 1.8V, ON, SLEEP_A or B, SLEEP full power */
 575 #define LDO_E_SETTING           0x10
 576 /* LDO_E SLEEP 0x00: 1.8V, not used, SLEEP_A or B, not used */
 577 #define LDO_E_SLEEP_SETTING     0x00
 578 /* LDO_F 0xD0: 2.5V, ON, SLEEP_A or B, SLEEP full power */
 579 #define LDO_F_SETTING           0xD0
 580 /* LDO_G 0x00: 2.85V, OFF, SLEEP_A or B, SLEEP full power */
 581 #define LDO_G_SETTING           0x00
 582 /* LDO_H 0x18: 2.75V, ON, SLEEP_B, SLEEP full power */
 583 #define LDO_H_SETTING           0x18
 584 /* LDO_K 0x00: 2.75V, OFF, SLEEP_A or B, SLEEP full power */
 585 #define LDO_K_SETTING           0x00
 586 /* LDO_EXT 0x00: Voltage not set, OFF, not used, not used */
 587 #define LDO_EXT_SETTING         0x00
 588 /* BUCK 0x7D: 1.2V, ON, SLEEP_A and B, SLEEP low power */
 589 #define BUCK_SETTING    0x7D
 590 /* BUCK SLEEP 0xAC: 1.05V, Not used, SLEEP_A and B, Not used */
 591 #define BUCK_SLEEP_SETTING      0xAC
 592 
 593 static const u8 ab3100_reg_initvals[] = {
 594         LDO_A_SETTING,
 595         LDO_C_SETTING,
 596         LDO_E_SETTING,
 597         LDO_E_SLEEP_SETTING,
 598         LDO_F_SETTING,
 599         LDO_G_SETTING,
 600         LDO_H_SETTING,
 601         LDO_K_SETTING,
 602         LDO_EXT_SETTING,
 603         BUCK_SETTING,
 604         BUCK_SLEEP_SETTING,
 605         LDO_D_SETTING,
 606 };
 607 
 608 static int
 609 ab3100_regulator_of_probe(struct platform_device *pdev, struct device_node *np)
 610 {
 611         int err, i;
 612 
 613         /*
 614          * Set up the regulator registers, as was previously done with
 615          * platform data.
 616          */
 617         /* Set up regulators */
 618         for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
 619                 err = abx500_set_register_interruptible(&pdev->dev, 0,
 620                                         ab3100_reg_init_order[i],
 621                                         ab3100_reg_initvals[i]);
 622                 if (err) {
 623                         dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
 624                                 err);
 625                         return err;
 626                 }
 627         }
 628 
 629         for (i = 0; i < ARRAY_SIZE(ab3100_regulator_matches); i++) {
 630                 err = ab3100_regulator_register(
 631                         pdev, NULL, ab3100_regulator_matches[i].init_data,
 632                         ab3100_regulator_matches[i].of_node,
 633                         (unsigned long)ab3100_regulator_matches[i].driver_data);
 634                 if (err)
 635                         return err;
 636         }
 637 
 638         return 0;
 639 }
 640 
 641 
 642 static int ab3100_regulators_probe(struct platform_device *pdev)
 643 {
 644         struct ab3100_platform_data *plfdata = dev_get_platdata(&pdev->dev);
 645         struct device_node *np = pdev->dev.of_node;
 646         int err = 0;
 647         u8 data;
 648         int i;
 649 
 650         /* Check chip state */
 651         err = abx500_get_register_interruptible(&pdev->dev, 0,
 652                                                 AB3100_LDO_D, &data);
 653         if (err) {
 654                 dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
 655                 return err;
 656         }
 657         if (data & 0x10)
 658                 dev_notice(&pdev->dev,
 659                            "chip is already in active mode (Warm start)\n");
 660         else
 661                 dev_notice(&pdev->dev,
 662                            "chip is in inactive mode (Cold start)\n");
 663 
 664         if (np) {
 665                 err = of_regulator_match(&pdev->dev, np,
 666                                          ab3100_regulator_matches,
 667                                          ARRAY_SIZE(ab3100_regulator_matches));
 668                 if (err < 0) {
 669                         dev_err(&pdev->dev,
 670                                 "Error parsing regulator init data: %d\n", err);
 671                         return err;
 672                 }
 673                 return ab3100_regulator_of_probe(pdev, np);
 674         }
 675 
 676         /* Set up regulators */
 677         for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
 678                 err = abx500_set_register_interruptible(&pdev->dev, 0,
 679                                         ab3100_reg_init_order[i],
 680                                         plfdata->reg_initvals[i]);
 681                 if (err) {
 682                         dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
 683                                 err);
 684                         return err;
 685                 }
 686         }
 687 
 688         /* Register the regulators */
 689         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
 690                 const struct regulator_desc *desc = &ab3100_regulator_desc[i];
 691 
 692                 err = ab3100_regulator_register(pdev, plfdata, NULL, NULL,
 693                                                 desc->id);
 694                 if (err)
 695                         return err;
 696         }
 697 
 698         return 0;
 699 }
 700 
 701 static struct platform_driver ab3100_regulators_driver = {
 702         .driver = {
 703                 .name  = "ab3100-regulators",
 704         },
 705         .probe = ab3100_regulators_probe,
 706 };
 707 
 708 static __init int ab3100_regulators_init(void)
 709 {
 710         return platform_driver_register(&ab3100_regulators_driver);
 711 }
 712 
 713 static __exit void ab3100_regulators_exit(void)
 714 {
 715         platform_driver_unregister(&ab3100_regulators_driver);
 716 }
 717 
 718 subsys_initcall(ab3100_regulators_init);
 719 module_exit(ab3100_regulators_exit);
 720 
 721 MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
 722 MODULE_DESCRIPTION("AB3100 Regulator driver");
 723 MODULE_LICENSE("GPL");
 724 MODULE_ALIAS("platform:ab3100-regulators");
/* [<][>][^][v][top][bottom][index][help] */