Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b2ce1c88 authored by Len Brown's avatar Len Brown Committed by Thomas Gleixner
Browse files

thermal/x86_pkg_temp_thermal: Cosmetic: Rename internal variables to zones from packages 



Syntax update only -- no logical or functional change.

In response to the new multi-die/package changes, update variable names to
use the more generic thermal "zone" terminology, instead of "package", as
the zones can refer to either packages or die.

Signed-off-by: default avatarLen Brown <len.brown@intel.com>
Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
Reviewed-by: default avatarIngo Molnar <mingo@kernel.org>
Acked-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Cc: Zhang Rui <rui.zhang@intel.com>
Link: https://lkml.kernel.org/r/b65494a76be13481dc3a809c75debb2574c34eda.1557769318.git.len.brown@intel.com
parent cb63ba0f

drivers/thermal/intel/x86_pkg_temp_thermal.c

+72 −70
Original line number Diff line number Diff line
@@ -55,7 +55,7 @@ MODULE_PARM_DESC(notify_delay_ms, 
*/

#define MAX_NUMBER_OF_TRIPS	2



struct pkg_device {

struct zone_device {

	int				cpu;

	bool				work_scheduled;

	u32				tj_max;
@@ -70,10 +70,10 @@ static struct thermal_zone_params pkg_temp_tz_params = { 
	.no_hwmon	= true,

};



/* Keep track of how many package pointers we allocated in init() */

static int max_packages __read_mostly;

/* Array of package pointers */

static struct pkg_device **packages;

/* Keep track of how many zone pointers we allocated in init() */

static int max_id __read_mostly;

/* Array of zone pointers */

static struct zone_device **zones;

/* Serializes interrupt notification, work and hotplug */

static DEFINE_SPINLOCK(pkg_temp_lock);

/* Protects zone operation in the work function against hotplug removal */
@@ -120,12 +120,12 @@ static int pkg_temp_debugfs_init(void) 
 *

 * - Other callsites: Must hold pkg_temp_lock

 */

static struct pkg_device *pkg_temp_thermal_get_dev(unsigned int cpu)

static struct zone_device *pkg_temp_thermal_get_dev(unsigned int cpu)

{

	int pkgid = topology_logical_die_id(cpu);

	int id = topology_logical_die_id(cpu);



	if (pkgid >= 0 && pkgid < max_packages)

		return packages[pkgid];

	if (id >= 0 && id < max_id)

		return zones[id];

	return NULL;

}
@@ -150,12 +150,13 @@ static int get_tj_max(int cpu, u32 *tj_max) 


static int sys_get_curr_temp(struct thermal_zone_device *tzd, int *temp)

{

	struct pkg_device *pkgdev = tzd->devdata;

	struct zone_device *zonedev = tzd->devdata;

	u32 eax, edx;



	rdmsr_on_cpu(pkgdev->cpu, MSR_IA32_PACKAGE_THERM_STATUS, &eax, &edx);

	rdmsr_on_cpu(zonedev->cpu, MSR_IA32_PACKAGE_THERM_STATUS,

			&eax, &edx);

	if (eax & 0x80000000) {

		*temp = pkgdev->tj_max - ((eax >> 16) & 0x7f) * 1000;

		*temp = zonedev->tj_max - ((eax >> 16) & 0x7f) * 1000;

		pr_debug("sys_get_curr_temp %d\n", *temp);

		return 0;

	}
@@ -165,7 +166,7 @@ static int sys_get_curr_temp(struct thermal_zone_device *tzd, int *temp) 
static int sys_get_trip_temp(struct thermal_zone_device *tzd,

			     int trip, int *temp)

{

	struct pkg_device *pkgdev = tzd->devdata;

	struct zone_device *zonedev = tzd->devdata;

	unsigned long thres_reg_value;

	u32 mask, shift, eax, edx;

	int ret;
@@ -181,14 +182,14 @@ static int sys_get_trip_temp(struct thermal_zone_device *tzd, 
		shift = THERM_SHIFT_THRESHOLD0;

	}



	ret = rdmsr_on_cpu(pkgdev->cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT,

	ret = rdmsr_on_cpu(zonedev->cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT,

			   &eax, &edx);

	if (ret < 0)

		return ret;



	thres_reg_value = (eax & mask) >> shift;

	if (thres_reg_value)

		*temp = pkgdev->tj_max - thres_reg_value * 1000;

		*temp = zonedev->tj_max - thres_reg_value * 1000;

	else

		*temp = 0;

	pr_debug("sys_get_trip_temp %d\n", *temp);
@@ -199,14 +200,14 @@ static int sys_get_trip_temp(struct thermal_zone_device *tzd, 
static int

sys_set_trip_temp(struct thermal_zone_device *tzd, int trip, int temp)

{

	struct pkg_device *pkgdev = tzd->devdata;

	struct zone_device *zonedev = tzd->devdata;

	u32 l, h, mask, shift, intr;

	int ret;



	if (trip >= MAX_NUMBER_OF_TRIPS || temp >= pkgdev->tj_max)

	if (trip >= MAX_NUMBER_OF_TRIPS || temp >= zonedev->tj_max)

		return -EINVAL;



	ret = rdmsr_on_cpu(pkgdev->cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT,

	ret = rdmsr_on_cpu(zonedev->cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT,

			   &l, &h);

	if (ret < 0)

		return ret;
@@ -228,11 +229,12 @@ sys_set_trip_temp(struct thermal_zone_device *tzd, int trip, int temp) 
	if (!temp) {

		l &= ~intr;

	} else {

		l |= (pkgdev->tj_max - temp)/1000 << shift;

		l |= (zonedev->tj_max - temp)/1000 << shift;

		l |= intr;

	}



	return wrmsr_on_cpu(pkgdev->cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT, l, h);

	return wrmsr_on_cpu(zonedev->cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT,

			l, h);

}



static int sys_get_trip_type(struct thermal_zone_device *thermal, int trip,
@@ -287,26 +289,26 @@ static void pkg_temp_thermal_threshold_work_fn(struct work_struct *work) 
{

	struct thermal_zone_device *tzone = NULL;

	int cpu = smp_processor_id();

	struct pkg_device *pkgdev;

	struct zone_device *zonedev;

	u64 msr_val, wr_val;



	mutex_lock(&thermal_zone_mutex);

	spin_lock_irq(&pkg_temp_lock);

	++pkg_work_cnt;



	pkgdev = pkg_temp_thermal_get_dev(cpu);

	if (!pkgdev) {

	zonedev = pkg_temp_thermal_get_dev(cpu);

	if (!zonedev) {

		spin_unlock_irq(&pkg_temp_lock);

		mutex_unlock(&thermal_zone_mutex);

		return;

	}

	pkgdev->work_scheduled = false;

	zonedev->work_scheduled = false;



	rdmsrl(MSR_IA32_PACKAGE_THERM_STATUS, msr_val);

	wr_val = msr_val & ~(THERM_LOG_THRESHOLD0 | THERM_LOG_THRESHOLD1);

	if (wr_val != msr_val) {

		wrmsrl(MSR_IA32_PACKAGE_THERM_STATUS, wr_val);

		tzone = pkgdev->tzone;

		tzone = zonedev->tzone;

	}



	enable_pkg_thres_interrupt();
@@ -332,7 +334,7 @@ static void pkg_thermal_schedule_work(int cpu, struct delayed_work *work) 
static int pkg_thermal_notify(u64 msr_val)

{

	int cpu = smp_processor_id();

	struct pkg_device *pkgdev;

	struct zone_device *zonedev;

	unsigned long flags;



	spin_lock_irqsave(&pkg_temp_lock, flags);
@@ -341,10 +343,10 @@ static int pkg_thermal_notify(u64 msr_val) 
	disable_pkg_thres_interrupt();



	/* Work is per package, so scheduling it once is enough. */

	pkgdev = pkg_temp_thermal_get_dev(cpu);

	if (pkgdev && !pkgdev->work_scheduled) {

		pkgdev->work_scheduled = true;

		pkg_thermal_schedule_work(pkgdev->cpu, &pkgdev->work);

	zonedev = pkg_temp_thermal_get_dev(cpu);

	if (zonedev && !zonedev->work_scheduled) {

		zonedev->work_scheduled = true;

		pkg_thermal_schedule_work(zonedev->cpu, &zonedev->work);

	}



	spin_unlock_irqrestore(&pkg_temp_lock, flags);
@@ -353,12 +355,12 @@ static int pkg_thermal_notify(u64 msr_val) 


static int pkg_temp_thermal_device_add(unsigned int cpu)

{

	int pkgid = topology_logical_die_id(cpu);

	int id = topology_logical_die_id(cpu);

	u32 tj_max, eax, ebx, ecx, edx;

	struct pkg_device *pkgdev;

	struct zone_device *zonedev;

	int thres_count, err;



	if (pkgid >= max_packages)

	if (id >= max_id)

		return -ENOMEM;



	cpuid(6, &eax, &ebx, &ecx, &edx);
@@ -372,51 +374,51 @@ static int pkg_temp_thermal_device_add(unsigned int cpu) 
	if (err)

		return err;



	pkgdev = kzalloc(sizeof(*pkgdev), GFP_KERNEL);

	if (!pkgdev)

	zonedev = kzalloc(sizeof(*zonedev), GFP_KERNEL);

	if (!zonedev)

		return -ENOMEM;



	INIT_DELAYED_WORK(&pkgdev->work, pkg_temp_thermal_threshold_work_fn);

	pkgdev->cpu = cpu;

	pkgdev->tj_max = tj_max;

	pkgdev->tzone = thermal_zone_device_register("x86_pkg_temp",

	INIT_DELAYED_WORK(&zonedev->work, pkg_temp_thermal_threshold_work_fn);

	zonedev->cpu = cpu;

	zonedev->tj_max = tj_max;

	zonedev->tzone = thermal_zone_device_register("x86_pkg_temp",

			thres_count,

			(thres_count == MAX_NUMBER_OF_TRIPS) ? 0x03 : 0x01,

			pkgdev, &tzone_ops, &pkg_temp_tz_params, 0, 0);

	if (IS_ERR(pkgdev->tzone)) {

		err = PTR_ERR(pkgdev->tzone);

		kfree(pkgdev);

			zonedev, &tzone_ops, &pkg_temp_tz_params, 0, 0);

	if (IS_ERR(zonedev->tzone)) {

		err = PTR_ERR(zonedev->tzone);

		kfree(zonedev);

		return err;

	}

	/* Store MSR value for package thermal interrupt, to restore at exit */

	rdmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT, pkgdev->msr_pkg_therm_low,

	      pkgdev->msr_pkg_therm_high);

	rdmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT, zonedev->msr_pkg_therm_low,

	      zonedev->msr_pkg_therm_high);



	cpumask_set_cpu(cpu, &pkgdev->cpumask);

	cpumask_set_cpu(cpu, &zonedev->cpumask);

	spin_lock_irq(&pkg_temp_lock);

	packages[pkgid] = pkgdev;

	zones[id] = zonedev;

	spin_unlock_irq(&pkg_temp_lock);

	return 0;

}



static int pkg_thermal_cpu_offline(unsigned int cpu)

{

	struct pkg_device *pkgdev = pkg_temp_thermal_get_dev(cpu);

	struct zone_device *zonedev = pkg_temp_thermal_get_dev(cpu);

	bool lastcpu, was_target;

	int target;



	if (!pkgdev)

	if (!zonedev)

		return 0;



	target = cpumask_any_but(&pkgdev->cpumask, cpu);

	cpumask_clear_cpu(cpu, &pkgdev->cpumask);

	target = cpumask_any_but(&zonedev->cpumask, cpu);

	cpumask_clear_cpu(cpu, &zonedev->cpumask);

	lastcpu = target >= nr_cpu_ids;

	/*

	 * Remove the sysfs files, if this is the last cpu in the package

	 * before doing further cleanups.

	 */

	if (lastcpu) {

		struct thermal_zone_device *tzone = pkgdev->tzone;

		struct thermal_zone_device *tzone = zonedev->tzone;



		/*

		 * We must protect against a work function calling
@@ -425,7 +427,7 @@ static int pkg_thermal_cpu_offline(unsigned int cpu) 
		 * won't try to call.

		 */

		mutex_lock(&thermal_zone_mutex);

		pkgdev->tzone = NULL;

		zonedev->tzone = NULL;

		mutex_unlock(&thermal_zone_mutex);



		thermal_zone_device_unregister(tzone);
@@ -439,8 +441,8 @@ static int pkg_thermal_cpu_offline(unsigned int cpu) 
	 * one. When we drop the lock, then the interrupt notify function

	 * will see the new target.

	 */

	was_target = pkgdev->cpu == cpu;

	pkgdev->cpu = target;

	was_target = zonedev->cpu == cpu;

	zonedev->cpu = target;



	/*

	 * If this is the last CPU in the package remove the package
@@ -449,23 +451,23 @@ static int pkg_thermal_cpu_offline(unsigned int cpu) 
	 * worker will see the package anymore.

	 */

	if (lastcpu) {

		packages[topology_logical_die_id(cpu)] = NULL;

		zones[topology_logical_die_id(cpu)] = NULL;

		/* After this point nothing touches the MSR anymore. */

		wrmsr(MSR_IA32_PACKAGE_THERM_INTERRUPT,

		      pkgdev->msr_pkg_therm_low, pkgdev->msr_pkg_therm_high);

		      zonedev->msr_pkg_therm_low, zonedev->msr_pkg_therm_high);

	}



	/*

	 * Check whether there is work scheduled and whether the work is

	 * targeted at the outgoing CPU.

	 */

	if (pkgdev->work_scheduled && was_target) {

	if (zonedev->work_scheduled && was_target) {

		/*

		 * To cancel the work we need to drop the lock, otherwise

		 * we might deadlock if the work needs to be flushed.

		 */

		spin_unlock_irq(&pkg_temp_lock);

		cancel_delayed_work_sync(&pkgdev->work);

		cancel_delayed_work_sync(&zonedev->work);

		spin_lock_irq(&pkg_temp_lock);

		/*

		 * If this is not the last cpu in the package and the work
@@ -473,21 +475,21 @@ static int pkg_thermal_cpu_offline(unsigned int cpu) 
		 * need to reschedule the work, otherwise the interrupt

		 * stays disabled forever.

		 */

		if (!lastcpu && pkgdev->work_scheduled)

			pkg_thermal_schedule_work(target, &pkgdev->work);

		if (!lastcpu && zonedev->work_scheduled)

			pkg_thermal_schedule_work(target, &zonedev->work);

	}



	spin_unlock_irq(&pkg_temp_lock);



	/* Final cleanup if this is the last cpu */

	if (lastcpu)

		kfree(pkgdev);

		kfree(zonedev);

	return 0;

}



static int pkg_thermal_cpu_online(unsigned int cpu)

{

	struct pkg_device *pkgdev = pkg_temp_thermal_get_dev(cpu);

	struct zone_device *zonedev = pkg_temp_thermal_get_dev(cpu);

	struct cpuinfo_x86 *c = &cpu_data(cpu);



	/* Paranoia check */
@@ -495,8 +497,8 @@ static int pkg_thermal_cpu_online(unsigned int cpu) 
		return -ENODEV;



	/* If the package exists, nothing to do */

	if (pkgdev) {

		cpumask_set_cpu(cpu, &pkgdev->cpumask);

	if (zonedev) {

		cpumask_set_cpu(cpu, &zonedev->cpumask);

		return 0;

	}

	return pkg_temp_thermal_device_add(cpu);
@@ -515,10 +517,10 @@ static int __init pkg_temp_thermal_init(void) 
	if (!x86_match_cpu(pkg_temp_thermal_ids))

		return -ENODEV;



	max_packages = topology_max_packages() * topology_max_die_per_package();

	packages = kcalloc(max_packages, sizeof(struct pkg_device *),

	max_id = topology_max_packages() * topology_max_die_per_package();

	zones = kcalloc(max_id, sizeof(struct zone_device *),

			   GFP_KERNEL);

	if (!packages)

	if (!zones)

		return -ENOMEM;



	ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "thermal/x86_pkg:online",
@@ -537,7 +539,7 @@ static int __init pkg_temp_thermal_init(void) 
	return 0;



err:

	kfree(packages);

	kfree(zones);

	return ret;

}

module_init(pkg_temp_thermal_init)
@@ -549,7 +551,7 @@ static void __exit pkg_temp_thermal_exit(void) 


	cpuhp_remove_state(pkg_thermal_hp_state);

	debugfs_remove_recursive(debugfs);

	kfree(packages);

	kfree(zones);

}

module_exit(pkg_temp_thermal_exit)