~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/platforms/cell/cbe_thermal.c

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp