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         lockdep_assert_held(&opp_table_lock);
  81
  82         mutex_lock(&opp_table->lock);
  83
  84         list_for_each_entry(opp, &opp_table->opp_list, node) {
  85                 if (opp->np == opp_np) {
  86                         dev_pm_opp_get(opp);
  87                         mutex_unlock(&opp_table->lock);
  88                         return opp;
  89                 }
  90         }
  91
  92         mutex_unlock(&opp_table->lock);
  93
  94         return NULL;
  95 }
  96
  97 static struct device_node *of_parse_required_opp(struct device_node *np,
  98                                                  int index)
  99 {
 100         struct device_node *required_np;
 101
 102         required_np = of_parse_phandle(np, "required-opps", index);
 103         if (unlikely(!required_np)) {
 104                 pr_err("%s: Unable to parse required-opps: %pOF, index: %d\n",
 105                        __func__, np, index);
 106         }
 107
 108         return required_np;
 109 }
 110
 111 /* The caller must call dev_pm_opp_put_opp_table() after the table is used */
 112 static struct opp_table *_find_table_of_opp_np(struct device_node *opp_np)
 113 {
 114         struct opp_table *opp_table;
 115         struct device_node *opp_table_np;
 116
 117         lockdep_assert_held(&opp_table_lock);
 118
 119         opp_table_np = of_get_parent(opp_np);
 120         if (!opp_table_np)
 121                 goto err;
 122
 123         /* It is safe to put the node now as all we need now is its address */
 124         of_node_put(opp_table_np);
 125
 126         list_for_each_entry(opp_table, &opp_tables, node) {
 127                 if (opp_table_np == opp_table->np) {
 128                         _get_opp_table_kref(opp_table);
 129                         return opp_table;
 130                 }
 131         }
 132
 133 err:
 134         return ERR_PTR(-ENODEV);
 135 }
 136
 137 /* Free resources previously acquired by _opp_table_alloc_required_tables() */
 138 static void _opp_table_free_required_tables(struct opp_table *opp_table)
 139 {
 140         struct opp_table **required_opp_tables = opp_table->required_opp_tables;
 141         struct device **genpd_virt_devs = opp_table->genpd_virt_devs;
 142         int i;
 143
 144         if (!required_opp_tables)
 145                 return;
 146
 147         for (i = 0; i < opp_table->required_opp_count; i++) {
 148                 if (IS_ERR_OR_NULL(required_opp_tables[i]))
 149                         break;
 150
 151                 dev_pm_opp_put_opp_table(required_opp_tables[i]);
 152         }
 153
 154         kfree(required_opp_tables);
 155         kfree(genpd_virt_devs);
 156
 157         opp_table->required_opp_count = 0;
 158         opp_table->genpd_virt_devs = NULL;
 159         opp_table->required_opp_tables = NULL;
 160 }
 161
 162 /*
 163  * Populate all devices and opp tables which are part of "required-opps" list.
 164  * Checking only the first OPP node should be enough.
 165  */
 166 static void _opp_table_alloc_required_tables(struct opp_table *opp_table,
 167                                              struct device *dev,
 168                                              struct device_node *opp_np)
 169 {
 170         struct opp_table **required_opp_tables;
 171         struct device **genpd_virt_devs = NULL;
 172         struct device_node *required_np, *np;
 173         int count, count_pd, i;
 174
 175         /* Traversing the first OPP node is all we need */
 176         np = of_get_next_available_child(opp_np, NULL);
 177         if (!np) {
 178                 dev_err(dev, "Empty OPP table\n");
 179                 return;
 180         }
 181
 182         count = of_count_phandle_with_args(np, "required-opps", NULL);
 183         if (!count)
 184                 goto put_np;
 185
 186         /*
 187          * Check the number of power-domains to know if we need to deal
 188          * with virtual devices. In some cases we have devices with multiple
 189          * power domains but with only one of them being scalable, hence
 190          * 'count' could be 1, but we still have to deal with multiple genpds
 191          * and virtual devices.
 192          */
 193         count_pd = of_count_phandle_with_args(dev->of_node, "power-domains",
 194                                               "#power-domain-cells");
 195         if (!count_pd)
 196                 goto put_np;
 197
 198         if (count_pd > 1) {
 199                 genpd_virt_devs = kcalloc(count, sizeof(*genpd_virt_devs),
 200                                         GFP_KERNEL);
 201                 if (!genpd_virt_devs)
 202                         goto put_np;
 203         }
 204
 205         required_opp_tables = kcalloc(count, sizeof(*required_opp_tables),
 206                                       GFP_KERNEL);
 207         if (!required_opp_tables) {
 208                 kfree(genpd_virt_devs);
 209                 goto put_np;
 210         }
 211
 212         opp_table->genpd_virt_devs = genpd_virt_devs;
 213         opp_table->required_opp_tables = required_opp_tables;
 214         opp_table->required_opp_count = count;
 215
 216         for (i = 0; i < count; i++) {
 217                 required_np = of_parse_required_opp(np, i);
 218                 if (!required_np)
 219                         goto free_required_tables;
 220
 221                 required_opp_tables[i] = _find_table_of_opp_np(required_np);
 222                 of_node_put(required_np);
 223
 224                 if (IS_ERR(required_opp_tables[i]))
 225                         goto free_required_tables;
 226
 227                 /*
 228                  * We only support genpd's OPPs in the "required-opps" for now,
 229                  * as we don't know how much about other cases. Error out if the
 230                  * required OPP doesn't belong to a genpd.
 231                  */
 232                 if (!required_opp_tables[i]->is_genpd) {
 233                         dev_err(dev, "required-opp doesn't belong to genpd: %pOF\n",
 234                                 required_np);
 235                         goto free_required_tables;
 236                 }
 237         }
 238
 239         goto put_np;
 240
 241 free_required_tables:
 242         _opp_table_free_required_tables(opp_table);
 243 put_np:
 244         of_node_put(np);
 245 }
 246
 247 void _of_init_opp_table(struct opp_table *opp_table, struct device *dev,
 248                         int index)
 249 {
 250         struct device_node *np, *opp_np;
 251         u32 val;
 252
 253         /*
 254          * Only required for backward compatibility with v1 bindings, but isn't
 255          * harmful for other cases. And so we do it unconditionally.
 256          */
 257         np = of_node_get(dev->of_node);
 258         if (!np)
 259                 return;
 260
 261         if (!of_property_read_u32(np, "clock-latency", &val))
 262                 opp_table->clock_latency_ns_max = val;
 263         of_property_read_u32(np, "voltage-tolerance",
 264                              &opp_table->voltage_tolerance_v1);
 265
 266         if (of_find_property(np, "#power-domain-cells", NULL))
 267                 opp_table->is_genpd = true;
 268
 269         /* Get OPP table node */
 270         opp_np = _opp_of_get_opp_desc_node(np, index);
 271         of_node_put(np);
 272
 273         if (!opp_np)
 274                 return;
 275
 276         if (of_property_read_bool(opp_np, "opp-shared"))
 277                 opp_table->shared_opp = OPP_TABLE_ACCESS_SHARED;
 278         else
 279                 opp_table->shared_opp = OPP_TABLE_ACCESS_EXCLUSIVE;
 280
 281         opp_table->np = opp_np;
 282
 283         _opp_table_alloc_required_tables(opp_table, dev, opp_np);
 284         of_node_put(opp_np);
 285 }
 286
 287 void _of_clear_opp_table(struct opp_table *opp_table)
 288 {
 289         _opp_table_free_required_tables(opp_table);
 290 }
 291
 292 /*
 293  * Release all resources previously acquired with a call to
 294  * _of_opp_alloc_required_opps().
 295  */
 296 void _of_opp_free_required_opps(struct opp_table *opp_table,
 297                                 struct dev_pm_opp *opp)
 298 {
 299         struct dev_pm_opp **required_opps = opp->required_opps;
 300         int i;
 301
 302         if (!required_opps)
 303                 return;
 304
 305         for (i = 0; i < opp_table->required_opp_count; i++) {
 306                 if (!required_opps[i])
 307                         break;
 308
 309                 /* Put the reference back */
 310                 dev_pm_opp_put(required_opps[i]);
 311         }
 312
 313         kfree(required_opps);
 314         opp->required_opps = NULL;
 315 }
 316
 317 /* Populate all required OPPs which are part of "required-opps" list */
 318 static int _of_opp_alloc_required_opps(struct opp_table *opp_table,
 319                                        struct dev_pm_opp *opp)
 320 {
 321         struct dev_pm_opp **required_opps;
 322         struct opp_table *required_table;
 323         struct device_node *np;
 324         int i, ret, count = opp_table->required_opp_count;
 325
 326         if (!count)
 327                 return 0;
 328
 329         required_opps = kcalloc(count, sizeof(*required_opps), GFP_KERNEL);
 330         if (!required_opps)
 331                 return -ENOMEM;
 332
 333         opp->required_opps = required_opps;
 334
 335         for (i = 0; i < count; i++) {
 336                 required_table = opp_table->required_opp_tables[i];
 337
 338                 np = of_parse_required_opp(opp->np, i);
 339                 if (unlikely(!np)) {
 340                         ret = -ENODEV;
 341                         goto free_required_opps;
 342                 }
 343
 344                 required_opps[i] = _find_opp_of_np(required_table, np);
 345                 of_node_put(np);
 346
 347                 if (!required_opps[i]) {
 348                         pr_err("%s: Unable to find required OPP node: %pOF (%d)\n",
 349                                __func__, opp->np, i);
 350                         ret = -ENODEV;
 351                         goto free_required_opps;
 352                 }
 353         }
 354
 355         return 0;
 356
 357 free_required_opps:
 358         _of_opp_free_required_opps(opp_table, opp);
 359
 360         return ret;
 361 }
 362
 363 static bool _opp_is_supported(struct device *dev, struct opp_table *opp_table,
 364                               struct device_node *np)
 365 {
 366         unsigned int count = opp_table->supported_hw_count;
 367         u32 version;
 368         int ret;
 369
 370         if (!opp_table->supported_hw) {
 371                 /*
 372                  * In the case that no supported_hw has been set by the
 373                  * platform but there is an opp-supported-hw value set for
 374                  * an OPP then the OPP should not be enabled as there is
 375                  * no way to see if the hardware supports it.
 376                  */
 377                 if (of_find_property(np, "opp-supported-hw", NULL))
 378                         return false;
 379                 else
 380                         return true;
 381         }
 382
 383         while (count--) {
 384                 ret = of_property_read_u32_index(np, "opp-supported-hw", count,
 385                                                  &version);
 386                 if (ret) {
 387                         dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n",
 388                                  __func__, count, ret);
 389                         return false;
 390                 }
 391
 392                 /* Both of these are bitwise masks of the versions */
 393                 if (!(version & opp_table->supported_hw[count]))
 394                         return false;
 395         }
 396
 397         return true;
 398 }
 399
 400 static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev,
 401                               struct opp_table *opp_table)
 402 {
 403         u32 *microvolt, *microamp = NULL;
 404         int supplies = opp_table->regulator_count, vcount, icount, ret, i, j;
 405         struct property *prop = NULL;
 406         char name[NAME_MAX];
 407
 408         /* Search for "opp-microvolt-<name>" */
 409         if (opp_table->prop_name) {
 410                 snprintf(name, sizeof(name), "opp-microvolt-%s",
 411                          opp_table->prop_name);
 412                 prop = of_find_property(opp->np, name, NULL);
 413         }
 414
 415         if (!prop) {
 416                 /* Search for "opp-microvolt" */
 417                 sprintf(name, "opp-microvolt");
 418                 prop = of_find_property(opp->np, name, NULL);
 419
 420                 /* Missing property isn't a problem, but an invalid entry is */
 421                 if (!prop) {
 422                         if (unlikely(supplies == -1)) {
 423                                 /* Initialize regulator_count */
 424                                 opp_table->regulator_count = 0;
 425                                 return 0;
 426                         }
 427
 428                         if (!supplies)
 429                                 return 0;
 430
 431                         dev_err(dev, "%s: opp-microvolt missing although OPP managing regulators\n",
 432                                 __func__);
 433                         return -EINVAL;
 434                 }
 435         }
 436
 437         if (unlikely(supplies == -1)) {
 438                 /* Initialize regulator_count */
 439                 supplies = opp_table->regulator_count = 1;
 440         } else if (unlikely(!supplies)) {
 441                 dev_err(dev, "%s: opp-microvolt wasn't expected\n", __func__);
 442                 return -EINVAL;
 443         }
 444
 445         vcount = of_property_count_u32_elems(opp->np, name);
 446         if (vcount < 0) {
 447                 dev_err(dev, "%s: Invalid %s property (%d)\n",
 448                         __func__, name, vcount);
 449                 return vcount;
 450         }
 451
 452         /* There can be one or three elements per supply */
 453         if (vcount != supplies && vcount != supplies * 3) {
 454                 dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n",
 455                         __func__, name, vcount, supplies);
 456                 return -EINVAL;
 457         }
 458
 459         microvolt = kmalloc_array(vcount, sizeof(*microvolt), GFP_KERNEL);
 460         if (!microvolt)
 461                 return -ENOMEM;
 462
 463         ret = of_property_read_u32_array(opp->np, name, microvolt, vcount);
 464         if (ret) {
 465                 dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret);
 466                 ret = -EINVAL;
 467                 goto free_microvolt;
 468         }
 469
 470         /* Search for "opp-microamp-<name>" */
 471         prop = NULL;
 472         if (opp_table->prop_name) {
 473                 snprintf(name, sizeof(name), "opp-microamp-%s",
 474                          opp_table->prop_name);
 475                 prop = of_find_property(opp->np, name, NULL);
 476         }
 477
 478         if (!prop) {
 479                 /* Search for "opp-microamp" */
 480                 sprintf(name, "opp-microamp");
 481                 prop = of_find_property(opp->np, name, NULL);
 482         }
 483
 484         if (prop) {
 485                 icount = of_property_count_u32_elems(opp->np, name);
 486                 if (icount < 0) {
 487                         dev_err(dev, "%s: Invalid %s property (%d)\n", __func__,
 488                                 name, icount);
 489                         ret = icount;
 490                         goto free_microvolt;
 491                 }
 492
 493                 if (icount != supplies) {
 494                         dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n",
 495                                 __func__, name, icount, supplies);
 496                         ret = -EINVAL;
 497                         goto free_microvolt;
 498                 }
 499
 500                 microamp = kmalloc_array(icount, sizeof(*microamp), GFP_KERNEL);
 501                 if (!microamp) {
 502                         ret = -EINVAL;
 503                         goto free_microvolt;
 504                 }
 505
 506                 ret = of_property_read_u32_array(opp->np, name, microamp,
 507                                                  icount);
 508                 if (ret) {
 509                         dev_err(dev, "%s: error parsing %s: %d\n", __func__,
 510                                 name, ret);
 511                         ret = -EINVAL;
 512                         goto free_microamp;
 513                 }
 514         }
 515
 516         for (i = 0, j = 0; i < supplies; i++) {
 517                 opp->supplies[i].u_volt = microvolt[j++];
 518
 519                 if (vcount == supplies) {
 520                         opp->supplies[i].u_volt_min = opp->supplies[i].u_volt;
 521                         opp->supplies[i].u_volt_max = opp->supplies[i].u_volt;
 522                 } else {
 523                         opp->supplies[i].u_volt_min = microvolt[j++];
 524                         opp->supplies[i].u_volt_max = microvolt[j++];
 525                 }
 526
 527                 if (microamp)
 528                         opp->supplies[i].u_amp = microamp[i];
 529         }
 530
 531 free_microamp:
 532         kfree(microamp);
 533 free_microvolt:
 534         kfree(microvolt);
 535
 536         return ret;
 537 }
 538
 539 /**
 540  * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
 541  *                                entries
 542  * @dev:        device pointer used to lookup OPP table.
 543  *
 544  * Free OPPs created using static entries present in DT.
 545  */
 546 void dev_pm_opp_of_remove_table(struct device *dev)
 547 {
 548         _dev_pm_opp_find_and_remove_table(dev);
 549 }
 550 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);
 551
 552 /**
 553  * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
 554  * @opp_table:  OPP table
 555  * @dev:        device for which we do this operation
 556  * @np:         device node
 557  *
 558  * This function adds an opp definition to the opp table and returns status. The
 559  * opp can be controlled using dev_pm_opp_enable/disable functions and may be
 560  * removed by dev_pm_opp_remove.
 561  *
 562  * Return:
 563  * Valid OPP pointer:
 564  *              On success
 565  * NULL:
 566  *              Duplicate OPPs (both freq and volt are same) and opp->available
 567  *              OR if the OPP is not supported by hardware.
 568  * ERR_PTR(-EEXIST):
 569  *              Freq are same and volt are different OR
 570  *              Duplicate OPPs (both freq and volt are same) and !opp->available
 571  * ERR_PTR(-ENOMEM):
 572  *              Memory allocation failure
 573  * ERR_PTR(-EINVAL):
 574  *              Failed parsing the OPP node
 575  */
 576 static struct dev_pm_opp *_opp_add_static_v2(struct opp_table *opp_table,
 577                 struct device *dev, struct device_node *np)
 578 {
 579         struct dev_pm_opp *new_opp;
 580         u64 rate = 0;
 581         u32 val;
 582         int ret;
 583         bool rate_not_available = false;
 584
 585         new_opp = _opp_allocate(opp_table);
 586         if (!new_opp)
 587                 return ERR_PTR(-ENOMEM);
 588
 589         ret = of_property_read_u64(np, "opp-hz", &rate);
 590         if (ret < 0) {
 591                 /* "opp-hz" is optional for devices like power domains. */
 592                 if (!opp_table->is_genpd) {
 593                         dev_err(dev, "%s: opp-hz not found\n", __func__);
 594                         goto free_opp;
 595                 }
 596
 597                 rate_not_available = true;
 598         } else {
 599                 /*
 600                  * Rate is defined as an unsigned long in clk API, and so
 601                  * casting explicitly to its type. Must be fixed once rate is 64
 602                  * bit guaranteed in clk API.
 603                  */
 604                 new_opp->rate = (unsigned long)rate;
 605         }
 606
 607         of_property_read_u32(np, "opp-level", &new_opp->level);
 608
 609         /* Check if the OPP supports hardware's hierarchy of versions or not */
 610         if (!_opp_is_supported(dev, opp_table, np)) {
 611                 dev_dbg(dev, "OPP not supported by hardware: %llu\n", rate);
 612                 goto free_opp;
 613         }
 614
 615         new_opp->turbo = of_property_read_bool(np, "turbo-mode");
 616
 617         new_opp->np = np;
 618         new_opp->dynamic = false;
 619         new_opp->available = true;
 620
 621         ret = _of_opp_alloc_required_opps(opp_table, new_opp);
 622         if (ret)
 623                 goto free_opp;
 624
 625         if (!of_property_read_u32(np, "clock-latency-ns", &val))
 626                 new_opp->clock_latency_ns = val;
 627
 628         ret = opp_parse_supplies(new_opp, dev, opp_table);
 629         if (ret)
 630                 goto free_required_opps;
 631
 632         if (opp_table->is_genpd)
 633                 new_opp->pstate = pm_genpd_opp_to_performance_state(dev, new_opp);
 634
 635         ret = _opp_add(dev, new_opp, opp_table, rate_not_available);
 636         if (ret) {
 637                 /* Don't return error for duplicate OPPs */
 638                 if (ret == -EBUSY)
 639                         ret = 0;
 640                 goto free_required_opps;
 641         }
 642
 643         /* OPP to select on device suspend */
 644         if (of_property_read_bool(np, "opp-suspend")) {
 645                 if (opp_table->suspend_opp) {
 646                         dev_warn(dev, "%s: Multiple suspend OPPs found (%lu %lu)\n",
 647                                  __func__, opp_table->suspend_opp->rate,
 648                                  new_opp->rate);
 649                 } else {
 650                         new_opp->suspend = true;
 651                         opp_table->suspend_opp = new_opp;
 652                 }
 653         }
 654
 655         if (new_opp->clock_latency_ns > opp_table->clock_latency_ns_max)
 656                 opp_table->clock_latency_ns_max = new_opp->clock_latency_ns;
 657
 658         pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n",
 659                  __func__, new_opp->turbo, new_opp->rate,
 660                  new_opp->supplies[0].u_volt, new_opp->supplies[0].u_volt_min,
 661                  new_opp->supplies[0].u_volt_max, new_opp->clock_latency_ns);
 662
 663         /*
 664          * Notify the changes in the availability of the operable
 665          * frequency/voltage list.
 666          */
 667         blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADD, new_opp);
 668         return new_opp;
 669
 670 free_required_opps:
 671         _of_opp_free_required_opps(opp_table, new_opp);
 672 free_opp:
 673         _opp_free(new_opp);
 674
 675         return ERR_PTR(ret);
 676 }
 677
 678 /* Initializes OPP tables based on new bindings */
 679 static int _of_add_opp_table_v2(struct device *dev, struct opp_table *opp_table)
 680 {
 681         struct device_node *np;
 682         int ret, count = 0, pstate_count = 0;
 683         struct dev_pm_opp *opp;
 684
 685         /* OPP table is already initialized for the device */
 686         if (opp_table->parsed_static_opps) {
 687                 kref_get(&opp_table->list_kref);
 688                 return 0;
 689         }
 690
 691         kref_init(&opp_table->list_kref);
 692
 693         /* We have opp-table node now, iterate over it and add OPPs */
 694         for_each_available_child_of_node(opp_table->np, np) {
 695                 opp = _opp_add_static_v2(opp_table, dev, np);
 696                 if (IS_ERR(opp)) {
 697                         ret = PTR_ERR(opp);
 698                         dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,
 699                                 ret);
 700                         of_node_put(np);
 701                         goto put_list_kref;
 702                 } else if (opp) {
 703                         count++;
 704                 }
 705         }
 706
 707         /* There should be one of more OPP defined */
 708         if (WARN_ON(!count)) {
 709                 ret = -ENOENT;
 710                 goto put_list_kref;
 711         }
 712
 713         list_for_each_entry(opp, &opp_table->opp_list, node)
 714                 pstate_count += !!opp->pstate;
 715
 716         /* Either all or none of the nodes shall have performance state set */
 717         if (pstate_count && pstate_count != count) {
 718                 dev_err(dev, "Not all nodes have performance state set (%d: %d)\n",
 719                         count, pstate_count);
 720                 ret = -ENOENT;
 721                 goto put_list_kref;
 722         }
 723
 724         if (pstate_count)
 725                 opp_table->genpd_performance_state = true;
 726
 727         opp_table->parsed_static_opps = true;
 728
 729         return 0;
 730
 731 put_list_kref:
 732         _put_opp_list_kref(opp_table);
 733
 734         return ret;
 735 }
 736
 737 /* Initializes OPP tables based on old-deprecated bindings */
 738 static int _of_add_opp_table_v1(struct device *dev, struct opp_table *opp_table)
 739 {
 740         const struct property *prop;
 741         const __be32 *val;
 742         int nr, ret = 0;
 743
 744         prop = of_find_property(dev->of_node, "operating-points", NULL);
 745         if (!prop)
 746                 return -ENODEV;
 747         if (!prop->value)
 748                 return -ENODATA;
 749
 750         /*
 751          * Each OPP is a set of tuples consisting of frequency and
 752          * voltage like <freq-kHz vol-uV>.
 753          */
 754         nr = prop->length / sizeof(u32);
 755         if (nr % 2) {
 756                 dev_err(dev, "%s: Invalid OPP table\n", __func__);
 757                 return -EINVAL;
 758         }
 759
 760         kref_init(&opp_table->list_kref);
 761
 762         val = prop->value;
 763         while (nr) {
 764                 unsigned long freq = be32_to_cpup(val++) * 1000;
 765                 unsigned long volt = be32_to_cpup(val++);
 766
 767                 ret = _opp_add_v1(opp_table, dev, freq, volt, false);
 768                 if (ret) {
 769                         dev_err(dev, "%s: Failed to add OPP %ld (%d)\n",
 770                                 __func__, freq, ret);
 771                         _put_opp_list_kref(opp_table);
 772                         return ret;
 773                 }
 774                 nr -= 2;
 775         }
 776
 777         return ret;
 778 }
 779
 780 /**
 781  * dev_pm_opp_of_add_table() - Initialize opp table from device tree
 782  * @dev:        device pointer used to lookup OPP table.
 783  *
 784  * Register the initial OPP table with the OPP library for given device.
 785  *
 786  * Return:
 787  * 0            On success OR
 788  *              Duplicate OPPs (both freq and volt are same) and opp->available
 789  * -EEXIST      Freq are same and volt are different OR
 790  *              Duplicate OPPs (both freq and volt are same) and !opp->available
 791  * -ENOMEM      Memory allocation failure
 792  * -ENODEV      when 'operating-points' property is not found or is invalid data
 793  *              in device node.
 794  * -ENODATA     when empty 'operating-points' property is found
 795  * -EINVAL      when invalid entries are found in opp-v2 table
 796  */
 797 int dev_pm_opp_of_add_table(struct device *dev)
 798 {
 799         struct opp_table *opp_table;
 800         int ret;
 801
 802         opp_table = dev_pm_opp_get_opp_table_indexed(dev, 0);
 803         if (!opp_table)
 804                 return -ENOMEM;
 805
 806         /*
 807          * OPPs have two version of bindings now. Also try the old (v1)
 808          * bindings for backward compatibility with older dtbs.
 809          */
 810         if (opp_table->np)
 811                 ret = _of_add_opp_table_v2(dev, opp_table);
 812         else
 813                 ret = _of_add_opp_table_v1(dev, opp_table);
 814
 815         if (ret)
 816                 dev_pm_opp_put_opp_table(opp_table);
 817
 818         return ret;
 819 }
 820 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);
 821
 822 /**
 823  * dev_pm_opp_of_add_table_indexed() - Initialize indexed opp table from device tree
 824  * @dev:        device pointer used to lookup OPP table.
 825  * @index:      Index number.
 826  *
 827  * Register the initial OPP table with the OPP library for given device only
 828  * using the "operating-points-v2" property.
 829  *
 830  * Return:
 831  * 0            On success OR
 832  *              Duplicate OPPs (both freq and volt are same) and opp->available
 833  * -EEXIST      Freq are same and volt are different OR
 834  *              Duplicate OPPs (both freq and volt are same) and !opp->available
 835  * -ENOMEM      Memory allocation failure
 836  * -ENODEV      when 'operating-points' property is not found or is invalid data
 837  *              in device node.
 838  * -ENODATA     when empty 'operating-points' property is found
 839  * -EINVAL      when invalid entries are found in opp-v2 table
 840  */
 841 int dev_pm_opp_of_add_table_indexed(struct device *dev, int index)
 842 {
 843         struct opp_table *opp_table;
 844         int ret, count;
 845
 846         if (index) {
 847                 /*
 848                  * If only one phandle is present, then the same OPP table
 849                  * applies for all index requests.
 850                  */
 851                 count = of_count_phandle_with_args(dev->of_node,
 852                                                    "operating-points-v2", NULL);
 853                 if (count == 1)
 854                         index = 0;
 855         }
 856
 857         opp_table = dev_pm_opp_get_opp_table_indexed(dev, index);
 858         if (!opp_table)
 859                 return -ENOMEM;
 860
 861         ret = _of_add_opp_table_v2(dev, opp_table);
 862         if (ret)
 863                 dev_pm_opp_put_opp_table(opp_table);
 864
 865         return ret;
 866 }
 867 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_indexed);
 868
 869 /* CPU device specific helpers */
 870
 871 /**
 872  * dev_pm_opp_of_cpumask_remove_table() - Removes OPP table for @cpumask
 873  * @cpumask:    cpumask for which OPP table needs to be removed
 874  *
 875  * This removes the OPP tables for CPUs present in the @cpumask.
 876  * This should be used only to remove static entries created from DT.
 877  */
 878 void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask)
 879 {
 880         _dev_pm_opp_cpumask_remove_table(cpumask, -1);
 881 }
 882 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table);
 883
 884 /**
 885  * dev_pm_opp_of_cpumask_add_table() - Adds OPP table for @cpumask
 886  * @cpumask:    cpumask for which OPP table needs to be added.
 887  *
 888  * This adds the OPP tables for CPUs present in the @cpumask.
 889  */
 890 int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask)
 891 {
 892         struct device *cpu_dev;
 893         int cpu, ret;
 894
 895         if (WARN_ON(cpumask_empty(cpumask)))
 896                 return -ENODEV;
 897
 898         for_each_cpu(cpu, cpumask) {
 899                 cpu_dev = get_cpu_device(cpu);
 900                 if (!cpu_dev) {
 901                         pr_err("%s: failed to get cpu%d device\n", __func__,
 902                                cpu);
 903                         ret = -ENODEV;
 904                         goto remove_table;
 905                 }
 906
 907                 ret = dev_pm_opp_of_add_table(cpu_dev);
 908                 if (ret) {
 909                         /*
 910                          * OPP may get registered dynamically, don't print error
 911                          * message here.
 912                          */
 913                         pr_debug("%s: couldn't find opp table for cpu:%d, %d\n",
 914                                  __func__, cpu, ret);
 915
 916                         goto remove_table;
 917                 }
 918         }
 919
 920         return 0;
 921
 922 remove_table:
 923         /* Free all other OPPs */
 924         _dev_pm_opp_cpumask_remove_table(cpumask, cpu);
 925
 926         return ret;
 927 }
 928 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table);
 929
 930 /*
 931  * Works only for OPP v2 bindings.
 932  *
 933  * Returns -ENOENT if operating-points-v2 bindings aren't supported.
 934  */
 935 /**
 936  * dev_pm_opp_of_get_sharing_cpus() - Get cpumask of CPUs sharing OPPs with
 937  *                                    @cpu_dev using operating-points-v2
 938  *                                    bindings.
 939  *
 940  * @cpu_dev:    CPU device for which we do this operation
 941  * @cpumask:    cpumask to update with information of sharing CPUs
 942  *
 943  * This updates the @cpumask with CPUs that are sharing OPPs with @cpu_dev.
 944  *
 945  * Returns -ENOENT if operating-points-v2 isn't present for @cpu_dev.
 946  */
 947 int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev,
 948                                    struct cpumask *cpumask)
 949 {
 950         struct device_node *np, *tmp_np, *cpu_np;
 951         int cpu, ret = 0;
 952
 953         /* Get OPP descriptor node */
 954         np = dev_pm_opp_of_get_opp_desc_node(cpu_dev);
 955         if (!np) {
 956                 dev_dbg(cpu_dev, "%s: Couldn't find opp node.\n", __func__);
 957                 return -ENOENT;
 958         }
 959
 960         cpumask_set_cpu(cpu_dev->id, cpumask);
 961
 962         /* OPPs are shared ? */
 963         if (!of_property_read_bool(np, "opp-shared"))
 964                 goto put_cpu_node;
 965
 966         for_each_possible_cpu(cpu) {
 967                 if (cpu == cpu_dev->id)
 968                         continue;
 969
 970                 cpu_np = of_cpu_device_node_get(cpu);
 971                 if (!cpu_np) {
 972                         dev_err(cpu_dev, "%s: failed to get cpu%d node\n",
 973                                 __func__, cpu);
 974                         ret = -ENOENT;
 975                         goto put_cpu_node;
 976                 }
 977
 978                 /* Get OPP descriptor node */
 979                 tmp_np = _opp_of_get_opp_desc_node(cpu_np, 0);
 980                 of_node_put(cpu_np);
 981                 if (!tmp_np) {
 982                         pr_err("%pOF: Couldn't find opp node\n", cpu_np);
 983                         ret = -ENOENT;
 984                         goto put_cpu_node;
 985                 }
 986
 987                 /* CPUs are sharing opp node */
 988                 if (np == tmp_np)
 989                         cpumask_set_cpu(cpu, cpumask);
 990
 991                 of_node_put(tmp_np);
 992         }
 993
 994 put_cpu_node:
 995         of_node_put(np);
 996         return ret;
 997 }
 998 EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus);
 999
