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 int _bandwidth_supported(struct device *dev, struct opp_table *opp_table) 336 { 337 struct device_node *np, *opp_np; 338 struct property *prop; 339 340 if (!opp_table) { 341 np = of_node_get(dev->of_node); 342 if (!np) 343 return -ENODEV; 344 345 opp_np = _opp_of_get_opp_desc_node(np, 0); 346 of_node_put(np); 347 } else { 348 opp_np = of_node_get(opp_table->np); 349 } 350 351 /* Lets not fail in case we are parsing opp-v1 bindings */ 352 if (!opp_np) 353 return 0; 354 355 /* Checking only first OPP is sufficient */ 356 np = of_get_next_available_child(opp_np, NULL); 357 if (!np) { 358 dev_err(dev, "OPP table empty\n"); 359 return -EINVAL; 360 } 361 of_node_put(opp_np); 362 363 prop = of_find_property(np, "opp-peak-kBps", NULL); 364 of_node_put(np); 365 366 if (!prop || !prop->length) 367 return 0; 368 369 return 1; 370 } 371 372 int dev_pm_opp_of_find_icc_paths(struct device *dev, 373 struct opp_table *opp_table) 374 { 375 struct device_node *np; 376 int ret, i, count, num_paths; 377 struct icc_path **paths; 378 379 ret = _bandwidth_supported(dev, opp_table); 380 if (ret <= 0) 381 return ret; 382 383 ret = 0; 384 385 np = of_node_get(dev->of_node); 386 if (!np) 387 return 0; 388 389 count = of_count_phandle_with_args(np, "interconnects", 390 "#interconnect-cells"); 391 of_node_put(np); 392 if (count < 0) 393 return 0; 394 395 /* two phandles when #interconnect-cells = <1> */ 396 if (count % 2) { 397 dev_err(dev, "%s: Invalid interconnects values\n", __func__); 398 return -EINVAL; 399 } 400 401 num_paths = count / 2; 402 paths = kcalloc(num_paths, sizeof(*paths), GFP_KERNEL); 403 if (!paths) 404 return -ENOMEM; 405 406 for (i = 0; i < num_paths; i++) { 407 paths[i] = of_icc_get_by_index(dev, i); 408 if (IS_ERR(paths[i])) { 409 ret = PTR_ERR(paths[i]); 410 if (ret != -EPROBE_DEFER) { 411 dev_err(dev, "%s: Unable to get path%d: %d\n", 412 __func__, i, ret); 413 } 414 goto err; 415 } 416 } 417 418 if (opp_table) { 419 opp_table->paths = paths; 420 opp_table->path_count = num_paths; 421 return 0; 422 } 423 424 err: 425 while (i--) 426 icc_put(paths[i]); 427 428 kfree(paths); 429 430 return ret; 431 } 432 EXPORT_SYMBOL_GPL(dev_pm_opp_of_find_icc_paths); 433 434 static bool _opp_is_supported(struct device *dev, struct opp_table *opp_table, 435 struct device_node *np) 436 { 437 unsigned int count = opp_table->supported_hw_count; 438 u32 version; 439 int ret; 440 441 if (!opp_table->supported_hw) { 442 /* 443 * In the case that no supported_hw has been set by the 444 * platform but there is an opp-supported-hw value set for 445 * an OPP then the OPP should not be enabled as there is 446 * no way to see if the hardware supports it. 447 */ 448 if (of_find_property(np, "opp-supported-hw", NULL)) 449 return false; 450 else 451 return true; 452 } 453 454 while (count--) { 455 ret = of_property_read_u32_index(np, "opp-supported-hw", count, 456 &version); 457 if (ret) { 458 dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n", 459 __func__, count, ret); 460 return false; 461 } 462 463 /* Both of these are bitwise masks of the versions */ 464 if (!(version & opp_table->supported_hw[count])) 465 return false; 466 } 467 468 return true; 469 } 470 471 static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev, 472 struct opp_table *opp_table) 473 { 474 u32 *microvolt, *microamp = NULL; 475 int supplies = opp_table->regulator_count, vcount, icount, ret, i, j; 476 struct property *prop = NULL; 477 char name[NAME_MAX]; 478 479 /* Search for "opp-microvolt-<name>" */ 480 if (opp_table->prop_name) { 481 snprintf(name, sizeof(name), "opp-microvolt-%s", 482 opp_table->prop_name); 483 prop = of_find_property(opp->np, name, NULL); 484 } 485 486 if (!prop) { 487 /* Search for "opp-microvolt" */ 488 sprintf(name, "opp-microvolt"); 489 prop = of_find_property(opp->np, name, NULL); 490 491 /* Missing property isn't a problem, but an invalid entry is */ 492 if (!prop) { 493 if (unlikely(supplies == -1)) { 494 /* Initialize regulator_count */ 495 opp_table->regulator_count = 0; 496 return 0; 497 } 498 499 if (!supplies) 500 return 0; 501 502 dev_err(dev, "%s: opp-microvolt missing although OPP managing regulators\n", 503 __func__); 504 return -EINVAL; 505 } 506 } 507 508 if (unlikely(supplies == -1)) { 509 /* Initialize regulator_count */ 510 supplies = opp_table->regulator_count = 1; 511 } else if (unlikely(!supplies)) { 512 dev_err(dev, "%s: opp-microvolt wasn't expected\n", __func__); 513 return -EINVAL; 514 } 515 516 vcount = of_property_count_u32_elems(opp->np, name); 517 if (vcount < 0) { 518 dev_err(dev, "%s: Invalid %s property (%d)\n", 519 __func__, name, vcount); 520 return vcount; 521 } 522 523 /* There can be one or three elements per supply */ 524 if (vcount != supplies && vcount != supplies * 3) { 525 dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n", 526 __func__, name, vcount, supplies); 527 return -EINVAL; 528 } 529 530 microvolt = kmalloc_array(vcount, sizeof(*microvolt), GFP_KERNEL); 531 if (!microvolt) 532 return -ENOMEM; 533 534 ret = of_property_read_u32_array(opp->np, name, microvolt, vcount); 535 if (ret) { 536 dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret); 537 ret = -EINVAL; 538 goto free_microvolt; 539 } 540 541 /* Search for "opp-microamp-<name>" */ 542 prop = NULL; 543 if (opp_table->prop_name) { 544 snprintf(name, sizeof(name), "opp-microamp-%s", 545 opp_table->prop_name); 546 prop = of_find_property(opp->np, name, NULL); 547 } 548 549 if (!prop) { 550 /* Search for "opp-microamp" */ 551 sprintf(name, "opp-microamp"); 552 prop = of_find_property(opp->np, name, NULL); 553 } 554 555 if (prop) { 556 icount = of_property_count_u32_elems(opp->np, name); 557 if (icount < 0) { 558 dev_err(dev, "%s: Invalid %s property (%d)\n", __func__, 559 name, icount); 560 ret = icount; 561 goto free_microvolt; 562 } 563 564 if (icount != supplies) { 565 dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n", 566 __func__, name, icount, supplies); 567 ret = -EINVAL; 568 goto free_microvolt; 569 } 570 571 microamp = kmalloc_array(icount, sizeof(*microamp), GFP_KERNEL); 572 if (!microamp) { 573 ret = -EINVAL; 574 goto free_microvolt; 575 } 576 577 ret = of_property_read_u32_array(opp->np, name, microamp, 578 icount); 579 if (ret) { 580 dev_err(dev, "%s: error parsing %s: %d\n", __func__, 581 name, ret); 582 ret = -EINVAL; 583 goto free_microamp; 584 } 585 } 586 587 for (i = 0, j = 0; i < supplies; i++) { 588 opp->supplies[i].u_volt = microvolt[j++]; 589 590 if (vcount == supplies) { 591 opp->supplies[i].u_volt_min = opp->supplies[i].u_volt; 592 opp->supplies[i].u_volt_max = opp->supplies[i].u_volt; 593 } else { 594 opp->supplies[i].u_volt_min = microvolt[j++]; 595 opp->supplies[i].u_volt_max = microvolt[j++]; 596 } 597 598 if (microamp) 599 opp->supplies[i].u_amp = microamp[i]; 600 } 601 602 free_microamp: 603 kfree(microamp); 604 free_microvolt: 605 kfree(microvolt); 606 607 return ret; 608 } 609 610 /** 611 * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT 612 * entries 613 * @dev: device pointer used to lookup OPP table. 614 * 615 * Free OPPs created using static entries present in DT. 616 */ 617 void dev_pm_opp_of_remove_table(struct device *dev) 618 { 619 _dev_pm_opp_find_and_remove_table(dev); 620 } 621 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table); 622 623 static int _read_bw(struct dev_pm_opp *new_opp, struct opp_table *table, 624 struct device_node *np, bool peak) 625 { 626 const char *name = peak ? "opp-peak-kBps" : "opp-avg-kBps"; 627 struct property *prop; 628 int i, count, ret; 629 u32 *bw; 630 631 prop = of_find_property(np, name, NULL); 632 if (!prop) 633 return -ENODEV; 634 635 count = prop->length / sizeof(u32); 636 if (table->path_count != count) { 637 pr_err("%s: Mismatch between %s and paths (%d %d)\n", 638 __func__, name, count, table->path_count); 639 return -EINVAL; 640 } 641 642 bw = kmalloc_array(count, sizeof(*bw), GFP_KERNEL); 643 if (!bw) 644 return -ENOMEM; 645 646 ret = of_property_read_u32_array(np, name, bw, count); 647 if (ret) { 648 pr_err("%s: Error parsing %s: %d\n", __func__, name, ret); 649 goto out; 650 } 651 652 for (i = 0; i < count; i++) { 653 if (peak) 654 new_opp->bandwidth[i].peak = kBps_to_icc(bw[i]); 655 else 656 new_opp->bandwidth[i].avg = kBps_to_icc(bw[i]); 657 } 658 659 out: 660 kfree(bw); 661 return ret; 662 } 663 664 static int _read_opp_key(struct dev_pm_opp *new_opp, struct opp_table *table, 665 struct device_node *np, bool *rate_not_available) 666 { 667 bool found = false; 668 u64 rate; 669 int ret; 670 671 ret = of_property_read_u64(np, "opp-hz", &rate); 672 if (!ret) { 673 /* 674 * Rate is defined as an unsigned long in clk API, and so 675 * casting explicitly to its type. Must be fixed once rate is 64 676 * bit guaranteed in clk API. 677 */ 678 new_opp->rate = (unsigned long)rate; 679 found = true; 680 } 681 *rate_not_available = !!ret; 682 683 /* 684 * Bandwidth consists of peak and average (optional) values: 685 * opp-peak-kBps = <path1_value path2_value>; 686 * opp-avg-kBps = <path1_value path2_value>; 687 */ 688 ret = _read_bw(new_opp, table, np, true); 689 if (!ret) { 690 found = true; 691 ret = _read_bw(new_opp, table, np, false); 692 } 693 694 /* The properties were found but we failed to parse them */ 695 if (ret && ret != -ENODEV) 696 return ret; 697 698 if (!of_property_read_u32(np, "opp-level", &new_opp->level)) 699 found = true; 700 701 if (found) 702 return 0; 703 704 return ret; 705 } 706 707 /** 708 * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings) 709 * @opp_table: OPP table 710 * @dev: device for which we do this operation 711 * @np: device node 712 * 713 * This function adds an opp definition to the opp table and returns status. The 714 * opp can be controlled using dev_pm_opp_enable/disable functions and may be 715 * removed by dev_pm_opp_remove. 716 * 717 * Return: 718 * Valid OPP pointer: 719 * On success 720 * NULL: 721 * Duplicate OPPs (both freq and volt are same) and opp->available 722 * OR if the OPP is not supported by hardware. 723 * ERR_PTR(-EEXIST): 724 * Freq are same and volt are different OR 725 * Duplicate OPPs (both freq and volt are same) and !opp->available 726 * ERR_PTR(-ENOMEM): 727 * Memory allocation failure 728 * ERR_PTR(-EINVAL): 729 * Failed parsing the OPP node 730 */ 731 static struct dev_pm_opp *_opp_add_static_v2(struct opp_table *opp_table, 732 struct device *dev, struct device_node *np) 733 { 734 struct dev_pm_opp *new_opp; 735 u64 rate = 0; 736 u32 val; 737 int ret; 738 bool rate_not_available = false; 739 740 new_opp = _opp_allocate(opp_table); 741 if (!new_opp) 742 return ERR_PTR(-ENOMEM); 743 744 ret = _read_opp_key(new_opp, opp_table, np, &rate_not_available); 745 if (ret < 0 && !opp_table->is_genpd) { 746 dev_err(dev, "%s: opp key field not found\n", __func__); 747 goto free_opp; 748 } 749 750 /* Check if the OPP supports hardware's hierarchy of versions or not */ 751 if (!_opp_is_supported(dev, opp_table, np)) { 752 dev_dbg(dev, "OPP not supported by hardware: %llu\n", rate); 753 goto free_opp; 754 } 755 756 new_opp->turbo = of_property_read_bool(np, "turbo-mode"); 757 758 new_opp->np = np; 759 new_opp->dynamic = false; 760 new_opp->available = true; 761 762 ret = _of_opp_alloc_required_opps(opp_table, new_opp); 763 if (ret) 764 goto free_opp; 765 766 if (!of_property_read_u32(np, "clock-latency-ns", &val)) 767 new_opp->clock_latency_ns = val; 768 769 ret = opp_parse_supplies(new_opp, dev, opp_table); 770 if (ret) 771 goto free_required_opps; 772 773 if (opp_table->is_genpd) 774 new_opp->pstate = pm_genpd_opp_to_performance_state(dev, new_opp); 775 776 ret = _opp_add(dev, new_opp, opp_table, rate_not_available); 777 if (ret) { 778 /* Don't return error for duplicate OPPs */ 779 if (ret == -EBUSY) 780 ret = 0; 781 goto free_required_opps; 782 } 783 784 /* OPP to select on device suspend */ 785 if (of_property_read_bool(np, "opp-suspend")) { 786 if (opp_table->suspend_opp) { 787 /* Pick the OPP with higher rate as suspend OPP */ 788 if (new_opp->rate > opp_table->suspend_opp->rate) { 789 opp_table->suspend_opp->suspend = false; 790 new_opp->suspend = true; 791 opp_table->suspend_opp = new_opp; 792 } 793 } else { 794 new_opp->suspend = true; 795 opp_table->suspend_opp = new_opp; 796 } 797 } 798 799 if (new_opp->clock_latency_ns > opp_table->clock_latency_ns_max) 800 opp_table->clock_latency_ns_max = new_opp->clock_latency_ns; 801 802 pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n", 803 __func__, new_opp->turbo, new_opp->rate, 804 new_opp->supplies[0].u_volt, new_opp->supplies[0].u_volt_min, 805 new_opp->supplies[0].u_volt_max, new_opp->clock_latency_ns); 806 807 /* 808 * Notify the changes in the availability of the operable 809 * frequency/voltage list. 810 */ 811 blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADD, new_opp); 812 return new_opp; 813 814 free_required_opps: 815 _of_opp_free_required_opps(opp_table, new_opp); 816 free_opp: 817 _opp_free(new_opp); 818 819 return ERR_PTR(ret); 820 } 821 822 /* Initializes OPP tables based on new bindings */ 823 static int _of_add_opp_table_v2(struct device *dev, struct opp_table *opp_table) 824 { 825 struct device_node *np; 826 int ret, count = 0, pstate_count = 0; 827 struct dev_pm_opp *opp; 828 829 /* OPP table is already initialized for the device */ 830 mutex_lock(&opp_table->lock); 831 if (opp_table->parsed_static_opps) { 832 opp_table->parsed_static_opps++; 833 mutex_unlock(&opp_table->lock); 834 return 0; 835 } 836 837 opp_table->parsed_static_opps = 1; 838 mutex_unlock(&opp_table->lock); 839 840 /* We have opp-table node now, iterate over it and add OPPs */ 841 for_each_available_child_of_node(opp_table->np, np) { 842 opp = _opp_add_static_v2(opp_table, dev, np); 843 if (IS_ERR(opp)) { 844 ret = PTR_ERR(opp); 845 dev_err(dev, "%s: Failed to add OPP, %d\n", __func__, 846 ret); 847 of_node_put(np); 848 goto remove_static_opp; 849 } else if (opp) { 850 count++; 851 } 852 } 853 854 /* There should be one of more OPP defined */ 855 if (WARN_ON(!count)) { 856 ret = -ENOENT; 857 goto remove_static_opp; 858 } 859 860 list_for_each_entry(opp, &opp_table->opp_list, node) 861 pstate_count += !!opp->pstate; 862 863 /* Either all or none of the nodes shall have performance state set */ 864 if (pstate_count && pstate_count != count) { 865 dev_err(dev, "Not all nodes have performance state set (%d: %d)\n", 866 count, pstate_count); 867 ret = -ENOENT; 868 goto remove_static_opp; 869 } 870 871 if (pstate_count) 872 opp_table->genpd_performance_state = true; 873 874 return 0; 875 876 remove_static_opp: 877 _opp_remove_all_static(opp_table); 878 879 return ret; 880 } 881 882 /* Initializes OPP tables based on old-deprecated bindings */ 883 static int _of_add_opp_table_v1(struct device *dev, struct opp_table *opp_table) 884 { 885 const struct property *prop; 886 const __be32 *val; 887 int nr, ret = 0; 888 889 prop = of_find_property(dev->of_node, "operating-points", NULL); 890 if (!prop) 891 return -ENODEV; 892 if (!prop->value) 893 return -ENODATA; 894 895 /* 896 * Each OPP is a set of tuples consisting of frequency and 897 * voltage like <freq-kHz vol-uV>. 898 */ 899 nr = prop->length / sizeof(u32); 900 if (nr % 2) { 901 dev_err(dev, "%s: Invalid OPP table\n", __func__); 902 return -EINVAL; 903 } 904 905 val = prop->value; 906 while (nr) { 907 unsigned long freq = be32_to_cpup(val++) * 1000; 908 unsigned long volt = be32_to_cpup(val++); 909 910 ret = _opp_add_v1(opp_table, dev, freq, volt, false); 911 if (ret) { 912 dev_err(dev, "%s: Failed to add OPP %ld (%d)\n", 913 __func__, freq, ret); 914 _opp_remove_all_static(opp_table); 915 return ret; 916 } 917 nr -= 2; 918 } 919 920 return ret; 921 } 922 923 /** 924 * dev_pm_opp_of_add_table() - Initialize opp table from device tree 925 * @dev: device pointer used to lookup OPP table. 926 * 927 * Register the initial OPP table with the OPP library for given device. 928 * 929 * Return: 930 * 0 On success OR 931 * Duplicate OPPs (both freq and volt are same) and opp->available 932 * -EEXIST Freq are same and volt are different OR 933 * Duplicate OPPs (both freq and volt are same) and !opp->available 934 * -ENOMEM Memory allocation failure 935 * -ENODEV when 'operating-points' property is not found or is invalid data 936 * in device node. 937 * -ENODATA when empty 'operating-points' property is found 938 * -EINVAL when invalid entries are found in opp-v2 table 939 */ 940 int dev_pm_opp_of_add_table(struct device *dev) 941 { 942 struct opp_table *opp_table; 943 int ret; 944 945 opp_table = dev_pm_opp_get_opp_table_indexed(dev, 0); 946 if (!opp_table) 947 return -ENOMEM; 948 949 /* 950 * OPPs have two version of bindings now. Also try the old (v1) 951 * bindings for backward compatibility with older dtbs. 952 */ 953 if (opp_table->np) 954 ret = _of_add_opp_table_v2(dev, opp_table); 955 else 956 ret = _of_add_opp_table_v1(dev, opp_table); 957 958 if (ret) 959 dev_pm_opp_put_opp_table(opp_table); 960 961 return ret; 962 } 963 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table); 964 965 /** 966 * dev_pm_opp_of_add_table_indexed() - Initialize indexed opp table from device tree 967 * @dev: device pointer used to lookup OPP table. 968 * @index: Index number. 969 * 970 * Register the initial OPP table with the OPP library for given device only 971 * using the "operating-points-v2" property. 972 * 973 * Return: 974 * 0 On success OR 975 * Duplicate OPPs (both freq and volt are same) and opp->available 976 * -EEXIST Freq are same and volt are different OR 977 * Duplicate OPPs (both freq and volt are same) and !opp->available 978 * -ENOMEM Memory allocation failure 979 * -ENODEV when 'operating-points' property is not found or is invalid data 980 * in device node. 981 * -ENODATA when empty 'operating-points' property is found 982 * -EINVAL when invalid entries are found in opp-v2 table 983 */ 984 int dev_pm_opp_of_add_table_indexed(struct device *dev, int index) 985 { 986 struct opp_table *opp_table; 987 int ret, count; 988 989 if (index) { 990 /* 991 * If only one phandle is present, then the same OPP table 992 * applies for all index requests. 993 */ 994 count = of_count_phandle_with_args(dev->of_node, 995 "operating-points-v2", NULL); 996 if (count == 1) 997 index = 0; 998 } 999 1000 opp_table = dev_pm_opp_get_opp_table_indexed(dev, index); 1001 if (!opp_table) 1002 return -ENOMEM; 1003 1004 ret = _of_add_opp_table_v2(dev, opp_table); 1005 if (ret) 1006 dev_pm_opp_put_opp_table(opp_table); 1007 1008 return ret; 1009 } 1010 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_indexed); 1011 1012 /* CPU device specific helpers */ 1013 1014 /** 1015 * dev_pm_opp_of_cpumask_remove_table() - Removes OPP table for @cpumask 1016 * @cpumask: cpumask for which OPP table needs to be removed 1017 * 1018 * This removes the OPP tables for CPUs present in the @cpumask. 1019 * This should be used only to remove static entries created from DT. 1020 */ 1021 void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask) 1022 { 1023 _dev_pm_opp_cpumask_remove_table(cpumask, -1); 1024 } 1025 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table); 1026 1027 /** 1028 * dev_pm_opp_of_cpumask_add_table() - Adds OPP table for @cpumask 1029 * @cpumask: cpumask for which OPP table needs to be added. 1030 * 1031 * This adds the OPP tables for CPUs present in the @cpumask. 1032 */ 1033 int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask) 1034 { 1035 struct device *cpu_dev; 1036 int cpu, ret; 1037 1038 if (WARN_ON(cpumask_empty(cpumask))) 1039 return -ENODEV; 1040 1041 for_each_cpu(cpu, cpumask) { 1042 cpu_dev = get_cpu_device(cpu); 1043 if (!cpu_dev) { 1044 pr_err("%s: failed to get cpu%d device\n", __func__, 1045 cpu); 1046 ret = -ENODEV; 1047 goto remove_table; 1048 } 1049 1050 ret = dev_pm_opp_of_add_table(cpu_dev); 1051 if (ret) { 1052 /* 1053 * OPP may get registered dynamically, don't print error 1054 * message here. 1055 */ 1056 pr_debug("%s: couldn't find opp table for cpu:%d, %d\n", 1057 __func__, cpu, ret); 1058 1059 goto remove_table; 1060 } 1061 } 1062 1063 return 0; 1064 1065 remove_table: 1066 /* Free all other OPPs */ 1067 _dev_pm_opp_cpumask_remove_table(cpumask, cpu); 1068 1069 return ret; 1070 } 1071 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table); 1072 1073 /* 1074 * Works only for OPP v2 bindings. 1075 * 1076 * Returns -ENOENT if operating-points-v2 bindings aren't supported. 1077 */ 1078 /** 1079 * dev_pm_opp_of_get_sharing_cpus() - Get cpumask of CPUs sharing OPPs with 1080 * @cpu_dev using operating-points-v2 1081 * bindings. 1082 * 1083 * @cpu_dev: CPU device for which we do this operation 1084 * @cpumask: cpumask to update with information of sharing CPUs 1085 * 1086 * This updates the @cpumask with CPUs that are sharing OPPs with @cpu_dev. 1087 * 1088 * Returns -ENOENT if operating-points-v2 isn't present for @cpu_dev. 1089 */ 1090 int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, 1091 struct cpumask *cpumask) 1092 { 1093 struct device_node *np, *tmp_np, *cpu_np; 1094 int cpu, ret = 0; 1095 1096 /* Get OPP descriptor node */ 1097 np = dev_pm_opp_of_get_opp_desc_node(cpu_dev); 1098 if (!np) { 1099 dev_dbg(cpu_dev, "%s: Couldn't find opp node.\n", __func__); 1100 return -ENOENT; 1101 } 1102 1103 cpumask_set_cpu(cpu_dev->id, cpumask); 1104 1105 /* OPPs are shared ? */ 1106 if (!of_property_read_bool(np, "opp-shared")) 1107 goto put_cpu_node; 1108 1109 for_each_possible_cpu(cpu) { 1110 if (cpu == cpu_dev->id) 1111 continue; 1112 1113 cpu_np = of_cpu_device_node_get(cpu); 1114 if (!cpu_np) { 1115 dev_err(cpu_dev, "%s: failed to get cpu%d node\n", 1116 __func__, cpu); 1117 ret = -ENOENT; 1118 goto put_cpu_node; 1119 } 1120 1121 /* Get OPP descriptor node */ 1122 tmp_np = _opp_of_get_opp_desc_node(cpu_np, 0); 1123 of_node_put(cpu_np); 1124 if (!tmp_np) { 1125 pr_err("%pOF: Couldn't find opp node\n", cpu_np); 1126 ret = -ENOENT; 1127 goto put_cpu_node; 1128 } 1129 1130 /* CPUs are sharing opp node */ 1131 if (np == tmp_np) 1132 cpumask_set_cpu(cpu, cpumask); 1133 1134 of_node_put(tmp_np); 1135 } 1136 1137 put_cpu_node: 1138 of_node_put(np); 1139 return ret; 1140 } 1141 EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus); 1142 1143 /** 1144 * of_get_required_opp_performance_state() - Search for required OPP and return its performance state. 1145 * @np: Node that contains the "required-opps" property. 1146 * @index: Index of the phandle to parse. 1147 * 1148 * Returns the performance state of the OPP pointed out by the "required-opps" 1149 * property at @index in @np. 1150 * 1151 * Return: Zero or positive performance state on success, otherwise negative 1152 * value on errors. 1153 */ 1154 int of_get_required_opp_performance_state(struct device_node *np, int index) 1155 { 1156 struct dev_pm_opp *opp; 1157 struct device_node *required_np; 1158 struct opp_table *opp_table; 1159 int pstate = -EINVAL; 1160 1161 required_np = of_parse_required_opp(np, index); 1162 if (!required_np) 1163 return -EINVAL; 1164 1165 opp_table = _find_table_of_opp_np(required_np); 1166 if (IS_ERR(opp_table)) { 1167 pr_err("%s: Failed to find required OPP table %pOF: %ld\n", 1168 __func__, np, PTR_ERR(opp_table)); 1169 goto put_required_np; 1170 } 1171 1172 opp = _find_opp_of_np(opp_table, required_np); 1173 if (opp) { 1174 pstate = opp->pstate; 1175 dev_pm_opp_put(opp); 1176 } 1177 1178 dev_pm_opp_put_opp_table(opp_table); 1179 1180 put_required_np: 1181 of_node_put(required_np); 1182 1183 return pstate; 1184 } 1185 EXPORT_SYMBOL_GPL(of_get_required_opp_performance_state); 1186 1187 /** 1188 * dev_pm_opp_get_of_node() - Gets the DT node corresponding to an opp 1189 * @opp: opp for which DT node has to be returned for 1190 * 1191 * Return: DT node corresponding to the opp, else 0 on success. 1192 * 1193 * The caller needs to put the node with of_node_put() after using it. 1194 */ 1195 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) 1196 { 1197 if (IS_ERR_OR_NULL(opp)) { 1198 pr_err("%s: Invalid parameters\n", __func__); 1199 return NULL; 1200 } 1201 1202 return of_node_get(opp->np); 1203 } 1204 EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node); 1205 1206 /* 1207 * Callback function provided to the Energy Model framework upon registration. 1208 * This computes the power estimated by @CPU at @kHz if it is the frequency 1209 * of an existing OPP, or at the frequency of the first OPP above @kHz otherwise 1210 * (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled 1211 * frequency and @mW to the associated power. The power is estimated as 1212 * P = C * V^2 * f with C being the CPU's capacitance and V and f respectively 1213 * the voltage and frequency of the OPP. 1214 * 1215 * Returns -ENODEV if the CPU device cannot be found, -EINVAL if the power 1216 * calculation failed because of missing parameters, 0 otherwise. 1217 */ 1218 static int __maybe_unused _get_cpu_power(unsigned long *mW, unsigned long *kHz, 1219 int cpu) 1220 { 1221 struct device *cpu_dev; 1222 struct dev_pm_opp *opp; 1223 struct device_node *np; 1224 unsigned long mV, Hz; 1225 u32 cap; 1226 u64 tmp; 1227 int ret; 1228 1229 cpu_dev = get_cpu_device(cpu); 1230 if (!cpu_dev) 1231 return -ENODEV; 1232 1233 np = of_node_get(cpu_dev->of_node); 1234 if (!np) 1235 return -EINVAL; 1236 1237 ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap); 1238 of_node_put(np); 1239 if (ret) 1240 return -EINVAL; 1241 1242 Hz = *kHz * 1000; 1243 opp = dev_pm_opp_find_freq_ceil(cpu_dev, &Hz); 1244 if (IS_ERR(opp)) 1245 return -EINVAL; 1246 1247 mV = dev_pm_opp_get_voltage(opp) / 1000; 1248 dev_pm_opp_put(opp); 1249 if (!mV) 1250 return -EINVAL; 1251 1252 tmp = (u64)cap * mV * mV * (Hz / 1000000); 1253 do_div(tmp, 1000000000); 1254 1255 *mW = (unsigned long)tmp; 1256 *kHz = Hz / 1000; 1257 1258 return 0; 1259 } 1260 1261 /** 1262 * dev_pm_opp_of_register_em() - Attempt to register an Energy Model 1263 * @cpus : CPUs for which an Energy Model has to be registered 1264 * 1265 * This checks whether the "dynamic-power-coefficient" devicetree property has 1266 * been specified, and tries to register an Energy Model with it if it has. 1267 */ 1268 void dev_pm_opp_of_register_em(struct cpumask *cpus) 1269 { 1270 struct em_data_callback em_cb = EM_DATA_CB(_get_cpu_power); 1271 int ret, nr_opp, cpu = cpumask_first(cpus); 1272 struct device *cpu_dev; 1273 struct device_node *np; 1274 u32 cap; 1275 1276 cpu_dev = get_cpu_device(cpu); 1277 if (!cpu_dev) 1278 return; 1279 1280 nr_opp = dev_pm_opp_get_opp_count(cpu_dev); 1281 if (nr_opp <= 0) 1282 return; 1283 1284 np = of_node_get(cpu_dev->of_node); 1285 if (!np) 1286 return; 1287 1288 /* 1289 * Register an EM only if the 'dynamic-power-coefficient' property is 1290 * set in devicetree. It is assumed the voltage values are known if that 1291 * property is set since it is useless otherwise. If voltages are not 1292 * known, just let the EM registration fail with an error to alert the 1293 * user about the inconsistent configuration. 1294 */ 1295 ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap); 1296 of_node_put(np); 1297 if (ret || !cap) 1298 return; 1299 1300 em_register_perf_domain(cpus, nr_opp, &em_cb); 1301 } 1302 EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em); 1303