[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / arch / powerpc / platforms / cell / cbe_thermal.c

/*
 * thermal support for the cell processor
 *
 * This module adds some sysfs attributes to cpu and spu nodes.
 * Base for measurements are the digital thermal sensors (DTS)
 * located on the chip.
 * The accuracy is 2 degrees, starting from 65 up to 125 degrees celsius
 * The attributes can be found under
 * /sys/devices/system/cpu/cpuX/thermal
 * /sys/devices/system/spu/spuX/thermal
 *
 * The following attributes are added for each node:
 * temperature:
 *	contains the current temperature measured by the DTS
 * throttle_begin:
 *	throttling begins when temperature is greater or equal to
 *	throttle_begin. Setting this value to 125 prevents throttling.
 * throttle_end:
 *	throttling is being ceased, if the temperature is lower than
 *	throttle_end. Due to a delay between applying throttling and
 *	a reduced temperature this value should be less than throttle_begin.
 *	A value equal to throttle_begin provides only a very little hysteresis.
 * throttle_full_stop:
 *	If the temperatrue is greater or equal to throttle_full_stop,
 *	full throttling is applied to the cpu or spu. This value should be
 *	greater than throttle_begin and throttle_end. Setting this value to
 *	65 prevents the unit from running code at all.
 *
 * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
 *
 * Author: Christian Krafft <krafft@de.ibm.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/module.h>
#include <linux/sysdev.h>
#include <linux/kernel.h>
#include <linux/cpu.h>
#include <asm/spu.h>
#include <asm/io.h>
#include <asm/prom.h>
#include <asm/cell-regs.h>

#include "spu_priv1_mmio.h"

#define TEMP_MIN 65
#define TEMP_MAX 125

#define SYSDEV_PREFIX_ATTR(_prefix,_name,_mode)			\
struct sysdev_attribute attr_ ## _prefix ## _ ## _name = {	\
	.attr = { .name = __stringify(_name), .mode = _mode },	\
	.show	= _prefix ## _show_ ## _name,			\
	.store	= _prefix ## _store_ ## _name,			\
};

static inline u8 reg_to_temp(u8 reg_value)
{
	return ((reg_value & 0x3f) << 1) + TEMP_MIN;
}

static inline u8 temp_to_reg(u8 temp)
{
	return ((temp - TEMP_MIN) >> 1) & 0x3f;
}

static struct cbe_pmd_regs __iomem *get_pmd_regs(struct sys_device *sysdev)
{
	struct spu *spu;

	spu = container_of(sysdev, struct spu, sysdev);

	return cbe_get_pmd_regs(spu_devnode(spu));
}

/* returns the value for a given spu in a given register */
static u8 spu_read_register_value(struct sys_device *sysdev, union spe_reg __iomem *reg)
{
	union spe_reg value;
	struct spu *spu;

	spu = container_of(sysdev, struct spu, sysdev);
	value.val = in_be64(&reg->val);

	return value.spe[spu->spe_id];
}

static ssize_t spu_show_temp(struct sys_device *sysdev, struct sysdev_attribute *attr,
			char *buf)
{
	u8 value;
	struct cbe_pmd_regs __iomem *pmd_regs;

	pmd_regs = get_pmd_regs(sysdev);

	value = spu_read_register_value(sysdev, &pmd_regs->ts_ctsr1);

	return sprintf(buf, "%d\n", reg_to_temp(value));
}

static ssize_t show_throttle(struct cbe_pmd_regs __iomem *pmd_regs, char *buf, int pos)
{
	u64 value;

	value = in_be64(&pmd_regs->tm_tpr.val);
	/* access the corresponding byte */
	value >>= pos;
	value &= 0x3F;

	return sprintf(buf, "%d\n", reg_to_temp(value));
}

static ssize_t store_throttle(struct cbe_pmd_regs __iomem *pmd_regs, const char *buf, size_t size, int pos)
{
	u64 reg_value;
	int temp;
	u64 new_value;
	int ret;

	ret = sscanf(buf, "%u", &temp);

	if (ret != 1 || temp < TEMP_MIN || temp > TEMP_MAX)
		return -EINVAL;

	new_value = temp_to_reg(temp);

	reg_value = in_be64(&pmd_regs->tm_tpr.val);

	/* zero out bits for new value */
	reg_value &= ~(0xffull << pos);
	/* set bits to new value */
	reg_value |= new_value << pos;

	out_be64(&pmd_regs->tm_tpr.val, reg_value);
	return size;
}

static ssize_t spu_show_throttle_end(struct sys_device *sysdev,
			struct sysdev_attribute *attr, char *buf)
{
	return show_throttle(get_pmd_regs(sysdev), buf, 0);
}

static ssize_t spu_show_throttle_begin(struct sys_device *sysdev,
			struct sysdev_attribute *attr, char *buf)
{
	return show_throttle(get_pmd_regs(sysdev), buf, 8);
}

static ssize_t spu_show_throttle_full_stop(struct sys_device *sysdev,
			struct sysdev_attribute *attr, char *buf)
{
	return show_throttle(get_pmd_regs(sysdev), buf, 16);
}

static ssize_t spu_store_throttle_end(struct sys_device *sysdev,
			struct sysdev_attribute *attr, const char *buf, size_t size)
{
	return store_throttle(get_pmd_regs(sysdev), buf, size, 0);
}

static ssize_t spu_store_throttle_begin(struct sys_device *sysdev,
			struct sysdev_attribute *attr, const char *buf, size_t size)
{
	return store_throttle(get_pmd_regs(sysdev), buf, size, 8);
}

static ssize_t spu_store_throttle_full_stop(struct sys_device *sysdev,
			struct sysdev_attribute *attr, const char *buf, size_t size)
{
	return store_throttle(get_pmd_regs(sysdev), buf, size, 16);
}

static ssize_t ppe_show_temp(struct sys_device *sysdev, char *buf, int pos)
{
	struct cbe_pmd_regs __iomem *pmd_regs;
	u64 value;

	pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);
	value = in_be64(&pmd_regs->ts_ctsr2);

	value = (value >> pos) & 0x3f;

	return sprintf(buf, "%d\n", reg_to_temp(value));
}


