1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright 2020 Linaro Limited 4 * 5 * Author: Daniel Lezcano <daniel.lezcano@linaro.org> 6 * 7 * The powercap based Dynamic Thermal Power Management framework 8 * provides to the userspace a consistent API to set the power limit 9 * on some devices. 10 * 11 * DTPM defines the functions to create a tree of constraints. Each 12 * parent node is a virtual description of the aggregation of the 13 * children. It propagates the constraints set at its level to its 14 * children and collect the children power information. The leaves of 15 * the tree are the real devices which have the ability to get their 16 * current power consumption and set their power limit. 17 */ 18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 19 20 #include <linux/dtpm.h> 21 #include <linux/init.h> 22 #include <linux/kernel.h> 23 #include <linux/powercap.h> 24 #include <linux/slab.h> 25 #include <linux/mutex.h> 26 #include <linux/of.h> 27 28 #include "dtpm_subsys.h" 29 30 #define DTPM_POWER_LIMIT_FLAG 0 31 32 static const char *constraint_name[] = { 33 "Instantaneous", 34 }; 35 36 static DEFINE_MUTEX(dtpm_lock); 37 static struct powercap_control_type *pct; 38 static struct dtpm *root; 39 40 static int get_time_window_us(struct powercap_zone *pcz, int cid, u64 *window) 41 { 42 return -ENOSYS; 43 } 44 45 static int set_time_window_us(struct powercap_zone *pcz, int cid, u64 window) 46 { 47 return -ENOSYS; 48 } 49 50 static int get_max_power_range_uw(struct powercap_zone *pcz, u64 *max_power_uw) 51 { 52 struct dtpm *dtpm = to_dtpm(pcz); 53 54 *max_power_uw = dtpm->power_max - dtpm->power_min; 55 56 return 0; 57 } 58 59 static int __get_power_uw(struct dtpm *dtpm, u64 *power_uw) 60 { 61 struct dtpm *child; 62 u64 power; 63 int ret = 0; 64 65 if (dtpm->ops) { 66 *power_uw = dtpm->ops->get_power_uw(dtpm); 67 return 0; 68 } 69 70 *power_uw = 0; 71 72 list_for_each_entry(child, &dtpm->children, sibling) { 73 ret = __get_power_uw(child, &power); 74 if (ret) 75 break; 76 *power_uw += power; 77 } 78 79 return ret; 80 } 81 82 static int get_power_uw(struct powercap_zone *pcz, u64 *power_uw) 83 { 84 return __get_power_uw(to_dtpm(pcz), power_uw); 85 } 86 87 static void __dtpm_rebalance_weight(struct dtpm *dtpm) 88 { 89 struct dtpm *child; 90 91 list_for_each_entry(child, &dtpm->children, sibling) { 92 93 pr_debug("Setting weight '%d' for '%s'\n", 94 child->weight, child->zone.name); 95 96 child->weight = DIV64_U64_ROUND_CLOSEST( 97 child->power_max * 1024, dtpm->power_max); 98 99 __dtpm_rebalance_weight(child); 100 } 101 } 102 103 static void __dtpm_sub_power(struct dtpm *dtpm) 104 { 105 struct dtpm *parent = dtpm->parent; 106 107 while (parent) { 108 parent->power_min -= dtpm->power_min; 109 parent->power_max -= dtpm->power_max; 110 parent->power_limit -= dtpm->power_limit; 111 parent = parent->parent; 112 } 113 } 114 115 static void __dtpm_add_power(struct dtpm *dtpm) 116 { 117 struct dtpm *parent = dtpm->parent; 118 119 while (parent) { 120 parent->power_min += dtpm->power_min; 121 parent->power_max += dtpm->power_max; 122 parent->power_limit += dtpm->power_limit; 123 parent = parent->parent; 124 } 125 } 126 127 /** 128 * dtpm_update_power - Update the power on the dtpm 129 * @dtpm: a pointer to a dtpm structure to update 130 * 131 * Function to update the power values of the dtpm node specified in 132 * parameter. These new values will be propagated to the tree. 133 * 134 * Return: zero on success, -EINVAL if the values are inconsistent 135 */ 136 int dtpm_update_power(struct dtpm *dtpm) 137 { 138 int ret; 139 140 __dtpm_sub_power(dtpm); 141 142 ret = dtpm->ops->update_power_uw(dtpm); 143 if (ret) 144 pr_err("Failed to update power for '%s': %d\n", 145 dtpm->zone.name, ret); 146 147 if (!test_bit(DTPM_POWER_LIMIT_FLAG, &dtpm->flags)) 148 dtpm->power_limit = dtpm->power_max; 149 150 __dtpm_add_power(dtpm); 151 152 if (root) 153 __dtpm_rebalance_weight(root); 154 155 return ret; 156 } 157 158 /** 159 * dtpm_release_zone - Cleanup when the node is released 160 * @pcz: a pointer to a powercap_zone structure 161 * 162 * Do some housecleaning and update the weight on the tree. The 163 * release will be denied if the node has children. This function must 164 * be called by the specific release callback of the different 165 * backends. 166 * 167 * Return: 0 on success, -EBUSY if there are children 168 */ 169 int dtpm_release_zone(struct powercap_zone *pcz) 170 { 171 struct dtpm *dtpm = to_dtpm(pcz); 172 struct dtpm *parent = dtpm->parent; 173 174 if (!list_empty(&dtpm->children)) 175 return -EBUSY; 176 177 if (parent) 178 list_del(&dtpm->sibling); 179 180 __dtpm_sub_power(dtpm); 181 182 if (dtpm->ops) 183 dtpm->ops->release(dtpm); 184 else 185 kfree(dtpm); 186 187 return 0; 188 } 189 190 static int get_power_limit_uw(struct powercap_zone *pcz, 191 int cid, u64 *power_limit) 192 { 193 *power_limit = to_dtpm(pcz)->power_limit; 194 195 return 0; 196 } 197 198 /* 199 * Set the power limit on the nodes, the power limit is distributed 200 * given the weight of the children. 201 * 202 * The dtpm node lock must be held when calling this function. 203 */ 204 static int __set_power_limit_uw(struct dtpm *dtpm, int cid, u64 power_limit) 205 { 206 struct dtpm *child; 207 int ret = 0; 208 u64 power; 209 210 /* 211 * A max power limitation means we remove the power limit, 212 * otherwise we set a constraint and flag the dtpm node. 213 */ 214 if (power_limit == dtpm->power_max) { 215 clear_bit(DTPM_POWER_LIMIT_FLAG, &dtpm->flags); 216 } else { 217 set_bit(DTPM_POWER_LIMIT_FLAG, &dtpm->flags); 218 } 219 220 pr_debug("Setting power limit for '%s': %llu uW\n", 221 dtpm->zone.name, power_limit); 222 223 /* 224 * Only leaves of the dtpm tree has ops to get/set the power 225 */ 226 if (dtpm->ops) { 227 dtpm->power_limit = dtpm->ops->set_power_uw(dtpm, power_limit); 228 } else { 229 dtpm->power_limit = 0; 230 231 list_for_each_entry(child, &dtpm->children, sibling) { 232 233 /* 234 * Integer division rounding will inevitably 235 * lead to a different min or max value when 236 * set several times. In order to restore the 237 * initial value, we force the child's min or 238 * max power every time if the constraint is 239 * at the boundaries. 240 */ 241 if (power_limit == dtpm->power_max) { 242 power = child->power_max; 243 } else if (power_limit == dtpm->power_min) { 244 power = child->power_min; 245 } else { 246 power = DIV_ROUND_CLOSEST_ULL( 247 power_limit * child->weight, 1024); 248 } 249 250 pr_debug("Setting power limit for '%s': %llu uW\n", 251 child->zone.name, power); 252 253 ret = __set_power_limit_uw(child, cid, power); 254 if (!ret) 255 ret = get_power_limit_uw(&child->zone, cid, &power); 256 257 if (ret) 258 break; 259 260 dtpm->power_limit += power; 261 } 262 } 263 264 return ret; 265 } 266 267 static int set_power_limit_uw(struct powercap_zone *pcz, 268 int cid, u64 power_limit) 269 { 270 struct dtpm *dtpm = to_dtpm(pcz); 271 int ret; 272 273 /* 274 * Don't allow values outside of the power range previously 275 * set when initializing the power numbers. 276 */ 277 power_limit = clamp_val(power_limit, dtpm->power_min, dtpm->power_max); 278 279 ret = __set_power_limit_uw(dtpm, cid, power_limit); 280 281 pr_debug("%s: power limit: %llu uW, power max: %llu uW\n", 282 dtpm->zone.name, dtpm->power_limit, dtpm->power_max); 283 284 return ret; 285 } 286 287 static const char *get_constraint_name(struct powercap_zone *pcz, int cid) 288 { 289 return constraint_name[cid]; 290 } 291 292 static int get_max_power_uw(struct powercap_zone *pcz, int id, u64 *max_power) 293 { 294 *max_power = to_dtpm(pcz)->power_max; 295 296 return 0; 297 } 298 299 static struct powercap_zone_constraint_ops constraint_ops = { 300 .set_power_limit_uw = set_power_limit_uw, 301 .get_power_limit_uw = get_power_limit_uw, 302 .set_time_window_us = set_time_window_us, 303 .get_time_window_us = get_time_window_us, 304 .get_max_power_uw = get_max_power_uw, 305 .get_name = get_constraint_name, 306 }; 307 308 static struct powercap_zone_ops zone_ops = { 309 .get_max_power_range_uw = get_max_power_range_uw, 310 .get_power_uw = get_power_uw, 311 .release = dtpm_release_zone, 312 }; 313 314 /** 315 * dtpm_init - Allocate and initialize a dtpm struct 316 * @dtpm: The dtpm struct pointer to be initialized 317 * @ops: The dtpm device specific ops, NULL for a virtual node 318 */ 319 void dtpm_init(struct dtpm *dtpm, struct dtpm_ops *ops) 320 { 321 if (dtpm) { 322 INIT_LIST_HEAD(&dtpm->children); 323 INIT_LIST_HEAD(&dtpm->sibling); 324 dtpm->weight = 1024; 325 dtpm->ops = ops; 326 } 327 } 328 329 /** 330 * dtpm_unregister - Unregister a dtpm node from the hierarchy tree 331 * @dtpm: a pointer to a dtpm structure corresponding to the node to be removed 332 * 333 * Call the underlying powercap unregister function. That will call 334 * the release callback of the powercap zone. 335 */ 336 void dtpm_unregister(struct dtpm *dtpm) 337 { 338 powercap_unregister_zone(pct, &dtpm->zone); 339 340 pr_debug("Unregistered dtpm node '%s'\n", dtpm->zone.name); 341 } 342 343 /** 344 * dtpm_register - Register a dtpm node in the hierarchy tree 345 * @name: a string specifying the name of the node 346 * @dtpm: a pointer to a dtpm structure corresponding to the new node 347 * @parent: a pointer to a dtpm structure corresponding to the parent node 348 * 349 * Create a dtpm node in the tree. If no parent is specified, the node 350 * is the root node of the hierarchy. If the root node already exists, 351 * then the registration will fail. The powercap controller must be 352 * initialized before calling this function. 353 * 354 * The dtpm structure must be initialized with the power numbers 355 * before calling this function. 356 * 357 * Return: zero on success, a negative value in case of error: 358 * -EAGAIN: the function is called before the framework is initialized. 359 * -EBUSY: the root node is already inserted 360 * -EINVAL: * there is no root node yet and @parent is specified 361 * * no all ops are defined 362 * * parent have ops which are reserved for leaves 363 * Other negative values are reported back from the powercap framework 364 */ 365 int dtpm_register(const char *name, struct dtpm *dtpm, struct dtpm *parent) 366 { 367 struct powercap_zone *pcz; 368 369 if (!pct) 370 return -EAGAIN; 371 372 if (root && !parent) 373 return -EBUSY; 374 375 if (!root && parent) 376 return -EINVAL; 377 378 if (parent && parent->ops) 379 return -EINVAL; 380 381 if (!dtpm) 382 return -EINVAL; 383 384 if (dtpm->ops && !(dtpm->ops->set_power_uw && 385 dtpm->ops->get_power_uw && 386 dtpm->ops->update_power_uw && 387 dtpm->ops->release)) 388 return -EINVAL; 389 390 pcz = powercap_register_zone(&dtpm->zone, pct, name, 391 parent ? &parent->zone : NULL, 392 &zone_ops, MAX_DTPM_CONSTRAINTS, 393 &constraint_ops); 394 if (IS_ERR(pcz)) 395 return PTR_ERR(pcz); 396 397 if (parent) { 398 list_add_tail(&dtpm->sibling, &parent->children); 399 dtpm->parent = parent; 400 } else { 401 root = dtpm; 402 } 403 404 if (dtpm->ops && !dtpm->ops->update_power_uw(dtpm)) { 405 __dtpm_add_power(dtpm); 406 dtpm->power_limit = dtpm->power_max; 407 } 408 409 pr_debug("Registered dtpm node '%s' / %llu-%llu uW, \n", 410 dtpm->zone.name, dtpm->power_min, dtpm->power_max); 411 412 return 0; 413 } 414 415 static struct dtpm *dtpm_setup_virtual(const struct dtpm_node *hierarchy, 416 struct dtpm *parent) 417 { 418 struct dtpm *dtpm; 419 int ret; 420 421 dtpm = kzalloc(sizeof(*dtpm), GFP_KERNEL); 422 if (!dtpm) 423 return ERR_PTR(-ENOMEM); 424 dtpm_init(dtpm, NULL); 425 426 ret = dtpm_register(hierarchy->name, dtpm, parent); 427 if (ret) { 428 pr_err("Failed to register dtpm node '%s': %d\n", 429 hierarchy->name, ret); 430 kfree(dtpm); 431 return ERR_PTR(ret); 432 } 433 434 return dtpm; 435 } 436 437 static struct dtpm *dtpm_setup_dt(const struct dtpm_node *hierarchy, 438 struct dtpm *parent) 439 { 440 struct device_node *np; 441 int i, ret; 442 443 np = of_find_node_by_path(hierarchy->name); 444 if (!np) { 445 pr_err("Failed to find '%s'\n", hierarchy->name); 446 return ERR_PTR(-ENXIO); 447 } 448 449 for (i = 0; i < ARRAY_SIZE(dtpm_subsys); i++) { 450 451 if (!dtpm_subsys[i]->setup) 452 continue; 453 454 ret = dtpm_subsys[i]->setup(parent, np); 455 if (ret) { 456 pr_err("Failed to setup '%s': %d\n", dtpm_subsys[i]->name, ret); 457 of_node_put(np); 458 return ERR_PTR(ret); 459 } 460 } 461 462 of_node_put(np); 463 464 /* 465 * By returning a NULL pointer, we let know the caller there 466 * is no child for us as we are a leaf of the tree 467 */ 468 return NULL; 469 } 470 471 typedef struct dtpm * (*dtpm_node_callback_t)(const struct dtpm_node *, struct dtpm *); 472 473 static dtpm_node_callback_t dtpm_node_callback[] = { 474 [DTPM_NODE_VIRTUAL] = dtpm_setup_virtual, 475 [DTPM_NODE_DT] = dtpm_setup_dt, 476 }; 477 478 static int dtpm_for_each_child(const struct dtpm_node *hierarchy, 479 const struct dtpm_node *it, struct dtpm *parent) 480 { 481 struct dtpm *dtpm; 482 int i, ret; 483 484 for (i = 0; hierarchy[i].name; i++) { 485 486 if (hierarchy[i].parent != it) 487 continue; 488 489 dtpm = dtpm_node_callback[hierarchy[i].type](&hierarchy[i], parent); 490 491 /* 492 * A NULL pointer means there is no children, hence we 493 * continue without going deeper in the recursivity. 494 */ 495 if (!dtpm) 496 continue; 497 498 /* 499 * There are multiple reasons why the callback could 500 * fail. The generic glue is abstracting the backend 501 * and therefore it is not possible to report back or 502 * take a decision based on the error. In any case, 503 * if this call fails, it is not critical in the 504 * hierarchy creation, we can assume the underlying 505 * service is not found, so we continue without this 506 * branch in the tree but with a warning to log the 507 * information the node was not created. 508 */ 509 if (IS_ERR(dtpm)) { 510 pr_warn("Failed to create '%s' in the hierarchy\n", 511 hierarchy[i].name); 512 continue; 513 } 514 515 ret = dtpm_for_each_child(hierarchy, &hierarchy[i], dtpm); 516 if (ret) 517 return ret; 518 } 519 520 return 0; 521 } 522 523 /** 524 * dtpm_create_hierarchy - Create the dtpm hierarchy 525 * @dtpm_match_table: Pointer to the array of device ID structures 526 * 527 * The function is called by the platform specific code with the 528 * description of the different node in the hierarchy. It creates the 529 * tree in the sysfs filesystem under the powercap dtpm entry. 530 * 531 * The expected tree has the format: 532 * 533 * struct dtpm_node hierarchy[] = { 534 * [0] { .name = "topmost", type = DTPM_NODE_VIRTUAL }, 535 * [1] { .name = "package", .type = DTPM_NODE_VIRTUAL, .parent = &hierarchy[0] }, 536 * [2] { .name = "/cpus/cpu0", .type = DTPM_NODE_DT, .parent = &hierarchy[1] }, 537 * [3] { .name = "/cpus/cpu1", .type = DTPM_NODE_DT, .parent = &hierarchy[1] }, 538 * [4] { .name = "/cpus/cpu2", .type = DTPM_NODE_DT, .parent = &hierarchy[1] }, 539 * [5] { .name = "/cpus/cpu3", .type = DTPM_NODE_DT, .parent = &hierarchy[1] }, 540 * [6] { } 541 * }; 542 * 543 * The last element is always an empty one and marks the end of the 544 * array. 545 * 546 * Return: zero on success, a negative value in case of error. Errors 547 * are reported back from the underlying functions. 548 */ 549 int dtpm_create_hierarchy(struct of_device_id *dtpm_match_table) 550 { 551 const struct of_device_id *match; 552 const struct dtpm_node *hierarchy; 553 struct device_node *np; 554 int i, ret; 555 556 mutex_lock(&dtpm_lock); 557 558 if (pct) { 559 ret = -EBUSY; 560 goto out_unlock; 561 } 562 563 pct = powercap_register_control_type(NULL, "dtpm", NULL); 564 if (IS_ERR(pct)) { 565 pr_err("Failed to register control type\n"); 566 ret = PTR_ERR(pct); 567 goto out_pct; 568 } 569 570 ret = -ENODEV; 571 np = of_find_node_by_path("/"); 572 if (!np) 573 goto out_err; 574 575 match = of_match_node(dtpm_match_table, np); 576 577 of_node_put(np); 578 579 if (!match) 580 goto out_err; 581 582 hierarchy = match->data; 583 if (!hierarchy) { 584 ret = -EFAULT; 585 goto out_err; 586 } 587 588 ret = dtpm_for_each_child(hierarchy, NULL, NULL); 589 if (ret) 590 goto out_err; 591 592 for (i = 0; i < ARRAY_SIZE(dtpm_subsys); i++) { 593 594 if (!dtpm_subsys[i]->init) 595 continue; 596 597 ret = dtpm_subsys[i]->init(); 598 if (ret) 599 pr_info("Failed to initialize '%s': %d", 600 dtpm_subsys[i]->name, ret); 601 } 602 603 mutex_unlock(&dtpm_lock); 604 605 return 0; 606 607 out_err: 608 powercap_unregister_control_type(pct); 609 out_pct: 610 pct = NULL; 611 out_unlock: 612 mutex_unlock(&dtpm_lock); 613 614 return ret; 615 } 616 EXPORT_SYMBOL_GPL(dtpm_create_hierarchy); 617 618 static void __dtpm_destroy_hierarchy(struct dtpm *dtpm) 619 { 620 struct dtpm *child, *aux; 621 622 list_for_each_entry_safe(child, aux, &dtpm->children, sibling) 623 __dtpm_destroy_hierarchy(child); 624 625 /* 626 * At this point, we know all children were removed from the 627 * recursive call before 628 */ 629 dtpm_unregister(dtpm); 630 } 631 632 void dtpm_destroy_hierarchy(void) 633 { 634 int i; 635 636 mutex_lock(&dtpm_lock); 637 638 if (!pct) 639 goto out_unlock; 640 641 __dtpm_destroy_hierarchy(root); 642 643 644 for (i = 0; i < ARRAY_SIZE(dtpm_subsys); i++) { 645 646 if (!dtpm_subsys[i]->exit) 647 continue; 648 649 dtpm_subsys[i]->exit(); 650 } 651 652 powercap_unregister_control_type(pct); 653 654 pct = NULL; 655 656 root = NULL; 657 658 out_unlock: 659 mutex_unlock(&dtpm_lock); 660 } 661 EXPORT_SYMBOL_GPL(dtpm_destroy_hierarchy); 662