drivers/regulator/ab8500.c

   1 /*
   2  * Copyright (C) ST-Ericsson SA 2010
   3  *
   4  * License Terms: GNU General Public License v2
   5  *
   6  * Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
   7  *          Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
   8  *
   9  * AB8500 peripheral regulators
  10  *
  11  * AB8500 supports the following regulators:
  12  *   VAUX1/2/3, VINTCORE, VTVOUT, VUSB, VAUDIO, VAMIC1/2, VDMIC, VANA
  13  */
  14 #include <linux/init.h>
  15 #include <linux/kernel.h>
  16 #include <linux/err.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/mfd/ab8500.h>
  19 #include <linux/mfd/abx500.h>
  20 #include <linux/regulator/driver.h>
  21 #include <linux/regulator/machine.h>
  22 #include <linux/regulator/ab8500.h>
  23
  24 /**
  25  * struct ab8500_regulator_info - ab8500 regulator information
  26  * @dev: device pointer
  27  * @desc: regulator description
  28  * @regulator_dev: regulator device
  29  * @max_uV: maximum voltage (for variable voltage supplies)
  30  * @min_uV: minimum voltage (for variable voltage supplies)
  31  * @fixed_uV: typical voltage (for fixed voltage supplies)
  32  * @update_bank: bank to control on/off
  33  * @update_reg: register to control on/off
  34  * @update_mask: mask to enable/disable regulator
  35  * @update_val_enable: bits to enable the regulator in normal (high power) mode
  36  * @voltage_bank: bank to control regulator voltage
  37  * @voltage_reg: register to control regulator voltage
  38  * @voltage_mask: mask to control regulator voltage
  39  * @voltages: supported voltage table
  40  * @voltages_len: number of supported voltages for the regulator
  41  * @delay: startup/set voltage delay in us
  42  */
  43 struct ab8500_regulator_info {
  44         struct device           *dev;
  45         struct regulator_desc   desc;
  46         struct regulator_dev    *regulator;
  47         int max_uV;
  48         int min_uV;
  49         int fixed_uV;
  50         u8 update_bank;
  51         u8 update_reg;
  52         u8 update_mask;
  53         u8 update_val_enable;
  54         u8 voltage_bank;
  55         u8 voltage_reg;
  56         u8 voltage_mask;
  57         int const *voltages;
  58         int voltages_len;
  59         unsigned int delay;
  60 };
  61
  62 /* voltage tables for the vauxn/vintcore supplies */
  63 static const int ldo_vauxn_voltages[] = {
  64         1100000,
  65         1200000,
  66         1300000,
  67         1400000,
  68         1500000,
  69         1800000,
  70         1850000,
  71         1900000,
  72         2500000,
  73         2650000,
  74         2700000,
  75         2750000,
  76         2800000,
  77         2900000,
  78         3000000,
  79         3300000,
  80 };
  81
  82 static const int ldo_vaux3_voltages[] = {
  83         1200000,
  84         1500000,
  85         1800000,
  86         2100000,
  87         2500000,
  88         2750000,
  89         2790000,
  90         2910000,
  91 };
  92
  93 static const int ldo_vintcore_voltages[] = {
  94         1200000,
  95         1225000,
  96         1250000,
  97         1275000,
  98         1300000,
  99         1325000,
 100         1350000,
 101 };
 102
 103 static int ab8500_regulator_enable(struct regulator_dev *rdev)
 104 {
 105         int ret;
 106         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 107
 108         if (info == NULL) {
 109                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 110                 return -EINVAL;
 111         }
 112
 113         ret = abx500_mask_and_set_register_interruptible(info->dev,
 114                 info->update_bank, info->update_reg,
 115                 info->update_mask, info->update_val_enable);
 116         if (ret < 0)
 117                 dev_err(rdev_get_dev(rdev),
 118                         "couldn't set enable bits for regulator\n");
 119
 120         dev_vdbg(rdev_get_dev(rdev),
 121                 "%s-enable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
 122                 info->desc.name, info->update_bank, info->update_reg,
 123                 info->update_mask, info->update_val_enable);
 124
 125         return ret;
 126 }
 127
 128 static int ab8500_regulator_disable(struct regulator_dev *rdev)
 129 {
 130         int ret;
 131         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 132
 133         if (info == NULL) {
 134                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 135                 return -EINVAL;
 136         }
 137
 138         ret = abx500_mask_and_set_register_interruptible(info->dev,
 139                 info->update_bank, info->update_reg,
 140                 info->update_mask, 0x0);
 141         if (ret < 0)
 142                 dev_err(rdev_get_dev(rdev),
 143                         "couldn't set disable bits for regulator\n");
 144
 145         dev_vdbg(rdev_get_dev(rdev),
 146                 "%s-disable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
 147                 info->desc.name, info->update_bank, info->update_reg,
 148                 info->update_mask, 0x0);
 149
 150         return ret;
 151 }
 152
 153 static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
 154 {
 155         int ret;
 156         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 157         u8 regval;
 158
 159         if (info == NULL) {
 160                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 161                 return -EINVAL;
 162         }
 163
 164         ret = abx500_get_register_interruptible(info->dev,
 165                 info->update_bank, info->update_reg, &regval);
 166         if (ret < 0) {
 167                 dev_err(rdev_get_dev(rdev),
 168                         "couldn't read 0x%x register\n", info->update_reg);
 169                 return ret;
 170         }
 171
 172         dev_vdbg(rdev_get_dev(rdev),
 173                 "%s-is_enabled (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
 174                 " 0x%x\n",
 175                 info->desc.name, info->update_bank, info->update_reg,
 176                 info->update_mask, regval);
 177
 178         if (regval & info->update_mask)
 179                 return true;
 180         else
 181                 return false;
 182 }
 183
 184 static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
 185 {
 186         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 187
 188         if (info == NULL) {
 189                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 190                 return -EINVAL;
 191         }
 192
 193         /* return the uV for the fixed regulators */
 194         if (info->fixed_uV)
 195                 return info->fixed_uV;
 196
 197         if (selector >= info->voltages_len)
 198                 return -EINVAL;
 199
 200         return info->voltages[selector];
 201 }
 202
 203 static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
 204 {
 205         int ret, val;
 206         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 207         u8 regval;
 208
 209         if (info == NULL) {
 210                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 211                 return -EINVAL;
 212         }
 213
 214         ret = abx500_get_register_interruptible(info->dev,
 215                         info->voltage_bank, info->voltage_reg, &regval);
 216         if (ret < 0) {
 217                 dev_err(rdev_get_dev(rdev),
 218                         "couldn't read voltage reg for regulator\n");
 219                 return ret;
 220         }
 221
 222         dev_vdbg(rdev_get_dev(rdev),
 223                 "%s-get_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
 224                 " 0x%x\n",
 225                 info->desc.name, info->voltage_bank, info->voltage_reg,
 226                 info->voltage_mask, regval);
 227
 228         /* vintcore has a different layout */
 229         val = regval & info->voltage_mask;
 230         if (info->desc.id == AB8500_LDO_INTCORE)
 231                 ret = info->voltages[val >> 0x3];
 232         else
 233                 ret = info->voltages[val];
 234
 235         return ret;
 236 }
 237
 238 static int ab8500_get_best_voltage_index(struct regulator_dev *rdev,
 239                 int min_uV, int max_uV)
 240 {
 241         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 242         int i;
 243
 244         /* check the supported voltage */
 245         for (i = 0; i < info->voltages_len; i++) {
 246                 if ((info->voltages[i] >= min_uV) &&
 247                     (info->voltages[i] <= max_uV))
 248                         return i;
 249         }
 250
 251         return -EINVAL;
 252 }
 253
 254 static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
 255                                         int min_uV, int max_uV,
 256                                         unsigned *selector)
 257 {
 258         int ret;
 259         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 260         u8 regval;
 261
 262         if (info == NULL) {
 263                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 264                 return -EINVAL;
 265         }
 266
 267         /* get the appropriate voltages within the range */
 268         ret = ab8500_get_best_voltage_index(rdev, min_uV, max_uV);
 269         if (ret < 0) {
 270                 dev_err(rdev_get_dev(rdev),
 271                                 "couldn't get best voltage for regulator\n");
 272                 return ret;
 273         }
 274
 275         *selector = ret;
 276
 277         /* set the registers for the request */
 278         regval = (u8)ret;
 279         ret = abx500_mask_and_set_register_interruptible(info->dev,
 280                         info->voltage_bank, info->voltage_reg,
 281                         info->voltage_mask, regval);
 282         if (ret < 0)
 283                 dev_err(rdev_get_dev(rdev),
 284                 "couldn't set voltage reg for regulator\n");
 285
 286         dev_vdbg(rdev_get_dev(rdev),
 287                 "%s-set_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
 288                 " 0x%x\n",
 289                 info->desc.name, info->voltage_bank, info->voltage_reg,
 290                 info->voltage_mask, regval);
 291
 292         return ret;
 293 }
 294
 295 static int ab8500_regulator_enable_time(struct regulator_dev *rdev)
 296 {
 297         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 298
 299         return info->delay;
 300 }
 301
 302 static int ab8500_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
 303                                              unsigned int old_sel,
 304                                              unsigned int new_sel)
 305 {
 306         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 307         int ret;
 308
 309         /* If the regulator isn't on, it won't take time here */
 310         ret = ab8500_regulator_is_enabled(rdev);
 311         if (ret < 0)
 312                 return ret;
 313         if (!ret)
 314                 return 0;
 315         return info->delay;
 316 }
 317
 318 static struct regulator_ops ab8500_regulator_ops = {
 319         .enable         = ab8500_regulator_enable,
 320         .disable        = ab8500_regulator_disable,
 321         .is_enabled     = ab8500_regulator_is_enabled,
 322         .get_voltage    = ab8500_regulator_get_voltage,
 323         .set_voltage    = ab8500_regulator_set_voltage,
 324         .list_voltage   = ab8500_list_voltage,
 325         .enable_time    = ab8500_regulator_enable_time,
 326         .set_voltage_time_sel = ab8500_regulator_set_voltage_time_sel,
 327 };
 328
 329 static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
 330 {
 331         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 332
 333         if (info == NULL) {
 334                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 335                 return -EINVAL;
 336         }
 337
 338         return info->fixed_uV;
 339 }
 340
 341 static struct regulator_ops ab8500_regulator_fixed_ops = {
 342         .enable         = ab8500_regulator_enable,
 343         .disable        = ab8500_regulator_disable,
 344         .is_enabled     = ab8500_regulator_is_enabled,
 345         .get_voltage    = ab8500_fixed_get_voltage,
 346         .list_voltage   = ab8500_list_voltage,
 347         .enable_time    = ab8500_regulator_enable_time,
 348         .set_voltage_time_sel = ab8500_regulator_set_voltage_time_sel,
 349 };
 350
 351 static struct ab8500_regulator_info
 352                 ab8500_regulator_info[AB8500_NUM_REGULATORS] = {
 353         /*
 354          * Variable Voltage Regulators
 355          *   name, min mV, max mV,
 356          *   update bank, reg, mask, enable val
 357          *   volt bank, reg, mask, table, table length
 358          */
 359         [AB8500_LDO_AUX1] = {
 360                 .desc = {
 361                         .name           = "LDO-AUX1",
 362                         .ops            = &ab8500_regulator_ops,
 363                         .type           = REGULATOR_VOLTAGE,
 364                         .id             = AB8500_LDO_AUX1,
 365                         .owner          = THIS_MODULE,
 366                         .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
 367                 },
 368                 .min_uV                 = 1100000,
 369                 .max_uV                 = 3300000,
 370                 .update_bank            = 0x04,
 371                 .update_reg             = 0x09,
 372                 .update_mask            = 0x03,
 373                 .update_val_enable      = 0x01,
 374                 .voltage_bank           = 0x04,
 375                 .voltage_reg            = 0x1f,
 376                 .voltage_mask           = 0x0f,
 377                 .voltages               = ldo_vauxn_voltages,
 378                 .voltages_len           = ARRAY_SIZE(ldo_vauxn_voltages),
 379         },
 380         [AB8500_LDO_AUX2] = {
 381                 .desc = {
 382                         .name           = "LDO-AUX2",
 383                         .ops            = &ab8500_regulator_ops,
 384                         .type           = REGULATOR_VOLTAGE,
 385                         .id             = AB8500_LDO_AUX2,
 386                         .owner          = THIS_MODULE,
 387                         .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
 388                 },
 389                 .min_uV                 = 1100000,
 390                 .max_uV                 = 3300000,
 391                 .update_bank            = 0x04,
 392                 .update_reg             = 0x09,
 393                 .update_mask            = 0x0c,
 394                 .update_val_enable      = 0x04,
 395                 .voltage_bank           = 0x04,
 396                 .voltage_reg            = 0x20,
 397                 .voltage_mask           = 0x0f,
 398                 .voltages               = ldo_vauxn_voltages,
 399                 .voltages_len           = ARRAY_SIZE(ldo_vauxn_voltages),
 400         },
 401         [AB8500_LDO_AUX3] = {
 402                 .desc = {
 403                         .name           = "LDO-AUX3",
 404                         .ops            = &ab8500_regulator_ops,
 405                         .type           = REGULATOR_VOLTAGE,
 406                         .id             = AB8500_LDO_AUX3,
 407                         .owner          = THIS_MODULE,
 408                         .n_voltages     = ARRAY_SIZE(ldo_vaux3_voltages),
 409                 },
 410                 .min_uV                 = 1100000,
 411                 .max_uV                 = 3300000,
 412                 .update_bank            = 0x04,
 413                 .update_reg             = 0x0a,
 414                 .update_mask            = 0x03,
 415                 .update_val_enable      = 0x01,
 416                 .voltage_bank           = 0x04,
 417                 .voltage_reg            = 0x21,
 418                 .voltage_mask           = 0x07,
 419                 .voltages               = ldo_vaux3_voltages,
 420                 .voltages_len           = ARRAY_SIZE(ldo_vaux3_voltages),
 421         },
 422         [AB8500_LDO_INTCORE] = {
 423                 .desc = {
 424                         .name           = "LDO-INTCORE",
 425                         .ops            = &ab8500_regulator_ops,
 426                         .type           = REGULATOR_VOLTAGE,
 427                         .id             = AB8500_LDO_INTCORE,
 428                         .owner          = THIS_MODULE,
 429                         .n_voltages     = ARRAY_SIZE(ldo_vintcore_voltages),
 430                 },
 431                 .min_uV                 = 1100000,
 432                 .max_uV                 = 3300000,
 433                 .update_bank            = 0x03,
 434                 .update_reg             = 0x80,
 435                 .update_mask            = 0x44,
 436                 .update_val_enable      = 0x04,
 437                 .voltage_bank           = 0x03,
 438                 .voltage_reg            = 0x80,
 439                 .voltage_mask           = 0x38,
 440                 .voltages               = ldo_vintcore_voltages,
 441                 .voltages_len           = ARRAY_SIZE(ldo_vintcore_voltages),
 442         },
 443
 444         /*
 445          * Fixed Voltage Regulators
 446          *   name, fixed mV,
 447          *   update bank, reg, mask, enable val
 448          */
 449         [AB8500_LDO_TVOUT] = {
 450                 .desc = {
 451                         .name           = "LDO-TVOUT",
 452                         .ops            = &ab8500_regulator_fixed_ops,
 453                         .type           = REGULATOR_VOLTAGE,
 454                         .id             = AB8500_LDO_TVOUT,
 455                         .owner          = THIS_MODULE,
 456                         .n_voltages     = 1,
 457                 },
 458                 .delay                  = 10000,
 459                 .fixed_uV               = 2000000,
 460                 .update_bank            = 0x03,
 461                 .update_reg             = 0x80,
 462                 .update_mask            = 0x82,
 463                 .update_val_enable      = 0x02,
 464         },
 465         [AB8500_LDO_USB] = {
 466                 .desc = {
 467                         .name           = "LDO-USB",
 468                         .ops            = &ab8500_regulator_fixed_ops,
 469                         .type           = REGULATOR_VOLTAGE,
 470                         .id             = AB8500_LDO_USB,
 471                         .owner          = THIS_MODULE,
 472                         .n_voltages     = 1,
 473                 },
 474                 .fixed_uV               = 3300000,
 475                 .update_bank            = 0x03,
 476                 .update_reg             = 0x82,
 477                 .update_mask            = 0x03,
 478                 .update_val_enable      = 0x01,
 479         },
 480         [AB8500_LDO_AUDIO] = {
 481                 .desc = {
 482                         .name           = "LDO-AUDIO",
 483                         .ops            = &ab8500_regulator_fixed_ops,
 484                         .type           = REGULATOR_VOLTAGE,
 485                         .id             = AB8500_LDO_AUDIO,
 486                         .owner          = THIS_MODULE,
 487                         .n_voltages     = 1,
 488                 },
 489                 .fixed_uV               = 2000000,
 490                 .update_bank            = 0x03,
 491                 .update_reg             = 0x83,
 492                 .update_mask            = 0x02,
 493                 .update_val_enable      = 0x02,
 494         },
 495         [AB8500_LDO_ANAMIC1] = {
 496                 .desc = {
 497                         .name           = "LDO-ANAMIC1",
 498                         .ops            = &ab8500_regulator_fixed_ops,
 499                         .type           = REGULATOR_VOLTAGE,
 500                         .id             = AB8500_LDO_ANAMIC1,
 501                         .owner          = THIS_MODULE,
 502                         .n_voltages     = 1,
 503                 },
 504                 .fixed_uV               = 2050000,
 505                 .update_bank            = 0x03,
 506                 .update_reg             = 0x83,
 507                 .update_mask            = 0x08,
 508                 .update_val_enable      = 0x08,
 509         },
 510         [AB8500_LDO_ANAMIC2] = {
 511                 .desc = {
 512                         .name           = "LDO-ANAMIC2",
 513                         .ops            = &ab8500_regulator_fixed_ops,
 514                         .type           = REGULATOR_VOLTAGE,
 515                         .id             = AB8500_LDO_ANAMIC2,
 516                         .owner          = THIS_MODULE,
 517                         .n_voltages     = 1,
 518                 },
 519                 .fixed_uV               = 2050000,
 520                 .update_bank            = 0x03,
 521                 .update_reg             = 0x83,
 522                 .update_mask            = 0x10,
 523                 .update_val_enable      = 0x10,
 524         },
 525         [AB8500_LDO_DMIC] = {
 526                 .desc = {
 527                         .name           = "LDO-DMIC",
 528                         .ops            = &ab8500_regulator_fixed_ops,
 529                         .type           = REGULATOR_VOLTAGE,
 530                         .id             = AB8500_LDO_DMIC,
 531                         .owner          = THIS_MODULE,
 532                         .n_voltages     = 1,
 533                 },
 534                 .fixed_uV               = 1800000,
 535                 .update_bank            = 0x03,
 536                 .update_reg             = 0x83,
 537                 .update_mask            = 0x04,
 538                 .update_val_enable      = 0x04,
 539         },
 540         [AB8500_LDO_ANA] = {
 541                 .desc = {
 542                         .name           = "LDO-ANA",
 543                         .ops            = &ab8500_regulator_fixed_ops,
 544                         .type           = REGULATOR_VOLTAGE,
 545                         .id             = AB8500_LDO_ANA,
 546                         .owner          = THIS_MODULE,
 547                         .n_voltages     = 1,
 548                 },
 549                 .fixed_uV               = 1200000,
 550                 .update_bank            = 0x04,
 551                 .update_reg             = 0x06,
 552                 .update_mask            = 0x0c,
 553                 .update_val_enable      = 0x04,
 554         },
 555
 556
 557 };
 558
 559 struct ab8500_reg_init {
 560         u8 bank;
 561         u8 addr;
 562         u8 mask;
 563 };
 564
 565 #define REG_INIT(_id, _bank, _addr, _mask)      \
 566         [_id] = {                               \
 567                 .bank = _bank,                  \
 568                 .addr = _addr,                  \
 569                 .mask = _mask,                  \
 570         }
 571
 572 static struct ab8500_reg_init ab8500_reg_init[] = {
 573         /*
 574          * 0x30, VanaRequestCtrl
 575          * 0x0C, VpllRequestCtrl
 576          * 0xc0, VextSupply1RequestCtrl
 577          */
 578         REG_INIT(AB8500_REGUREQUESTCTRL2,       0x03, 0x04, 0xfc),
 579         /*
 580          * 0x03, VextSupply2RequestCtrl
 581          * 0x0c, VextSupply3RequestCtrl
 582          * 0x30, Vaux1RequestCtrl
 583          * 0xc0, Vaux2RequestCtrl
 584          */
 585         REG_INIT(AB8500_REGUREQUESTCTRL3,       0x03, 0x05, 0xff),
 586         /*
 587          * 0x03, Vaux3RequestCtrl
 588          * 0x04, SwHPReq
 589          */
 590         REG_INIT(AB8500_REGUREQUESTCTRL4,       0x03, 0x06, 0x07),
 591         /*
 592          * 0x08, VanaSysClkReq1HPValid
 593          * 0x20, Vaux1SysClkReq1HPValid
 594          * 0x40, Vaux2SysClkReq1HPValid
 595          * 0x80, Vaux3SysClkReq1HPValid
 596          */
 597         REG_INIT(AB8500_REGUSYSCLKREQ1HPVALID1, 0x03, 0x07, 0xe8),
 598         /*
 599          * 0x10, VextSupply1SysClkReq1HPValid
 600          * 0x20, VextSupply2SysClkReq1HPValid
 601          * 0x40, VextSupply3SysClkReq1HPValid
 602          */
 603         REG_INIT(AB8500_REGUSYSCLKREQ1HPVALID2, 0x03, 0x08, 0x70),
 604         /*
 605          * 0x08, VanaHwHPReq1Valid
 606          * 0x20, Vaux1HwHPReq1Valid
 607          * 0x40, Vaux2HwHPReq1Valid
 608          * 0x80, Vaux3HwHPReq1Valid
 609          */
 610         REG_INIT(AB8500_REGUHWHPREQ1VALID1,     0x03, 0x09, 0xe8),
 611         /*
 612          * 0x01, VextSupply1HwHPReq1Valid
 613          * 0x02, VextSupply2HwHPReq1Valid
 614          * 0x04, VextSupply3HwHPReq1Valid
 615          */
 616         REG_INIT(AB8500_REGUHWHPREQ1VALID2,     0x03, 0x0a, 0x07),
 617         /*
 618          * 0x08, VanaHwHPReq2Valid
 619          * 0x20, Vaux1HwHPReq2Valid
 620          * 0x40, Vaux2HwHPReq2Valid
 621          * 0x80, Vaux3HwHPReq2Valid
 622          */
 623         REG_INIT(AB8500_REGUHWHPREQ2VALID1,     0x03, 0x0b, 0xe8),
 624         /*
 625          * 0x01, VextSupply1HwHPReq2Valid
 626          * 0x02, VextSupply2HwHPReq2Valid
 627          * 0x04, VextSupply3HwHPReq2Valid
 628          */
 629         REG_INIT(AB8500_REGUHWHPREQ2VALID2,     0x03, 0x0c, 0x07),
 630         /*
 631          * 0x20, VanaSwHPReqValid
 632          * 0x80, Vaux1SwHPReqValid
 633          */
 634         REG_INIT(AB8500_REGUSWHPREQVALID1,      0x03, 0x0d, 0xa0),
 635         /*
 636          * 0x01, Vaux2SwHPReqValid
 637          * 0x02, Vaux3SwHPReqValid
 638          * 0x04, VextSupply1SwHPReqValid
 639          * 0x08, VextSupply2SwHPReqValid
 640          * 0x10, VextSupply3SwHPReqValid
 641          */
 642         REG_INIT(AB8500_REGUSWHPREQVALID2,      0x03, 0x0e, 0x1f),
 643         /*
 644          * 0x02, SysClkReq2Valid1
 645          * ...
 646          * 0x80, SysClkReq8Valid1
 647          */
 648         REG_INIT(AB8500_REGUSYSCLKREQVALID1,    0x03, 0x0f, 0xfe),
 649         /*
 650          * 0x02, SysClkReq2Valid2
 651          * ...
 652          * 0x80, SysClkReq8Valid2
 653          */
 654         REG_INIT(AB8500_REGUSYSCLKREQVALID2,    0x03, 0x10, 0xfe),
 655         /*
 656          * 0x02, VTVoutEna
 657          * 0x04, Vintcore12Ena
 658          * 0x38, Vintcore12Sel
 659          * 0x40, Vintcore12LP
 660          * 0x80, VTVoutLP
 661          */
 662         REG_INIT(AB8500_REGUMISC1,              0x03, 0x80, 0xfe),
 663         /*
 664          * 0x02, VaudioEna
 665          * 0x04, VdmicEna
 666          * 0x08, Vamic1Ena
 667          * 0x10, Vamic2Ena
 668          */
 669         REG_INIT(AB8500_VAUDIOSUPPLY,           0x03, 0x83, 0x1e),
 670         /*
 671          * 0x01, Vamic1_dzout
 672          * 0x02, Vamic2_dzout
 673          */
 674         REG_INIT(AB8500_REGUCTRL1VAMIC,         0x03, 0x84, 0x03),
 675         /*
 676          * 0x0c, VanaRegu
 677          * 0x03, VpllRegu
 678          */
 679         REG_INIT(AB8500_VPLLVANAREGU,           0x04, 0x06, 0x0f),
 680         /*
 681          * 0x01, VrefDDREna
 682          * 0x02, VrefDDRSleepMode
 683          */
 684         REG_INIT(AB8500_VREFDDR,                0x04, 0x07, 0x03),
 685         /*
 686          * 0x03, VextSupply1Regu
 687          * 0x0c, VextSupply2Regu
 688          * 0x30, VextSupply3Regu
 689          * 0x40, ExtSupply2Bypass
 690          * 0x80, ExtSupply3Bypass
 691          */
 692         REG_INIT(AB8500_EXTSUPPLYREGU,          0x04, 0x08, 0xff),
 693         /*
 694          * 0x03, Vaux1Regu
 695          * 0x0c, Vaux2Regu
 696          */
 697         REG_INIT(AB8500_VAUX12REGU,             0x04, 0x09, 0x0f),
 698         /*
 699          * 0x03, Vaux3Regu
 700          */
 701         REG_INIT(AB8500_VRF1VAUX3REGU,          0x04, 0x0a, 0x03),
 702         /*
 703          * 0x3f, Vsmps1Sel1
 704          */
 705         REG_INIT(AB8500_VSMPS1SEL1,             0x04, 0x13, 0x3f),
 706         /*
 707          * 0x0f, Vaux1Sel
 708          */
 709         REG_INIT(AB8500_VAUX1SEL,               0x04, 0x1f, 0x0f),
 710         /*
 711          * 0x0f, Vaux2Sel
 712          */
 713         REG_INIT(AB8500_VAUX2SEL,               0x04, 0x20, 0x0f),
 714         /*
 715          * 0x07, Vaux3Sel
 716          */
 717         REG_INIT(AB8500_VRF1VAUX3SEL,           0x04, 0x21, 0x07),
 718         /*
 719          * 0x01, VextSupply12LP
 720          */
 721         REG_INIT(AB8500_REGUCTRL2SPARE,         0x04, 0x22, 0x01),
 722         /*
 723          * 0x04, Vaux1Disch
 724          * 0x08, Vaux2Disch
 725          * 0x10, Vaux3Disch
 726          * 0x20, Vintcore12Disch
 727          * 0x40, VTVoutDisch
 728          * 0x80, VaudioDisch
 729          */
 730         REG_INIT(AB8500_REGUCTRLDISCH,          0x04, 0x43, 0xfc),
 731         /*
 732          * 0x02, VanaDisch
 733          * 0x04, VdmicPullDownEna
 734          * 0x10, VdmicDisch
 735          */
 736         REG_INIT(AB8500_REGUCTRLDISCH2,         0x04, 0x44, 0x16),
 737 };
 738
 739 static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
 740 {
 741         struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
 742         struct ab8500_platform_data *pdata;
 743         int i, err;
 744
 745         if (!ab8500) {
 746                 dev_err(&pdev->dev, "null mfd parent\n");
 747                 return -EINVAL;
 748         }
 749         pdata = dev_get_platdata(ab8500->dev);
 750         if (!pdata) {
 751                 dev_err(&pdev->dev, "null pdata\n");
 752                 return -EINVAL;
 753         }
 754
 755         /* make sure the platform data has the correct size */
 756         if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
 757                 dev_err(&pdev->dev, "Configuration error: size mismatch.\n");
 758                 return -EINVAL;
 759         }
 760
 761         /* initialize registers */
 762         for (i = 0; i < pdata->num_regulator_reg_init; i++) {
 763                 int id;
 764                 u8 value;
 765
 766                 id = pdata->regulator_reg_init[i].id;
 767                 value = pdata->regulator_reg_init[i].value;
 768
 769                 /* check for configuration errors */
 770                 if (id >= AB8500_NUM_REGULATOR_REGISTERS) {
 771                         dev_err(&pdev->dev,
 772                                 "Configuration error: id outside range.\n");
 773                         return -EINVAL;
 774                 }
 775                 if (value & ~ab8500_reg_init[id].mask) {
 776                         dev_err(&pdev->dev,
 777                                 "Configuration error: value outside mask.\n");
 778                         return -EINVAL;
 779                 }
 780
 781                 /* initialize register */
 782                 err = abx500_mask_and_set_register_interruptible(&pdev->dev,
 783                         ab8500_reg_init[id].bank,
 784                         ab8500_reg_init[id].addr,
 785                         ab8500_reg_init[id].mask,
 786                         value);
 787                 if (err < 0) {
 788                         dev_err(&pdev->dev,
 789                                 "Failed to initialize 0x%02x, 0x%02x.\n",
 790                                 ab8500_reg_init[id].bank,
 791                                 ab8500_reg_init[id].addr);
 792                         return err;
 793                 }
 794                 dev_vdbg(&pdev->dev,
 795                         "  init: 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
 796                         ab8500_reg_init[id].bank,
 797                         ab8500_reg_init[id].addr,
 798                         ab8500_reg_init[id].mask,
 799                         value);
 800         }
 801
 802         /* register all regulators */
 803         for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
 804                 struct ab8500_regulator_info *info = NULL;
 805
 806                 /* assign per-regulator data */
 807                 info = &ab8500_regulator_info[i];
 808                 info->dev = &pdev->dev;
 809
 810                 /* fix for hardware before ab8500v2.0 */
 811                 if (abx500_get_chip_id(info->dev) < 0x20) {
 812                         if (info->desc.id == AB8500_LDO_AUX3) {
 813                                 info->desc.n_voltages =
 814                                         ARRAY_SIZE(ldo_vauxn_voltages);
 815                                 info->voltages = ldo_vauxn_voltages;
 816                                 info->voltages_len =
 817                                         ARRAY_SIZE(ldo_vauxn_voltages);
 818                                 info->voltage_mask = 0xf;
 819                         }
 820                 }
 821
 822                 /* register regulator with framework */
 823                 info->regulator = regulator_register(&info->desc, &pdev->dev,
 824                                 &pdata->regulator[i], info);
 825                 if (IS_ERR(info->regulator)) {
 826                         err = PTR_ERR(info->regulator);
 827                         dev_err(&pdev->dev, "failed to register regulator %s\n",
 828                                         info->desc.name);
 829                         /* when we fail, un-register all earlier regulators */
 830                         while (--i >= 0) {
 831                                 info = &ab8500_regulator_info[i];
 832                                 regulator_unregister(info->regulator);
 833                         }
 834                         return err;
 835                 }
 836
 837                 dev_vdbg(rdev_get_dev(info->regulator),
 838                         "%s-probed\n", info->desc.name);
 839         }
 840
 841         return 0;
 842 }
 843
 844 static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
 845 {
 846         int i;
 847
 848         for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
 849                 struct ab8500_regulator_info *info = NULL;
 850                 info = &ab8500_regulator_info[i];
 851
 852                 dev_vdbg(rdev_get_dev(info->regulator),
 853                         "%s-remove\n", info->desc.name);
 854
 855                 regulator_unregister(info->regulator);
 856         }
 857
 858         return 0;
 859 }
 860
 861 static struct platform_driver ab8500_regulator_driver = {
 862         .probe = ab8500_regulator_probe,
 863         .remove = __devexit_p(ab8500_regulator_remove),
 864         .driver         = {
 865                 .name   = "ab8500-regulator",
 866                 .owner  = THIS_MODULE,
 867         },
 868 };
 869
 870 static int __init ab8500_regulator_init(void)
 871 {
 872         int ret;
 873
 874         ret = platform_driver_register(&ab8500_regulator_driver);
 875         if (ret != 0)
 876                 pr_err("Failed to register ab8500 regulator: %d\n", ret);
 877
 878         return ret;
 879 }
 880 subsys_initcall(ab8500_regulator_init);
 881
 882 static void __exit ab8500_regulator_exit(void)
 883 {
 884         platform_driver_unregister(&ab8500_regulator_driver);
 885 }
 886 module_exit(ab8500_regulator_exit);
 887
 888 MODULE_LICENSE("GPL v2");
 889 MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
 890 MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC");
 891 MODULE_ALIAS("platform:ab8500-regulator");