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