root/drivers/platform/x86/intel_menlow.c

DEFINITIONS

1. memory_get_max_bandwidth
2. memory_get_cur_bandwidth
3. memory_set_cur_bandwidth
4. intel_menlow_memory_add
5. intel_menlow_memory_remove
6. sensor_get_auxtrip
7. sensor_set_auxtrip
8. aux_show
9. aux0_show
10. aux1_show
11. aux_store
12. aux0_store
13. aux1_store
14. bios_enabled_show
15. intel_menlow_add_one_attribute
16. intel_menlow_register_sensor
17. intel_menlow_unregister_sensor
18. intel_menlow_module_init
19. intel_menlow_module_exit

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Intel menlow Driver for thermal management extension
   4  *
   5  *  Copyright (C) 2008 Intel Corp
   6  *  Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
   7  *  Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
   8  *
   9  *  This driver creates the sys I/F for programming the sensors.
  10  *  It also implements the driver for intel menlow memory controller (hardware
  11  *  id is INT0002) which makes use of the platform specific ACPI methods
  12  *  to get/set bandwidth.
  13  */
  14 
  15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  16 
  17 #include <linux/acpi.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/pci.h>
  21 #include <linux/pm.h>
  22 #include <linux/slab.h>
  23 #include <linux/thermal.h>
  24 #include <linux/types.h>
  25 
  26 MODULE_AUTHOR("Thomas Sujith");
  27 MODULE_AUTHOR("Zhang Rui");
  28 MODULE_DESCRIPTION("Intel Menlow platform specific driver");
  29 MODULE_LICENSE("GPL v2");
  30 
  31 /*
  32  * Memory controller device control
  33  */
  34 
  35 #define MEMORY_GET_BANDWIDTH "GTHS"
  36 #define MEMORY_SET_BANDWIDTH "STHS"
  37 #define MEMORY_ARG_CUR_BANDWIDTH 1
  38 #define MEMORY_ARG_MAX_BANDWIDTH 0
  39 
  40 static void intel_menlow_unregister_sensor(void);
  41 
  42 /*
  43  * GTHS returning 'n' would mean that [0,n-1] states are supported
  44  * In that case max_cstate would be n-1
  45  * GTHS returning '0' would mean that no bandwidth control states are supported
  46  */
  47 static int memory_get_max_bandwidth(struct thermal_cooling_device *cdev,
  48                                     unsigned long *max_state)
  49 {
  50         struct acpi_device *device = cdev->devdata;
  51         acpi_handle handle = device->handle;
  52         unsigned long long value;
  53         struct acpi_object_list arg_list;
  54         union acpi_object arg;
  55         acpi_status status = AE_OK;
  56 
  57         arg_list.count = 1;
  58         arg_list.pointer = &arg;
  59         arg.type = ACPI_TYPE_INTEGER;
  60         arg.integer.value = MEMORY_ARG_MAX_BANDWIDTH;
  61         status = acpi_evaluate_integer(handle, MEMORY_GET_BANDWIDTH,
  62                                        &arg_list, &value);
  63         if (ACPI_FAILURE(status))
  64                 return -EFAULT;
  65 
  66         if (!value)
  67                 return -EINVAL;
  68 
  69         *max_state = value - 1;
  70         return 0;
  71 }
  72 
  73 static int memory_get_cur_bandwidth(struct thermal_cooling_device *cdev,
  74                                     unsigned long *value)
  75 {
  76         struct acpi_device *device = cdev->devdata;
  77         acpi_handle handle = device->handle;
  78         unsigned long long result;
  79         struct acpi_object_list arg_list;
  80         union acpi_object arg;
  81         acpi_status status = AE_OK;
  82 
  83         arg_list.count = 1;
  84         arg_list.pointer = &arg;
  85         arg.type = ACPI_TYPE_INTEGER;
  86         arg.integer.value = MEMORY_ARG_CUR_BANDWIDTH;
  87         status = acpi_evaluate_integer(handle, MEMORY_GET_BANDWIDTH,
  88                                        &arg_list, &result);
  89         if (ACPI_FAILURE(status))
  90                 return -EFAULT;
  91 
  92         *value = result;
  93         return 0;
  94 }
  95 
  96 static int memory_set_cur_bandwidth(struct thermal_cooling_device *cdev,
  97                                     unsigned long state)
  98 {
  99         struct acpi_device *device = cdev->devdata;
 100         acpi_handle handle = device->handle;
 101         struct acpi_object_list arg_list;
 102         union acpi_object arg;
 103         acpi_status status;
 104         unsigned long long temp;
 105         unsigned long max_state;
 106 
 107         if (memory_get_max_bandwidth(cdev, &max_state))
 108                 return -EFAULT;
 109 
 110         if (state > max_state)
 111                 return -EINVAL;
 112 
 113         arg_list.count = 1;
 114         arg_list.pointer = &arg;
 115         arg.type = ACPI_TYPE_INTEGER;
 116         arg.integer.value = state;
 117 
 118         status =
 119             acpi_evaluate_integer(handle, MEMORY_SET_BANDWIDTH, &arg_list,
 120                                   &temp);
 121 
 122         pr_info("Bandwidth value was %ld: status is %d\n", state, status);
 123         if (ACPI_FAILURE(status))
 124                 return -EFAULT;
 125 
 126         return 0;
 127 }
 128 
 129 static const struct thermal_cooling_device_ops memory_cooling_ops = {
 130         .get_max_state = memory_get_max_bandwidth,
 131         .get_cur_state = memory_get_cur_bandwidth,
 132         .set_cur_state = memory_set_cur_bandwidth,
 133 };
 134 
 135 /*
 136  * Memory Device Management
 137  */
 138 static int intel_menlow_memory_add(struct acpi_device *device)
 139 {
 140         int result = -ENODEV;
 141         struct thermal_cooling_device *cdev;
 142 
 143         if (!device)
 144                 return -EINVAL;
 145 
 146         if (!acpi_has_method(device->handle, MEMORY_GET_BANDWIDTH))
 147                 goto end;
 148 
 149         if (!acpi_has_method(device->handle, MEMORY_SET_BANDWIDTH))
 150                 goto end;
 151 
 152         cdev = thermal_cooling_device_register("Memory controller", device,
 153                                                &memory_cooling_ops);
 154         if (IS_ERR(cdev)) {
 155                 result = PTR_ERR(cdev);
 156                 goto end;
 157         }
 158 
 159         device->driver_data = cdev;
 160         result = sysfs_create_link(&device->dev.kobj,
 161                                 &cdev->device.kobj, "thermal_cooling");
 162         if (result)
 163                 goto unregister;
 164 
 165         result = sysfs_create_link(&cdev->device.kobj,
 166                                 &device->dev.kobj, "device");
 167         if (result) {
 168                 sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
 169                 goto unregister;
 170         }
 171 
 172  end:
 173         return result;
 174 
 175  unregister:
 176         thermal_cooling_device_unregister(cdev);
 177         return result;
 178 
 179 }
 180 
 181 static int intel_menlow_memory_remove(struct acpi_device *device)
 182 {
 183         struct thermal_cooling_device *cdev;
 184 
 185         if (!device)
 186                 return -EINVAL;
 187 
 188         cdev = acpi_driver_data(device);
 189         if (!cdev)
 190                 return -EINVAL;
 191 
 192         sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
 193         sysfs_remove_link(&cdev->device.kobj, "device");
 194         thermal_cooling_device_unregister(cdev);
 195 
 196         return 0;
 197 }
 198 
 199 static const struct acpi_device_id intel_menlow_memory_ids[] = {
 200         {"INT0002", 0},
 201         {"", 0},
 202 };
 203 
 204 static struct acpi_driver intel_menlow_memory_driver = {
 205         .name = "intel_menlow_thermal_control",
 206         .ids = intel_menlow_memory_ids,
 207         .ops = {
 208                 .add = intel_menlow_memory_add,
 209                 .remove = intel_menlow_memory_remove,
 210                 },
 211 };
 212 
 213 /*
 214  * Sensor control on menlow platform
 215  */
 216 
 217 #define THERMAL_AUX0 0
 218 #define THERMAL_AUX1 1
 219 #define GET_AUX0 "GAX0"
 220 #define GET_AUX1 "GAX1"
 221 #define SET_AUX0 "SAX0"
 222 #define SET_AUX1 "SAX1"
 223 
 224 struct intel_menlow_attribute {
 225         struct device_attribute attr;
 226         struct device *device;
 227         acpi_handle handle;
 228         struct list_head node;
 229 };
 230 
 231 static LIST_HEAD(intel_menlow_attr_list);
 232 static DEFINE_MUTEX(intel_menlow_attr_lock);
 233 
 234 /*
 235  * sensor_get_auxtrip - get the current auxtrip value from sensor
 236  * @name: Thermalzone name
 237  * @auxtype : AUX0/AUX1
 238  * @buf: syfs buffer
 239  */
 240 static int sensor_get_auxtrip(acpi_handle handle, int index,
 241                                                         unsigned long long *value)
 242 {
 243         acpi_status status;
 244 
 245         if ((index != 0 && index != 1) || !value)
 246                 return -EINVAL;
 247 
 248         status = acpi_evaluate_integer(handle, index ? GET_AUX1 : GET_AUX0,
 249                                        NULL, value);
 250         if (ACPI_FAILURE(status))
 251                 return -EIO;
 252 
 253         return 0;
 254 }
 255 
 256 /*
 257  * sensor_set_auxtrip - set the new auxtrip value to sensor
 258  * @name: Thermalzone name
 259  * @auxtype : AUX0/AUX1
 260  * @buf: syfs buffer
 261  */
 262 static int sensor_set_auxtrip(acpi_handle handle, int index, int value)
 263 {
 264         acpi_status status;
 265         union acpi_object arg = {
 266                 ACPI_TYPE_INTEGER
 267         };
 268         struct acpi_object_list args = {
 269                 1, &arg
 270         };
 271         unsigned long long temp;
 272 
 273         if (index != 0 && index != 1)
 274                 return -EINVAL;
 275 
 276         status = acpi_evaluate_integer(handle, index ? GET_AUX0 : GET_AUX1,
 277                                        NULL, &temp);
 278         if (ACPI_FAILURE(status))
 279                 return -EIO;
 280         if ((index && value < temp) || (!index && value > temp))
 281                 return -EINVAL;
 282 
 283         arg.integer.value = value;
 284         status = acpi_evaluate_integer(handle, index ? SET_AUX1 : SET_AUX0,
 285                                        &args, &temp);
 286         if (ACPI_FAILURE(status))
 287                 return -EIO;
 288 
 289         /* do we need to check the return value of SAX0/SAX1 ? */
 290 
 291         return 0;
 292 }
 293 
 294 #define to_intel_menlow_attr(_attr)     \
 295         container_of(_attr, struct intel_menlow_attribute, attr)
 296 
 297 static ssize_t aux_show(struct device *dev, struct device_attribute *dev_attr,
 298                         char *buf, int idx)
 299 {
 300         struct intel_menlow_attribute *attr = to_intel_menlow_attr(dev_attr);
 301         unsigned long long value;
 302         int result;
 303 
 304         result = sensor_get_auxtrip(attr->handle, idx, &value);
 305 
 306         return result ? result : sprintf(buf, "%lu", DECI_KELVIN_TO_CELSIUS(value));
 307 }
 308 
 309 static ssize_t aux0_show(struct device *dev,
 310                          struct device_attribute *dev_attr, char *buf)
 311 {
 312         return aux_show(dev, dev_attr, buf, 0);
 313 }
 314 
 315 static ssize_t aux1_show(struct device *dev,
 316                          struct device_attribute *dev_attr, char *buf)
 317 {
 318         return aux_show(dev, dev_attr, buf, 1);
 319 }
 320 
 321 static ssize_t aux_store(struct device *dev, struct device_attribute *dev_attr,
 322                          const char *buf, size_t count, int idx)
 323 {
 324         struct intel_menlow_attribute *attr = to_intel_menlow_attr(dev_attr);
 325         int value;
 326         int result;
 327 
 328         /*Sanity check; should be a positive integer */
 329         if (!sscanf(buf, "%d", &value))
 330                 return -EINVAL;
 331 
 332         if (value < 0)
 333                 return -EINVAL;
 334 
 335         result = sensor_set_auxtrip(attr->handle, idx, 
 336                                     CELSIUS_TO_DECI_KELVIN(value));
 337         return result ? result : count;
 338 }
 339 
 340 static ssize_t aux0_store(struct device *dev,
 341                           struct device_attribute *dev_attr,
 342                           const char *buf, size_t count)
 343 {
 344         return aux_store(dev, dev_attr, buf, count, 0);
 345 }
 346 
 347 static ssize_t aux1_store(struct device *dev,
 348                           struct device_attribute *dev_attr,
 349                           const char *buf, size_t count)
 350 {
 351         return aux_store(dev, dev_attr, buf, count, 1);
 352 }
 353 
 354 /* BIOS can enable/disable the thermal user application in dabney platform */
 355 #define BIOS_ENABLED "\\_TZ.GSTS"
 356 static ssize_t bios_enabled_show(struct device *dev,
 357                                  struct device_attribute *attr, char *buf)
 358 {
 359         acpi_status status;
 360         unsigned long long bios_enabled;
 361 
 362         status = acpi_evaluate_integer(NULL, BIOS_ENABLED, NULL, &bios_enabled);
 363         if (ACPI_FAILURE(status))
 364                 return -ENODEV;
 365 
 366         return sprintf(buf, "%s\n", bios_enabled ? "enabled" : "disabled");
 367 }
 368 
 369 static int intel_menlow_add_one_attribute(char *name, umode_t mode, void *show,
 370                                           void *store, struct device *dev,
 371                                           acpi_handle handle)
 372 {
 373         struct intel_menlow_attribute *attr;
 374         int result;
 375 
 376         attr = kzalloc(sizeof(struct intel_menlow_attribute), GFP_KERNEL);
 377         if (!attr)
 378                 return -ENOMEM;
 379 
 380         sysfs_attr_init(&attr->attr.attr); /* That is consistent naming :D */
 381         attr->attr.attr.name = name;
 382         attr->attr.attr.mode = mode;
 383         attr->attr.show = show;
 384         attr->attr.store = store;
 385         attr->device = dev;
 386         attr->handle = handle;
 387 
 388         result = device_create_file(dev, &attr->attr);
 389         if (result) {
 390                 kfree(attr);
 391                 return result;
 392         }
 393 
 394         mutex_lock(&intel_menlow_attr_lock);
 395         list_add_tail(&attr->node, &intel_menlow_attr_list);
 396         mutex_unlock(&intel_menlow_attr_lock);
 397 
 398         return 0;
 399 }
 400 
 401 static acpi_status intel_menlow_register_sensor(acpi_handle handle, u32 lvl,
 402                                                 void *context, void **rv)
 403 {
 404         acpi_status status;
 405         acpi_handle dummy;
 406         struct thermal_zone_device *thermal;
 407         int result;
 408 
 409         result = acpi_bus_get_private_data(handle, (void **)&thermal);
 410         if (result)
 411                 return 0;
 412 
 413         /* _TZ must have the AUX0/1 methods */
 414         status = acpi_get_handle(handle, GET_AUX0, &dummy);
 415         if (ACPI_FAILURE(status))
 416                 return (status == AE_NOT_FOUND) ? AE_OK : status;
 417 
 418         status = acpi_get_handle(handle, SET_AUX0, &dummy);
 419         if (ACPI_FAILURE(status))
 420                 return (status == AE_NOT_FOUND) ? AE_OK : status;
 421 
 422         result = intel_menlow_add_one_attribute("aux0", 0644,
 423                                                 aux0_show, aux0_store,
 424                                                 &thermal->device, handle);
 425         if (result)
 426                 return AE_ERROR;
 427 
 428         status = acpi_get_handle(handle, GET_AUX1, &dummy);
 429         if (ACPI_FAILURE(status))
 430                 goto aux1_not_found;
 431 
 432         status = acpi_get_handle(handle, SET_AUX1, &dummy);
 433         if (ACPI_FAILURE(status))
 434                 goto aux1_not_found;
 435 
 436         result = intel_menlow_add_one_attribute("aux1", 0644,
 437                                                 aux1_show, aux1_store,
 438                                                 &thermal->device, handle);
 439         if (result) {
 440                 intel_menlow_unregister_sensor();
 441                 return AE_ERROR;
 442         }
 443 
 444         /*
 445          * create the "dabney_enabled" attribute which means the user app
 446          * should be loaded or not
 447          */
 448 
 449         result = intel_menlow_add_one_attribute("bios_enabled", 0444,
 450                                                 bios_enabled_show, NULL,
 451                                                 &thermal->device, handle);
 452         if (result) {
 453                 intel_menlow_unregister_sensor();
 454                 return AE_ERROR;
 455         }
 456 
 457         return AE_OK;
 458 
 459  aux1_not_found:
 460         if (status == AE_NOT_FOUND)
 461                 return AE_OK;
 462 
 463         intel_menlow_unregister_sensor();
 464         return status;
 465 }
 466 
 467 static void intel_menlow_unregister_sensor(void)
 468 {
 469         struct intel_menlow_attribute *pos, *next;
 470 
 471         mutex_lock(&intel_menlow_attr_lock);
 472         list_for_each_entry_safe(pos, next, &intel_menlow_attr_list, node) {
 473                 list_del(&pos->node);
 474                 device_remove_file(pos->device, &pos->attr);
 475                 kfree(pos);
 476         }
 477         mutex_unlock(&intel_menlow_attr_lock);
 478 
 479         return;
 480 }
 481 
 482 static int __init intel_menlow_module_init(void)
 483 {
 484         int result = -ENODEV;
 485         acpi_status status;
 486         unsigned long long enable;
 487 
 488         if (acpi_disabled)
 489                 return result;
 490 
 491         /* Looking for the \_TZ.GSTS method */
 492         status = acpi_evaluate_integer(NULL, BIOS_ENABLED, NULL, &enable);
 493         if (ACPI_FAILURE(status) || !enable)
 494                 return -ENODEV;
 495 
 496         /* Looking for ACPI device MEM0 with hardware id INT0002 */
 497         result = acpi_bus_register_driver(&intel_menlow_memory_driver);
 498         if (result)
 499                 return result;
 500 
 501         /* Looking for sensors in each ACPI thermal zone */
 502         status = acpi_walk_namespace(ACPI_TYPE_THERMAL, ACPI_ROOT_OBJECT,
 503                                      ACPI_UINT32_MAX,
 504                                      intel_menlow_register_sensor, NULL, NULL, NULL);
 505         if (ACPI_FAILURE(status)) {
 506                 acpi_bus_unregister_driver(&intel_menlow_memory_driver);
 507                 return -ENODEV;
 508         }
 509 
 510         return 0;
 511 }
 512 
 513 static void __exit intel_menlow_module_exit(void)
 514 {
 515         acpi_bus_unregister_driver(&intel_menlow_memory_driver);
 516         intel_menlow_unregister_sensor();
 517 }
 518 
 519 module_init(intel_menlow_module_init);
 520 module_exit(intel_menlow_module_exit);