mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 03:10:12 +00:00
![Daniel Lezcano](/assets/img/avatar_default.png)
The root node is not set to NULL when the dtpm root node is removed. Consequently, it is not possible to create a new root as it is already set. Set the root node to NULL when the last node is removed. Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
483 lines
11 KiB
C
483 lines
11 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Copyright 2020 Linaro Limited
|
|
*
|
|
* Author: Daniel Lezcano <daniel.lezcano@linaro.org>
|
|
*
|
|
* The powercap based Dynamic Thermal Power Management framework
|
|
* provides to the userspace a consistent API to set the power limit
|
|
* on some devices.
|
|
*
|
|
* DTPM defines the functions to create a tree of constraints. Each
|
|
* parent node is a virtual description of the aggregation of the
|
|
* children. It propagates the constraints set at its level to its
|
|
* children and collect the children power information. The leaves of
|
|
* the tree are the real devices which have the ability to get their
|
|
* current power consumption and set their power limit.
|
|
*/
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/dtpm.h>
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/powercap.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/mutex.h>
|
|
|
|
#define DTPM_POWER_LIMIT_FLAG 0
|
|
|
|
static const char *constraint_name[] = {
|
|
"Instantaneous",
|
|
};
|
|
|
|
static DEFINE_MUTEX(dtpm_lock);
|
|
static struct powercap_control_type *pct;
|
|
static struct dtpm *root;
|
|
|
|
static int get_time_window_us(struct powercap_zone *pcz, int cid, u64 *window)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
static int set_time_window_us(struct powercap_zone *pcz, int cid, u64 window)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
static int get_max_power_range_uw(struct powercap_zone *pcz, u64 *max_power_uw)
|
|
{
|
|
struct dtpm *dtpm = to_dtpm(pcz);
|
|
|
|
mutex_lock(&dtpm_lock);
|
|
*max_power_uw = dtpm->power_max - dtpm->power_min;
|
|
mutex_unlock(&dtpm_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __get_power_uw(struct dtpm *dtpm, u64 *power_uw)
|
|
{
|
|
struct dtpm *child;
|
|
u64 power;
|
|
int ret = 0;
|
|
|
|
if (dtpm->ops) {
|
|
*power_uw = dtpm->ops->get_power_uw(dtpm);
|
|
return 0;
|
|
}
|
|
|
|
*power_uw = 0;
|
|
|
|
list_for_each_entry(child, &dtpm->children, sibling) {
|
|
ret = __get_power_uw(child, &power);
|
|
if (ret)
|
|
break;
|
|
*power_uw += power;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int get_power_uw(struct powercap_zone *pcz, u64 *power_uw)
|
|
{
|
|
struct dtpm *dtpm = to_dtpm(pcz);
|
|
int ret;
|
|
|
|
mutex_lock(&dtpm_lock);
|
|
ret = __get_power_uw(dtpm, power_uw);
|
|
mutex_unlock(&dtpm_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void __dtpm_rebalance_weight(struct dtpm *dtpm)
|
|
{
|
|
struct dtpm *child;
|
|
|
|
list_for_each_entry(child, &dtpm->children, sibling) {
|
|
|
|
pr_debug("Setting weight '%d' for '%s'\n",
|
|
child->weight, child->zone.name);
|
|
|
|
child->weight = DIV64_U64_ROUND_CLOSEST(
|
|
child->power_max * 1024, dtpm->power_max);
|
|
|
|
__dtpm_rebalance_weight(child);
|
|
}
|
|
}
|
|
|
|
static void __dtpm_sub_power(struct dtpm *dtpm)
|
|
{
|
|
struct dtpm *parent = dtpm->parent;
|
|
|
|
while (parent) {
|
|
parent->power_min -= dtpm->power_min;
|
|
parent->power_max -= dtpm->power_max;
|
|
parent->power_limit -= dtpm->power_limit;
|
|
parent = parent->parent;
|
|
}
|
|
|
|
__dtpm_rebalance_weight(root);
|
|
}
|
|
|
|
static void __dtpm_add_power(struct dtpm *dtpm)
|
|
{
|
|
struct dtpm *parent = dtpm->parent;
|
|
|
|
while (parent) {
|
|
parent->power_min += dtpm->power_min;
|
|
parent->power_max += dtpm->power_max;
|
|
parent->power_limit += dtpm->power_limit;
|
|
parent = parent->parent;
|
|
}
|
|
|
|
__dtpm_rebalance_weight(root);
|
|
}
|
|
|
|
/**
|
|
* dtpm_update_power - Update the power on the dtpm
|
|
* @dtpm: a pointer to a dtpm structure to update
|
|
* @power_min: a u64 representing the new power_min value
|
|
* @power_max: a u64 representing the new power_max value
|
|
*
|
|
* Function to update the power values of the dtpm node specified in
|
|
* parameter. These new values will be propagated to the tree.
|
|
*
|
|
* Return: zero on success, -EINVAL if the values are inconsistent
|
|
*/
|
|
int dtpm_update_power(struct dtpm *dtpm, u64 power_min, u64 power_max)
|
|
{
|
|
int ret = 0;
|
|
|
|
mutex_lock(&dtpm_lock);
|
|
|
|
if (power_min == dtpm->power_min && power_max == dtpm->power_max)
|
|
goto unlock;
|
|
|
|
if (power_max < power_min) {
|
|
ret = -EINVAL;
|
|
goto unlock;
|
|
}
|
|
|
|
__dtpm_sub_power(dtpm);
|
|
|
|
dtpm->power_min = power_min;
|
|
dtpm->power_max = power_max;
|
|
if (!test_bit(DTPM_POWER_LIMIT_FLAG, &dtpm->flags))
|
|
dtpm->power_limit = power_max;
|
|
|
|
__dtpm_add_power(dtpm);
|
|
|
|
unlock:
|
|
mutex_unlock(&dtpm_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* dtpm_release_zone - Cleanup when the node is released
|
|
* @pcz: a pointer to a powercap_zone structure
|
|
*
|
|
* Do some housecleaning and update the weight on the tree. The
|
|
* release will be denied if the node has children. This function must
|
|
* be called by the specific release callback of the different
|
|
* backends.
|
|
*
|
|
* Return: 0 on success, -EBUSY if there are children
|
|
*/
|
|
int dtpm_release_zone(struct powercap_zone *pcz)
|
|
{
|
|
struct dtpm *dtpm = to_dtpm(pcz);
|
|
struct dtpm *parent = dtpm->parent;
|
|
|
|
mutex_lock(&dtpm_lock);
|
|
|
|
if (!list_empty(&dtpm->children)) {
|
|
mutex_unlock(&dtpm_lock);
|
|
return -EBUSY;
|
|
}
|
|
|
|
if (parent)
|
|
list_del(&dtpm->sibling);
|
|
|
|
__dtpm_sub_power(dtpm);
|
|
|
|
mutex_unlock(&dtpm_lock);
|
|
|
|
if (dtpm->ops)
|
|
dtpm->ops->release(dtpm);
|
|
|
|
if (root == dtpm)
|
|
root = NULL;
|
|
|
|
kfree(dtpm);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __get_power_limit_uw(struct dtpm *dtpm, int cid, u64 *power_limit)
|
|
{
|
|
*power_limit = dtpm->power_limit;
|
|
return 0;
|
|
}
|
|
|
|
static int get_power_limit_uw(struct powercap_zone *pcz,
|
|
int cid, u64 *power_limit)
|
|
{
|
|
struct dtpm *dtpm = to_dtpm(pcz);
|
|
int ret;
|
|
|
|
mutex_lock(&dtpm_lock);
|
|
ret = __get_power_limit_uw(dtpm, cid, power_limit);
|
|
mutex_unlock(&dtpm_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Set the power limit on the nodes, the power limit is distributed
|
|
* given the weight of the children.
|
|
*
|
|
* The dtpm node lock must be held when calling this function.
|
|
*/
|
|
static int __set_power_limit_uw(struct dtpm *dtpm, int cid, u64 power_limit)
|
|
{
|
|
struct dtpm *child;
|
|
int ret = 0;
|
|
u64 power;
|
|
|
|
/*
|
|
* A max power limitation means we remove the power limit,
|
|
* otherwise we set a constraint and flag the dtpm node.
|
|
*/
|
|
if (power_limit == dtpm->power_max) {
|
|
clear_bit(DTPM_POWER_LIMIT_FLAG, &dtpm->flags);
|
|
} else {
|
|
set_bit(DTPM_POWER_LIMIT_FLAG, &dtpm->flags);
|
|
}
|
|
|
|
pr_debug("Setting power limit for '%s': %llu uW\n",
|
|
dtpm->zone.name, power_limit);
|
|
|
|
/*
|
|
* Only leaves of the dtpm tree has ops to get/set the power
|
|
*/
|
|
if (dtpm->ops) {
|
|
dtpm->power_limit = dtpm->ops->set_power_uw(dtpm, power_limit);
|
|
} else {
|
|
dtpm->power_limit = 0;
|
|
|
|
list_for_each_entry(child, &dtpm->children, sibling) {
|
|
|
|
/*
|
|
* Integer division rounding will inevitably
|
|
* lead to a different min or max value when
|
|
* set several times. In order to restore the
|
|
* initial value, we force the child's min or
|
|
* max power every time if the constraint is
|
|
* at the boundaries.
|
|
*/
|
|
if (power_limit == dtpm->power_max) {
|
|
power = child->power_max;
|
|
} else if (power_limit == dtpm->power_min) {
|
|
power = child->power_min;
|
|
} else {
|
|
power = DIV_ROUND_CLOSEST_ULL(
|
|
power_limit * child->weight, 1024);
|
|
}
|
|
|
|
pr_debug("Setting power limit for '%s': %llu uW\n",
|
|
child->zone.name, power);
|
|
|
|
ret = __set_power_limit_uw(child, cid, power);
|
|
if (!ret)
|
|
ret = __get_power_limit_uw(child, cid, &power);
|
|
|
|
if (ret)
|
|
break;
|
|
|
|
dtpm->power_limit += power;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int set_power_limit_uw(struct powercap_zone *pcz,
|
|
int cid, u64 power_limit)
|
|
{
|
|
struct dtpm *dtpm = to_dtpm(pcz);
|
|
int ret;
|
|
|
|
mutex_lock(&dtpm_lock);
|
|
|
|
/*
|
|
* Don't allow values outside of the power range previously
|
|
* set when initializing the power numbers.
|
|
*/
|
|
power_limit = clamp_val(power_limit, dtpm->power_min, dtpm->power_max);
|
|
|
|
ret = __set_power_limit_uw(dtpm, cid, power_limit);
|
|
|
|
pr_debug("%s: power limit: %llu uW, power max: %llu uW\n",
|
|
dtpm->zone.name, dtpm->power_limit, dtpm->power_max);
|
|
|
|
mutex_unlock(&dtpm_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const char *get_constraint_name(struct powercap_zone *pcz, int cid)
|
|
{
|
|
return constraint_name[cid];
|
|
}
|
|
|
|
static int get_max_power_uw(struct powercap_zone *pcz, int id, u64 *max_power)
|
|
{
|
|
struct dtpm *dtpm = to_dtpm(pcz);
|
|
|
|
mutex_lock(&dtpm_lock);
|
|
*max_power = dtpm->power_max;
|
|
mutex_unlock(&dtpm_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct powercap_zone_constraint_ops constraint_ops = {
|
|
.set_power_limit_uw = set_power_limit_uw,
|
|
.get_power_limit_uw = get_power_limit_uw,
|
|
.set_time_window_us = set_time_window_us,
|
|
.get_time_window_us = get_time_window_us,
|
|
.get_max_power_uw = get_max_power_uw,
|
|
.get_name = get_constraint_name,
|
|
};
|
|
|
|
static struct powercap_zone_ops zone_ops = {
|
|
.get_max_power_range_uw = get_max_power_range_uw,
|
|
.get_power_uw = get_power_uw,
|
|
.release = dtpm_release_zone,
|
|
};
|
|
|
|
/**
|
|
* dtpm_alloc - Allocate and initialize a dtpm struct
|
|
* @name: a string specifying the name of the node
|
|
*
|
|
* Return: a struct dtpm pointer, NULL in case of error
|
|
*/
|
|
struct dtpm *dtpm_alloc(struct dtpm_ops *ops)
|
|
{
|
|
struct dtpm *dtpm;
|
|
|
|
dtpm = kzalloc(sizeof(*dtpm), GFP_KERNEL);
|
|
if (dtpm) {
|
|
INIT_LIST_HEAD(&dtpm->children);
|
|
INIT_LIST_HEAD(&dtpm->sibling);
|
|
dtpm->weight = 1024;
|
|
dtpm->ops = ops;
|
|
}
|
|
|
|
return dtpm;
|
|
}
|
|
|
|
/**
|
|
* dtpm_unregister - Unregister a dtpm node from the hierarchy tree
|
|
* @dtpm: a pointer to a dtpm structure corresponding to the node to be removed
|
|
*
|
|
* Call the underlying powercap unregister function. That will call
|
|
* the release callback of the powercap zone.
|
|
*/
|
|
void dtpm_unregister(struct dtpm *dtpm)
|
|
{
|
|
powercap_unregister_zone(pct, &dtpm->zone);
|
|
|
|
pr_info("Unregistered dtpm node '%s'\n", dtpm->zone.name);
|
|
}
|
|
|
|
/**
|
|
* dtpm_register - Register a dtpm node in the hierarchy tree
|
|
* @name: a string specifying the name of the node
|
|
* @dtpm: a pointer to a dtpm structure corresponding to the new node
|
|
* @parent: a pointer to a dtpm structure corresponding to the parent node
|
|
*
|
|
* Create a dtpm node in the tree. If no parent is specified, the node
|
|
* is the root node of the hierarchy. If the root node already exists,
|
|
* then the registration will fail. The powercap controller must be
|
|
* initialized before calling this function.
|
|
*
|
|
* The dtpm structure must be initialized with the power numbers
|
|
* before calling this function.
|
|
*
|
|
* Return: zero on success, a negative value in case of error:
|
|
* -EAGAIN: the function is called before the framework is initialized.
|
|
* -EBUSY: the root node is already inserted
|
|
* -EINVAL: * there is no root node yet and @parent is specified
|
|
* * no all ops are defined
|
|
* * parent have ops which are reserved for leaves
|
|
* Other negative values are reported back from the powercap framework
|
|
*/
|
|
int dtpm_register(const char *name, struct dtpm *dtpm, struct dtpm *parent)
|
|
{
|
|
struct powercap_zone *pcz;
|
|
|
|
if (!pct)
|
|
return -EAGAIN;
|
|
|
|
if (root && !parent)
|
|
return -EBUSY;
|
|
|
|
if (!root && parent)
|
|
return -EINVAL;
|
|
|
|
if (parent && parent->ops)
|
|
return -EINVAL;
|
|
|
|
if (!dtpm)
|
|
return -EINVAL;
|
|
|
|
if (dtpm->ops && !(dtpm->ops->set_power_uw &&
|
|
dtpm->ops->get_power_uw &&
|
|
dtpm->ops->release))
|
|
return -EINVAL;
|
|
|
|
pcz = powercap_register_zone(&dtpm->zone, pct, name,
|
|
parent ? &parent->zone : NULL,
|
|
&zone_ops, MAX_DTPM_CONSTRAINTS,
|
|
&constraint_ops);
|
|
if (IS_ERR(pcz))
|
|
return PTR_ERR(pcz);
|
|
|
|
mutex_lock(&dtpm_lock);
|
|
|
|
if (parent) {
|
|
list_add_tail(&dtpm->sibling, &parent->children);
|
|
dtpm->parent = parent;
|
|
} else {
|
|
root = dtpm;
|
|
}
|
|
|
|
__dtpm_add_power(dtpm);
|
|
|
|
pr_info("Registered dtpm node '%s' / %llu-%llu uW, \n",
|
|
dtpm->zone.name, dtpm->power_min, dtpm->power_max);
|
|
|
|
mutex_unlock(&dtpm_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __init dtpm_init(void)
|
|
{
|
|
struct dtpm_descr **dtpm_descr;
|
|
|
|
pct = powercap_register_control_type(NULL, "dtpm", NULL);
|
|
if (IS_ERR(pct)) {
|
|
pr_err("Failed to register control type\n");
|
|
return PTR_ERR(pct);
|
|
}
|
|
|
|
for_each_dtpm_table(dtpm_descr)
|
|
(*dtpm_descr)->init(*dtpm_descr);
|
|
|
|
return 0;
|
|
}
|
|
late_initcall(dtpm_init);
|