[mirror_ubuntu-zesty-kernel.git] / arch / powerpc / platforms / cell / cbe_thermal.c

/*
 * thermal support for the cell processor
 *
 * (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 "cbe_regs.h"
#include "spu_priv1_mmio.h"

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)
{
	const unsigned int *id;
	union spe_reg value;
	struct spu *spu;

	/* getting the id from the reg attribute will not work on future device-tree layouts
	 * in future we should store the id to the spu struct and use it here */
	spu = container_of(sysdev, struct spu, sysdev);
	id = of_get_property(spu_devnode(spu), "reg", NULL);
	value.val = in_be64(&reg->val);

	return value.spe[*id];
}

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

	pmd_regs = get_pmd_regs(sysdev);

	value = spu_read_register_value(sysdev, &pmd_regs->ts_ctsr1);
	/* clear all other bits */
	value &= 0x3F;
	/* temp is stored in steps of 2 degrees */
	value *= 2;
	/* base temp is 65 degrees */
	value += 65;

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

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);

	/* access the corresponding byte */
	value >>= pos;
	/* clear all other bits */
	value &= 0x3F;
	/* temp is stored in steps of 2 degrees */
	value *= 2;
	/* base temp is 65 degrees */
	value += 65;

	return sprintf(buf, "%d\n", (int) 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, 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, char *buf)
{
	return ppe_show_temp(sysdev, buf, 0);
}

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

static struct attribute *spu_attributes[] = {
	&attr_spu_temperature.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 struct attribute *ppe_attributes[] = {
	&attr_ppe_temperature0.attr,
	&attr_ppe_temperature1.attr,
	NULL,
};

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

/*
 * initialize throttling with default values
 */
static void __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);
		pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);

		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);
	}
}


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

	spu_add_sysdev_attr_group(&spu_attribute_group);
	cpu_add_sysdev_attr_group(&ppe_attribute_group);

	return 0;
}
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	*
	4	* (C) Copyright IBM Deutschland Entwicklung GmbH 2005
	5	*
	6	* Author: Christian Krafft <krafft@de.ibm.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2, or (at your option)
	11	* any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	21	*/
	22
	23	#include <linux/module.h>
	24	#include <linux/sysdev.h>
	25	#include <linux/kernel.h>
	26	#include <linux/cpu.h>
	27	#include <asm/spu.h>
	28	#include <asm/io.h>
	29	#include <asm/prom.h>
	30
	31	#include "cbe_regs.h"
