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, 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  */
  42 struct ab8500_regulator_info {
  43         struct device           *dev;
  44         struct regulator_desc   desc;
  45         struct regulator_dev    *regulator;
  46         int max_uV;
  47         int min_uV;
  48         int fixed_uV;
  49         u8 update_bank;
  50         u8 update_reg;
  51         u8 update_mask;
  52         u8 update_val_enable;
  53         u8 voltage_bank;
  54         u8 voltage_reg;
  55         u8 voltage_mask;
  56         int const *voltages;
  57         int voltages_len;
  58 };
  59
  60 /* voltage tables for the vauxn/vintcore supplies */
  61 static const int ldo_vauxn_voltages[] = {
  62         1100000,
  63         1200000,
  64         1300000,
  65         1400000,
  66         1500000,
  67         1800000,
  68         1850000,
  69         1900000,
  70         2500000,
  71         2650000,
  72         2700000,
  73         2750000,
  74         2800000,
  75         2900000,
  76         3000000,
  77         3300000,
  78 };
  79
  80 static const int ldo_vaux3_voltages[] = {
  81         1200000,
  82         1500000,
  83         1800000,
  84         2100000,
  85         2500000,
  86         2750000,
  87         2790000,
  88         2910000,
  89 };
  90
  91 static const int ldo_vintcore_voltages[] = {
  92         1200000,
  93         1225000,
  94         1250000,
  95         1275000,
  96         1300000,
  97         1325000,
  98         1350000,
  99 };
 100
 101 static int ab8500_regulator_enable(struct regulator_dev *rdev)
 102 {
 103         int ret;
 104         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 105
 106         if (info == NULL) {
 107                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 108                 return -EINVAL;
 109         }
 110
 111         ret = abx500_mask_and_set_register_interruptible(info->dev,
 112                 info->update_bank, info->update_reg,
 113                 info->update_mask, info->update_val_enable);
 114         if (ret < 0)
 115                 dev_err(rdev_get_dev(rdev),
 116                         "couldn't set enable bits for regulator\n");
 117
 118         dev_vdbg(rdev_get_dev(rdev),
 119                 "%s-enable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
 120                 info->desc.name, info->update_bank, info->update_reg,
 121                 info->update_mask, info->update_val_enable);
 122
 123         return ret;
 124 }
 125
 126 static int ab8500_regulator_disable(struct regulator_dev *rdev)
 127 {
 128         int ret;
 129         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 130
 131         if (info == NULL) {
 132                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 133                 return -EINVAL;
 134         }
 135
 136         ret = abx500_mask_and_set_register_interruptible(info->dev,
 137                 info->update_bank, info->update_reg,
 138                 info->update_mask, 0x0);
 139         if (ret < 0)
 140                 dev_err(rdev_get_dev(rdev),
 141                         "couldn't set disable bits for regulator\n");
 142
 143         dev_vdbg(rdev_get_dev(rdev),
 144                 "%s-disable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
 145                 info->desc.name, info->update_bank, info->update_reg,
 146                 info->update_mask, 0x0);
 147
 148         return ret;
 149 }
 150
 151 static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
 152 {
 153         int ret;
 154         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 155         u8 regval;
 156
 157         if (info == NULL) {
 158                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 159                 return -EINVAL;
 160         }
 161
 162         ret = abx500_get_register_interruptible(info->dev,
 163                 info->update_bank, info->update_reg, &regval);
 164         if (ret < 0) {
 165                 dev_err(rdev_get_dev(rdev),
 166                         "couldn't read 0x%x register\n", info->update_reg);
 167                 return ret;
 168         }
 169
 170         dev_vdbg(rdev_get_dev(rdev),
 171                 "%s-is_enabled (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
 172                 " 0x%x\n",
 173                 info->desc.name, info->update_bank, info->update_reg,
 174                 info->update_mask, regval);
 175
 176         if (regval & info->update_mask)
 177                 return true;
 178         else
 179                 return false;
 180 }
 181
 182 static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
 183 {
 184         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 185
 186         if (info == NULL) {
 187                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 188                 return -EINVAL;
 189         }
 190
 191         /* return the uV for the fixed regulators */
 192         if (info->fixed_uV)
 193                 return info->fixed_uV;
 194
 195         if (selector >= info->voltages_len)
 196                 return -EINVAL;
 197
 198         return info->voltages[selector];
 199 }
 200
 201 static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
 202 {
 203         int ret, val;
 204         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 205         u8 regval;
 206
 207         if (info == NULL) {
 208                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 209                 return -EINVAL;
 210         }
 211
 212         ret = abx500_get_register_interruptible(info->dev,
 213                         info->voltage_bank, info->voltage_reg, &regval);
 214         if (ret < 0) {
 215                 dev_err(rdev_get_dev(rdev),
 216                         "couldn't read voltage reg for regulator\n");
 217                 return ret;
 218         }
 219
 220         dev_vdbg(rdev_get_dev(rdev),
 221                 "%s-get_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
 222                 " 0x%x\n",
 223                 info->desc.name, info->voltage_bank, info->voltage_reg,
 224                 info->voltage_mask, regval);
 225
 226         /* vintcore has a different layout */
 227         val = regval & info->voltage_mask;
 228         if (info->desc.id == AB8500_LDO_INTCORE)
 229                 ret = info->voltages[val >> 0x3];
 230         else
 231                 ret = info->voltages[val];
 232
 233         return ret;
 234 }
 235
 236 static int ab8500_get_best_voltage_index(struct regulator_dev *rdev,
 237                 int min_uV, int max_uV)
 238 {
 239         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 240         int i;
 241
 242         /* check the supported voltage */
 243         for (i = 0; i < info->voltages_len; i++) {
 244                 if ((info->voltages[i] >= min_uV) &&
 245                     (info->voltages[i] <= max_uV))
 246                         return i;
 247         }
 248
 249         return -EINVAL;
 250 }
 251
 252 static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
 253                                         int min_uV, int max_uV,
 254                                         unsigned *selector)
 255 {
 256         int ret;
 257         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 258         u8 regval;
 259
 260         if (info == NULL) {
 261                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 262                 return -EINVAL;
 263         }
 264
 265         /* get the appropriate voltages within the range */
 266         ret = ab8500_get_best_voltage_index(rdev, min_uV, max_uV);
 267         if (ret < 0) {
 268                 dev_err(rdev_get_dev(rdev),
 269                                 "couldn't get best voltage for regulator\n");
 270                 return ret;
 271         }
 272
 273         *selector = ret;
 274
 275         /* set the registers for the request */
 276         regval = (u8)ret;
 277         ret = abx500_mask_and_set_register_interruptible(info->dev,
 278                         info->voltage_bank, info->voltage_reg,
 279                         info->voltage_mask, regval);
 280         if (ret < 0)
 281                 dev_err(rdev_get_dev(rdev),
 282                 "couldn't set voltage reg for regulator\n");
 283
 284         dev_vdbg(rdev_get_dev(rdev),
 285                 "%s-set_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
 286                 " 0x%x\n",
 287                 info->desc.name, info->voltage_bank, info->voltage_reg,
 288                 info->voltage_mask, regval);
 289
 290         return ret;
 291 }
 292
 293 static struct regulator_ops ab8500_regulator_ops = {
 294         .enable         = ab8500_regulator_enable,
 295         .disable        = ab8500_regulator_disable,
 296         .is_enabled     = ab8500_regulator_is_enabled,
 297         .get_voltage    = ab8500_regulator_get_voltage,
 298         .set_voltage    = ab8500_regulator_set_voltage,
 299         .list_voltage   = ab8500_list_voltage,
 300 };
 301
 302 static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
 303 {
 304         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 305
 306         if (info == NULL) {
 307                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 308                 return -EINVAL;
 309         }
 310
 311         return info->fixed_uV;
 312 }
 313
 314 static struct regulator_ops ab8500_regulator_fixed_ops = {
 315         .enable         = ab8500_regulator_enable,
 316         .disable        = ab8500_regulator_disable,
 317         .is_enabled     = ab8500_regulator_is_enabled,
 318         .get_voltage    = ab8500_fixed_get_voltage,
 319         .list_voltage   = ab8500_list_voltage,
 320 };
 321
 322 static struct ab8500_regulator_info
 323                 ab8500_regulator_info[AB8500_NUM_REGULATORS] = {
 324         /*
 325          * Variable Voltage Regulators
 326          *   name, min mV, max mV,
 327          *   update bank, reg, mask, enable val
 328          *   volt bank, reg, mask, table, table length
 329          */
 330         [AB8500_LDO_AUX1] = {
 331                 .desc = {
 332                         .name           = "LDO-AUX1",
 333                         .ops            = &ab8500_regulator_ops,
 334                         .type           = REGULATOR_VOLTAGE,
 335                         .id             = AB8500_LDO_AUX1,
 336                         .owner          = THIS_MODULE,
 337                         .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
 338                 },
 339                 .min_uV                 = 1100000,
 340                 .max_uV                 = 3300000,
 341                 .update_bank            = 0x04,
 342                 .update_reg             = 0x09,
 343                 .update_mask            = 0x03,
 344                 .update_val_enable      = 0x01,
 345                 .voltage_bank           = 0x04,
 346                 .voltage_reg            = 0x1f,
 347                 .voltage_mask           = 0x0f,
 348                 .voltages               = ldo_vauxn_voltages,
 349                 .voltages_len           = ARRAY_SIZE(ldo_vauxn_voltages),
 350         },
 351         [AB8500_LDO_AUX2] = {
 352                 .desc = {
 353                         .name           = "LDO-AUX2",
 354                         .ops            = &ab8500_regulator_ops,
 355                         .type           = REGULATOR_VOLTAGE,
 356                         .id             = AB8500_LDO_AUX2,
 357                         .owner          = THIS_MODULE,
 358                         .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
 359                 },
 360                 .min_uV                 = 1100000,
 361                 .max_uV                 = 3300000,
 362                 .update_bank            = 0x04,
 363                 .update_reg             = 0x09,
 364                 .update_mask            = 0x0c,
 365                 .update_val_enable      = 0x04,
 366                 .voltage_bank           = 0x04,
 367                 .voltage_reg            = 0x20,
 368                 .voltage_mask           = 0x0f,
 369                 .voltages               = ldo_vauxn_voltages,
 370                 .voltages_len           = ARRAY_SIZE(ldo_vauxn_voltages),
 371         },
 372         [AB8500_LDO_AUX3] = {
 373                 .desc = {
 374                         .name           = "LDO-AUX3",
 375                         .ops            = &ab8500_regulator_ops,
 376                         .type           = REGULATOR_VOLTAGE,
 377                         .id             = AB8500_LDO_AUX3,
 378                         .owner          = THIS_MODULE,
 379                         .n_voltages     = ARRAY_SIZE(ldo_vaux3_voltages),
 380                 },
 381                 .min_uV                 = 1100000,
 382                 .max_uV                 = 3300000,
 383                 .update_bank            = 0x04,
 384                 .update_reg             = 0x0a,
 385                 .update_mask            = 0x03,
 386                 .update_val_enable      = 0x01,
 387                 .voltage_bank           = 0x04,
 388                 .voltage_reg            = 0x21,
 389                 .voltage_mask           = 0x07,
 390                 .voltages               = ldo_vaux3_voltages,
 391                 .voltages_len           = ARRAY_SIZE(ldo_vaux3_voltages),
 392         },
 393         [AB8500_LDO_INTCORE] = {
 394                 .desc = {
 395                         .name           = "LDO-INTCORE",
 396                         .ops            = &ab8500_regulator_ops,
 397                         .type           = REGULATOR_VOLTAGE,
 398                         .id             = AB8500_LDO_INTCORE,
 399                         .owner          = THIS_MODULE,
 400                         .n_voltages     = ARRAY_SIZE(ldo_vintcore_voltages),
 401                 },
 402                 .min_uV                 = 1100000,
 403                 .max_uV                 = 3300000,
 404                 .update_bank            = 0x03,
 405                 .update_reg             = 0x80,
 406                 .update_mask            = 0x44,
 407                 .update_val_enable      = 0x04,
 408                 .voltage_bank           = 0x03,
 409                 .voltage_reg            = 0x80,
 410                 .voltage_mask           = 0x38,
 411                 .voltages               = ldo_vintcore_voltages,
 412                 .voltages_len           = ARRAY_SIZE(ldo_vintcore_voltages),
 413         },
 414
 415         /*
 416          * Fixed Voltage Regulators
 417          *   name, fixed mV,
 418          *   update bank, reg, mask, enable val
 419          */
 420         [AB8500_LDO_TVOUT] = {
 421                 .desc = {
 422                         .name           = "LDO-TVOUT",
 423                         .ops            = &ab8500_regulator_fixed_ops,
 424                         .type           = REGULATOR_VOLTAGE,
 425                         .id             = AB8500_LDO_TVOUT,
 426                         .owner          = THIS_MODULE,
 427                         .n_voltages     = 1,
 428                 },
 429                 .fixed_uV               = 2000000,
 430                 .update_bank            = 0x03,
 431                 .update_reg             = 0x80,
 432                 .update_mask            = 0x82,
 433                 .update_val_enable      = 0x02,
 434         },
 435         [AB8500_LDO_AUDIO] = {
 436                 .desc = {
 437                         .name           = "LDO-AUDIO",
 438                         .ops            = &ab8500_regulator_fixed_ops,
 439                         .type           = REGULATOR_VOLTAGE,
 440                         .id             = AB8500_LDO_AUDIO,
 441                         .owner          = THIS_MODULE,
 442                         .n_voltages     = 1,
 443                 },
 444                 .fixed_uV               = 2000000,
 445                 .update_bank            = 0x03,
 446                 .update_reg             = 0x83,
 447                 .update_mask            = 0x02,
 448                 .update_val_enable      = 0x02,
 449         },
 450         [AB8500_LDO_ANAMIC1] = {
 451                 .desc = {
 452                         .name           = "LDO-ANAMIC1",
 453                         .ops            = &ab8500_regulator_fixed_ops,
 454                         .type           = REGULATOR_VOLTAGE,
 455                         .id             = AB8500_LDO_ANAMIC1,
 456                         .owner          = THIS_MODULE,
 457                         .n_voltages     = 1,
 458                 },
 459                 .fixed_uV               = 2050000,
 460                 .update_bank            = 0x03,
 461                 .update_reg             = 0x83,
 462                 .update_mask            = 0x08,
 463                 .update_val_enable      = 0x08,
 464         },
 465         [AB8500_LDO_ANAMIC2] = {
 466                 .desc = {
 467                         .name           = "LDO-ANAMIC2",
 468                         .ops            = &ab8500_regulator_fixed_ops,
 469                         .type           = REGULATOR_VOLTAGE,
 470                         .id             = AB8500_LDO_ANAMIC2,
 471                         .owner          = THIS_MODULE,
 472                         .n_voltages     = 1,
 473                 },
 474                 .fixed_uV               = 2050000,
 475                 .update_bank            = 0x03,
 476                 .update_reg             = 0x83,
 477                 .update_mask            = 0x10,
 478                 .update_val_enable      = 0x10,
 479         },
 480         [AB8500_LDO_DMIC] = {
 481                 .desc = {
 482                         .name           = "LDO-DMIC",
 483                         .ops            = &ab8500_regulator_fixed_ops,
 484                         .type           = REGULATOR_VOLTAGE,
 485                         .id             = AB8500_LDO_DMIC,
 486                         .owner          = THIS_MODULE,
 487                         .n_voltages     = 1,
 488                 },
 489                 .fixed_uV               = 1800000,
 490                 .update_bank            = 0x03,
 491                 .update_reg             = 0x83,
 492                 .update_mask            = 0x04,
 493                 .update_val_enable      = 0x04,
 494         },
 495         [AB8500_LDO_ANA] = {
 496                 .desc = {
 497                         .name           = "LDO-ANA",
 498                         .ops            = &ab8500_regulator_fixed_ops,
 499                         .type           = REGULATOR_VOLTAGE,
 500                         .id             = AB8500_LDO_ANA,
 501                         .owner          = THIS_MODULE,
 502                         .n_voltages     = 1,
 503                 },
 504                 .fixed_uV               = 1200000,
 505                 .update_bank            = 0x04,
 506                 .update_reg             = 0x06,
 507                 .update_mask            = 0x0c,
 508                 .update_val_enable      = 0x04,
 509         },
 510
 511
 512 };
 513
 514 static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
 515 {
 516         struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
 517         struct ab8500_platform_data *pdata;
 518         int i, err;
 519
 520         if (!ab8500) {
 521                 dev_err(&pdev->dev, "null mfd parent\n");
 522                 return -EINVAL;
 523         }
 524         pdata = dev_get_platdata(ab8500->dev);
 525         if (!pdata) {
 526                 dev_err(&pdev->dev, "null pdata\n");
 527                 return -EINVAL;
 528         }
 529
 530         /* make sure the platform data has the correct size */
 531         if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
 532                 dev_err(&pdev->dev, "platform configuration error\n");
 533                 return -EINVAL;
 534         }
 535
 536         /* register all regulators */
 537         for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
 538                 struct ab8500_regulator_info *info = NULL;
 539
 540                 /* assign per-regulator data */
 541                 info = &ab8500_regulator_info[i];
 542                 info->dev = &pdev->dev;
 543
 544                 /* fix for hardware before ab8500v2.0 */
 545                 if (abx500_get_chip_id(info->dev) < 0x20) {
 546                         if (info->desc.id == AB8500_LDO_AUX3) {
 547                                 info->desc.n_voltages =
 548                                         ARRAY_SIZE(ldo_vauxn_voltages);
 549                                 info->voltages = ldo_vauxn_voltages;
 550                                 info->voltages_len =
 551                                         ARRAY_SIZE(ldo_vauxn_voltages);
 552                                 info->voltage_mask = 0xf;
 553                         }
 554                 }
 555
 556                 /* register regulator with framework */
 557                 info->regulator = regulator_register(&info->desc, &pdev->dev,
 558                                 &pdata->regulator[i], info);
 559                 if (IS_ERR(info->regulator)) {
 560                         err = PTR_ERR(info->regulator);
 561                         dev_err(&pdev->dev, "failed to register regulator %s\n",
 562                                         info->desc.name);
 563                         /* when we fail, un-register all earlier regulators */
 564                         while (--i >= 0) {
 565                                 info = &ab8500_regulator_info[i];
 566                                 regulator_unregister(info->regulator);
 567                         }
 568                         return err;
 569                 }
 570
 571                 dev_vdbg(rdev_get_dev(info->regulator),
 572                         "%s-probed\n", info->desc.name);
 573         }
 574
 575         return 0;
 576 }
 577
 578 static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
 579 {
 580         int i;
 581
 582         for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
 583                 struct ab8500_regulator_info *info = NULL;
 584                 info = &ab8500_regulator_info[i];
 585
 586                 dev_vdbg(rdev_get_dev(info->regulator),
 587                         "%s-remove\n", info->desc.name);
 588
 589                 regulator_unregister(info->regulator);
 590         }
 591
 592         return 0;
 593 }
 594
 595 static struct platform_driver ab8500_regulator_driver = {
 596         .probe = ab8500_regulator_probe,
 597         .remove = __devexit_p(ab8500_regulator_remove),
 598         .driver         = {
 599                 .name   = "ab8500-regulator",
 600                 .owner  = THIS_MODULE,
 601         },
 602 };
 603
 604 static int __init ab8500_regulator_init(void)
 605 {
 606         int ret;
 607
 608         ret = platform_driver_register(&ab8500_regulator_driver);
 609         if (ret != 0)
 610                 pr_err("Failed to register ab8500 regulator: %d\n", ret);
 611
 612         return ret;
 613 }
 614 subsys_initcall(ab8500_regulator_init);
 615
 616 static void __exit ab8500_regulator_exit(void)
 617 {
 618         platform_driver_unregister(&ab8500_regulator_driver);
 619 }
 620 module_exit(ab8500_regulator_exit);
 621
 622 MODULE_LICENSE("GPL v2");
 623 MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
 624 MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC");
 625 MODULE_ALIAS("platform:ab8500-regulator");