[mirror_ubuntu-artful-kernel.git] / drivers / thermal / int340x_thermal / acpi_thermal_rel.c

/* 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
 * @trt_count: the number of valid entries resulted from parsing _TRT
 * @trtp: pointer to pointer of array of _TRT 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 -ENODEV;

	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)
			pr_warn("Failed to get source ACPI device\n");

		result = acpi_bus_get_device(trt->target, &adev);
		if (result)
			pr_warn("Failed to get target ACPI device\n");
	}

	result = 0;

	*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 -ENODEV;

	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)
				pr_warn("Failed to get source ACPI device\n");
		}
		if (art->target) {
			result = acpi_bus_get_device(art->target, &adev);
			if (result)
				pr_warn("Failed to get target 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;
	int count = 0;
	char __user *arg = (void __user *)__arg;
	struct trt *trts = NULL;
	struct art *arts = NULL;

	switch (cmd) {
	case ACPI_THERMAL_GET_TRT_COUNT:
		ret = acpi_parse_trt(acpi_thermal_rel_handle, &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, &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, &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, &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");
Commit	Line	Data
52b1c69d JP	1	/* acpi_thermal_rel.c driver for exporting ACPI thermal relationship
	2	*
	3	* Copyright (c) 2014 Intel Corp
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 as published by
	7	* the Free Software Foundation.
	8	*
	9	*/
	10
	11	/*
	12	* Two functionalities included:
	13	* 1. Export _TRT, _ART, via misc device interface to the userspace.
	14	* 2. Provide parsing result to kernel drivers
	15	*
	16	*/
	17	#include <linux/init.h>
	18	#include <linux/export.h>
	19	#include <linux/module.h>
	20	#include <linux/device.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/io.h>
	23	#include <linux/acpi.h>
	24	#include <linux/uaccess.h>
	25	#include <linux/miscdevice.h>
	26	#include "acpi_thermal_rel.h"
	27
	28	static acpi_handle acpi_thermal_rel_handle;
	29	static DEFINE_SPINLOCK(acpi_thermal_rel_chrdev_lock);
	30	static int acpi_thermal_rel_chrdev_count; /* #times opened */
	31	static int acpi_thermal_rel_chrdev_exclu; /* already open exclusive? */
	32
	33	static int acpi_thermal_rel_open(struct inode inode, struct file file)
	34	{
	35	spin_lock(&acpi_thermal_rel_chrdev_lock);
	36	if (acpi_thermal_rel_chrdev_exclu \|\|
	37	(acpi_thermal_rel_chrdev_count && (file->f_flags & O_EXCL))) {
	38	spin_unlock(&acpi_thermal_rel_chrdev_lock);
	39	return -EBUSY;
	40	}
	41
	42	if (file->f_flags & O_EXCL)
	43	acpi_thermal_rel_chrdev_exclu = 1;
	44	acpi_thermal_rel_chrdev_count++;
	45
	46	spin_unlock(&acpi_thermal_rel_chrdev_lock);
	47
	48	return nonseekable_open(inode, file);
	49	}
	50
	51	static int acpi_thermal_rel_release(struct inode inode, struct file file)
	52	{
	53	spin_lock(&acpi_thermal_rel_chrdev_lock);
	54	acpi_thermal_rel_chrdev_count--;
	55	acpi_thermal_rel_chrdev_exclu = 0;
	56	spin_unlock(&acpi_thermal_rel_chrdev_lock);
	57
	58	return 0;
	59	}
	60
	61	/**
	62	* acpi_parse_trt - Thermal Relationship Table _TRT for passive cooling
	63	*
	64	* @handle: ACPI handle of the device contains _TRT
86326031 SP	65	* @trt_count: the number of valid entries resulted from parsing _TRT
86326031 SP	66	* @trtp: pointer to pointer of array of _TRT entries in parsing result
52b1c69d JP	67	* @create_dev: whether to create platform devices for target and source
	68	*
	69	*/
	70	int acpi_parse_trt(acpi_handle handle, int trt_count, struct trt *trtp,
	71	bool create_dev)
	72	{
	73	acpi_status status;
	74	int result = 0;
	75	int i;
	76	int nr_bad_entries = 0;
	77	struct trt *trts;
	78	struct acpi_device *adev;
	79	union acpi_object *p;
	80	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	81	struct acpi_buffer element = { 0, NULL };
	82	struct acpi_buffer trt_format = { sizeof("RRNNNNNN"), "RRNNNNNN" };
	83
	84	if (!acpi_has_method(handle, "_TRT"))
7b094063	85	return -ENODEV;
52b1c69d JP	86
	87	status = acpi_evaluate_object(handle, "_TRT", NULL, &buffer);
	88	if (ACPI_FAILURE(status))
	89	return -ENODEV;
	90
	91	p = buffer.pointer;
	92	if (!p \|\| (p->type != ACPI_TYPE_PACKAGE)) {
	93	pr_err("Invalid _TRT data\n");
	94	result = -EFAULT;
	95	goto end;
	96	}
	97
	98	*trt_count = p->package.count;
	99	trts = kzalloc(trt_count sizeof(struct trt), GFP_KERNEL);
	100	if (!trts) {
	101	result = -ENOMEM;
	102	goto end;
	103	}
	104
	105	for (i = 0; i < *trt_count; i++) {
	106	struct trt *trt = &trts[i - nr_bad_entries];
	107
	108	element.length = sizeof(struct trt);
	109	element.pointer = trt;
	110
	111	status = acpi_extract_package(&(p->package.elements[i]),
	112	&trt_format, &element);
	113	if (ACPI_FAILURE(status)) {
	114	nr_bad_entries++;
	115	pr_warn("_TRT package %d is invalid, ignored\n", i);
	116	continue;
	117	}
	118	if (!create_dev)
	119	continue;
	120
	121	result = acpi_bus_get_device(trt->source, &adev);
48628e40	122	if (result)
52b1c69d JP	123	pr_warn("Failed to get source ACPI device\n");
	124
	125	result = acpi_bus_get_device(trt->target, &adev);
48628e40	126	if (result)
52b1c69d JP	127	pr_warn("Failed to get target ACPI device\n");
	128	}
	129
e413ad7c IK	130	result = 0;
e413ad7c IK	131
52b1c69d JP	132	*trtp = trts;
	133	/* don't count bad entries */
	134	*trt_count -= nr_bad_entries;
	135	end:
	136	kfree(buffer.pointer);
	137	return result;
	138	}
	139	EXPORT_SYMBOL(acpi_parse_trt);
	140
	141	/**
	142	* acpi_parse_art - Parse Active Relationship Table _ART
	143	*
	144	* @handle: ACPI handle of the device contains _ART
	145	* @art_count: the number of valid entries resulted from parsing _ART
	146	* @artp: pointer to pointer of array of art entries in parsing result
	147	* @create_dev: whether to create platform devices for target and source
	148	*
	149	*/
	150	int acpi_parse_art(acpi_handle handle, int art_count, struct art *artp,
	151	bool create_dev)
	152	{
	153	acpi_status status;
	154	int result = 0;
	155	int i;
	156	int nr_bad_entries = 0;
	157	struct art *arts;
	158	struct acpi_device *adev;
	159	union acpi_object *p;
	160	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	161	struct acpi_buffer element = { 0, NULL };
	162	struct acpi_buffer art_format = {
	163	sizeof("RRNNNNNNNNNNN"), "RRNNNNNNNNNNN" };
	164
	165	if (!acpi_has_method(handle, "_ART"))
7b094063	166	return -ENODEV;
52b1c69d JP	167
	168	status = acpi_evaluate_object(handle, "_ART", NULL, &buffer);
	169	if (ACPI_FAILURE(status))
	170	return -ENODEV;
	171
	172	p = buffer.pointer;
	173	if (!p \|\| (p->type != ACPI_TYPE_PACKAGE)) {
	174	pr_err("Invalid _ART data\n");
	175	result = -EFAULT;
	176	goto end;
	177	}
	178
	179	/* ignore p->package.elements[0], as this is _ART Revision field */
	180	*art_count = p->package.count - 1;
	181	arts = kzalloc(art_count sizeof(struct art), GFP_KERNEL);
	182	if (!arts) {
	183	result = -ENOMEM;
	184	goto end;
	185	}
	186
	187	for (i = 0; i < *art_count; i++) {
	188	struct art *art = &arts[i - nr_bad_entries];
	189
	190	element.length = sizeof(struct art);
	191	element.pointer = art;
	192
	193	status = acpi_extract_package(&(p->package.elements[i + 1]),
	194	&art_format, &element);
	195	if (ACPI_FAILURE(status)) {
	196	pr_warn("_ART package %d is invalid, ignored", i);
	197	nr_bad_entries++;
	198	continue;
	199	}
	200	if (!create_dev)
	201	continue;
	202
	203	if (art->source) {
	204	result = acpi_bus_get_device(art->source, &adev);
48628e40	205	if (result)
52b1c69d JP	206	pr_warn("Failed to get source ACPI device\n");
	207	}
	208	if (art->target) {
	209	result = acpi_bus_get_device(art->target, &adev);
48628e40	210	if (result)
86326031	211	pr_warn("Failed to get target ACPI device\n");
52b1c69d JP	212	}
	213	}
	214
	215	*artp = arts;
	216	/* don't count bad entries */
	217	*art_count -= nr_bad_entries;
	218	end:
	219	kfree(buffer.pointer);
	220	return result;
	221	}
	222	EXPORT_SYMBOL(acpi_parse_art);
	223
	224
	225	/* get device name from acpi handle */
	226	static void get_single_name(acpi_handle handle, char *name)
	227	{
	228	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};
	229
	230	if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer)))
	231	pr_warn("Failed get name from handle\n");
	232	else {
	233	memcpy(name, buffer.pointer, ACPI_NAME_SIZE);
	234	kfree(buffer.pointer);
	235	}
	236	}
	237
	238	static int fill_art(char __user *ubuf)
	239	{
	240	int i;
	241	int ret;
	242	int count;
	243	int art_len;
	244	struct art *arts = NULL;
	245	union art_object *art_user;
	246
	247	ret = acpi_parse_art(acpi_thermal_rel_handle, &count, &arts, false);
	248	if (ret)
	249	goto free_art;
	250	art_len = count * sizeof(union art_object);
	251	art_user = kzalloc(art_len, GFP_KERNEL);
	252	if (!art_user) {
	253	ret = -ENOMEM;
	254	goto free_art;
	255	}
	256	/* now fill in user art data */
	257	for (i = 0; i < count; i++) {
	258	/* userspace art needs device name instead of acpi reference */
	259	get_single_name(arts[i].source, art_user[i].source_device);
	260	get_single_name(arts[i].target, art_user[i].target_device);
	261	/* copy the rest int data in addition to source and target */
	262	memcpy(&art_user[i].weight, &arts[i].weight,
	263	sizeof(u64) * (ACPI_NR_ART_ELEMENTS - 2));
	264	}
	265
	266	if (copy_to_user(ubuf, art_user, art_len))
	267	ret = -EFAULT;
	268	kfree(art_user);
	269	free_art:
	270	kfree(arts);
	271	return ret;
	272	}
	273
	274	static int fill_trt(char __user *ubuf)
	275	{
276	int i;
277	int ret;
278	int count;
279	int trt_len;
280	struct trt *trts = NULL;
281	union trt_object *trt_user;
282
283	ret = acpi_parse_trt(acpi_thermal_rel_handle, &count, &trts, false);
284	if (ret)
285	goto free_trt;
286	trt_len = count * sizeof(union trt_object);
287	trt_user = kzalloc(trt_len, GFP_KERNEL);
288	if (!trt_user) {
289	ret = -ENOMEM;
290	goto free_trt;
291	}
292	/* now fill in user trt data */
293	for (i = 0; i < count; i++) {
294	/* userspace trt needs device name instead of acpi reference */
295	get_single_name(trts[i].source, trt_user[i].source_device);
296	get_single_name(trts[i].target, trt_user[i].target_device);
297	trt_user[i].sample_period = trts[i].sample_period;
298	trt_user[i].influence = trts[i].influence;
299	}
300
301	if (copy_to_user(ubuf, trt_user, trt_len))
302	ret = -EFAULT;
303	kfree(trt_user);
304	free_trt:
305	kfree(trts);
306	return ret;
307	}
308
309	static long acpi_thermal_rel_ioctl(struct file *f, unsigned int cmd,
310	unsigned long __arg)
311	{
312	int ret = 0;
313	unsigned long length = 0;
b81e5962	314	int count = 0;
52b1c69d	315	char __user arg = (void __user )__arg;
7b094063 IK	316	struct trt *trts = NULL;
7b094063 IK	317	struct art *arts = NULL;
52b1c69d JP	318
	319	switch (cmd) {
	320	case ACPI_THERMAL_GET_TRT_COUNT:
b81e5962	321	ret = acpi_parse_trt(acpi_thermal_rel_handle, &count,
52b1c69d JP	322	&trts, false);
	323	kfree(trts);
	324	if (!ret)
	325	return put_user(count, (unsigned long __user *)__arg);
	326	return ret;
	327	case ACPI_THERMAL_GET_TRT_LEN:
b81e5962	328	ret = acpi_parse_trt(acpi_thermal_rel_handle, &count,
52b1c69d JP	329	&trts, false);
	330	kfree(trts);
	331	length = count * sizeof(union trt_object);
	332	if (!ret)
	333	return put_user(length, (unsigned long __user *)__arg);
	334	return ret;
	335	case ACPI_THERMAL_GET_TRT:
	336	return fill_trt(arg);
	337	case ACPI_THERMAL_GET_ART_COUNT:
b81e5962	338	ret = acpi_parse_art(acpi_thermal_rel_handle, &count,
52b1c69d JP	339	&arts, false);
	340	kfree(arts);
	341	if (!ret)
	342	return put_user(count, (unsigned long __user *)__arg);
	343	return ret;
	344	case ACPI_THERMAL_GET_ART_LEN:
b81e5962	345	ret = acpi_parse_art(acpi_thermal_rel_handle, &count,
52b1c69d JP	346	&arts, false);
	347	kfree(arts);
	348	length = count * sizeof(union art_object);
	349	if (!ret)
	350	return put_user(length, (unsigned long __user *)__arg);
	351	return ret;
	352
	353	case ACPI_THERMAL_GET_ART:
	354	return fill_art(arg);
	355
	356	default:
	357	return -ENOTTY;
	358	}
	359	}
	360
	361	static const struct file_operations acpi_thermal_rel_fops = {
	362	.owner = THIS_MODULE,
	363	.open = acpi_thermal_rel_open,
	364	.release = acpi_thermal_rel_release,
	365	.unlocked_ioctl = acpi_thermal_rel_ioctl,
	366	.llseek = no_llseek,
	367	};
	368
	369	static struct miscdevice acpi_thermal_rel_misc_device = {
	370	.minor = MISC_DYNAMIC_MINOR,
	371	"acpi_thermal_rel",
	372	&acpi_thermal_rel_fops
	373	};
	374
	375	int acpi_thermal_rel_misc_device_add(acpi_handle handle)
	376	{
	377	acpi_thermal_rel_handle = handle;
	378
	379	return misc_register(&acpi_thermal_rel_misc_device);
	380	}
	381	EXPORT_SYMBOL(acpi_thermal_rel_misc_device_add);
	382
	383	int acpi_thermal_rel_misc_device_remove(acpi_handle handle)
	384	{
	385	misc_deregister(&acpi_thermal_rel_misc_device);
	386
	387	return 0;
	388	}
	389	EXPORT_SYMBOL(acpi_thermal_rel_misc_device_remove);
	390
	391	MODULE_AUTHOR("Zhang Rui <rui.zhang@intel.com>");
	392	MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@intel.com");
	393	MODULE_DESCRIPTION("Intel acpi thermal rel misc dev driver");
	394	MODULE_LICENSE("GPL v2");