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.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 must 29 * 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 and 58 * so will have same node-pointer, np. 59 * 60 * But the OPPs will be considered as shared only if the 61 * 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 it 207 * 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't 230 * 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 else 254 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 to 269 * _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 the 321 * same `dev` structure (instead of a virtual one provided by genpd 322 * core) for setting the performance state. 323 * 324 * It doesn't make sense for a device's DT entry to have both 325 * "opp-level" and single "required-opps" entry pointing to a genpd's 326 * OPP, as that would make the OPP core call 327 * dev_pm_domain_set_performance_state() for two different values for 328 * the same device structure. Lets treat single genpd configuration as a 329 * case where the OPP's level is directly available without required-opp 330 * link in the DT. 331 * 332 * Just update the `level` with the right value, which 333 * 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 has 336 * required-opps set to a parent genpd. The OPP core expects the user to 337 * set the respective required `struct device` pointer via 338 * 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 for 434 * 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 the 574 * platform but there is an opp-supported-hw value set for 575 * an OPP then the OPP should not be enabled as there is 576 * no way to see if the hardware supports it. 577 */ 578 if (of_property_present(np, "opp-supported-hw")) 579 return false; 580 else 581 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 provided 653 * by the platform. Now that one of the properties is available, fix the 654 * 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 invalid 695 * entry is. This property isn't optional if regulator 696 * information is provided. Check only for the first OPP, as 697 * regulator_count may get initialized after that to a valid 698 * 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 properties 736 * 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 DT 774 * entries 775 * @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 so 813 * casting explicitly to its type. Must be fixed once rate is 64 814 * 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 else 862 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 table 909 * @dev: device for which we do this operation 910 * @np: device node 911 * 912 * This function adds an opp definition to the opp table and returns status. The 913 * opp can be controlled using dev_pm_opp_enable/disable functions and may be 914 * removed by dev_pm_opp_remove. 915 * 916 * Return: 917 * Valid OPP pointer: 918 * On success 919 * NULL: 920 * Duplicate OPPs (both freq and volt are same) and opp->available 921 * OR if the OPP is not supported by hardware. 922 * ERR_PTR(-EEXIST): 923 * Freq are same and volt are different OR 924 * Duplicate OPPs (both freq and volt are same) and !opp->available 925 * ERR_PTR(-ENOMEM): 926 * Memory allocation failure 927 * ERR_PTR(-EINVAL): 928 * Failed parsing the OPP node 929 */ 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 operable 1005 * 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 and 1096 * 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 table 1139 * 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 else 1158 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 tree 1184 * @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 OR 1192 * Duplicate OPPs (both freq and volt are same) and opp->available 1193 * -EEXIST Freq are same and volt are different OR 1194 * Duplicate OPPs (both freq and volt are same) and !opp->available 1195 * -ENOMEM Memory allocation failure 1196 * -ENODEV when 'operating-points' property is not found or is invalid data 1197 * in device node. 1198 * -ENODATA when empty 'operating-points' property is found 1199 * -EINVAL when invalid entries are found in opp-v2 table 1200 */ 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 tree 1209 * @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 OR 1215 * Duplicate OPPs (both freq and volt are same) and opp->available 1216 * -EEXIST Freq are same and volt are different OR 1217 * Duplicate OPPs (both freq and volt are same) and !opp->available 1218 * -ENOMEM Memory allocation failure 1219 * -ENODEV when 'operating-points' property is not found or is invalid data 1220 * in device node. 1221 * -ENODATA when empty 'operating-points' property is found 1222 * -EINVAL when invalid entries are found in opp-v2 table 1223 */ 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 tree 1232 * @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 only 1236 * 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 tree 1248 * @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 @cpumask 1263 * @cpumask: cpumask for which OPP table needs to be removed 1264 * 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 @cpumask 1276 * @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 error 1301 * 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 with 1327 * @cpu_dev using operating-points-v2 1328 * bindings. 1329 * 1330 * @cpu_dev: CPU device for which we do this operation 1331 * @cpumask: cpumask to update with information of sharing CPUs 1332 * 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 negative 1399 * 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_get_of_node() - Gets the DT node corresponding to an opp 1448 * @opp: opp for which DT node has to be returned for 1449 * 1450 * Return: DT node corresponding to the opp, else 0 on success. 1451 * 1452 * The caller needs to put the node with of_node_put() after using it. 1453 */ 1454struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) 1455{ 1456 if (IS_ERR_OR_NULL(opp)) { 1457 pr_err("%s: Invalid parameters\n", __func__); 1458 return NULL; 1459 } 1460 1461 return of_node_get(opp->np); 1462} 1463EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node); 1464 1465/* 1466 * Callback function provided to the Energy Model framework upon registration. 1467 * It provides the power used by @dev at @kHz if it is the frequency of an 1468 * existing OPP, or at the frequency of the first OPP above @kHz otherwise 1469 * (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled 1470 * frequency and @uW to the associated power. 1471 * 1472 * Returns 0 on success or a proper -EINVAL value in case of error. 1473 */ 1474static int __maybe_unused 1475_get_dt_power(struct device *dev, unsigned long *uW, unsigned long *kHz) 1476{ 1477 struct dev_pm_opp *opp; 1478 unsigned long opp_freq, opp_power; 1479 1480 /* Find the right frequency and related OPP */ 1481 opp_freq = *kHz * 1000; 1482 opp = dev_pm_opp_find_freq_ceil(dev, &opp_freq); 1483 if (IS_ERR(opp)) 1484 return -EINVAL; 1485 1486 opp_power = dev_pm_opp_get_power(opp); 1487 dev_pm_opp_put(opp); 1488 if (!opp_power) 1489 return -EINVAL; 1490 1491 *kHz = opp_freq / 1000; 1492 *uW = opp_power; 1493 1494 return 0; 1495} 1496 1497/* 1498 * Callback function provided to the Energy Model framework upon registration. 1499 * This computes the power estimated by @dev at @kHz if it is the frequency 1500 * of an existing OPP, or at the frequency of the first OPP above @kHz otherwise 1501 * (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled 1502 * frequency and @uW to the associated power. The power is estimated as 1503 * P = C * V^2 * f with C being the device's capacitance and V and f 1504 * respectively the voltage and frequency of the OPP. 1505 * 1506 * Returns -EINVAL if the power calculation failed because of missing 1507 * parameters, 0 otherwise. 1508 */ 1509static int __maybe_unused _get_power(struct device *dev, unsigned long *uW, 1510 unsigned long *kHz) 1511{ 1512 struct dev_pm_opp *opp; 1513 struct device_node *np; 1514 unsigned long mV, Hz; 1515 u32 cap; 1516 u64 tmp; 1517 int ret; 1518 1519 np = of_node_get(dev->of_node); 1520 if (!np) 1521 return -EINVAL; 1522 1523 ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap); 1524 of_node_put(np); 1525 if (ret) 1526 return -EINVAL; 1527 1528 Hz = *kHz * 1000; 1529 opp = dev_pm_opp_find_freq_ceil(dev, &Hz); 1530 if (IS_ERR(opp)) 1531 return -EINVAL; 1532 1533 mV = dev_pm_opp_get_voltage(opp) / 1000; 1534 dev_pm_opp_put(opp); 1535 if (!mV) 1536 return -EINVAL; 1537 1538 tmp = (u64)cap * mV * mV * (Hz / 1000000); 1539 /* Provide power in micro-Watts */ 1540 do_div(tmp, 1000000); 1541 1542 *uW = (unsigned long)tmp; 1543 *kHz = Hz / 1000; 1544 1545 return 0; 1546} 1547 1548static bool _of_has_opp_microwatt_property(struct device *dev) 1549{ 1550 unsigned long power, freq = 0; 1551 struct dev_pm_opp *opp; 1552 1553 /* Check if at least one OPP has needed property */ 1554 opp = dev_pm_opp_find_freq_ceil(dev, &freq); 1555 if (IS_ERR(opp)) 1556 return false; 1557 1558 power = dev_pm_opp_get_power(opp); 1559 dev_pm_opp_put(opp); 1560 if (!power) 1561 return false; 1562 1563 return true; 1564} 1565 1566/** 1567 * dev_pm_opp_of_register_em() - Attempt to register an Energy Model 1568 * @dev : Device for which an Energy Model has to be registered 1569 * @cpus : CPUs for which an Energy Model has to be registered. For 1570 * other type of devices it should be set to NULL. 1571 * 1572 * This checks whether the "dynamic-power-coefficient" devicetree property has 1573 * been specified, and tries to register an Energy Model with it if it has. 1574 * Having this property means the voltages are known for OPPs and the EM 1575 * might be calculated. 1576 */ 1577int dev_pm_opp_of_register_em(struct device *dev, struct cpumask *cpus) 1578{ 1579 struct em_data_callback em_cb; 1580 struct device_node *np; 1581 int ret, nr_opp; 1582 u32 cap; 1583 1584 if (IS_ERR_OR_NULL(dev)) { 1585 ret = -EINVAL; 1586 goto failed; 1587 } 1588 1589 nr_opp = dev_pm_opp_get_opp_count(dev); 1590 if (nr_opp <= 0) { 1591 ret = -EINVAL; 1592 goto failed; 1593 } 1594 1595 /* First, try to find more precised Energy Model in DT */ 1596 if (_of_has_opp_microwatt_property(dev)) { 1597 EM_SET_ACTIVE_POWER_CB(em_cb, _get_dt_power); 1598 goto register_em; 1599 } 1600 1601 np = of_node_get(dev->of_node); 1602 if (!np) { 1603 ret = -EINVAL; 1604 goto failed; 1605 } 1606 1607 /* 1608 * Register an EM only if the 'dynamic-power-coefficient' property is 1609 * set in devicetree. It is assumed the voltage values are known if that 1610 * property is set since it is useless otherwise. If voltages are not 1611 * known, just let the EM registration fail with an error to alert the 1612 * user about the inconsistent configuration. 1613 */ 1614 ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap); 1615 of_node_put(np); 1616 if (ret || !cap) { 1617 dev_dbg(dev, "Couldn't find proper 'dynamic-power-coefficient' in DT\n"); 1618 ret = -EINVAL; 1619 goto failed; 1620 } 1621 1622 EM_SET_ACTIVE_POWER_CB(em_cb, _get_power); 1623 1624register_em: 1625 ret = em_dev_register_perf_domain(dev, nr_opp, &em_cb, cpus, true); 1626 if (ret) 1627 goto failed; 1628 1629 return 0; 1630 1631failed: 1632 dev_dbg(dev, "Couldn't register Energy Model %d\n", ret); 1633 return ret; 1634} 1635EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em); 1636