[linux-2.6-block.git] / drivers / acpi / processor_thermal.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * processor_thermal.c - Passive cooling submodule of the ACPI processor driver
 *
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
 *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
 *  			- Added processor hotplug support
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/cpufreq.h>
#include <linux/acpi.h>
#include <acpi/processor.h>
#include <linux/uaccess.h>

#include "internal.h"

#ifdef CONFIG_CPU_FREQ

/* If a passive cooling situation is detected, primarily CPUfreq is used, as it
 * offers (in most cases) voltage scaling in addition to frequency scaling, and
 * thus a cubic (instead of linear) reduction of energy. Also, we allow for
 * _any_ cpufreq driver and not only the acpi-cpufreq driver.
 */

#define CPUFREQ_THERMAL_MIN_STEP 0

static int cpufreq_thermal_max_step __read_mostly = 3;

/*
 * Minimum throttle percentage for processor_thermal cooling device.
 * The processor_thermal driver uses it to calculate the percentage amount by
 * which cpu frequency must be reduced for each cooling state. This is also used
 * to calculate the maximum number of throttling steps or cooling states.
 */
static int cpufreq_thermal_reduction_pctg __read_mostly = 20;

static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_step);

#define reduction_step(cpu) \
	per_cpu(cpufreq_thermal_reduction_step, phys_package_first_cpu(cpu))

/*
 * Emulate "per package data" using per cpu data (which should really be
 * provided elsewhere)
 *
 * Note we can lose a CPU on cpu hotunplug, in this case we forget the state
 * temporarily. Fortunately that's not a big issue here (I hope)
 */
static int phys_package_first_cpu(int cpu)
{
	int i;
	int id = topology_physical_package_id(cpu);

	for_each_online_cpu(i)
		if (topology_physical_package_id(i) == id)
			return i;
	return 0;
}

static int cpu_has_cpufreq(unsigned int cpu)
{
	struct cpufreq_policy *policy;

	if (!acpi_processor_cpufreq_init)
		return 0;

	policy = cpufreq_cpu_get(cpu);
	if (policy) {
		cpufreq_cpu_put(policy);
		return 1;
	}
	return 0;
}

static int cpufreq_get_max_state(unsigned int cpu)
{
	if (!cpu_has_cpufreq(cpu))
		return 0;

	return cpufreq_thermal_max_step;
}

static int cpufreq_get_cur_state(unsigned int cpu)
{
	if (!cpu_has_cpufreq(cpu))
		return 0;

	return reduction_step(cpu);
}

static int cpufreq_set_cur_state(unsigned int cpu, int state)
{
	struct cpufreq_policy *policy;
	struct acpi_processor *pr;
	unsigned long max_freq;
	int i, ret;

	if (!cpu_has_cpufreq(cpu))
		return 0;

	reduction_step(cpu) = state;

	/*
	 * Update all the CPUs in the same package because they all
	 * contribute to the temperature and often share the same
	 * frequency.
	 */
	for_each_online_cpu(i) {
		if (topology_physical_package_id(i) !=
		    topology_physical_package_id(cpu))
			continue;

		pr = per_cpu(processors, i);

		if (unlikely(!freq_qos_request_active(&pr->thermal_req)))
			continue;

		policy = cpufreq_cpu_get(i);
		if (!policy)
			return -EINVAL;

		max_freq = (policy->cpuinfo.max_freq *
			    (100 - reduction_step(i) * cpufreq_thermal_reduction_pctg)) / 100;

		cpufreq_cpu_put(policy);

		ret = freq_qos_update_request(&pr->thermal_req, max_freq);
		if (ret < 0) {
			pr_warn("Failed to update thermal freq constraint: CPU%d (%d)\n",
				pr->id, ret);
		}
	}
	return 0;
}

static void acpi_thermal_cpufreq_config(void)
{
	int cpufreq_pctg = acpi_arch_thermal_cpufreq_pctg();

	if (!cpufreq_pctg)
		return;

	cpufreq_thermal_reduction_pctg = cpufreq_pctg;

	/*
	 * Derive the MAX_STEP from minimum throttle percentage so that the reduction
	 * percentage doesn't end up becoming negative. Also, cap the MAX_STEP so that
	 * the CPU performance doesn't become 0.
	 */
	cpufreq_thermal_max_step = (100 / cpufreq_pctg) - 2;
}

