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 opp_table_np = of_get_parent(opp_np); 116 if (!opp_table_np) 117 goto err; 118 119 /* It is safe to put the node now as all we need now is its address */ 120 of_node_put(opp_table_np); 121 122 mutex_lock(&opp_table_lock); 123 list_for_each_entry(opp_table, &opp_tables, node) { 124 if (opp_table_np == opp_table->np) { 125 _get_opp_table_kref(opp_table); 126 mutex_unlock(&opp_table_lock); 127 return opp_table; 128 } 129 } 130 mutex_unlock(&opp_table_lock); 131 132 err: 133 return ERR_PTR(-ENODEV); 134 } 135 136 /* Free resources previously acquired by _opp_table_alloc_required_tables() */ 137 static void _opp_table_free_required_tables(struct opp_table *opp_table) 138 { 139 struct opp_table **required_opp_tables = opp_table->required_opp_tables; 140 int i; 141 142 if (!required_opp_tables) 143 return; 144 145 for (i = 0; i < opp_table->required_opp_count; i++) { 146 if (IS_ERR_OR_NULL(required_opp_tables[i])) 147 continue; 148 149 dev_pm_opp_put_opp_table(required_opp_tables[i]); 150 } 151 152 kfree(required_opp_tables); 153 154 opp_table->required_opp_count = 0; 155 opp_table->required_opp_tables = NULL; 156 list_del(&opp_table->lazy); 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 bool lazy = false; 170 int count, i; 171 172 /* Traversing the first OPP node is all we need */ 173 np = of_get_next_available_child(opp_np, NULL); 174 if (!np) { 175 dev_warn(dev, "Empty OPP table\n"); 176 177 return; 178 } 179 180 count = of_count_phandle_with_args(np, "required-opps", NULL); 181 if (!count) 182 goto put_np; 183 184 required_opp_tables = kcalloc(count, sizeof(*required_opp_tables), 185 GFP_KERNEL); 186 if (!required_opp_tables) 187 goto put_np; 188 189 opp_table->required_opp_tables = required_opp_tables; 190 opp_table->required_opp_count = count; 191 192 for (i = 0; i < count; i++) { 193 required_np = of_parse_required_opp(np, i); 194 if (!required_np) 195 goto free_required_tables; 196 197 required_opp_tables[i] = _find_table_of_opp_np(required_np); 198 of_node_put(required_np); 199 200 if (IS_ERR(required_opp_tables[i])) 201 lazy = true; 202 } 203 204 /* Let's do the linking later on */ 205 if (lazy) 206 list_add(&opp_table->lazy, &lazy_opp_tables); 207 208 goto put_np; 209 210 free_required_tables: 211 _opp_table_free_required_tables(opp_table); 212 put_np: 213 of_node_put(np); 214 } 215 216 void _of_init_opp_table(struct opp_table *opp_table, struct device *dev, 217 int index) 218 { 219 struct device_node *np, *opp_np; 220 u32 val; 221 222 /* 223 * Only required for backward compatibility with v1 bindings, but isn't 224 * harmful for other cases. And so we do it unconditionally. 225 */ 226 np = of_node_get(dev->of_node); 227 if (!np) 228 return; 229 230 if (!of_property_read_u32(np, "clock-latency", &val)) 231 opp_table->clock_latency_ns_max = val; 232 of_property_read_u32(np, "voltage-tolerance", 233 &opp_table->voltage_tolerance_v1); 234 235 if (of_find_property(np, "#power-domain-cells", NULL)) 236 opp_table->is_genpd = true; 237 238 /* Get OPP table node */ 239 opp_np = _opp_of_get_opp_desc_node(np, index); 240 of_node_put(np); 241 242 if (!opp_np) 243 return; 244 245 if (of_property_read_bool(opp_np, "opp-shared")) 246 opp_table->shared_opp = OPP_TABLE_ACCESS_SHARED; 247 else 248 opp_table->shared_opp = OPP_TABLE_ACCESS_EXCLUSIVE; 249 250 opp_table->np = opp_np; 251 252 _opp_table_alloc_required_tables(opp_table, dev, opp_np); 253 of_node_put(opp_np); 254 } 255 256 void _of_clear_opp_table(struct opp_table *opp_table) 257 { 258 _opp_table_free_required_tables(opp_table); 259 } 260 261 /* 262 * Release all resources previously acquired with a call to 263 * _of_opp_alloc_required_opps(). 264 */ 265 void _of_opp_free_required_opps(struct opp_table *opp_table, 266 struct dev_pm_opp *opp) 267 { 268 struct dev_pm_opp **required_opps = opp->required_opps; 269 int i; 270 271 if (!required_opps) 272 return; 273 274 for (i = 0; i < opp_table->required_opp_count; i++) { 275 if (!required_opps[i]) 276 continue; 277 278 /* Put the reference back */ 279 dev_pm_opp_put(required_opps[i]); 280 } 281 282 opp->required_opps = NULL; 283 kfree(required_opps); 284 } 285 286 /* Populate all required OPPs which are part of "required-opps" list */ 287 static int _of_opp_alloc_required_opps(struct opp_table *opp_table, 288 struct dev_pm_opp *opp) 289 { 290 struct dev_pm_opp **required_opps; 291 struct opp_table *required_table; 292 struct device_node *np; 293 int i, ret, count = opp_table->required_opp_count; 294 295 if (!count) 296 return 0; 297 298 required_opps = kcalloc(count, sizeof(*required_opps), GFP_KERNEL); 299 if (!required_opps) 300 return -ENOMEM; 301 302 opp->required_opps = required_opps; 303 304 for (i = 0; i < count; i++) { 305 required_table = opp_table->required_opp_tables[i]; 306 307 /* Required table not added yet, we will link later */ 308 if (IS_ERR_OR_NULL(required_table)) 309 continue; 310 311 np = of_parse_required_opp(opp->np, i); 312 if (unlikely(!np)) { 313 ret = -ENODEV; 314 goto free_required_opps; 315 } 316 317 required_opps[i] = _find_opp_of_np(required_table, np); 318 of_node_put(np); 319 320 if (!required_opps[i]) { 321 pr_err("%s: Unable to find required OPP node: %pOF (%d)\n", 322 __func__, opp->np, i); 323 ret = -ENODEV; 324 goto free_required_opps; 325 } 326 } 327 328 return 0; 329 330 free_required_opps: 331 _of_opp_free_required_opps(opp_table, opp); 332 333 return ret; 334 } 335 336 /* Link required OPPs for an individual OPP */ 337 static int lazy_link_required_opps(struct opp_table *opp_table, 338 struct opp_table *new_table, int index) 339 { 340 struct device_node *required_np; 341 struct dev_pm_opp *opp; 342 343 list_for_each_entry(opp, &opp_table->opp_list, node) { 344 required_np = of_parse_required_opp(opp->np, index); 345 if (unlikely(!required_np)) 346 return -ENODEV; 347 348 opp->required_opps[index] = _find_opp_of_np(new_table, required_np); 349 of_node_put(required_np); 350 351 if (!opp->required_opps[index]) { 352 pr_err("%s: Unable to find required OPP node: %pOF (%d)\n", 353 __func__, opp->np, index); 354 return -ENODEV; 355 } 356 } 357 358 return 0; 359 } 360 361 /* Link required OPPs for all OPPs of the newly added OPP table */ 362 static void lazy_link_required_opp_table(struct opp_table *new_table) 363 { 364 struct opp_table *opp_table, *temp, **required_opp_tables; 365 struct device_node *required_np, *opp_np, *required_table_np; 366 struct dev_pm_opp *opp; 367 int i, ret; 368 369 mutex_lock(&opp_table_lock); 370 371 list_for_each_entry_safe(opp_table, temp, &lazy_opp_tables, lazy) { 372 bool lazy = false; 373 374 /* opp_np can't be invalid here */ 375 opp_np = of_get_next_available_child(opp_table->np, NULL); 376 377 for (i = 0; i < opp_table->required_opp_count; i++) { 378 required_opp_tables = opp_table->required_opp_tables; 379 380 /* Required opp-table is already parsed */ 381 if (!IS_ERR(required_opp_tables[i])) 382 continue; 383 384 /* required_np can't be invalid here */ 385 required_np = of_parse_required_opp(opp_np, i); 386 required_table_np = of_get_parent(required_np); 387 388 of_node_put(required_table_np); 389 of_node_put(required_np); 390 391 /* 392 * Newly added table isn't the required opp-table for 393 * opp_table. 394 */ 395 if (required_table_np != new_table->np) { 396 lazy = true; 397 continue; 398 } 399 400 required_opp_tables[i] = new_table; 401 _get_opp_table_kref(new_table); 402 403 /* Link OPPs now */ 404 ret = lazy_link_required_opps(opp_table, new_table, i); 405 if (ret) { 406 /* The OPPs will be marked unusable */ 407 lazy = false; 408 break; 409 } 410 } 411 412 of_node_put(opp_np); 413 414 /* All required opp-tables found, remove from lazy list */ 415 if (!lazy) { 416 list_del_init(&opp_table->lazy); 417 418 list_for_each_entry(opp, &opp_table->opp_list, node) 419 _required_opps_available(opp, opp_table->required_opp_count); 420 } 421 } 422 423 mutex_unlock(&opp_table_lock); 424 } 425 426 static int _bandwidth_supported(struct device *dev, struct opp_table *opp_table) 427 { 428 struct device_node *np, *opp_np; 429 struct property *prop; 430 431 if (!opp_table) { 432 np = of_node_get(dev->of_node); 433 if (!np) 434 return -ENODEV; 435 436 opp_np = _opp_of_get_opp_desc_node(np, 0); 437 of_node_put(np); 438 } else { 439 opp_np = of_node_get(opp_table->np); 440 } 441 442 /* Lets not fail in case we are parsing opp-v1 bindings */ 443 if (!opp_np) 444 return 0; 445 446 /* Checking only first OPP is sufficient */ 447 np = of_get_next_available_child(opp_np, NULL); 448 if (!np) { 449 dev_err(dev, "OPP table empty\n"); 450 return -EINVAL; 451 } 452 of_node_put(opp_np); 453 454 prop = of_find_property(np, "opp-peak-kBps", NULL); 455 of_node_put(np); 456 457 if (!prop || !prop->length) 458 return 0; 459 460 return 1; 461 } 462 463 int dev_pm_opp_of_find_icc_paths(struct device *dev, 464 struct opp_table *opp_table) 465 { 466 struct device_node *np; 467 int ret, i, count, num_paths; 468 struct icc_path **paths; 469 470 ret = _bandwidth_supported(dev, opp_table); 471 if (ret == -EINVAL) 472 return 0; /* Empty OPP table is a valid corner-case, let's not fail */ 473 else if (ret <= 0) 474 return ret; 475 476 ret = 0; 477 478 np = of_node_get(dev->of_node); 479 if (!np) 480 return 0; 481 482 count = of_count_phandle_with_args(np, "interconnects", 483 "#interconnect-cells"); 484 of_node_put(np); 485 if (count < 0) 486 return 0; 487 488 /* two phandles when #interconnect-cells = <1> */ 489 if (count % 2) { 490 dev_err(dev, "%s: Invalid interconnects values\n", __func__); 491 return -EINVAL; 492 } 493 494 num_paths = count / 2; 495 paths = kcalloc(num_paths, sizeof(*paths), GFP_KERNEL); 496 if (!paths) 497 return -ENOMEM; 498 499 for (i = 0; i < num_paths; i++) { 500 paths[i] = of_icc_get_by_index(dev, i); 501 if (IS_ERR(paths[i])) { 502 ret = PTR_ERR(paths[i]); 503 if (ret != -EPROBE_DEFER) { 504 dev_err(dev, "%s: Unable to get path%d: %d\n", 505 __func__, i, ret); 506 } 507 goto err; 508 } 509 } 510 511 if (opp_table) { 512 opp_table->paths = paths; 513 opp_table->path_count = num_paths; 514 return 0; 515 } 516 517 err: 518 while (i--) 519 icc_put(paths[i]); 520 521 kfree(paths); 522 523 return ret; 524 } 525 EXPORT_SYMBOL_GPL(dev_pm_opp_of_find_icc_paths); 526 527 static bool _opp_is_supported(struct device *dev, struct opp_table *opp_table, 528 struct device_node *np) 529 { 530 unsigned int levels = opp_table->supported_hw_count; 531 int count, versions, ret, i, j; 532 u32 val; 533 534 if (!opp_table->supported_hw) { 535 /* 536 * In the case that no supported_hw has been set by the 537 * platform but there is an opp-supported-hw value set for 538 * an OPP then the OPP should not be enabled as there is 539 * no way to see if the hardware supports it. 540 */ 541 if (of_find_property(np, "opp-supported-hw", NULL)) 542 return false; 543 else 544 return true; 545 } 546 547 count = of_property_count_u32_elems(np, "opp-supported-hw"); 548 if (count <= 0 || count % levels) { 549 dev_err(dev, "%s: Invalid opp-supported-hw property (%d)\n", 550 __func__, count); 551 return false; 552 } 553 554 versions = count / levels; 555 556 /* All levels in at least one of the versions should match */ 557 for (i = 0; i < versions; i++) { 558 bool supported = true; 559 560 for (j = 0; j < levels; j++) { 561 ret = of_property_read_u32_index(np, "opp-supported-hw", 562 i * levels + j, &val); 563 if (ret) { 564 dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n", 565 __func__, i * levels + j, ret); 566 return false; 567 } 568 569 /* Check if the level is supported */ 570 if (!(val & opp_table->supported_hw[j])) { 571 supported = false; 572 break; 573 } 574 } 575 576 if (supported) 577 return true; 578 } 579 580 return false; 581 } 582 583 static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev, 584 struct opp_table *opp_table) 585 { 586 u32 *microvolt, *microamp = NULL; 587 int supplies = opp_table->regulator_count, vcount, icount, ret, i, j; 588 struct property *prop = NULL; 589 char name[NAME_MAX]; 590 591 /* Search for "opp-microvolt-<name>" */ 592 if (opp_table->prop_name) { 593 snprintf(name, sizeof(name), "opp-microvolt-%s", 594 opp_table->prop_name); 595 prop = of_find_property(opp->np, name, NULL); 596 } 597 598 if (!prop) { 599 /* Search for "opp-microvolt" */ 600 sprintf(name, "opp-microvolt"); 601 prop = of_find_property(opp->np, name, NULL); 602 603 /* Missing property isn't a problem, but an invalid entry is */ 604 if (!prop) { 605 if (unlikely(supplies == -1)) { 606 /* Initialize regulator_count */ 607 opp_table->regulator_count = 0; 608 return 0; 609 } 610 611 if (!supplies) 612 return 0; 613 614 dev_err(dev, "%s: opp-microvolt missing although OPP managing regulators\n", 615 __func__); 616 return -EINVAL; 617 } 618 } 619 620 if (unlikely(supplies == -1)) { 621 /* Initialize regulator_count */ 622 supplies = opp_table->regulator_count = 1; 623 } else if (unlikely(!supplies)) { 624 dev_err(dev, "%s: opp-microvolt wasn't expected\n", __func__); 625 return -EINVAL; 626 } 627 628 vcount = of_property_count_u32_elems(opp->np, name); 629 if (vcount < 0) { 630 dev_err(dev, "%s: Invalid %s property (%d)\n", 631 __func__, name, vcount); 632 return vcount; 633 } 634 635 /* There can be one or three elements per supply */ 636 if (vcount != supplies && vcount != supplies * 3) { 637 dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n", 638 __func__, name, vcount, supplies); 639 return -EINVAL; 640 } 641 642 microvolt = kmalloc_array(vcount, sizeof(*microvolt), GFP_KERNEL); 643 if (!microvolt) 644 return -ENOMEM; 645 646 ret = of_property_read_u32_array(opp->np, name, microvolt, vcount); 647 if (ret) { 648 dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret); 649 ret = -EINVAL; 650 goto free_microvolt; 651 } 652 653 /* Search for "opp-microamp-<name>" */ 654 prop = NULL; 655 if (opp_table->prop_name) { 656 snprintf(name, sizeof(name), "opp-microamp-%s", 657 opp_table->prop_name); 658 prop = of_find_property(opp->np, name, NULL); 659 } 660 661 if (!prop) { 662 /* Search for "opp-microamp" */ 663 sprintf(name, "opp-microamp"); 664 prop = of_find_property(opp->np, name, NULL); 665 } 666 667 if (prop) { 668 icount = of_property_count_u32_elems(opp->np, name); 669 if (icount < 0) { 670 dev_err(dev, "%s: Invalid %s property (%d)\n", __func__, 671 name, icount); 672 ret = icount; 673 goto free_microvolt; 674 } 675 676 if (icount != supplies) { 677 dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n", 678 __func__, name, icount, supplies); 679 ret = -EINVAL; 680 goto free_microvolt; 681 } 682 683 microamp = kmalloc_array(icount, sizeof(*microamp), GFP_KERNEL); 684 if (!microamp) { 685 ret = -EINVAL; 686 goto free_microvolt; 687 } 688 689 ret = of_property_read_u32_array(opp->np, name, microamp, 690 icount); 691 if (ret) { 692 dev_err(dev, "%s: error parsing %s: %d\n", __func__, 693 name, ret); 694 ret = -EINVAL; 695 goto free_microamp; 696 } 697 } 698 699 for (i = 0, j = 0; i < supplies; i++) { 700 opp->supplies[i].u_volt = microvolt[j++]; 701 702 if (vcount == supplies) { 703 opp->supplies[i].u_volt_min = opp->supplies[i].u_volt; 704 opp->supplies[i].u_volt_max = opp->supplies[i].u_volt; 705 } else { 706 opp->supplies[i].u_volt_min = microvolt[j++]; 707 opp->supplies[i].u_volt_max = microvolt[j++]; 708 } 709 710 if (microamp) 711 opp->supplies[i].u_amp = microamp[i]; 712 } 713 714 free_microamp: 715 kfree(microamp); 716 free_microvolt: 717 kfree(microvolt); 718 719 return ret; 720 } 721 722 /** 723 * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT 724 * entries 725 * @dev: device pointer used to lookup OPP table. 726 * 727 * Free OPPs created using static entries present in DT. 728 */ 729 void dev_pm_opp_of_remove_table(struct device *dev) 730 { 731 dev_pm_opp_remove_table(dev); 732 } 733 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table); 734 735 static int _read_bw(struct dev_pm_opp *new_opp, struct opp_table *table, 736 struct device_node *np, bool peak) 737 { 738 const char *name = peak ? "opp-peak-kBps" : "opp-avg-kBps"; 739 struct property *prop; 740 int i, count, ret; 741 u32 *bw; 742 743 prop = of_find_property(np, name, NULL); 744 if (!prop) 745 return -ENODEV; 746 747 count = prop->length / sizeof(u32); 748 if (table->path_count != count) { 749 pr_err("%s: Mismatch between %s and paths (%d %d)\n", 750 __func__, name, count, table->path_count); 751 return -EINVAL; 752 } 753 754 bw = kmalloc_array(count, sizeof(*bw), GFP_KERNEL); 755 if (!bw) 756 return -ENOMEM; 757 758 ret = of_property_read_u32_array(np, name, bw, count); 759 if (ret) { 760 pr_err("%s: Error parsing %s: %d\n", __func__, name, ret); 761 goto out; 762 } 763 764 for (i = 0; i < count; i++) { 765 if (peak) 766 new_opp->bandwidth[i].peak = kBps_to_icc(bw[i]); 767 else 768 new_opp->bandwidth[i].avg = kBps_to_icc(bw[i]); 769 } 770 771 out: 772 kfree(bw); 773 return ret; 774 } 775 776 static int _read_opp_key(struct dev_pm_opp *new_opp, struct opp_table *table, 777 struct device_node *np, bool *rate_not_available) 778 { 779 bool found = false; 780 u64 rate; 781 int ret; 782 783 ret = of_property_read_u64(np, "opp-hz", &rate); 784 if (!ret) { 785 /* 786 * Rate is defined as an unsigned long in clk API, and so 787 * casting explicitly to its type. Must be fixed once rate is 64 788 * bit guaranteed in clk API. 789 */ 790 new_opp->rate = (unsigned long)rate; 791 found = true; 792 } 793 *rate_not_available = !!ret; 794 795 /* 796 * Bandwidth consists of peak and average (optional) values: 797 * opp-peak-kBps = <path1_value path2_value>; 798 * opp-avg-kBps = <path1_value path2_value>; 799 */ 800 ret = _read_bw(new_opp, table, np, true); 801 if (!ret) { 802 found = true; 803 ret = _read_bw(new_opp, table, np, false); 804 } 805 806 /* The properties were found but we failed to parse them */ 807 if (ret && ret != -ENODEV) 808 return ret; 809 810 if (!of_property_read_u32(np, "opp-level", &new_opp->level)) 811 found = true; 812 813 if (found) 814 return 0; 815 816 return ret; 817 } 818 819 /** 820 * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings) 821 * @opp_table: OPP table 822 * @dev: device for which we do this operation 823 * @np: device node 824 * 825 * This function adds an opp definition to the opp table and returns status. The 826 * opp can be controlled using dev_pm_opp_enable/disable functions and may be 827 * removed by dev_pm_opp_remove. 828 * 829 * Return: 830 * Valid OPP pointer: 831 * On success 832 * NULL: 833 * Duplicate OPPs (both freq and volt are same) and opp->available 834 * OR if the OPP is not supported by hardware. 835 * ERR_PTR(-EEXIST): 836 * Freq are same and volt are different OR 837 * Duplicate OPPs (both freq and volt are same) and !opp->available 838 * ERR_PTR(-ENOMEM): 839 * Memory allocation failure 840 * ERR_PTR(-EINVAL): 841 * Failed parsing the OPP node 842 */ 843 static struct dev_pm_opp *_opp_add_static_v2(struct opp_table *opp_table, 844 struct device *dev, struct device_node *np) 845 { 846 struct dev_pm_opp *new_opp; 847 u32 val; 848 int ret; 849 bool rate_not_available = false; 850 851 new_opp = _opp_allocate(opp_table); 852 if (!new_opp) 853 return ERR_PTR(-ENOMEM); 854 855 ret = _read_opp_key(new_opp, opp_table, np, &rate_not_available); 856 if (ret < 0) { 857 dev_err(dev, "%s: opp key field not found\n", __func__); 858 goto free_opp; 859 } 860 861 /* Check if the OPP supports hardware's hierarchy of versions or not */ 862 if (!_opp_is_supported(dev, opp_table, np)) { 863 dev_dbg(dev, "OPP not supported by hardware: %lu\n", 864 new_opp->rate); 865 goto free_opp; 866 } 867 868 new_opp->turbo = of_property_read_bool(np, "turbo-mode"); 869 870 new_opp->np = np; 871 new_opp->dynamic = false; 872 new_opp->available = true; 873 874 ret = _of_opp_alloc_required_opps(opp_table, new_opp); 875 if (ret) 876 goto free_opp; 877 878 if (!of_property_read_u32(np, "clock-latency-ns", &val)) 879 new_opp->clock_latency_ns = val; 880 881 ret = opp_parse_supplies(new_opp, dev, opp_table); 882 if (ret) 883 goto free_required_opps; 884 885 if (opp_table->is_genpd) 886 new_opp->pstate = pm_genpd_opp_to_performance_state(dev, new_opp); 887 888 ret = _opp_add(dev, new_opp, opp_table, rate_not_available); 889 if (ret) { 890 /* Don't return error for duplicate OPPs */ 891 if (ret == -EBUSY) 892 ret = 0; 893 goto free_required_opps; 894 } 895 896 /* OPP to select on device suspend */ 897 if (of_property_read_bool(np, "opp-suspend")) { 898 if (opp_table->suspend_opp) { 899 /* Pick the OPP with higher rate as suspend OPP */ 900 if (new_opp->rate > opp_table->suspend_opp->rate) { 901 opp_table->suspend_opp->suspend = false; 902 new_opp->suspend = true; 903 opp_table->suspend_opp = new_opp; 904 } 905 } else { 906 new_opp->suspend = true; 907 opp_table->suspend_opp = new_opp; 908 } 909 } 910 911 if (new_opp->clock_latency_ns > opp_table->clock_latency_ns_max) 912 opp_table->clock_latency_ns_max = new_opp->clock_latency_ns; 913 914 pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu level:%u\n", 915 __func__, new_opp->turbo, new_opp->rate, 916 new_opp->supplies[0].u_volt, new_opp->supplies[0].u_volt_min, 917 new_opp->supplies[0].u_volt_max, new_opp->clock_latency_ns, 918 new_opp->level); 919 920 /* 921 * Notify the changes in the availability of the operable 922 * frequency/voltage list. 923 */ 924 blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADD, new_opp); 925 return new_opp; 926 927 free_required_opps: 928 _of_opp_free_required_opps(opp_table, new_opp); 929 free_opp: 930 _opp_free(new_opp); 931 932 return ERR_PTR(ret); 933 } 934 935 /* Initializes OPP tables based on new bindings */ 936 static int _of_add_opp_table_v2(struct device *dev, struct opp_table *opp_table) 937 { 938 struct device_node *np; 939 int ret, count = 0; 940 struct dev_pm_opp *opp; 941 942 /* OPP table is already initialized for the device */ 943 mutex_lock(&opp_table->lock); 944 if (opp_table->parsed_static_opps) { 945 opp_table->parsed_static_opps++; 946 mutex_unlock(&opp_table->lock); 947 return 0; 948 } 949 950 opp_table->parsed_static_opps = 1; 951 mutex_unlock(&opp_table->lock); 952 953 /* We have opp-table node now, iterate over it and add OPPs */ 954 for_each_available_child_of_node(opp_table->np, np) { 955 opp = _opp_add_static_v2(opp_table, dev, np); 956 if (IS_ERR(opp)) { 957 ret = PTR_ERR(opp); 958 dev_err(dev, "%s: Failed to add OPP, %d\n", __func__, 959 ret); 960 of_node_put(np); 961 goto remove_static_opp; 962 } else if (opp) { 963 count++; 964 } 965 } 966 967 /* There should be one or more OPPs defined */ 968 if (!count) { 969 dev_err(dev, "%s: no supported OPPs", __func__); 970 ret = -ENOENT; 971 goto remove_static_opp; 972 } 973 974 list_for_each_entry(opp, &opp_table->opp_list, node) { 975 /* Any non-zero performance state would enable the feature */ 976 if (opp->pstate) { 977 opp_table->genpd_performance_state = true; 978 break; 979 } 980 } 981 982 lazy_link_required_opp_table(opp_table); 983 984 return 0; 985 986 remove_static_opp: 987 _opp_remove_all_static(opp_table); 988 989 return ret; 990 } 991 992 /* Initializes OPP tables based on old-deprecated bindings */ 993 static int _of_add_opp_table_v1(struct device *dev, struct opp_table *opp_table) 994 { 995 const struct property *prop; 996 const __be32 *val; 997 int nr, ret = 0; 998 999 mutex_lock(&opp_table->lock); 1000 if (opp_table->parsed_static_opps) { 1001 opp_table->parsed_static_opps++; 1002 mutex_unlock(&opp_table->lock); 1003 return 0; 1004 } 1005 1006 opp_table->parsed_static_opps = 1; 1007 mutex_unlock(&opp_table->lock); 1008 1009 prop = of_find_property(dev->of_node, "operating-points", NULL); 1010 if (!prop) { 1011 ret = -ENODEV; 1012 goto remove_static_opp; 1013 } 1014 if (!prop->value) { 1015 ret = -ENODATA; 1016 goto remove_static_opp; 1017 } 1018 1019 /* 1020 * Each OPP is a set of tuples consisting of frequency and 1021 * voltage like <freq-kHz vol-uV>. 1022 */ 1023 nr = prop->length / sizeof(u32); 1024 if (nr % 2) { 1025 dev_err(dev, "%s: Invalid OPP table\n", __func__); 1026 ret = -EINVAL; 1027 goto remove_static_opp; 1028 } 1029 1030 val = prop->value; 1031 while (nr) { 1032 unsigned long freq = be32_to_cpup(val++) * 1000; 1033 unsigned long volt = be32_to_cpup(val++); 1034 1035 ret = _opp_add_v1(opp_table, dev, freq, volt, false); 1036 if (ret) { 1037 dev_err(dev, "%s: Failed to add OPP %ld (%d)\n", 1038 __func__, freq, ret); 1039 goto remove_static_opp; 1040 } 1041 nr -= 2; 1042 } 1043 1044 return 0; 1045 1046 remove_static_opp: 1047 _opp_remove_all_static(opp_table); 1048 1049 return ret; 1050 } 1051 1052 static int _of_add_table_indexed(struct device *dev, int index, bool getclk) 1053 { 1054 struct opp_table *opp_table; 1055 int ret, count; 1056 1057 if (index) { 1058 /* 1059 * If only one phandle is present, then the same OPP table 1060 * applies for all index requests. 1061 */ 1062 count = of_count_phandle_with_args(dev->of_node, 1063 "operating-points-v2", NULL); 1064 if (count == 1) 1065 index = 0; 1066 } 1067 1068 opp_table = _add_opp_table_indexed(dev, index, getclk); 1069 if (IS_ERR(opp_table)) 1070 return PTR_ERR(opp_table); 1071 1072 /* 1073 * OPPs have two version of bindings now. Also try the old (v1) 1074 * bindings for backward compatibility with older dtbs. 1075 */ 1076 if (opp_table->np) 1077 ret = _of_add_opp_table_v2(dev, opp_table); 1078 else 1079 ret = _of_add_opp_table_v1(dev, opp_table); 1080 1081 if (ret) 1082 dev_pm_opp_put_opp_table(opp_table); 1083 1084 return ret; 1085 } 1086 1087 static void devm_pm_opp_of_table_release(void *data) 1088 { 1089 dev_pm_opp_of_remove_table(data); 1090 } 1091 1092 /** 1093 * devm_pm_opp_of_add_table() - Initialize opp table from device tree 1094 * @dev: device pointer used to lookup OPP table. 1095 * 1096 * Register the initial OPP table with the OPP library for given device. 1097 * 1098 * The opp_table structure will be freed after the device is destroyed. 1099 * 1100 * Return: 1101 * 0 On success OR 1102 * Duplicate OPPs (both freq and volt are same) and opp->available 1103 * -EEXIST Freq are same and volt are different OR 1104 * Duplicate OPPs (both freq and volt are same) and !opp->available 1105 * -ENOMEM Memory allocation failure 1106 * -ENODEV when 'operating-points' property is not found or is invalid data 1107 * in device node. 1108 * -ENODATA when empty 'operating-points' property is found 1109 * -EINVAL when invalid entries are found in opp-v2 table 1110 */ 1111 int devm_pm_opp_of_add_table(struct device *dev) 1112 { 1113 int ret; 1114 1115 ret = dev_pm_opp_of_add_table(dev); 1116 if (ret) 1117 return ret; 1118 1119 return devm_add_action_or_reset(dev, devm_pm_opp_of_table_release, dev); 1120 } 1121 EXPORT_SYMBOL_GPL(devm_pm_opp_of_add_table); 1122 1123 /** 1124 * dev_pm_opp_of_add_table() - Initialize opp table from device tree 1125 * @dev: device pointer used to lookup OPP table. 1126 * 1127 * Register the initial OPP table with the OPP library for given device. 1128 * 1129 * Return: 1130 * 0 On success OR 1131 * Duplicate OPPs (both freq and volt are same) and opp->available 1132 * -EEXIST Freq are same and volt are different OR 1133 * Duplicate OPPs (both freq and volt are same) and !opp->available 1134 * -ENOMEM Memory allocation failure 1135 * -ENODEV when 'operating-points' property is not found or is invalid data 1136 * in device node. 1137 * -ENODATA when empty 'operating-points' property is found 1138 * -EINVAL when invalid entries are found in opp-v2 table 1139 */ 1140 int dev_pm_opp_of_add_table(struct device *dev) 1141 { 1142 return _of_add_table_indexed(dev, 0, true); 1143 } 1144 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table); 1145 1146 /** 1147 * dev_pm_opp_of_add_table_indexed() - Initialize indexed opp table from device tree 1148 * @dev: device pointer used to lookup OPP table. 1149 * @index: Index number. 1150 * 1151 * Register the initial OPP table with the OPP library for given device only 1152 * using the "operating-points-v2" property. 1153 * 1154 * Return: Refer to dev_pm_opp_of_add_table() for return values. 1155 */ 1156 int dev_pm_opp_of_add_table_indexed(struct device *dev, int index) 1157 { 1158 return _of_add_table_indexed(dev, index, true); 1159 } 1160 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_indexed); 1161 1162 /** 1163 * dev_pm_opp_of_add_table_noclk() - Initialize indexed opp table from device 1164 * tree without getting clk for device. 1165 * @dev: device pointer used to lookup OPP table. 1166 * @index: Index number. 1167 * 1168 * Register the initial OPP table with the OPP library for given device only 1169 * using the "operating-points-v2" property. Do not try to get the clk for the 1170 * device. 1171 * 1172 * Return: Refer to dev_pm_opp_of_add_table() for return values. 1173 */ 1174 int dev_pm_opp_of_add_table_noclk(struct device *dev, int index) 1175 { 1176 return _of_add_table_indexed(dev, index, false); 1177 } 1178 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_noclk); 1179 1180 /* CPU device specific helpers */ 1181 1182 /** 1183 * dev_pm_opp_of_cpumask_remove_table() - Removes OPP table for @cpumask 1184 * @cpumask: cpumask for which OPP table needs to be removed 1185 * 1186 * This removes the OPP tables for CPUs present in the @cpumask. 1187 * This should be used only to remove static entries created from DT. 1188 */ 1189 void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask) 1190 { 1191 _dev_pm_opp_cpumask_remove_table(cpumask, -1); 1192 } 1193 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table); 1194 1195 /** 1196 * dev_pm_opp_of_cpumask_add_table() - Adds OPP table for @cpumask 1197 * @cpumask: cpumask for which OPP table needs to be added. 1198 * 1199 * This adds the OPP tables for CPUs present in the @cpumask. 1200 */ 1201 int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask) 1202 { 1203 struct device *cpu_dev; 1204 int cpu, ret; 1205 1206 if (WARN_ON(cpumask_empty(cpumask))) 1207 return -ENODEV; 1208 1209 for_each_cpu(cpu, cpumask) { 1210 cpu_dev = get_cpu_device(cpu); 1211 if (!cpu_dev) { 1212 pr_err("%s: failed to get cpu%d device\n", __func__, 1213 cpu); 1214 ret = -ENODEV; 1215 goto remove_table; 1216 } 1217 1218 ret = dev_pm_opp_of_add_table(cpu_dev); 1219 if (ret) { 1220 /* 1221 * OPP may get registered dynamically, don't print error 1222 * message here. 1223 */ 1224 pr_debug("%s: couldn't find opp table for cpu:%d, %d\n", 1225 __func__, cpu, ret); 1226 1227 goto remove_table; 1228 } 1229 } 1230 1231 return 0; 1232 1233 remove_table: 1234 /* Free all other OPPs */ 1235 _dev_pm_opp_cpumask_remove_table(cpumask, cpu); 1236 1237 return ret; 1238 } 1239 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table); 1240 1241 /* 1242 * Works only for OPP v2 bindings. 1243 * 1244 * Returns -ENOENT if operating-points-v2 bindings aren't supported. 1245 */ 1246 /** 1247 * dev_pm_opp_of_get_sharing_cpus() - Get cpumask of CPUs sharing OPPs with 1248 * @cpu_dev using operating-points-v2 1249 * bindings. 1250 * 1251 * @cpu_dev: CPU device for which we do this operation 1252 * @cpumask: cpumask to update with information of sharing CPUs 1253 * 1254 * This updates the @cpumask with CPUs that are sharing OPPs with @cpu_dev. 1255 * 1256 * Returns -ENOENT if operating-points-v2 isn't present for @cpu_dev. 1257 */ 1258 int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, 1259 struct cpumask *cpumask) 1260 { 1261 struct device_node *np, *tmp_np, *cpu_np; 1262 int cpu, ret = 0; 1263 1264 /* Get OPP descriptor node */ 1265 np = dev_pm_opp_of_get_opp_desc_node(cpu_dev); 1266 if (!np) { 1267 dev_dbg(cpu_dev, "%s: Couldn't find opp node.\n", __func__); 1268 return -ENOENT; 1269 } 1270 1271 cpumask_set_cpu(cpu_dev->id, cpumask); 1272 1273 /* OPPs are shared ? */ 1274 if (!of_property_read_bool(np, "opp-shared")) 1275 goto put_cpu_node; 1276 1277 for_each_possible_cpu(cpu) { 1278 if (cpu == cpu_dev->id) 1279 continue; 1280 1281 cpu_np = of_cpu_device_node_get(cpu); 1282 if (!cpu_np) { 1283 dev_err(cpu_dev, "%s: failed to get cpu%d node\n", 1284 __func__, cpu); 1285 ret = -ENOENT; 1286 goto put_cpu_node; 1287 } 1288 1289 /* Get OPP descriptor node */ 1290 tmp_np = _opp_of_get_opp_desc_node(cpu_np, 0); 1291 of_node_put(cpu_np); 1292 if (!tmp_np) { 1293 pr_err("%pOF: Couldn't find opp node\n", cpu_np); 1294 ret = -ENOENT; 1295 goto put_cpu_node; 1296 } 1297 1298 /* CPUs are sharing opp node */ 1299 if (np == tmp_np) 1300 cpumask_set_cpu(cpu, cpumask); 1301 1302 of_node_put(tmp_np); 1303 } 1304 1305 put_cpu_node: 1306 of_node_put(np); 1307 return ret; 1308 } 1309 EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus); 1310 1311 /** 1312 * of_get_required_opp_performance_state() - Search for required OPP and return its performance state. 1313 * @np: Node that contains the "required-opps" property. 1314 * @index: Index of the phandle to parse. 1315 * 1316 * Returns the performance state of the OPP pointed out by the "required-opps" 1317 * property at @index in @np. 1318 * 1319 * Return: Zero or positive performance state on success, otherwise negative 1320 * value on errors. 1321 */ 1322 int of_get_required_opp_performance_state(struct device_node *np, int index) 1323 { 1324 struct dev_pm_opp *opp; 1325 struct device_node *required_np; 1326 struct opp_table *opp_table; 1327 int pstate = -EINVAL; 1328 1329 required_np = of_parse_required_opp(np, index); 1330 if (!required_np) 1331 return -EINVAL; 1332 1333 opp_table = _find_table_of_opp_np(required_np); 1334 if (IS_ERR(opp_table)) { 1335 pr_err("%s: Failed to find required OPP table %pOF: %ld\n", 1336 __func__, np, PTR_ERR(opp_table)); 1337 goto put_required_np; 1338 } 1339 1340 opp = _find_opp_of_np(opp_table, required_np); 1341 if (opp) { 1342 pstate = opp->pstate; 1343 dev_pm_opp_put(opp); 1344 } 1345 1346 dev_pm_opp_put_opp_table(opp_table); 1347 1348 put_required_np: 1349 of_node_put(required_np); 1350 1351 return pstate; 1352 } 1353 EXPORT_SYMBOL_GPL(of_get_required_opp_performance_state); 1354 1355 /** 1356 * dev_pm_opp_get_of_node() - Gets the DT node corresponding to an opp 1357 * @opp: opp for which DT node has to be returned for 1358 * 1359 * Return: DT node corresponding to the opp, else 0 on success. 1360 * 1361 * The caller needs to put the node with of_node_put() after using it. 1362 */ 1363 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) 1364 { 1365 if (IS_ERR_OR_NULL(opp)) { 1366 pr_err("%s: Invalid parameters\n", __func__); 1367 return NULL; 1368 } 1369 1370 return of_node_get(opp->np); 1371 } 1372 EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node); 1373 1374 /* 1375 * Callback function provided to the Energy Model framework upon registration. 1376 * This computes the power estimated by @dev at @kHz if it is the frequency 1377 * of an existing OPP, or at the frequency of the first OPP above @kHz otherwise 1378 * (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled 1379 * frequency and @mW to the associated power. The power is estimated as 1380 * P = C * V^2 * f with C being the device's capacitance and V and f 1381 * respectively the voltage and frequency of the OPP. 1382 * 1383 * Returns -EINVAL if the power calculation failed because of missing 1384 * parameters, 0 otherwise. 1385 */ 1386 static int __maybe_unused _get_power(unsigned long *mW, unsigned long *kHz, 1387 struct device *dev) 1388 { 1389 struct dev_pm_opp *opp; 1390 struct device_node *np; 1391 unsigned long mV, Hz; 1392 u32 cap; 1393 u64 tmp; 1394 int ret; 1395 1396 np = of_node_get(dev->of_node); 1397 if (!np) 1398 return -EINVAL; 1399 1400 ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap); 1401 of_node_put(np); 1402 if (ret) 1403 return -EINVAL; 1404 1405 Hz = *kHz * 1000; 1406 opp = dev_pm_opp_find_freq_ceil(dev, &Hz); 1407 if (IS_ERR(opp)) 1408 return -EINVAL; 1409 1410 mV = dev_pm_opp_get_voltage(opp) / 1000; 1411 dev_pm_opp_put(opp); 1412 if (!mV) 1413 return -EINVAL; 1414 1415 tmp = (u64)cap * mV * mV * (Hz / 1000000); 1416 do_div(tmp, 1000000000); 1417 1418 *mW = (unsigned long)tmp; 1419 *kHz = Hz / 1000; 1420 1421 return 0; 1422 } 1423 1424 /** 1425 * dev_pm_opp_of_register_em() - Attempt to register an Energy Model 1426 * @dev : Device for which an Energy Model has to be registered 1427 * @cpus : CPUs for which an Energy Model has to be registered. For 1428 * other type of devices it should be set to NULL. 1429 * 1430 * This checks whether the "dynamic-power-coefficient" devicetree property has 1431 * been specified, and tries to register an Energy Model with it if it has. 1432 * Having this property means the voltages are known for OPPs and the EM 1433 * might be calculated. 1434 */ 1435 int dev_pm_opp_of_register_em(struct device *dev, struct cpumask *cpus) 1436 { 1437 struct em_data_callback em_cb = EM_DATA_CB(_get_power); 1438 struct device_node *np; 1439 int ret, nr_opp; 1440 u32 cap; 1441 1442 if (IS_ERR_OR_NULL(dev)) { 1443 ret = -EINVAL; 1444 goto failed; 1445 } 1446 1447 nr_opp = dev_pm_opp_get_opp_count(dev); 1448 if (nr_opp <= 0) { 1449 ret = -EINVAL; 1450 goto failed; 1451 } 1452 1453 np = of_node_get(dev->of_node); 1454 if (!np) { 1455 ret = -EINVAL; 1456 goto failed; 1457 } 1458 1459 /* 1460 * Register an EM only if the 'dynamic-power-coefficient' property is 1461 * set in devicetree. It is assumed the voltage values are known if that 1462 * property is set since it is useless otherwise. If voltages are not 1463 * known, just let the EM registration fail with an error to alert the 1464 * user about the inconsistent configuration. 1465 */ 1466 ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap); 1467 of_node_put(np); 1468 if (ret || !cap) { 1469 dev_dbg(dev, "Couldn't find proper 'dynamic-power-coefficient' in DT\n"); 1470 ret = -EINVAL; 1471 goto failed; 1472 } 1473 1474 ret = em_dev_register_perf_domain(dev, nr_opp, &em_cb, cpus, true); 1475 if (ret) 1476 goto failed; 1477 1478 return 0; 1479 1480 failed: 1481 dev_dbg(dev, "Couldn't register Energy Model %d\n", ret); 1482 return ret; 1483 } 1484 EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em); 1485