Commit 52b1c69d authored by Jacob Pan's avatar Jacob Pan Committed by Zhang Rui
Browse files

Thermal: int340x_thermal: expose acpi thermal relationship tables 



ACPI 4.0 introduced two thermal relationship tables via _ART
(active cooling) and  _TRT (passive cooling) objects. These
tables contain many to many relationships among thermal sensors
and cooling devices.

This patch parses _ART and _TRT and makes the result available to
the userspace via an misc device interface. At the same time,
kernel drivers can also request parsing results from internal
kernel APIs.

The results include source and target devices, influence, and
sampling rate in case of _TRT. For _ART, the result shows source
device, target device, and weight percentage.

Signed-off-by: default avatarJacob Pan <jacob.jun.pan@linux.intel.com>
Signed-off-by: default avatarZhang Rui <rui.zhang@intel.com>
parent 4384b8fe

drivers/thermal/Kconfig

+5 −0
Original line number Diff line number Diff line
@@ -223,6 +223,7 @@ config INT340X_THERMAL 
	tristate "ACPI INT340X thermal drivers"

	depends on X86 && ACPI

	select THERMAL_GOV_USER_SPACE

	select ACPI_THERMAL_REL

	help

	  Newer laptops and tablets that use ACPI may have thermal sensors and

	  other devices with thermal control capabilities outside the core
@@ -237,6 +238,10 @@ config INT340X_THERMAL 
	  information to allow the user to select his laptop to run without

	  turning on the fans.



config ACPI_THERMAL_REL

	tristate

	depends on ACPI



menu "Texas Instruments thermal drivers"

source "drivers/thermal/ti-soc-thermal/Kconfig"

endmenu

drivers/thermal/int340x_thermal/Makefile

+1 −0
Original line number Diff line number Diff line 
obj-$(CONFIG_INT340X_THERMAL)	+= int3400_thermal.o

obj-$(CONFIG_INT340X_THERMAL)	+= int3402_thermal.o

obj-$(CONFIG_INT340X_THERMAL)	+= int3403_thermal.o

obj-$(CONFIG_ACPI_THERMAL_REL)	+= acpi_thermal_rel.o

drivers/thermal/int340x_thermal/acpi_thermal_rel.c

0 → 100644
+400 −0
Original line number Diff line number Diff line 
/* acpi_thermal_rel.c driver for exporting ACPI thermal relationship

 *

 * Copyright (c) 2014 Intel Corp

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 as published by

 * the Free Software Foundation.

 *

 */



/*

 * Two functionalities included:

 * 1. Export _TRT, _ART, via misc device interface to the userspace.

 * 2. Provide parsing result to kernel drivers

 *

 */

#include <linux/init.h>

#include <linux/export.h>

#include <linux/module.h>

#include <linux/device.h>

#include <linux/platform_device.h>

#include <linux/io.h>

#include <linux/acpi.h>

#include <linux/uaccess.h>

#include <linux/miscdevice.h>

#include "acpi_thermal_rel.h"



static acpi_handle acpi_thermal_rel_handle;

static DEFINE_SPINLOCK(acpi_thermal_rel_chrdev_lock);

static int acpi_thermal_rel_chrdev_count;	/* #times opened */

static int acpi_thermal_rel_chrdev_exclu;	/* already open exclusive? */



static int acpi_thermal_rel_open(struct inode *inode, struct file *file)

{

	spin_lock(&acpi_thermal_rel_chrdev_lock);

	if (acpi_thermal_rel_chrdev_exclu ||

	    (acpi_thermal_rel_chrdev_count && (file->f_flags & O_EXCL))) {

		spin_unlock(&acpi_thermal_rel_chrdev_lock);

		return -EBUSY;

	}



	if (file->f_flags & O_EXCL)

		acpi_thermal_rel_chrdev_exclu = 1;

	acpi_thermal_rel_chrdev_count++;



	spin_unlock(&acpi_thermal_rel_chrdev_lock);



	return nonseekable_open(inode, file);

}



static int acpi_thermal_rel_release(struct inode *inode, struct file *file)

{

	spin_lock(&acpi_thermal_rel_chrdev_lock);

	acpi_thermal_rel_chrdev_count--;

	acpi_thermal_rel_chrdev_exclu = 0;

	spin_unlock(&acpi_thermal_rel_chrdev_lock);



	return 0;

}



/**

 * acpi_parse_trt - Thermal Relationship Table _TRT for passive cooling

 *

 * @handle: ACPI handle of the device contains _TRT

 * @art_count: the number of valid entries resulted from parsing _TRT

 * @artp: pointer to pointer of array of art entries in parsing result

 * @create_dev: whether to create platform devices for target and source

 *

 */

