linux/arch/powerpc/platforms/cell/cbe_thermal.c
<<
>>
Prefs
   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(&reg->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