drivers/regulator/bd9571mwv-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ROHM BD9571MWV-M regulator driver
   4  *
   5  * Copyright (C) 2017 Marek Vasut <marek.vasut+renesas@gmail.com>
   6  *
   7  * Based on the TPS65086 driver
   8  *
   9  * NOTE: VD09 is missing
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/of.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/regulator/driver.h>
  16
  17 #include <linux/mfd/bd9571mwv.h>
  18
  19 struct bd9571mwv_reg {
  20         struct regmap *regmap;
  21
  22         /* DDR Backup Power */
  23         u8 bkup_mode_cnt_keepon;        /* from "rohm,ddr-backup-power" */
  24         u8 bkup_mode_cnt_saved;
  25         bool bkup_mode_enabled;
  26
  27         /* Power switch type */
  28         bool rstbmode_level;
  29         bool rstbmode_pulse;
  30 };
  31
  32 enum bd9571mwv_regulators { VD09, VD18, VD25, VD33, DVFS };
  33
  34 #define BD9571MWV_REG(_name, _of, _id, _ops, _vr, _vm, _nv, _min, _step, _lmin)\
  35         {                                                       \
  36                 .name                   = _name,                \
  37                 .of_match               = of_match_ptr(_of),    \
  38                 .regulators_node        = "regulators",         \
  39                 .id                     = _id,                  \
  40                 .ops                    = &_ops,                \
  41                 .n_voltages             = _nv,                  \
  42                 .type                   = REGULATOR_VOLTAGE,    \
  43                 .owner                  = THIS_MODULE,          \
  44                 .vsel_reg               = _vr,                  \
  45                 .vsel_mask              = _vm,                  \
  46                 .min_uV                 = _min,                 \
  47                 .uV_step                = _step,                \
  48                 .linear_min_sel         = _lmin,                \
  49         }
  50
  51 static int bd9571mwv_avs_get_moni_state(struct regulator_dev *rdev)
  52 {
  53         unsigned int val;
  54         int ret;
  55
  56         ret = regmap_read(rdev->regmap, BD9571MWV_AVS_SET_MONI, &val);
  57         if (ret != 0)
  58                 return ret;
  59
  60         return val & BD9571MWV_AVS_SET_MONI_MASK;
  61 }
  62
  63 static int bd9571mwv_avs_set_voltage_sel_regmap(struct regulator_dev *rdev,
  64                                                 unsigned int sel)
  65 {
  66         int ret;
  67
  68         ret = bd9571mwv_avs_get_moni_state(rdev);
  69         if (ret < 0)
  70                 return ret;
  71
  72         return regmap_write_bits(rdev->regmap, BD9571MWV_AVS_VD09_VID(ret),
  73                                  rdev->desc->vsel_mask, sel);
  74 }
  75
  76 static int bd9571mwv_avs_get_voltage_sel_regmap(struct regulator_dev *rdev)
  77 {
  78         unsigned int val;
  79         int ret;
  80
  81         ret = bd9571mwv_avs_get_moni_state(rdev);
  82         if (ret < 0)
  83                 return ret;
  84
  85         ret = regmap_read(rdev->regmap, BD9571MWV_AVS_VD09_VID(ret), &val);
  86         if (ret != 0)
  87                 return ret;
  88
  89         val &= rdev->desc->vsel_mask;
  90         val >>= ffs(rdev->desc->vsel_mask) - 1;
  91
  92         return val;
  93 }
  94
  95 static int bd9571mwv_reg_set_voltage_sel_regmap(struct regulator_dev *rdev,
  96                                                 unsigned int sel)
  97 {
  98         return regmap_write_bits(rdev->regmap, BD9571MWV_DVFS_SETVID,
  99                                  rdev->desc->vsel_mask, sel);
 100 }
 101
 102 /* Operations permitted on AVS voltage regulator */
 103 static const struct regulator_ops avs_ops = {
 104         .set_voltage_sel        = bd9571mwv_avs_set_voltage_sel_regmap,
 105         .map_voltage            = regulator_map_voltage_linear,
 106         .get_voltage_sel        = bd9571mwv_avs_get_voltage_sel_regmap,
 107         .list_voltage           = regulator_list_voltage_linear,
 108 };
 109
 110 /* Operations permitted on voltage regulators */
 111 static const struct regulator_ops reg_ops = {
 112         .set_voltage_sel        = bd9571mwv_reg_set_voltage_sel_regmap,
 113         .map_voltage            = regulator_map_voltage_linear,
 114         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 115         .list_voltage           = regulator_list_voltage_linear,
 116 };
 117
 118 /* Operations permitted on voltage monitors */
 119 static const struct regulator_ops vid_ops = {
 120         .map_voltage            = regulator_map_voltage_linear,
 121         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 122         .list_voltage           = regulator_list_voltage_linear,
 123 };
 124
 125 static const struct regulator_desc regulators[] = {
 126         BD9571MWV_REG("VD09", "vd09", VD09, avs_ops, 0, 0x7f,
 127                       0x80, 600000, 10000, 0x3c),
 128         BD9571MWV_REG("VD18", "vd18", VD18, vid_ops, BD9571MWV_VD18_VID, 0xf,
 129                       16, 1625000, 25000, 0),
 130         BD9571MWV_REG("VD25", "vd25", VD25, vid_ops, BD9571MWV_VD25_VID, 0xf,
 131                       16, 2150000, 50000, 0),
 132         BD9571MWV_REG("VD33", "vd33", VD33, vid_ops, BD9571MWV_VD33_VID, 0xf,
 133                       11, 2800000, 100000, 0),
 134         BD9571MWV_REG("DVFS", "dvfs", DVFS, reg_ops,
 135                       BD9571MWV_DVFS_MONIVDAC, 0x7f,
 136                       0x80, 600000, 10000, 0x3c),
 137 };
 138
 139 #ifdef CONFIG_PM_SLEEP
 140 static int bd9571mwv_bkup_mode_read(struct bd9571mwv_reg *bdreg,
 141                                     unsigned int *mode)
 142 {
 143         int ret;
 144
 145         ret = regmap_read(bdreg->regmap, BD9571MWV_BKUP_MODE_CNT, mode);
 146         if (ret) {
 147                 dev_err(regmap_get_device(bdreg->regmap),
 148                         "failed to read backup mode (%d)\n", ret);
 149                 return ret;
 150         }
 151
 152         return 0;
 153 }
 154
 155 static int bd9571mwv_bkup_mode_write(struct bd9571mwv_reg *bdreg,
 156                                      unsigned int mode)
 157 {
 158         int ret;
 159
 160         ret = regmap_write(bdreg->regmap, BD9571MWV_BKUP_MODE_CNT, mode);
 161         if (ret) {
 162                 dev_err(regmap_get_device(bdreg->regmap),
 163                         "failed to configure backup mode 0x%x (%d)\n",
 164                         mode, ret);
 165                 return ret;
 166         }
 167
 168         return 0;
 169 }
 170
 171 static ssize_t backup_mode_show(struct device *dev,
 172                                 struct device_attribute *attr, char *buf)
 173 {
 174         struct bd9571mwv_reg *bdreg = dev_get_drvdata(dev);
 175
 176         return sprintf(buf, "%s\n", bdreg->bkup_mode_enabled ? "on" : "off");
 177 }
 178
 179 static ssize_t backup_mode_store(struct device *dev,
 180                                  struct device_attribute *attr,
 181                                  const char *buf, size_t count)
 182 {
 183         struct bd9571mwv_reg *bdreg = dev_get_drvdata(dev);
 184         unsigned int mode;
 185         int ret;
 186
 187         if (!count)
 188                 return 0;
 189
 190         ret = kstrtobool(buf, &bdreg->bkup_mode_enabled);
 191         if (ret)
 192                 return ret;
 193
 194         if (!bdreg->rstbmode_level)
 195                 return count;
 196
 197         /*
 198          * Configure DDR Backup Mode, to change the role of the accessory power
 199          * switch from a power switch to a wake-up switch, or vice versa
 200          */
 201         ret = bd9571mwv_bkup_mode_read(bdreg, &mode);
 202         if (ret)
 203                 return ret;
 204
 205         mode &= ~BD9571MWV_BKUP_MODE_CNT_KEEPON_MASK;
 206         if (bdreg->bkup_mode_enabled)
 207                 mode |= bdreg->bkup_mode_cnt_keepon;
 208
 209         ret = bd9571mwv_bkup_mode_write(bdreg, mode);
 210         if (ret)
 211                 return ret;
 212
 213         return count;
 214 }
 215
 216 static DEVICE_ATTR_RW(backup_mode);
 217
 218 static int bd9571mwv_suspend(struct device *dev)
 219 {
 220         struct bd9571mwv_reg *bdreg = dev_get_drvdata(dev);
 221         unsigned int mode;
 222         int ret;
 223
 224         if (!bdreg->bkup_mode_enabled)
 225                 return 0;
 226
 227         /* Save DDR Backup Mode */
 228         ret = bd9571mwv_bkup_mode_read(bdreg, &mode);
 229         if (ret)
 230                 return ret;
 231
 232         bdreg->bkup_mode_cnt_saved = mode;
 233
 234         if (!bdreg->rstbmode_pulse)
 235                 return 0;
 236
 237         /* Enable DDR Backup Mode */
 238         mode &= ~BD9571MWV_BKUP_MODE_CNT_KEEPON_MASK;
 239         mode |= bdreg->bkup_mode_cnt_keepon;
 240
 241         if (mode != bdreg->bkup_mode_cnt_saved)
 242                 return bd9571mwv_bkup_mode_write(bdreg, mode);
 243
 244         return 0;
 245 }
 246
 247 static int bd9571mwv_resume(struct device *dev)
 248 {
 249         struct bd9571mwv_reg *bdreg = dev_get_drvdata(dev);
 250
 251         if (!bdreg->bkup_mode_enabled)
 252                 return 0;
 253
 254         /* Restore DDR Backup Mode */
 255         return bd9571mwv_bkup_mode_write(bdreg, bdreg->bkup_mode_cnt_saved);
 256 }
 257
 258 static const struct dev_pm_ops bd9571mwv_pm  = {
 259         SET_SYSTEM_SLEEP_PM_OPS(bd9571mwv_suspend, bd9571mwv_resume)
 260 };
 261
 262 static int bd9571mwv_regulator_remove(struct platform_device *pdev)
 263 {
 264         device_remove_file(&pdev->dev, &dev_attr_backup_mode);
 265         return 0;
 266 }
 267 #define DEV_PM_OPS      &bd9571mwv_pm
 268 #else
 269 #define DEV_PM_OPS      NULL
 270 #define bd9571mwv_regulator_remove      NULL
 271 #endif /* CONFIG_PM_SLEEP */
 272
 273 static int bd9571mwv_regulator_probe(struct platform_device *pdev)
 274 {
 275         struct regulator_config config = { };
 276         struct bd9571mwv_reg *bdreg;
 277         struct regulator_dev *rdev;
 278         unsigned int val;
 279         int i;
 280
 281         bdreg = devm_kzalloc(&pdev->dev, sizeof(*bdreg), GFP_KERNEL);
 282         if (!bdreg)
 283                 return -ENOMEM;
 284
 285         bdreg->regmap = dev_get_regmap(pdev->dev.parent, NULL);
 286
 287         platform_set_drvdata(pdev, bdreg);
 288
 289         config.dev = &pdev->dev;
 290         config.dev->of_node = pdev->dev.parent->of_node;
 291         config.driver_data = bdreg;
 292         config.regmap = bdreg->regmap;
 293
 294         for (i = 0; i < ARRAY_SIZE(regulators); i++) {
 295                 rdev = devm_regulator_register(&pdev->dev, &regulators[i],
 296                                                &config);
 297                 if (IS_ERR(rdev)) {
 298                         dev_err(&pdev->dev, "failed to register %s regulator\n",
 299                                 pdev->name);
 300                         return PTR_ERR(rdev);
 301                 }
 302         }
 303
 304         val = 0;
 305         of_property_read_u32(config.dev->of_node, "rohm,ddr-backup-power", &val);
 306         if (val & ~BD9571MWV_BKUP_MODE_CNT_KEEPON_MASK) {
 307                 dev_err(&pdev->dev, "invalid %s mode %u\n",
 308                         "rohm,ddr-backup-power", val);
 309                 return -EINVAL;
 310         }
 311         bdreg->bkup_mode_cnt_keepon = val;
 312
 313         bdreg->rstbmode_level = of_property_read_bool(config.dev->of_node,
 314                                                       "rohm,rstbmode-level");
 315         bdreg->rstbmode_pulse = of_property_read_bool(config.dev->of_node,
 316                                                       "rohm,rstbmode-pulse");
 317         if (bdreg->rstbmode_level && bdreg->rstbmode_pulse) {
 318                 dev_err(&pdev->dev, "only one rohm,rstbmode-* may be specified");
 319                 return -EINVAL;
 320         }
 321
 322 #ifdef CONFIG_PM_SLEEP
 323         if (bdreg->bkup_mode_cnt_keepon) {
 324                 int ret;
 325
 326                 /*
 327                  * Backup mode is enabled by default in pulse mode, but needs
 328                  * explicit user setup in level mode.
 329                  */
 330                 bdreg->bkup_mode_enabled = bdreg->rstbmode_pulse;
 331
 332                 ret = device_create_file(&pdev->dev, &dev_attr_backup_mode);
 333                 if (ret)
 334                         return ret;
 335         }
 336 #endif /* CONFIG_PM_SLEEP */
 337
 338         return 0;
 339 }
 340
 341 static const struct platform_device_id bd9571mwv_regulator_id_table[] = {
 342         { "bd9571mwv-regulator", },
 343         { /* sentinel */ }
 344 };
 345 MODULE_DEVICE_TABLE(platform, bd9571mwv_regulator_id_table);
 346
 347 static struct platform_driver bd9571mwv_regulator_driver = {
 348         .driver = {
 349                 .name = "bd9571mwv-regulator",
 350                 .pm = DEV_PM_OPS,
 351         },
 352         .probe = bd9571mwv_regulator_probe,
 353         .remove = bd9571mwv_regulator_remove,
 354         .id_table = bd9571mwv_regulator_id_table,
 355 };
 356 module_platform_driver(bd9571mwv_regulator_driver);
 357
 358 MODULE_AUTHOR("Marek Vasut <marek.vasut+renesas@gmail.com>");
 359 MODULE_DESCRIPTION("BD9571MWV Regulator driver");
 360 MODULE_LICENSE("GPL v2");