1000 /**
1001  * of_get_required_opp_performance_state() - Search for required OPP and return its performance state.
1002  * @np: Node that contains the "required-opps" property.
1003  * @index: Index of the phandle to parse.
1004  *
1005  * Returns the performance state of the OPP pointed out by the "required-opps"
1006  * property at @index in @np.
1007  *
1008  * Return: Zero or positive performance state on success, otherwise negative
1009  * value on errors.
1010  */
1011 int of_get_required_opp_performance_state(struct device_node *np, int index)
1012 {
1013         struct dev_pm_opp *opp;
1014         struct device_node *required_np;
1015         struct opp_table *opp_table;
1016         int pstate = -EINVAL;
1017
1018         required_np = of_parse_required_opp(np, index);
1019         if (!required_np)
1020                 return -EINVAL;
1021
1022         opp_table = _find_table_of_opp_np(required_np);
1023         if (IS_ERR(opp_table)) {
1024                 pr_err("%s: Failed to find required OPP table %pOF: %ld\n",
1025                        __func__, np, PTR_ERR(opp_table));
1026                 goto put_required_np;
1027         }
1028
1029         opp = _find_opp_of_np(opp_table, required_np);
1030         if (opp) {
1031                 pstate = opp->pstate;
1032                 dev_pm_opp_put(opp);
1033         }
1034
1035         dev_pm_opp_put_opp_table(opp_table);
1036
1037 put_required_np:
1038         of_node_put(required_np);
1039
1040         return pstate;
1041 }
1042 EXPORT_SYMBOL_GPL(of_get_required_opp_performance_state);
1043
1044 /**
1045  * dev_pm_opp_get_of_node() - Gets the DT node corresponding to an opp
1046  * @opp:        opp for which DT node has to be returned for
1047  *
1048  * Return: DT node corresponding to the opp, else 0 on success.
1049  *
1050  * The caller needs to put the node with of_node_put() after using it.
1051  */
1052 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
1053 {
1054         if (IS_ERR_OR_NULL(opp)) {
1055                 pr_err("%s: Invalid parameters\n", __func__);
1056                 return NULL;
1057         }
1058
1059         return of_node_get(opp->np);
1060 }
1061 EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node);
1062
1063 /*
1064  * Callback function provided to the Energy Model framework upon registration.
1065  * This computes the power estimated by @CPU at @kHz if it is the frequency
1066  * of an existing OPP, or at the frequency of the first OPP above @kHz otherwise
1067  * (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled
1068  * frequency and @mW to the associated power. The power is estimated as
1069  * P = C * V^2 * f with C being the CPU's capacitance and V and f respectively
1070  * the voltage and frequency of the OPP.
1071  *
1072  * Returns -ENODEV if the CPU device cannot be found, -EINVAL if the power
1073  * calculation failed because of missing parameters, 0 otherwise.
1074  */
1075 static int __maybe_unused _get_cpu_power(unsigned long *mW, unsigned long *kHz,
1076                                          int cpu)
1077 {
1078         struct device *cpu_dev;
1079         struct dev_pm_opp *opp;
1080         struct device_node *np;
1081         unsigned long mV, Hz;
1082         u32 cap;
1083         u64 tmp;
1084         int ret;
1085
1086         cpu_dev = get_cpu_device(cpu);
1087         if (!cpu_dev)
1088                 return -ENODEV;
1089
1090         np = of_node_get(cpu_dev->of_node);
1091         if (!np)
1092                 return -EINVAL;
1093
1094         ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
1095         of_node_put(np);
1096         if (ret)
1097                 return -EINVAL;
1098
1099         Hz = *kHz * 1000;
1100         opp = dev_pm_opp_find_freq_ceil(cpu_dev, &Hz);
1101         if (IS_ERR(opp))
1102                 return -EINVAL;
1103
1104         mV = dev_pm_opp_get_voltage(opp) / 1000;
1105         dev_pm_opp_put(opp);
1106         if (!mV)
1107                 return -EINVAL;
1108
1109         tmp = (u64)cap * mV * mV * (Hz / 1000000);
1110         do_div(tmp, 1000000000);
1111
1112         *mW = (unsigned long)tmp;
1113         *kHz = Hz / 1000;
1114
1115         return 0;
1116 }
1117
1118 /**
1119  * dev_pm_opp_of_register_em() - Attempt to register an Energy Model
1120  * @cpus        : CPUs for which an Energy Model has to be registered
1121  *
1122  * This checks whether the "dynamic-power-coefficient" devicetree property has
1123  * been specified, and tries to register an Energy Model with it if it has.
1124  */
1125 void dev_pm_opp_of_register_em(struct cpumask *cpus)
1126 {
1127         struct em_data_callback em_cb = EM_DATA_CB(_get_cpu_power);
1128         int ret, nr_opp, cpu = cpumask_first(cpus);
1129         struct device *cpu_dev;
1130         struct device_node *np;
1131         u32 cap;
1132
1133         cpu_dev = get_cpu_device(cpu);
1134         if (!cpu_dev)
1135                 return;
1136
1137         nr_opp = dev_pm_opp_get_opp_count(cpu_dev);
1138         if (nr_opp <= 0)
1139                 return;
1140
1141         np = of_node_get(cpu_dev->of_node);
1142         if (!np)
1143                 return;
1144
1145         /*
1146          * Register an EM only if the 'dynamic-power-coefficient' property is
1147          * set in devicetree. It is assumed the voltage values are known if that
1148          * property is set since it is useless otherwise. If voltages are not
1149          * known, just let the EM registration fail with an error to alert the
1150          * user about the inconsistent configuration.
1151          */
1152         ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
1153         of_node_put(np);
1154         if (ret || !cap)
1155                 return;
1156
1157         em_register_perf_domain(cpus, nr_opp, &em_cb);
1158 }
1159 EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em);