drivers/thermal/thermal_helpers.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  thermal_helpers.c - helper functions to handle thermal devices
   4  *
   5  *  Copyright (C) 2016 Eduardo Valentin <edubezval@gmail.com>
   6  *
   7  *  Highly based on original thermal_core.c
   8  *  Copyright (C) 2008 Intel Corp
   9  *  Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
  10  *  Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
  11  */
  12
  13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15 #include <linux/device.h>
  16 #include <linux/err.h>
  17 #include <linux/export.h>
  18 #include <linux/slab.h>
  19 #include <linux/string.h>
  20 #include <linux/sysfs.h>
  21
  22 #include "thermal_core.h"
  23 #include "thermal_trace.h"
  24
  25 int get_tz_trend(struct thermal_zone_device *tz, const struct thermal_trip *trip)
  26 {
  27         enum thermal_trend trend;
  28
  29         if (tz->emul_temperature || !tz->ops.get_trend ||
  30             tz->ops.get_trend(tz, trip, &trend)) {
  31                 if (tz->temperature > tz->last_temperature)
  32                         trend = THERMAL_TREND_RAISING;
  33                 else if (tz->temperature < tz->last_temperature)
  34                         trend = THERMAL_TREND_DROPPING;
  35                 else
  36                         trend = THERMAL_TREND_STABLE;
  37         }
  38
  39         return trend;
  40 }
  41
  42 static bool thermal_instance_present(struct thermal_zone_device *tz,
  43                                      struct thermal_cooling_device *cdev,
  44                                      const struct thermal_trip *trip)
  45 {
  46         const struct thermal_trip_desc *td = trip_to_trip_desc(trip);
  47         struct thermal_instance *ti;
  48
  49         list_for_each_entry(ti, &td->thermal_instances, trip_node) {
  50                 if (ti->cdev == cdev)
  51                         return true;
  52         }
  53
  54         return false;
  55 }
  56
  57 bool thermal_trip_is_bound_to_cdev(struct thermal_zone_device *tz,
  58                                    const struct thermal_trip *trip,
  59                                    struct thermal_cooling_device *cdev)
  60 {
  61         guard(thermal_zone)(tz);
  62         guard(cooling_dev)(cdev);
  63
  64         return thermal_instance_present(tz, cdev, trip);
  65 }
  66 EXPORT_SYMBOL_GPL(thermal_trip_is_bound_to_cdev);
  67
  68 /**
  69  * __thermal_zone_get_temp() - returns the temperature of a thermal zone
  70  * @tz: a valid pointer to a struct thermal_zone_device
  71  * @temp: a valid pointer to where to store the resulting temperature.
  72  *
  73  * When a valid thermal zone reference is passed, it will fetch its
  74  * temperature and fill @temp.
  75  *
  76  * Both tz and tz->ops must be valid pointers when calling this function,
  77  * and the tz->ops.get_temp callback must be provided.
  78  * The function must be called under tz->lock.
  79  *
  80  * Return: On success returns 0, an error code otherwise
  81  */
  82 int __thermal_zone_get_temp(struct thermal_zone_device *tz, int *temp)
  83 {
  84         const struct thermal_trip_desc *td;
  85         int crit_temp = INT_MAX;
  86         int ret = -EINVAL;
  87
  88         lockdep_assert_held(&tz->lock);
  89
  90         ret = tz->ops.get_temp(tz, temp);
  91
  92         if (IS_ENABLED(CONFIG_THERMAL_EMULATION) && tz->emul_temperature) {
  93                 for_each_trip_desc(tz, td) {
  94                         const struct thermal_trip *trip = &td->trip;
  95
  96                         if (trip->type == THERMAL_TRIP_CRITICAL) {
  97                                 crit_temp = trip->temperature;
  98                                 break;
  99                         }
 100                 }
 101
 102                 /*
 103                  * Only allow emulating a temperature when the real temperature
 104                  * is below the critical temperature so that the emulation code
 105                  * cannot hide critical conditions.
 106                  */
 107                 if (!ret && *temp < crit_temp)
 108                         *temp = tz->emul_temperature;
 109         }
 110
 111         if (ret)
 112                 dev_dbg(&tz->device, "Failed to get temperature: %d\n", ret);
 113
 114         return ret;
 115 }
 116
 117 /**
 118  * thermal_zone_get_temp() - returns the temperature of a thermal zone
 119  * @tz: a valid pointer to a struct thermal_zone_device
 120  * @temp: a valid pointer to where to store the resulting temperature.
 121  *
 122  * When a valid thermal zone reference is passed, it will fetch its
 123  * temperature and fill @temp.
 124  *
 125  * Return: On success returns 0, an error code otherwise
 126  */
 127 int thermal_zone_get_temp(struct thermal_zone_device *tz, int *temp)
 128 {
 129         int ret;
 130
 131         if (IS_ERR_OR_NULL(tz))
 132                 return -EINVAL;
 133
 134         guard(thermal_zone)(tz);
 135
 136         if (!tz->ops.get_temp)
 137                 return -EINVAL;
 138
 139         ret = __thermal_zone_get_temp(tz, temp);
 140         if (!ret && *temp <= THERMAL_TEMP_INVALID)
 141                 return -ENODATA;
 142
 143         return ret;
 144 }
 145 EXPORT_SYMBOL_GPL(thermal_zone_get_temp);
 146
 147 static int thermal_cdev_set_cur_state(struct thermal_cooling_device *cdev, int state)
 148 {
 149         int ret;
 150
 151         /*
 152          * No check is needed for the ops->set_cur_state as the
 153          * registering function checked the ops are correctly set
 154          */
 155         ret = cdev->ops->set_cur_state(cdev, state);
 156         if (ret)
 157                 return ret;
 158
 159         thermal_notify_cdev_state_update(cdev, state);
 160         thermal_cooling_device_stats_update(cdev, state);
 161         thermal_debug_cdev_state_update(cdev, state);
 162
 163         return 0;
 164 }
 165
 166 void __thermal_cdev_update(struct thermal_cooling_device *cdev)
 167 {
 168         struct thermal_instance *instance;
 169         unsigned long target = 0;
 170
 171         /* Make sure cdev enters the deepest cooling state */
 172         list_for_each_entry(instance, &cdev->thermal_instances, cdev_node) {
 173                 if (instance->target == THERMAL_NO_TARGET)
 174                         continue;
 175                 if (instance->target > target)
 176                         target = instance->target;
 177         }
 178
 179         thermal_cdev_set_cur_state(cdev, target);
 180
 181         trace_cdev_update(cdev, target);
 182         dev_dbg(&cdev->device, "set to state %lu\n", target);
 183 }
 184
 185 /**
 186  * thermal_cdev_update - update cooling device state if needed
 187  * @cdev:       pointer to struct thermal_cooling_device
 188  *
 189  * Update the cooling device state if there is a need.
 190  */
 191 void thermal_cdev_update(struct thermal_cooling_device *cdev)
 192 {
 193         guard(cooling_dev)(cdev);
 194
 195         if (!cdev->updated) {
 196                 __thermal_cdev_update(cdev);
 197                 cdev->updated = true;
 198         }
 199 }
 200
 201 /**
 202  * thermal_cdev_update_nocheck() - Unconditionally update cooling device state
 203  * @cdev: Target cooling device.
 204  */
 205 void thermal_cdev_update_nocheck(struct thermal_cooling_device *cdev)
 206 {
 207         guard(cooling_dev)(cdev);
 208
 209         __thermal_cdev_update(cdev);
 210 }
 211
 212 /**
 213  * thermal_zone_get_slope - return the slope attribute of the thermal zone
 214  * @tz: thermal zone device with the slope attribute
 215  *
 216  * Return: If the thermal zone device has a slope attribute, return it, else
 217  * return 1.
 218  */
 219 int thermal_zone_get_slope(struct thermal_zone_device *tz)
 220 {
 221         if (tz && tz->tzp)
 222                 return tz->tzp->slope;
 223         return 1;
 224 }
 225 EXPORT_SYMBOL_GPL(thermal_zone_get_slope);
 226
 227 /**
 228  * thermal_zone_get_offset - return the offset attribute of the thermal zone
 229  * @tz: thermal zone device with the offset attribute
 230  *
 231  * Return: If the thermal zone device has a offset attribute, return it, else
 232  * return 0.
 233  */
 234 int thermal_zone_get_offset(struct thermal_zone_device *tz)
 235 {
 236         if (tz && tz->tzp)
 237                 return tz->tzp->offset;
 238         return 0;
 239 }
 240 EXPORT_SYMBOL_GPL(thermal_zone_get_offset);