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
acpi_thermal_rel_open(struct inode * inode,struct file * file)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
acpi_thermal_rel_release(struct inode * inode,struct file * file)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
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
68 *
69 */
acpi_parse_trt(acpi_handle handle,int * trt_count,struct trt ** trtp,bool create_dev)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"))
85 return -ENODEV;
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);
122 if (result)
123 pr_warn("Failed to get source ACPI device\n");
124
125 result = acpi_bus_get_device(trt->target, &adev);
126 if (result)
127 pr_warn("Failed to get target ACPI device\n");
128 }
129
130 result = 0;
131
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 */
acpi_parse_art(acpi_handle handle,int * art_count,struct art ** artp,bool create_dev)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"))
166 return -ENODEV;
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);
205 if (result)
206 pr_warn("Failed to get source ACPI device\n");
207 }
208 if (art->target) {
209 result = acpi_bus_get_device(art->target, &adev);
210 if (result)
211 pr_warn("Failed to get source ACPI device\n");
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 */
get_single_name(acpi_handle handle,char * name)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
fill_art(char __user * ubuf)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
fill_trt(char __user * ubuf)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
acpi_thermal_rel_ioctl(struct file * f,unsigned int cmd,unsigned long __arg)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;
314 int count = 0;
315 char __user *arg = (void __user *)__arg;
316 struct trt *trts = NULL;
317 struct art *arts = NULL;
318
319 switch (cmd) {
320 case ACPI_THERMAL_GET_TRT_COUNT:
321 ret = acpi_parse_trt(acpi_thermal_rel_handle, &count,
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:
328 ret = acpi_parse_trt(acpi_thermal_rel_handle, &count,
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:
338 ret = acpi_parse_art(acpi_thermal_rel_handle, &count,
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:
345 ret = acpi_parse_art(acpi_thermal_rel_handle, &count,
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
acpi_thermal_rel_misc_device_add(acpi_handle handle)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
acpi_thermal_rel_misc_device_remove(acpi_handle handle)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");
395