drivers/regulator/rk818-regulator.c

   1 /*
   2  * Regulator driver for Rockchip RK818
   3  *
   4  * Copyright (c) 2016, Fuzhou Rockchip Electronics Co., Ltd
   5  *
   6  * Author: xsf <xsf@rock-chips.com>
   7  * Author: Zhang Qing <zhangqing@rock-chips.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms and conditions of the GNU General Public License,
  11  * version 2, as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16  * more details.
  17  */
  18
  19 #include <linux/delay.h>
  20 #include <linux/gpio.h>
  21 #include <linux/i2c.h>
  22 #include <linux/module.h>
  23 #include <linux/of_device.h>
  24 #include <linux/of_gpio.h>
  25 #include <linux/mfd/rk808.h>
  26 #include <linux/regulator/driver.h>
  27 #include <linux/regulator/of_regulator.h>
  28 #include <linux/gpio/consumer.h>
  29
  30 /* Field Definitions */
  31 #define RK818_BUCK_VSEL_MASK    0x3f
  32 #define RK818_BUCK4_VSEL_MASK   0x1f
  33 #define RK818_LDO_VSEL_MASK     0x1f
  34 #define RK818_LDO3_VSEL_MASK    0x0f
  35
  36 /* Ramp rate definitions for buck1 / buck2 only */
  37 #define RK818_RAMP_RATE_OFFSET          3
  38 #define RK818_RAMP_RATE_MASK            (3 << RK818_RAMP_RATE_OFFSET)
  39 #define RK818_RAMP_RATE_2MV_PER_US      (0 << RK818_RAMP_RATE_OFFSET)
  40 #define RK818_RAMP_RATE_4MV_PER_US      (1 << RK818_RAMP_RATE_OFFSET)
  41 #define RK818_RAMP_RATE_6MV_PER_US      (2 << RK818_RAMP_RATE_OFFSET)
  42 #define RK818_RAMP_RATE_10MV_PER_US     (3 << RK818_RAMP_RATE_OFFSET)
  43
  44 /* Offset from XXX_ON_VSEL to XXX_SLP_VSEL */
  45 #define RK818_SLP_REG_OFFSET 1
  46
  47 /* Offset from XXX_EN_REG to SLEEP_SET_OFF_XXX */
  48 #define RK818_SLP_SET_OFF_REG_OFFSET 2
  49
  50 /* max steps for increase voltage of Buck1/2, equal 100mv*/
  51 #define MAX_STEPS_ONE_TIME 8
  52
  53 static const int rk818_buck_config_regs[] = {
  54         RK818_BUCK1_CONFIG_REG,
  55         RK818_BUCK2_CONFIG_REG,
  56         RK818_BUCK3_CONFIG_REG,
  57         RK818_BUCK4_CONFIG_REG,
  58 };
  59
  60 static const struct regulator_linear_range rk818_buck_voltage_ranges[] = {
  61         REGULATOR_LINEAR_RANGE(712500, 0, 63, 12500),
  62 };
  63
  64 static const struct regulator_linear_range rk818_buck4_voltage_ranges[] = {
  65         REGULATOR_LINEAR_RANGE(1800000, 0, 15, 100000),
  66 };
  67
  68 static const struct regulator_linear_range rk818_ldo_voltage_ranges[] = {
  69         REGULATOR_LINEAR_RANGE(1800000, 0, 16, 100000),
  70 };
  71
  72 static const struct regulator_linear_range rk818_ldo3_voltage_ranges[] = {
  73         REGULATOR_LINEAR_RANGE(800000, 0, 13, 100000),
  74         REGULATOR_LINEAR_RANGE(2500000, 15, 15, 0),
  75 };
  76
  77 static const struct regulator_linear_range rk818_ldo6_voltage_ranges[] = {
  78         REGULATOR_LINEAR_RANGE(800000, 0, 17, 100000),
  79 };
  80
  81 static int rk818_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
  82 {
  83         unsigned int ramp_value = RK818_RAMP_RATE_10MV_PER_US;
  84         unsigned int reg = rk818_buck_config_regs[rdev->desc->id -
  85                                                   RK818_ID_DCDC1];
  86
  87         switch (ramp_delay) {
  88         case 1 ... 2000:
  89                 ramp_value = RK818_RAMP_RATE_2MV_PER_US;
  90                 break;
  91         case 2001 ... 4000:
  92                 ramp_value = RK818_RAMP_RATE_4MV_PER_US;
  93                 break;
  94         case 4001 ... 6000:
  95                 ramp_value = RK818_RAMP_RATE_6MV_PER_US;
  96                 break;
  97         case 6001 ... 10000:
  98                 break;
  99         default:
 100                 pr_warn("%s ramp_delay: %d not supported, setting 10000\n",
 101                         rdev->desc->name, ramp_delay);
 102         }
 103
 104         return regmap_update_bits(rdev->regmap, reg,
 105                                   RK818_RAMP_RATE_MASK, ramp_value);
 106 }
 107
 108 static int rk818_set_suspend_voltage(struct regulator_dev *rdev, int uv)
 109 {
 110         unsigned int reg;
 111         int sel = regulator_map_voltage_linear_range(rdev, uv, uv);
 112
 113         if (sel < 0)
 114                 return -EINVAL;
 115
 116         reg = rdev->desc->vsel_reg + RK818_SLP_REG_OFFSET;
 117
 118         return regmap_update_bits(rdev->regmap, reg,
 119                                   rdev->desc->vsel_mask,
 120                                   sel);
 121 }
 122
 123 static int rk818_set_suspend_enable(struct regulator_dev *rdev)
 124 {
 125         unsigned int reg;
 126
 127         reg = rdev->desc->enable_reg + RK818_SLP_SET_OFF_REG_OFFSET;
 128
 129         return regmap_update_bits(rdev->regmap, reg,
 130                                   rdev->desc->enable_mask,
 131                                   0);
 132 }
 133
 134 static int rk818_set_suspend_disable(struct regulator_dev *rdev)
 135 {
 136         unsigned int reg;
 137
 138         reg = rdev->desc->enable_reg + RK818_SLP_SET_OFF_REG_OFFSET;
 139
 140         return regmap_update_bits(rdev->regmap, reg,
 141                                   rdev->desc->enable_mask,
 142                                   rdev->desc->enable_mask);
 143 }
 144
 145 static struct regulator_ops rk818_buck1_2_ops = {
 146         .list_voltage           = regulator_list_voltage_linear_range,
 147         .map_voltage            = regulator_map_voltage_linear_range,
 148         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 149         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 150         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 151         .enable                 = regulator_enable_regmap,
 152         .disable                = regulator_disable_regmap,
 153         .is_enabled             = regulator_is_enabled_regmap,
 154         .set_ramp_delay         = rk818_set_ramp_delay,
 155         .set_suspend_voltage    = rk818_set_suspend_voltage,
 156         .set_suspend_enable     = rk818_set_suspend_enable,
 157         .set_suspend_disable    = rk818_set_suspend_disable,
 158 };
 159
 160 static struct regulator_ops rk818_reg_ops = {
 161         .list_voltage           = regulator_list_voltage_linear_range,
 162         .map_voltage            = regulator_map_voltage_linear_range,
 163         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 164         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 165         .enable                 = regulator_enable_regmap,
 166         .disable                = regulator_disable_regmap,
 167         .is_enabled             = regulator_is_enabled_regmap,
 168         .set_suspend_voltage    = rk818_set_suspend_voltage,
 169         .set_suspend_enable     = rk818_set_suspend_enable,
 170         .set_suspend_disable    = rk818_set_suspend_disable,
 171 };
 172
 173 static struct regulator_ops rk818_switch_ops = {
 174         .enable                 = regulator_enable_regmap,
 175         .disable                = regulator_disable_regmap,
 176         .is_enabled             = regulator_is_enabled_regmap,
 177         .set_suspend_enable     = rk818_set_suspend_enable,
 178         .set_suspend_disable    = rk818_set_suspend_disable,
 179 };
 180
 181 static const struct regulator_desc rk818_reg[] = {
 182         {
 183                 .name = "DCDC_REG1",
 184                 .supply_name = "vcc1",
 185                 .id = RK818_ID_DCDC1,
 186                 .ops = &rk818_buck1_2_ops,
 187                 .type = REGULATOR_VOLTAGE,
 188                 .n_voltages = 64,
 189                 .linear_ranges = rk818_buck_voltage_ranges,
 190                 .n_linear_ranges = ARRAY_SIZE(rk818_buck_voltage_ranges),
 191                 .vsel_reg = RK818_BUCK1_ON_VSEL_REG,
 192                 .vsel_mask = RK818_BUCK_VSEL_MASK,
 193                 .enable_reg = RK818_DCDC_EN_REG,
 194                 .enable_mask = BIT(0),
 195                 .owner = THIS_MODULE,
 196         }, {
 197                 .name = "DCDC_REG2",
 198                 .supply_name = "vcc2",
 199                 .id = RK818_ID_DCDC2,
 200                 .ops = &rk818_buck1_2_ops,
 201                 .type = REGULATOR_VOLTAGE,
 202                 .n_voltages = 64,
 203                 .linear_ranges = rk818_buck_voltage_ranges,
 204                 .n_linear_ranges = ARRAY_SIZE(rk818_buck_voltage_ranges),
 205                 .vsel_reg = RK818_BUCK2_ON_VSEL_REG,
 206                 .vsel_mask = RK818_BUCK_VSEL_MASK,
 207                 .enable_reg = RK818_DCDC_EN_REG,
 208                 .enable_mask = BIT(1),
 209                 .owner = THIS_MODULE,
 210         }, {
 211                 .name = "DCDC_REG3",
 212                 .supply_name = "vcc3",
 213                 .id = RK818_ID_DCDC3,
 214                 .ops = &rk818_switch_ops,
 215                 .type = REGULATOR_VOLTAGE,
 216                 .n_voltages = 1,
 217                 .enable_reg = RK818_DCDC_EN_REG,
 218                 .enable_mask = BIT(2),
 219                 .owner = THIS_MODULE,
 220         }, {
 221                 .name = "DCDC_REG4",
 222                 .supply_name = "vcc4",
 223                 .id = RK818_ID_DCDC4,
 224                 .ops = &rk818_reg_ops,
 225                 .type = REGULATOR_VOLTAGE,
 226                 .n_voltages = 16,
 227                 .linear_ranges = rk818_buck4_voltage_ranges,
 228                 .n_linear_ranges = ARRAY_SIZE(rk818_buck4_voltage_ranges),
 229                 .vsel_reg = RK818_BUCK4_ON_VSEL_REG,
 230                 .vsel_mask = RK818_BUCK4_VSEL_MASK,
 231                 .enable_reg = RK818_DCDC_EN_REG,
 232                 .enable_mask = BIT(3),
 233                 .owner = THIS_MODULE,
 234         }, {
 235                 .name = "LDO_REG1",
 236                 .supply_name = "vcc6",
 237                 .id = RK818_ID_LDO1,
 238                 .ops = &rk818_reg_ops,
 239                 .type = REGULATOR_VOLTAGE,
 240                 .n_voltages = 17,
 241                 .linear_ranges = rk818_ldo_voltage_ranges,
 242                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 243                 .vsel_reg = RK818_LDO1_ON_VSEL_REG,
 244                 .vsel_mask = RK818_LDO_VSEL_MASK,
 245                 .enable_reg = RK818_LDO_EN_REG,
 246                 .enable_mask = BIT(0),
 247                 .enable_time = 400,
 248                 .owner = THIS_MODULE,
 249         }, {
 250                 .name = "LDO_REG2",
 251                 .supply_name = "vcc6",
 252                 .id = RK818_ID_LDO2,
 253                 .ops = &rk818_reg_ops,
 254                 .type = REGULATOR_VOLTAGE,
 255                 .n_voltages = 17,
 256                 .linear_ranges = rk818_ldo_voltage_ranges,
 257                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 258                 .vsel_reg = RK818_LDO2_ON_VSEL_REG,
 259                 .vsel_mask = RK818_LDO_VSEL_MASK,
 260                 .enable_reg = RK818_LDO_EN_REG,
 261                 .enable_mask = BIT(1),
 262                 .enable_time = 400,
 263                 .owner = THIS_MODULE,
 264         }, {
 265                 .name = "LDO_REG3",
 266                 .supply_name = "vcc7",
 267                 .id = RK818_ID_LDO3,
 268                 .ops = &rk818_reg_ops,
 269                 .type = REGULATOR_VOLTAGE,
 270                 .n_voltages = 16,
 271                 .linear_ranges = rk818_ldo3_voltage_ranges,
 272                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo3_voltage_ranges),
 273                 .vsel_reg = RK818_LDO3_ON_VSEL_REG,
 274                 .vsel_mask = RK818_LDO3_VSEL_MASK,
 275                 .enable_reg = RK818_LDO_EN_REG,
 276                 .enable_mask = BIT(2),
 277                 .enable_time = 400,
 278                 .owner = THIS_MODULE,
 279         }, {
 280                 .name = "LDO_REG4",
 281                 .supply_name = "vcc8",
 282                 .id = RK818_ID_LDO4,
 283                 .ops = &rk818_reg_ops,
 284                 .type = REGULATOR_VOLTAGE,
 285                 .n_voltages = 17,
 286                 .linear_ranges = rk818_ldo_voltage_ranges,
 287                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 288                 .vsel_reg = RK818_LDO4_ON_VSEL_REG,
 289                 .vsel_mask = RK818_LDO_VSEL_MASK,
 290                 .enable_reg = RK818_LDO_EN_REG,
 291                 .enable_mask = BIT(3),
 292                 .enable_time = 400,
 293                 .owner = THIS_MODULE,
 294         }, {
 295                 .name = "LDO_REG5",
 296                 .supply_name = "vcc7",
 297                 .id = RK818_ID_LDO5,
 298                 .ops = &rk818_reg_ops,
 299                 .type = REGULATOR_VOLTAGE,
 300                 .n_voltages = 17,
 301                 .linear_ranges = rk818_ldo_voltage_ranges,
 302                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 303                 .vsel_reg = RK818_LDO5_ON_VSEL_REG,
 304                 .vsel_mask = RK818_LDO_VSEL_MASK,
 305                 .enable_reg = RK818_LDO_EN_REG,
 306                 .enable_mask = BIT(4),
 307                 .enable_time = 400,
 308                 .owner = THIS_MODULE,
 309         }, {
 310                 .name = "LDO_REG6",
 311                 .supply_name = "vcc8",
 312                 .id = RK818_ID_LDO6,
 313                 .ops = &rk818_reg_ops,
 314                 .type = REGULATOR_VOLTAGE,
 315                 .n_voltages = 18,
 316                 .linear_ranges = rk818_ldo6_voltage_ranges,
 317                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo6_voltage_ranges),
 318                 .vsel_reg = RK818_LDO6_ON_VSEL_REG,
 319                 .vsel_mask = RK818_LDO_VSEL_MASK,
 320                 .enable_reg = RK818_LDO_EN_REG,
 321                 .enable_mask = BIT(5),
 322                 .enable_time = 400,
 323                 .owner = THIS_MODULE,
 324         }, {
 325                 .name = "LDO_REG7",
 326                 .supply_name = "vcc7",
 327                 .id = RK818_ID_LDO7,
 328                 .ops = &rk818_reg_ops,
 329                 .type = REGULATOR_VOLTAGE,
 330                 .n_voltages = 18,
 331                 .linear_ranges = rk818_ldo6_voltage_ranges,
 332                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo6_voltage_ranges),
 333                 .vsel_reg = RK818_LDO7_ON_VSEL_REG,
 334                 .vsel_mask = RK818_LDO_VSEL_MASK,
 335                 .enable_reg = RK818_LDO_EN_REG,
 336                 .enable_mask = BIT(6),
 337                 .enable_time = 400,
 338                 .owner = THIS_MODULE,
 339         }, {
 340                 .name = "LDO_REG8",
 341                 .supply_name = "vcc8",
 342                 .id = RK818_ID_LDO8,
 343                 .ops = &rk818_reg_ops,
 344                 .type = REGULATOR_VOLTAGE,
 345                 .n_voltages = 17,
 346                 .linear_ranges = rk818_ldo_voltage_ranges,
 347                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 348                 .vsel_reg =  RK818_LDO8_ON_VSEL_REG,
 349                 .vsel_mask = RK818_LDO_VSEL_MASK,
 350                 .enable_reg = RK818_LDO_EN_REG,
 351                 .enable_mask = BIT(7),
 352                 .enable_time = 400,
 353                 .owner = THIS_MODULE,
 354         }, {
 355                 .name = "LDO_REG9",
 356                 .supply_name = "vcc9",
 357                 .id = RK818_ID_LDO9,
 358                 .ops = &rk818_reg_ops,
 359                 .type = REGULATOR_VOLTAGE,
 360                 .n_voltages = 17,
 361                 .linear_ranges = rk818_ldo_voltage_ranges,
 362                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 363                 .vsel_reg = RK818_BOOST_LDO9_ON_VSEL_REG,
 364                 .vsel_mask = RK818_LDO_VSEL_MASK,
 365                 .enable_reg = RK818_DCDC_EN_REG,
 366                 .enable_mask = BIT(5),
 367                 .enable_time = 400,
 368                 .owner = THIS_MODULE,
 369         }, {
 370                 .name = "SWITCH_REG",
 371                 .supply_name = "vcc9",
 372                 .id = RK818_ID_SWITCH,
 373                 .ops = &rk818_switch_ops,
 374                 .type = REGULATOR_VOLTAGE,
 375                 .enable_reg = RK818_DCDC_EN_REG,
 376                 .enable_mask = BIT(6),
 377                 .owner = THIS_MODULE,
 378         },
 379 };
 380
 381 static struct of_regulator_match rk818_reg_matches[] = {
 382         [RK818_ID_DCDC1]        = { .name = "DCDC_REG1" },
 383         [RK818_ID_DCDC2]        = { .name = "DCDC_REG2" },
 384         [RK818_ID_DCDC3]        = { .name = "DCDC_REG3" },
 385         [RK818_ID_DCDC4]        = { .name = "DCDC_REG4" },
 386         [RK818_ID_LDO1]         = { .name = "LDO_REG1" },
 387         [RK818_ID_LDO2]         = { .name = "LDO_REG2" },
 388         [RK818_ID_LDO3]         = { .name = "LDO_REG3" },
 389         [RK818_ID_LDO4]         = { .name = "LDO_REG4" },
 390         [RK818_ID_LDO5]         = { .name = "LDO_REG5" },
 391         [RK818_ID_LDO6]         = { .name = "LDO_REG6" },
 392         [RK818_ID_LDO7]         = { .name = "LDO_REG7" },
 393         [RK818_ID_LDO8]         = { .name = "LDO_REG8" },
 394         [RK818_ID_LDO9]         = { .name = "LDO_REG9" },
 395         [RK818_ID_SWITCH]       = { .name = "SWITCH_REG" },
 396 };
 397
 398 static int rk818_regulator_dt_parse_pdata(struct device *dev,
 399                                           struct device *client_dev,
 400                                           struct regmap *map)
 401 {
 402         struct device_node *np;
 403         int ret;
 404
 405         np = of_get_child_by_name(client_dev->of_node, "regulators");
 406         if (!np)
 407                 return -ENXIO;
 408
 409         ret = of_regulator_match(dev, np, rk818_reg_matches,
 410                                  RK818_NUM_REGULATORS);
 411
 412         of_node_put(np);
 413         return ret;
 414 }
 415
 416 static int rk818_regulator_probe(struct platform_device *pdev)
 417 {
 418         struct rk808 *rk818 = dev_get_drvdata(pdev->dev.parent);
 419         struct i2c_client *client = rk818->i2c;
 420         struct regulator_config config = {};
 421         struct regulator_dev *rk818_rdev;
 422         int ret, i;
 423
 424         ret = rk818_regulator_dt_parse_pdata(&pdev->dev, &client->dev,
 425                                              rk818->regmap);
 426         if (ret < 0)
 427                 return ret;
 428
 429         /* Instantiate the regulators */
 430         for (i = 0; i < RK818_NUM_REGULATORS; i++) {
 431                 if (!rk818_reg_matches[i].init_data ||
 432                     !rk818_reg_matches[i].of_node)
 433                         continue;
 434
 435                 config.dev = &client->dev;
 436                 config.regmap = rk818->regmap;
 437                 config.of_node = rk818_reg_matches[i].of_node;
 438                 config.init_data = rk818_reg_matches[i].init_data;
 439
 440                 rk818_rdev = devm_regulator_register(&pdev->dev,
 441                                                      &rk818_reg[i], &config);
 442                 if (IS_ERR(rk818_rdev)) {
 443                         dev_err(&client->dev,
 444                                 "failed to register %d regulator\n", i);
 445                         return PTR_ERR(rk818_rdev);
 446                 }
 447         }
 448
 449         return 0;
 450 }
 451
 452 static struct platform_driver rk818_regulator_driver = {
 453         .probe = rk818_regulator_probe,
 454         .driver = {
 455                 .name = "rk818-regulator",
 456                 .owner = THIS_MODULE,
 457         },
 458 };
 459
 460 module_platform_driver(rk818_regulator_driver);
 461
 462 MODULE_DESCRIPTION("regulator driver for the rk818 series PMICs");
 463 MODULE_AUTHOR("xsf<xsf@rock-chips.com>");
 464 MODULE_AUTHOR("Zhang Qing<zhangqing@rock-chips.com>");
 465 MODULE_LICENSE("GPL");
 466 MODULE_ALIAS("platform:rk818-regulator");
 467