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 or more OPPs defined */
 968         if (!count) {
 969                 dev_err(dev, "%s: no supported OPPs", __func__);
 970                 ret = -ENOENT;
 971                 goto remove_static_opp;
 972         }
 973
 974         list_for_each_entry(opp, &opp_table->opp_list, node) {
 975                 /* Any non-zero performance state would enable the feature */
 976                 if (opp->pstate) {
 977                         opp_table->genpd_performance_state = true;
 978                         break;
 979                 }
 980         }
 981
 982         lazy_link_required_opp_table(opp_table);
 983
 984         return 0;
 985
 986 remove_static_opp:
 987         _opp_remove_all_static(opp_table);
 988
 989         return ret;
 990 }
 991
 992 /* Initializes OPP tables based on old-deprecated bindings */
 993 static int _of_add_opp_table_v1(struct device *dev, struct opp_table *opp_table)
 994 {
 995         const struct property *prop;
 996         const __be32 *val;
 997         int nr, ret = 0;
 998
 999         mutex_lock(&opp_table->lock);
1000         if (opp_table->parsed_static_opps) {
1001                 opp_table->parsed_static_opps++;
1002                 mutex_unlock(&opp_table->lock);
1003                 return 0;
1004         }
1005
1006         opp_table->parsed_static_opps = 1;
1007         mutex_unlock(&opp_table->lock);
1008
1009         prop = of_find_property(dev->of_node, "operating-points", NULL);
1010         if (!prop) {
1011                 ret = -ENODEV;
1012                 goto remove_static_opp;
1013         }
1014         if (!prop->value) {
1015                 ret = -ENODATA;
1016                 goto remove_static_opp;
1017         }
1018
1019         /*
1020          * Each OPP is a set of tuples consisting of frequency and
1021          * voltage like <freq-kHz vol-uV>.
1022          */
1023         nr = prop->length / sizeof(u32);
1024         if (nr % 2) {
1025                 dev_err(dev, "%s: Invalid OPP table\n", __func__);
1026                 ret = -EINVAL;
1027                 goto remove_static_opp;
1028         }
1029
1030         val = prop->value;
1031         while (nr) {
1032                 unsigned long freq = be32_to_cpup(val++) * 1000;
1033                 unsigned long volt = be32_to_cpup(val++);
1034
1035                 ret = _opp_add_v1(opp_table, dev, freq, volt, false);
1036                 if (ret) {
1037                         dev_err(dev, "%s: Failed to add OPP %ld (%d)\n",
1038                                 __func__, freq, ret);
1039                         goto remove_static_opp;
1040                 }
1041                 nr -= 2;
1042         }
1043
1044         return 0;
1045
1046 remove_static_opp:
1047         _opp_remove_all_static(opp_table);
1048
1049         return ret;
1050 }
1051
1052 static int _of_add_table_indexed(struct device *dev, int index, bool getclk)
1053 {
1054         struct opp_table *opp_table;
1055         int ret, count;
1056
1057         if (index) {
1058                 /*
1059                  * If only one phandle is present, then the same OPP table
1060                  * applies for all index requests.
1061                  */
1062                 count = of_count_phandle_with_args(dev->of_node,
1063                                                    "operating-points-v2", NULL);
1064                 if (count == 1)
1065                         index = 0;
1066         }
1067
1068         opp_table = _add_opp_table_indexed(dev, index, getclk);
1069         if (IS_ERR(opp_table))
1070                 return PTR_ERR(opp_table);
1071
1072         /*
1073          * OPPs have two version of bindings now. Also try the old (v1)
1074          * bindings for backward compatibility with older dtbs.
1075          */
1076         if (opp_table->np)
1077                 ret = _of_add_opp_table_v2(dev, opp_table);
1078         else
1079                 ret = _of_add_opp_table_v1(dev, opp_table);
1080
1081         if (ret)
1082                 dev_pm_opp_put_opp_table(opp_table);
1083
1084         return ret;
1085 }
1086
1087 static void devm_pm_opp_of_table_release(void *data)
1088 {
1089         dev_pm_opp_of_remove_table(data);
1090 }
1091
1092 /**
1093  * devm_pm_opp_of_add_table() - Initialize opp table from device tree
1094  * @dev:        device pointer used to lookup OPP table.
1095  *
1096  * Register the initial OPP table with the OPP library for given device.
1097  *
1098  * The opp_table structure will be freed after the device is destroyed.
1099  *
1100  * Return:
1101  * 0            On success OR
1102  *              Duplicate OPPs (both freq and volt are same) and opp->available
1103  * -EEXIST      Freq are same and volt are different OR
1104  *              Duplicate OPPs (both freq and volt are same) and !opp->available
1105  * -ENOMEM      Memory allocation failure
1106  * -ENODEV      when 'operating-points' property is not found or is invalid data
1107  *              in device node.
1108  * -ENODATA     when empty 'operating-points' property is found
1109  * -EINVAL      when invalid entries are found in opp-v2 table
1110  */
1111 int devm_pm_opp_of_add_table(struct device *dev)
1112 {
1113         int ret;
1114
1115         ret = dev_pm_opp_of_add_table(dev);
1116         if (ret)
1117                 return ret;
1118
1119         return devm_add_action_or_reset(dev, devm_pm_opp_of_table_release, dev);
1120 }
1121 EXPORT_SYMBOL_GPL(devm_pm_opp_of_add_table);
1122
1123 /**
1124  * dev_pm_opp_of_add_table() - Initialize opp table from device tree
1125  * @dev:        device pointer used to lookup OPP table.
1126  *
1127  * Register the initial OPP table with the OPP library for given device.
1128  *
1129  * Return:
1130  * 0            On success OR
1131  *              Duplicate OPPs (both freq and volt are same) and opp->available
1132  * -EEXIST      Freq are same and volt are different OR
1133  *              Duplicate OPPs (both freq and volt are same) and !opp->available
1134  * -ENOMEM      Memory allocation failure
1135  * -ENODEV      when 'operating-points' property is not found or is invalid data
1136  *              in device node.
1137  * -ENODATA     when empty 'operating-points' property is found
1138  * -EINVAL      when invalid entries are found in opp-v2 table
1139  */
1140 int dev_pm_opp_of_add_table(struct device *dev)
1141 {
1142         return _of_add_table_indexed(dev, 0, true);
1143 }
1144 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);
1145
1146 /**
1147  * dev_pm_opp_of_add_table_indexed() - Initialize indexed opp table from device tree
1148  * @dev:        device pointer used to lookup OPP table.
1149  * @index:      Index number.
1150  *
1151  * Register the initial OPP table with the OPP library for given device only
1152  * using the "operating-points-v2" property.
1153  *
1154  * Return: Refer to dev_pm_opp_of_add_table() for return values.
1155  */
1156 int dev_pm_opp_of_add_table_indexed(struct device *dev, int index)
1157 {
1158         return _of_add_table_indexed(dev, index, true);
1159 }
1160 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_indexed);
1161
1162 /**
1163  * dev_pm_opp_of_add_table_noclk() - Initialize indexed opp table from device
1164  *              tree without getting clk for device.
1165  * @dev:        device pointer used to lookup OPP table.
1166  * @index:      Index number.
1167  *
1168  * Register the initial OPP table with the OPP library for given device only
1169  * using the "operating-points-v2" property. Do not try to get the clk for the
1170  * device.
1171  *
1172  * Return: Refer to dev_pm_opp_of_add_table() for return values.
1173  */
1174 int dev_pm_opp_of_add_table_noclk(struct device *dev, int index)
1175 {
1176         return _of_add_table_indexed(dev, index, false);
1177 }
1178 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_noclk);
1179
1180 /* CPU device specific helpers */
1181
1182 /**
1183  * dev_pm_opp_of_cpumask_remove_table() - Removes OPP table for @cpumask
1184  * @cpumask:    cpumask for which OPP table needs to be removed
1185  *
1186  * This removes the OPP tables for CPUs present in the @cpumask.
1187  * This should be used only to remove static entries created from DT.
1188  */
1189 void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask)
1190 {
1191         _dev_pm_opp_cpumask_remove_table(cpumask, -1);
1192 }
1193 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table);
1194
1195 /**
1196  * dev_pm_opp_of_cpumask_add_table() - Adds OPP table for @cpumask
1197  * @cpumask:    cpumask for which OPP table needs to be added.
1198  *
1199  * This adds the OPP tables for CPUs present in the @cpumask.
1200  */
1201 int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask)
1202 {
1203         struct device *cpu_dev;
1204         int cpu, ret;
1205
1206         if (WARN_ON(cpumask_empty(cpumask)))
1207                 return -ENODEV;
1208
1209         for_each_cpu(cpu, cpumask) {
1210                 cpu_dev = get_cpu_device(cpu);
1211                 if (!cpu_dev) {
1212                         pr_err("%s: failed to get cpu%d device\n", __func__,
1213                                cpu);
1214                         ret = -ENODEV;
1215                         goto remove_table;
1216                 }
1217
1218                 ret = dev_pm_opp_of_add_table(cpu_dev);
1219                 if (ret) {
1220                         /*
1221                          * OPP may get registered dynamically, don't print error
1222                          * message here.
1223                          */
1224                         pr_debug("%s: couldn't find opp table for cpu:%d, %d\n",
1225                                  __func__, cpu, ret);
1226
1227                         goto remove_table;
1228                 }
1229         }
1230
1231         return 0;
1232
1233 remove_table:
1234         /* Free all other OPPs */
1235         _dev_pm_opp_cpumask_remove_table(cpumask, cpu);
1236
1237         return ret;
1238 }
1239 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table);
1240
1241 /*
1242  * Works only for OPP v2 bindings.
1243  *
1244  * Returns -ENOENT if operating-points-v2 bindings aren't supported.
1245  */
1246 /**
1247  * dev_pm_opp_of_get_sharing_cpus() - Get cpumask of CPUs sharing OPPs with
1248  *                                    @cpu_dev using operating-points-v2
1249  *                                    bindings.
1250  *
1251  * @cpu_dev:    CPU device for which we do this operation
1252  * @cpumask:    cpumask to update with information of sharing CPUs
1253  *
1254  * This updates the @cpumask with CPUs that are sharing OPPs with @cpu_dev.
1255  *
1256  * Returns -ENOENT if operating-points-v2 isn't present for @cpu_dev.
1257  */
1258 int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev,
1259                                    struct cpumask *cpumask)
1260 {
1261         struct device_node *np, *tmp_np, *cpu_np;
1262         int cpu, ret = 0;
1263
1264         /* Get OPP descriptor node */
1265         np = dev_pm_opp_of_get_opp_desc_node(cpu_dev);
1266         if (!np) {
1267                 dev_dbg(cpu_dev, "%s: Couldn't find opp node.\n", __func__);
1268                 return -ENOENT;
1269         }
1270
1271         cpumask_set_cpu(cpu_dev->id, cpumask);
1272
1273         /* OPPs are shared ? */
1274         if (!of_property_read_bool(np, "opp-shared"))
1275                 goto put_cpu_node;
1276
1277         for_each_possible_cpu(cpu) {
1278                 if (cpu == cpu_dev->id)
1279                         continue;
1280
1281                 cpu_np = of_cpu_device_node_get(cpu);
1282                 if (!cpu_np) {
1283                         dev_err(cpu_dev, "%s: failed to get cpu%d node\n",
1284                                 __func__, cpu);
1285                         ret = -ENOENT;
1286                         goto put_cpu_node;
1287                 }
1288
1289                 /* Get OPP descriptor node */
1290                 tmp_np = _opp_of_get_opp_desc_node(cpu_np, 0);
1291                 of_node_put(cpu_np);
1292                 if (!tmp_np) {
1293                         pr_err("%pOF: Couldn't find opp node\n", cpu_np);
1294                         ret = -ENOENT;
1295                         goto put_cpu_node;
1296                 }
1297
1298                 /* CPUs are sharing opp node */
1299                 if (np == tmp_np)
1300                         cpumask_set_cpu(cpu, cpumask);
1301
1302                 of_node_put(tmp_np);
1303         }
1304
1305 put_cpu_node:
1306         of_node_put(np);
1307         return ret;
1308 }
1309 EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus);
1310
1311 /**
1312  * of_get_required_opp_performance_state() - Search for required OPP and return its performance state.
1313  * @np: Node that contains the "required-opps" property.
1314  * @index: Index of the phandle to parse.
1315  *
1316  * Returns the performance state of the OPP pointed out by the "required-opps"
1317  * property at @index in @np.
1318  *
1319  * Return: Zero or positive performance state on success, otherwise negative
1320  * value on errors.
1321  */
1322 int of_get_required_opp_performance_state(struct device_node *np, int index)
1323 {
1324         struct dev_pm_opp *opp;
1325         struct device_node *required_np;
1326         struct opp_table *opp_table;
1327         int pstate = -EINVAL;
1328
1329         required_np = of_parse_required_opp(np, index);
1330         if (!required_np)
1331                 return -EINVAL;
1332
1333         opp_table = _find_table_of_opp_np(required_np);
1334         if (IS_ERR(opp_table)) {
1335                 pr_err("%s: Failed to find required OPP table %pOF: %ld\n",
1336                        __func__, np, PTR_ERR(opp_table));
1337                 goto put_required_np;
1338         }
1339
1340         opp = _find_opp_of_np(opp_table, required_np);
1341         if (opp) {
1342                 pstate = opp->pstate;
1343                 dev_pm_opp_put(opp);
1344         }
1345
1346         dev_pm_opp_put_opp_table(opp_table);
1347
1348 put_required_np:
1349         of_node_put(required_np);
1350
1351         return pstate;
1352 }
1353 EXPORT_SYMBOL_GPL(of_get_required_opp_performance_state);
1354
1355 /**
1356  * dev_pm_opp_get_of_node() - Gets the DT node corresponding to an opp
1357  * @opp:        opp for which DT node has to be returned for
1358  *
1359  * Return: DT node corresponding to the opp, else 0 on success.
1360  *
1361  * The caller needs to put the node with of_node_put() after using it.
1362  */
1363 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
1364 {
1365         if (IS_ERR_OR_NULL(opp)) {
1366                 pr_err("%s: Invalid parameters\n", __func__);
1367                 return NULL;
1368         }
1369
1370         return of_node_get(opp->np);
1371 }
1372 EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node);
1373
1374 /*
1375  * Callback function provided to the Energy Model framework upon registration.
1376  * This computes the power estimated by @dev at @kHz if it is the frequency
1377  * of an existing OPP, or at the frequency of the first OPP above @kHz otherwise
1378  * (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled
1379  * frequency and @mW to the associated power. The power is estimated as
1380  * P = C * V^2 * f with C being the device's capacitance and V and f
1381  * respectively the voltage and frequency of the OPP.
1382  *
1383  * Returns -EINVAL if the power calculation failed because of missing
1384  * parameters, 0 otherwise.
1385  */
1386 static int __maybe_unused _get_power(unsigned long *mW, unsigned long *kHz,
1387                                      struct device *dev)
1388 {
1389         struct dev_pm_opp *opp;
1390         struct device_node *np;
1391         unsigned long mV, Hz;
1392         u32 cap;
1393         u64 tmp;
1394         int ret;
1395
1396         np = of_node_get(dev->of_node);
1397         if (!np)
1398                 return -EINVAL;
1399
1400         ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
1401         of_node_put(np);
1402         if (ret)
1403                 return -EINVAL;
1404
1405         Hz = *kHz * 1000;
1406         opp = dev_pm_opp_find_freq_ceil(dev, &Hz);
1407         if (IS_ERR(opp))
1408                 return -EINVAL;
1409
1410         mV = dev_pm_opp_get_voltage(opp) / 1000;
1411         dev_pm_opp_put(opp);
1412         if (!mV)
1413                 return -EINVAL;
1414
1415         tmp = (u64)cap * mV * mV * (Hz / 1000000);
1416         do_div(tmp, 1000000000);
1417
1418         *mW = (unsigned long)tmp;
1419         *kHz = Hz / 1000;
1420
1421         return 0;
1422 }
1423
1424 /**
1425  * dev_pm_opp_of_register_em() - Attempt to register an Energy Model
1426  * @dev         : Device for which an Energy Model has to be registered
1427  * @cpus        : CPUs for which an Energy Model has to be registered. For
1428  *              other type of devices it should be set to NULL.
1429  *
1430  * This checks whether the "dynamic-power-coefficient" devicetree property has
1431  * been specified, and tries to register an Energy Model with it if it has.
1432  * Having this property means the voltages are known for OPPs and the EM
1433  * might be calculated.
1434  */
1435 int dev_pm_opp_of_register_em(struct device *dev, struct cpumask *cpus)
1436 {
1437         struct em_data_callback em_cb = EM_DATA_CB(_get_power);
1438         struct device_node *np;
1439         int ret, nr_opp;
1440         u32 cap;
1441
1442         if (IS_ERR_OR_NULL(dev)) {
1443                 ret = -EINVAL;
1444                 goto failed;
1445         }
1446
1447         nr_opp = dev_pm_opp_get_opp_count(dev);
1448         if (nr_opp <= 0) {
1449                 ret = -EINVAL;
1450                 goto failed;
1451         }
1452
1453         np = of_node_get(dev->of_node);
1454         if (!np) {
1455                 ret = -EINVAL;
1456                 goto failed;
1457         }
1458
1459         /*
1460          * Register an EM only if the 'dynamic-power-coefficient' property is
1461          * set in devicetree. It is assumed the voltage values are known if that
1462          * property is set since it is useless otherwise. If voltages are not
1463          * known, just let the EM registration fail with an error to alert the
1464          * user about the inconsistent configuration.
1465          */
1466         ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
1467         of_node_put(np);
1468         if (ret || !cap) {
1469                 dev_dbg(dev, "Couldn't find proper 'dynamic-power-coefficient' in DT\n");
1470                 ret = -EINVAL;
1471                 goto failed;
1472         }
1473
1474         ret = em_dev_register_perf_domain(dev, nr_opp, &em_cb, cpus, true);
1475         if (ret)
1476                 goto failed;
1477
1478         return 0;
1479
1480 failed:
1481         dev_dbg(dev, "Couldn't register Energy Model %d\n", ret);
1482         return ret;
1483 }
1484 EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em);