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