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 0;
  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                         acpi_create_platform_device(adev);
 124                 else
 125                         pr_warn("Failed to get source ACPI device\n");
 126
 127                 result = acpi_bus_get_device(trt->target, &adev);
 128                 if (!result)
 129                         acpi_create_platform_device(adev);
 130                 else
 131                         pr_warn("Failed to get target ACPI device\n");
 132         }
 133
 134         *trtp = trts;
 135         /* don't count bad entries */
 136         *trt_count -= nr_bad_entries;
 137 end:
 138         kfree(buffer.pointer);
 139         return result;
 140 }
 141 EXPORT_SYMBOL(acpi_parse_trt);
 142
 143 /**
 144  * acpi_parse_art - Parse Active Relationship Table _ART
 145  *
 146  * @handle: ACPI handle of the device contains _ART
 147  * @art_count: the number of valid entries resulted from parsing _ART
 148  * @artp: pointer to pointer of array of art entries in parsing result
 149  * @create_dev: whether to create platform devices for target and source
 150  *
 151  */
 152 int acpi_parse_art(acpi_handle handle, int *art_count, struct art **artp,
 153                 bool create_dev)
 154 {
 155         acpi_status status;
 156         int result = 0;
 157         int i;
 158         int nr_bad_entries = 0;
 159         struct art *arts;
 160         struct acpi_device *adev;
 161         union acpi_object *p;
 162         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 163         struct acpi_buffer element = { 0, NULL };
 164         struct acpi_buffer art_format = {
 165                 sizeof("RRNNNNNNNNNNN"), "RRNNNNNNNNNNN" };
 166
 167         if (!acpi_has_method(handle, "_ART"))
 168                 return 0;
 169
 170         status = acpi_evaluate_object(handle, "_ART", NULL, &buffer);
 171         if (ACPI_FAILURE(status))
 172                 return -ENODEV;
 173
 174         p = buffer.pointer;
 175         if (!p || (p->type != ACPI_TYPE_PACKAGE)) {
 176                 pr_err("Invalid _ART data\n");
 177                 result = -EFAULT;
 178                 goto end;
 179         }
 180
 181         /* ignore p->package.elements[0], as this is _ART Revision field */
 182         *art_count = p->package.count - 1;
 183         arts = kzalloc(*art_count * sizeof(struct art), GFP_KERNEL);
 184         if (!arts) {
 185                 result = -ENOMEM;
 186                 goto end;
 187         }
 188
 189         for (i = 0; i < *art_count; i++) {
 190                 struct art *art = &arts[i - nr_bad_entries];
 191
 192                 element.length = sizeof(struct art);
 193                 element.pointer = art;
 194
 195                 status = acpi_extract_package(&(p->package.elements[i + 1]),
 196                                               &art_format, &element);
 197                 if (ACPI_FAILURE(status)) {
 198                         pr_warn("_ART package %d is invalid, ignored", i);
 199                         nr_bad_entries++;
 200                         continue;
 201                 }
 202                 if (!create_dev)
 203                         continue;
 204
 205                 if (art->source) {
 206                         result = acpi_bus_get_device(art->source, &adev);
 207                         if (!result)
 208                                 acpi_create_platform_device(adev);
 209                         else
 210                                 pr_warn("Failed to get source ACPI device\n");
 211                 }
 212                 if (art->target) {
 213                         result = acpi_bus_get_device(art->target, &adev);
 214                         if (!result)
 215                                 acpi_create_platform_device(adev);
 216                         else
 217                                 pr_warn("Failed to get source ACPI device\n");
 218                 }
 219         }
 220
 221         *artp = arts;
 222         /* don't count bad entries */
 223         *art_count -= nr_bad_entries;
 224 end:
 225         kfree(buffer.pointer);
 226         return result;
 227 }
 228 EXPORT_SYMBOL(acpi_parse_art);
 229
 230
 231 /* get device name from acpi handle */
 232 static void get_single_name(acpi_handle handle, char *name)
 233 {
 234         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};
 235
 236         if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer)))
 237                 pr_warn("Failed get name from handle\n");
 238         else {
 239                 memcpy(name, buffer.pointer, ACPI_NAME_SIZE);
 240                 kfree(buffer.pointer);
 241         }
 242 }
 243
 244 static int fill_art(char __user *ubuf)
 245 {
 246         int i;
 247         int ret;
 248         int count;
 249         int art_len;
 250         struct art *arts = NULL;
 251         union art_object *art_user;
 252
 253         ret = acpi_parse_art(acpi_thermal_rel_handle, &count, &arts, false);
 254         if (ret)
 255                 goto free_art;
 256         art_len = count * sizeof(union art_object);
 257         art_user = kzalloc(art_len, GFP_KERNEL);
 258         if (!art_user) {
 259                 ret = -ENOMEM;
 260                 goto free_art;
 261         }
 262         /* now fill in user art data */
 263         for (i = 0; i < count; i++) {
 264                 /* userspace art needs device name instead of acpi reference */
 265                 get_single_name(arts[i].source, art_user[i].source_device);
 266                 get_single_name(arts[i].target, art_user[i].target_device);
 267                 /* copy the rest int data in addition to source and target */
 268                 memcpy(&art_user[i].weight, &arts[i].weight,
 269                         sizeof(u64) * (ACPI_NR_ART_ELEMENTS - 2));
 270         }
 271
 272         if (copy_to_user(ubuf, art_user, art_len))
 273                 ret = -EFAULT;
 274         kfree(art_user);
 275 free_art:
 276         kfree(arts);
 277         return ret;
 278 }
 279
 280 static int fill_trt(char __user *ubuf)
 281 {
 282         int i;
 283         int ret;
 284         int count;
 285         int trt_len;
 286         struct trt *trts = NULL;
 287         union trt_object *trt_user;
 288
 289         ret = acpi_parse_trt(acpi_thermal_rel_handle, &count, &trts, false);
 290         if (ret)
 291                 goto free_trt;
 292         trt_len = count * sizeof(union trt_object);
 293         trt_user = kzalloc(trt_len, GFP_KERNEL);
 294         if (!trt_user) {
 295                 ret = -ENOMEM;
 296                 goto free_trt;
 297         }
 298         /* now fill in user trt data */
 299         for (i = 0; i < count; i++) {
 300                 /* userspace trt needs device name instead of acpi reference */
 301                 get_single_name(trts[i].source, trt_user[i].source_device);
 302                 get_single_name(trts[i].target, trt_user[i].target_device);
 303                 trt_user[i].sample_period = trts[i].sample_period;
 304                 trt_user[i].influence = trts[i].influence;
 305         }
 306
 307         if (copy_to_user(ubuf, trt_user, trt_len))
 308                 ret = -EFAULT;
 309         kfree(trt_user);
 310 free_trt:
 311         kfree(trts);
 312         return ret;
 313 }
 314
 315 static long acpi_thermal_rel_ioctl(struct file *f, unsigned int cmd,
 316                                    unsigned long __arg)
 317 {
 318         int ret = 0;
 319         unsigned long length = 0;
 320         unsigned long count = 0;
 321         char __user *arg = (void __user *)__arg;
 322         struct trt *trts;
 323         struct art *arts;
 324
 325         switch (cmd) {
 326         case ACPI_THERMAL_GET_TRT_COUNT:
 327                 ret = acpi_parse_trt(acpi_thermal_rel_handle, (int *)&count,
 328                                 &trts, false);
 329                 kfree(trts);
 330                 if (!ret)
 331                         return put_user(count, (unsigned long __user *)__arg);
 332                 return ret;
 333         case ACPI_THERMAL_GET_TRT_LEN:
 334                 ret = acpi_parse_trt(acpi_thermal_rel_handle, (int *)&count,
 335                                 &trts, false);
 336                 kfree(trts);
 337                 length = count * sizeof(union trt_object);
 338                 if (!ret)
 339                         return put_user(length, (unsigned long __user *)__arg);
 340                 return ret;
 341         case ACPI_THERMAL_GET_TRT:
 342                 return fill_trt(arg);
 343         case ACPI_THERMAL_GET_ART_COUNT:
 344                 ret = acpi_parse_art(acpi_thermal_rel_handle, (int *)&count,
 345                                 &arts, false);
 346                 kfree(arts);
 347                 if (!ret)
 348                         return put_user(count, (unsigned long __user *)__arg);
 349                 return ret;
 350         case ACPI_THERMAL_GET_ART_LEN:
 351                 ret = acpi_parse_art(acpi_thermal_rel_handle, (int *)&count,
 352                                 &arts, false);
 353                 kfree(arts);
 354                 length = count * sizeof(union art_object);
 355                 if (!ret)
 356                         return put_user(length, (unsigned long __user *)__arg);
 357                 return ret;
 358
 359         case ACPI_THERMAL_GET_ART:
 360                 return fill_art(arg);
 361
 362         default:
 363                 return -ENOTTY;
 364         }
 365 }
 366
 367 static const struct file_operations acpi_thermal_rel_fops = {
 368         .owner          = THIS_MODULE,
 369         .open           = acpi_thermal_rel_open,
 370         .release        = acpi_thermal_rel_release,
 371         .unlocked_ioctl = acpi_thermal_rel_ioctl,
 372         .llseek         = no_llseek,
 373 };
 374
 375 static struct miscdevice acpi_thermal_rel_misc_device = {
 376         .minor  = MISC_DYNAMIC_MINOR,
 377         "acpi_thermal_rel",
 378         &acpi_thermal_rel_fops
 379 };
 380
 381 int acpi_thermal_rel_misc_device_add(acpi_handle handle)
 382 {
 383         acpi_thermal_rel_handle = handle;
 384
 385         return misc_register(&acpi_thermal_rel_misc_device);
 386 }
 387 EXPORT_SYMBOL(acpi_thermal_rel_misc_device_add);
 388
 389 int acpi_thermal_rel_misc_device_remove(acpi_handle handle)
 390 {
 391         misc_deregister(&acpi_thermal_rel_misc_device);
 392
 393         return 0;
 394 }
 395 EXPORT_SYMBOL(acpi_thermal_rel_misc_device_remove);
 396
 397 MODULE_AUTHOR("Zhang Rui <rui.zhang@intel.com>");
 398 MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@intel.com");
 399 MODULE_DESCRIPTION("Intel acpi thermal rel misc dev driver");
 400 MODULE_LICENSE("GPL v2");