/* shows the temperature of the DTS on the PPE,
 * located near the linear thermal sensor */
static ssize_t ppe_show_temp0(struct sys_device *sysdev,
			struct sysdev_attribute *attr, char *buf)
{
	return ppe_show_temp(sysdev, buf, 32);
}

/* shows the temperature of the second DTS on the PPE */
static ssize_t ppe_show_temp1(struct sys_device *sysdev,
			struct sysdev_attribute *attr, char *buf)
{
	return ppe_show_temp(sysdev, buf, 0);
}

static ssize_t ppe_show_throttle_end(struct sys_device *sysdev,
			struct sysdev_attribute *attr, char *buf)
{
	return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 32);
}

static ssize_t ppe_show_throttle_begin(struct sys_device *sysdev,
			struct sysdev_attribute *attr, char *buf)
{
	return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 40);
}

static ssize_t ppe_show_throttle_full_stop(struct sys_device *sysdev,
			struct sysdev_attribute *attr, char *buf)
{
	return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 48);
}

static ssize_t ppe_store_throttle_end(struct sys_device *sysdev,
			struct sysdev_attribute *attr, const char *buf, size_t size)
{
	return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 32);
}

static ssize_t ppe_store_throttle_begin(struct sys_device *sysdev,
			struct sysdev_attribute *attr, const char *buf, size_t size)
{
	return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 40);
}

static ssize_t ppe_store_throttle_full_stop(struct sys_device *sysdev,
			struct sysdev_attribute *attr, const char *buf, size_t size)
{
	return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 48);
}


static struct sysdev_attribute attr_spu_temperature = {
	.attr = {.name = "temperature", .mode = 0400 },
	.show = spu_show_temp,
};

static SYSDEV_PREFIX_ATTR(spu, throttle_end, 0600);
static SYSDEV_PREFIX_ATTR(spu, throttle_begin, 0600);
static SYSDEV_PREFIX_ATTR(spu, throttle_full_stop, 0600);


static struct attribute *spu_attributes[] = {
	&attr_spu_temperature.attr,
	&attr_spu_throttle_end.attr,
	&attr_spu_throttle_begin.attr,
	&attr_spu_throttle_full_stop.attr,
	NULL,
};

