Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc
[linux-2.6.git] / arch / powerpc / platforms / cell / cbe_thermal.c
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/sysdev.h>
50 #include <linux/kernel.h>
51 #include <linux/cpu.h>
52 #include <asm/spu.h>
53 #include <asm/io.h>
54 #include <asm/prom.h>
55 #include <asm/cell-regs.h>
56
57 #include "spu_priv1_mmio.h"
58
59 #define TEMP_MIN 65
60 #define TEMP_MAX 125
61
62 #define SYSDEV_PREFIX_ATTR(_prefix,_name,_mode)                 \
63 struct sysdev_attribute attr_ ## _prefix ## _ ## _name = {      \
64         .attr = { .name = __stringify(_name), .mode = _mode },  \
65         .show   = _prefix ## _show_ ## _name,                   \
66         .store  = _prefix ## _store_ ## _name,                  \
67 };
68
69 static inline u8 reg_to_temp(u8 reg_value)
70 {
71         return ((reg_value & 0x3f) << 1) + TEMP_MIN;
72 }
73
74 static inline u8 temp_to_reg(u8 temp)
75 {
76         return ((temp - TEMP_MIN) >> 1) & 0x3f;
77 }
78
79 static struct cbe_pmd_regs __iomem *get_pmd_regs(struct sys_device *sysdev)
80 {
81         struct spu *spu;
82
83         spu = container_of(sysdev, struct spu, sysdev);
84
85         return cbe_get_pmd_regs(spu_devnode(spu));
86 }
87
88 /* returns the value for a given spu in a given register */
89 static u8 spu_read_register_value(struct sys_device *sysdev, union spe_reg __iomem *reg)
90 {
91         union spe_reg value;
92         struct spu *spu;
93
94         spu = container_of(sysdev, struct spu, sysdev);
95         value.val = in_be64(&reg->val);
96
97         return value.spe[spu->spe_id];
98 }
99
100 static ssize_t spu_show_temp(struct sys_device *sysdev, struct sysdev_attribute *attr,
101                         char *buf)
102 {
103         u8 value;
104         struct cbe_pmd_regs __iomem *pmd_regs;
105
106         pmd_regs = get_pmd_regs(sysdev);
107
108         value = spu_read_register_value(sysdev, &pmd_regs->ts_ctsr1);
109
110         return sprintf(buf, "%d\n", reg_to_temp(value));
111 }
112
113 static ssize_t show_throttle(struct cbe_pmd_regs __iomem *pmd_regs, char *buf, int pos)
114 {
115         u64 value;
116
117         value = in_be64(&pmd_regs->tm_tpr.val);
118         /* access the corresponding byte */
119         value >>= pos;
120         value &= 0x3F;
121
122         return sprintf(buf, "%d\n", reg_to_temp(value));
123 }
124
125 static ssize_t store_throttle(struct cbe_pmd_regs __iomem *pmd_regs, const char *buf, size_t size, int pos)
126 {
127         u64 reg_value;
128         int temp;
129         u64 new_value;
130         int ret;
131
132         ret = sscanf(buf, "%u", &temp);
133
134         if (ret != 1 || temp < TEMP_MIN || temp > TEMP_MAX)
135                 return -EINVAL;
136
137         new_value = temp_to_reg(temp);
138
139         reg_value = in_be64(&pmd_regs->tm_tpr.val);
140
141         /* zero out bits for new value */
142         reg_value &= ~(0xffull << pos);
143         /* set bits to new value */
144         reg_value |= new_value << pos;
145
146         out_be64(&pmd_regs->tm_tpr.val, reg_value);
147         return size;
148 }
149
150 static ssize_t spu_show_throttle_end(struct sys_device *sysdev,
151                         struct sysdev_attribute *attr, char *buf)
152 {
153         return show_throttle(get_pmd_regs(sysdev), buf, 0);
154 }
155
156 static ssize_t spu_show_throttle_begin(struct sys_device *sysdev,
157                         struct sysdev_attribute *attr, char *buf)
158 {
159         return show_throttle(get_pmd_regs(sysdev), buf, 8);
160 }
161
162 static ssize_t spu_show_throttle_full_stop(struct sys_device *sysdev,
163                         struct sysdev_attribute *attr, char *buf)
164 {
165         return show_throttle(get_pmd_regs(sysdev), buf, 16);
166 }
167
168 static ssize_t spu_store_throttle_end(struct sys_device *sysdev,
169                         struct sysdev_attribute *attr, const char *buf, size_t size)
170 {
171         return store_throttle(get_pmd_regs(sysdev), buf, size, 0);
172 }
173
174 static ssize_t spu_store_throttle_begin(struct sys_device *sysdev,
175                         struct sysdev_attribute *attr, const char *buf, size_t size)
176 {
177         return store_throttle(get_pmd_regs(sysdev), buf, size, 8);
178 }
179
180 static ssize_t spu_store_throttle_full_stop(struct sys_device *sysdev,
181                         struct sysdev_attribute *attr, const char *buf, size_t size)
182 {
183         return store_throttle(get_pmd_regs(sysdev), buf, size, 16);
184 }
185
186 static ssize_t ppe_show_temp(struct sys_device *sysdev, char *buf, int pos)
187 {
188         struct cbe_pmd_regs __iomem *pmd_regs;
189         u64 value;
190
191         pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);
192         value = in_be64(&pmd_regs->ts_ctsr2);
193
194         value = (value >> pos) & 0x3f;
195
196         return sprintf(buf, "%d\n", reg_to_temp(value));
197 }
198
199
200 /* shows the temperature of the DTS on the PPE,
201  * located near the linear thermal sensor */
202 static ssize_t ppe_show_temp0(struct sys_device *sysdev,
203                         struct sysdev_attribute *attr, char *buf)
204 {
205         return ppe_show_temp(sysdev, buf, 32);
206 }
207
208 /* shows the temperature of the second DTS on the PPE */
209 static ssize_t ppe_show_temp1(struct sys_device *sysdev,
210                         struct sysdev_attribute *attr, char *buf)
211 {
212         return ppe_show_temp(sysdev, buf, 0);
213 }
214
215 static ssize_t ppe_show_throttle_end(struct sys_device *sysdev,
216                         struct sysdev_attribute *attr, char *buf)
217 {
218         return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 32);
219 }
220
221 static ssize_t ppe_show_throttle_begin(struct sys_device *sysdev,
222                         struct sysdev_attribute *attr, char *buf)
223 {
224         return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 40);
225 }
226
227 static ssize_t ppe_show_throttle_full_stop(struct sys_device *sysdev,
228                         struct sysdev_attribute *attr, char *buf)
229 {
230         return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 48);
231 }
232
233 static ssize_t ppe_store_throttle_end(struct sys_device *sysdev,
234                         struct sysdev_attribute *attr, const char *buf, size_t size)
235 {
236         return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 32);
237 }
238
239 static ssize_t ppe_store_throttle_begin(struct sys_device *sysdev,
240                         struct sysdev_attribute *attr, const char *buf, size_t size)
241 {
242         return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 40);
243 }
244
245 static ssize_t ppe_store_throttle_full_stop(struct sys_device *sysdev,
246                         struct sysdev_attribute *attr, const char *buf, size_t size)
247 {
248         return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 48);
249 }
250
251
252 static struct sysdev_attribute attr_spu_temperature = {
253         .attr = {.name = "temperature", .mode = 0400 },
254         .show = spu_show_temp,
255 };
256
257 static SYSDEV_PREFIX_ATTR(spu, throttle_end, 0600);
258 static SYSDEV_PREFIX_ATTR(spu, throttle_begin, 0600);
259 static SYSDEV_PREFIX_ATTR(spu, throttle_full_stop, 0600);
260
261
262 static struct attribute *spu_attributes[] = {
263         &attr_spu_temperature.attr,
264         &attr_spu_throttle_end.attr,
265         &attr_spu_throttle_begin.attr,
266         &attr_spu_throttle_full_stop.attr,
267         NULL,
268 };
269
270 static struct attribute_group spu_attribute_group = {
271         .name   = "thermal",
272         .attrs  = spu_attributes,
273 };
274
275 static struct sysdev_attribute attr_ppe_temperature0 = {
276         .attr = {.name = "temperature0", .mode = 0400 },
277         .show = ppe_show_temp0,
278 };
279
280 static struct sysdev_attribute attr_ppe_temperature1 = {
281         .attr = {.name = "temperature1", .mode = 0400 },
282         .show = ppe_show_temp1,
283 };
284
285 static SYSDEV_PREFIX_ATTR(ppe, throttle_end, 0600);
286 static SYSDEV_PREFIX_ATTR(ppe, throttle_begin, 0600);
287 static SYSDEV_PREFIX_ATTR(ppe, throttle_full_stop, 0600);
288
289 static struct attribute *ppe_attributes[] = {
290         &attr_ppe_temperature0.attr,
291         &attr_ppe_temperature1.attr,
292         &attr_ppe_throttle_end.attr,
293         &attr_ppe_throttle_begin.attr,
294         &attr_ppe_throttle_full_stop.attr,
295         NULL,
296 };
297
298 static struct attribute_group ppe_attribute_group = {
299         .name   = "thermal",
300         .attrs  = ppe_attributes,
301 };
302
303 /*
304  * initialize throttling with default values
305  */
306 static int __init init_default_values(void)
307 {
308         int cpu;
309         struct cbe_pmd_regs __iomem *pmd_regs;
310         struct sys_device *sysdev;
311         union ppe_spe_reg tpr;
312         union spe_reg str1;
313         u64 str2;
314         union spe_reg cr1;
315         u64 cr2;
316
317         /* TPR defaults */
318         /* ppe
319          *      1F - no full stop
320          *      08 - dynamic throttling starts if over 80 degrees
321          *      03 - dynamic throttling ceases if below 70 degrees */
322         tpr.ppe = 0x1F0803;
323         /* spe
324          *      10 - full stopped when over 96 degrees
325          *      08 - dynamic throttling starts if over 80 degrees
326          *      03 - dynamic throttling ceases if below 70 degrees
327          */
328         tpr.spe = 0x100803;
329
330         /* STR defaults */
331         /* str1
332          *      10 - stop 16 of 32 cycles
333          */
334         str1.val = 0x1010101010101010ull;
335         /* str2
336          *      10 - stop 16 of 32 cycles
337          */
338         str2 = 0x10;
339
340         /* CR defaults */
341         /* cr1
342          *      4 - normal operation
343          */
344         cr1.val = 0x0404040404040404ull;
345         /* cr2
346          *      4 - normal operation
347          */
348         cr2 = 0x04;
349
350         for_each_possible_cpu (cpu) {
351                 pr_debug("processing cpu %d\n", cpu);
352                 sysdev = get_cpu_sysdev(cpu);
353
354                 if (!sysdev) {
355                         pr_info("invalid sysdev pointer for cbe_thermal\n");
356                         return -EINVAL;
357                 }
358
359                 pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);
360
361                 if (!pmd_regs) {
362                         pr_info("invalid CBE regs pointer for cbe_thermal\n");
363                         return -EINVAL;
364                 }
365
366                 out_be64(&pmd_regs->tm_str2, str2);
367                 out_be64(&pmd_regs->tm_str1.val, str1.val);
368                 out_be64(&pmd_regs->tm_tpr.val, tpr.val);
369                 out_be64(&pmd_regs->tm_cr1.val, cr1.val);
370                 out_be64(&pmd_regs->tm_cr2, cr2);
371         }
372
373         return 0;
374 }
375
376
377 static int __init thermal_init(void)
378 {
379         int rc = init_default_values();
380
381         if (rc == 0) {
382                 spu_add_sysdev_attr_group(&spu_attribute_group);
383                 cpu_add_sysdev_attr_group(&ppe_attribute_group);
384         }
385
386         return rc;
387 }
388 module_init(thermal_init);
389
390 static void __exit thermal_exit(void)
391 {
392         spu_remove_sysdev_attr_group(&spu_attribute_group);
393         cpu_remove_sysdev_attr_group(&ppe_attribute_group);
394 }
395 module_exit(thermal_exit);
396
397 MODULE_LICENSE("GPL");
398 MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
399