drivers/regulator/scmi-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // System Control and Management Interface (SCMI) based regulator driver
   4 //
   5 // Copyright (C) 2020 ARM Ltd.
   6 //
   7 // Implements a regulator driver on top of the SCMI Voltage Protocol.
   8 //
   9 // The ARM SCMI Protocol aims in general to hide as much as possible all the
  10 // underlying operational details while providing an abstracted interface for
  11 // its users to operate upon: as a consequence the resulting operational
  12 // capabilities and configurability of this regulator device are much more
  13 // limited than the ones usually available on a standard physical regulator.
  14 //
  15 // The supported SCMI regulator ops are restricted to the bare minimum:
  16 //
  17 //  - 'status_ops': enable/disable/is_enabled
  18 //  - 'voltage_ops': get_voltage_sel/set_voltage_sel
  19 //                   list_voltage/map_voltage
  20 //
  21 // Each SCMI regulator instance is associated, through the means of a proper DT
  22 // entry description, to a specific SCMI Voltage Domain.
  23
  24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  25
  26 #include <linux/linear_range.h>
  27 #include <linux/module.h>
  28 #include <linux/of.h>
  29 #include <linux/regulator/driver.h>
  30 #include <linux/regulator/machine.h>
  31 #include <linux/regulator/of_regulator.h>
  32 #include <linux/scmi_protocol.h>
  33 #include <linux/slab.h>
  34 #include <linux/types.h>
  35
  36 struct scmi_regulator {
  37         u32 id;
  38         struct scmi_device *sdev;
  39         struct regulator_dev *rdev;
  40         struct device_node *of_node;
  41         struct regulator_desc desc;
  42         struct regulator_config conf;
  43 };
  44
  45 struct scmi_regulator_info {
  46         int num_doms;
  47         struct scmi_regulator **sregv;
  48 };
  49
  50 static int scmi_reg_enable(struct regulator_dev *rdev)
  51 {
  52         struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
  53         const struct scmi_handle *handle = sreg->sdev->handle;
  54
  55         return handle->voltage_ops->config_set(handle, sreg->id,
  56                                                SCMI_VOLTAGE_ARCH_STATE_ON);
  57 }
  58
  59 static int scmi_reg_disable(struct regulator_dev *rdev)
  60 {
  61         struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
  62         const struct scmi_handle *handle = sreg->sdev->handle;
  63
  64         return handle->voltage_ops->config_set(handle, sreg->id,
  65                                                SCMI_VOLTAGE_ARCH_STATE_OFF);
  66 }
  67
  68 static int scmi_reg_is_enabled(struct regulator_dev *rdev)
  69 {
  70         int ret;
  71         u32 config;
  72         struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
  73         const struct scmi_handle *handle = sreg->sdev->handle;
  74
  75         ret = handle->voltage_ops->config_get(handle, sreg->id,
  76                                               &config);
  77         if (ret) {
  78                 dev_err(&sreg->sdev->dev,
  79                         "Error %d reading regulator %s status.\n",
  80                         ret, sreg->desc.name);
  81                 return ret;
  82         }
  83
  84         return config & SCMI_VOLTAGE_ARCH_STATE_ON;
  85 }
  86
  87 static int scmi_reg_get_voltage_sel(struct regulator_dev *rdev)
  88 {
  89         int ret;
  90         s32 volt_uV;
  91         struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
  92         const struct scmi_handle *handle = sreg->sdev->handle;
  93
  94         ret = handle->voltage_ops->level_get(handle, sreg->id, &volt_uV);
  95         if (ret)
  96                 return ret;
  97
  98         return sreg->desc.ops->map_voltage(rdev, volt_uV, volt_uV);
  99 }
 100
 101 static int scmi_reg_set_voltage_sel(struct regulator_dev *rdev,
 102                                     unsigned int selector)
 103 {
 104         s32 volt_uV;
 105         struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
 106         const struct scmi_handle *handle = sreg->sdev->handle;
 107
 108         volt_uV = sreg->desc.ops->list_voltage(rdev, selector);
 109         if (volt_uV <= 0)
 110                 return -EINVAL;
 111
 112         return handle->voltage_ops->level_set(handle, sreg->id, 0x0, volt_uV);
 113 }
 114
 115 static const struct regulator_ops scmi_reg_fixed_ops = {
 116         .enable = scmi_reg_enable,
 117         .disable = scmi_reg_disable,
 118         .is_enabled = scmi_reg_is_enabled,
 119 };
 120
 121 static const struct regulator_ops scmi_reg_linear_ops = {
 122         .enable = scmi_reg_enable,
 123         .disable = scmi_reg_disable,
 124         .is_enabled = scmi_reg_is_enabled,
 125         .get_voltage_sel = scmi_reg_get_voltage_sel,
 126         .set_voltage_sel = scmi_reg_set_voltage_sel,
 127         .list_voltage = regulator_list_voltage_linear,
 128         .map_voltage = regulator_map_voltage_linear,
 129 };
 130
 131 static const struct regulator_ops scmi_reg_discrete_ops = {
 132         .enable = scmi_reg_enable,
 133         .disable = scmi_reg_disable,
 134         .is_enabled = scmi_reg_is_enabled,
 135         .get_voltage_sel = scmi_reg_get_voltage_sel,
 136         .set_voltage_sel = scmi_reg_set_voltage_sel,
 137         .list_voltage = regulator_list_voltage_table,
 138         .map_voltage = regulator_map_voltage_iterate,
 139 };
 140
 141 static int
 142 scmi_config_linear_regulator_mappings(struct scmi_regulator *sreg,
 143                                       const struct scmi_voltage_info *vinfo)
 144 {
 145         s32 delta_uV;
 146
 147         /*
 148          * Note that SCMI voltage domains describable by linear ranges
 149          * (segments) {low, high, step} are guaranteed to come in one single
 150          * triplet by the SCMI Voltage Domain protocol support itself.
 151          */
 152
 153         delta_uV = (vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_HIGH] -
 154                         vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW]);
 155
 156         /* Rule out buggy negative-intervals answers from fw */
 157         if (delta_uV < 0) {
 158                 dev_err(&sreg->sdev->dev,
 159                         "Invalid volt-range %d-%duV for domain %d\n",
 160                         vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW],
 161                         vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_HIGH],
 162                         sreg->id);
 163                 return -EINVAL;
 164         }
 165
 166         if (!delta_uV) {
 167                 /* Just one fixed voltage exposed by SCMI */
 168                 sreg->desc.fixed_uV =
 169                         vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW];
 170                 sreg->desc.n_voltages = 1;
 171                 sreg->desc.ops = &scmi_reg_fixed_ops;
 172         } else {
 173                 /* One simple linear mapping. */
 174                 sreg->desc.min_uV =
 175                         vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW];
 176                 sreg->desc.uV_step =
 177                         vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_STEP];
 178                 sreg->desc.linear_min_sel = 0;
 179                 sreg->desc.n_voltages = (delta_uV / sreg->desc.uV_step) + 1;
 180                 sreg->desc.ops = &scmi_reg_linear_ops;
 181         }
 182
 183         return 0;
 184 }
 185
 186 static int
 187 scmi_config_discrete_regulator_mappings(struct scmi_regulator *sreg,
 188                                         const struct scmi_voltage_info *vinfo)
 189 {
 190         /* Discrete non linear levels are mapped to volt_table */
 191         sreg->desc.n_voltages = vinfo->num_levels;
 192
 193         if (sreg->desc.n_voltages > 1) {
 194                 sreg->desc.volt_table = (const unsigned int *)vinfo->levels_uv;
 195                 sreg->desc.ops = &scmi_reg_discrete_ops;
 196         } else {
 197                 sreg->desc.fixed_uV = vinfo->levels_uv[0];
 198                 sreg->desc.ops = &scmi_reg_fixed_ops;
 199         }
 200
 201         return 0;
 202 }
 203
 204 static int scmi_regulator_common_init(struct scmi_regulator *sreg)
 205 {
 206         int ret;
 207         const struct scmi_handle *handle = sreg->sdev->handle;
 208         struct device *dev = &sreg->sdev->dev;
 209         const struct scmi_voltage_info *vinfo;
 210
 211         vinfo = handle->voltage_ops->info_get(handle, sreg->id);
 212         if (!vinfo) {
 213                 dev_warn(dev, "Failure to get voltage domain %d\n",
 214                          sreg->id);
 215                 return -ENODEV;
 216         }
 217
 218         /*
 219          * Regulator framework does not fully support negative voltages
 220          * so we discard any voltage domain reported as supporting negative
 221          * voltages: as a consequence each levels_uv entry is guaranteed to
 222          * be non-negative from here on.
 223          */
 224         if (vinfo->negative_volts_allowed) {
 225                 dev_warn(dev, "Negative voltages NOT supported...skip %s\n",
 226                          sreg->of_node->full_name);
 227                 return -EOPNOTSUPP;
 228         }
 229
 230         sreg->desc.name = devm_kasprintf(dev, GFP_KERNEL, "%s", vinfo->name);
 231         if (!sreg->desc.name)
 232                 return -ENOMEM;
 233
 234         sreg->desc.id = sreg->id;
 235         sreg->desc.type = REGULATOR_VOLTAGE;
 236         sreg->desc.owner = THIS_MODULE;
 237         sreg->desc.of_match_full_name = true;
 238         sreg->desc.of_match = sreg->of_node->full_name;
 239         sreg->desc.regulators_node = "regulators";
 240         if (vinfo->segmented)
 241                 ret = scmi_config_linear_regulator_mappings(sreg, vinfo);
 242         else
 243                 ret = scmi_config_discrete_regulator_mappings(sreg, vinfo);
 244         if (ret)
 245                 return ret;
 246
 247         /*
 248          * Using the scmi device here to have DT searched from Voltage
 249          * protocol node down.
 250          */
 251         sreg->conf.dev = dev;
 252
 253         /* Store for later retrieval via rdev_get_drvdata() */
 254         sreg->conf.driver_data = sreg;
 255
 256         return 0;
 257 }
 258
 259 static int process_scmi_regulator_of_node(struct scmi_device *sdev,
 260                                           struct device_node *np,
 261                                           struct scmi_regulator_info *rinfo)
 262 {
 263         u32 dom, ret;
 264
 265         ret = of_property_read_u32(np, "reg", &dom);
 266         if (ret)
 267                 return ret;
 268
 269         if (dom >= rinfo->num_doms)
 270                 return -ENODEV;
 271
 272         if (rinfo->sregv[dom]) {
 273                 dev_err(&sdev->dev,
 274                         "SCMI Voltage Domain %d already in use. Skipping: %s\n",
 275                         dom, np->full_name);
 276                 return -EINVAL;
 277         }
 278
 279         rinfo->sregv[dom] = devm_kzalloc(&sdev->dev,
 280                                          sizeof(struct scmi_regulator),
 281                                          GFP_KERNEL);
 282         if (!rinfo->sregv[dom])
 283                 return -ENOMEM;
 284
 285         rinfo->sregv[dom]->id = dom;
 286         rinfo->sregv[dom]->sdev = sdev;
 287
 288         /* get hold of good nodes */
 289         of_node_get(np);
 290         rinfo->sregv[dom]->of_node = np;
 291
 292         dev_dbg(&sdev->dev,
 293                 "Found SCMI Regulator entry -- OF node [%d] -> %s\n",
 294                 dom, np->full_name);
 295
 296         return 0;
 297 }
 298
 299 static int scmi_regulator_probe(struct scmi_device *sdev)
 300 {
 301         int d, ret, num_doms;
 302         struct device_node *np, *child;
 303         const struct scmi_handle *handle = sdev->handle;
 304         struct scmi_regulator_info *rinfo;
 305
 306         if (!handle || !handle->voltage_ops)
 307                 return -ENODEV;
 308
 309         num_doms = handle->voltage_ops->num_domains_get(handle);
 310         if (num_doms <= 0) {
 311                 if (!num_doms) {
 312                         dev_err(&sdev->dev,
 313                                 "number of voltage domains invalid\n");
 314                         num_doms = -EINVAL;
 315                 } else {
 316                         dev_err(&sdev->dev,
 317                                 "failed to get voltage domains - err:%d\n",
 318                                 num_doms);
 319                 }
 320
 321                 return num_doms;
 322         }
 323
 324         rinfo = devm_kzalloc(&sdev->dev, sizeof(*rinfo), GFP_KERNEL);
 325         if (!rinfo)
 326                 return -ENOMEM;
 327
 328         /* Allocate pointers array for all possible domains */
 329         rinfo->sregv = devm_kcalloc(&sdev->dev, num_doms,
 330                                     sizeof(void *), GFP_KERNEL);
 331         if (!rinfo->sregv)
 332                 return -ENOMEM;
 333
 334         rinfo->num_doms = num_doms;
 335
 336         /*
 337          * Start collecting into rinfo->sregv possibly good SCMI Regulators as
 338          * described by a well-formed DT entry and associated with an existing
 339          * plausible SCMI Voltage Domain number, all belonging to this SCMI
 340          * platform instance node (handle->dev->of_node).
 341          */
 342         np = of_find_node_by_name(handle->dev->of_node, "regulators");
 343         for_each_child_of_node(np, child) {
 344                 ret = process_scmi_regulator_of_node(sdev, child, rinfo);
 345                 /* abort on any mem issue */
 346                 if (ret == -ENOMEM) {
 347                         of_node_put(child);
 348                         return ret;
 349                 }
 350         }
 351
 352         /*
 353          * Register a regulator for each valid regulator-DT-entry that we
 354          * can successfully reach via SCMI and has a valid associated voltage
 355          * domain.
 356          */
 357         for (d = 0; d < num_doms; d++) {
 358                 struct scmi_regulator *sreg = rinfo->sregv[d];
 359
 360                 /* Skip empty slots */
 361                 if (!sreg)
 362                         continue;
 363
 364                 ret = scmi_regulator_common_init(sreg);
 365                 /* Skip invalid voltage domains */
 366                 if (ret)
 367                         continue;
 368
 369                 sreg->rdev = devm_regulator_register(&sdev->dev, &sreg->desc,
 370                                                      &sreg->conf);
 371                 if (IS_ERR(sreg->rdev)) {
 372                         sreg->rdev = NULL;
 373                         continue;
 374                 }
 375
 376                 dev_info(&sdev->dev,
 377                          "Regulator %s registered for domain [%d]\n",
 378                          sreg->desc.name, sreg->id);
 379         }
 380
 381         dev_set_drvdata(&sdev->dev, rinfo);
 382
 383         return 0;
 384 }
 385
 386 static void scmi_regulator_remove(struct scmi_device *sdev)
 387 {
 388         int d;
 389         struct scmi_regulator_info *rinfo;
 390
 391         rinfo = dev_get_drvdata(&sdev->dev);
 392         if (!rinfo)
 393                 return;
 394
 395         for (d = 0; d < rinfo->num_doms; d++) {
 396                 if (!rinfo->sregv[d])
 397                         continue;
 398                 of_node_put(rinfo->sregv[d]->of_node);
 399         }
 400 }
 401
 402 static const struct scmi_device_id scmi_regulator_id_table[] = {
 403         { SCMI_PROTOCOL_VOLTAGE,  "regulator" },
 404         { },
 405 };
 406 MODULE_DEVICE_TABLE(scmi, scmi_regulator_id_table);
 407
 408 static struct scmi_driver scmi_drv = {
 409         .name           = "scmi-regulator",
 410         .probe          = scmi_regulator_probe,
 411         .remove         = scmi_regulator_remove,
 412         .id_table       = scmi_regulator_id_table,
 413 };
 414
 415 module_scmi_driver(scmi_drv);
 416
 417 MODULE_AUTHOR("Cristian Marussi <cristian.marussi@arm.com>");
 418 MODULE_DESCRIPTION("ARM SCMI regulator driver");
 419 MODULE_LICENSE("GPL v2");