int acpi_parse_trt(acpi_handle handle, int *trt_count, struct trt **trtp,

		bool create_dev)

{

	acpi_status status;

	int result = 0;

	int i;

	int nr_bad_entries = 0;

	struct trt *trts;

	struct acpi_device *adev;

	union acpi_object *p;

	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };

	struct acpi_buffer element = { 0, NULL };

	struct acpi_buffer trt_format = { sizeof("RRNNNNNN"), "RRNNNNNN" };



	if (!acpi_has_method(handle, "_TRT"))

		return 0;



	status = acpi_evaluate_object(handle, "_TRT", NULL, &buffer);

	if (ACPI_FAILURE(status))

		return -ENODEV;



	p = buffer.pointer;

	if (!p || (p->type != ACPI_TYPE_PACKAGE)) {

		pr_err("Invalid _TRT data\n");

		result = -EFAULT;

		goto end;

	}



	*trt_count = p->package.count;

	trts = kzalloc(*trt_count * sizeof(struct trt), GFP_KERNEL);

	if (!trts) {

		result = -ENOMEM;

		goto end;

	}



	for (i = 0; i < *trt_count; i++) {

		struct trt *trt = &trts[i - nr_bad_entries];



		element.length = sizeof(struct trt);

		element.pointer = trt;



		status = acpi_extract_package(&(p->package.elements[i]),

					      &trt_format, &element);

		if (ACPI_FAILURE(status)) {

			nr_bad_entries++;

			pr_warn("_TRT package %d is invalid, ignored\n", i);

			continue;

		}

		if (!create_dev)

			continue;



		result = acpi_bus_get_device(trt->source, &adev);

		if (!result)

			acpi_create_platform_device(adev);

		else

			pr_warn("Failed to get source ACPI device\n");



		result = acpi_bus_get_device(trt->target, &adev);

		if (!result)

			acpi_create_platform_device(adev);

		else

			pr_warn("Failed to get target ACPI device\n");

	}



	*trtp = trts;

	/* don't count bad entries */

	*trt_count -= nr_bad_entries;

end:

	kfree(buffer.pointer);

	return result;

}

EXPORT_SYMBOL(acpi_parse_trt);



/**

 * acpi_parse_art - Parse Active Relationship Table _ART

 *

 * @handle: ACPI handle of the device contains _ART

 * @art_count: the number of valid entries resulted from parsing _ART

 * @artp: pointer to pointer of array of art entries in parsing result

 * @create_dev: whether to create platform devices for target and source

 *

 */

int acpi_parse_art(acpi_handle handle, int *art_count, struct art **artp,

		bool create_dev)

{

	acpi_status status;

	int result = 0;

	int i;

	int nr_bad_entries = 0;

	struct art *arts;

	struct acpi_device *adev;

	union acpi_object *p;

	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };

	struct acpi_buffer element = { 0, NULL };

	struct acpi_buffer art_format =	{

		sizeof("RRNNNNNNNNNNN"), "RRNNNNNNNNNNN" };



	if (!acpi_has_method(handle, "_ART"))

		return 0;



	status = acpi_evaluate_object(handle, "_ART", NULL, &buffer);

	if (ACPI_FAILURE(status))

		return -ENODEV;



	p = buffer.pointer;

	if (!p || (p->type != ACPI_TYPE_PACKAGE)) {

		pr_err("Invalid _ART data\n");

		result = -EFAULT;

		goto end;

	}



	/* ignore p->package.elements[0], as this is _ART Revision field */

	*art_count = p->package.count - 1;

	arts = kzalloc(*art_count * sizeof(struct art), GFP_KERNEL);

	if (!arts) {

		result = -ENOMEM;

		goto end;

	}



	for (i = 0; i < *art_count; i++) {

		struct art *art = &arts[i - nr_bad_entries];



		element.length = sizeof(struct art);

		element.pointer = art;



		status = acpi_extract_package(&(p->package.elements[i + 1]),

					      &art_format, &element);

		if (ACPI_FAILURE(status)) {

			pr_warn("_ART package %d is invalid, ignored", i);

			nr_bad_entries++;

			continue;

		}

		if (!create_dev)

			continue;



		if (art->source) {

			result = acpi_bus_get_device(art->source, &adev);

			if (!result)

				acpi_create_platform_device(adev);

			else

				pr_warn("Failed to get source ACPI device\n");

		}

		if (art->target) {

			result = acpi_bus_get_device(art->target, &adev);

			if (!result)

				acpi_create_platform_device(adev);

			else

				pr_warn("Failed to get source ACPI device\n");

		}

	}



	*artp = arts;

	/* don't count bad entries */

	*art_count -= nr_bad_entries;

