1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  Copyright (C) 2019 Linaro Limited.
4  *
5  *  Author: Daniel Lezcano <daniel.lezcano@linaro.org>
6  *
7  */
8 #include <linux/cpu_cooling.h>
9 #include <linux/cpuidle.h>
10 #include <linux/err.h>
11 #include <linux/idle_inject.h>
12 #include <linux/idr.h>
13 #include <linux/slab.h>
14 #include <linux/thermal.h>
15 
16 /**
17  * struct cpuidle_cooling_device - data for the idle cooling device
18  * @ii_dev: an atomic to keep track of the last task exiting the idle cycle
19  * @state: a normalized integer giving the state of the cooling device
20  */
21 struct cpuidle_cooling_device {
22 	struct idle_inject_device *ii_dev;
23 	unsigned long state;
24 };
25 
26 static DEFINE_IDA(cpuidle_ida);
27 
28 /**
29  * cpuidle_cooling_runtime - Running time computation
30  * @idle_duration_us: the idle cooling device
31  * @state: a percentile based number
32  *
33  * The running duration is computed from the idle injection duration
34  * which is fixed. If we reach 100% of idle injection ratio, that
35  * means the running duration is zero. If we have a 50% ratio
36  * injection, that means we have equal duration for idle and for
37  * running duration.
38  *
39  * The formula is deduced as follows:
40  *
41  *  running = idle x ((100 / ratio) - 1)
42  *
43  * For precision purpose for integer math, we use the following:
44  *
45  *  running = (idle x 100) / ratio - idle
46  *
47  * For example, if we have an injected duration of 50%, then we end up
48  * with 10ms of idle injection and 10ms of running duration.
49  *
50  * Return: An unsigned int for a usec based runtime duration.
51  */
52 static unsigned int cpuidle_cooling_runtime(unsigned int idle_duration_us,
53 					    unsigned long state)
54 {
55 	if (!state)
56 		return 0;
57 
58 	return ((idle_duration_us * 100) / state) - idle_duration_us;
59 }
60 
61 /**
62  * cpuidle_cooling_get_max_state - Get the maximum state
63  * @cdev  : the thermal cooling device
64  * @state : a pointer to the state variable to be filled
65  *
66  * The function always returns 100 as the injection ratio. It is
67  * percentile based for consistency accross different platforms.
68  *
69  * Return: The function can not fail, it is always zero
70  */
71 static int cpuidle_cooling_get_max_state(struct thermal_cooling_device *cdev,
72 					 unsigned long *state)
73 {
74 	/*
75 	 * Depending on the configuration or the hardware, the running
76 	 * cycle and the idle cycle could be different. We want to
77 	 * unify that to an 0..100 interval, so the set state
78 	 * interface will be the same whatever the platform is.
79 	 *
80 	 * The state 100% will make the cluster 100% ... idle. A 0%
81 	 * injection ratio means no idle injection at all and 50%
82 	 * means for 10ms of idle injection, we have 10ms of running
83 	 * time.
84 	 */
85 	*state = 100;
86 
87 	return 0;
88 }
89 
90 /**
91  * cpuidle_cooling_get_cur_state - Get the current cooling state
92  * @cdev: the thermal cooling device
93  * @state: a pointer to the state
94  *
95  * The function just copies  the state value from the private thermal
96  * cooling device structure, the mapping is 1 <-> 1.
97  *
98  * Return: The function can not fail, it is always zero
99  */
100 static int cpuidle_cooling_get_cur_state(struct thermal_cooling_device *cdev,
101 					 unsigned long *state)
102 {
103 	struct cpuidle_cooling_device *idle_cdev = cdev->devdata;
104 
105 	*state = idle_cdev->state;
106 
107 	return 0;
108 }
109 
110 /**
111  * cpuidle_cooling_set_cur_state - Set the current cooling state
112  * @cdev: the thermal cooling device
113  * @state: the target state
114  *
115  * The function checks first if we are initiating the mitigation which
116  * in turn wakes up all the idle injection tasks belonging to the idle
117  * cooling device. In any case, it updates the internal state for the
118  * cooling device.
119  *
120  * Return: The function can not fail, it is always zero
121  */
122 static int cpuidle_cooling_set_cur_state(struct thermal_cooling_device *cdev,
123 					 unsigned long state)
124 {
125 	struct cpuidle_cooling_device *idle_cdev = cdev->devdata;
126 	struct idle_inject_device *ii_dev = idle_cdev->ii_dev;
127 	unsigned long current_state = idle_cdev->state;
128 	unsigned int runtime_us, idle_duration_us;
129 
130 	idle_cdev->state = state;
131 
132 	idle_inject_get_duration(ii_dev, &runtime_us, &idle_duration_us);
133 
134 	runtime_us = cpuidle_cooling_runtime(idle_duration_us, state);
135 
136 	idle_inject_set_duration(ii_dev, runtime_us, idle_duration_us);
137 
138 	if (current_state == 0 && state > 0) {
139 		idle_inject_start(ii_dev);
140 	} else if (current_state > 0 && !state)  {
141 		idle_inject_stop(ii_dev);
142 	}
143 
144 	return 0;
145 }
146 
147 /**
148  * cpuidle_cooling_ops - thermal cooling device ops
149  */
150 static struct thermal_cooling_device_ops cpuidle_cooling_ops = {
151 	.get_max_state = cpuidle_cooling_get_max_state,
152 	.get_cur_state = cpuidle_cooling_get_cur_state,
153 	.set_cur_state = cpuidle_cooling_set_cur_state,
154 };
155 
156 /**
157  * cpuidle_of_cooling_register - Idle cooling device initialization function
158  * @drv: a cpuidle driver structure pointer
159  * @np: a node pointer to a device tree cooling device node
160  *
161  * This function is in charge of creating a cooling device per cpuidle
162  * driver and register it to thermal framework.
163  *
164  * Return: zero on success, or negative value corresponding to the
165  * error detected in the underlying subsystems.
166  */
167 int cpuidle_of_cooling_register(struct device_node *np,
168 				struct cpuidle_driver *drv)
169 {
170 	struct idle_inject_device *ii_dev;
171 	struct cpuidle_cooling_device *idle_cdev;
172 	struct thermal_cooling_device *cdev;
173 	char dev_name[THERMAL_NAME_LENGTH];
174 	int id, ret;
175 
176 	idle_cdev = kzalloc(sizeof(*idle_cdev), GFP_KERNEL);
177 	if (!idle_cdev) {
178 		ret = -ENOMEM;
179 		goto out;
180 	}
181 
182 	id = ida_simple_get(&cpuidle_ida, 0, 0, GFP_KERNEL);
183 	if (id < 0) {
184 		ret = id;
185 		goto out_kfree;
186 	}
187 
188 	ii_dev = idle_inject_register(drv->cpumask);
189 	if (!ii_dev) {
190 		ret = -EINVAL;
191 		goto out_id;
192 	}
193 
194 	idle_inject_set_duration(ii_dev, TICK_USEC, TICK_USEC);
195 
196 	idle_cdev->ii_dev = ii_dev;
197 
198 	snprintf(dev_name, sizeof(dev_name), "thermal-idle-%d", id);
199 
200 	cdev = thermal_of_cooling_device_register(np, dev_name, idle_cdev,
201 						  &cpuidle_cooling_ops);
202 	if (IS_ERR(cdev)) {
203 		ret = PTR_ERR(cdev);
204 		goto out_unregister;
205 	}
206 
207 	return 0;
208 
209 out_unregister:
210 	idle_inject_unregister(ii_dev);
211 out_id:
212 	ida_simple_remove(&cpuidle_ida, id);
213 out_kfree:
214 	kfree(idle_cdev);
215 out:
216 	return ret;
217 }
218 
219 /**
220  * cpuidle_cooling_register - Idle cooling device initialization function
221  * @drv: a cpuidle driver structure pointer
222  *
223  * This function is in charge of creating a cooling device per cpuidle
224  * driver and register it to thermal framework.
225  *
226  * Return: zero on success, or negative value corresponding to the
227  * error detected in the underlying subsystems.
228  */
229 int cpuidle_cooling_register(struct cpuidle_driver *drv)
230 {
231 	return cpuidle_of_cooling_register(NULL, drv);
232 }
233