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         return ret;
 118 }
 119
 120 static int ab8500_regulator_disable(struct regulator_dev *rdev)
 121 {
 122         int ret;
 123         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 124
 125         if (info == NULL) {
 126                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 127                 return -EINVAL;
 128         }
 129
 130         ret = abx500_mask_and_set_register_interruptible(info->dev,
 131                 info->update_bank, info->update_reg,
 132                 info->update_mask, 0x0);
 133         if (ret < 0)
 134                 dev_err(rdev_get_dev(rdev),
 135                         "couldn't set disable bits for regulator\n");
 136         return ret;
 137 }
 138
 139 static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
 140 {
 141         int ret;
 142         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 143         u8 value;
 144
 145         if (info == NULL) {
 146                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 147                 return -EINVAL;
 148         }
 149
 150         ret = abx500_get_register_interruptible(info->dev,
 151                 info->update_bank, info->update_reg, &value);
 152         if (ret < 0) {
 153                 dev_err(rdev_get_dev(rdev),
 154                         "couldn't read 0x%x register\n", info->update_reg);
 155                 return ret;
 156         }
 157
 158         if (value & info->update_mask)
 159                 return true;
 160         else
 161                 return false;
 162 }
 163
 164 static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
 165 {
 166         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 167
 168         if (info == NULL) {
 169                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 170                 return -EINVAL;
 171         }
 172
 173         /* return the uV for the fixed regulators */
 174         if (info->fixed_uV)
 175                 return info->fixed_uV;
 176
 177         if (selector >= info->voltages_len)
 178                 return -EINVAL;
 179
 180         return info->voltages[selector];
 181 }
 182
 183 static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
 184 {
 185         int ret;
 186         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 187         u8 value;
 188
 189         if (info == NULL) {
 190                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 191                 return -EINVAL;
 192         }
 193
 194         ret = abx500_get_register_interruptible(info->dev, info->voltage_bank,
 195                 info->voltage_reg, &value);
 196         if (ret < 0) {
 197                 dev_err(rdev_get_dev(rdev),
 198                         "couldn't read voltage reg for regulator\n");
 199                 return ret;
 200         }
 201
 202         /* vintcore has a different layout */
 203         value &= info->voltage_mask;
 204         if (info->desc.id == AB8500_LDO_INTCORE)
 205                 ret = info->voltages[value >> 0x3];
 206         else
 207                 ret = info->voltages[value];
 208
 209         return ret;
 210 }
 211
 212 static int ab8500_get_best_voltage_index(struct regulator_dev *rdev,
 213                 int min_uV, int max_uV)
 214 {
 215         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 216         int i;
 217
 218         /* check the supported voltage */
 219         for (i = 0; i < info->voltages_len; i++) {
 220                 if ((info->voltages[i] >= min_uV) &&
 221                     (info->voltages[i] <= max_uV))
 222                         return i;
 223         }
 224
 225         return -EINVAL;
 226 }
 227
 228 static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
 229                                         int min_uV, int max_uV,
 230                                         unsigned *selector)
 231 {
 232         int ret;
 233         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 234
 235         if (info == NULL) {
 236                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 237                 return -EINVAL;
 238         }
 239
 240         /* get the appropriate voltages within the range */
 241         ret = ab8500_get_best_voltage_index(rdev, min_uV, max_uV);
 242         if (ret < 0) {
 243                 dev_err(rdev_get_dev(rdev),
 244                                 "couldn't get best voltage for regulator\n");
 245                 return ret;
 246         }
 247
 248         *selector = ret;
 249
 250         /* set the registers for the request */
 251         ret = abx500_mask_and_set_register_interruptible(info->dev,
 252                 info->voltage_bank, info->voltage_reg,
 253                 info->voltage_mask, (u8)ret);
 254         if (ret < 0)
 255                 dev_err(rdev_get_dev(rdev),
 256                 "couldn't set voltage reg for regulator\n");
 257
 258         return ret;
 259 }
 260
 261 static struct regulator_ops ab8500_regulator_ops = {
 262         .enable         = ab8500_regulator_enable,
 263         .disable        = ab8500_regulator_disable,
 264         .is_enabled     = ab8500_regulator_is_enabled,
 265         .get_voltage    = ab8500_regulator_get_voltage,
 266         .set_voltage    = ab8500_regulator_set_voltage,
 267         .list_voltage   = ab8500_list_voltage,
 268 };
 269
 270 static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
 271 {
 272         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 273
 274         if (info == NULL) {
 275                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 276                 return -EINVAL;
 277         }
 278
 279         return info->fixed_uV;
 280 }
 281
 282 static struct regulator_ops ab8500_ldo_fixed_ops = {
 283         .enable         = ab8500_regulator_enable,
 284         .disable        = ab8500_regulator_disable,
 285         .is_enabled     = ab8500_regulator_is_enabled,
 286         .get_voltage    = ab8500_fixed_get_voltage,
 287         .list_voltage   = ab8500_list_voltage,
 288 };
 289
 290 #define AB8500_LDO(_id, _min_mV, _max_mV,                       \
 291         _u_bank, _u_reg, _u_mask, _u_val_enable,                \
 292         _v_bank, _v_reg, _v_mask, _v_table, _v_table_len)       \
 293 [AB8500_LDO_##_id] = {                                          \
 294         .desc   = {                                             \
 295                 .name           = "LDO-" #_id,                  \
 296                 .ops            = &ab8500_regulator_ops,        \
 297                 .type           = REGULATOR_VOLTAGE,            \
 298                 .id             = AB8500_LDO_##_id,             \
 299                 .owner          = THIS_MODULE,                  \
 300         },                                                      \
 301         .min_uV                 = (_min_mV) * 1000,             \
 302         .max_uV                 = (_max_mV) * 1000,             \
 303         .update_bank            = _u_bank,                      \
 304         .update_reg             = _u_reg,                       \
 305         .update_mask            = _u_mask,                      \
 306         .update_val_enable      = _u_val_enable,                \
 307         .voltage_bank           = _v_bank,                      \
 308         .voltage_reg            = _v_reg,                       \
 309         .voltage_mask           = _v_mask,                      \
 310         .voltages               = _v_table,                     \
 311         .voltages_len           = _v_table_len,                 \
 312         .fixed_uV               = 0,                            \
 313 }
 314
 315 #define AB8500_FIXED_LDO(_id, _fixed_mV,                        \
 316         _u_bank, _u_reg, _u_mask, _u_val_enable)                \
 317 [AB8500_LDO_##_id] = {                                          \
 318         .desc   = {                                             \
 319                 .name           = "LDO-" #_id,                  \
 320                 .ops            = &ab8500_ldo_fixed_ops,        \
 321                 .type           = REGULATOR_VOLTAGE,            \
 322                 .id             = AB8500_LDO_##_id,             \
 323                 .owner          = THIS_MODULE,                  \
 324         },                                                      \
 325         .fixed_uV               = (_fixed_mV) * 1000,           \
 326         .update_bank            = _u_bank,                      \
 327         .update_reg             = _u_reg,                       \
 328         .update_mask            = _u_mask,                      \
 329         .update_val_enable      = _u_val_enable,                \
 330 }
 331
 332 static struct ab8500_regulator_info ab8500_regulator_info[] = {
 333         /*
 334          * Variable Voltage Regulators
 335          *   name, min mV, max mV,
 336          *   update bank, reg, mask, enable val
 337          *   volt bank, reg, mask, table, table length
 338          */
 339         AB8500_LDO(AUX1, 1100, 3300,
 340                 0x04, 0x09, 0x03, 0x01, 0x04, 0x1f, 0x0f,
 341                 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
 342         AB8500_LDO(AUX2, 1100, 3300,
 343                 0x04, 0x09, 0x0c, 0x04, 0x04, 0x20, 0x0f,
 344                 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
 345         AB8500_LDO(AUX3, 1100, 3300,
 346                 0x04, 0x0a, 0x03, 0x01, 0x04, 0x21, 0x07,
 347                 ldo_vaux3_voltages, ARRAY_SIZE(ldo_vaux3_voltages)),
 348         AB8500_LDO(INTCORE, 1100, 3300,
 349                 0x03, 0x80, 0x44, 0x04, 0x03, 0x80, 0x38,
 350                 ldo_vintcore_voltages, ARRAY_SIZE(ldo_vintcore_voltages)),
 351
 352         /*
 353          * Fixed Voltage Regulators
 354          *   name, fixed mV,
 355          *   update bank, reg, mask, enable val
 356          */
 357         AB8500_FIXED_LDO(TVOUT,   2000, 0x03, 0x80, 0x82, 0x02),
 358         AB8500_FIXED_LDO(AUDIO,   2000, 0x03, 0x83, 0x02, 0x02),
 359         AB8500_FIXED_LDO(ANAMIC1, 2050, 0x03, 0x83, 0x08, 0x08),
 360         AB8500_FIXED_LDO(ANAMIC2, 2050, 0x03, 0x83, 0x10, 0x10),
 361         AB8500_FIXED_LDO(DMIC,    1800, 0x03, 0x83, 0x04, 0x04),
 362         AB8500_FIXED_LDO(ANA,     1200, 0x04, 0x06, 0x0c, 0x04),
 363 };
 364
 365 static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
 366 {
 367         struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
 368         struct ab8500_platform_data *pdata;
 369         int i, err;
 370
 371         if (!ab8500) {
 372                 dev_err(&pdev->dev, "null mfd parent\n");
 373                 return -EINVAL;
 374         }
 375         pdata = dev_get_platdata(ab8500->dev);
 376         if (!pdata) {
 377                 dev_err(&pdev->dev, "null pdata\n");
 378                 return -EINVAL;
 379         }
 380
 381         /* make sure the platform data has the correct size */
 382         if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
 383                 dev_err(&pdev->dev, "platform configuration error\n");
 384                 return -EINVAL;
 385         }
 386
 387         /* register all regulators */
 388         for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
 389                 struct ab8500_regulator_info *info = NULL;
 390
 391                 /* assign per-regulator data */
 392                 info = &ab8500_regulator_info[i];
 393                 info->dev = &pdev->dev;
 394
 395                 /* fix for hardware before ab8500v2.0 */
 396                 if (abx500_get_chip_id(info->dev) < 0x20) {
 397                         if (info->desc.id == AB8500_LDO_AUX3) {
 398                                 info->desc.n_voltages =
 399                                         ARRAY_SIZE(ldo_vauxn_voltages);
 400                                 info->voltages = ldo_vauxn_voltages;
 401                                 info->voltages_len =
 402                                         ARRAY_SIZE(ldo_vauxn_voltages);
 403                                 info->voltage_mask = 0xf;
 404                         }
 405                 }
 406
 407                 /* register regulator with framework */
 408                 info->regulator = regulator_register(&info->desc, &pdev->dev,
 409                                 &pdata->regulator[i], info);
 410                 if (IS_ERR(info->regulator)) {
 411                         err = PTR_ERR(info->regulator);
 412                         dev_err(&pdev->dev, "failed to register regulator %s\n",
 413                                         info->desc.name);
 414                         /* when we fail, un-register all earlier regulators */
 415                         while (--i >= 0) {
 416                                 info = &ab8500_regulator_info[i];
 417                                 regulator_unregister(info->regulator);
 418                         }
 419                         return err;
 420                 }
 421         }
 422
 423         return 0;
 424 }
 425
 426 static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
 427 {
 428         int i;
 429
 430         for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
 431                 struct ab8500_regulator_info *info = NULL;
 432                 info = &ab8500_regulator_info[i];
 433                 regulator_unregister(info->regulator);
 434         }
 435
 436         return 0;
 437 }
 438
 439 static struct platform_driver ab8500_regulator_driver = {
 440         .probe = ab8500_regulator_probe,
 441         .remove = __devexit_p(ab8500_regulator_remove),
 442         .driver         = {
 443                 .name   = "ab8500-regulator",
 444                 .owner  = THIS_MODULE,
 445         },
 446 };
 447
 448 static int __init ab8500_regulator_init(void)
 449 {
 450         int ret;
 451
 452         ret = platform_driver_register(&ab8500_regulator_driver);
 453         if (ret != 0)
 454                 pr_err("Failed to register ab8500 regulator: %d\n", ret);
 455
 456         return ret;
 457 }
 458 subsys_initcall(ab8500_regulator_init);
 459
 460 static void __exit ab8500_regulator_exit(void)
 461 {
 462         platform_driver_unregister(&ab8500_regulator_driver);
 463 }
 464 module_exit(ab8500_regulator_exit);
 465
 466 MODULE_LICENSE("GPL v2");
 467 MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
 468 MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC");
 469 MODULE_ALIAS("platform:ab8500-regulator");