e28b0031	32	#include "spu_priv1_mmio.h"
b3d7dc19 CK	33
	34	static struct cbe_pmd_regs __iomem get_pmd_regs(struct sys_device sysdev)
	35	{
	36	struct spu *spu;
	37
	38	spu = container_of(sysdev, struct spu, sysdev);
	39
e28b0031	40	return cbe_get_pmd_regs(spu_devnode(spu));
b3d7dc19 CK	41	}
	42
	43	/* returns the value for a given spu in a given register */
	44	static u8 spu_read_register_value(struct sys_device sysdev, union spe_reg __iomem reg)
	45	{
e2eb6392	46	const unsigned int *id;
b3d7dc19 CK	47	union spe_reg value;
	48	struct spu *spu;
	49
	50	/* getting the id from the reg attribute will not work on future device-tree layouts
	51	* in future we should store the id to the spu struct and use it here */
	52	spu = container_of(sysdev, struct spu, sysdev);
e2eb6392	53	id = of_get_property(spu_devnode(spu), "reg", NULL);
b3d7dc19 CK	54	value.val = in_be64(&reg->val);
	55
	56	return value.spe[*id];
	57	}
	58
	59	static ssize_t spu_show_temp(struct sys_device sysdev, char buf)
	60	{
	61	int value;
	62	struct cbe_pmd_regs __iomem *pmd_regs;
	63
	64	pmd_regs = get_pmd_regs(sysdev);
	65
	66	value = spu_read_register_value(sysdev, &pmd_regs->ts_ctsr1);
	67	/* clear all other bits */
	68	value &= 0x3F;
	69	/* temp is stored in steps of 2 degrees */
	70	value *= 2;
	71	/* base temp is 65 degrees */
	72	value += 65;
	73
	74	return sprintf(buf, "%d\n", (int) value);
	75	}
	76
	77	static ssize_t ppe_show_temp(struct sys_device sysdev, char buf, int pos)
	78	{
	79	struct cbe_pmd_regs __iomem *pmd_regs;
	80	u64 value;
	81
	82	pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);
	83	value = in_be64(&pmd_regs->ts_ctsr2);
	84
	85	/* access the corresponding byte */
	86	value >>= pos;
	87	/* clear all other bits */
	88	value &= 0x3F;
	89	/* temp is stored in steps of 2 degrees */
	90	value *= 2;
	91	/* base temp is 65 degrees */
	92	value += 65;
	93
	94	return sprintf(buf, "%d\n", (int) value);
	95	}
	96
	97
	98	/* shows the temperature of the DTS on the PPE,
	99	* located near the linear thermal sensor */
	100	static ssize_t ppe_show_temp0(struct sys_device sysdev, char buf)
	101	{
	102	return ppe_show_temp(sysdev, buf, 32);
	103	}
	104
	105	/* shows the temperature of the second DTS on the PPE */
	106	static ssize_t ppe_show_temp1(struct sys_device sysdev, char buf)
	107	{
	108	return ppe_show_temp(sysdev, buf, 0);
	109	}
	110
	111	static struct sysdev_attribute attr_spu_temperature = {
	112	.attr = {.name = "temperature", .mode = 0400 },
	113	.show = spu_show_temp,
	114	};
	115
	116	static struct attribute *spu_attributes[] = {
	117	&attr_spu_temperature.attr,
22b6e590	118	NULL,
b3d7dc19 CK	119	};
	120
	121	static struct attribute_group spu_attribute_group = {
	122	.name = "thermal",
	123	.attrs = spu_attributes,
	124	};
	125
	126	static struct sysdev_attribute attr_ppe_temperature0 = {
	127	.attr = {.name = "temperature0", .mode = 0400 },
	128	.show = ppe_show_temp0,
	129	};
	130
	131	static struct sysdev_attribute attr_ppe_temperature1 = {
	132	.attr = {.name = "temperature1", .mode = 0400 },
	133	.show = ppe_show_temp1,
	134	};
	135
	136	static struct attribute *ppe_attributes[] = {
	137	&attr_ppe_temperature0.attr,
	138	&attr_ppe_temperature1.attr,
22b6e590	139	NULL,
b3d7dc19 CK	140	};
	141
	142	static struct attribute_group ppe_attribute_group = {
	143	.name = "thermal",
	144	.attrs = ppe_attributes,
	145	};
	146
	147	/*
	148	* initialize throttling with default values
	149	*/
	150	static void __init init_default_values(void)
	151	{
	152	int cpu;
	153	struct cbe_pmd_regs __iomem *pmd_regs;
	154	struct sys_device *sysdev;
	155	union ppe_spe_reg tpr;
	156	union spe_reg str1;
	157	u64 str2;
	158	union spe_reg cr1;
	159	u64 cr2;
	160
	161	/* TPR defaults */
	162	/* ppe
	163	* 1F - no full stop
	164	* 08 - dynamic throttling starts if over 80 degrees
	165	* 03 - dynamic throttling ceases if below 70 degrees */
	166	tpr.ppe = 0x1F0803;
	167	/* spe
	168	* 10 - full stopped when over 96 degrees
	169	* 08 - dynamic throttling starts if over 80 degrees
	170	* 03 - dynamic throttling ceases if below 70 degrees
	171	*/
	172	tpr.spe = 0x100803;
	173
	174	/* STR defaults */
	175	/* str1
	176	* 10 - stop 16 of 32 cycles
	177	*/
	178	str1.val = 0x1010101010101010ull;
	179	/* str2
	180	* 10 - stop 16 of 32 cycles
	181	*/
	182	str2 = 0x10;
	183
	184	/* CR defaults */
	185	/* cr1
	186	* 4 - normal operation
	187	*/
	188	cr1.val = 0x0404040404040404ull;
	189	/* cr2
	190	* 4 - normal operation
	191	*/
	192	cr2 = 0x04;
	193
	194	for_each_possible_cpu (cpu) {
	195	pr_debug("processing cpu %d\n", cpu);
	196	sysdev = get_cpu_sysdev(cpu);
	197	pmd_regs = cbe_get_cpu_pmd_regs(sysdev->id);
	198
	199	out_be64(&pmd_regs->tm_str2, str2);
	200	out_be64(&pmd_regs->tm_str1.val, str1.val);
	201	out_be64(&pmd_regs->tm_tpr.val, tpr.val);
	202	out_be64(&pmd_regs->tm_cr1.val, cr1.val);
	203	out_be64(&pmd_regs->tm_cr2, cr2);
204	}
205	}
206
207
208	static int __init thermal_init(void)
209	{
210	init_default_values();
211
212	spu_add_sysdev_attr_group(&spu_attribute_group);
213	cpu_add_sysdev_attr_group(&ppe_attribute_group);
214
215	return 0;
216	}
217	module_init(thermal_init);
218
219	static void __exit thermal_exit(void)
220	{
221	spu_remove_sysdev_attr_group(&spu_attribute_group);
222	cpu_remove_sysdev_attr_group(&ppe_attribute_group);
223	}
224	module_exit(thermal_exit);
225
226	MODULE_LICENSE("GPL");
227	MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");
228