void acpi_thermal_cpufreq_init(struct cpufreq_policy *policy)
{
	unsigned int cpu;

	acpi_thermal_cpufreq_config();

	for_each_cpu(cpu, policy->related_cpus) {
		struct acpi_processor *pr = per_cpu(processors, cpu);
		int ret;

		if (!pr)
			continue;

		ret = freq_qos_add_request(&policy->constraints,
					   &pr->thermal_req,
					   FREQ_QOS_MAX, INT_MAX);
		if (ret < 0) {
			pr_err("Failed to add freq constraint for CPU%d (%d)\n",
			       cpu, ret);
			continue;
		}

		thermal_cooling_device_update(pr->cdev);
	}
}

void acpi_thermal_cpufreq_exit(struct cpufreq_policy *policy)
{
	unsigned int cpu;

	for_each_cpu(cpu, policy->related_cpus) {
		struct acpi_processor *pr = per_cpu(processors, cpu);

		if (!pr)
			continue;

		freq_qos_remove_request(&pr->thermal_req);

		thermal_cooling_device_update(pr->cdev);
	}
}
#else				/* ! CONFIG_CPU_FREQ */
static int cpufreq_get_max_state(unsigned int cpu)
{
	return 0;
}

static int cpufreq_get_cur_state(unsigned int cpu)
{
	return 0;
}

static int cpufreq_set_cur_state(unsigned int cpu, int state)
{
	return 0;
}

#endif

/* thermal cooling device callbacks */
static int acpi_processor_max_state(struct acpi_processor *pr)
{
	int max_state = 0;

	/*
	 * There exists four states according to
	 * cpufreq_thermal_reduction_step. 0, 1, 2, 3
	 */
	max_state += cpufreq_get_max_state(pr->id);
	if (pr->flags.throttling)
		max_state += (pr->throttling.state_count -1);

	return max_state;
}
static int
processor_get_max_state(struct thermal_cooling_device *cdev,
			unsigned long *state)
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_processor *pr;

	if (!device)
		return -EINVAL;

	pr = acpi_driver_data(device);
	if (!pr)
		return -EINVAL;

	*state = acpi_processor_max_state(pr);
	return 0;
}

static int
processor_get_cur_state(struct thermal_cooling_device *cdev,
			unsigned long *cur_state)
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_processor *pr;

	if (!device)
		return -EINVAL;

	pr = acpi_driver_data(device);
	if (!pr)
		return -EINVAL;

	*cur_state = cpufreq_get_cur_state(pr->id);
	if (pr->flags.throttling)
		*cur_state += pr->throttling.state;
	return 0;
}

static int
processor_set_cur_state(struct thermal_cooling_device *cdev,
			unsigned long state)
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_processor *pr;
	int result = 0;
	int max_pstate;

	if (!device)
		return -EINVAL;

	pr = acpi_driver_data(device);
	if (!pr)
		return -EINVAL;

	max_pstate = cpufreq_get_max_state(pr->id);

	if (state > acpi_processor_max_state(pr))
		return -EINVAL;

	if (state <= max_pstate) {
		if (pr->flags.throttling && pr->throttling.state)
			result = acpi_processor_set_throttling(pr, 0, false);
		cpufreq_set_cur_state(pr->id, state);
	} else {
		cpufreq_set_cur_state(pr->id, max_pstate);
		result = acpi_processor_set_throttling(pr,
				state - max_pstate, false);
	}
	return result;
}

const struct thermal_cooling_device_ops processor_cooling_ops = {
	.get_max_state = processor_get_max_state,
	.get_cur_state = processor_get_cur_state,
	.set_cur_state = processor_set_cur_state,
};

int acpi_processor_thermal_init(struct acpi_processor *pr,
				struct acpi_device *device)
{
	int result = 0;

	pr->cdev = thermal_cooling_device_register("Processor", device,
						   &processor_cooling_ops);
	if (IS_ERR(pr->cdev)) {
		result = PTR_ERR(pr->cdev);
		return result;
	}

	dev_dbg(&device->dev, "registered as cooling_device%d\n",
		pr->cdev->id);

	result = sysfs_create_link(&device->dev.kobj,
				   &pr->cdev->device.kobj,
				   "thermal_cooling");
	if (result) {
		dev_err(&device->dev,
			"Failed to create sysfs link 'thermal_cooling'\n");
		goto err_thermal_unregister;
	}