static struct attribute_group spu_attribute_group = {
	.name	= "thermal",
	.attrs	= spu_attributes,
};

static struct sysdev_attribute attr_ppe_temperature0 = {
	.attr = {.name = "temperature0", .mode = 0400 },
	.show = ppe_show_temp0,
};

static struct sysdev_attribute attr_ppe_temperature1 = {
	.attr = {.name = "temperature1", .mode = 0400 },
	.show = ppe_show_temp1,
};

static SYSDEV_PREFIX_ATTR(ppe, throttle_end, 0600);
static SYSDEV_PREFIX_ATTR(ppe, throttle_begin, 0600);
static SYSDEV_PREFIX_ATTR(ppe, throttle_full_stop, 0600);

static struct attribute *ppe_attributes[] = {
	&attr_ppe_temperature0.attr,
	&attr_ppe_temperature1.attr,
	&attr_ppe_throttle_end.attr,
	&attr_ppe_throttle_begin.attr,
	&attr_ppe_throttle_full_stop.attr,
	NULL,
};

static struct attribute_group ppe_attribute_group = {
	.name	= "thermal",
	.attrs	= ppe_attributes,
};

/*
 * initialize throttling with default values
 */
static int __init init_default_values(void)
{
	int cpu;
	struct cbe_pmd_regs __iomem *pmd_regs;
	struct sys_device *sysdev;
	union ppe_spe_reg tpr;
	union spe_reg str1;
	u64 str2;
	union spe_reg cr1;
	u64 cr2;

	/* TPR defaults */
	/* ppe
	 *	1F - no full stop
	 *	08 - dynamic throttling starts if over 80 degrees
	 *	03 - dynamic throttling ceases if below 70 degrees */
	tpr.ppe = 0x1F0803;
	/* spe
	 *	10 - full stopped when over 96 degrees
	 *	08 - dynamic throttling starts if over 80 degrees
	 *	03 - dynamic throttling ceases if below 70 degrees
	 */
	tpr.spe = 0x100803;

	/* STR defaults */
	/* str1
	 *	10 - stop 16 of 32 cycles
	 */
	str1.val = 0x1010101010101010ull;
	/* str2
	 *	10 - stop 16 of 32 cycles
	 */
	str2 = 0x10;

	/* CR defaults */
	/* cr1
	 *	4 - normal operation
	 */
	cr1.val = 0x0404040404040404ull;
	/* cr2
	 *	4 - normal operation
	 */
	cr2 = 0x04;

	for_each_possible_cpu (cpu) {
		pr_debug("processing cpu %d\n", cpu);
		sysdev = get_cpu_sysdev(cpu);

		if (!sysdev) {
			pr_info("invalid sysdev pointer for cbe_thermal\n");
			return -EINVAL;
		}

		pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);

		if (!pmd_regs) {
			pr_info("invalid CBE regs pointer for cbe_thermal\n");
			return -EINVAL;
		}

		out_be64(&pmd_regs->tm_str2, str2);
		out_be64(&pmd_regs->tm_str1.val, str1.val);
		out_be64(&pmd_regs->tm_tpr.val, tpr.val);
		out_be64(&pmd_regs->tm_cr1.val, cr1.val);
		out_be64(&pmd_regs->tm_cr2, cr2);
	}

	return 0;
}


static int __init thermal_init(void)
{
	int rc = init_default_values();

	if (rc == 0) {
		spu_add_sysdev_attr_group(&spu_attribute_group);
		cpu_add_sysdev_attr_group(&ppe_attribute_group);
	}

	return rc;
}
module_init(thermal_init);

