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