end:

	kfree(buffer.pointer);

	return result;

}

EXPORT_SYMBOL(acpi_parse_art);





/* get device name from acpi handle */

static void get_single_name(acpi_handle handle, char *name)

{

	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};



	if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer)))

		pr_warn("Failed get name from handle\n");

	else {

		memcpy(name, buffer.pointer, ACPI_NAME_SIZE);

		kfree(buffer.pointer);

	}

}



static int fill_art(char __user *ubuf)

{

	int i;

	int ret;

	int count;

	int art_len;

	struct art *arts = NULL;

	union art_object *art_user;



	ret = acpi_parse_art(acpi_thermal_rel_handle, &count, &arts, false);

	if (ret)

		goto free_art;

	art_len = count * sizeof(union art_object);

	art_user = kzalloc(art_len, GFP_KERNEL);

	if (!art_user) {

		ret = -ENOMEM;

		goto free_art;

	}

	/* now fill in user art data */

	for (i = 0; i < count; i++) {

		/* userspace art needs device name instead of acpi reference */

		get_single_name(arts[i].source, art_user[i].source_device);

		get_single_name(arts[i].target, art_user[i].target_device);

		/* copy the rest int data in addition to source and target */

		memcpy(&art_user[i].weight, &arts[i].weight,

			sizeof(u64) * (ACPI_NR_ART_ELEMENTS - 2));

	}



	if (copy_to_user(ubuf, art_user, art_len))

		ret = -EFAULT;

	kfree(art_user);

free_art:

	kfree(arts);

	return ret;

}



static int fill_trt(char __user *ubuf)

{

	int i;

	int ret;

	int count;

	int trt_len;

	struct trt *trts = NULL;

	union trt_object *trt_user;



	ret = acpi_parse_trt(acpi_thermal_rel_handle, &count, &trts, false);

	if (ret)

		goto free_trt;

	trt_len = count * sizeof(union trt_object);

	trt_user = kzalloc(trt_len, GFP_KERNEL);

	if (!trt_user) {

		ret = -ENOMEM;

		goto free_trt;

	}

	/* now fill in user trt data */

	for (i = 0; i < count; i++) {

		/* userspace trt needs device name instead of acpi reference */

		get_single_name(trts[i].source, trt_user[i].source_device);

		get_single_name(trts[i].target, trt_user[i].target_device);

		trt_user[i].sample_period = trts[i].sample_period;

		trt_user[i].influence = trts[i].influence;

	}



	if (copy_to_user(ubuf, trt_user, trt_len))

		ret = -EFAULT;

	kfree(trt_user);

free_trt:

	kfree(trts);

	return ret;

}



static long acpi_thermal_rel_ioctl(struct file *f, unsigned int cmd,

				   unsigned long __arg)

{

	int ret = 0;

	unsigned long length = 0;

	unsigned long count = 0;

	char __user *arg = (void __user *)__arg;

	struct trt *trts;

	struct art *arts;



	switch (cmd) {

	case ACPI_THERMAL_GET_TRT_COUNT:

		ret = acpi_parse_trt(acpi_thermal_rel_handle, (int *)&count,

				&trts, false);

		kfree(trts);

		if (!ret)

			return put_user(count, (unsigned long __user *)__arg);

		return ret;

	case ACPI_THERMAL_GET_TRT_LEN:

		ret = acpi_parse_trt(acpi_thermal_rel_handle, (int *)&count,

				&trts, false);

		kfree(trts);

		length = count * sizeof(union trt_object);

		if (!ret)

			return put_user(length, (unsigned long __user *)__arg);

		return ret;

	case ACPI_THERMAL_GET_TRT:

		return fill_trt(arg);

	case ACPI_THERMAL_GET_ART_COUNT:

		ret = acpi_parse_art(acpi_thermal_rel_handle, (int *)&count,

				&arts, false);

		kfree(arts);

		if (!ret)

			return put_user(count, (unsigned long __user *)__arg);

		return ret;

	case ACPI_THERMAL_GET_ART_LEN:

		ret = acpi_parse_art(acpi_thermal_rel_handle, (int *)&count,

				&arts, false);

		kfree(arts);

		length = count * sizeof(union art_object);

		if (!ret)

			return put_user(length, (unsigned long __user *)__arg);

		return ret;



	case ACPI_THERMAL_GET_ART:

		return fill_art(arg);



	default:

		return -ENOTTY;

	}

}



