drivers/regulator/hi6421v600-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Device driver for regulators in Hisi IC
   4 //
   5 // Copyright (c) 2013 Linaro Ltd.
   6 // Copyright (c) 2011 HiSilicon Ltd.
   7 // Copyright (c) 2020-2021 Huawei Technologies Co., Ltd
   8 //
   9 // Guodong Xu <guodong.xu@linaro.org>
  10
  11 #include <linux/delay.h>
  12 #include <linux/mfd/hi6421-spmi-pmic.h>
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/regmap.h>
  16 #include <linux/regulator/driver.h>
  17 #include <linux/spmi.h>
  18
  19 struct hi6421_spmi_reg_info {
  20         struct regulator_desc   desc;
  21         struct hi6421_spmi_pmic *pmic;
  22         u8                      eco_mode_mask;
  23         u32                     eco_uA;
  24
  25         /* Serialize regulator enable logic */
  26         struct mutex enable_mutex;
  27 };
  28
  29 static const unsigned int ldo3_voltages[] = {
  30         1500000, 1550000, 1600000, 1650000,
  31         1700000, 1725000, 1750000, 1775000,
  32         1800000, 1825000, 1850000, 1875000,
  33         1900000, 1925000, 1950000, 2000000
  34 };
  35
  36 static const unsigned int ldo4_voltages[] = {
  37         1725000, 1750000, 1775000, 1800000,
  38         1825000, 1850000, 1875000, 1900000
  39 };
  40
  41 static const unsigned int ldo9_voltages[] = {
  42         1750000, 1800000, 1825000, 2800000,
  43         2850000, 2950000, 3000000, 3300000
  44 };
  45
  46 static const unsigned int ldo15_voltages[] = {
  47         1800000, 1850000, 2400000, 2600000,
  48         2700000, 2850000, 2950000, 3000000
  49 };
  50
  51 static const unsigned int ldo17_voltages[] = {
  52         2500000, 2600000, 2700000, 2800000,
  53         3000000, 3100000, 3200000, 3300000
  54 };
  55
  56 static const unsigned int ldo34_voltages[] = {
  57         2600000, 2700000, 2800000, 2900000,
  58         3000000, 3100000, 3200000, 3300000
  59 };
  60
  61 /**
  62  * HI6421V600_LDO() - specify a LDO power line
  63  * @_id: LDO id name string
  64  * @vtable: voltage table
  65  * @ereg: enable register
  66  * @emask: enable mask
  67  * @vreg: voltage select register
  68  * @odelay: off/on delay time in uS
  69  * @etime: enable time in uS
  70  * @ecomask: eco mode mask
  71  * @ecoamp: eco mode load uppler limit in uA
  72  */
  73 #define HI6421V600_LDO(_id, vtable, ereg, emask, vreg,                         \
  74                        odelay, etime, ecomask, ecoamp)                         \
  75         [HI6421V600_##_id] = {                                                 \
  76                 .desc = {                                                      \
  77                         .name           = #_id,                                \
  78                         .of_match        = of_match_ptr(#_id),                 \
  79                         .regulators_node = of_match_ptr("regulators"),         \
  80                         .ops            = &hi6421_spmi_ldo_rops,               \
  81                         .type           = REGULATOR_VOLTAGE,                   \
  82                         .id             = HI6421V600_##_id,                    \
  83                         .owner          = THIS_MODULE,                         \
  84                         .volt_table     = vtable,                              \
  85                         .n_voltages     = ARRAY_SIZE(vtable),                  \
  86                         .vsel_mask      = ARRAY_SIZE(vtable) - 1,              \
  87                         .vsel_reg       = vreg,                                \
  88                         .enable_reg     = ereg,                                \
  89                         .enable_mask    = emask,                               \
  90                         .enable_time    = etime,                               \
  91                         .ramp_delay     = etime,                               \
  92                         .off_on_delay   = odelay,                              \
  93                 },                                                             \
  94                 .eco_mode_mask          = ecomask,                             \
  95                 .eco_uA                 = ecoamp,                              \
  96         }
  97
  98 static int hi6421_spmi_regulator_enable(struct regulator_dev *rdev)
  99 {
 100         struct hi6421_spmi_reg_info *sreg = rdev_get_drvdata(rdev);
 101         struct hi6421_spmi_pmic *pmic = sreg->pmic;
 102         int ret;
 103
 104         /* cannot enable more than one regulator at one time */
 105         mutex_lock(&sreg->enable_mutex);
 106
 107         ret = regmap_update_bits(pmic->regmap, rdev->desc->enable_reg,
 108                                  rdev->desc->enable_mask,
 109                                  rdev->desc->enable_mask);
 110
 111         /* Avoid powering up multiple devices at the same time */
 112         usleep_range(rdev->desc->off_on_delay, rdev->desc->off_on_delay + 60);
 113
 114         mutex_unlock(&sreg->enable_mutex);
 115
 116         return ret;
 117 }
 118
 119 static int hi6421_spmi_regulator_disable(struct regulator_dev *rdev)
 120 {
 121         struct hi6421_spmi_reg_info *sreg = rdev_get_drvdata(rdev);
 122         struct hi6421_spmi_pmic *pmic = sreg->pmic;
 123
 124         return regmap_update_bits(pmic->regmap, rdev->desc->enable_reg,
 125                                   rdev->desc->enable_mask, 0);
 126 }
 127
 128 static unsigned int hi6421_spmi_regulator_get_mode(struct regulator_dev *rdev)
 129 {
 130         struct hi6421_spmi_reg_info *sreg = rdev_get_drvdata(rdev);
 131         struct hi6421_spmi_pmic *pmic = sreg->pmic;
 132         unsigned int reg_val;
 133
 134         regmap_read(pmic->regmap, rdev->desc->enable_reg, &reg_val);
 135
 136         if (reg_val & sreg->eco_mode_mask)
 137                 return REGULATOR_MODE_IDLE;
 138
 139         return REGULATOR_MODE_NORMAL;
 140 }
 141
 142 static int hi6421_spmi_regulator_set_mode(struct regulator_dev *rdev,
 143                                           unsigned int mode)
 144 {
 145         struct hi6421_spmi_reg_info *sreg = rdev_get_drvdata(rdev);
 146         struct hi6421_spmi_pmic *pmic = sreg->pmic;
 147         unsigned int val;
 148
 149         switch (mode) {
 150         case REGULATOR_MODE_NORMAL:
 151                 val = 0;
 152                 break;
 153         case REGULATOR_MODE_IDLE:
 154                 if (!sreg->eco_mode_mask)
 155                         return -EINVAL;
 156
 157                 val = sreg->eco_mode_mask;
 158                 break;
 159         default:
 160                 return -EINVAL;
 161         }
 162
 163         return regmap_update_bits(pmic->regmap, rdev->desc->enable_reg,
 164                                   sreg->eco_mode_mask, val);
 165 }
 166
 167 static unsigned int
 168 hi6421_spmi_regulator_get_optimum_mode(struct regulator_dev *rdev,
 169                                        int input_uV, int output_uV,
 170                                        int load_uA)
 171 {
 172         struct hi6421_spmi_reg_info *sreg = rdev_get_drvdata(rdev);
 173
 174         if (!sreg->eco_uA || ((unsigned int)load_uA > sreg->eco_uA))
 175                 return REGULATOR_MODE_NORMAL;
 176
 177         return REGULATOR_MODE_IDLE;
 178 }
 179
 180 static const struct regulator_ops hi6421_spmi_ldo_rops = {
 181         .is_enabled = regulator_is_enabled_regmap,
 182         .enable = hi6421_spmi_regulator_enable,
 183         .disable = hi6421_spmi_regulator_disable,
 184         .list_voltage = regulator_list_voltage_table,
 185         .map_voltage = regulator_map_voltage_iterate,
 186         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 187         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 188         .get_mode = hi6421_spmi_regulator_get_mode,
 189         .set_mode = hi6421_spmi_regulator_set_mode,
 190         .get_optimum_mode = hi6421_spmi_regulator_get_optimum_mode,
 191 };
 192
 193 /* HI6421v600 regulators with known registers */
 194 enum hi6421_spmi_regulator_id {
 195         HI6421V600_LDO3,
 196         HI6421V600_LDO4,
 197         HI6421V600_LDO9,
 198         HI6421V600_LDO15,
 199         HI6421V600_LDO16,
 200         HI6421V600_LDO17,
 201         HI6421V600_LDO33,
 202         HI6421V600_LDO34,
 203 };
 204
 205 static struct hi6421_spmi_reg_info regulator_info[] = {
 206         HI6421V600_LDO(LDO3, ldo3_voltages,
 207                        0x16, 0x01, 0x51,
 208                        20000, 120,
 209                        0, 0),
 210         HI6421V600_LDO(LDO4, ldo4_voltages,
 211                        0x17, 0x01, 0x52,
 212                        20000, 120,
 213                        0x10, 10000),
 214         HI6421V600_LDO(LDO9, ldo9_voltages,
 215                        0x1c, 0x01, 0x57,
 216                        20000, 360,
 217                        0x10, 10000),
 218         HI6421V600_LDO(LDO15, ldo15_voltages,
 219                        0x21, 0x01, 0x5c,
 220                        20000, 360,
 221                        0x10, 10000),
 222         HI6421V600_LDO(LDO16, ldo15_voltages,
 223                        0x22, 0x01, 0x5d,
 224                        20000, 360,
 225                        0x10, 10000),
 226         HI6421V600_LDO(LDO17, ldo17_voltages,
 227                        0x23, 0x01, 0x5e,
 228                        20000, 120,
 229                        0x10, 10000),
 230         HI6421V600_LDO(LDO33, ldo17_voltages,
 231                        0x32, 0x01, 0x6d,
 232                        20000, 120,
 233                        0, 0),
 234         HI6421V600_LDO(LDO34, ldo34_voltages,
 235                        0x33, 0x01, 0x6e,
 236                        20000, 120,
 237                        0, 0),
 238 };
 239
 240 static int hi6421_spmi_regulator_probe(struct platform_device *pdev)
 241 {
 242         struct device *pmic_dev = pdev->dev.parent;
 243         struct regulator_config config = { };
 244         struct hi6421_spmi_reg_info *sreg;
 245         struct hi6421_spmi_reg_info *info;
 246         struct device *dev = &pdev->dev;
 247         struct hi6421_spmi_pmic *pmic;
 248         struct regulator_dev *rdev;
 249         int i;
 250
 251         /*
 252          * This driver is meant to be called by hi6421-spmi-core,
 253          * which should first set drvdata. If this doesn't happen, hit
 254          * a warn on and return.
 255          */
 256         pmic = dev_get_drvdata(pmic_dev);
 257         if (WARN_ON(!pmic))
 258                 return -ENODEV;
 259
 260         sreg = devm_kzalloc(dev, sizeof(*sreg), GFP_KERNEL);
 261         if (!sreg)
 262                 return -ENOMEM;
 263
 264         sreg->pmic = pmic;
 265         mutex_init(&sreg->enable_mutex);
 266
 267         for (i = 0; i < ARRAY_SIZE(regulator_info); i++) {
 268                 info = &regulator_info[i];
 269
 270                 config.dev = pdev->dev.parent;
 271                 config.driver_data = sreg;
 272                 config.regmap = pmic->regmap;
 273
 274                 rdev = devm_regulator_register(dev, &info->desc, &config);
 275                 if (IS_ERR(rdev)) {
 276                         dev_err(dev, "failed to register %s\n",
 277                                 info->desc.name);
 278                         return PTR_ERR(rdev);
 279                 }
 280         }
 281
 282         return 0;
 283 }
 284
 285 static const struct platform_device_id hi6421_spmi_regulator_table[] = {
 286         { .name = "hi6421v600-regulator" },
 287         {},
 288 };
 289 MODULE_DEVICE_TABLE(platform, hi6421_spmi_regulator_table);
 290
 291 static struct platform_driver hi6421_spmi_regulator_driver = {
 292         .id_table = hi6421_spmi_regulator_table,
 293         .driver = {
 294                 .name = "hi6421v600-regulator",
 295         },
 296         .probe  = hi6421_spmi_regulator_probe,
 297 };
 298 module_platform_driver(hi6421_spmi_regulator_driver);
 299
 300 MODULE_DESCRIPTION("Hi6421v600 SPMI regulator driver");
 301 MODULE_LICENSE("GPL v2");
 302