static void __exit thermal_exit(void)
{
	spu_remove_sysdev_attr_group(&spu_attribute_group);
	cpu_remove_sysdev_attr_group(&ppe_attribute_group);
}
module_exit(thermal_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
Commit	Line	Data
b3d7dc19 CK	1	/*
	2	* thermal support for the cell processor
	3	*
5f7bdaee CK	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	*
b3d7dc19 CK	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>
eef686a0	55	#include <asm/cell-regs.h>
b3d7dc19	56
e28b0031	57	#include "spu_priv1_mmio.h"
b3d7dc19	58
5f7bdaee CK	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
24d560d7 CK	69	static inline u8 reg_to_temp(u8 reg_value)
24d560d7 CK	70	{
5f7bdaee CK	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;
24d560d7 CK	77	}
24d560d7 CK	78
b3d7dc19 CK	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
e28b0031	85	return cbe_get_pmd_regs(spu_devnode(spu));
b3d7dc19 CK	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	{
b3d7dc19 CK	91	union spe_reg value;
	92	struct spu *spu;
	93
b3d7dc19	94	spu = container_of(sysdev, struct spu, sysdev);
b3d7dc19 CK	95	value.val = in_be64(&reg->val);
b3d7dc19 CK	96
fa7f374b	97	return value.spe[spu->spe_id];
b3d7dc19 CK	98	}
b3d7dc19 CK	99
4a0b2b4d AK	100	static ssize_t spu_show_temp(struct sys_device sysdev, struct sysdev_attribute attr,
4a0b2b4d AK	101	char *buf)
b3d7dc19	102	{
24d560d7	103	u8 value;
b3d7dc19 CK	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);
24d560d7 CK	109
24d560d7 CK	110	return sprintf(buf, "%d\n", reg_to_temp(value));
b3d7dc19 CK	111	}
b3d7dc19 CK	112
5f7bdaee CK	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
4a0b2b4d AK	150	static ssize_t spu_show_throttle_end(struct sys_device *sysdev,
4a0b2b4d AK	151	struct sysdev_attribute attr, char buf)
5f7bdaee CK	152	{
	153	return show_throttle(get_pmd_regs(sysdev), buf, 0);
	154	}
	155
4a0b2b4d AK	156	static ssize_t spu_show_throttle_begin(struct sys_device *sysdev,
4a0b2b4d AK	157	struct sysdev_attribute attr, char buf)
5f7bdaee CK	158	{
	159	return show_throttle(get_pmd_regs(sysdev), buf, 8);
	160	}
	161
4a0b2b4d AK	162	static ssize_t spu_show_throttle_full_stop(struct sys_device *sysdev,
4a0b2b4d AK	163	struct sysdev_attribute attr, char buf)
5f7bdaee CK	164	{
	165	return show_throttle(get_pmd_regs(sysdev), buf, 16);
	166	}
	167
4a0b2b4d AK	168	static ssize_t spu_store_throttle_end(struct sys_device *sysdev,
4a0b2b4d AK	169	struct sysdev_attribute attr, const char buf, size_t size)
5f7bdaee CK	170	{
	171	return store_throttle(get_pmd_regs(sysdev), buf, size, 0);
	172	}
	173
4a0b2b4d AK	174	static ssize_t spu_store_throttle_begin(struct sys_device *sysdev,
4a0b2b4d AK	175	struct sysdev_attribute attr, const char buf, size_t size)
5f7bdaee CK	176	{
	177	return store_throttle(get_pmd_regs(sysdev), buf, size, 8);
	178	}
	179
4a0b2b4d AK	180	static ssize_t spu_store_throttle_full_stop(struct sys_device *sysdev,
4a0b2b4d AK	181	struct sysdev_attribute attr, const char buf, size_t size)
5f7bdaee CK	182	{
	183	return store_throttle(get_pmd_regs(sysdev), buf, size, 16);
	184	}
	185
b3d7dc19 CK	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
24d560d7	194	value = (value >> pos) & 0x3f;
b3d7dc19	195
24d560d7	196	return sprintf(buf, "%d\n", reg_to_temp(value));
b3d7dc19 CK	197	}
	198
	199
	200	/* shows the temperature of the DTS on the PPE,
	201	* located near the linear thermal sensor */
4a0b2b4d AK	202	static ssize_t ppe_show_temp0(struct sys_device *sysdev,
4a0b2b4d AK	203	struct sysdev_attribute attr, char buf)
b3d7dc19 CK	204	{
	205	return ppe_show_temp(sysdev, buf, 32);
	206	}
	207
	208	/* shows the temperature of the second DTS on the PPE */
4a0b2b4d AK	209	static ssize_t ppe_show_temp1(struct sys_device *sysdev,
4a0b2b4d AK	210	struct sysdev_attribute attr, char buf)
b3d7dc19 CK	211	{
	212	return ppe_show_temp(sysdev, buf, 0);
	213	}
	214
4a0b2b4d AK	215	static ssize_t ppe_show_throttle_end(struct sys_device *sysdev,
4a0b2b4d AK	216	struct sysdev_attribute attr, char buf)
5f7bdaee CK	217	{
	218	return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 32);
	219	}
	220