static const struct file_operations acpi_thermal_rel_fops = {

	.owner		= THIS_MODULE,

	.open		= acpi_thermal_rel_open,

	.release	= acpi_thermal_rel_release,

	.unlocked_ioctl	= acpi_thermal_rel_ioctl,

	.llseek		= no_llseek,

};



static struct miscdevice acpi_thermal_rel_misc_device = {

	.minor	= MISC_DYNAMIC_MINOR,

	"acpi_thermal_rel",

	&acpi_thermal_rel_fops

};



int acpi_thermal_rel_misc_device_add(acpi_handle handle)

{

	acpi_thermal_rel_handle = handle;



	return misc_register(&acpi_thermal_rel_misc_device);

}

EXPORT_SYMBOL(acpi_thermal_rel_misc_device_add);



int acpi_thermal_rel_misc_device_remove(acpi_handle handle)

{

	misc_deregister(&acpi_thermal_rel_misc_device);



	return 0;

}

EXPORT_SYMBOL(acpi_thermal_rel_misc_device_remove);



MODULE_AUTHOR("Zhang Rui <rui.zhang@intel.com>");

MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@intel.com");

MODULE_DESCRIPTION("Intel acpi thermal rel misc dev driver");

MODULE_LICENSE("GPL v2");

drivers/thermal/int340x_thermal/acpi_thermal_rel.h

0 → 100644
+84 −0
Original line number Diff line number Diff line 
#ifndef __ACPI_ACPI_THERMAL_H

#define __ACPI_ACPI_THERMAL_H



#include <asm/ioctl.h>



#define ACPI_THERMAL_MAGIC 's'



#define ACPI_THERMAL_GET_TRT_LEN _IOR(ACPI_THERMAL_MAGIC, 1, unsigned long)

#define ACPI_THERMAL_GET_ART_LEN _IOR(ACPI_THERMAL_MAGIC, 2, unsigned long)

#define ACPI_THERMAL_GET_TRT_COUNT _IOR(ACPI_THERMAL_MAGIC, 3, unsigned long)

#define ACPI_THERMAL_GET_ART_COUNT _IOR(ACPI_THERMAL_MAGIC, 4, unsigned long)



#define ACPI_THERMAL_GET_TRT	_IOR(ACPI_THERMAL_MAGIC, 5, unsigned long)

#define ACPI_THERMAL_GET_ART	_IOR(ACPI_THERMAL_MAGIC, 6, unsigned long)



struct art {

	acpi_handle source;

	acpi_handle target;

	u64 weight;

	u64 ac0_max;

	u64 ac1_max;

	u64 ac2_max;

	u64 ac3_max;

	u64 ac4_max;

	u64 ac5_max;

	u64 ac6_max;

	u64 ac7_max;

	u64 ac8_max;

	u64 ac9_max;

} __packed;



struct trt {

	acpi_handle source;

	acpi_handle target;

	u64 influence;

	u64 sample_period;

	u64 reverved1;

	u64 reverved2;

	u64 reverved3;

	u64 reverved4;

} __packed;



#define ACPI_NR_ART_ELEMENTS 13

/* for usrspace */

union art_object {

	struct {

		char source_device[8]; /* ACPI single name */

		char target_device[8]; /* ACPI single name */

		u64 weight;

		u64 ac0_max_level;

		u64 ac1_max_level;

		u64 ac2_max_level;

		u64 ac3_max_level;

		u64 ac4_max_level;

		u64 ac5_max_level;

		u64 ac6_max_level;

		u64 ac7_max_level;

		u64 ac8_max_level;

		u64 ac9_max_level;

	};

	u64 __data[ACPI_NR_ART_ELEMENTS];

};



union trt_object {

	struct {

		char source_device[8]; /* ACPI single name */

		char target_device[8]; /* ACPI single name */

		u64 influence;

		u64 sample_period;

		u64 reserved[4];

	};

	u64 __data[8];

};



#ifdef __KERNEL__

int acpi_thermal_rel_misc_device_add(acpi_handle handle);

int acpi_thermal_rel_misc_device_remove(acpi_handle handle);

int acpi_parse_art(acpi_handle handle, int *art_count, struct art **arts,

		bool create_dev);

int acpi_parse_trt(acpi_handle handle, int *trt_count, struct trt **trts,

		bool create_dev);

#endif



#endif /* __ACPI_ACPI_THERMAL_H */

CRA Git | Maintained and supported by SUSTech CRA and CCSE