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/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)                 \
  63 struct device_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 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 */
  89 static 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(&reg->val);
  96
  97         return value.spe[spu->spe_id];
  98 }
  99
 100 static 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
 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 device *dev,
 151                         struct device_attribute *attr, char *buf)
 152 {
 153         return show_throttle(get_pmd_regs(dev), buf, 0);
 154 }
 155
 156 static 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
 162 static 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
 168 static 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
 174 static 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
 180 static 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
 186 static 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 */
 202 static 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 */
 209 static 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
 215 static 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
 221 static 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
 227 static 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
 233 static 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
 239 static 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
 245 static 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
 252 static struct device_attribute attr_spu_temperature = {
 253         .attr = {.name = "temperature", .mode = 0400 },
 254         .show = spu_show_temp,
 255 };
 256
 257 static DEVICE_PREFIX_ATTR(spu, throttle_end, 0600);
 258 static DEVICE_PREFIX_ATTR(spu, throttle_begin, 0600);
 259 static DEVICE_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 device_attribute attr_ppe_temperature0 = {
 276         .attr = {.name = "temperature0", .mode = 0400 },
 277         .show = ppe_show_temp0,
 278 };
 279
 280 static struct device_attribute attr_ppe_temperature1 = {
 281         .attr = {.name = "temperature1", .mode = 0400 },
 282         .show = ppe_show_temp1,
 283 };
 284
 285 static DEVICE_PREFIX_ATTR(ppe, throttle_end, 0600);
 286 static DEVICE_PREFIX_ATTR(ppe, throttle_begin, 0600);
 287 static DEVICE_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 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
 377 static 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 }
 388 module_init(thermal_init);
 389
 390 static 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 }
 395 module_exit(thermal_exit);
 396
 397 MODULE_LICENSE("GPL");
 398 MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
 399