GNU Linux-libre 4.9.283-gnu1
[releases.git] / drivers / thermal / int340x_thermal / acpi_thermal_rel.c
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
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  */
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  */
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 */
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;
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
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");