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 <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 DEVICE_PREFIX_ATTR(_prefix,_name,_mode) \ 63struct device_attribute attr_ ## _prefix ## _ ## _name = { \ 64 .attr = { .name = __stringify(_name), .mode = _mode }, \ 65 .show = _prefix ## _show_ ## _name, \ 66 .store = _prefix ## _store_ ## _name, \ 67}; 68 69static inline u8 reg_to_temp(u8 reg_value) 70{ 71 return ((reg_value & 0x3f) << 1) + TEMP_MIN; 72} 73 74static inline u8 temp_to_reg(u8 temp) 75{ 76 return ((temp - TEMP_MIN) >> 1) & 0x3f; 77} 78 79static struct cbe_pmd_regs __iomem *get_pmd_regs(struct device *dev) 80{ 81 struct spu *spu; 82 83 spu = container_of(dev, struct spu, dev); 84 85 return cbe_get_pmd_regs(spu_devnode(spu)); 86} 87 88/* returns the value for a given spu in a given register */ 89static u8 spu_read_register_value(struct device *dev, union spe_reg __iomem *reg) 90{ 91 union spe_reg value; 92 struct spu *spu; 93 94 spu = container_of(dev, struct spu, dev); 95 value.val = in_be64(®->val); 96 97 return value.spe[spu->spe_id]; 98} 99 100static ssize_t spu_show_temp(struct device *dev, struct device_attribute *attr, 101 char *buf) 102{ 103 u8 value; 104 struct cbe_pmd_regs __iomem *pmd_regs; 105 106 pmd_regs = get_pmd_regs(dev); 107 108 value = spu_read_register_value(dev, &pmd_regs->ts_ctsr1); 109 110 return sprintf(buf, "%d\n", reg_to_temp(value)); 111} 112 113static 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 125static 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 unsigned 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 150static ssize_t spu_show_throttle_end(struct device *dev, 151 struct device_attribute *attr, char *buf) 152{ 153 return show_throttle(get_pmd_regs(dev), buf, 0); 154} 155 156static ssize_t spu_show_throttle_begin(struct device *dev, 157 struct device_attribute *attr, char *buf) 158{ 159 return show_throttle(get_pmd_regs(dev), buf, 8); 160} 161 162static ssize_t spu_show_throttle_full_stop(struct device *dev, 163 struct device_attribute *attr, char *buf) 164{ 165 return show_throttle(get_pmd_regs(dev), buf, 16); 166} 167 168static ssize_t spu_store_throttle_end(struct device *dev, 169 struct device_attribute *attr, const char *buf, size_t size) 170{ 171 return store_throttle(get_pmd_regs(dev), buf, size, 0); 172} 173 174static ssize_t spu_store_throttle_begin(struct device *dev, 175 struct device_attribute *attr, const char *buf, size_t size) 176{ 177 return store_throttle(get_pmd_regs(dev), buf, size, 8); 178} 179 180static ssize_t spu_store_throttle_full_stop(struct device *dev, 181 struct device_attribute *attr, const char *buf, size_t size) 182{ 183 return store_throttle(get_pmd_regs(dev), buf, size, 16); 184} 185 186static ssize_t ppe_show_temp(struct device *dev, 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(dev->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 */ 202static ssize_t ppe_show_temp0(struct device *dev, 203 struct device_attribute *attr, char *buf) 204{ 205 return ppe_show_temp(dev, buf, 32); 206} 207 208/* shows the temperature of the second DTS on the PPE */ 209static ssize_t ppe_show_temp1(struct device *dev, 210 struct device_attribute *attr, char *buf) 211{ 212 return ppe_show_temp(dev, buf, 0); 213} 214 215static ssize_t ppe_show_throttle_end(struct device *dev, 216 struct device_attribute *attr, char *buf) 217{ 218 return show_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, 32); 219} 220 221static ssize_t ppe_show_throttle_begin(struct device *dev, 222 struct device_attribute *attr, char *buf) 223{ 224 return show_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, 40); 225} 226 227static ssize_t ppe_show_throttle_full_stop(struct device *dev, 228 struct device_attribute *attr, char *buf) 229{ 230 return show_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, 48); 231} 232 233static ssize_t ppe_store_throttle_end(struct device *dev, 234 struct device_attribute *attr, const char *buf, size_t size) 235{ 236 return store_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, size, 32); 237} 238 239static ssize_t ppe_store_throttle_begin(struct device *dev, 240 struct device_attribute *attr, const char *buf, size_t size) 241{ 242 return store_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, size, 40); 243} 244 245static ssize_t ppe_store_throttle_full_stop(struct device *dev, 246 struct device_attribute *attr, const char *buf, size_t size) 247{ 248 return store_throttle(cbe_get_cpu_pmd_regs(dev->id), buf, size, 48); 249} 250 251 252static struct device_attribute attr_spu_temperature = { 253 .attr = {.name = "temperature", .mode = 0400 }, 254 .show = spu_show_temp, 255}; 256 257static DEVICE_PREFIX_ATTR(spu, throttle_end, 0600); 258static DEVICE_PREFIX_ATTR(spu, throttle_begin, 0600); 259static DEVICE_PREFIX_ATTR(spu, throttle_full_stop, 0600); 260 261 262static 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 270static struct attribute_group spu_attribute_group = { 271 .name = "thermal", 272 .attrs = spu_attributes, 273}; 274 275static struct device_attribute attr_ppe_temperature0 = { 276 .attr = {.name = "temperature0", .mode = 0400 }, 277 .show = ppe_show_temp0, 278}; 279 280static struct device_attribute attr_ppe_temperature1 = { 281 .attr = {.name = "temperature1", .mode = 0400 }, 282 .show = ppe_show_temp1, 283}; 284 285static DEVICE_PREFIX_ATTR(ppe, throttle_end, 0600); 286static DEVICE_PREFIX_ATTR(ppe, throttle_begin, 0600); 287static DEVICE_PREFIX_ATTR(ppe, throttle_full_stop, 0600); 288 289static 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 298static struct attribute_group ppe_attribute_group = { 299 .name = "thermal", 300 .attrs = ppe_attributes, 301}; 302 303/* 304 * initialize throttling with default values 305 */ 306static int __init init_default_values(void) 307{ 308 int cpu; 309 struct cbe_pmd_regs __iomem *pmd_regs; 310 struct device *dev; 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 dev = get_cpu_device(cpu); 353 354 if (!dev) { 355 pr_info("invalid dev pointer for cbe_thermal\n"); 356 return -EINVAL; 357 } 358 359 pmd_regs = cbe_get_cpu_pmd_regs(dev->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 377static int __init thermal_init(void) 378{ 379 int rc = init_default_values(); 380 381 if (rc == 0) { 382 spu_add_dev_attr_group(&spu_attribute_group); 383 cpu_add_dev_attr_group(&ppe_attribute_group); 384 } 385 386 return rc; 387} 388module_init(thermal_init); 389 390static void __exit thermal_exit(void) 391{ 392 spu_remove_dev_attr_group(&spu_attribute_group); 393 cpu_remove_dev_attr_group(&ppe_attribute_group); 394} 395module_exit(thermal_exit); 396 397MODULE_LICENSE("GPL"); 398MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>"); 399 400