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