drivers/regulator/ab8500-ext.c

   1 /*
   2  * Copyright (C) ST-Ericsson SA 2010
   3  *
   4  * License Terms: GNU General Public License v2
   5  *
   6  * Authors: Bengt Jonsson <bengt.g.jonsson@stericsson.com>
   7  *
   8  * This file is based on drivers/regulator/ab8500.c
   9  *
  10  * AB8500 external regulators
  11  *
  12  * ab8500-ext supports the following regulators:
  13  * - VextSupply3
  14  */
  15 #include <linux/init.h>
  16 #include <linux/kernel.h>
  17 #include <linux/err.h>
  18 #include <linux/module.h>
  19 #include <linux/of.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/regulator/driver.h>
  22 #include <linux/regulator/machine.h>
  23 #include <linux/regulator/of_regulator.h>
  24 #include <linux/mfd/abx500.h>
  25 #include <linux/mfd/abx500/ab8500.h>
  26 #include <linux/regulator/ab8500.h>
  27
  28 /**
  29  * struct ab8500_ext_regulator_info - ab8500 regulator information
  30  * @dev: device pointer
  31  * @desc: regulator description
  32  * @rdev: regulator device
  33  * @cfg: regulator configuration (extension of regulator FW configuration)
  34  * @update_bank: bank to control on/off
  35  * @update_reg: register to control on/off
  36  * @update_mask: mask to enable/disable and set mode of regulator
  37  * @update_val: bits holding the regulator current mode
  38  * @update_val_hp: bits to set EN pin active (LPn pin deactive)
  39  *                 normally this means high power mode
  40  * @update_val_lp: bits to set EN pin active and LPn pin active
  41  *                 normally this means low power mode
  42  * @update_val_hw: bits to set regulator pins in HW control
  43  *                 SysClkReq pins and logic will choose mode
  44  */
  45 struct ab8500_ext_regulator_info {
  46         struct device *dev;
  47         struct regulator_desc desc;
  48         struct regulator_dev *rdev;
  49         struct ab8500_ext_regulator_cfg *cfg;
  50         u8 update_bank;
  51         u8 update_reg;
  52         u8 update_mask;
  53         u8 update_val;
  54         u8 update_val_hp;
  55         u8 update_val_lp;
  56         u8 update_val_hw;
  57 };
  58
  59 static int ab8500_ext_regulator_enable(struct regulator_dev *rdev)
  60 {
  61         int ret;
  62         struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
  63         u8 regval;
  64
  65         if (info == NULL) {
  66                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
  67                 return -EINVAL;
  68         }
  69
  70         /*
  71          * To satisfy both HW high power request and SW request, the regulator
  72          * must be on in high power.
  73          */
  74         if (info->cfg && info->cfg->hwreq)
  75                 regval = info->update_val_hp;
  76         else
  77                 regval = info->update_val;
  78
  79         ret = abx500_mask_and_set_register_interruptible(info->dev,
  80                 info->update_bank, info->update_reg,
  81                 info->update_mask, regval);
  82         if (ret < 0) {
  83                 dev_err(rdev_get_dev(info->rdev),
  84                         "couldn't set enable bits for regulator\n");
  85                 return ret;
  86         }
  87
  88         dev_dbg(rdev_get_dev(rdev),
  89                 "%s-enable (bank, reg, mask, value): 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
  90                 info->desc.name, info->update_bank, info->update_reg,
  91                 info->update_mask, regval);
  92
  93         return 0;
  94 }
  95
  96 static int ab8500_ext_regulator_disable(struct regulator_dev *rdev)
  97 {
  98         int ret;
  99         struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
 100         u8 regval;
 101
 102         if (info == NULL) {
 103                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 104                 return -EINVAL;
 105         }
 106
 107         /*
 108          * Set the regulator in HW request mode if configured
 109          */
 110         if (info->cfg && info->cfg->hwreq)
 111                 regval = info->update_val_hw;
 112         else
 113                 regval = 0;
 114
 115         ret = abx500_mask_and_set_register_interruptible(info->dev,
 116                 info->update_bank, info->update_reg,
 117                 info->update_mask, regval);
 118         if (ret < 0) {
 119                 dev_err(rdev_get_dev(info->rdev),
 120                         "couldn't set disable bits for regulator\n");
 121                 return ret;
 122         }
 123
 124         dev_dbg(rdev_get_dev(rdev), "%s-disable (bank, reg, mask, value):"
 125                 " 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
 126                 info->desc.name, info->update_bank, info->update_reg,
 127                 info->update_mask, regval);
 128
 129         return 0;
 130 }
 131
 132 static int ab8500_ext_regulator_is_enabled(struct regulator_dev *rdev)
 133 {
 134         int ret;
 135         struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
 136         u8 regval;
 137
 138         if (info == NULL) {
 139                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 140                 return -EINVAL;
 141         }
 142
 143         ret = abx500_get_register_interruptible(info->dev,
 144                 info->update_bank, info->update_reg, &regval);
 145         if (ret < 0) {
 146                 dev_err(rdev_get_dev(rdev),
 147                         "couldn't read 0x%x register\n", info->update_reg);
 148                 return ret;
 149         }
 150
 151         dev_dbg(rdev_get_dev(rdev), "%s-is_enabled (bank, reg, mask, value):"
 152                 " 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
 153                 info->desc.name, info->update_bank, info->update_reg,
 154                 info->update_mask, regval);
 155
 156         if (((regval & info->update_mask) == info->update_val_lp) ||
 157             ((regval & info->update_mask) == info->update_val_hp))
 158                 return 1;
 159         else
 160                 return 0;
 161 }
 162
 163 static int ab8500_ext_regulator_set_mode(struct regulator_dev *rdev,
 164                                          unsigned int mode)
 165 {
 166         int ret = 0;
 167         struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
 168         u8 regval;
 169
 170         if (info == NULL) {
 171                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 172                 return -EINVAL;
 173         }
 174
 175         switch (mode) {
 176         case REGULATOR_MODE_NORMAL:
 177                 regval = info->update_val_hp;
 178                 break;
 179         case REGULATOR_MODE_IDLE:
 180                 regval = info->update_val_lp;
 181                 break;
 182
 183         default:
 184                 return -EINVAL;
 185         }
 186
 187         /* If regulator is enabled and info->cfg->hwreq is set, the regulator
 188            must be on in high power, so we don't need to write the register with
 189            the same value.
 190          */
 191         if (ab8500_ext_regulator_is_enabled(rdev) &&
 192             !(info->cfg && info->cfg->hwreq)) {
 193                 ret = abx500_mask_and_set_register_interruptible(info->dev,
 194                                         info->update_bank, info->update_reg,
 195                                         info->update_mask, regval);
 196                 if (ret < 0) {
 197                         dev_err(rdev_get_dev(rdev),
 198                                 "Could not set regulator mode.\n");
 199                         return ret;
 200                 }
 201
 202                 dev_dbg(rdev_get_dev(rdev),
 203                         "%s-set_mode (bank, reg, mask, value): "
 204                         "0x%x, 0x%x, 0x%x, 0x%x\n",
 205                         info->desc.name, info->update_bank, info->update_reg,
 206                         info->update_mask, regval);
 207         }
 208
 209         info->update_val = regval;
 210
 211         return 0;
 212 }
 213
 214 static unsigned int ab8500_ext_regulator_get_mode(struct regulator_dev *rdev)
 215 {
 216         struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
 217         int ret;
 218
 219         if (info == NULL) {
 220                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 221                 return -EINVAL;
 222         }
 223
 224         if (info->update_val == info->update_val_hp)
 225                 ret = REGULATOR_MODE_NORMAL;
 226         else if (info->update_val == info->update_val_lp)
 227                 ret = REGULATOR_MODE_IDLE;
 228         else
 229                 ret = -EINVAL;
 230
 231         return ret;
 232 }
 233
 234 static int ab8500_ext_set_voltage(struct regulator_dev *rdev, int min_uV,
 235                                   int max_uV, unsigned *selector)
 236 {
 237         struct regulation_constraints *regu_constraints = rdev->constraints;
 238
 239         if (!regu_constraints) {
 240                 dev_err(rdev_get_dev(rdev), "No regulator constraints\n");
 241                 return -EINVAL;
 242         }
 243
 244         if (regu_constraints->min_uV == min_uV &&
 245             regu_constraints->max_uV == max_uV)
 246                 return 0;
 247
 248         dev_err(rdev_get_dev(rdev),
 249                 "Requested min %duV max %duV != constrained min %duV max %duV\n",
 250                 min_uV, max_uV,
 251                 regu_constraints->min_uV, regu_constraints->max_uV);
 252
 253         return -EINVAL;
 254 }
 255
 256 static int ab8500_ext_list_voltage(struct regulator_dev *rdev,
 257                                    unsigned selector)
 258 {
 259         struct regulation_constraints *regu_constraints = rdev->constraints;
 260
 261         if (regu_constraints == NULL) {
 262                 dev_err(rdev_get_dev(rdev), "regulator constraints null pointer\n");
 263                 return -EINVAL;
 264         }
 265         /* return the uV for the fixed regulators */
 266         if (regu_constraints->min_uV && regu_constraints->max_uV) {
 267                 if (regu_constraints->min_uV == regu_constraints->max_uV)
 268                         return regu_constraints->min_uV;
 269         }
 270         return -EINVAL;
 271 }
 272
 273 static struct regulator_ops ab8500_ext_regulator_ops = {
 274         .enable                 = ab8500_ext_regulator_enable,
 275         .disable                = ab8500_ext_regulator_disable,
 276         .is_enabled             = ab8500_ext_regulator_is_enabled,
 277         .set_mode               = ab8500_ext_regulator_set_mode,
 278         .get_mode               = ab8500_ext_regulator_get_mode,
 279         .set_voltage            = ab8500_ext_set_voltage,
 280         .list_voltage           = ab8500_ext_list_voltage,
 281 };
 282
 283 static struct ab8500_ext_regulator_info
 284                 ab8500_ext_regulator_info[AB8500_NUM_EXT_REGULATORS] = {
 285         [AB8500_EXT_SUPPLY1] = {
 286                 .desc = {
 287                         .name           = "VEXTSUPPLY1",
 288                         .ops            = &ab8500_ext_regulator_ops,
 289                         .type           = REGULATOR_VOLTAGE,
 290                         .id             = AB8500_EXT_SUPPLY1,
 291                         .owner          = THIS_MODULE,
 292                         .n_voltages     = 1,
 293                 },
 294                 .update_bank            = 0x04,
 295                 .update_reg             = 0x08,
 296                 .update_mask            = 0x03,
 297                 .update_val             = 0x01,
 298                 .update_val_hp          = 0x01,
 299                 .update_val_lp          = 0x03,
 300                 .update_val_hw          = 0x02,
 301         },
 302         [AB8500_EXT_SUPPLY2] = {
 303                 .desc = {
 304                         .name           = "VEXTSUPPLY2",
 305                         .ops            = &ab8500_ext_regulator_ops,
 306                         .type           = REGULATOR_VOLTAGE,
 307                         .id             = AB8500_EXT_SUPPLY2,
 308                         .owner          = THIS_MODULE,
 309                         .n_voltages     = 1,
 310                 },
 311                 .update_bank            = 0x04,
 312                 .update_reg             = 0x08,
 313                 .update_mask            = 0x0c,
 314                 .update_val             = 0x04,
 315                 .update_val_hp          = 0x04,
 316                 .update_val_lp          = 0x0c,
 317                 .update_val_hw          = 0x08,
 318         },
 319         [AB8500_EXT_SUPPLY3] = {
 320                 .desc = {
 321                         .name           = "VEXTSUPPLY3",
 322                         .ops            = &ab8500_ext_regulator_ops,
 323                         .type           = REGULATOR_VOLTAGE,
 324                         .id             = AB8500_EXT_SUPPLY3,
 325                         .owner          = THIS_MODULE,
 326                         .n_voltages     = 1,
 327                 },
 328                 .update_bank            = 0x04,
 329                 .update_reg             = 0x08,
 330                 .update_mask            = 0x30,
 331                 .update_val             = 0x10,
 332                 .update_val_hp          = 0x10,
 333                 .update_val_lp          = 0x30,
 334                 .update_val_hw          = 0x20,
 335         },
 336 };
 337
 338 static struct of_regulator_match ab8500_ext_regulator_match[] = {
 339         { .name = "ab8500_ext1", .driver_data = (void *) AB8500_EXT_SUPPLY1, },
 340         { .name = "ab8500_ext2", .driver_data = (void *) AB8500_EXT_SUPPLY2, },
 341         { .name = "ab8500_ext3", .driver_data = (void *) AB8500_EXT_SUPPLY3, },
 342 };
 343
 344 static int ab8500_ext_regulator_probe(struct platform_device *pdev)
 345 {
 346         struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
 347         struct ab8500_platform_data *ppdata;
 348         struct ab8500_regulator_platform_data *pdata;
 349         struct device_node *np = pdev->dev.of_node;
 350         struct regulator_config config = { };
 351         int i, err;
 352
 353         if (np) {
 354                 err = of_regulator_match(&pdev->dev, np,
 355                                          ab8500_ext_regulator_match,
 356                                          ARRAY_SIZE(ab8500_ext_regulator_match));
 357                 if (err < 0) {
 358                         dev_err(&pdev->dev,
 359                                 "Error parsing regulator init data: %d\n", err);
 360                         return err;
 361                 }
 362         }
 363
 364         if (!ab8500) {
 365                 dev_err(&pdev->dev, "null mfd parent\n");
 366                 return -EINVAL;
 367         }
 368
 369         ppdata = dev_get_platdata(ab8500->dev);
 370         if (!ppdata) {
 371                 dev_err(&pdev->dev, "null parent pdata\n");
 372                 return -EINVAL;
 373         }
 374
 375         pdata = ppdata->regulator;
 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_ext_regulator != ARRAY_SIZE(ab8500_ext_regulator_info)) {
 383                 dev_err(&pdev->dev, "Configuration error: size mismatch.\n");
 384                 return -EINVAL;
 385         }
 386
 387         /* check for AB8500 2.x */
 388         if (is_ab8500_2p0_or_earlier(ab8500)) {
 389                 struct ab8500_ext_regulator_info *info;
 390
 391                 /* VextSupply3LPn is inverted on AB8500 2.x */
 392                 info = &ab8500_ext_regulator_info[AB8500_EXT_SUPPLY3];
 393                 info->update_val = 0x30;
 394                 info->update_val_hp = 0x30;
 395                 info->update_val_lp = 0x10;
 396         }
 397
 398         /* register all regulators */
 399         for (i = 0; i < ARRAY_SIZE(ab8500_ext_regulator_info); i++) {
 400                 struct ab8500_ext_regulator_info *info = NULL;
 401
 402                 /* assign per-regulator data */
 403                 info = &ab8500_ext_regulator_info[i];
 404                 info->dev = &pdev->dev;
 405                 info->cfg = (struct ab8500_ext_regulator_cfg *)
 406                         pdata->ext_regulator[i].driver_data;
 407
 408                 config.dev = &pdev->dev;
 409                 config.driver_data = info;
 410                 config.of_node = ab8500_ext_regulator_match[i].of_node;
 411                 config.init_data = (np) ?
 412                         ab8500_ext_regulator_match[i].init_data :
 413                         &pdata->ext_regulator[i];
 414
 415                 /* register regulator with framework */
 416                 info->rdev = regulator_register(&info->desc, &config);
 417                 if (IS_ERR(info->rdev)) {
 418                         err = PTR_ERR(info->rdev);
 419                         dev_err(&pdev->dev, "failed to register regulator %s\n",
 420                                         info->desc.name);
 421                         /* when we fail, un-register all earlier regulators */
 422                         while (--i >= 0) {
 423                                 info = &ab8500_ext_regulator_info[i];
 424                                 regulator_unregister(info->rdev);
 425                         }
 426                         return err;
 427                 }
 428
 429                 dev_dbg(rdev_get_dev(info->rdev),
 430                         "%s-probed\n", info->desc.name);
 431         }
 432
 433         return 0;
 434 }
 435
 436 static int ab8500_ext_regulator_remove(struct platform_device *pdev)
 437 {
 438         int i;
 439
 440         for (i = 0; i < ARRAY_SIZE(ab8500_ext_regulator_info); i++) {
 441                 struct ab8500_ext_regulator_info *info = NULL;
 442                 info = &ab8500_ext_regulator_info[i];
 443
 444                 dev_vdbg(rdev_get_dev(info->rdev),
 445                         "%s-remove\n", info->desc.name);
 446
 447                 regulator_unregister(info->rdev);
 448         }
 449
 450         return 0;
 451 }
 452
 453 static struct platform_driver ab8500_ext_regulator_driver = {
 454         .probe = ab8500_ext_regulator_probe,
 455         .remove = ab8500_ext_regulator_remove,
 456         .driver         = {
 457                 .name   = "ab8500-ext-regulator",
 458                 .owner  = THIS_MODULE,
 459         },
 460 };
 461
 462 static int __init ab8500_ext_regulator_init(void)
 463 {
 464         int ret;
 465
 466         ret = platform_driver_register(&ab8500_ext_regulator_driver);
 467         if (ret)
 468                 pr_err("Failed to register ab8500 ext regulator: %d\n", ret);
 469
 470         return ret;
 471 }
 472 subsys_initcall(ab8500_ext_regulator_init);
 473
 474 static void __exit ab8500_ext_regulator_exit(void)
 475 {
 476         platform_driver_unregister(&ab8500_ext_regulator_driver);
 477 }
 478 module_exit(ab8500_ext_regulator_exit);
 479
 480 MODULE_LICENSE("GPL v2");
 481 MODULE_AUTHOR("Bengt Jonsson <bengt.g.jonsson@stericsson.com>");
 482 MODULE_DESCRIPTION("AB8500 external regulator driver");
 483 MODULE_ALIAS("platform:ab8500-ext-regulator");