	result = sysfs_create_link(&pr->cdev->device.kobj,
				   &device->dev.kobj,
				   "device");
	if (result) {
		dev_err(&pr->cdev->device,
			"Failed to create sysfs link 'device'\n");
		goto err_remove_sysfs_thermal;
	}

	return 0;

err_remove_sysfs_thermal:
	sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
err_thermal_unregister:
	thermal_cooling_device_unregister(pr->cdev);

	return result;
}

void acpi_processor_thermal_exit(struct acpi_processor *pr,
				 struct acpi_device *device)
{
	if (pr->cdev) {
		sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
		sysfs_remove_link(&pr->cdev->device.kobj, "device");
		thermal_cooling_device_unregister(pr->cdev);
		pr->cdev = NULL;
	}
}
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* processor_thermal.c - Passive cooling submodule of the ACPI processor driver
	4	*
	5	* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
	6	* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
	7	* Copyright (C) 2004 Dominik Brodowski <linux@brodo.de>
	8	* Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
	9	* - Added processor hotplug support
	10	*/
	11
	12	#include <linux/kernel.h>
	13	#include <linux/module.h>
	14	#include <linux/init.h>
	15	#include <linux/cpufreq.h>
	16	#include <linux/acpi.h>
	17	#include <acpi/processor.h>
	18	#include <linux/uaccess.h>
	19
	20	#include "internal.h"
	21
	22	#ifdef CONFIG_CPU_FREQ
	23
	24	/* If a passive cooling situation is detected, primarily CPUfreq is used, as it
	25	* offers (in most cases) voltage scaling in addition to frequency scaling, and
	26	* thus a cubic (instead of linear) reduction of energy. Also, we allow for
	27	* _any_ cpufreq driver and not only the acpi-cpufreq driver.
	28	*/
	29
	30	#define CPUFREQ_THERMAL_MIN_STEP 0
	31
	32	static int cpufreq_thermal_max_step __read_mostly = 3;
	33
	34	/*
	35	* Minimum throttle percentage for processor_thermal cooling device.
	36	* The processor_thermal driver uses it to calculate the percentage amount by
	37	* which cpu frequency must be reduced for each cooling state. This is also used
	38	* to calculate the maximum number of throttling steps or cooling states.
	39	*/
	40	static int cpufreq_thermal_reduction_pctg __read_mostly = 20;
	41
	42	static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_step);
	43
	44	#define reduction_step(cpu) \
	45	per_cpu(cpufreq_thermal_reduction_step, phys_package_first_cpu(cpu))
	46
	47	/*
	48	* Emulate "per package data" using per cpu data (which should really be
	49	* provided elsewhere)
	50	*
	51	* Note we can lose a CPU on cpu hotunplug, in this case we forget the state
	52	* temporarily. Fortunately that's not a big issue here (I hope)
	53	*/
	54	static int phys_package_first_cpu(int cpu)
	55	{
	56	int i;
	57	int id = topology_physical_package_id(cpu);
	58
	59	for_each_online_cpu(i)
	60	if (topology_physical_package_id(i) == id)
	61	return i;
	62	return 0;
	63	}
	64
	65	static int cpu_has_cpufreq(unsigned int cpu)
	66	{
	67	struct cpufreq_policy *policy;
	68
	69	if (!acpi_processor_cpufreq_init)
	70	return 0;
	71
	72	policy = cpufreq_cpu_get(cpu);
	73	if (policy) {
	74	cpufreq_cpu_put(policy);
	75	return 1;
	76	}
	77	return 0;
	78	}
	79
	80	static int cpufreq_get_max_state(unsigned int cpu)
	81	{
	82	if (!cpu_has_cpufreq(cpu))
	83	return 0;
	84
	85	return cpufreq_thermal_max_step;
	86	}
	87
	88	static int cpufreq_get_cur_state(unsigned int cpu)
	89	{
	90	if (!cpu_has_cpufreq(cpu))
	91	return 0;
	92
	93	return reduction_step(cpu);
	94	}
	95
	96	static int cpufreq_set_cur_state(unsigned int cpu, int state)
	97	{
	98	struct cpufreq_policy *policy;
	99	struct acpi_processor *pr;
	100	unsigned long max_freq;
	101	int i, ret;
	102
	103	if (!cpu_has_cpufreq(cpu))
	104	return 0;
	105
	106	reduction_step(cpu) = state;
	107
	108	/*
	109	* Update all the CPUs in the same package because they all
	110	* contribute to the temperature and often share the same
	111	* frequency.
	112	*/
	113	for_each_online_cpu(i) {
	114	if (topology_physical_package_id(i) !=
	115	topology_physical_package_id(cpu))
	116	continue;
	117
	118	pr = per_cpu(processors, i);
	119
	120	if (unlikely(!freq_qos_request_active(&pr->thermal_req)))
	121	continue;
	122
	123	policy = cpufreq_cpu_get(i);
	124	if (!policy)
	125	return -EINVAL;
	126
	127	max_freq = (policy->cpuinfo.max_freq *
	128	(100 - reduction_step(i) * cpufreq_thermal_reduction_pctg)) / 100;
	129
	130	cpufreq_cpu_put(policy);
	131
	132	ret = freq_qos_update_request(&pr->thermal_req, max_freq);
	133	if (ret < 0) {
	134	pr_warn("Failed to update thermal freq constraint: CPU%d (%d)\n",
	135	pr->id, ret);
	136	}
	137	}
	138	return 0;
	139	}
	140
	141	static void acpi_thermal_cpufreq_config(void)
	142	{
	143	int cpufreq_pctg = acpi_arch_thermal_cpufreq_pctg();
	144
	145	if (!cpufreq_pctg)
	146	return;
	147
	148	cpufreq_thermal_reduction_pctg = cpufreq_pctg;
	149
	150	/*
	151	* Derive the MAX_STEP from minimum throttle percentage so that the reduction
	152	* percentage doesn't end up becoming negative. Also, cap the MAX_STEP so that
	153	* the CPU performance doesn't become 0.
	154	*/
	155	cpufreq_thermal_max_step = (100 / cpufreq_pctg) - 2;
	156	}
	157
	158	void acpi_thermal_cpufreq_init(struct cpufreq_policy *policy)
	159	{
	160	unsigned int cpu;
	161
	162	acpi_thermal_cpufreq_config();
	163
	164	for_each_cpu(cpu, policy->related_cpus) {
	165	struct acpi_processor *pr = per_cpu(processors, cpu);
	166	int ret;
	167
	168	if (!pr)
	169	continue;
	170
	171	ret = freq_qos_add_request(&policy->constraints,
	172	&pr->thermal_req,
	173	FREQ_QOS_MAX, INT_MAX);
	174	if (ret < 0) {
	175	pr_err("Failed to add freq constraint for CPU%d (%d)\n",
	176	cpu, ret);
	177	continue;
	178	}
	179
	180	thermal_cooling_device_update(pr->cdev);
	181	}
	182	}
	183
	184	void acpi_thermal_cpufreq_exit(struct cpufreq_policy *policy)
	185	{
	186	unsigned int cpu;
	187
	188	for_each_cpu(cpu, policy->related_cpus) {
	189	struct acpi_processor *pr = per_cpu(processors, cpu);
	190
	191	if (!pr)
	192	continue;
	193
	194	freq_qos_remove_request(&pr->thermal_req);
	195
	196	thermal_cooling_device_update(pr->cdev);
	197	}
	198	}
	199	#else /* ! CONFIG_CPU_FREQ */
	200	static int cpufreq_get_max_state(unsigned int cpu)
	201	{
	202	return 0;
	203	}
	204
	205	static int cpufreq_get_cur_state(unsigned int cpu)
	206	{
	207	return 0;
	208	}
	209
	210	static int cpufreq_set_cur_state(unsigned int cpu, int state)
	211	{
	212	return 0;
	213	}
	214
	215	#endif
	216
	217	/* thermal cooling device callbacks */
	218	static int acpi_processor_max_state(struct acpi_processor *pr)
	219	{
	220	int max_state = 0;
	221
	222	/*
	223	* There exists four states according to
	224	* cpufreq_thermal_reduction_step. 0, 1, 2, 3
	225	*/
	226	max_state += cpufreq_get_max_state(pr->id);
	227	if (pr->flags.throttling)
	228	max_state += (pr->throttling.state_count -1);
	229
	230	return max_state;
	231	}
	232	static int
	233	processor_get_max_state(struct thermal_cooling_device *cdev,
	234	unsigned long *state)
	235	{
	236	struct acpi_device *device = cdev->devdata;
	237	struct acpi_processor *pr;
	238
	239	if (!device)
	240	return -EINVAL;
	241
	242	pr = acpi_driver_data(device);
	243	if (!pr)
	244	return -EINVAL;
	245
	246	*state = acpi_processor_max_state(pr);
	247	return 0;
	248	}
	249
	250	static int
	251	processor_get_cur_state(struct thermal_cooling_device *cdev,
	252	unsigned long *cur_state)
	253	{
	254	struct acpi_device *device = cdev->devdata;
	255	struct acpi_processor *pr;
	256
	257	if (!device)
	258	return -EINVAL;
	259
	260	pr = acpi_driver_data(device);
	261	if (!pr)
	262	return -EINVAL;
	263
	264	*cur_state = cpufreq_get_cur_state(pr->id);
	265	if (pr->flags.throttling)
	266	*cur_state += pr->throttling.state;
	267	return 0;
	268	}
	269
	270	static int
	271	processor_set_cur_state(struct thermal_cooling_device *cdev,
	272	unsigned long state)
	273	{
	274	struct acpi_device *device = cdev->devdata;
	275	struct acpi_processor *pr;
	276	int result = 0;
	277	int max_pstate;
	278
	279	if (!device)
	280	return -EINVAL;
	281
	282	pr = acpi_driver_data(device);
	283	if (!pr)
	284	return -EINVAL;
	285
	286	max_pstate = cpufreq_get_max_state(pr->id);
	287
	288	if (state > acpi_processor_max_state(pr))
	289	return -EINVAL;
	290
	291	if (state <= max_pstate) {
	292	if (pr->flags.throttling && pr->throttling.state)
	293	result = acpi_processor_set_throttling(pr, 0, false);
	294	cpufreq_set_cur_state(pr->id, state);
	295	} else {
	296	cpufreq_set_cur_state(pr->id, max_pstate);
	297	result = acpi_processor_set_throttling(pr,
	298	state - max_pstate, false);
	299	}
	300	return result;
	301	}
	302
	303	const struct thermal_cooling_device_ops processor_cooling_ops = {
	304	.get_max_state = processor_get_max_state,
	305	.get_cur_state = processor_get_cur_state,
	306	.set_cur_state = processor_set_cur_state,
	307	};
	308
	309	int acpi_processor_thermal_init(struct acpi_processor *pr,
	310	struct acpi_device *device)
	311	{
	312	int result = 0;
	313
	314	pr->cdev = thermal_cooling_device_register("Processor", device,
	315	&processor_cooling_ops);
	316	if (IS_ERR(pr->cdev)) {
	317	result = PTR_ERR(pr->cdev);
	318	return result;
	319	}
	320
	321	dev_dbg(&device->dev, "registered as cooling_device%d\n",
	322	pr->cdev->id);
	323
	324	result = sysfs_create_link(&device->dev.kobj,
	325	&pr->cdev->device.kobj,
	326	"thermal_cooling");
	327	if (result) {
	328	dev_err(&device->dev,
	329	"Failed to create sysfs link 'thermal_cooling'\n");
	330	goto err_thermal_unregister;
	331	}
	332
	333	result = sysfs_create_link(&pr->cdev->device.kobj,
	334	&device->dev.kobj,
	335	"device");
	336	if (result) {
	337	dev_err(&pr->cdev->device,
	338	"Failed to create sysfs link 'device'\n");
	339	goto err_remove_sysfs_thermal;
	340	}
	341
	342	return 0;
	343
	344	err_remove_sysfs_thermal:
	345	sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
	346	err_thermal_unregister:
	347	thermal_cooling_device_unregister(pr->cdev);
	348
	349	return result;
	350	}
	351
	352	void acpi_processor_thermal_exit(struct acpi_processor *pr,
	353	struct acpi_device *device)
	354	{
	355	if (pr->cdev) {
	356	sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
	357	sysfs_remove_link(&pr->cdev->device.kobj, "device");
	358	thermal_cooling_device_unregister(pr->cdev);
	359	pr->cdev = NULL;
	360	}
	361	}