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 #define RK818_BOOST_ON_VSEL_MASK        0xe0
  36
  37 /* Ramp rate definitions for buck1 / buck2 only */
  38 #define RK818_RAMP_RATE_OFFSET          3
  39 #define RK818_RAMP_RATE_MASK            (3 << RK818_RAMP_RATE_OFFSET)
  40 #define RK818_RAMP_RATE_2MV_PER_US      (0 << RK818_RAMP_RATE_OFFSET)
  41 #define RK818_RAMP_RATE_4MV_PER_US      (1 << RK818_RAMP_RATE_OFFSET)
  42 #define RK818_RAMP_RATE_6MV_PER_US      (2 << RK818_RAMP_RATE_OFFSET)
  43 #define RK818_RAMP_RATE_10MV_PER_US     (3 << RK818_RAMP_RATE_OFFSET)
  44
  45 #define RK805_RAMP_RATE_OFFSET          3
  46 #define RK805_RAMP_RATE_MASK            (3 << RK805_RAMP_RATE_OFFSET)
  47 #define RK805_RAMP_RATE_3MV_PER_US      (0 << RK805_RAMP_RATE_OFFSET)
  48 #define RK805_RAMP_RATE_6MV_PER_US      (1 << RK805_RAMP_RATE_OFFSET)
  49 #define RK805_RAMP_RATE_12_5MV_PER_US   (2 << RK805_RAMP_RATE_OFFSET)
  50 #define RK805_RAMP_RATE_25MV_PER_US     (3 << RK805_RAMP_RATE_OFFSET)
  51
  52 /* Offset from XXX_ON_VSEL to XXX_SLP_VSEL */
  53 #define RK818_SLP_REG_OFFSET 1
  54
  55 /* Offset from XXX_EN_REG to SLEEP_SET_OFF_XXX */
  56 #define RK818_SLP_SET_OFF_REG_OFFSET 2
  57
  58 #define RK805_SLP_LDO_EN_OFFSET         -1
  59 #define RK805_SLP_DCDC_EN_OFFSET        2
  60
  61 /* max steps for increase voltage of Buck1/2, equal 100mv*/
  62 #define MAX_STEPS_ONE_TIME 8
  63
  64 static const int rk818_buck_config_regs[] = {
  65         RK818_BUCK1_CONFIG_REG,
  66         RK818_BUCK2_CONFIG_REG,
  67         RK818_BUCK3_CONFIG_REG,
  68         RK818_BUCK4_CONFIG_REG,
  69 };
  70
  71 /* rk805 */
  72 #define ENABLE_MASK(id) (BIT(id) | BIT(4 + (id)))
  73 #define DISABLE_VAL(id) (BIT(4 + (id)))
  74
  75 static const struct regulator_linear_range rk805_buck_voltage_ranges[] = {
  76         REGULATOR_LINEAR_RANGE(712500, 0, 59, 12500),   /* 0.7125v - 1.45v */
  77         REGULATOR_LINEAR_RANGE(1800000, 60, 62, 200000),/* 1.8v - 2.2v */
  78         REGULATOR_LINEAR_RANGE(2300000, 63, 63, 0),     /* 2.3v - 2.3v */
  79 };
  80
  81 static const struct regulator_linear_range rk805_buck4_voltage_ranges[] = {
  82         REGULATOR_LINEAR_RANGE(800000, 0, 26, 100000),  /* 0.8v - 3.4 */
  83         REGULATOR_LINEAR_RANGE(3500000, 27, 31, 0),     /* 3.5v */
  84 };
  85
  86 static const struct regulator_linear_range rk805_ldo_voltage_ranges[] = {
  87         REGULATOR_LINEAR_RANGE(800000, 0, 26, 100000),  /* 0.8v - 3.4 */
  88 };
  89
  90 /* rk818 */
  91 static const struct regulator_linear_range rk818_buck_voltage_ranges[] = {
  92         REGULATOR_LINEAR_RANGE(712500, 0, 63, 12500),
  93 };
  94
  95 static const struct regulator_linear_range rk818_buck4_voltage_ranges[] = {
  96         REGULATOR_LINEAR_RANGE(1800000, 0, 15, 100000),
  97 };
  98
  99 static const struct regulator_linear_range rk818_ldo_voltage_ranges[] = {
 100         REGULATOR_LINEAR_RANGE(1800000, 0, 16, 100000),
 101 };
 102
 103 static const struct regulator_linear_range rk818_ldo3_voltage_ranges[] = {
 104         REGULATOR_LINEAR_RANGE(800000, 0, 13, 100000),
 105         REGULATOR_LINEAR_RANGE(2500000, 15, 15, 0),
 106 };
 107
 108 static const struct regulator_linear_range rk818_ldo6_voltage_ranges[] = {
 109         REGULATOR_LINEAR_RANGE(800000, 0, 17, 100000),
 110 };
 111
 112 static const struct regulator_linear_range rk818_boost_voltage_ranges[] = {
 113         REGULATOR_LINEAR_RANGE(4700000, 0, 7, 100000),
 114 };
 115
 116 static int rk818_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
 117 {
 118         struct rk808 *rk818 = rdev->reg_data;
 119         unsigned int ramp_value = RK818_RAMP_RATE_10MV_PER_US;
 120         unsigned int reg = rk818_buck_config_regs[rdev->desc->id -
 121                                                   RK818_ID_DCDC1];
 122
 123         switch (rk818->variant) {
 124         case RK818_ID:
 125                 switch (ramp_delay) {
 126                 case 1 ... 2000:
 127                         ramp_value = RK818_RAMP_RATE_2MV_PER_US;
 128                         break;
 129                 case 2001 ... 4000:
 130                         ramp_value = RK818_RAMP_RATE_4MV_PER_US;
 131                         break;
 132                 case 4001 ... 6000:
 133                         ramp_value = RK818_RAMP_RATE_6MV_PER_US;
 134                         break;
 135                 case 6001 ... 10000:
 136                         break;
 137                 default:
 138                         pr_warn("%s ramp_delay: %d not supported, set 10000\n",
 139                                 rdev->desc->name, ramp_delay);
 140                 }
 141                 break;
 142         case RK805_ID:
 143                 switch (ramp_delay) {
 144                 case 3000:
 145                         ramp_value = RK805_RAMP_RATE_3MV_PER_US;
 146                         break;
 147                 case 6000:
 148                         ramp_value = RK805_RAMP_RATE_6MV_PER_US;
 149                         break;
 150                 case 12500:
 151                         ramp_value = RK805_RAMP_RATE_12_5MV_PER_US;
 152                         break;
 153                 case 25000:
 154                         ramp_value = RK805_RAMP_RATE_25MV_PER_US;
 155                         break;
 156                 default:
 157                         pr_warn("%s ramp_delay: %d not supported\n",
 158                                 rdev->desc->name, ramp_delay);
 159                 }
 160                 break;
 161         default:
 162                 dev_err(&rdev->dev, "%s: unsupported RK8XX ID %lu\n",
 163                         __func__, rk818->variant);
 164                 return -EINVAL;
 165         }
 166
 167         return regmap_update_bits(rdev->regmap, reg,
 168                                   RK818_RAMP_RATE_MASK, ramp_value);
 169 }
 170
 171 static int rk818_set_suspend_voltage(struct regulator_dev *rdev, int uv)
 172 {
 173         unsigned int reg;
 174         int sel = regulator_map_voltage_linear_range(rdev, uv, uv);
 175
 176         if (sel < 0)
 177                 return -EINVAL;
 178
 179         reg = rdev->desc->vsel_reg + RK818_SLP_REG_OFFSET;
 180
 181         return regmap_update_bits(rdev->regmap, reg,
 182                                   rdev->desc->vsel_mask,
 183                                   sel);
 184 }
 185
 186 static int rk818_set_suspend_enable(struct regulator_dev *rdev)
 187 {
 188         unsigned int reg, enable_val;
 189         int offset = 0;
 190         struct rk808 *rk818 = rdev->reg_data;
 191
 192         switch (rk818->variant) {
 193         case RK818_ID:
 194                 offset = RK818_SLP_SET_OFF_REG_OFFSET;
 195                 enable_val = 0;
 196                 break;
 197         case RK805_ID:
 198                 if (rdev->desc->id >= RK805_ID_LDO1)
 199                         offset = RK805_SLP_LDO_EN_OFFSET;
 200                 else
 201                         offset = RK805_SLP_DCDC_EN_OFFSET;
 202                 enable_val = rdev->desc->enable_mask;
 203                 break;
 204         default:
 205                 dev_err(&rdev->dev, "not define sleep en reg offset!!\n");
 206                 return -EINVAL;
 207         }
 208
 209         reg = rdev->desc->enable_reg + offset;
 210
 211         return regmap_update_bits(rdev->regmap, reg,
 212                                   rdev->desc->enable_mask,
 213                                   enable_val);
 214 }
 215
 216 static int rk818_set_suspend_disable(struct regulator_dev *rdev)
 217 {
 218         int offset = 0;
 219         unsigned int reg, disable_val;
 220         struct rk808 *rk818 = rdev->reg_data;
 221
 222         switch (rk818->variant) {
 223         case RK818_ID:
 224                 offset = RK818_SLP_SET_OFF_REG_OFFSET;
 225                 disable_val = rdev->desc->enable_mask;
 226                 break;
 227         case RK805_ID:
 228                 if (rdev->desc->id >= RK805_ID_LDO1)
 229                         offset = RK805_SLP_LDO_EN_OFFSET;
 230                 else
 231                         offset = RK805_SLP_DCDC_EN_OFFSET;
 232                 disable_val = 0;
 233                 break;
 234         default:
 235                 dev_err(&rdev->dev, "not define sleep en reg offset!!\n");
 236                 return -EINVAL;
 237         }
 238
 239         reg = rdev->desc->enable_reg + offset;
 240
 241         return regmap_update_bits(rdev->regmap, reg,
 242                                   rdev->desc->enable_mask,
 243                                   disable_val);
 244 }
 245
 246 static int rk818_set_suspend_mode(struct regulator_dev *rdev, unsigned int mode)
 247 {
 248         unsigned int reg;
 249
 250         reg = rdev->desc->vsel_reg + RK818_SLP_REG_OFFSET;
 251
 252         switch (mode) {
 253         case REGULATOR_MODE_FAST:
 254                 return regmap_update_bits(rdev->regmap, reg,
 255                                           FPWM_MODE, FPWM_MODE);
 256         case REGULATOR_MODE_NORMAL:
 257                 return regmap_update_bits(rdev->regmap, reg, FPWM_MODE, 0);
 258         default:
 259                 pr_err("do not support this mode\n");
 260                 return -EINVAL;
 261         }
 262
 263         return 0;
 264 }
 265
 266 static int rk818_set_mode(struct regulator_dev *rdev, unsigned int mode)
 267 {
 268         switch (mode) {
 269         case REGULATOR_MODE_FAST:
 270                 return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
 271                                           FPWM_MODE, FPWM_MODE);
 272         case REGULATOR_MODE_NORMAL:
 273                 return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
 274                                           FPWM_MODE, 0);
 275         default:
 276                 pr_err("do not support this mode\n");
 277                 return -EINVAL;
 278         }
 279
 280         return 0;
 281 }
 282
 283 static unsigned int rk818_get_mode(struct regulator_dev *rdev)
 284 {
 285         unsigned int val;
 286         int err;
 287
 288         err = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
 289         if (err)
 290                 return err;
 291
 292         if (val & FPWM_MODE)
 293                 return REGULATOR_MODE_FAST;
 294         else
 295                 return REGULATOR_MODE_NORMAL;
 296 }
 297
 298 static unsigned int rk818_regulator_of_map_mode(unsigned int mode)
 299 {
 300         if (mode == 1)
 301                 return REGULATOR_MODE_FAST;
 302         if (mode == 2)
 303                 return REGULATOR_MODE_NORMAL;
 304
 305         return -EINVAL;
 306 }
 307
 308 static struct regulator_ops rk818_buck1_2_ops = {
 309         .list_voltage           = regulator_list_voltage_linear_range,
 310         .map_voltage            = regulator_map_voltage_linear_range,
 311         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 312         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 313         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 314         .enable                 = regulator_enable_regmap,
 315         .disable                = regulator_disable_regmap,
 316         .is_enabled             = regulator_is_enabled_regmap,
 317         .set_mode               = rk818_set_mode,
 318         .get_mode               = rk818_get_mode,
 319         .set_ramp_delay         = rk818_set_ramp_delay,
 320         .set_suspend_mode       = rk818_set_suspend_mode,
 321         .set_suspend_voltage    = rk818_set_suspend_voltage,
 322         .set_suspend_enable     = rk818_set_suspend_enable,
 323         .set_suspend_disable    = rk818_set_suspend_disable,
 324 };
 325
 326 static struct regulator_ops rk818_reg_ops = {
 327         .list_voltage           = regulator_list_voltage_linear_range,
 328         .map_voltage            = regulator_map_voltage_linear_range,
 329         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 330         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 331         .enable                 = regulator_enable_regmap,
 332         .disable                = regulator_disable_regmap,
 333         .set_mode               = rk818_set_mode,
 334         .get_mode               = rk818_get_mode,
 335         .is_enabled             = regulator_is_enabled_regmap,
 336         .set_suspend_mode       = rk818_set_suspend_mode,
 337         .set_suspend_voltage    = rk818_set_suspend_voltage,
 338         .set_suspend_enable     = rk818_set_suspend_enable,
 339         .set_suspend_disable    = rk818_set_suspend_disable,
 340 };
 341
 342 static struct regulator_ops rk818_switch_ops = {
 343         .enable                 = regulator_enable_regmap,
 344         .disable                = regulator_disable_regmap,
 345         .is_enabled             = regulator_is_enabled_regmap,
 346         .set_suspend_enable     = rk818_set_suspend_enable,
 347         .set_suspend_disable    = rk818_set_suspend_disable,
 348         .set_mode               = rk818_set_mode,
 349         .get_mode               = rk818_get_mode,
 350         .set_suspend_mode       = rk818_set_suspend_mode,
 351 };
 352
 353 static const struct regulator_desc rk818_desc[] = {
 354         {
 355                 .name = "DCDC_REG1",
 356                 .supply_name = "vcc1",
 357                 .id = RK818_ID_DCDC1,
 358                 .ops = &rk818_buck1_2_ops,
 359                 .type = REGULATOR_VOLTAGE,
 360                 .n_voltages = 64,
 361                 .linear_ranges = rk818_buck_voltage_ranges,
 362                 .n_linear_ranges = ARRAY_SIZE(rk818_buck_voltage_ranges),
 363                 .vsel_reg = RK818_BUCK1_ON_VSEL_REG,
 364                 .vsel_mask = RK818_BUCK_VSEL_MASK,
 365                 .enable_reg = RK818_DCDC_EN_REG,
 366                 .enable_mask = BIT(0),
 367                 .owner = THIS_MODULE,
 368         }, {
 369                 .name = "DCDC_REG2",
 370                 .supply_name = "vcc2",
 371                 .id = RK818_ID_DCDC2,
 372                 .ops = &rk818_buck1_2_ops,
 373                 .type = REGULATOR_VOLTAGE,
 374                 .n_voltages = 64,
 375                 .linear_ranges = rk818_buck_voltage_ranges,
 376                 .n_linear_ranges = ARRAY_SIZE(rk818_buck_voltage_ranges),
 377                 .vsel_reg = RK818_BUCK2_ON_VSEL_REG,
 378                 .vsel_mask = RK818_BUCK_VSEL_MASK,
 379                 .enable_reg = RK818_DCDC_EN_REG,
 380                 .enable_mask = BIT(1),
 381                 .owner = THIS_MODULE,
 382         }, {
 383                 .name = "DCDC_REG3",
 384                 .supply_name = "vcc3",
 385                 .id = RK818_ID_DCDC3,
 386                 .ops = &rk818_switch_ops,
 387                 .type = REGULATOR_VOLTAGE,
 388                 .n_voltages = 1,
 389                 .enable_reg = RK818_DCDC_EN_REG,
 390                 .enable_mask = BIT(2),
 391                 .owner = THIS_MODULE,
 392         }, {
 393                 .name = "DCDC_REG4",
 394                 .supply_name = "vcc4",
 395                 .id = RK818_ID_DCDC4,
 396                 .ops = &rk818_reg_ops,
 397                 .type = REGULATOR_VOLTAGE,
 398                 .n_voltages = 16,
 399                 .linear_ranges = rk818_buck4_voltage_ranges,
 400                 .n_linear_ranges = ARRAY_SIZE(rk818_buck4_voltage_ranges),
 401                 .vsel_reg = RK818_BUCK4_ON_VSEL_REG,
 402                 .vsel_mask = RK818_BUCK4_VSEL_MASK,
 403                 .enable_reg = RK818_DCDC_EN_REG,
 404                 .enable_mask = BIT(3),
 405                 .owner = THIS_MODULE,
 406         }, {
 407                 .name = "DCDC_BOOST",
 408                 .supply_name = "boost",
 409                 .id = RK818_ID_BOOST,
 410                 .ops = &rk818_reg_ops,
 411                 .type = REGULATOR_VOLTAGE,
 412                 .n_voltages = 8,
 413                 .linear_ranges = rk818_boost_voltage_ranges,
 414                 .n_linear_ranges = ARRAY_SIZE(rk818_boost_voltage_ranges),
 415                 .vsel_reg = RK818_BOOST_LDO9_ON_VSEL_REG,
 416                 .vsel_mask = RK818_BOOST_ON_VSEL_MASK,
 417                 .enable_reg = RK818_DCDC_EN_REG,
 418                 .enable_mask = BIT(4),
 419                 .enable_time = 0,
 420                 .owner = THIS_MODULE,
 421         }, {
 422                 .name = "LDO_REG1",
 423                 .supply_name = "vcc6",
 424                 .id = RK818_ID_LDO1,
 425                 .ops = &rk818_reg_ops,
 426                 .type = REGULATOR_VOLTAGE,
 427                 .n_voltages = 17,
 428                 .linear_ranges = rk818_ldo_voltage_ranges,
 429                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 430                 .vsel_reg = RK818_LDO1_ON_VSEL_REG,
 431                 .vsel_mask = RK818_LDO_VSEL_MASK,
 432                 .enable_reg = RK818_LDO_EN_REG,
 433                 .enable_mask = BIT(0),
 434                 .enable_time = 400,
 435                 .owner = THIS_MODULE,
 436         }, {
 437                 .name = "LDO_REG2",
 438                 .supply_name = "vcc6",
 439                 .id = RK818_ID_LDO2,
 440                 .ops = &rk818_reg_ops,
 441                 .type = REGULATOR_VOLTAGE,
 442                 .n_voltages = 17,
 443                 .linear_ranges = rk818_ldo_voltage_ranges,
 444                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 445                 .vsel_reg = RK818_LDO2_ON_VSEL_REG,
 446                 .vsel_mask = RK818_LDO_VSEL_MASK,
 447                 .enable_reg = RK818_LDO_EN_REG,
 448                 .enable_mask = BIT(1),
 449                 .enable_time = 400,
 450                 .owner = THIS_MODULE,
 451         }, {
 452                 .name = "LDO_REG3",
 453                 .supply_name = "vcc7",
 454                 .id = RK818_ID_LDO3,
 455                 .ops = &rk818_reg_ops,
 456                 .type = REGULATOR_VOLTAGE,
 457                 .n_voltages = 16,
 458                 .linear_ranges = rk818_ldo3_voltage_ranges,
 459                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo3_voltage_ranges),
 460                 .vsel_reg = RK818_LDO3_ON_VSEL_REG,
 461                 .vsel_mask = RK818_LDO3_VSEL_MASK,
 462                 .enable_reg = RK818_LDO_EN_REG,
 463                 .enable_mask = BIT(2),
 464                 .enable_time = 400,
 465                 .owner = THIS_MODULE,
 466         }, {
 467                 .name = "LDO_REG4",
 468                 .supply_name = "vcc8",
 469                 .id = RK818_ID_LDO4,
 470                 .ops = &rk818_reg_ops,
 471                 .type = REGULATOR_VOLTAGE,
 472                 .n_voltages = 17,
 473                 .linear_ranges = rk818_ldo_voltage_ranges,
 474                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 475                 .vsel_reg = RK818_LDO4_ON_VSEL_REG,
 476                 .vsel_mask = RK818_LDO_VSEL_MASK,
 477                 .enable_reg = RK818_LDO_EN_REG,
 478                 .enable_mask = BIT(3),
 479                 .enable_time = 400,
 480                 .owner = THIS_MODULE,
 481         }, {
 482                 .name = "LDO_REG5",
 483                 .supply_name = "vcc7",
 484                 .id = RK818_ID_LDO5,
 485                 .ops = &rk818_reg_ops,
 486                 .type = REGULATOR_VOLTAGE,
 487                 .n_voltages = 17,
 488                 .linear_ranges = rk818_ldo_voltage_ranges,
 489                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 490                 .vsel_reg = RK818_LDO5_ON_VSEL_REG,
 491                 .vsel_mask = RK818_LDO_VSEL_MASK,
 492                 .enable_reg = RK818_LDO_EN_REG,
 493                 .enable_mask = BIT(4),
 494                 .enable_time = 400,
 495                 .owner = THIS_MODULE,
 496         }, {
 497                 .name = "LDO_REG6",
 498                 .supply_name = "vcc8",
 499                 .id = RK818_ID_LDO6,
 500                 .ops = &rk818_reg_ops,
 501                 .type = REGULATOR_VOLTAGE,
 502                 .n_voltages = 18,
 503                 .linear_ranges = rk818_ldo6_voltage_ranges,
 504                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo6_voltage_ranges),
 505                 .vsel_reg = RK818_LDO6_ON_VSEL_REG,
 506                 .vsel_mask = RK818_LDO_VSEL_MASK,
 507                 .enable_reg = RK818_LDO_EN_REG,
 508                 .enable_mask = BIT(5),
 509                 .enable_time = 400,
 510                 .owner = THIS_MODULE,
 511         }, {
 512                 .name = "LDO_REG7",
 513                 .supply_name = "vcc7",
 514                 .id = RK818_ID_LDO7,
 515                 .ops = &rk818_reg_ops,
 516                 .type = REGULATOR_VOLTAGE,
 517                 .n_voltages = 18,
 518                 .linear_ranges = rk818_ldo6_voltage_ranges,
 519                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo6_voltage_ranges),
 520                 .vsel_reg = RK818_LDO7_ON_VSEL_REG,
 521                 .vsel_mask = RK818_LDO_VSEL_MASK,
 522                 .enable_reg = RK818_LDO_EN_REG,
 523                 .enable_mask = BIT(6),
 524                 .enable_time = 400,
 525                 .owner = THIS_MODULE,
 526         }, {
 527                 .name = "LDO_REG8",
 528                 .supply_name = "vcc8",
 529                 .id = RK818_ID_LDO8,
 530                 .ops = &rk818_reg_ops,
 531                 .type = REGULATOR_VOLTAGE,
 532                 .n_voltages = 17,
 533                 .linear_ranges = rk818_ldo_voltage_ranges,
 534                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 535                 .vsel_reg =  RK818_LDO8_ON_VSEL_REG,
 536                 .vsel_mask = RK818_LDO_VSEL_MASK,
 537                 .enable_reg = RK818_LDO_EN_REG,
 538                 .enable_mask = BIT(7),
 539                 .enable_time = 400,
 540                 .owner = THIS_MODULE,
 541         }, {
 542                 .name = "LDO_REG9",
 543                 .supply_name = "vcc9",
 544                 .id = RK818_ID_LDO9,
 545                 .ops = &rk818_reg_ops,
 546                 .type = REGULATOR_VOLTAGE,
 547                 .n_voltages = 17,
 548                 .linear_ranges = rk818_ldo_voltage_ranges,
 549                 .n_linear_ranges = ARRAY_SIZE(rk818_ldo_voltage_ranges),
 550                 .vsel_reg = RK818_BOOST_LDO9_ON_VSEL_REG,
 551                 .vsel_mask = RK818_LDO_VSEL_MASK,
 552                 .enable_reg = RK818_DCDC_EN_REG,
 553                 .enable_mask = BIT(5),
 554                 .enable_time = 400,
 555                 .owner = THIS_MODULE,
 556         }, {
 557                 .name = "SWITCH_REG",
 558                 .supply_name = "vcc9",
 559                 .id = RK818_ID_SWITCH,
 560                 .ops = &rk818_switch_ops,
 561                 .type = REGULATOR_VOLTAGE,
 562                 .enable_reg = RK818_DCDC_EN_REG,
 563                 .enable_mask = BIT(6),
 564                 .owner = THIS_MODULE,
 565         },
 566 };
 567
 568 static struct of_regulator_match rk818_reg_matches[] = {
 569         [RK818_ID_DCDC1]        = { .name = "DCDC_REG1" },
 570         [RK818_ID_DCDC2]        = { .name = "DCDC_REG2" },
 571         [RK818_ID_DCDC3]        = { .name = "DCDC_REG3" },
 572         [RK818_ID_DCDC4]        = { .name = "DCDC_REG4" },
 573         [RK818_ID_BOOST]        = { .name = "DCDC_BOOST" },
 574         [RK818_ID_LDO1]         = { .name = "LDO_REG1" },
 575         [RK818_ID_LDO2]         = { .name = "LDO_REG2" },
 576         [RK818_ID_LDO3]         = { .name = "LDO_REG3" },
 577         [RK818_ID_LDO4]         = { .name = "LDO_REG4" },
 578         [RK818_ID_LDO5]         = { .name = "LDO_REG5" },
 579         [RK818_ID_LDO6]         = { .name = "LDO_REG6" },
 580         [RK818_ID_LDO7]         = { .name = "LDO_REG7" },
 581         [RK818_ID_LDO8]         = { .name = "LDO_REG8" },
 582         [RK818_ID_LDO9]         = { .name = "LDO_REG9" },
 583         [RK818_ID_SWITCH]       = { .name = "SWITCH_REG" },
 584 };
 585
 586 static const struct regulator_desc rk805_desc[] = {
 587         {
 588                 .name = "DCDC_REG1",
 589                 .supply_name = "vcc1",
 590                 .id = RK805_ID_DCDC1,
 591                 .ops = &rk818_buck1_2_ops,
 592                 .type = REGULATOR_VOLTAGE,
 593                 .n_voltages = 64,
 594                 .linear_ranges = rk805_buck_voltage_ranges,
 595                 .n_linear_ranges = ARRAY_SIZE(rk805_buck_voltage_ranges),
 596                 .vsel_reg = RK805_BUCK1_ON_VSEL_REG,
 597                 .vsel_mask = RK818_BUCK_VSEL_MASK,
 598                 .enable_reg = RK805_DCDC_EN_REG,
 599                 .enable_mask = ENABLE_MASK(0),
 600                 .disable_val = DISABLE_VAL(0),
 601                 .of_map_mode = rk818_regulator_of_map_mode,
 602                 .owner = THIS_MODULE,
 603         }, {
 604                 .name = "DCDC_REG2",
 605                 .supply_name = "vcc2",
 606                 .id = RK805_ID_DCDC2,
 607                 .ops = &rk818_buck1_2_ops,
 608                 .type = REGULATOR_VOLTAGE,
 609                 .n_voltages = 64,
 610                 .linear_ranges = rk805_buck_voltage_ranges,
 611                 .n_linear_ranges = ARRAY_SIZE(rk805_buck_voltage_ranges),
 612                 .vsel_reg = RK805_BUCK2_ON_VSEL_REG,
 613                 .vsel_mask = RK818_BUCK_VSEL_MASK,
 614                 .enable_reg = RK805_DCDC_EN_REG,
 615                 .enable_mask = ENABLE_MASK(1),
 616                 .disable_val = DISABLE_VAL(1),
 617                 .of_map_mode = rk818_regulator_of_map_mode,
 618                 .owner = THIS_MODULE,
 619         }, {
 620                 .name = "DCDC_REG3",
 621                 .supply_name = "vcc3",
 622                 .id = RK805_ID_DCDC3,
 623                 .ops = &rk818_switch_ops,
 624                 .type = REGULATOR_VOLTAGE,
 625                 .n_voltages = 1,
 626                 .enable_reg = RK805_DCDC_EN_REG,
 627                 .enable_mask = ENABLE_MASK(2),
 628                 .disable_val = DISABLE_VAL(2),
 629                 .of_map_mode = rk818_regulator_of_map_mode,
 630                 .owner = THIS_MODULE,
 631         }, {
 632                 .name = "DCDC_REG4",
 633                 .supply_name = "vcc4",
 634                 .id = RK805_ID_DCDC4,
 635                 .ops = &rk818_reg_ops,
 636                 .type = REGULATOR_VOLTAGE,
 637                 .n_voltages = 32,
 638                 .linear_ranges = rk805_buck4_voltage_ranges,
 639                 .n_linear_ranges = ARRAY_SIZE(rk805_buck4_voltage_ranges),
 640                 .vsel_reg = RK805_BUCK4_ON_VSEL_REG,
 641                 .vsel_mask = RK818_BUCK4_VSEL_MASK,
 642                 .enable_reg = RK805_DCDC_EN_REG,
 643                 .enable_mask = ENABLE_MASK(3),
 644                 .disable_val = DISABLE_VAL(3),
 645                 .of_map_mode = rk818_regulator_of_map_mode,
 646                 .owner = THIS_MODULE,
 647         }, {
 648                 .name = "LDO_REG1",
 649                 .supply_name = "vcc5",
 650                 .id = RK805_ID_LDO1,
 651                 .ops = &rk818_reg_ops,
 652                 .type = REGULATOR_VOLTAGE,
 653                 .n_voltages = 27,
 654                 .linear_ranges = rk805_ldo_voltage_ranges,
 655                 .n_linear_ranges = ARRAY_SIZE(rk805_ldo_voltage_ranges),
 656                 .vsel_reg = RK805_LDO1_ON_VSEL_REG,
 657                 .vsel_mask = RK818_LDO_VSEL_MASK,
 658                 .enable_reg = RK805_LDO_EN_REG,
 659                 .enable_mask = ENABLE_MASK(0),
 660                 .disable_val = DISABLE_VAL(0),
 661                 .enable_time = 400,
 662                 .owner = THIS_MODULE,
 663         }, {
 664                 .name = "LDO_REG2",
 665                 .supply_name = "vcc5",
 666                 .id = RK805_ID_LDO2,
 667                 .ops = &rk818_reg_ops,
 668                 .type = REGULATOR_VOLTAGE,
 669                 .n_voltages = 27,
 670                 .linear_ranges = rk805_ldo_voltage_ranges,
 671                 .n_linear_ranges = ARRAY_SIZE(rk805_ldo_voltage_ranges),
 672                 .vsel_reg = RK805_LDO2_ON_VSEL_REG,
 673                 .vsel_mask = RK818_LDO_VSEL_MASK,
 674                 .enable_reg = RK805_LDO_EN_REG,
 675                 .enable_mask = ENABLE_MASK(1),
 676                 .disable_val = DISABLE_VAL(1),
 677                 .enable_time = 400,
 678                 .owner = THIS_MODULE,
 679         }, {
 680                 .name = "LDO_REG3",
 681                 .supply_name = "vcc6",
 682                 .id = RK805_ID_LDO3,
 683                 .ops = &rk818_reg_ops,
 684                 .type = REGULATOR_VOLTAGE,
 685                 .n_voltages = 27,
 686                 .linear_ranges = rk805_ldo_voltage_ranges,
 687                 .n_linear_ranges = ARRAY_SIZE(rk805_ldo_voltage_ranges),
 688                 .vsel_reg = RK805_LDO3_ON_VSEL_REG,
 689                 .vsel_mask = RK818_LDO_VSEL_MASK,
 690                 .enable_reg = RK805_LDO_EN_REG,
 691                 .enable_mask = ENABLE_MASK(2),
 692                 .disable_val = DISABLE_VAL(2),
 693                 .enable_time = 400,
 694                 .owner = THIS_MODULE,
 695         },
 696 };
 697
 698 static struct of_regulator_match rk805_reg_matches[] = {
 699         [RK805_ID_DCDC1] = {
 700                 .name = "RK805_DCDC1",
 701                 .desc = &rk805_desc[RK805_ID_DCDC1] /* for of_map_node */
 702         },
 703         [RK805_ID_DCDC2] = {
 704                 .name = "RK805_DCDC2",
 705                 .desc = &rk805_desc[RK805_ID_DCDC2]
 706         },
 707         [RK805_ID_DCDC3] = {
 708                 .name = "RK805_DCDC3",
 709                 .desc = &rk805_desc[RK805_ID_DCDC3]
 710         },
 711         [RK805_ID_DCDC4] = {
 712                 .name = "RK805_DCDC4",
 713                 .desc = &rk805_desc[RK805_ID_DCDC4]
 714         },
 715         [RK805_ID_LDO1] = { .name = "RK805_LDO1", },
 716         [RK805_ID_LDO2] = { .name = "RK805_LDO2", },
 717         [RK805_ID_LDO3] = { .name = "RK805_LDO3", },
 718 };
 719
 720 static int rk818_regulator_dt_parse_pdata(struct device *dev,
 721                                           struct device *client_dev,
 722                                           struct regmap *map,
 723                                           struct of_regulator_match *reg_matches,
 724                                           int regulator_nr)
 725 {
 726         struct device_node *np;
 727         int ret;
 728
 729         np = of_get_child_by_name(client_dev->of_node, "regulators");
 730         if (!np)
 731                 return -ENXIO;
 732
 733         ret = of_regulator_match(dev, np, reg_matches, regulator_nr);
 734
 735         of_node_put(np);
 736         return ret;
 737 }
 738
 739 static int rk818_regulator_probe(struct platform_device *pdev)
 740 {
 741         struct rk808 *rk818 = dev_get_drvdata(pdev->dev.parent);
 742         struct i2c_client *client = rk818->i2c;
 743         struct regulator_config config = {};
 744         struct regulator_dev *rk818_rdev;
 745         int ret, i, reg_nr;
 746         const struct regulator_desc *reg_desc;
 747         struct of_regulator_match *reg_matches;
 748
 749         switch (rk818->variant) {
 750         case RK818_ID:
 751                 reg_desc = rk818_desc;
 752                 reg_matches = rk818_reg_matches;
 753                 reg_nr = ARRAY_SIZE(rk818_reg_matches);
 754                 break;
 755         case RK805_ID:
 756                 reg_desc = rk805_desc;
 757                 reg_matches = rk805_reg_matches;
 758                 reg_nr = RK805_NUM_REGULATORS;
 759                 break;
 760         default:
 761                 dev_err(&client->dev, "unsupported RK8XX ID %lu\n",
 762                         rk818->variant);
 763                 return -EINVAL;
 764         }
 765
 766         ret = rk818_regulator_dt_parse_pdata(&pdev->dev, &client->dev,
 767                                              rk818->regmap,
 768                                              reg_matches, reg_nr);
 769         if (ret < 0)
 770                 return ret;
 771
 772         /* Instantiate the regulators */
 773         for (i = 0; i < reg_nr; i++) {
 774                 if (!reg_matches[i].init_data ||
 775                     !reg_matches[i].of_node)
 776                         continue;
 777
 778                 config.driver_data = rk818;
 779                 config.dev = &client->dev;
 780                 config.regmap = rk818->regmap;
 781                 config.of_node = reg_matches[i].of_node;
 782                 config.init_data = reg_matches[i].init_data;
 783                 rk818_rdev = devm_regulator_register(&pdev->dev,
 784                                                      &reg_desc[i],
 785                                                      &config);
 786                 if (IS_ERR(rk818_rdev)) {
 787                         dev_err(&client->dev,
 788                                 "failed to register %d regulator\n", i);
 789                         return PTR_ERR(rk818_rdev);
 790                 }
 791         }
 792
 793         dev_info(&client->dev, "register rk%lx regulators\n", rk818->variant);
 794
 795         return 0;
 796 }
 797
 798 static struct platform_driver rk818_regulator_driver = {
 799         .probe = rk818_regulator_probe,
 800         .driver = {
 801                 .name = "rk818-regulator",
 802                 .owner = THIS_MODULE,
 803         },
 804 };
 805
 806 module_platform_driver(rk818_regulator_driver);
 807
 808 MODULE_DESCRIPTION("regulator driver for the rk818 series PMICs");
 809 MODULE_AUTHOR("xsf<xsf@rock-chips.com>");
 810 MODULE_AUTHOR("Zhang Qing<zhangqing@rock-chips.com>");
 811 MODULE_AUTHOR("chen Jianhong<chenjh@rock-chips.com>");
 812 MODULE_LICENSE("GPL");
 813 MODULE_ALIAS("platform:rk818-regulator");
 814