drivers/opp/of.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Generic OPP OF helpers
   4  *
   5  * Copyright (C) 2009-2010 Texas Instruments Incorporated.
   6  *      Nishanth Menon
   7  *      Romit Dasgupta
   8  *      Kevin Hilman
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/cpu.h>
  14 #include <linux/errno.h>
  15 #include <linux/device.h>
  16 #include <linux/of_device.h>
  17 #include <linux/pm_domain.h>
  18 #include <linux/slab.h>
  19 #include <linux/export.h>
  20 #include <linux/energy_model.h>
  21
  22 #include "opp.h"
  23
  24 /*
  25  * Returns opp descriptor node for a device node, caller must
  26  * do of_node_put().
  27  */
  28 static struct device_node *_opp_of_get_opp_desc_node(struct device_node *np,
  29                                                      int index)
  30 {
  31         /* "operating-points-v2" can be an array for power domain providers */
  32         return of_parse_phandle(np, "operating-points-v2", index);
  33 }
  34
  35 /* Returns opp descriptor node for a device, caller must do of_node_put() */
  36 struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev)
  37 {
  38         return _opp_of_get_opp_desc_node(dev->of_node, 0);
  39 }
  40 EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_opp_desc_node);
  41
  42 struct opp_table *_managed_opp(struct device *dev, int index)
  43 {
  44         struct opp_table *opp_table, *managed_table = NULL;
  45         struct device_node *np;
  46
  47         np = _opp_of_get_opp_desc_node(dev->of_node, index);
  48         if (!np)
  49                 return NULL;
  50
  51         list_for_each_entry(opp_table, &opp_tables, node) {
  52                 if (opp_table->np == np) {
  53                         /*
  54                          * Multiple devices can point to the same OPP table and
  55                          * so will have same node-pointer, np.
  56                          *
  57                          * But the OPPs will be considered as shared only if the
  58                          * OPP table contains a "opp-shared" property.
  59                          */
  60                         if (opp_table->shared_opp == OPP_TABLE_ACCESS_SHARED) {
  61                                 _get_opp_table_kref(opp_table);
  62                                 managed_table = opp_table;
  63                         }
  64
  65                         break;
  66                 }
  67         }
  68
  69         of_node_put(np);
  70
  71         return managed_table;
  72 }
  73
  74 /* The caller must call dev_pm_opp_put() after the OPP is used */
  75 static struct dev_pm_opp *_find_opp_of_np(struct opp_table *opp_table,
  76                                           struct device_node *opp_np)
  77 {
  78         struct dev_pm_opp *opp;
  79
  80         mutex_lock(&opp_table->lock);
  81
  82         list_for_each_entry(opp, &opp_table->opp_list, node) {
  83                 if (opp->np == opp_np) {
  84                         dev_pm_opp_get(opp);
  85                         mutex_unlock(&opp_table->lock);
  86                         return opp;
  87                 }
  88         }
  89
  90         mutex_unlock(&opp_table->lock);
  91
  92         return NULL;
  93 }
  94
  95 static struct device_node *of_parse_required_opp(struct device_node *np,
  96                                                  int index)
  97 {
  98         struct device_node *required_np;
  99
 100         required_np = of_parse_phandle(np, "required-opps", index);
 101         if (unlikely(!required_np)) {
 102                 pr_err("%s: Unable to parse required-opps: %pOF, index: %d\n",
 103                        __func__, np, index);
 104         }
 105
 106         return required_np;
 107 }
 108
 109 /* The caller must call dev_pm_opp_put_opp_table() after the table is used */
 110 static struct opp_table *_find_table_of_opp_np(struct device_node *opp_np)
 111 {
 112         struct opp_table *opp_table;
 113         struct device_node *opp_table_np;
 114
 115         opp_table_np = of_get_parent(opp_np);
 116         if (!opp_table_np)
 117                 goto err;
 118
 119         /* It is safe to put the node now as all we need now is its address */
 120         of_node_put(opp_table_np);
 121
 122         mutex_lock(&opp_table_lock);
 123         list_for_each_entry(opp_table, &opp_tables, node) {
 124                 if (opp_table_np == opp_table->np) {
 125                         _get_opp_table_kref(opp_table);
 126                         mutex_unlock(&opp_table_lock);
 127                         return opp_table;
 128                 }
 129         }
 130         mutex_unlock(&opp_table_lock);
 131
 132 err:
 133         return ERR_PTR(-ENODEV);
 134 }
 135
 136 /* Free resources previously acquired by _opp_table_alloc_required_tables() */
 137 static void _opp_table_free_required_tables(struct opp_table *opp_table)
 138 {
 139         struct opp_table **required_opp_tables = opp_table->required_opp_tables;
 140         int i;
 141
 142         if (!required_opp_tables)
 143                 return;
 144
 145         for (i = 0; i < opp_table->required_opp_count; i++) {
 146                 if (IS_ERR_OR_NULL(required_opp_tables[i]))
 147                         continue;
 148
 149                 dev_pm_opp_put_opp_table(required_opp_tables[i]);
 150         }
 151
 152         kfree(required_opp_tables);
 153
 154         opp_table->required_opp_count = 0;
 155         opp_table->required_opp_tables = NULL;
 156         list_del(&opp_table->lazy);
 157 }
 158
 159 /*
 160  * Populate all devices and opp tables which are part of "required-opps" list.
 161  * Checking only the first OPP node should be enough.
 162  */
 163 static void _opp_table_alloc_required_tables(struct opp_table *opp_table,
 164                                              struct device *dev,
 165                                              struct device_node *opp_np)
 166 {
 167         struct opp_table **required_opp_tables;
 168         struct device_node *required_np, *np;
 169         bool lazy = false;
 170         int count, i;
 171
 172         /* Traversing the first OPP node is all we need */
 173         np = of_get_next_available_child(opp_np, NULL);
 174         if (!np) {
 175                 dev_warn(dev, "Empty OPP table\n");
 176
 177                 return;
 178         }
 179
 180         count = of_count_phandle_with_args(np, "required-opps", NULL);
 181         if (!count)
 182                 goto put_np;
 183
 184         required_opp_tables = kcalloc(count, sizeof(*required_opp_tables),
 185                                       GFP_KERNEL);
 186         if (!required_opp_tables)
 187                 goto put_np;
 188
 189         opp_table->required_opp_tables = required_opp_tables;
 190         opp_table->required_opp_count = count;
 191
 192         for (i = 0; i < count; i++) {
 193                 required_np = of_parse_required_opp(np, i);
 194                 if (!required_np)
 195                         goto free_required_tables;
 196
 197                 required_opp_tables[i] = _find_table_of_opp_np(required_np);
 198                 of_node_put(required_np);
 199
 200                 if (IS_ERR(required_opp_tables[i]))
 201                         lazy = true;
 202         }
 203
 204         /* Let's do the linking later on */
 205         if (lazy)
 206                 list_add(&opp_table->lazy, &lazy_opp_tables);
 207
 208         goto put_np;
 209
 210 free_required_tables:
 211         _opp_table_free_required_tables(opp_table);
 212 put_np:
 213         of_node_put(np);
 214 }
 215
 216 void _of_init_opp_table(struct opp_table *opp_table, struct device *dev,
 217                         int index)
 218 {
 219         struct device_node *np, *opp_np;
 220         u32 val;
 221
 222         /*
 223          * Only required for backward compatibility with v1 bindings, but isn't
 224          * harmful for other cases. And so we do it unconditionally.
 225          */
 226         np = of_node_get(dev->of_node);
 227         if (!np)
 228                 return;
 229
 230         if (!of_property_read_u32(np, "clock-latency", &val))
 231                 opp_table->clock_latency_ns_max = val;
 232         of_property_read_u32(np, "voltage-tolerance",
 233                              &opp_table->voltage_tolerance_v1);
 234
 235         if (of_find_property(np, "#power-domain-cells", NULL))
 236                 opp_table->is_genpd = true;
 237
 238         /* Get OPP table node */
 239         opp_np = _opp_of_get_opp_desc_node(np, index);
 240         of_node_put(np);
 241
 242         if (!opp_np)
 243                 return;
 244
 245         if (of_property_read_bool(opp_np, "opp-shared"))
 246                 opp_table->shared_opp = OPP_TABLE_ACCESS_SHARED;
 247         else
 248                 opp_table->shared_opp = OPP_TABLE_ACCESS_EXCLUSIVE;
 249
 250         opp_table->np = opp_np;
 251
 252         _opp_table_alloc_required_tables(opp_table, dev, opp_np);
 253         of_node_put(opp_np);
 254 }
 255
 256 void _of_clear_opp_table(struct opp_table *opp_table)
 257 {
 258         _opp_table_free_required_tables(opp_table);
 259 }
 260
 261 /*
 262  * Release all resources previously acquired with a call to
 263  * _of_opp_alloc_required_opps().
 264  */
 265 void _of_opp_free_required_opps(struct opp_table *opp_table,
 266                                 struct dev_pm_opp *opp)
 267 {
 268         struct dev_pm_opp **required_opps = opp->required_opps;
 269         int i;
 270
 271         if (!required_opps)
 272                 return;
 273
 274         for (i = 0; i < opp_table->required_opp_count; i++) {
 275                 if (!required_opps[i])
 276                         continue;
 277
 278                 /* Put the reference back */
 279                 dev_pm_opp_put(required_opps[i]);
 280         }
 281
 282         opp->required_opps = NULL;
 283         kfree(required_opps);
 284 }
 285
 286 /* Populate all required OPPs which are part of "required-opps" list */
 287 static int _of_opp_alloc_required_opps(struct opp_table *opp_table,
 288                                        struct dev_pm_opp *opp)
 289 {
 290         struct dev_pm_opp **required_opps;
 291         struct opp_table *required_table;
 292         struct device_node *np;
 293         int i, ret, count = opp_table->required_opp_count;
 294
 295         if (!count)
 296                 return 0;
 297
 298         required_opps = kcalloc(count, sizeof(*required_opps), GFP_KERNEL);
 299         if (!required_opps)
 300                 return -ENOMEM;
 301
 302         opp->required_opps = required_opps;
 303
 304         for (i = 0; i < count; i++) {
 305                 required_table = opp_table->required_opp_tables[i];
 306
 307                 /* Required table not added yet, we will link later */
 308                 if (IS_ERR_OR_NULL(required_table))
 309                         continue;
 310
 311                 np = of_parse_required_opp(opp->np, i);
 312                 if (unlikely(!np)) {
 313                         ret = -ENODEV;
 314                         goto free_required_opps;
 315                 }
 316
 317                 required_opps[i] = _find_opp_of_np(required_table, np);
 318                 of_node_put(np);
 319
 320                 if (!required_opps[i]) {
 321                         pr_err("%s: Unable to find required OPP node: %pOF (%d)\n",
 322                                __func__, opp->np, i);
 323                         ret = -ENODEV;
 324                         goto free_required_opps;
 325                 }
 326         }
 327
 328         return 0;
 329
 330 free_required_opps:
 331         _of_opp_free_required_opps(opp_table, opp);
 332
 333         return ret;
 334 }
 335
 336 /* Link required OPPs for an individual OPP */
 337 static int lazy_link_required_opps(struct opp_table *opp_table,
 338                                    struct opp_table *new_table, int index)
 339 {
 340         struct device_node *required_np;
 341         struct dev_pm_opp *opp;
 342
 343         list_for_each_entry(opp, &opp_table->opp_list, node) {
 344                 required_np = of_parse_required_opp(opp->np, index);
 345                 if (unlikely(!required_np))
 346                         return -ENODEV;
 347
 348                 opp->required_opps[index] = _find_opp_of_np(new_table, required_np);
 349                 of_node_put(required_np);
 350
 351                 if (!opp->required_opps[index]) {
 352                         pr_err("%s: Unable to find required OPP node: %pOF (%d)\n",
 353                                __func__, opp->np, index);
 354                         return -ENODEV;
 355                 }
 356         }
 357
 358         return 0;
 359 }
 360
 361 /* Link required OPPs for all OPPs of the newly added OPP table */
 362 static void lazy_link_required_opp_table(struct opp_table *new_table)
 363 {
 364         struct opp_table *opp_table, *temp, **required_opp_tables;
 365         struct device_node *required_np, *opp_np, *required_table_np;
 366         struct dev_pm_opp *opp;
 367         int i, ret;
 368
 369         mutex_lock(&opp_table_lock);
 370
 371         list_for_each_entry_safe(opp_table, temp, &lazy_opp_tables, lazy) {
 372                 bool lazy = false;
 373
 374                 /* opp_np can't be invalid here */
 375                 opp_np = of_get_next_available_child(opp_table->np, NULL);
 376
 377                 for (i = 0; i < opp_table->required_opp_count; i++) {
 378                         required_opp_tables = opp_table->required_opp_tables;
 379
 380                         /* Required opp-table is already parsed */
 381                         if (!IS_ERR(required_opp_tables[i]))
 382                                 continue;
 383
 384                         /* required_np can't be invalid here */
 385                         required_np = of_parse_required_opp(opp_np, i);
 386                         required_table_np = of_get_parent(required_np);
 387
 388                         of_node_put(required_table_np);
 389                         of_node_put(required_np);
 390
 391                         /*
 392                          * Newly added table isn't the required opp-table for
 393                          * opp_table.
 394                          */
 395                         if (required_table_np != new_table->np) {
 396                                 lazy = true;
 397                                 continue;
 398                         }
 399
 400                         required_opp_tables[i] = new_table;
 401                         _get_opp_table_kref(new_table);
 402
 403                         /* Link OPPs now */
 404                         ret = lazy_link_required_opps(opp_table, new_table, i);
 405                         if (ret) {
 406                                 /* The OPPs will be marked unusable */
 407                                 lazy = false;
 408                                 break;
 409                         }
 410                 }
 411
 412                 of_node_put(opp_np);
 413
 414                 /* All required opp-tables found, remove from lazy list */
 415                 if (!lazy) {
 416                         list_del_init(&opp_table->lazy);
 417
 418                         list_for_each_entry(opp, &opp_table->opp_list, node)
 419                                 _required_opps_available(opp, opp_table->required_opp_count);
 420                 }
 421         }
 422
 423         mutex_unlock(&opp_table_lock);
 424 }
 425
 426 static int _bandwidth_supported(struct device *dev, struct opp_table *opp_table)
 427 {
 428         struct device_node *np, *opp_np;
 429         struct property *prop;
 430
 431         if (!opp_table) {
 432                 np = of_node_get(dev->of_node);
 433                 if (!np)
 434                         return -ENODEV;
 435
 436                 opp_np = _opp_of_get_opp_desc_node(np, 0);
 437                 of_node_put(np);
 438         } else {
 439                 opp_np = of_node_get(opp_table->np);
 440         }
 441
 442         /* Lets not fail in case we are parsing opp-v1 bindings */
 443         if (!opp_np)
 444                 return 0;
 445
 446         /* Checking only first OPP is sufficient */
 447         np = of_get_next_available_child(opp_np, NULL);
 448         if (!np) {
 449                 dev_err(dev, "OPP table empty\n");
 450                 return -EINVAL;
 451         }
 452         of_node_put(opp_np);
 453
 454         prop = of_find_property(np, "opp-peak-kBps", NULL);
 455         of_node_put(np);
 456
 457         if (!prop || !prop->length)
 458                 return 0;
 459
 460         return 1;
 461 }
 462
 463 int dev_pm_opp_of_find_icc_paths(struct device *dev,
 464                                  struct opp_table *opp_table)
 465 {
 466         struct device_node *np;
 467         int ret, i, count, num_paths;
 468         struct icc_path **paths;
 469
 470         ret = _bandwidth_supported(dev, opp_table);
 471         if (ret == -EINVAL)
 472                 return 0; /* Empty OPP table is a valid corner-case, let's not fail */
 473         else if (ret <= 0)
 474                 return ret;
 475
 476         ret = 0;
 477
 478         np = of_node_get(dev->of_node);
 479         if (!np)
 480                 return 0;
 481
 482         count = of_count_phandle_with_args(np, "interconnects",
 483                                            "#interconnect-cells");
 484         of_node_put(np);
 485         if (count < 0)
 486                 return 0;
 487
 488         /* two phandles when #interconnect-cells = <1> */
 489         if (count % 2) {
 490                 dev_err(dev, "%s: Invalid interconnects values\n", __func__);
 491                 return -EINVAL;
 492         }
 493
 494         num_paths = count / 2;
 495         paths = kcalloc(num_paths, sizeof(*paths), GFP_KERNEL);
 496         if (!paths)
 497                 return -ENOMEM;
 498
 499         for (i = 0; i < num_paths; i++) {
 500                 paths[i] = of_icc_get_by_index(dev, i);
 501                 if (IS_ERR(paths[i])) {
 502                         ret = PTR_ERR(paths[i]);
 503                         if (ret != -EPROBE_DEFER) {
 504                                 dev_err(dev, "%s: Unable to get path%d: %d\n",
 505                                         __func__, i, ret);
 506                         }
 507                         goto err;
 508                 }
 509         }
 510
 511         if (opp_table) {
 512                 opp_table->paths = paths;
 513                 opp_table->path_count = num_paths;
 514                 return 0;
 515         }
 516
 517 err:
 518         while (i--)
 519                 icc_put(paths[i]);
 520
 521         kfree(paths);
 522
 523         return ret;
 524 }
 525 EXPORT_SYMBOL_GPL(dev_pm_opp_of_find_icc_paths);
 526
 527 static bool _opp_is_supported(struct device *dev, struct opp_table *opp_table,
 528                               struct device_node *np)
 529 {
 530         unsigned int levels = opp_table->supported_hw_count;
 531         int count, versions, ret, i, j;
 532         u32 val;
 533
 534         if (!opp_table->supported_hw) {
 535                 /*
 536                  * In the case that no supported_hw has been set by the
 537                  * platform but there is an opp-supported-hw value set for
 538                  * an OPP then the OPP should not be enabled as there is
 539                  * no way to see if the hardware supports it.
 540                  */
 541                 if (of_find_property(np, "opp-supported-hw", NULL))
 542                         return false;
 543                 else
 544                         return true;
 545         }
 546
 547         count = of_property_count_u32_elems(np, "opp-supported-hw");
 548         if (count <= 0 || count % levels) {
 549                 dev_err(dev, "%s: Invalid opp-supported-hw property (%d)\n",
 550                         __func__, count);
 551                 return false;
 552         }
 553
 554         versions = count / levels;
 555
 556         /* All levels in at least one of the versions should match */
 557         for (i = 0; i < versions; i++) {
 558                 bool supported = true;
 559
 560                 for (j = 0; j < levels; j++) {
 561                         ret = of_property_read_u32_index(np, "opp-supported-hw",
 562                                                          i * levels + j, &val);
 563                         if (ret) {
 564                                 dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n",
 565                                          __func__, i * levels + j, ret);
 566                                 return false;
 567                         }
 568
 569                         /* Check if the level is supported */
 570                         if (!(val & opp_table->supported_hw[j])) {
 571                                 supported = false;
 572                                 break;
 573                         }
 574                 }
 575
 576                 if (supported)
 577                         return true;
 578         }
 579
 580         return false;
 581 }
 582
 583 static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev,
 584                               struct opp_table *opp_table)
 585 {
 586         u32 *microvolt, *microamp = NULL;
 587         int supplies = opp_table->regulator_count, vcount, icount, ret, i, j;
 588         struct property *prop = NULL;
 589         char name[NAME_MAX];
 590
 591         /* Search for "opp-microvolt-<name>" */
 592         if (opp_table->prop_name) {
 593                 snprintf(name, sizeof(name), "opp-microvolt-%s",
 594                          opp_table->prop_name);
 595                 prop = of_find_property(opp->np, name, NULL);
 596         }
 597
 598         if (!prop) {
 599                 /* Search for "opp-microvolt" */
 600                 sprintf(name, "opp-microvolt");
 601                 prop = of_find_property(opp->np, name, NULL);
 602
 603                 /* Missing property isn't a problem, but an invalid entry is */
 604                 if (!prop) {
 605                         if (unlikely(supplies == -1)) {
 606                                 /* Initialize regulator_count */
 607                                 opp_table->regulator_count = 0;
 608                                 return 0;
 609                         }
 610
 611                         if (!supplies)
 612                                 return 0;
 613
 614                         dev_err(dev, "%s: opp-microvolt missing although OPP managing regulators\n",
 615                                 __func__);
 616                         return -EINVAL;
 617                 }
 618         }
 619
 620         if (unlikely(supplies == -1)) {
 621                 /* Initialize regulator_count */
 622                 supplies = opp_table->regulator_count = 1;
 623         } else if (unlikely(!supplies)) {
 624                 dev_err(dev, "%s: opp-microvolt wasn't expected\n", __func__);
 625                 return -EINVAL;
 626         }
 627
 628         vcount = of_property_count_u32_elems(opp->np, name);
 629         if (vcount < 0) {
 630                 dev_err(dev, "%s: Invalid %s property (%d)\n",
 631                         __func__, name, vcount);
 632                 return vcount;
 633         }
 634
 635         /* There can be one or three elements per supply */
 636         if (vcount != supplies && vcount != supplies * 3) {
 637                 dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n",
 638                         __func__, name, vcount, supplies);
 639                 return -EINVAL;
 640         }
 641
 642         microvolt = kmalloc_array(vcount, sizeof(*microvolt), GFP_KERNEL);
 643         if (!microvolt)
 644                 return -ENOMEM;
 645
 646         ret = of_property_read_u32_array(opp->np, name, microvolt, vcount);
 647         if (ret) {
 648                 dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret);
 649                 ret = -EINVAL;
 650                 goto free_microvolt;
 651         }
 652
 653         /* Search for "opp-microamp-<name>" */
 654         prop = NULL;
 655         if (opp_table->prop_name) {
 656                 snprintf(name, sizeof(name), "opp-microamp-%s",
 657                          opp_table->prop_name);
 658                 prop = of_find_property(opp->np, name, NULL);
 659         }
 660
 661         if (!prop) {
 662                 /* Search for "opp-microamp" */
 663                 sprintf(name, "opp-microamp");
 664                 prop = of_find_property(opp->np, name, NULL);
 665         }
 666
 667         if (prop) {
 668                 icount = of_property_count_u32_elems(opp->np, name);
 669                 if (icount < 0) {
 670                         dev_err(dev, "%s: Invalid %s property (%d)\n", __func__,
 671                                 name, icount);
 672                         ret = icount;
 673                         goto free_microvolt;
 674                 }
 675
 676                 if (icount != supplies) {
 677                         dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n",
 678                                 __func__, name, icount, supplies);
 679                         ret = -EINVAL;
 680                         goto free_microvolt;
 681                 }
 682
 683                 microamp = kmalloc_array(icount, sizeof(*microamp), GFP_KERNEL);
 684                 if (!microamp) {
 685                         ret = -EINVAL;
 686                         goto free_microvolt;
 687                 }
 688
 689                 ret = of_property_read_u32_array(opp->np, name, microamp,
 690                                                  icount);
 691                 if (ret) {
 692                         dev_err(dev, "%s: error parsing %s: %d\n", __func__,
 693                                 name, ret);
 694                         ret = -EINVAL;
 695                         goto free_microamp;
 696                 }
 697         }
 698
 699         for (i = 0, j = 0; i < supplies; i++) {
 700                 opp->supplies[i].u_volt = microvolt[j++];
 701
 702                 if (vcount == supplies) {
 703                         opp->supplies[i].u_volt_min = opp->supplies[i].u_volt;
 704                         opp->supplies[i].u_volt_max = opp->supplies[i].u_volt;
 705                 } else {
 706                         opp->supplies[i].u_volt_min = microvolt[j++];
 707                         opp->supplies[i].u_volt_max = microvolt[j++];
 708                 }
 709
 710                 if (microamp)
 711                         opp->supplies[i].u_amp = microamp[i];
 712         }
 713
 714 free_microamp:
 715         kfree(microamp);
 716 free_microvolt:
 717         kfree(microvolt);
 718
 719         return ret;
 720 }
 721
 722 /**
 723  * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
 724  *                                entries
 725  * @dev:        device pointer used to lookup OPP table.
 726  *
 727  * Free OPPs created using static entries present in DT.
 728  */
 729 void dev_pm_opp_of_remove_table(struct device *dev)
 730 {
 731         dev_pm_opp_remove_table(dev);
 732 }
 733 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);
 734
 735 static int _read_bw(struct dev_pm_opp *new_opp, struct opp_table *table,
 736                     struct device_node *np, bool peak)
 737 {
 738         const char *name = peak ? "opp-peak-kBps" : "opp-avg-kBps";
 739         struct property *prop;
 740         int i, count, ret;
 741         u32 *bw;
 742
 743         prop = of_find_property(np, name, NULL);
 744         if (!prop)
 745                 return -ENODEV;
 746
 747         count = prop->length / sizeof(u32);
 748         if (table->path_count != count) {
 749                 pr_err("%s: Mismatch between %s and paths (%d %d)\n",
 750                                 __func__, name, count, table->path_count);
 751                 return -EINVAL;
 752         }
 753
 754         bw = kmalloc_array(count, sizeof(*bw), GFP_KERNEL);
 755         if (!bw)
 756                 return -ENOMEM;
 757
 758         ret = of_property_read_u32_array(np, name, bw, count);
 759         if (ret) {
 760                 pr_err("%s: Error parsing %s: %d\n", __func__, name, ret);
 761                 goto out;
 762         }
 763
 764         for (i = 0; i < count; i++) {
 765                 if (peak)
 766                         new_opp->bandwidth[i].peak = kBps_to_icc(bw[i]);
 767                 else
 768                         new_opp->bandwidth[i].avg = kBps_to_icc(bw[i]);
 769         }
 770
 771 out:
 772         kfree(bw);
 773         return ret;
 774 }
 775
 776 static int _read_opp_key(struct dev_pm_opp *new_opp, struct opp_table *table,
 777                          struct device_node *np, bool *rate_not_available)
 778 {
 779         bool found = false;
 780         u64 rate;
 781         int ret;
 782
 783         ret = of_property_read_u64(np, "opp-hz", &rate);
 784         if (!ret) {
 785                 /*
 786                  * Rate is defined as an unsigned long in clk API, and so
 787                  * casting explicitly to its type. Must be fixed once rate is 64
 788                  * bit guaranteed in clk API.
 789                  */
 790                 new_opp->rate = (unsigned long)rate;
 791                 found = true;
 792         }
 793         *rate_not_available = !!ret;
 794
 795         /*
 796          * Bandwidth consists of peak and average (optional) values:
 797          * opp-peak-kBps = <path1_value path2_value>;
 798          * opp-avg-kBps = <path1_value path2_value>;
 799          */
 800         ret = _read_bw(new_opp, table, np, true);
 801         if (!ret) {
 802                 found = true;
 803                 ret = _read_bw(new_opp, table, np, false);
 804         }
 805
 806         /* The properties were found but we failed to parse them */
 807         if (ret && ret != -ENODEV)
 808                 return ret;
 809
 810         if (!of_property_read_u32(np, "opp-level", &new_opp->level))
 811                 found = true;
 812
 813         if (found)
 814                 return 0;
 815
 816         return ret;
 817 }
 818
 819 /**
 820  * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
 821  * @opp_table:  OPP table
 822  * @dev:        device for which we do this operation
 823  * @np:         device node
 824  *
 825  * This function adds an opp definition to the opp table and returns status. The
 826  * opp can be controlled using dev_pm_opp_enable/disable functions and may be
 827  * removed by dev_pm_opp_remove.
 828  *
 829  * Return:
 830  * Valid OPP pointer:
 831  *              On success
 832  * NULL:
 833  *              Duplicate OPPs (both freq and volt are same) and opp->available
 834  *              OR if the OPP is not supported by hardware.
 835  * ERR_PTR(-EEXIST):
 836  *              Freq are same and volt are different OR
 837  *              Duplicate OPPs (both freq and volt are same) and !opp->available
 838  * ERR_PTR(-ENOMEM):
 839  *              Memory allocation failure
 840  * ERR_PTR(-EINVAL):
 841  *              Failed parsing the OPP node
 842  */
 843 static struct dev_pm_opp *_opp_add_static_v2(struct opp_table *opp_table,
 844                 struct device *dev, struct device_node *np)
 845 {
 846         struct dev_pm_opp *new_opp;
 847         u32 val;
 848         int ret;
 849         bool rate_not_available = false;
 850
 851         new_opp = _opp_allocate(opp_table);
 852         if (!new_opp)
 853                 return ERR_PTR(-ENOMEM);
 854
 855         ret = _read_opp_key(new_opp, opp_table, np, &rate_not_available);
 856         if (ret < 0) {
 857                 dev_err(dev, "%s: opp key field not found\n", __func__);
 858                 goto free_opp;
 859         }
 860
 861         /* Check if the OPP supports hardware's hierarchy of versions or not */
 862         if (!_opp_is_supported(dev, opp_table, np)) {
 863                 dev_dbg(dev, "OPP not supported by hardware: %lu\n",
 864                         new_opp->rate);
 865                 goto free_opp;
 866         }
 867
 868         new_opp->turbo = of_property_read_bool(np, "turbo-mode");
 869
 870         new_opp->np = np;
 871         new_opp->dynamic = false;
 872         new_opp->available = true;
 873
 874         ret = _of_opp_alloc_required_opps(opp_table, new_opp);
 875         if (ret)
 876                 goto free_opp;
 877
 878         if (!of_property_read_u32(np, "clock-latency-ns", &val))
 879                 new_opp->clock_latency_ns = val;
 880
 881         ret = opp_parse_supplies(new_opp, dev, opp_table);
 882         if (ret)
 883                 goto free_required_opps;
 884
 885         if (opp_table->is_genpd)
 886                 new_opp->pstate = pm_genpd_opp_to_performance_state(dev, new_opp);
 887
 888         ret = _opp_add(dev, new_opp, opp_table, rate_not_available);
 889         if (ret) {
 890                 /* Don't return error for duplicate OPPs */
 891                 if (ret == -EBUSY)
 892                         ret = 0;
 893                 goto free_required_opps;
 894         }
 895
 896         /* OPP to select on device suspend */
 897         if (of_property_read_bool(np, "opp-suspend")) {
 898                 if (opp_table->suspend_opp) {
 899                         /* Pick the OPP with higher rate as suspend OPP */
 900                         if (new_opp->rate > opp_table->suspend_opp->rate) {
 901                                 opp_table->suspend_opp->suspend = false;
 902                                 new_opp->suspend = true;
 903                                 opp_table->suspend_opp = new_opp;
 904                         }
 905                 } else {
 906                         new_opp->suspend = true;
 907                         opp_table->suspend_opp = new_opp;
 908                 }
 909         }
 910
 911         if (new_opp->clock_latency_ns > opp_table->clock_latency_ns_max)
 912                 opp_table->clock_latency_ns_max = new_opp->clock_latency_ns;
 913
 914         pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu level:%u\n",
 915                  __func__, new_opp->turbo, new_opp->rate,
 916                  new_opp->supplies[0].u_volt, new_opp->supplies[0].u_volt_min,
 917                  new_opp->supplies[0].u_volt_max, new_opp->clock_latency_ns,
 918                  new_opp->level);
 919
 920         /*
 921          * Notify the changes in the availability of the operable
 922          * frequency/voltage list.
 923          */
 924         blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADD, new_opp);
 925         return new_opp;
 926
 927 free_required_opps:
 928         _of_opp_free_required_opps(opp_table, new_opp);
 929 free_opp:
 930         _opp_free(new_opp);
 931
 932         return ERR_PTR(ret);
 933 }
 934
 935 /* Initializes OPP tables based on new bindings */
 936 static int _of_add_opp_table_v2(struct device *dev, struct opp_table *opp_table)
 937 {
 938         struct device_node *np;
 939         int ret, count = 0;
 940         struct dev_pm_opp *opp;
 941
 942         /* OPP table is already initialized for the device */
 943         mutex_lock(&opp_table->lock);
 944         if (opp_table->parsed_static_opps) {
 945                 opp_table->parsed_static_opps++;
 946                 mutex_unlock(&opp_table->lock);
 947                 return 0;
 948         }
 949
 950         opp_table->parsed_static_opps = 1;
 951         mutex_unlock(&opp_table->lock);
 952
 953         /* We have opp-table node now, iterate over it and add OPPs */
 954         for_each_available_child_of_node(opp_table->np, np) {
 955                 opp = _opp_add_static_v2(opp_table, dev, np);
 956                 if (IS_ERR(opp)) {
 957                         ret = PTR_ERR(opp);
 958                         dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,
 959                                 ret);
 960                         of_node_put(np);
 961                         goto remove_static_opp;
 962                 } else if (opp) {
 963                         count++;
 964                 }
 965         }
 966
 967         /* There should be one of more OPP defined */
 968         if (WARN_ON(!count)) {
 969                 ret = -ENOENT;
 970                 goto remove_static_opp;
 971         }
 972
 973         list_for_each_entry(opp, &opp_table->opp_list, node) {
 974                 /* Any non-zero performance state would enable the feature */
 975                 if (opp->pstate) {
 976                         opp_table->genpd_performance_state = true;
 977                         break;
 978                 }
 979         }
 980
 981         lazy_link_required_opp_table(opp_table);
 982
 983         return 0;
 984
 985 remove_static_opp:
 986         _opp_remove_all_static(opp_table);
 987
 988         return ret;
 989 }
 990
 991 /* Initializes OPP tables based on old-deprecated bindings */
 992 static int _of_add_opp_table_v1(struct device *dev, struct opp_table *opp_table)
 993 {
 994         const struct property *prop;
 995         const __be32 *val;
 996         int nr, ret = 0;
 997
 998         mutex_lock(&opp_table->lock);
 999         if (opp_table->parsed_static_opps) {
1000                 opp_table->parsed_static_opps++;
1001                 mutex_unlock(&opp_table->lock);
1002                 return 0;
1003         }
1004
1005         opp_table->parsed_static_opps = 1;
1006         mutex_unlock(&opp_table->lock);
1007
1008         prop = of_find_property(dev->of_node, "operating-points", NULL);
1009         if (!prop) {
1010                 ret = -ENODEV;
1011                 goto remove_static_opp;
1012         }
1013         if (!prop->value) {
1014                 ret = -ENODATA;
1015                 goto remove_static_opp;
1016         }
1017
1018         /*
1019          * Each OPP is a set of tuples consisting of frequency and
1020          * voltage like <freq-kHz vol-uV>.
1021          */
1022         nr = prop->length / sizeof(u32);
1023         if (nr % 2) {
1024                 dev_err(dev, "%s: Invalid OPP table\n", __func__);
1025                 ret = -EINVAL;
1026                 goto remove_static_opp;
1027         }
1028
1029         val = prop->value;
1030         while (nr) {
1031                 unsigned long freq = be32_to_cpup(val++) * 1000;
1032                 unsigned long volt = be32_to_cpup(val++);
1033
1034                 ret = _opp_add_v1(opp_table, dev, freq, volt, false);
1035                 if (ret) {
1036                         dev_err(dev, "%s: Failed to add OPP %ld (%d)\n",
1037                                 __func__, freq, ret);
1038                         goto remove_static_opp;
1039                 }
1040                 nr -= 2;
1041         }
1042
1043         return 0;
1044
1045 remove_static_opp:
1046         _opp_remove_all_static(opp_table);
1047
1048         return ret;
1049 }
1050
1051 static int _of_add_table_indexed(struct device *dev, int index, bool getclk)
1052 {
1053         struct opp_table *opp_table;
1054         int ret, count;
1055
1056         if (index) {
1057                 /*
1058                  * If only one phandle is present, then the same OPP table
1059                  * applies for all index requests.
1060                  */
1061                 count = of_count_phandle_with_args(dev->of_node,
1062                                                    "operating-points-v2", NULL);
1063                 if (count == 1)
1064                         index = 0;
1065         }
1066
1067         opp_table = _add_opp_table_indexed(dev, index, getclk);
1068         if (IS_ERR(opp_table))
1069                 return PTR_ERR(opp_table);
1070
1071         /*
1072          * OPPs have two version of bindings now. Also try the old (v1)
1073          * bindings for backward compatibility with older dtbs.
1074          */
1075         if (opp_table->np)
1076                 ret = _of_add_opp_table_v2(dev, opp_table);
1077         else
1078                 ret = _of_add_opp_table_v1(dev, opp_table);
1079
1080         if (ret)
1081                 dev_pm_opp_put_opp_table(opp_table);
1082
1083         return ret;
1084 }
1085
1086 static void devm_pm_opp_of_table_release(void *data)
1087 {
1088         dev_pm_opp_of_remove_table(data);
1089 }
1090
1091 /**
1092  * devm_pm_opp_of_add_table() - Initialize opp table from device tree
1093  * @dev:        device pointer used to lookup OPP table.
1094  *
1095  * Register the initial OPP table with the OPP library for given device.
1096  *
1097  * The opp_table structure will be freed after the device is destroyed.
1098  *
1099  * Return:
1100  * 0            On success OR
1101  *              Duplicate OPPs (both freq and volt are same) and opp->available
1102  * -EEXIST      Freq are same and volt are different OR
1103  *              Duplicate OPPs (both freq and volt are same) and !opp->available
1104  * -ENOMEM      Memory allocation failure
1105  * -ENODEV      when 'operating-points' property is not found or is invalid data
1106  *              in device node.
1107  * -ENODATA     when empty 'operating-points' property is found
1108  * -EINVAL      when invalid entries are found in opp-v2 table
1109  */
1110 int devm_pm_opp_of_add_table(struct device *dev)
1111 {
1112         int ret;
1113
1114         ret = dev_pm_opp_of_add_table(dev);
1115         if (ret)
1116                 return ret;
1117
1118         return devm_add_action_or_reset(dev, devm_pm_opp_of_table_release, dev);
1119 }
1120 EXPORT_SYMBOL_GPL(devm_pm_opp_of_add_table);
1121
1122 /**
1123  * dev_pm_opp_of_add_table() - Initialize opp table from device tree
1124  * @dev:        device pointer used to lookup OPP table.
1125  *
1126  * Register the initial OPP table with the OPP library for given device.
1127  *
1128  * Return:
1129  * 0            On success OR
1130  *              Duplicate OPPs (both freq and volt are same) and opp->available
1131  * -EEXIST      Freq are same and volt are different OR
1132  *              Duplicate OPPs (both freq and volt are same) and !opp->available
1133  * -ENOMEM      Memory allocation failure
1134  * -ENODEV      when 'operating-points' property is not found or is invalid data
1135  *              in device node.
1136  * -ENODATA     when empty 'operating-points' property is found
1137  * -EINVAL      when invalid entries are found in opp-v2 table
1138  */
1139 int dev_pm_opp_of_add_table(struct device *dev)
1140 {
1141         return _of_add_table_indexed(dev, 0, true);
1142 }
1143 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);
1144
1145 /**
1146  * dev_pm_opp_of_add_table_indexed() - Initialize indexed opp table from device tree
1147  * @dev:        device pointer used to lookup OPP table.
1148  * @index:      Index number.
1149  *
1150  * Register the initial OPP table with the OPP library for given device only
1151  * using the "operating-points-v2" property.
1152  *
1153  * Return: Refer to dev_pm_opp_of_add_table() for return values.
1154  */
1155 int dev_pm_opp_of_add_table_indexed(struct device *dev, int index)
1156 {
1157         return _of_add_table_indexed(dev, index, true);
1158 }
1159 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_indexed);
1160
1161 /**
1162  * dev_pm_opp_of_add_table_noclk() - Initialize indexed opp table from device
1163  *              tree without getting clk for device.
1164  * @dev:        device pointer used to lookup OPP table.
1165  * @index:      Index number.
1166  *
1167  * Register the initial OPP table with the OPP library for given device only
1168  * using the "operating-points-v2" property. Do not try to get the clk for the
1169  * device.
1170  *
1171  * Return: Refer to dev_pm_opp_of_add_table() for return values.
1172  */
1173 int dev_pm_opp_of_add_table_noclk(struct device *dev, int index)
1174 {
1175         return _of_add_table_indexed(dev, index, false);
1176 }
1177 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_noclk);
1178
1179 /* CPU device specific helpers */
1180
1181 /**
1182  * dev_pm_opp_of_cpumask_remove_table() - Removes OPP table for @cpumask
1183  * @cpumask:    cpumask for which OPP table needs to be removed
1184  *
1185  * This removes the OPP tables for CPUs present in the @cpumask.
1186  * This should be used only to remove static entries created from DT.
1187  */
1188 void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask)
1189 {
1190         _dev_pm_opp_cpumask_remove_table(cpumask, -1);
1191 }
1192 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table);
1193
1194 /**
1195  * dev_pm_opp_of_cpumask_add_table() - Adds OPP table for @cpumask
1196  * @cpumask:    cpumask for which OPP table needs to be added.
1197  *
1198  * This adds the OPP tables for CPUs present in the @cpumask.
1199  */
1200 int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask)
1201 {
1202         struct device *cpu_dev;
1203         int cpu, ret;
1204
1205         if (WARN_ON(cpumask_empty(cpumask)))
1206                 return -ENODEV;
1207
1208         for_each_cpu(cpu, cpumask) {
1209                 cpu_dev = get_cpu_device(cpu);
1210                 if (!cpu_dev) {
1211                         pr_err("%s: failed to get cpu%d device\n", __func__,
1212                                cpu);
1213                         ret = -ENODEV;
1214                         goto remove_table;
1215                 }
1216
1217                 ret = dev_pm_opp_of_add_table(cpu_dev);
1218                 if (ret) {
1219                         /*
1220                          * OPP may get registered dynamically, don't print error
1221                          * message here.
1222                          */
1223                         pr_debug("%s: couldn't find opp table for cpu:%d, %d\n",
1224                                  __func__, cpu, ret);
1225
1226                         goto remove_table;
1227                 }
1228         }
1229
1230         return 0;
1231
1232 remove_table:
1233         /* Free all other OPPs */
1234         _dev_pm_opp_cpumask_remove_table(cpumask, cpu);
1235
1236         return ret;
1237 }
1238 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table);
1239
1240 /*
1241  * Works only for OPP v2 bindings.
1242  *
1243  * Returns -ENOENT if operating-points-v2 bindings aren't supported.
1244  */
1245 /**
1246  * dev_pm_opp_of_get_sharing_cpus() - Get cpumask of CPUs sharing OPPs with
1247  *                                    @cpu_dev using operating-points-v2
1248  *                                    bindings.
1249  *
1250  * @cpu_dev:    CPU device for which we do this operation
1251  * @cpumask:    cpumask to update with information of sharing CPUs
1252  *
1253  * This updates the @cpumask with CPUs that are sharing OPPs with @cpu_dev.
1254  *
1255  * Returns -ENOENT if operating-points-v2 isn't present for @cpu_dev.
1256  */
1257 int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev,
1258                                    struct cpumask *cpumask)
1259 {
1260         struct device_node *np, *tmp_np, *cpu_np;
1261         int cpu, ret = 0;
1262
1263         /* Get OPP descriptor node */
1264         np = dev_pm_opp_of_get_opp_desc_node(cpu_dev);
1265         if (!np) {
1266                 dev_dbg(cpu_dev, "%s: Couldn't find opp node.\n", __func__);
1267                 return -ENOENT;
1268         }
1269
1270         cpumask_set_cpu(cpu_dev->id, cpumask);
1271
1272         /* OPPs are shared ? */
1273         if (!of_property_read_bool(np, "opp-shared"))
1274                 goto put_cpu_node;
1275
1276         for_each_possible_cpu(cpu) {
1277                 if (cpu == cpu_dev->id)
1278                         continue;
1279
1280                 cpu_np = of_cpu_device_node_get(cpu);
1281                 if (!cpu_np) {
1282                         dev_err(cpu_dev, "%s: failed to get cpu%d node\n",
1283                                 __func__, cpu);
1284                         ret = -ENOENT;
1285                         goto put_cpu_node;
1286                 }
1287
1288                 /* Get OPP descriptor node */
1289                 tmp_np = _opp_of_get_opp_desc_node(cpu_np, 0);
1290                 of_node_put(cpu_np);
1291                 if (!tmp_np) {
1292                         pr_err("%pOF: Couldn't find opp node\n", cpu_np);
1293                         ret = -ENOENT;
1294                         goto put_cpu_node;
1295                 }
1296
1297                 /* CPUs are sharing opp node */
1298                 if (np == tmp_np)
1299                         cpumask_set_cpu(cpu, cpumask);
1300
1301                 of_node_put(tmp_np);
1302         }
1303
1304 put_cpu_node:
1305         of_node_put(np);
1306         return ret;
1307 }
1308 EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus);
1309
1310 /**
1311  * of_get_required_opp_performance_state() - Search for required OPP and return its performance state.
1312  * @np: Node that contains the "required-opps" property.
1313  * @index: Index of the phandle to parse.
1314  *
1315  * Returns the performance state of the OPP pointed out by the "required-opps"
1316  * property at @index in @np.
1317  *
1318  * Return: Zero or positive performance state on success, otherwise negative
1319  * value on errors.
1320  */
1321 int of_get_required_opp_performance_state(struct device_node *np, int index)
1322 {
1323         struct dev_pm_opp *opp;
1324         struct device_node *required_np;
1325         struct opp_table *opp_table;
1326         int pstate = -EINVAL;
1327
1328         required_np = of_parse_required_opp(np, index);
1329         if (!required_np)
1330                 return -EINVAL;
1331
1332         opp_table = _find_table_of_opp_np(required_np);
1333         if (IS_ERR(opp_table)) {
1334                 pr_err("%s: Failed to find required OPP table %pOF: %ld\n",
1335                        __func__, np, PTR_ERR(opp_table));
1336                 goto put_required_np;
1337         }
1338
1339         opp = _find_opp_of_np(opp_table, required_np);
1340         if (opp) {
1341                 pstate = opp->pstate;
1342                 dev_pm_opp_put(opp);
1343         }
1344
1345         dev_pm_opp_put_opp_table(opp_table);
1346
1347 put_required_np:
1348         of_node_put(required_np);
1349
1350         return pstate;
1351 }
1352 EXPORT_SYMBOL_GPL(of_get_required_opp_performance_state);
1353
1354 /**
1355  * dev_pm_opp_get_of_node() - Gets the DT node corresponding to an opp
1356  * @opp:        opp for which DT node has to be returned for
1357  *
1358  * Return: DT node corresponding to the opp, else 0 on success.
1359  *
1360  * The caller needs to put the node with of_node_put() after using it.
1361  */
1362 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
1363 {
1364         if (IS_ERR_OR_NULL(opp)) {
1365                 pr_err("%s: Invalid parameters\n", __func__);
1366                 return NULL;
1367         }
1368
1369         return of_node_get(opp->np);
1370 }
1371 EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node);
1372
1373 /*
1374  * Callback function provided to the Energy Model framework upon registration.
1375  * This computes the power estimated by @dev at @kHz if it is the frequency
1376  * of an existing OPP, or at the frequency of the first OPP above @kHz otherwise
1377  * (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled
1378  * frequency and @mW to the associated power. The power is estimated as
1379  * P = C * V^2 * f with C being the device's capacitance and V and f
1380  * respectively the voltage and frequency of the OPP.
1381  *
1382  * Returns -EINVAL if the power calculation failed because of missing
1383  * parameters, 0 otherwise.
1384  */
1385 static int __maybe_unused _get_power(unsigned long *mW, unsigned long *kHz,
1386                                      struct device *dev)
1387 {
1388         struct dev_pm_opp *opp;
1389         struct device_node *np;
1390         unsigned long mV, Hz;
1391         u32 cap;
1392         u64 tmp;
1393         int ret;
1394
1395         np = of_node_get(dev->of_node);
1396         if (!np)
1397                 return -EINVAL;
1398
1399         ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
1400         of_node_put(np);
1401         if (ret)
1402                 return -EINVAL;
1403
1404         Hz = *kHz * 1000;
1405         opp = dev_pm_opp_find_freq_ceil(dev, &Hz);
1406         if (IS_ERR(opp))
1407                 return -EINVAL;
1408
1409         mV = dev_pm_opp_get_voltage(opp) / 1000;
1410         dev_pm_opp_put(opp);
1411         if (!mV)
1412                 return -EINVAL;
1413
1414         tmp = (u64)cap * mV * mV * (Hz / 1000000);
1415         do_div(tmp, 1000000000);
1416
1417         *mW = (unsigned long)tmp;
1418         *kHz = Hz / 1000;
1419
1420         return 0;
1421 }
1422
1423 /**
1424  * dev_pm_opp_of_register_em() - Attempt to register an Energy Model
1425  * @dev         : Device for which an Energy Model has to be registered
1426  * @cpus        : CPUs for which an Energy Model has to be registered. For
1427  *              other type of devices it should be set to NULL.
1428  *
1429  * This checks whether the "dynamic-power-coefficient" devicetree property has
1430  * been specified, and tries to register an Energy Model with it if it has.
1431  * Having this property means the voltages are known for OPPs and the EM
1432  * might be calculated.
1433  */
1434 int dev_pm_opp_of_register_em(struct device *dev, struct cpumask *cpus)
1435 {
1436         struct em_data_callback em_cb = EM_DATA_CB(_get_power);
1437         struct device_node *np;
1438         int ret, nr_opp;
1439         u32 cap;
1440
1441         if (IS_ERR_OR_NULL(dev)) {
1442                 ret = -EINVAL;
1443                 goto failed;
1444         }
1445
1446         nr_opp = dev_pm_opp_get_opp_count(dev);
1447         if (nr_opp <= 0) {
1448                 ret = -EINVAL;
1449                 goto failed;
1450         }
1451
1452         np = of_node_get(dev->of_node);
1453         if (!np) {
1454                 ret = -EINVAL;
1455                 goto failed;
1456         }
1457
1458         /*
1459          * Register an EM only if the 'dynamic-power-coefficient' property is
1460          * set in devicetree. It is assumed the voltage values are known if that
1461          * property is set since it is useless otherwise. If voltages are not
1462          * known, just let the EM registration fail with an error to alert the
1463          * user about the inconsistent configuration.
1464          */
1465         ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
1466         of_node_put(np);
1467         if (ret || !cap) {
1468                 dev_dbg(dev, "Couldn't find proper 'dynamic-power-coefficient' in DT\n");
1469                 ret = -EINVAL;
1470                 goto failed;
1471         }
1472
1473         ret = em_dev_register_perf_domain(dev, nr_opp, &em_cb, cpus, true);
1474         if (ret)
1475                 goto failed;
1476
1477         return 0;
1478
1479 failed:
1480         dev_dbg(dev, "Couldn't register Energy Model %d\n", ret);
1481         return ret;
1482 }
1483 EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em);