Skip to content
Navigation Menu
Toggle navigation
Sign in
In this repository
All GitHub Enterprise
↵
Jump to
↵
No suggested jump to results
In this repository
All GitHub Enterprise
↵
Jump to
↵
In this organization
All GitHub Enterprise
↵
Jump to
↵
In this repository
All GitHub Enterprise
↵
Jump to
↵
Sign in
Reseting focus
You signed in with another tab or window.
Reload
to refresh your session.
You signed out in another tab or window.
Reload
to refresh your session.
You switched accounts on another tab or window.
Reload
to refresh your session.
Dismiss alert
{{ message }}
mariux64
/
linux
Public
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Issues
2
Pull requests
0
Actions
Projects
0
Wiki
Security
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Wiki
Security
Insights
Files
44c9cf9
Documentation
LICENSES
arch
block
certs
crypto
drivers
accel
accessibility
acpi
amba
android
ata
atm
auxdisplay
base
bcma
block
bluetooth
bus
cache
cdrom
cdx
char
clk
clocksource
comedi
connector
counter
cpufreq
cpuidle
crypto
cxl
dax
dca
devfreq
dio
dma-buf
dma
dpll
edac
eisa
extcon
firewire
firmware
fpga
fsi
gnss
gpio
gpu
greybus
hid
hsi
hte
hv
hwmon
hwspinlock
hwtracing
i2c
i3c
idle
iio
infiniband
input
interconnect
iommu
ipack
irqchip
isdn
leds
macintosh
mailbox
mcb
md
media
memory
memstick
message
mfd
misc
mmc
most
mtd
mux
net
nfc
ntb
nubus
nvdimm
nvme
nvmem
of
opp
parisc
parport
pci
pcmcia
peci
perf
phy
pinctrl
platform
pmdomain
pnp
power
powercap
Kconfig
Makefile
arm_scmi_powercap.c
dtpm.c
dtpm_cpu.c
dtpm_devfreq.c
dtpm_subsys.h
idle_inject.c
intel_rapl_common.c
intel_rapl_msr.c
intel_rapl_tpmi.c
powercap_sys.c
pps
ps3
ptp
pwm
rapidio
ras
regulator
remoteproc
reset
rpmsg
rtc
s390
sbus
scsi
sh
siox
slimbus
soc
soundwire
spi
spmi
ssb
staging
target
tc
tee
thermal
thunderbolt
tty
ufs
uio
usb
vdpa
vfio
vhost
video
virt
virtio
w1
watchdog
xen
zorro
Kconfig
Makefile
fs
include
init
io_uring
ipc
kernel
lib
mm
net
rust
samples
scripts
security
sound
tools
usr
virt
.clang-format
.cocciconfig
.editorconfig
.get_maintainer.ignore
.gitattributes
.gitignore
.mailmap
.rustfmt.toml
COPYING
CREDITS
Kbuild
Kconfig
MAINTAINERS
Makefile
README
Breadcrumbs
linux
/
drivers
/
powercap
/
dtpm.c
Blame
Blame
Latest commit
History
History
661 lines (532 loc) · 15.5 KB
Breadcrumbs
linux
/
drivers
/
powercap
/
dtpm.c
Top
File metadata and controls
Code
Blame
661 lines (532 loc) · 15.5 KB
Raw
// 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> #include <linux/of.h> #include "dtpm_subsys.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); *max_power_uw = dtpm->power_max - dtpm->power_min; 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) { return __get_power_uw(to_dtpm(pcz), power_uw); } 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; } } 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_update_power - Update the power on the dtpm * @dtpm: a pointer to a dtpm structure to update * * 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) { int ret; __dtpm_sub_power(dtpm); ret = dtpm->ops->update_power_uw(dtpm); if (ret) pr_err("Failed to update power for '%s': %d\n", dtpm->zone.name, ret); if (!test_bit(DTPM_POWER_LIMIT_FLAG, &dtpm->flags)) dtpm->power_limit = dtpm->power_max; __dtpm_add_power(dtpm); if (root) __dtpm_rebalance_weight(root); 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; if (!list_empty(&dtpm->children)) return -EBUSY; if (parent) list_del(&dtpm->sibling); __dtpm_sub_power(dtpm); if (dtpm->ops) dtpm->ops->release(dtpm); else kfree(dtpm); return 0; } static int get_power_limit_uw(struct powercap_zone *pcz, int cid, u64 *power_limit) { *power_limit = to_dtpm(pcz)->power_limit; return 0; } /* * 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->zone, 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; /* * 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); 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) { *max_power = to_dtpm(pcz)->power_max; 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_init - Allocate and initialize a dtpm struct * @dtpm: The dtpm struct pointer to be initialized * @ops: The dtpm device specific ops, NULL for a virtual node */ void dtpm_init(struct dtpm *dtpm, struct dtpm_ops *ops) { if (dtpm) { INIT_LIST_HEAD(&dtpm->children); INIT_LIST_HEAD(&dtpm->sibling); dtpm->weight = 1024; dtpm->ops = ops; } } /** * 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_debug("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->update_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); if (parent) { list_add_tail(&dtpm->sibling, &parent->children); dtpm->parent = parent; } else { root = dtpm; } if (dtpm->ops && !dtpm->ops->update_power_uw(dtpm)) { __dtpm_add_power(dtpm); dtpm->power_limit = dtpm->power_max; } pr_debug("Registered dtpm node '%s' / %llu-%llu uW, \n", dtpm->zone.name, dtpm->power_min, dtpm->power_max); return 0; } static struct dtpm *dtpm_setup_virtual(const struct dtpm_node *hierarchy, struct dtpm *parent) { struct dtpm *dtpm; int ret; dtpm = kzalloc(sizeof(*dtpm), GFP_KERNEL); if (!dtpm) return ERR_PTR(-ENOMEM); dtpm_init(dtpm, NULL); ret = dtpm_register(hierarchy->name, dtpm, parent); if (ret) { pr_err("Failed to register dtpm node '%s': %d\n", hierarchy->name, ret); kfree(dtpm); return ERR_PTR(ret); } return dtpm; } static struct dtpm *dtpm_setup_dt(const struct dtpm_node *hierarchy, struct dtpm *parent) { struct device_node *np; int i, ret; np = of_find_node_by_path(hierarchy->name); if (!np) { pr_err("Failed to find '%s'\n", hierarchy->name); return ERR_PTR(-ENXIO); } for (i = 0; i < ARRAY_SIZE(dtpm_subsys); i++) { if (!dtpm_subsys[i]->setup) continue; ret = dtpm_subsys[i]->setup(parent, np); if (ret) { pr_err("Failed to setup '%s': %d\n", dtpm_subsys[i]->name, ret); of_node_put(np); return ERR_PTR(ret); } } of_node_put(np); /* * By returning a NULL pointer, we let know the caller there * is no child for us as we are a leaf of the tree */ return NULL; } typedef struct dtpm * (*dtpm_node_callback_t)(const struct dtpm_node *, struct dtpm *); static dtpm_node_callback_t dtpm_node_callback[] = { [DTPM_NODE_VIRTUAL] = dtpm_setup_virtual, [DTPM_NODE_DT] = dtpm_setup_dt, }; static int dtpm_for_each_child(const struct dtpm_node *hierarchy, const struct dtpm_node *it, struct dtpm *parent) { struct dtpm *dtpm; int i, ret; for (i = 0; hierarchy[i].name; i++) { if (hierarchy[i].parent != it) continue; dtpm = dtpm_node_callback[hierarchy[i].type](&hierarchy[i], parent); /* * A NULL pointer means there is no children, hence we * continue without going deeper in the recursivity. */ if (!dtpm) continue; /* * There are multiple reasons why the callback could * fail. The generic glue is abstracting the backend * and therefore it is not possible to report back or * take a decision based on the error. In any case, * if this call fails, it is not critical in the * hierarchy creation, we can assume the underlying * service is not found, so we continue without this * branch in the tree but with a warning to log the * information the node was not created. */ if (IS_ERR(dtpm)) { pr_warn("Failed to create '%s' in the hierarchy\n", hierarchy[i].name); continue; } ret = dtpm_for_each_child(hierarchy, &hierarchy[i], dtpm); if (ret) return ret; } return 0; } /** * dtpm_create_hierarchy - Create the dtpm hierarchy * @dtpm_match_table: Pointer to the array of device ID structures * * The function is called by the platform specific code with the * description of the different node in the hierarchy. It creates the * tree in the sysfs filesystem under the powercap dtpm entry. * * The expected tree has the format: * * struct dtpm_node hierarchy[] = { * [0] { .name = "topmost", type = DTPM_NODE_VIRTUAL }, * [1] { .name = "package", .type = DTPM_NODE_VIRTUAL, .parent = &hierarchy[0] }, * [2] { .name = "/cpus/cpu0", .type = DTPM_NODE_DT, .parent = &hierarchy[1] }, * [3] { .name = "/cpus/cpu1", .type = DTPM_NODE_DT, .parent = &hierarchy[1] }, * [4] { .name = "/cpus/cpu2", .type = DTPM_NODE_DT, .parent = &hierarchy[1] }, * [5] { .name = "/cpus/cpu3", .type = DTPM_NODE_DT, .parent = &hierarchy[1] }, * [6] { } * }; * * The last element is always an empty one and marks the end of the * array. * * Return: zero on success, a negative value in case of error. Errors * are reported back from the underlying functions. */ int dtpm_create_hierarchy(struct of_device_id *dtpm_match_table) { const struct of_device_id *match; const struct dtpm_node *hierarchy; struct device_node *np; int i, ret; mutex_lock(&dtpm_lock); if (pct) { ret = -EBUSY; goto out_unlock; } pct = powercap_register_control_type(NULL, "dtpm", NULL); if (IS_ERR(pct)) { pr_err("Failed to register control type\n"); ret = PTR_ERR(pct); goto out_pct; } ret = -ENODEV; np = of_find_node_by_path("/"); if (!np) goto out_err; match = of_match_node(dtpm_match_table, np); of_node_put(np); if (!match) goto out_err; hierarchy = match->data; if (!hierarchy) { ret = -EFAULT; goto out_err; } ret = dtpm_for_each_child(hierarchy, NULL, NULL); if (ret) goto out_err; for (i = 0; i < ARRAY_SIZE(dtpm_subsys); i++) { if (!dtpm_subsys[i]->init) continue; ret = dtpm_subsys[i]->init(); if (ret) pr_info("Failed to initialize '%s': %d", dtpm_subsys[i]->name, ret); } mutex_unlock(&dtpm_lock); return 0; out_err: powercap_unregister_control_type(pct); out_pct: pct = NULL; out_unlock: mutex_unlock(&dtpm_lock); return ret; } EXPORT_SYMBOL_GPL(dtpm_create_hierarchy); static void __dtpm_destroy_hierarchy(struct dtpm *dtpm) { struct dtpm *child, *aux; list_for_each_entry_safe(child, aux, &dtpm->children, sibling) __dtpm_destroy_hierarchy(child); /* * At this point, we know all children were removed from the * recursive call before */ dtpm_unregister(dtpm); } void dtpm_destroy_hierarchy(void) { int i; mutex_lock(&dtpm_lock); if (!pct) goto out_unlock; __dtpm_destroy_hierarchy(root); for (i = 0; i < ARRAY_SIZE(dtpm_subsys); i++) { if (!dtpm_subsys[i]->exit) continue; dtpm_subsys[i]->exit(); } powercap_unregister_control_type(pct); pct = NULL; root = NULL; out_unlock: mutex_unlock(&dtpm_lock); } EXPORT_SYMBOL_GPL(dtpm_destroy_hierarchy);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
You can’t perform that action at this time.