662 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright 2020 Linaro Limited4 *5 * Author: Daniel Lezcano <daniel.lezcano@linaro.org>6 *7 * The powercap based Dynamic Thermal Power Management framework8 * provides to the userspace a consistent API to set the power limit9 * on some devices.10 *11 * DTPM defines the functions to create a tree of constraints. Each12 * parent node is a virtual description of the aggregation of the13 * children. It propagates the constraints set at its level to its14 * children and collect the children power information. The leaves of15 * the tree are the real devices which have the ability to get their16 * current power consumption and set their power limit.17 */18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt19 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 031 32static const char *constraint_name[] = {33 "Instantaneous",34};35 36static DEFINE_MUTEX(dtpm_lock);37static struct powercap_control_type *pct;38static struct dtpm *root;39 40static int get_time_window_us(struct powercap_zone *pcz, int cid, u64 *window)41{42 return -ENOSYS;43}44 45static int set_time_window_us(struct powercap_zone *pcz, int cid, u64 window)46{47 return -ENOSYS;48}49 50static 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 59static 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 82static int get_power_uw(struct powercap_zone *pcz, u64 *power_uw)83{84 return __get_power_uw(to_dtpm(pcz), power_uw);85}86 87static 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 103static 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 115static 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 dtpm129 * @dtpm: a pointer to a dtpm structure to update130 *131 * Function to update the power values of the dtpm node specified in132 * parameter. These new values will be propagated to the tree.133 *134 * Return: zero on success, -EINVAL if the values are inconsistent135 */136int 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 released160 * @pcz: a pointer to a powercap_zone structure161 *162 * Do some housecleaning and update the weight on the tree. The163 * release will be denied if the node has children. This function must164 * be called by the specific release callback of the different165 * backends.166 *167 * Return: 0 on success, -EBUSY if there are children168 */169int 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 else185 kfree(dtpm);186 187 return 0;188}189 190static 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 distributed200 * given the weight of the children.201 *202 * The dtpm node lock must be held when calling this function.203 */204static 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 power225 */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 inevitably235 * lead to a different min or max value when236 * set several times. In order to restore the237 * initial value, we force the child's min or238 * max power every time if the constraint is239 * 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 267static 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 previously275 * 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 287static const char *get_constraint_name(struct powercap_zone *pcz, int cid)288{289 return constraint_name[cid];290}291 292static 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 299static 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 308static 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 struct316 * @dtpm: The dtpm struct pointer to be initialized317 * @ops: The dtpm device specific ops, NULL for a virtual node318 */319void 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 tree331 * @dtpm: a pointer to a dtpm structure corresponding to the node to be removed332 *333 * Call the underlying powercap unregister function. That will call334 * the release callback of the powercap zone.335 */336void 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 tree345 * @name: a string specifying the name of the node346 * @dtpm: a pointer to a dtpm structure corresponding to the new node347 * @parent: a pointer to a dtpm structure corresponding to the parent node348 *349 * Create a dtpm node in the tree. If no parent is specified, the node350 * is the root node of the hierarchy. If the root node already exists,351 * then the registration will fail. The powercap controller must be352 * initialized before calling this function.353 *354 * The dtpm structure must be initialized with the power numbers355 * 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 inserted360 * -EINVAL: * there is no root node yet and @parent is specified361 * * no all ops are defined362 * * parent have ops which are reserved for leaves363 * Other negative values are reported back from the powercap framework364 */365int 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 415static 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 437static 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 there466 * is no child for us as we are a leaf of the tree467 */468 return NULL;469}470 471typedef struct dtpm * (*dtpm_node_callback_t)(const struct dtpm_node *, struct dtpm *);472 473static dtpm_node_callback_t dtpm_node_callback[] = {474 [DTPM_NODE_VIRTUAL] = dtpm_setup_virtual,475 [DTPM_NODE_DT] = dtpm_setup_dt,476};477 478static 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 we493 * continue without going deeper in the recursivity.494 */495 if (!dtpm)496 continue;497 498 /*499 * There are multiple reasons why the callback could500 * fail. The generic glue is abstracting the backend501 * and therefore it is not possible to report back or502 * take a decision based on the error. In any case,503 * if this call fails, it is not critical in the504 * hierarchy creation, we can assume the underlying505 * service is not found, so we continue without this506 * branch in the tree but with a warning to log the507 * 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 hierarchy525 * @dtpm_match_table: Pointer to the array of device ID structures526 *527 * The function is called by the platform specific code with the528 * description of the different node in the hierarchy. It creates the529 * 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 the544 * array.545 *546 * Return: zero on success, a negative value in case of error. Errors547 * are reported back from the underlying functions.548 */549int 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 607out_err:608 powercap_unregister_control_type(pct);609out_pct:610 pct = NULL;611out_unlock:612 mutex_unlock(&dtpm_lock);613 614 return ret;615}616EXPORT_SYMBOL_GPL(dtpm_create_hierarchy);617 618static 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 the627 * recursive call before628 */629 dtpm_unregister(dtpm);630}631 632void 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 658out_unlock:659 mutex_unlock(&dtpm_lock);660}661EXPORT_SYMBOL_GPL(dtpm_destroy_hierarchy);662