4a0b2b4d AK	221	static ssize_t ppe_show_throttle_begin(struct sys_device *sysdev,
4a0b2b4d AK	222	struct sysdev_attribute attr, char buf)
5f7bdaee CK	223	{
	224	return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 40);
	225	}
	226
4a0b2b4d AK	227	static ssize_t ppe_show_throttle_full_stop(struct sys_device *sysdev,
4a0b2b4d AK	228	struct sysdev_attribute attr, char buf)
5f7bdaee CK	229	{
	230	return show_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, 48);
	231	}
	232
4a0b2b4d AK	233	static ssize_t ppe_store_throttle_end(struct sys_device *sysdev,
4a0b2b4d AK	234	struct sysdev_attribute attr, const char buf, size_t size)
5f7bdaee CK	235	{
	236	return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 32);
	237	}
	238
4a0b2b4d AK	239	static ssize_t ppe_store_throttle_begin(struct sys_device *sysdev,
4a0b2b4d AK	240	struct sysdev_attribute attr, const char buf, size_t size)
5f7bdaee CK	241	{
	242	return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 40);
	243	}
	244
4a0b2b4d AK	245	static ssize_t ppe_store_throttle_full_stop(struct sys_device *sysdev,
4a0b2b4d AK	246	struct sysdev_attribute attr, const char buf, size_t size)
5f7bdaee CK	247	{
	248	return store_throttle(cbe_get_cpu_pmd_regs(sysdev->id), buf, size, 48);
	249	}
	250
	251
b3d7dc19 CK	252	static struct sysdev_attribute attr_spu_temperature = {
	253	.attr = {.name = "temperature", .mode = 0400 },
	254	.show = spu_show_temp,
	255	};
	256
5f7bdaee CK	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
b3d7dc19 CK	262	static struct attribute *spu_attributes[] = {
b3d7dc19 CK	263	&attr_spu_temperature.attr,
5f7bdaee CK	264	&attr_spu_throttle_end.attr,
	265	&attr_spu_throttle_begin.attr,
	266	&attr_spu_throttle_full_stop.attr,
22b6e590	267	NULL,
b3d7dc19 CK	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
5f7bdaee CK	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
b3d7dc19 CK	289	static struct attribute *ppe_attributes[] = {
	290	&attr_ppe_temperature0.attr,
	291	&attr_ppe_temperature1.attr,
5f7bdaee CK	292	&attr_ppe_throttle_end.attr,
	293	&attr_ppe_throttle_begin.attr,
	294	&attr_ppe_throttle_full_stop.attr,
22b6e590	295	NULL,
b3d7dc19 CK	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	*/
827e3648	306	static int __init init_default_values(void)
b3d7dc19 CK	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);
827e3648 JCD	353
	354	if (!sysdev) {
	355	pr_info("invalid sysdev pointer for cbe_thermal\n");
	356	return -EINVAL;
	357	}
	358
b3d7dc19 CK	359	pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);
b3d7dc19 CK	360
827e3648 JCD	361	if (!pmd_regs) {
	362	pr_info("invalid CBE regs pointer for cbe_thermal\n");
	363	return -EINVAL;
	364	}
	365
b3d7dc19 CK	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	}
827e3648 JCD	372
827e3648 JCD	373	return 0;
b3d7dc19 CK	374	}
	375
	376
	377	static int __init thermal_init(void)
	378	{
827e3648	379	int rc = init_default_values();
b3d7dc19	380
827e3648 JCD	381	if (rc == 0) {
	382	spu_add_sysdev_attr_group(&spu_attribute_group);
	383	cpu_add_sysdev_attr_group(&ppe_attribute_group);
	384	}
b3d7dc19	385
827e3648	386	return rc;
b3d7dc19 CK	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