1675 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Generic OPP OF helpers4 *5 * Copyright (C) 2009-2010 Texas Instruments Incorporated.6 * Nishanth Menon7 * Romit Dasgupta8 * Kevin Hilman9 */10 11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt12 13#include <linux/cpu.h>14#include <linux/errno.h>15#include <linux/device.h>16#include <linux/of.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/* OPP tables with uninitialized required OPPs, protected by opp_table_lock */25static LIST_HEAD(lazy_opp_tables);26 27/*28 * Returns opp descriptor node for a device node, caller must29 * do of_node_put().30 */31static struct device_node *_opp_of_get_opp_desc_node(struct device_node *np,32 int index)33{34 /* "operating-points-v2" can be an array for power domain providers */35 return of_parse_phandle(np, "operating-points-v2", index);36}37 38/* Returns opp descriptor node for a device, caller must do of_node_put() */39struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev)40{41 return _opp_of_get_opp_desc_node(dev->of_node, 0);42}43EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_opp_desc_node);44 45struct opp_table *_managed_opp(struct device *dev, int index)46{47 struct opp_table *opp_table, *managed_table = NULL;48 struct device_node *np;49 50 np = _opp_of_get_opp_desc_node(dev->of_node, index);51 if (!np)52 return NULL;53 54 list_for_each_entry(opp_table, &opp_tables, node) {55 if (opp_table->np == np) {56 /*57 * Multiple devices can point to the same OPP table and58 * so will have same node-pointer, np.59 *60 * But the OPPs will be considered as shared only if the61 * OPP table contains a "opp-shared" property.62 */63 if (opp_table->shared_opp == OPP_TABLE_ACCESS_SHARED) {64 _get_opp_table_kref(opp_table);65 managed_table = opp_table;66 }67 68 break;69 }70 }71 72 of_node_put(np);73 74 return managed_table;75}76 77/* The caller must call dev_pm_opp_put() after the OPP is used */78static struct dev_pm_opp *_find_opp_of_np(struct opp_table *opp_table,79 struct device_node *opp_np)80{81 struct dev_pm_opp *opp;82 83 mutex_lock(&opp_table->lock);84 85 list_for_each_entry(opp, &opp_table->opp_list, node) {86 if (opp->np == opp_np) {87 dev_pm_opp_get(opp);88 mutex_unlock(&opp_table->lock);89 return opp;90 }91 }92 93 mutex_unlock(&opp_table->lock);94 95 return NULL;96}97 98static struct device_node *of_parse_required_opp(struct device_node *np,99 int index)100{101 return of_parse_phandle(np, "required-opps", index);102}103 104/* The caller must call dev_pm_opp_put_opp_table() after the table is used */105static struct opp_table *_find_table_of_opp_np(struct device_node *opp_np)106{107 struct opp_table *opp_table;108 struct device_node *opp_table_np;109 110 opp_table_np = of_get_parent(opp_np);111 if (!opp_table_np)112 goto err;113 114 /* It is safe to put the node now as all we need now is its address */115 of_node_put(opp_table_np);116 117 mutex_lock(&opp_table_lock);118 list_for_each_entry(opp_table, &opp_tables, node) {119 if (opp_table_np == opp_table->np) {120 _get_opp_table_kref(opp_table);121 mutex_unlock(&opp_table_lock);122 return opp_table;123 }124 }125 mutex_unlock(&opp_table_lock);126 127err:128 return ERR_PTR(-ENODEV);129}130 131/* Free resources previously acquired by _opp_table_alloc_required_tables() */132static void _opp_table_free_required_tables(struct opp_table *opp_table)133{134 struct opp_table **required_opp_tables = opp_table->required_opp_tables;135 int i;136 137 if (!required_opp_tables)138 return;139 140 for (i = 0; i < opp_table->required_opp_count; i++) {141 if (IS_ERR_OR_NULL(required_opp_tables[i]))142 continue;143 144 dev_pm_opp_put_opp_table(required_opp_tables[i]);145 }146 147 kfree(required_opp_tables);148 149 opp_table->required_opp_count = 0;150 opp_table->required_opp_tables = NULL;151 152 mutex_lock(&opp_table_lock);153 list_del(&opp_table->lazy);154 mutex_unlock(&opp_table_lock);155}156 157/*158 * Populate all devices and opp tables which are part of "required-opps" list.159 * Checking only the first OPP node should be enough.160 */161static void _opp_table_alloc_required_tables(struct opp_table *opp_table,162 struct device *dev,163 struct device_node *opp_np)164{165 struct opp_table **required_opp_tables;166 struct device_node *required_np, *np;167 bool lazy = false;168 int count, i, size;169 170 /* Traversing the first OPP node is all we need */171 np = of_get_next_available_child(opp_np, NULL);172 if (!np) {173 dev_warn(dev, "Empty OPP table\n");174 175 return;176 }177 178 count = of_count_phandle_with_args(np, "required-opps", NULL);179 if (count <= 0)180 goto put_np;181 182 size = sizeof(*required_opp_tables) + sizeof(*opp_table->required_devs);183 required_opp_tables = kcalloc(count, size, GFP_KERNEL);184 if (!required_opp_tables)185 goto put_np;186 187 opp_table->required_opp_tables = required_opp_tables;188 opp_table->required_devs = (void *)(required_opp_tables + count);189 opp_table->required_opp_count = count;190 191 for (i = 0; i < count; i++) {192 required_np = of_parse_required_opp(np, i);193 if (!required_np)194 goto free_required_tables;195 196 required_opp_tables[i] = _find_table_of_opp_np(required_np);197 of_node_put(required_np);198 199 if (IS_ERR(required_opp_tables[i]))200 lazy = true;201 }202 203 /* Let's do the linking later on */204 if (lazy) {205 /*206 * The OPP table is not held while allocating the table, take it207 * now to avoid corruption to the lazy_opp_tables list.208 */209 mutex_lock(&opp_table_lock);210 list_add(&opp_table->lazy, &lazy_opp_tables);211 mutex_unlock(&opp_table_lock);212 }213 214 goto put_np;215 216free_required_tables:217 _opp_table_free_required_tables(opp_table);218put_np:219 of_node_put(np);220}221 222void _of_init_opp_table(struct opp_table *opp_table, struct device *dev,223 int index)224{225 struct device_node *np, *opp_np;226 u32 val;227 228 /*229 * Only required for backward compatibility with v1 bindings, but isn't230 * harmful for other cases. And so we do it unconditionally.231 */232 np = of_node_get(dev->of_node);233 if (!np)234 return;235 236 if (!of_property_read_u32(np, "clock-latency", &val))237 opp_table->clock_latency_ns_max = val;238 of_property_read_u32(np, "voltage-tolerance",239 &opp_table->voltage_tolerance_v1);240 241 if (of_property_present(np, "#power-domain-cells"))242 opp_table->is_genpd = true;243 244 /* Get OPP table node */245 opp_np = _opp_of_get_opp_desc_node(np, index);246 of_node_put(np);247 248 if (!opp_np)249 return;250 251 if (of_property_read_bool(opp_np, "opp-shared"))252 opp_table->shared_opp = OPP_TABLE_ACCESS_SHARED;253 else254 opp_table->shared_opp = OPP_TABLE_ACCESS_EXCLUSIVE;255 256 opp_table->np = opp_np;257 258 _opp_table_alloc_required_tables(opp_table, dev, opp_np);259}260 261void _of_clear_opp_table(struct opp_table *opp_table)262{263 _opp_table_free_required_tables(opp_table);264 of_node_put(opp_table->np);265}266 267/*268 * Release all resources previously acquired with a call to269 * _of_opp_alloc_required_opps().270 */271static void _of_opp_free_required_opps(struct opp_table *opp_table,272 struct dev_pm_opp *opp)273{274 struct dev_pm_opp **required_opps = opp->required_opps;275 int i;276 277 if (!required_opps)278 return;279 280 for (i = 0; i < opp_table->required_opp_count; i++) {281 if (!required_opps[i])282 continue;283 284 /* Put the reference back */285 dev_pm_opp_put(required_opps[i]);286 }287 288 opp->required_opps = NULL;289 kfree(required_opps);290}291 292void _of_clear_opp(struct opp_table *opp_table, struct dev_pm_opp *opp)293{294 _of_opp_free_required_opps(opp_table, opp);295 of_node_put(opp->np);296}297 298static int _link_required_opps(struct dev_pm_opp *opp, struct opp_table *opp_table,299 struct opp_table *required_table, int index)300{301 struct device_node *np;302 303 np = of_parse_required_opp(opp->np, index);304 if (unlikely(!np))305 return -ENODEV;306 307 opp->required_opps[index] = _find_opp_of_np(required_table, np);308 of_node_put(np);309 310 if (!opp->required_opps[index]) {311 pr_err("%s: Unable to find required OPP node: %pOF (%d)\n",312 __func__, opp->np, index);313 return -ENODEV;314 }315 316 /*317 * There are two genpd (as required-opp) cases that we need to handle,318 * devices with a single genpd and ones with multiple genpds.319 *320 * The single genpd case requires special handling as we need to use the321 * same `dev` structure (instead of a virtual one provided by genpd322 * core) for setting the performance state.323 *324 * It doesn't make sense for a device's DT entry to have both325 * "opp-level" and single "required-opps" entry pointing to a genpd's326 * OPP, as that would make the OPP core call327 * dev_pm_domain_set_performance_state() for two different values for328 * the same device structure. Lets treat single genpd configuration as a329 * case where the OPP's level is directly available without required-opp330 * link in the DT.331 *332 * Just update the `level` with the right value, which333 * dev_pm_opp_set_opp() will take care of in the normal path itself.334 *335 * There is another case though, where a genpd's OPP table has336 * required-opps set to a parent genpd. The OPP core expects the user to337 * set the respective required `struct device` pointer via338 * dev_pm_opp_set_config().339 */340 if (required_table->is_genpd && opp_table->required_opp_count == 1 &&341 !opp_table->required_devs[0]) {342 /* Genpd core takes care of propagation to parent genpd */343 if (!opp_table->is_genpd) {344 if (!WARN_ON(opp->level != OPP_LEVEL_UNSET))345 opp->level = opp->required_opps[0]->level;346 }347 }348 349 return 0;350}351 352/* Populate all required OPPs which are part of "required-opps" list */353static int _of_opp_alloc_required_opps(struct opp_table *opp_table,354 struct dev_pm_opp *opp)355{356 struct opp_table *required_table;357 int i, ret, count = opp_table->required_opp_count;358 359 if (!count)360 return 0;361 362 opp->required_opps = kcalloc(count, sizeof(*opp->required_opps), GFP_KERNEL);363 if (!opp->required_opps)364 return -ENOMEM;365 366 for (i = 0; i < count; i++) {367 required_table = opp_table->required_opp_tables[i];368 369 /* Required table not added yet, we will link later */370 if (IS_ERR_OR_NULL(required_table))371 continue;372 373 ret = _link_required_opps(opp, opp_table, required_table, i);374 if (ret)375 goto free_required_opps;376 }377 378 return 0;379 380free_required_opps:381 _of_opp_free_required_opps(opp_table, opp);382 383 return ret;384}385 386/* Link required OPPs for an individual OPP */387static int lazy_link_required_opps(struct opp_table *opp_table,388 struct opp_table *new_table, int index)389{390 struct dev_pm_opp *opp;391 int ret;392 393 list_for_each_entry(opp, &opp_table->opp_list, node) {394 ret = _link_required_opps(opp, opp_table, new_table, index);395 if (ret)396 return ret;397 }398 399 return 0;400}401 402/* Link required OPPs for all OPPs of the newly added OPP table */403static void lazy_link_required_opp_table(struct opp_table *new_table)404{405 struct opp_table *opp_table, *temp, **required_opp_tables;406 struct device_node *required_np, *opp_np, *required_table_np;407 struct dev_pm_opp *opp;408 int i, ret;409 410 mutex_lock(&opp_table_lock);411 412 list_for_each_entry_safe(opp_table, temp, &lazy_opp_tables, lazy) {413 bool lazy = false;414 415 /* opp_np can't be invalid here */416 opp_np = of_get_next_available_child(opp_table->np, NULL);417 418 for (i = 0; i < opp_table->required_opp_count; i++) {419 required_opp_tables = opp_table->required_opp_tables;420 421 /* Required opp-table is already parsed */422 if (!IS_ERR(required_opp_tables[i]))423 continue;424 425 /* required_np can't be invalid here */426 required_np = of_parse_required_opp(opp_np, i);427 required_table_np = of_get_parent(required_np);428 429 of_node_put(required_table_np);430 of_node_put(required_np);431 432 /*433 * Newly added table isn't the required opp-table for434 * opp_table.435 */436 if (required_table_np != new_table->np) {437 lazy = true;438 continue;439 }440 441 required_opp_tables[i] = new_table;442 _get_opp_table_kref(new_table);443 444 /* Link OPPs now */445 ret = lazy_link_required_opps(opp_table, new_table, i);446 if (ret) {447 /* The OPPs will be marked unusable */448 lazy = false;449 break;450 }451 }452 453 of_node_put(opp_np);454 455 /* All required opp-tables found, remove from lazy list */456 if (!lazy) {457 list_del_init(&opp_table->lazy);458 459 list_for_each_entry(opp, &opp_table->opp_list, node)460 _required_opps_available(opp, opp_table->required_opp_count);461 }462 }463 464 mutex_unlock(&opp_table_lock);465}466 467static int _bandwidth_supported(struct device *dev, struct opp_table *opp_table)468{469 struct device_node *np, *opp_np;470 struct property *prop;471 472 if (!opp_table) {473 np = of_node_get(dev->of_node);474 if (!np)475 return -ENODEV;476 477 opp_np = _opp_of_get_opp_desc_node(np, 0);478 of_node_put(np);479 } else {480 opp_np = of_node_get(opp_table->np);481 }482 483 /* Lets not fail in case we are parsing opp-v1 bindings */484 if (!opp_np)485 return 0;486 487 /* Checking only first OPP is sufficient */488 np = of_get_next_available_child(opp_np, NULL);489 of_node_put(opp_np);490 if (!np) {491 dev_err(dev, "OPP table empty\n");492 return -EINVAL;493 }494 495 prop = of_find_property(np, "opp-peak-kBps", NULL);496 of_node_put(np);497 498 if (!prop || !prop->length)499 return 0;500 501 return 1;502}503 504int dev_pm_opp_of_find_icc_paths(struct device *dev,505 struct opp_table *opp_table)506{507 struct device_node *np;508 int ret, i, count, num_paths;509 struct icc_path **paths;510 511 ret = _bandwidth_supported(dev, opp_table);512 if (ret == -EINVAL)513 return 0; /* Empty OPP table is a valid corner-case, let's not fail */514 else if (ret <= 0)515 return ret;516 517 ret = 0;518 519 np = of_node_get(dev->of_node);520 if (!np)521 return 0;522 523 count = of_count_phandle_with_args(np, "interconnects",524 "#interconnect-cells");525 of_node_put(np);526 if (count < 0)527 return 0;528 529 /* two phandles when #interconnect-cells = <1> */530 if (count % 2) {531 dev_err(dev, "%s: Invalid interconnects values\n", __func__);532 return -EINVAL;533 }534 535 num_paths = count / 2;536 paths = kcalloc(num_paths, sizeof(*paths), GFP_KERNEL);537 if (!paths)538 return -ENOMEM;539 540 for (i = 0; i < num_paths; i++) {541 paths[i] = of_icc_get_by_index(dev, i);542 if (IS_ERR(paths[i])) {543 ret = dev_err_probe(dev, PTR_ERR(paths[i]), "%s: Unable to get path%d\n", __func__, i);544 goto err;545 }546 }547 548 if (opp_table) {549 opp_table->paths = paths;550 opp_table->path_count = num_paths;551 return 0;552 }553 554err:555 while (i--)556 icc_put(paths[i]);557 558 kfree(paths);559 560 return ret;561}562EXPORT_SYMBOL_GPL(dev_pm_opp_of_find_icc_paths);563 564static bool _opp_is_supported(struct device *dev, struct opp_table *opp_table,565 struct device_node *np)566{567 unsigned int levels = opp_table->supported_hw_count;568 int count, versions, ret, i, j;569 u32 val;570 571 if (!opp_table->supported_hw) {572 /*573 * In the case that no supported_hw has been set by the574 * platform but there is an opp-supported-hw value set for575 * an OPP then the OPP should not be enabled as there is576 * no way to see if the hardware supports it.577 */578 if (of_property_present(np, "opp-supported-hw"))579 return false;580 else581 return true;582 }583 584 count = of_property_count_u32_elems(np, "opp-supported-hw");585 if (count <= 0 || count % levels) {586 dev_err(dev, "%s: Invalid opp-supported-hw property (%d)\n",587 __func__, count);588 return false;589 }590 591 versions = count / levels;592 593 /* All levels in at least one of the versions should match */594 for (i = 0; i < versions; i++) {595 bool supported = true;596 597 for (j = 0; j < levels; j++) {598 ret = of_property_read_u32_index(np, "opp-supported-hw",599 i * levels + j, &val);600 if (ret) {601 dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n",602 __func__, i * levels + j, ret);603 return false;604 }605 606 /* Check if the level is supported */607 if (!(val & opp_table->supported_hw[j])) {608 supported = false;609 break;610 }611 }612 613 if (supported)614 return true;615 }616 617 return false;618}619 620static u32 *_parse_named_prop(struct dev_pm_opp *opp, struct device *dev,621 struct opp_table *opp_table,622 const char *prop_type, bool *triplet)623{624 struct property *prop = NULL;625 char name[NAME_MAX];626 int count, ret;627 u32 *out;628 629 /* Search for "opp-<prop_type>-<name>" */630 if (opp_table->prop_name) {631 snprintf(name, sizeof(name), "opp-%s-%s", prop_type,632 opp_table->prop_name);633 prop = of_find_property(opp->np, name, NULL);634 }635 636 if (!prop) {637 /* Search for "opp-<prop_type>" */638 snprintf(name, sizeof(name), "opp-%s", prop_type);639 prop = of_find_property(opp->np, name, NULL);640 if (!prop)641 return NULL;642 }643 644 count = of_property_count_u32_elems(opp->np, name);645 if (count < 0) {646 dev_err(dev, "%s: Invalid %s property (%d)\n", __func__, name,647 count);648 return ERR_PTR(count);649 }650 651 /*652 * Initialize regulator_count, if regulator information isn't provided653 * by the platform. Now that one of the properties is available, fix the654 * regulator_count to 1.655 */656 if (unlikely(opp_table->regulator_count == -1))657 opp_table->regulator_count = 1;658 659 if (count != opp_table->regulator_count &&660 (!triplet || count != opp_table->regulator_count * 3)) {661 dev_err(dev, "%s: Invalid number of elements in %s property (%u) with supplies (%d)\n",662 __func__, prop_type, count, opp_table->regulator_count);663 return ERR_PTR(-EINVAL);664 }665 666 out = kmalloc_array(count, sizeof(*out), GFP_KERNEL);667 if (!out)668 return ERR_PTR(-EINVAL);669 670 ret = of_property_read_u32_array(opp->np, name, out, count);671 if (ret) {672 dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret);673 kfree(out);674 return ERR_PTR(-EINVAL);675 }676 677 if (triplet)678 *triplet = count != opp_table->regulator_count;679 680 return out;681}682 683static u32 *opp_parse_microvolt(struct dev_pm_opp *opp, struct device *dev,684 struct opp_table *opp_table, bool *triplet)685{686 u32 *microvolt;687 688 microvolt = _parse_named_prop(opp, dev, opp_table, "microvolt", triplet);689 if (IS_ERR(microvolt))690 return microvolt;691 692 if (!microvolt) {693 /*694 * Missing property isn't a problem, but an invalid695 * entry is. This property isn't optional if regulator696 * information is provided. Check only for the first OPP, as697 * regulator_count may get initialized after that to a valid698 * value.699 */700 if (list_empty(&opp_table->opp_list) &&701 opp_table->regulator_count > 0) {702 dev_err(dev, "%s: opp-microvolt missing although OPP managing regulators\n",703 __func__);704 return ERR_PTR(-EINVAL);705 }706 }707 708 return microvolt;709}710 711static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev,712 struct opp_table *opp_table)713{714 u32 *microvolt, *microamp, *microwatt;715 int ret = 0, i, j;716 bool triplet;717 718 microvolt = opp_parse_microvolt(opp, dev, opp_table, &triplet);719 if (IS_ERR(microvolt))720 return PTR_ERR(microvolt);721 722 microamp = _parse_named_prop(opp, dev, opp_table, "microamp", NULL);723 if (IS_ERR(microamp)) {724 ret = PTR_ERR(microamp);725 goto free_microvolt;726 }727 728 microwatt = _parse_named_prop(opp, dev, opp_table, "microwatt", NULL);729 if (IS_ERR(microwatt)) {730 ret = PTR_ERR(microwatt);731 goto free_microamp;732 }733 734 /*735 * Initialize regulator_count if it is uninitialized and no properties736 * are found.737 */738 if (unlikely(opp_table->regulator_count == -1)) {739 opp_table->regulator_count = 0;740 return 0;741 }742 743 for (i = 0, j = 0; i < opp_table->regulator_count; i++) {744 if (microvolt) {745 opp->supplies[i].u_volt = microvolt[j++];746 747 if (triplet) {748 opp->supplies[i].u_volt_min = microvolt[j++];749 opp->supplies[i].u_volt_max = microvolt[j++];750 } else {751 opp->supplies[i].u_volt_min = opp->supplies[i].u_volt;752 opp->supplies[i].u_volt_max = opp->supplies[i].u_volt;753 }754 }755 756 if (microamp)757 opp->supplies[i].u_amp = microamp[i];758 759 if (microwatt)760 opp->supplies[i].u_watt = microwatt[i];761 }762 763 kfree(microwatt);764free_microamp:765 kfree(microamp);766free_microvolt:767 kfree(microvolt);768 769 return ret;770}771 772/**773 * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT774 * entries775 * @dev: device pointer used to lookup OPP table.776 *777 * Free OPPs created using static entries present in DT.778 */779void dev_pm_opp_of_remove_table(struct device *dev)780{781 dev_pm_opp_remove_table(dev);782}783EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);784 785static int _read_rate(struct dev_pm_opp *new_opp, struct opp_table *opp_table,786 struct device_node *np)787{788 struct property *prop;789 int i, count, ret;790 u64 *rates;791 792 prop = of_find_property(np, "opp-hz", NULL);793 if (!prop)794 return -ENODEV;795 796 count = prop->length / sizeof(u64);797 if (opp_table->clk_count != count) {798 pr_err("%s: Count mismatch between opp-hz and clk_count (%d %d)\n",799 __func__, count, opp_table->clk_count);800 return -EINVAL;801 }802 803 rates = kmalloc_array(count, sizeof(*rates), GFP_KERNEL);804 if (!rates)805 return -ENOMEM;806 807 ret = of_property_read_u64_array(np, "opp-hz", rates, count);808 if (ret) {809 pr_err("%s: Error parsing opp-hz: %d\n", __func__, ret);810 } else {811 /*812 * Rate is defined as an unsigned long in clk API, and so813 * casting explicitly to its type. Must be fixed once rate is 64814 * bit guaranteed in clk API.815 */816 for (i = 0; i < count; i++) {817 new_opp->rates[i] = (unsigned long)rates[i];818 819 /* This will happen for frequencies > 4.29 GHz */820 WARN_ON(new_opp->rates[i] != rates[i]);821 }822 }823 824 kfree(rates);825 826 return ret;827}828 829static int _read_bw(struct dev_pm_opp *new_opp, struct opp_table *opp_table,830 struct device_node *np, bool peak)831{832 const char *name = peak ? "opp-peak-kBps" : "opp-avg-kBps";833 struct property *prop;834 int i, count, ret;835 u32 *bw;836 837 prop = of_find_property(np, name, NULL);838 if (!prop)839 return -ENODEV;840 841 count = prop->length / sizeof(u32);842 if (opp_table->path_count != count) {843 pr_err("%s: Mismatch between %s and paths (%d %d)\n",844 __func__, name, count, opp_table->path_count);845 return -EINVAL;846 }847 848 bw = kmalloc_array(count, sizeof(*bw), GFP_KERNEL);849 if (!bw)850 return -ENOMEM;851 852 ret = of_property_read_u32_array(np, name, bw, count);853 if (ret) {854 pr_err("%s: Error parsing %s: %d\n", __func__, name, ret);855 goto out;856 }857 858 for (i = 0; i < count; i++) {859 if (peak)860 new_opp->bandwidth[i].peak = kBps_to_icc(bw[i]);861 else862 new_opp->bandwidth[i].avg = kBps_to_icc(bw[i]);863 }864 865out:866 kfree(bw);867 return ret;868}869 870static int _read_opp_key(struct dev_pm_opp *new_opp,871 struct opp_table *opp_table, struct device_node *np)872{873 bool found = false;874 int ret;875 876 ret = _read_rate(new_opp, opp_table, np);877 if (!ret)878 found = true;879 else if (ret != -ENODEV)880 return ret;881 882 /*883 * Bandwidth consists of peak and average (optional) values:884 * opp-peak-kBps = <path1_value path2_value>;885 * opp-avg-kBps = <path1_value path2_value>;886 */887 ret = _read_bw(new_opp, opp_table, np, true);888 if (!ret) {889 found = true;890 ret = _read_bw(new_opp, opp_table, np, false);891 }892 893 /* The properties were found but we failed to parse them */894 if (ret && ret != -ENODEV)895 return ret;896 897 if (!of_property_read_u32(np, "opp-level", &new_opp->level))898 found = true;899 900 if (found)901 return 0;902 903 return ret;904}905 906/**907 * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)908 * @opp_table: OPP table909 * @dev: device for which we do this operation910 * @np: device node911 *912 * This function adds an opp definition to the opp table and returns status. The913 * opp can be controlled using dev_pm_opp_enable/disable functions and may be914 * removed by dev_pm_opp_remove.915 *916 * Return:917 * Valid OPP pointer:918 * On success919 * NULL:920 * Duplicate OPPs (both freq and volt are same) and opp->available921 * OR if the OPP is not supported by hardware.922 * ERR_PTR(-EEXIST):923 * Freq are same and volt are different OR924 * Duplicate OPPs (both freq and volt are same) and !opp->available925 * ERR_PTR(-ENOMEM):926 * Memory allocation failure927 * ERR_PTR(-EINVAL):928 * Failed parsing the OPP node929 */930static struct dev_pm_opp *_opp_add_static_v2(struct opp_table *opp_table,931 struct device *dev, struct device_node *np)932{933 struct dev_pm_opp *new_opp;934 u32 val;935 int ret;936 937 new_opp = _opp_allocate(opp_table);938 if (!new_opp)939 return ERR_PTR(-ENOMEM);940 941 ret = _read_opp_key(new_opp, opp_table, np);942 if (ret < 0) {943 dev_err(dev, "%s: opp key field not found\n", __func__);944 goto free_opp;945 }946 947 /* Check if the OPP supports hardware's hierarchy of versions or not */948 if (!_opp_is_supported(dev, opp_table, np)) {949 dev_dbg(dev, "OPP not supported by hardware: %s\n",950 of_node_full_name(np));951 goto free_opp;952 }953 954 new_opp->turbo = of_property_read_bool(np, "turbo-mode");955 956 new_opp->np = of_node_get(np);957 new_opp->dynamic = false;958 new_opp->available = true;959 960 ret = _of_opp_alloc_required_opps(opp_table, new_opp);961 if (ret)962 goto free_opp;963 964 if (!of_property_read_u32(np, "clock-latency-ns", &val))965 new_opp->clock_latency_ns = val;966 967 ret = opp_parse_supplies(new_opp, dev, opp_table);968 if (ret)969 goto free_required_opps;970 971 ret = _opp_add(dev, new_opp, opp_table);972 if (ret) {973 /* Don't return error for duplicate OPPs */974 if (ret == -EBUSY)975 ret = 0;976 goto free_required_opps;977 }978 979 /* OPP to select on device suspend */980 if (of_property_read_bool(np, "opp-suspend")) {981 if (opp_table->suspend_opp) {982 /* Pick the OPP with higher rate/bw/level as suspend OPP */983 if (_opp_compare_key(opp_table, new_opp, opp_table->suspend_opp) == 1) {984 opp_table->suspend_opp->suspend = false;985 new_opp->suspend = true;986 opp_table->suspend_opp = new_opp;987 }988 } else {989 new_opp->suspend = true;990 opp_table->suspend_opp = new_opp;991 }992 }993 994 if (new_opp->clock_latency_ns > opp_table->clock_latency_ns_max)995 opp_table->clock_latency_ns_max = new_opp->clock_latency_ns;996 997 pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu level:%u\n",998 __func__, new_opp->turbo, new_opp->rates[0],999 new_opp->supplies[0].u_volt, new_opp->supplies[0].u_volt_min,1000 new_opp->supplies[0].u_volt_max, new_opp->clock_latency_ns,1001 new_opp->level);1002 1003 /*1004 * Notify the changes in the availability of the operable1005 * frequency/voltage list.1006 */1007 blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADD, new_opp);1008 return new_opp;1009 1010free_required_opps:1011 _of_opp_free_required_opps(opp_table, new_opp);1012free_opp:1013 _opp_free(new_opp);1014 1015 return ret ? ERR_PTR(ret) : NULL;1016}1017 1018/* Initializes OPP tables based on new bindings */1019static int _of_add_opp_table_v2(struct device *dev, struct opp_table *opp_table)1020{1021 struct device_node *np;1022 int ret, count = 0;1023 struct dev_pm_opp *opp;1024 1025 /* OPP table is already initialized for the device */1026 mutex_lock(&opp_table->lock);1027 if (opp_table->parsed_static_opps) {1028 opp_table->parsed_static_opps++;1029 mutex_unlock(&opp_table->lock);1030 return 0;1031 }1032 1033 opp_table->parsed_static_opps = 1;1034 mutex_unlock(&opp_table->lock);1035 1036 /* We have opp-table node now, iterate over it and add OPPs */1037 for_each_available_child_of_node(opp_table->np, np) {1038 opp = _opp_add_static_v2(opp_table, dev, np);1039 if (IS_ERR(opp)) {1040 ret = PTR_ERR(opp);1041 dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,1042 ret);1043 of_node_put(np);1044 goto remove_static_opp;1045 } else if (opp) {1046 count++;1047 }1048 }1049 1050 /* There should be one or more OPPs defined */1051 if (!count) {1052 dev_err(dev, "%s: no supported OPPs", __func__);1053 ret = -ENOENT;1054 goto remove_static_opp;1055 }1056 1057 lazy_link_required_opp_table(opp_table);1058 1059 return 0;1060 1061remove_static_opp:1062 _opp_remove_all_static(opp_table);1063 1064 return ret;1065}1066 1067/* Initializes OPP tables based on old-deprecated bindings */1068static int _of_add_opp_table_v1(struct device *dev, struct opp_table *opp_table)1069{1070 const struct property *prop;1071 const __be32 *val;1072 int nr, ret = 0;1073 1074 mutex_lock(&opp_table->lock);1075 if (opp_table->parsed_static_opps) {1076 opp_table->parsed_static_opps++;1077 mutex_unlock(&opp_table->lock);1078 return 0;1079 }1080 1081 opp_table->parsed_static_opps = 1;1082 mutex_unlock(&opp_table->lock);1083 1084 prop = of_find_property(dev->of_node, "operating-points", NULL);1085 if (!prop) {1086 ret = -ENODEV;1087 goto remove_static_opp;1088 }1089 if (!prop->value) {1090 ret = -ENODATA;1091 goto remove_static_opp;1092 }1093 1094 /*1095 * Each OPP is a set of tuples consisting of frequency and1096 * voltage like <freq-kHz vol-uV>.1097 */1098 nr = prop->length / sizeof(u32);1099 if (nr % 2) {1100 dev_err(dev, "%s: Invalid OPP table\n", __func__);1101 ret = -EINVAL;1102 goto remove_static_opp;1103 }1104 1105 val = prop->value;1106 while (nr) {1107 unsigned long freq = be32_to_cpup(val++) * 1000;1108 unsigned long volt = be32_to_cpup(val++);1109 struct dev_pm_opp_data data = {1110 .freq = freq,1111 .u_volt = volt,1112 };1113 1114 ret = _opp_add_v1(opp_table, dev, &data, false);1115 if (ret) {1116 dev_err(dev, "%s: Failed to add OPP %ld (%d)\n",1117 __func__, data.freq, ret);1118 goto remove_static_opp;1119 }1120 nr -= 2;1121 }1122 1123 return 0;1124 1125remove_static_opp:1126 _opp_remove_all_static(opp_table);1127 1128 return ret;1129}1130 1131static int _of_add_table_indexed(struct device *dev, int index)1132{1133 struct opp_table *opp_table;1134 int ret, count;1135 1136 if (index) {1137 /*1138 * If only one phandle is present, then the same OPP table1139 * applies for all index requests.1140 */1141 count = of_count_phandle_with_args(dev->of_node,1142 "operating-points-v2", NULL);1143 if (count == 1)1144 index = 0;1145 }1146 1147 opp_table = _add_opp_table_indexed(dev, index, true);1148 if (IS_ERR(opp_table))1149 return PTR_ERR(opp_table);1150 1151 /*1152 * OPPs have two version of bindings now. Also try the old (v1)1153 * bindings for backward compatibility with older dtbs.1154 */1155 if (opp_table->np)1156 ret = _of_add_opp_table_v2(dev, opp_table);1157 else1158 ret = _of_add_opp_table_v1(dev, opp_table);1159 1160 if (ret)1161 dev_pm_opp_put_opp_table(opp_table);1162 1163 return ret;1164}1165 1166static void devm_pm_opp_of_table_release(void *data)1167{1168 dev_pm_opp_of_remove_table(data);1169}1170 1171static int _devm_of_add_table_indexed(struct device *dev, int index)1172{1173 int ret;1174 1175 ret = _of_add_table_indexed(dev, index);1176 if (ret)1177 return ret;1178 1179 return devm_add_action_or_reset(dev, devm_pm_opp_of_table_release, dev);1180}1181 1182/**1183 * devm_pm_opp_of_add_table() - Initialize opp table from device tree1184 * @dev: device pointer used to lookup OPP table.1185 *1186 * Register the initial OPP table with the OPP library for given device.1187 *1188 * The opp_table structure will be freed after the device is destroyed.1189 *1190 * Return:1191 * 0 On success OR1192 * Duplicate OPPs (both freq and volt are same) and opp->available1193 * -EEXIST Freq are same and volt are different OR1194 * Duplicate OPPs (both freq and volt are same) and !opp->available1195 * -ENOMEM Memory allocation failure1196 * -ENODEV when 'operating-points' property is not found or is invalid data1197 * in device node.1198 * -ENODATA when empty 'operating-points' property is found1199 * -EINVAL when invalid entries are found in opp-v2 table1200 */1201int devm_pm_opp_of_add_table(struct device *dev)1202{1203 return _devm_of_add_table_indexed(dev, 0);1204}1205EXPORT_SYMBOL_GPL(devm_pm_opp_of_add_table);1206 1207/**1208 * dev_pm_opp_of_add_table() - Initialize opp table from device tree1209 * @dev: device pointer used to lookup OPP table.1210 *1211 * Register the initial OPP table with the OPP library for given device.1212 *1213 * Return:1214 * 0 On success OR1215 * Duplicate OPPs (both freq and volt are same) and opp->available1216 * -EEXIST Freq are same and volt are different OR1217 * Duplicate OPPs (both freq and volt are same) and !opp->available1218 * -ENOMEM Memory allocation failure1219 * -ENODEV when 'operating-points' property is not found or is invalid data1220 * in device node.1221 * -ENODATA when empty 'operating-points' property is found1222 * -EINVAL when invalid entries are found in opp-v2 table1223 */1224int dev_pm_opp_of_add_table(struct device *dev)1225{1226 return _of_add_table_indexed(dev, 0);1227}1228EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);1229 1230/**1231 * dev_pm_opp_of_add_table_indexed() - Initialize indexed opp table from device tree1232 * @dev: device pointer used to lookup OPP table.1233 * @index: Index number.1234 *1235 * Register the initial OPP table with the OPP library for given device only1236 * using the "operating-points-v2" property.1237 *1238 * Return: Refer to dev_pm_opp_of_add_table() for return values.1239 */1240int dev_pm_opp_of_add_table_indexed(struct device *dev, int index)1241{1242 return _of_add_table_indexed(dev, index);1243}1244EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_indexed);1245 1246/**1247 * devm_pm_opp_of_add_table_indexed() - Initialize indexed opp table from device tree1248 * @dev: device pointer used to lookup OPP table.1249 * @index: Index number.1250 *1251 * This is a resource-managed variant of dev_pm_opp_of_add_table_indexed().1252 */1253int devm_pm_opp_of_add_table_indexed(struct device *dev, int index)1254{1255 return _devm_of_add_table_indexed(dev, index);1256}1257EXPORT_SYMBOL_GPL(devm_pm_opp_of_add_table_indexed);1258 1259/* CPU device specific helpers */1260 1261/**1262 * dev_pm_opp_of_cpumask_remove_table() - Removes OPP table for @cpumask1263 * @cpumask: cpumask for which OPP table needs to be removed1264 *1265 * This removes the OPP tables for CPUs present in the @cpumask.1266 * This should be used only to remove static entries created from DT.1267 */1268void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask)1269{1270 _dev_pm_opp_cpumask_remove_table(cpumask, -1);1271}1272EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table);1273 1274/**1275 * dev_pm_opp_of_cpumask_add_table() - Adds OPP table for @cpumask1276 * @cpumask: cpumask for which OPP table needs to be added.1277 *1278 * This adds the OPP tables for CPUs present in the @cpumask.1279 */1280int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask)1281{1282 struct device *cpu_dev;1283 int cpu, ret;1284 1285 if (WARN_ON(cpumask_empty(cpumask)))1286 return -ENODEV;1287 1288 for_each_cpu(cpu, cpumask) {1289 cpu_dev = get_cpu_device(cpu);1290 if (!cpu_dev) {1291 pr_err("%s: failed to get cpu%d device\n", __func__,1292 cpu);1293 ret = -ENODEV;1294 goto remove_table;1295 }1296 1297 ret = dev_pm_opp_of_add_table(cpu_dev);1298 if (ret) {1299 /*1300 * OPP may get registered dynamically, don't print error1301 * message here.1302 */1303 pr_debug("%s: couldn't find opp table for cpu:%d, %d\n",1304 __func__, cpu, ret);1305 1306 goto remove_table;1307 }1308 }1309 1310 return 0;1311 1312remove_table:1313 /* Free all other OPPs */1314 _dev_pm_opp_cpumask_remove_table(cpumask, cpu);1315 1316 return ret;1317}1318EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table);1319 1320/*1321 * Works only for OPP v2 bindings.1322 *1323 * Returns -ENOENT if operating-points-v2 bindings aren't supported.1324 */1325/**1326 * dev_pm_opp_of_get_sharing_cpus() - Get cpumask of CPUs sharing OPPs with1327 * @cpu_dev using operating-points-v21328 * bindings.1329 *1330 * @cpu_dev: CPU device for which we do this operation1331 * @cpumask: cpumask to update with information of sharing CPUs1332 *1333 * This updates the @cpumask with CPUs that are sharing OPPs with @cpu_dev.1334 *1335 * Returns -ENOENT if operating-points-v2 isn't present for @cpu_dev.1336 */1337int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev,1338 struct cpumask *cpumask)1339{1340 struct device_node *np, *tmp_np, *cpu_np;1341 int cpu, ret = 0;1342 1343 /* Get OPP descriptor node */1344 np = dev_pm_opp_of_get_opp_desc_node(cpu_dev);1345 if (!np) {1346 dev_dbg(cpu_dev, "%s: Couldn't find opp node.\n", __func__);1347 return -ENOENT;1348 }1349 1350 cpumask_set_cpu(cpu_dev->id, cpumask);1351 1352 /* OPPs are shared ? */1353 if (!of_property_read_bool(np, "opp-shared"))1354 goto put_cpu_node;1355 1356 for_each_possible_cpu(cpu) {1357 if (cpu == cpu_dev->id)1358 continue;1359 1360 cpu_np = of_cpu_device_node_get(cpu);1361 if (!cpu_np) {1362 dev_err(cpu_dev, "%s: failed to get cpu%d node\n",1363 __func__, cpu);1364 ret = -ENOENT;1365 goto put_cpu_node;1366 }1367 1368 /* Get OPP descriptor node */1369 tmp_np = _opp_of_get_opp_desc_node(cpu_np, 0);1370 of_node_put(cpu_np);1371 if (!tmp_np) {1372 pr_err("%pOF: Couldn't find opp node\n", cpu_np);1373 ret = -ENOENT;1374 goto put_cpu_node;1375 }1376 1377 /* CPUs are sharing opp node */1378 if (np == tmp_np)1379 cpumask_set_cpu(cpu, cpumask);1380 1381 of_node_put(tmp_np);1382 }1383 1384put_cpu_node:1385 of_node_put(np);1386 return ret;1387}1388EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus);1389 1390/**1391 * of_get_required_opp_performance_state() - Search for required OPP and return its performance state.1392 * @np: Node that contains the "required-opps" property.1393 * @index: Index of the phandle to parse.1394 *1395 * Returns the performance state of the OPP pointed out by the "required-opps"1396 * property at @index in @np.1397 *1398 * Return: Zero or positive performance state on success, otherwise negative1399 * value on errors.1400 */1401int of_get_required_opp_performance_state(struct device_node *np, int index)1402{1403 struct dev_pm_opp *opp;1404 struct device_node *required_np;1405 struct opp_table *opp_table;1406 int pstate = -EINVAL;1407 1408 required_np = of_parse_required_opp(np, index);1409 if (!required_np)1410 return -ENODEV;1411 1412 opp_table = _find_table_of_opp_np(required_np);1413 if (IS_ERR(opp_table)) {1414 pr_err("%s: Failed to find required OPP table %pOF: %ld\n",1415 __func__, np, PTR_ERR(opp_table));1416 goto put_required_np;1417 }1418 1419 /* The OPP tables must belong to a genpd */1420 if (unlikely(!opp_table->is_genpd)) {1421 pr_err("%s: Performance state is only valid for genpds.\n", __func__);1422 goto put_required_np;1423 }1424 1425 opp = _find_opp_of_np(opp_table, required_np);1426 if (opp) {1427 if (opp->level == OPP_LEVEL_UNSET) {1428 pr_err("%s: OPP levels aren't available for %pOF\n",1429 __func__, np);1430 } else {1431 pstate = opp->level;1432 }1433 dev_pm_opp_put(opp);1434 1435 }1436 1437 dev_pm_opp_put_opp_table(opp_table);1438 1439put_required_np:1440 of_node_put(required_np);1441 1442 return pstate;1443}1444EXPORT_SYMBOL_GPL(of_get_required_opp_performance_state);1445 1446/**1447 * dev_pm_opp_of_has_required_opp - Find out if a required-opps exists.1448 * @dev: The device to investigate.1449 *1450 * Returns true if the device's node has a "operating-points-v2" property and if1451 * the corresponding node for the opp-table describes opp nodes that uses the1452 * "required-opps" property.1453 *1454 * Return: True if a required-opps is present, else false.1455 */1456bool dev_pm_opp_of_has_required_opp(struct device *dev)1457{1458 struct device_node *opp_np, *np;1459 int count;1460 1461 opp_np = _opp_of_get_opp_desc_node(dev->of_node, 0);1462 if (!opp_np)1463 return false;1464 1465 np = of_get_next_available_child(opp_np, NULL);1466 of_node_put(opp_np);1467 if (!np) {1468 dev_warn(dev, "Empty OPP table\n");1469 return false;1470 }1471 1472 count = of_count_phandle_with_args(np, "required-opps", NULL);1473 of_node_put(np);1474 1475 return count > 0;1476}1477 1478/**1479 * dev_pm_opp_get_of_node() - Gets the DT node corresponding to an opp1480 * @opp: opp for which DT node has to be returned for1481 *1482 * Return: DT node corresponding to the opp, else 0 on success.1483 *1484 * The caller needs to put the node with of_node_put() after using it.1485 */1486struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)1487{1488 if (IS_ERR_OR_NULL(opp)) {1489 pr_err("%s: Invalid parameters\n", __func__);1490 return NULL;1491 }1492 1493 return of_node_get(opp->np);1494}1495EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node);1496 1497/*1498 * Callback function provided to the Energy Model framework upon registration.1499 * It provides the power used by @dev at @kHz if it is the frequency of an1500 * existing OPP, or at the frequency of the first OPP above @kHz otherwise1501 * (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled1502 * frequency and @uW to the associated power.1503 *1504 * Returns 0 on success or a proper -EINVAL value in case of error.1505 */1506static int __maybe_unused1507_get_dt_power(struct device *dev, unsigned long *uW, unsigned long *kHz)1508{1509 struct dev_pm_opp *opp;1510 unsigned long opp_freq, opp_power;1511 1512 /* Find the right frequency and related OPP */1513 opp_freq = *kHz * 1000;1514 opp = dev_pm_opp_find_freq_ceil(dev, &opp_freq);1515 if (IS_ERR(opp))1516 return -EINVAL;1517 1518 opp_power = dev_pm_opp_get_power(opp);1519 dev_pm_opp_put(opp);1520 if (!opp_power)1521 return -EINVAL;1522 1523 *kHz = opp_freq / 1000;1524 *uW = opp_power;1525 1526 return 0;1527}1528 1529/**1530 * dev_pm_opp_calc_power() - Calculate power value for device with EM1531 * @dev : Device for which an Energy Model has to be registered1532 * @uW : New power value that is calculated1533 * @kHz : Frequency for which the new power is calculated1534 *1535 * This computes the power estimated by @dev at @kHz if it is the frequency1536 * of an existing OPP, or at the frequency of the first OPP above @kHz otherwise1537 * (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled1538 * frequency and @uW to the associated power. The power is estimated as1539 * P = C * V^2 * f with C being the device's capacitance and V and f1540 * respectively the voltage and frequency of the OPP.1541 * It is also used as a callback function provided to the Energy Model1542 * framework upon registration.1543 *1544 * Returns -EINVAL if the power calculation failed because of missing1545 * parameters, 0 otherwise.1546 */1547int dev_pm_opp_calc_power(struct device *dev, unsigned long *uW,1548 unsigned long *kHz)1549{1550 struct dev_pm_opp *opp;1551 struct device_node *np;1552 unsigned long mV, Hz;1553 u32 cap;1554 u64 tmp;1555 int ret;1556 1557 np = of_node_get(dev->of_node);1558 if (!np)1559 return -EINVAL;1560 1561 ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);1562 of_node_put(np);1563 if (ret)1564 return -EINVAL;1565 1566 Hz = *kHz * 1000;1567 opp = dev_pm_opp_find_freq_ceil(dev, &Hz);1568 if (IS_ERR(opp))1569 return -EINVAL;1570 1571 mV = dev_pm_opp_get_voltage(opp) / 1000;1572 dev_pm_opp_put(opp);1573 if (!mV)1574 return -EINVAL;1575 1576 tmp = (u64)cap * mV * mV * (Hz / 1000000);1577 /* Provide power in micro-Watts */1578 do_div(tmp, 1000000);1579 1580 *uW = (unsigned long)tmp;1581 *kHz = Hz / 1000;1582 1583 return 0;1584}1585EXPORT_SYMBOL_GPL(dev_pm_opp_calc_power);1586 1587static bool _of_has_opp_microwatt_property(struct device *dev)1588{1589 unsigned long power, freq = 0;1590 struct dev_pm_opp *opp;1591 1592 /* Check if at least one OPP has needed property */1593 opp = dev_pm_opp_find_freq_ceil(dev, &freq);1594 if (IS_ERR(opp))1595 return false;1596 1597 power = dev_pm_opp_get_power(opp);1598 dev_pm_opp_put(opp);1599 if (!power)1600 return false;1601 1602 return true;1603}1604 1605/**1606 * dev_pm_opp_of_register_em() - Attempt to register an Energy Model1607 * @dev : Device for which an Energy Model has to be registered1608 * @cpus : CPUs for which an Energy Model has to be registered. For1609 * other type of devices it should be set to NULL.1610 *1611 * This checks whether the "dynamic-power-coefficient" devicetree property has1612 * been specified, and tries to register an Energy Model with it if it has.1613 * Having this property means the voltages are known for OPPs and the EM1614 * might be calculated.1615 */1616int dev_pm_opp_of_register_em(struct device *dev, struct cpumask *cpus)1617{1618 struct em_data_callback em_cb;1619 struct device_node *np;1620 int ret, nr_opp;1621 u32 cap;1622 1623 if (IS_ERR_OR_NULL(dev)) {1624 ret = -EINVAL;1625 goto failed;1626 }1627 1628 nr_opp = dev_pm_opp_get_opp_count(dev);1629 if (nr_opp <= 0) {1630 ret = -EINVAL;1631 goto failed;1632 }1633 1634 /* First, try to find more precised Energy Model in DT */1635 if (_of_has_opp_microwatt_property(dev)) {1636 EM_SET_ACTIVE_POWER_CB(em_cb, _get_dt_power);1637 goto register_em;1638 }1639 1640 np = of_node_get(dev->of_node);1641 if (!np) {1642 ret = -EINVAL;1643 goto failed;1644 }1645 1646 /*1647 * Register an EM only if the 'dynamic-power-coefficient' property is1648 * set in devicetree. It is assumed the voltage values are known if that1649 * property is set since it is useless otherwise. If voltages are not1650 * known, just let the EM registration fail with an error to alert the1651 * user about the inconsistent configuration.1652 */1653 ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);1654 of_node_put(np);1655 if (ret || !cap) {1656 dev_dbg(dev, "Couldn't find proper 'dynamic-power-coefficient' in DT\n");1657 ret = -EINVAL;1658 goto failed;1659 }1660 1661 EM_SET_ACTIVE_POWER_CB(em_cb, dev_pm_opp_calc_power);1662 1663register_em:1664 ret = em_dev_register_perf_domain(dev, nr_opp, &em_cb, cpus, true);1665 if (ret)1666 goto failed;1667 1668 return 0;1669 1670failed:1671 dev_dbg(dev, "Couldn't register Energy Model %d\n", ret);1672 return ret;1673}1674EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em);1675