1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * thermal support for the cell processor
4  *
5  * This module adds some sysfs attributes to cpu and spu nodes.
6  * Base for measurements are the digital thermal sensors (DTS)
7  * located on the chip.
8  * The accuracy is 2 degrees, starting from 65 up to 125 degrees celsius
9  * The attributes can be found under
10  * /sys/devices/system/cpu/cpuX/thermal
11  * /sys/devices/system/spu/spuX/thermal
12  *
13  * The following attributes are added for each node:
14  * temperature:
15  *	contains the current temperature measured by the DTS
16  * throttle_begin:
17  *	throttling begins when temperature is greater or equal to
18  *	throttle_begin. Setting this value to 125 prevents throttling.
19  * throttle_end:
20  *	throttling is being ceased, if the temperature is lower than
21  *	throttle_end. Due to a delay between applying throttling and
22  *	a reduced temperature this value should be less than throttle_begin.
23  *	A value equal to throttle_begin provides only a very little hysteresis.
24  * throttle_full_stop:
25  *	If the temperatrue is greater or equal to throttle_full_stop,
26  *	full throttling is applied to the cpu or spu. This value should be
27  *	greater than throttle_begin and throttle_end. Setting this value to
28  *	65 prevents the unit from running code at all.
29  *
30  * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
31  *
32  * Author: Christian Krafft <krafft@de.ibm.com>
33  */
34 
35 #include <linux/module.h>
36 #include <linux/device.h>
37 #include <linux/kernel.h>
38 #include <linux/cpu.h>
39 #include <linux/stringify.h>
40 #include <asm/spu.h>
41 #include <asm/io.h>
42 #include <asm/cell-regs.h>
43 
44 #include "spu_priv1_mmio.h"
45 
46 #define TEMP_MIN 65
47 #define TEMP_MAX 125
48 
49 #define DEVICE_PREFIX_ATTR(_prefix,_name,_mode)			\
50 struct device_attribute attr_ ## _prefix ## _ ## _name = {	\
51 	.attr = { .name = __stringify(_name), .mode = _mode },	\
52 	.show	= _prefix ## _show_ ## _name,			\
53 	.store	= _prefix ## _store_ ## _name,			\
54 };
55 
reg_to_temp(u8 reg_value)56 static inline u8 reg_to_temp(u8 reg_value)
57 {
58 	return ((reg_value & 0x3f) << 1) + TEMP_MIN;
59 }
60 
temp_to_reg(u8 temp)61 static inline u8 temp_to_reg(u8 temp)
62 {
63 	return ((temp - TEMP_MIN) >> 1) & 0x3f;
64 }
65 
get_pmd_regs(struct device * dev)66 static struct cbe_pmd_regs __iomem *get_pmd_regs(struct device *dev)
67 {
68 	struct spu *spu;
69 
70 	spu = container_of(dev, struct spu, dev);
71 
72 	return cbe_get_pmd_regs(spu_devnode(spu));
73 }
74 
75 /* returns the value for a given spu in a given register */
spu_read_register_value(struct device * dev,union spe_reg __iomem * reg)76 static u8 spu_read_register_value(struct device *dev, union spe_reg __iomem *reg)
77 {
78 	union spe_reg value;
79 	struct spu *spu;
80 
81 	spu = container_of(dev, struct spu, dev);
82 	value.val = in_be64(&reg->val);
83 
84 	return value.spe[spu->spe_id];
85 }
86 
spu_show_temp(struct device * dev,struct device_attribute * attr,char * buf)87 static ssize_t spu_show_temp(struct device *dev, struct device_attribute *attr,
88 			char *buf)
89 {
90 	u8 value;
91 	struct cbe_pmd_regs __iomem *pmd_regs;
92 
93 	pmd_regs = get_pmd_regs(dev);
94 
95 	value = spu_read_register_value(dev, &pmd_regs->ts_ctsr1);
96 
97 	return sprintf(buf, "%d\n", reg_to_temp(value));
98 }
99 
show_throttle(struct cbe_pmd_regs __iomem * pmd_regs,char * buf,int pos)100 static ssize_t show_throttle(struct cbe_pmd_regs __iomem *pmd_regs, char *buf, int pos)
101 {
102 	u64 value;
103 
104 	value = in_be64(&pmd_regs->tm_tpr.val);
105 	/* access the corresponding byte */
106 	value >>= pos;
107 	value &= 0x3F;
108 
109 	return sprintf(buf, "%d\n", reg_to_temp(value));
110 }
111 
store_throttle(struct cbe_pmd_regs __iomem * pmd_regs,const char * buf,size_t size,int pos)112 static ssize_t store_throttle(struct cbe_pmd_regs __iomem *pmd_regs, const char *buf, size_t size, int pos)
113 {
114 	u64 reg_value;
115 	unsigned int temp;
116 	u64 new_value;
117 	int ret;
118 
119 	ret = sscanf(buf, "%u", &temp);
120 
121 	if (ret != 1 || temp < TEMP_MIN || temp > TEMP_MAX)
122 		return -EINVAL;
123 
124 	new_value = temp_to_reg(temp);
125 
126 	reg_value = in_be64(&pmd_regs->tm_tpr.val);
127 
128 	/* zero out bits for new value */
129 	reg_value &= ~(0xffull << pos);
130 	/* set bits to new value */
131 	reg_value |= new_value << pos;
132 
133 	out_be64(&pmd_regs->tm_tpr.val, reg_value);
134 	return size;
135 }
136 
spu_show_throttle_end(struct device * dev,struct device_attribute * attr,char * buf)137 static ssize_t spu_show_throttle_end(struct device *dev,
138 			struct device_attribute *attr, char *buf)
139 {
140 	return show_throttle(get_pmd_regs(dev), buf, 0);
141 }
142 
spu_show_throttle_begin(struct device * dev,struct device_attribute * attr,char * buf)143 static ssize_t spu_show_throttle_begin(struct device *dev,
144 			struct device_attribute *attr, char *buf)
145 {
146 	return show_throttle(get_pmd_regs(dev), buf, 8);
147 }
148 
spu_show_throttle_full_stop(struct device * dev,struct device_attribute * attr,char * buf)149 static ssize_t spu_show_throttle_full_stop(struct device *dev,
150 			struct device_attribute *attr, char *buf)
151 {
152 	return show_throttle(get_pmd_regs(dev), buf, 16);
153 }
154 
spu_store_throttle_end(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)155 static ssize_t spu_store_throttle_end(struct device *dev,
156 			struct device_attribute *attr, const char *buf, size_t size)
157 {
158 	return store_throttle(get_pmd_regs(dev), buf, size, 0);
159 }
160 
spu_store_throttle_begin(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)161 static ssize_t spu_store_throttle_begin(struct device *dev,
162 			struct device_attribute *attr, const char *buf, size_t size)
163 {
164 	return store_throttle(get_pmd_regs(dev), buf, size, 8);
165 }
166 
spu_store_throttle_full_stop(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)167 static ssize_t spu_store_throttle_full_stop(struct device *dev,
168 			struct device_attribute *attr, const char *buf, size_t size)
169 {
170 	return store_throttle(get_pmd_regs(dev), buf, size, 16);
171 }
172 
ppe_show_temp(struct device * dev,char * buf,int pos)173 static ssize_t ppe_show_temp(struct device *dev, char *buf, int pos)
174 {
175 	struct cbe_pmd_regs __iomem *pmd_regs;
176 	u64 value;
177 
178 	pmd_regs = cbe_get_cpu_pmd_regs(dev->id);
179 	value = in_be64(&pmd_regs->ts_ctsr2);
180 
181 	value = (value >> pos) & 0x3f;
182 
183 	return sprintf(buf, "%d\n", reg_to_temp(value));
184 }
185 
186 
187 /* shows the temperature of the DTS on the PPE,
188  * located near the linear thermal sensor */
ppe_show_temp0(struct device * dev,struct device_attribute * attr,char * buf)189 static ssize_t ppe_show_temp0(struct device *dev,
190 			struct device_attribute *attr, char *buf)
191 {
192 	return ppe_show_temp(dev, buf, 32);
193 }
194 
195 /* shows the temperature of the second DTS on the PPE */
ppe_show_temp1(struct device * dev,struct device_attribute * attr,char * buf)196 static ssize_t ppe_show_temp1(struct device *dev,
197 			struct device_attribute *attr, char *buf)
198 {
199 	return ppe_show_temp(dev, buf, 0);
200 }
201 
ppe_show_throttle_end(struct device * dev,struct device_attribute * attr,char * buf)202 static ssize_t ppe_show_throttle_end(struct device *dev,
203 			struct device_attribute *attr, char *buf)
204 {
205 	return show_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, 32);
206 }
207 
ppe_show_throttle_begin(struct device * dev,struct device_attribute * attr,char * buf)208 static ssize_t ppe_show_throttle_begin(struct device *dev,
209 			struct device_attribute *attr, char *buf)
210 {
211 	return show_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, 40);
212 }
213 
ppe_show_throttle_full_stop(struct device * dev,struct device_attribute * attr,char * buf)214 static ssize_t ppe_show_throttle_full_stop(struct device *dev,
215 			struct device_attribute *attr, char *buf)
216 {
217 	return show_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, 48);
218 }
219 
ppe_store_throttle_end(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)220 static ssize_t ppe_store_throttle_end(struct device *dev,
221 			struct device_attribute *attr, const char *buf, size_t size)
222 {
223 	return store_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, size, 32);
224 }
225 
ppe_store_throttle_begin(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)226 static ssize_t ppe_store_throttle_begin(struct device *dev,
227 			struct device_attribute *attr, const char *buf, size_t size)
228 {
229 	return store_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, size, 40);
230 }
231 
ppe_store_throttle_full_stop(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)232 static ssize_t ppe_store_throttle_full_stop(struct device *dev,
233 			struct device_attribute *attr, const char *buf, size_t size)
234 {
235 	return store_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, size, 48);
236 }
237 
238 
239 static struct device_attribute attr_spu_temperature = {
240 	.attr = {.name = "temperature", .mode = 0400 },
241 	.show = spu_show_temp,
242 };
243 
244 static DEVICE_PREFIX_ATTR(spu, throttle_end, 0600);
245 static DEVICE_PREFIX_ATTR(spu, throttle_begin, 0600);
246 static DEVICE_PREFIX_ATTR(spu, throttle_full_stop, 0600);
247 
248 
249 static struct attribute *spu_attributes[] = {
250 	&attr_spu_temperature.attr,
251 	&attr_spu_throttle_end.attr,
252 	&attr_spu_throttle_begin.attr,
253 	&attr_spu_throttle_full_stop.attr,
254 	NULL,
255 };
256 
257 static const struct attribute_group spu_attribute_group = {
258 	.name	= "thermal",
259 	.attrs	= spu_attributes,
260 };
261 
262 static struct device_attribute attr_ppe_temperature0 = {
263 	.attr = {.name = "temperature0", .mode = 0400 },
264 	.show = ppe_show_temp0,
265 };
266 
267 static struct device_attribute attr_ppe_temperature1 = {
268 	.attr = {.name = "temperature1", .mode = 0400 },
269 	.show = ppe_show_temp1,
270 };
271 
272 static DEVICE_PREFIX_ATTR(ppe, throttle_end, 0600);
273 static DEVICE_PREFIX_ATTR(ppe, throttle_begin, 0600);
274 static DEVICE_PREFIX_ATTR(ppe, throttle_full_stop, 0600);
275 
276 static struct attribute *ppe_attributes[] = {
277 	&attr_ppe_temperature0.attr,
278 	&attr_ppe_temperature1.attr,
279 	&attr_ppe_throttle_end.attr,
280 	&attr_ppe_throttle_begin.attr,
281 	&attr_ppe_throttle_full_stop.attr,
282 	NULL,
283 };
284 
285 static struct attribute_group ppe_attribute_group = {
286 	.name	= "thermal",
287 	.attrs	= ppe_attributes,
288 };
289 
290 /*
291  * initialize throttling with default values
292  */
init_default_values(void)293 static int __init init_default_values(void)
294 {
295 	int cpu;
296 	struct cbe_pmd_regs __iomem *pmd_regs;
297 	struct device *dev;
298 	union ppe_spe_reg tpr;
299 	union spe_reg str1;
300 	u64 str2;
301 	union spe_reg cr1;
302 	u64 cr2;
303 
304 	/* TPR defaults */
305 	/* ppe
306 	 *	1F - no full stop
307 	 *	08 - dynamic throttling starts if over 80 degrees
308 	 *	03 - dynamic throttling ceases if below 70 degrees */
309 	tpr.ppe = 0x1F0803;
310 	/* spe
311 	 *	10 - full stopped when over 96 degrees
312 	 *	08 - dynamic throttling starts if over 80 degrees
313 	 *	03 - dynamic throttling ceases if below 70 degrees
314 	 */
315 	tpr.spe = 0x100803;
316 
317 	/* STR defaults */
318 	/* str1
319 	 *	10 - stop 16 of 32 cycles
320 	 */
321 	str1.val = 0x1010101010101010ull;
322 	/* str2
323 	 *	10 - stop 16 of 32 cycles
324 	 */
325 	str2 = 0x10;
326 
327 	/* CR defaults */
328 	/* cr1
329 	 *	4 - normal operation
330 	 */
331 	cr1.val = 0x0404040404040404ull;
332 	/* cr2
333 	 *	4 - normal operation
334 	 */
335 	cr2 = 0x04;
336 
337 	for_each_possible_cpu (cpu) {
338 		pr_debug("processing cpu %d\n", cpu);
339 		dev = get_cpu_device(cpu);
340 
341 		if (!dev) {
342 			pr_info("invalid dev pointer for cbe_thermal\n");
343 			return -EINVAL;
344 		}
345 
346 		pmd_regs = cbe_get_cpu_pmd_regs(dev->id);
347 
348 		if (!pmd_regs) {
349 			pr_info("invalid CBE regs pointer for cbe_thermal\n");
350 			return -EINVAL;
351 		}
352 
353 		out_be64(&pmd_regs->tm_str2, str2);
354 		out_be64(&pmd_regs->tm_str1.val, str1.val);
355 		out_be64(&pmd_regs->tm_tpr.val, tpr.val);
356 		out_be64(&pmd_regs->tm_cr1.val, cr1.val);
357 		out_be64(&pmd_regs->tm_cr2, cr2);
358 	}
359 
360 	return 0;
361 }
362 
363 
thermal_init(void)364 static int __init thermal_init(void)
365 {
366 	int rc = init_default_values();
367 
368 	if (rc == 0) {
369 		spu_add_dev_attr_group(&spu_attribute_group);
370 		cpu_add_dev_attr_group(&ppe_attribute_group);
371 	}
372 
373 	return rc;
374 }
375 module_init(thermal_init);
376 
thermal_exit(void)377 static void __exit thermal_exit(void)
378 {
379 	spu_remove_dev_attr_group(&spu_attribute_group);
380 	cpu_remove_dev_attr_group(&ppe_attribute_group);
381 }
382 module_exit(thermal_exit);
383 
384 MODULE_LICENSE("GPL");
385 MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
386 
387