1 /* acpi_thermal_rel.c driver for exporting ACPI thermal relationship
3 * Copyright (c) 2014 Intel Corp
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.
12 * Two functionalities included:
13 * 1. Export _TRT, _ART, via misc device interface to the userspace.
14 * 2. Provide parsing result to kernel drivers
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>
23 #include <linux/acpi.h>
24 #include <linux/uaccess.h>
25 #include <linux/miscdevice.h>
26 #include "acpi_thermal_rel.h"
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? */
33 static int acpi_thermal_rel_open(struct inode *inode, struct file *file)
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);
42 if (file->f_flags & O_EXCL)
43 acpi_thermal_rel_chrdev_exclu = 1;
44 acpi_thermal_rel_chrdev_count++;
46 spin_unlock(&acpi_thermal_rel_chrdev_lock);
48 return nonseekable_open(inode, file);
51 static int acpi_thermal_rel_release(struct inode *inode, struct file *file)
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);
62 * acpi_parse_trt - Thermal Relationship Table _TRT for passive cooling
64 * @handle: ACPI handle of the device contains _TRT
65 * @art_count: the number of valid entries resulted from parsing _TRT
66 * @artp: pointer to pointer of array of art entries in parsing result
67 * @create_dev: whether to create platform devices for target and source
70 int acpi_parse_trt(acpi_handle handle, int *trt_count, struct trt **trtp,
76 int nr_bad_entries = 0;
78 struct acpi_device *adev;
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" };
84 if (!acpi_has_method(handle, "_TRT"))
87 status = acpi_evaluate_object(handle, "_TRT", NULL, &buffer);
88 if (ACPI_FAILURE(status))
92 if (!p || (p->type != ACPI_TYPE_PACKAGE)) {
93 pr_err("Invalid _TRT data\n");
98 *trt_count = p->package.count;
99 trts = kzalloc(*trt_count * sizeof(struct trt), GFP_KERNEL);
105 for (i = 0; i < *trt_count; i++) {
106 struct trt *trt = &trts[i - nr_bad_entries];
108 element.length = sizeof(struct trt);
109 element.pointer = trt;
111 status = acpi_extract_package(&(p->package.elements[i]),
112 &trt_format, &element);
113 if (ACPI_FAILURE(status)) {
115 pr_warn("_TRT package %d is invalid, ignored\n", i);
121 result = acpi_bus_get_device(trt->source, &adev);
123 acpi_create_platform_device(adev);
125 pr_warn("Failed to get source ACPI device\n");
127 result = acpi_bus_get_device(trt->target, &adev);
129 acpi_create_platform_device(adev);
131 pr_warn("Failed to get target ACPI device\n");
137 /* don't count bad entries */
138 *trt_count -= nr_bad_entries;
140 kfree(buffer.pointer);
143 EXPORT_SYMBOL(acpi_parse_trt);
146 * acpi_parse_art - Parse Active Relationship Table _ART
148 * @handle: ACPI handle of the device contains _ART
149 * @art_count: the number of valid entries resulted from parsing _ART
150 * @artp: pointer to pointer of array of art entries in parsing result
151 * @create_dev: whether to create platform devices for target and source
154 int acpi_parse_art(acpi_handle handle, int *art_count, struct art **artp,
160 int nr_bad_entries = 0;
162 struct acpi_device *adev;
163 union acpi_object *p;
164 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
165 struct acpi_buffer element = { 0, NULL };
166 struct acpi_buffer art_format = {
167 sizeof("RRNNNNNNNNNNN"), "RRNNNNNNNNNNN" };
169 if (!acpi_has_method(handle, "_ART"))
172 status = acpi_evaluate_object(handle, "_ART", NULL, &buffer);
173 if (ACPI_FAILURE(status))
177 if (!p || (p->type != ACPI_TYPE_PACKAGE)) {
178 pr_err("Invalid _ART data\n");
183 /* ignore p->package.elements[0], as this is _ART Revision field */
184 *art_count = p->package.count - 1;
185 arts = kzalloc(*art_count * sizeof(struct art), GFP_KERNEL);
191 for (i = 0; i < *art_count; i++) {
192 struct art *art = &arts[i - nr_bad_entries];
194 element.length = sizeof(struct art);
195 element.pointer = art;
197 status = acpi_extract_package(&(p->package.elements[i + 1]),
198 &art_format, &element);
199 if (ACPI_FAILURE(status)) {
200 pr_warn("_ART package %d is invalid, ignored", i);
208 result = acpi_bus_get_device(art->source, &adev);
210 acpi_create_platform_device(adev);
212 pr_warn("Failed to get source ACPI device\n");
215 result = acpi_bus_get_device(art->target, &adev);
217 acpi_create_platform_device(adev);
219 pr_warn("Failed to get source ACPI device\n");
224 /* don't count bad entries */
225 *art_count -= nr_bad_entries;
227 kfree(buffer.pointer);
230 EXPORT_SYMBOL(acpi_parse_art);
233 /* get device name from acpi handle */
234 static void get_single_name(acpi_handle handle, char *name)
236 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};
238 if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer)))
239 pr_warn("Failed get name from handle\n");
241 memcpy(name, buffer.pointer, ACPI_NAME_SIZE);
242 kfree(buffer.pointer);
246 static int fill_art(char __user *ubuf)
252 struct art *arts = NULL;
253 union art_object *art_user;
255 ret = acpi_parse_art(acpi_thermal_rel_handle, &count, &arts, false);
258 art_len = count * sizeof(union art_object);
259 art_user = kzalloc(art_len, GFP_KERNEL);
264 /* now fill in user art data */
265 for (i = 0; i < count; i++) {
266 /* userspace art needs device name instead of acpi reference */
267 get_single_name(arts[i].source, art_user[i].source_device);
268 get_single_name(arts[i].target, art_user[i].target_device);
269 /* copy the rest int data in addition to source and target */
270 memcpy(&art_user[i].weight, &arts[i].weight,
271 sizeof(u64) * (ACPI_NR_ART_ELEMENTS - 2));
274 if (copy_to_user(ubuf, art_user, art_len))
282 static int fill_trt(char __user *ubuf)
288 struct trt *trts = NULL;
289 union trt_object *trt_user;
291 ret = acpi_parse_trt(acpi_thermal_rel_handle, &count, &trts, false);
294 trt_len = count * sizeof(union trt_object);
295 trt_user = kzalloc(trt_len, GFP_KERNEL);
300 /* now fill in user trt data */
301 for (i = 0; i < count; i++) {
302 /* userspace trt needs device name instead of acpi reference */
303 get_single_name(trts[i].source, trt_user[i].source_device);
304 get_single_name(trts[i].target, trt_user[i].target_device);
305 trt_user[i].sample_period = trts[i].sample_period;
306 trt_user[i].influence = trts[i].influence;
309 if (copy_to_user(ubuf, trt_user, trt_len))
317 static long acpi_thermal_rel_ioctl(struct file *f, unsigned int cmd,
321 unsigned long length = 0;
323 char __user *arg = (void __user *)__arg;
324 struct trt *trts = NULL;
325 struct art *arts = NULL;
328 case ACPI_THERMAL_GET_TRT_COUNT:
329 ret = acpi_parse_trt(acpi_thermal_rel_handle, &count,
333 return put_user(count, (unsigned long __user *)__arg);
335 case ACPI_THERMAL_GET_TRT_LEN:
336 ret = acpi_parse_trt(acpi_thermal_rel_handle, &count,
339 length = count * sizeof(union trt_object);
341 return put_user(length, (unsigned long __user *)__arg);
343 case ACPI_THERMAL_GET_TRT:
344 return fill_trt(arg);
345 case ACPI_THERMAL_GET_ART_COUNT:
346 ret = acpi_parse_art(acpi_thermal_rel_handle, &count,
350 return put_user(count, (unsigned long __user *)__arg);
352 case ACPI_THERMAL_GET_ART_LEN:
353 ret = acpi_parse_art(acpi_thermal_rel_handle, &count,
356 length = count * sizeof(union art_object);
358 return put_user(length, (unsigned long __user *)__arg);
361 case ACPI_THERMAL_GET_ART:
362 return fill_art(arg);
369 static const struct file_operations acpi_thermal_rel_fops = {
370 .owner = THIS_MODULE,
371 .open = acpi_thermal_rel_open,
372 .release = acpi_thermal_rel_release,
373 .unlocked_ioctl = acpi_thermal_rel_ioctl,
377 static struct miscdevice acpi_thermal_rel_misc_device = {
378 .minor = MISC_DYNAMIC_MINOR,
380 &acpi_thermal_rel_fops
383 int acpi_thermal_rel_misc_device_add(acpi_handle handle)
385 acpi_thermal_rel_handle = handle;
387 return misc_register(&acpi_thermal_rel_misc_device);
389 EXPORT_SYMBOL(acpi_thermal_rel_misc_device_add);
391 int acpi_thermal_rel_misc_device_remove(acpi_handle handle)
393 misc_deregister(&acpi_thermal_rel_misc_device);
397 EXPORT_SYMBOL(acpi_thermal_rel_misc_device_remove);
399 MODULE_AUTHOR("Zhang Rui <rui.zhang@intel.com>");
400 MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@intel.com");
401 MODULE_DESCRIPTION("Intel acpi thermal rel misc dev driver");
402 MODULE_LICENSE("GPL v2");