1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Generic OPP OF helpers 4 * 5 * Copyright (C) 2009-2010 Texas Instruments Incorporated. 6 * Nishanth Menon 7 * Romit Dasgupta 8 * Kevin Hilman 9 */ 10 11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 12 13 #include <linux/cpu.h> 14 #include <linux/errno.h> 15 #include <linux/device.h> 16 #include <linux/of_device.h> 17 #include <linux/pm_domain.h> 18 #include <linux/slab.h> 19 #include <linux/export.h> 20 #include <linux/energy_model.h> 21 22 #include "opp.h" 23 24 /* 25 * Returns opp descriptor node for a device node, caller must 26 * do of_node_put(). 27 */ 28 static struct device_node *_opp_of_get_opp_desc_node(struct device_node *np, 29 int index) 30 { 31 /* "operating-points-v2" can be an array for power domain providers */ 32 return of_parse_phandle(np, "operating-points-v2", index); 33 } 34 35 /* Returns opp descriptor node for a device, caller must do of_node_put() */ 36 struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev) 37 { 38 return _opp_of_get_opp_desc_node(dev->of_node, 0); 39 } 40 EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_opp_desc_node); 41 42 struct opp_table *_managed_opp(struct device *dev, int index) 43 { 44 struct opp_table *opp_table, *managed_table = NULL; 45 struct device_node *np; 46 47 np = _opp_of_get_opp_desc_node(dev->of_node, index); 48 if (!np) 49 return NULL; 50 51 list_for_each_entry(opp_table, &opp_tables, node) { 52 if (opp_table->np == np) { 53 /* 54 * Multiple devices can point to the same OPP table and 55 * so will have same node-pointer, np. 56 * 57 * But the OPPs will be considered as shared only if the 58 * OPP table contains a "opp-shared" property. 59 */ 60 if (opp_table->shared_opp == OPP_TABLE_ACCESS_SHARED) { 61 _get_opp_table_kref(opp_table); 62 managed_table = opp_table; 63 } 64 65 break; 66 } 67 } 68 69 of_node_put(np); 70 71 return managed_table; 72 } 73 74 /* The caller must call dev_pm_opp_put() after the OPP is used */ 75 static struct dev_pm_opp *_find_opp_of_np(struct opp_table *opp_table, 76 struct device_node *opp_np) 77 { 78 struct dev_pm_opp *opp; 79 80 mutex_lock(&opp_table->lock); 81 82 list_for_each_entry(opp, &opp_table->opp_list, node) { 83 if (opp->np == opp_np) { 84 dev_pm_opp_get(opp); 85 mutex_unlock(&opp_table->lock); 86 return opp; 87 } 88 } 89 90 mutex_unlock(&opp_table->lock); 91 92 return NULL; 93 } 94 95 static struct device_node *of_parse_required_opp(struct device_node *np, 96 int index) 97 { 98 struct device_node *required_np; 99 100 required_np = of_parse_phandle(np, "required-opps", index); 101 if (unlikely(!required_np)) { 102 pr_err("%s: Unable to parse required-opps: %pOF, index: %d\n", 103 __func__, np, index); 104 } 105 106 return required_np; 107 } 108 109 /* The caller must call dev_pm_opp_put_opp_table() after the table is used */ 110 static struct opp_table *_find_table_of_opp_np(struct device_node *opp_np) 111 { 112 struct opp_table *opp_table; 113 struct device_node *opp_table_np; 114 115 lockdep_assert_held(&opp_table_lock); 116 117 opp_table_np = of_get_parent(opp_np); 118 if (!opp_table_np) 119 goto err; 120 121 /* It is safe to put the node now as all we need now is its address */ 122 of_node_put(opp_table_np); 123 124 list_for_each_entry(opp_table, &opp_tables, node) { 125 if (opp_table_np == opp_table->np) { 126 _get_opp_table_kref(opp_table); 127 return opp_table; 128 } 129 } 130 131 err: 132 return ERR_PTR(-ENODEV); 133 } 134 135 /* Free resources previously acquired by _opp_table_alloc_required_tables() */ 136 static void _opp_table_free_required_tables(struct opp_table *opp_table) 137 { 138 struct opp_table **required_opp_tables = opp_table->required_opp_tables; 139 int i; 140 141 if (!required_opp_tables) 142 return; 143 144 for (i = 0; i < opp_table->required_opp_count; i++) { 145 if (IS_ERR_OR_NULL(required_opp_tables[i])) 146 break; 147 148 dev_pm_opp_put_opp_table(required_opp_tables[i]); 149 } 150 151 kfree(required_opp_tables); 152 153 opp_table->required_opp_count = 0; 154 opp_table->required_opp_tables = NULL; 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 */ 161 static 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 int count, i; 168 169 /* Traversing the first OPP node is all we need */ 170 np = of_get_next_available_child(opp_np, NULL); 171 if (!np) { 172 dev_err(dev, "Empty OPP table\n"); 173 return; 174 } 175 176 count = of_count_phandle_with_args(np, "required-opps", NULL); 177 if (!count) 178 goto put_np; 179 180 required_opp_tables = kcalloc(count, sizeof(*required_opp_tables), 181 GFP_KERNEL); 182 if (!required_opp_tables) 183 goto put_np; 184 185 opp_table->required_opp_tables = required_opp_tables; 186 opp_table->required_opp_count = count; 187 188 for (i = 0; i < count; i++) { 189 required_np = of_parse_required_opp(np, i); 190 if (!required_np) 191 goto free_required_tables; 192 193 required_opp_tables[i] = _find_table_of_opp_np(required_np); 194 of_node_put(required_np); 195 196 if (IS_ERR(required_opp_tables[i])) 197 goto free_required_tables; 198 199 /* 200 * We only support genpd's OPPs in the "required-opps" for now, 201 * as we don't know how much about other cases. Error out if the 202 * required OPP doesn't belong to a genpd. 203 */ 204 if (!required_opp_tables[i]->is_genpd) { 205 dev_err(dev, "required-opp doesn't belong to genpd: %pOF\n", 206 required_np); 207 goto free_required_tables; 208 } 209 } 210 211 goto put_np; 212 213 free_required_tables: 214 _opp_table_free_required_tables(opp_table); 215 put_np: 216 of_node_put(np); 217 } 218 219 void _of_init_opp_table(struct opp_table *opp_table, struct device *dev, 220 int index) 221 { 222 struct device_node *np, *opp_np; 223 u32 val; 224 225 /* 226 * Only required for backward compatibility with v1 bindings, but isn't 227 * harmful for other cases. And so we do it unconditionally. 228 */ 229 np = of_node_get(dev->of_node); 230 if (!np) 231 return; 232 233 if (!of_property_read_u32(np, "clock-latency", &val)) 234 opp_table->clock_latency_ns_max = val; 235 of_property_read_u32(np, "voltage-tolerance", 236 &opp_table->voltage_tolerance_v1); 237 238 if (of_find_property(np, "#power-domain-cells", NULL)) 239 opp_table->is_genpd = true; 240 241 /* Get OPP table node */ 242 opp_np = _opp_of_get_opp_desc_node(np, index); 243 of_node_put(np); 244 245 if (!opp_np) 246 return; 247 248 if (of_property_read_bool(opp_np, "opp-shared")) 249 opp_table->shared_opp = OPP_TABLE_ACCESS_SHARED; 250 else 251 opp_table->shared_opp = OPP_TABLE_ACCESS_EXCLUSIVE; 252 253 opp_table->np = opp_np; 254 255 _opp_table_alloc_required_tables(opp_table, dev, opp_np); 256 of_node_put(opp_np); 257 } 258 259 void _of_clear_opp_table(struct opp_table *opp_table) 260 { 261 _opp_table_free_required_tables(opp_table); 262 } 263 264 /* 265 * Release all resources previously acquired with a call to 266 * _of_opp_alloc_required_opps(). 267 */ 268 void _of_opp_free_required_opps(struct opp_table *opp_table, 269 struct dev_pm_opp *opp) 270 { 271 struct dev_pm_opp **required_opps = opp->required_opps; 272 int i; 273 274 if (!required_opps) 275 return; 276 277 for (i = 0; i < opp_table->required_opp_count; i++) { 278 if (!required_opps[i]) 279 break; 280 281 /* Put the reference back */ 282 dev_pm_opp_put(required_opps[i]); 283 } 284 285 kfree(required_opps); 286 opp->required_opps = NULL; 287 } 288 289 /* Populate all required OPPs which are part of "required-opps" list */ 290 static int _of_opp_alloc_required_opps(struct opp_table *opp_table, 291 struct dev_pm_opp *opp) 292 { 293 struct dev_pm_opp **required_opps; 294 struct opp_table *required_table; 295 struct device_node *np; 296 int i, ret, count = opp_table->required_opp_count; 297 298 if (!count) 299 return 0; 300 301 required_opps = kcalloc(count, sizeof(*required_opps), GFP_KERNEL); 302 if (!required_opps) 303 return -ENOMEM; 304 305 opp->required_opps = required_opps; 306 307 for (i = 0; i < count; i++) { 308 required_table = opp_table->required_opp_tables[i]; 309 310 np = of_parse_required_opp(opp->np, i); 311 if (unlikely(!np)) { 312 ret = -ENODEV; 313 goto free_required_opps; 314 } 315 316 required_opps[i] = _find_opp_of_np(required_table, np); 317 of_node_put(np); 318 319 if (!required_opps[i]) { 320 pr_err("%s: Unable to find required OPP node: %pOF (%d)\n", 321 __func__, opp->np, i); 322 ret = -ENODEV; 323 goto free_required_opps; 324 } 325 } 326 327 return 0; 328 329 free_required_opps: 330 _of_opp_free_required_opps(opp_table, opp); 331 332 return ret; 333 } 334 335 static bool _opp_is_supported(struct device *dev, struct opp_table *opp_table, 336 struct device_node *np) 337 { 338 unsigned int count = opp_table->supported_hw_count; 339 u32 version; 340 int ret; 341 342 if (!opp_table->supported_hw) { 343 /* 344 * In the case that no supported_hw has been set by the 345 * platform but there is an opp-supported-hw value set for 346 * an OPP then the OPP should not be enabled as there is 347 * no way to see if the hardware supports it. 348 */ 349 if (of_find_property(np, "opp-supported-hw", NULL)) 350 return false; 351 else 352 return true; 353 } 354 355 while (count--) { 356 ret = of_property_read_u32_index(np, "opp-supported-hw", count, 357 &version); 358 if (ret) { 359 dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n", 360 __func__, count, ret); 361 return false; 362 } 363 364 /* Both of these are bitwise masks of the versions */ 365 if (!(version & opp_table->supported_hw[count])) 366 return false; 367 } 368 369 return true; 370 } 371 372 static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev, 373 struct opp_table *opp_table) 374 { 375 u32 *microvolt, *microamp = NULL; 376 int supplies = opp_table->regulator_count, vcount, icount, ret, i, j; 377 struct property *prop = NULL; 378 char name[NAME_MAX]; 379 380 /* Search for "opp-microvolt-<name>" */ 381 if (opp_table->prop_name) { 382 snprintf(name, sizeof(name), "opp-microvolt-%s", 383 opp_table->prop_name); 384 prop = of_find_property(opp->np, name, NULL); 385 } 386 387 if (!prop) { 388 /* Search for "opp-microvolt" */ 389 sprintf(name, "opp-microvolt"); 390 prop = of_find_property(opp->np, name, NULL); 391 392 /* Missing property isn't a problem, but an invalid entry is */ 393 if (!prop) { 394 if (unlikely(supplies == -1)) { 395 /* Initialize regulator_count */ 396 opp_table->regulator_count = 0; 397 return 0; 398 } 399 400 if (!supplies) 401 return 0; 402 403 dev_err(dev, "%s: opp-microvolt missing although OPP managing regulators\n", 404 __func__); 405 return -EINVAL; 406 } 407 } 408 409 if (unlikely(supplies == -1)) { 410 /* Initialize regulator_count */ 411 supplies = opp_table->regulator_count = 1; 412 } else if (unlikely(!supplies)) { 413 dev_err(dev, "%s: opp-microvolt wasn't expected\n", __func__); 414 return -EINVAL; 415 } 416 417 vcount = of_property_count_u32_elems(opp->np, name); 418 if (vcount < 0) { 419 dev_err(dev, "%s: Invalid %s property (%d)\n", 420 __func__, name, vcount); 421 return vcount; 422 } 423 424 /* There can be one or three elements per supply */ 425 if (vcount != supplies && vcount != supplies * 3) { 426 dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n", 427 __func__, name, vcount, supplies); 428 return -EINVAL; 429 } 430 431 microvolt = kmalloc_array(vcount, sizeof(*microvolt), GFP_KERNEL); 432 if (!microvolt) 433 return -ENOMEM; 434 435 ret = of_property_read_u32_array(opp->np, name, microvolt, vcount); 436 if (ret) { 437 dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret); 438 ret = -EINVAL; 439 goto free_microvolt; 440 } 441 442 /* Search for "opp-microamp-<name>" */ 443 prop = NULL; 444 if (opp_table->prop_name) { 445 snprintf(name, sizeof(name), "opp-microamp-%s", 446 opp_table->prop_name); 447 prop = of_find_property(opp->np, name, NULL); 448 } 449 450 if (!prop) { 451 /* Search for "opp-microamp" */ 452 sprintf(name, "opp-microamp"); 453 prop = of_find_property(opp->np, name, NULL); 454 } 455 456 if (prop) { 457 icount = of_property_count_u32_elems(opp->np, name); 458 if (icount < 0) { 459 dev_err(dev, "%s: Invalid %s property (%d)\n", __func__, 460 name, icount); 461 ret = icount; 462 goto free_microvolt; 463 } 464 465 if (icount != supplies) { 466 dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n", 467 __func__, name, icount, supplies); 468 ret = -EINVAL; 469 goto free_microvolt; 470 } 471 472 microamp = kmalloc_array(icount, sizeof(*microamp), GFP_KERNEL); 473 if (!microamp) { 474 ret = -EINVAL; 475 goto free_microvolt; 476 } 477 478 ret = of_property_read_u32_array(opp->np, name, microamp, 479 icount); 480 if (ret) { 481 dev_err(dev, "%s: error parsing %s: %d\n", __func__, 482 name, ret); 483 ret = -EINVAL; 484 goto free_microamp; 485 } 486 } 487 488 for (i = 0, j = 0; i < supplies; i++) { 489 opp->supplies[i].u_volt = microvolt[j++]; 490 491 if (vcount == supplies) { 492 opp->supplies[i].u_volt_min = opp->supplies[i].u_volt; 493 opp->supplies[i].u_volt_max = opp->supplies[i].u_volt; 494 } else { 495 opp->supplies[i].u_volt_min = microvolt[j++]; 496 opp->supplies[i].u_volt_max = microvolt[j++]; 497 } 498 499 if (microamp) 500 opp->supplies[i].u_amp = microamp[i]; 501 } 502 503 free_microamp: 504 kfree(microamp); 505 free_microvolt: 506 kfree(microvolt); 507 508 return ret; 509 } 510 511 /** 512 * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT 513 * entries 514 * @dev: device pointer used to lookup OPP table. 515 * 516 * Free OPPs created using static entries present in DT. 517 */ 518 void dev_pm_opp_of_remove_table(struct device *dev) 519 { 520 _dev_pm_opp_find_and_remove_table(dev); 521 } 522 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table); 523 524 /** 525 * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings) 526 * @opp_table: OPP table 527 * @dev: device for which we do this operation 528 * @np: device node 529 * 530 * This function adds an opp definition to the opp table and returns status. The 531 * opp can be controlled using dev_pm_opp_enable/disable functions and may be 532 * removed by dev_pm_opp_remove. 533 * 534 * Return: 535 * Valid OPP pointer: 536 * On success 537 * NULL: 538 * Duplicate OPPs (both freq and volt are same) and opp->available 539 * OR if the OPP is not supported by hardware. 540 * ERR_PTR(-EEXIST): 541 * Freq are same and volt are different OR 542 * Duplicate OPPs (both freq and volt are same) and !opp->available 543 * ERR_PTR(-ENOMEM): 544 * Memory allocation failure 545 * ERR_PTR(-EINVAL): 546 * Failed parsing the OPP node 547 */ 548 static struct dev_pm_opp *_opp_add_static_v2(struct opp_table *opp_table, 549 struct device *dev, struct device_node *np) 550 { 551 struct dev_pm_opp *new_opp; 552 u64 rate = 0; 553 u32 val; 554 int ret; 555 bool rate_not_available = false; 556 557 new_opp = _opp_allocate(opp_table); 558 if (!new_opp) 559 return ERR_PTR(-ENOMEM); 560 561 ret = of_property_read_u64(np, "opp-hz", &rate); 562 if (ret < 0) { 563 /* "opp-hz" is optional for devices like power domains. */ 564 if (!opp_table->is_genpd) { 565 dev_err(dev, "%s: opp-hz not found\n", __func__); 566 goto free_opp; 567 } 568 569 rate_not_available = true; 570 } else { 571 /* 572 * Rate is defined as an unsigned long in clk API, and so 573 * casting explicitly to its type. Must be fixed once rate is 64 574 * bit guaranteed in clk API. 575 */ 576 new_opp->rate = (unsigned long)rate; 577 } 578 579 of_property_read_u32(np, "opp-level", &new_opp->level); 580 581 /* Check if the OPP supports hardware's hierarchy of versions or not */ 582 if (!_opp_is_supported(dev, opp_table, np)) { 583 dev_dbg(dev, "OPP not supported by hardware: %llu\n", rate); 584 goto free_opp; 585 } 586 587 new_opp->turbo = of_property_read_bool(np, "turbo-mode"); 588 589 new_opp->np = np; 590 new_opp->dynamic = false; 591 new_opp->available = true; 592 593 ret = _of_opp_alloc_required_opps(opp_table, new_opp); 594 if (ret) 595 goto free_opp; 596 597 if (!of_property_read_u32(np, "clock-latency-ns", &val)) 598 new_opp->clock_latency_ns = val; 599 600 ret = opp_parse_supplies(new_opp, dev, opp_table); 601 if (ret) 602 goto free_required_opps; 603 604 if (opp_table->is_genpd) 605 new_opp->pstate = pm_genpd_opp_to_performance_state(dev, new_opp); 606 607 ret = _opp_add(dev, new_opp, opp_table, rate_not_available); 608 if (ret) { 609 /* Don't return error for duplicate OPPs */ 610 if (ret == -EBUSY) 611 ret = 0; 612 goto free_required_opps; 613 } 614 615 /* OPP to select on device suspend */ 616 if (of_property_read_bool(np, "opp-suspend")) { 617 if (opp_table->suspend_opp) { 618 /* Pick the OPP with higher rate as suspend OPP */ 619 if (new_opp->rate > opp_table->suspend_opp->rate) { 620 opp_table->suspend_opp->suspend = false; 621 new_opp->suspend = true; 622 opp_table->suspend_opp = new_opp; 623 } 624 } else { 625 new_opp->suspend = true; 626 opp_table->suspend_opp = new_opp; 627 } 628 } 629 630 if (new_opp->clock_latency_ns > opp_table->clock_latency_ns_max) 631 opp_table->clock_latency_ns_max = new_opp->clock_latency_ns; 632 633 pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n", 634 __func__, new_opp->turbo, new_opp->rate, 635 new_opp->supplies[0].u_volt, new_opp->supplies[0].u_volt_min, 636 new_opp->supplies[0].u_volt_max, new_opp->clock_latency_ns); 637 638 /* 639 * Notify the changes in the availability of the operable 640 * frequency/voltage list. 641 */ 642 blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADD, new_opp); 643 return new_opp; 644 645 free_required_opps: 646 _of_opp_free_required_opps(opp_table, new_opp); 647 free_opp: 648 _opp_free(new_opp); 649 650 return ERR_PTR(ret); 651 } 652 653 /* Initializes OPP tables based on new bindings */ 654 static int _of_add_opp_table_v2(struct device *dev, struct opp_table *opp_table) 655 { 656 struct device_node *np; 657 int ret, count = 0, pstate_count = 0; 658 struct dev_pm_opp *opp; 659 660 /* OPP table is already initialized for the device */ 661 mutex_lock(&opp_table->lock); 662 if (opp_table->parsed_static_opps) { 663 opp_table->parsed_static_opps++; 664 mutex_unlock(&opp_table->lock); 665 return 0; 666 } 667 668 opp_table->parsed_static_opps = 1; 669 mutex_unlock(&opp_table->lock); 670 671 /* We have opp-table node now, iterate over it and add OPPs */ 672 for_each_available_child_of_node(opp_table->np, np) { 673 opp = _opp_add_static_v2(opp_table, dev, np); 674 if (IS_ERR(opp)) { 675 ret = PTR_ERR(opp); 676 dev_err(dev, "%s: Failed to add OPP, %d\n", __func__, 677 ret); 678 of_node_put(np); 679 goto remove_static_opp; 680 } else if (opp) { 681 count++; 682 } 683 } 684 685 /* There should be one of more OPP defined */ 686 if (WARN_ON(!count)) { 687 ret = -ENOENT; 688 goto remove_static_opp; 689 } 690 691 list_for_each_entry(opp, &opp_table->opp_list, node) 692 pstate_count += !!opp->pstate; 693 694 /* Either all or none of the nodes shall have performance state set */ 695 if (pstate_count && pstate_count != count) { 696 dev_err(dev, "Not all nodes have performance state set (%d: %d)\n", 697 count, pstate_count); 698 ret = -ENOENT; 699 goto remove_static_opp; 700 } 701 702 if (pstate_count) 703 opp_table->genpd_performance_state = true; 704 705 return 0; 706 707 remove_static_opp: 708 _opp_remove_all_static(opp_table); 709 710 return ret; 711 } 712 713 /* Initializes OPP tables based on old-deprecated bindings */ 714 static int _of_add_opp_table_v1(struct device *dev, struct opp_table *opp_table) 715 { 716 const struct property *prop; 717 const __be32 *val; 718 int nr, ret = 0; 719 720 prop = of_find_property(dev->of_node, "operating-points", NULL); 721 if (!prop) 722 return -ENODEV; 723 if (!prop->value) 724 return -ENODATA; 725 726 /* 727 * Each OPP is a set of tuples consisting of frequency and 728 * voltage like <freq-kHz vol-uV>. 729 */ 730 nr = prop->length / sizeof(u32); 731 if (nr % 2) { 732 dev_err(dev, "%s: Invalid OPP table\n", __func__); 733 return -EINVAL; 734 } 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 _opp_remove_all_static(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