drivers/gpu/drm/nouveau/nvkm/subdev/therm/temp.c

   1 /*
   2  * Copyright 2012 The Nouveau community
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: Martin Peres
  23  */
  24 #include "priv.h"
  25
  26 static void
  27 nvkm_therm_temp_set_defaults(struct nvkm_therm *therm)
  28 {
  29         struct nvkm_therm_priv *priv = (void *)therm;
  30
  31         priv->bios_sensor.offset_constant = 0;
  32
  33         priv->bios_sensor.thrs_fan_boost.temp = 90;
  34         priv->bios_sensor.thrs_fan_boost.hysteresis = 3;
  35
  36         priv->bios_sensor.thrs_down_clock.temp = 95;
  37         priv->bios_sensor.thrs_down_clock.hysteresis = 3;
  38
  39         priv->bios_sensor.thrs_critical.temp = 105;
  40         priv->bios_sensor.thrs_critical.hysteresis = 5;
  41
  42         priv->bios_sensor.thrs_shutdown.temp = 135;
  43         priv->bios_sensor.thrs_shutdown.hysteresis = 5; /*not that it matters */
  44 }
  45
  46
  47 static void
  48 nvkm_therm_temp_safety_checks(struct nvkm_therm *therm)
  49 {
  50         struct nvkm_therm_priv *priv = (void *)therm;
  51         struct nvbios_therm_sensor *s = &priv->bios_sensor;
  52
  53         /* enforce a minimum hysteresis on thresholds */
  54         s->thrs_fan_boost.hysteresis = max_t(u8, s->thrs_fan_boost.hysteresis, 2);
  55         s->thrs_down_clock.hysteresis = max_t(u8, s->thrs_down_clock.hysteresis, 2);
  56         s->thrs_critical.hysteresis = max_t(u8, s->thrs_critical.hysteresis, 2);
  57         s->thrs_shutdown.hysteresis = max_t(u8, s->thrs_shutdown.hysteresis, 2);
  58 }
  59
  60 /* must be called with alarm_program_lock taken ! */
  61 void
  62 nvkm_therm_sensor_set_threshold_state(struct nvkm_therm *therm,
  63                                       enum nvkm_therm_thrs thrs,
  64                                       enum nvkm_therm_thrs_state st)
  65 {
  66         struct nvkm_therm_priv *priv = (void *)therm;
  67         priv->sensor.alarm_state[thrs] = st;
  68 }
  69
  70 /* must be called with alarm_program_lock taken ! */
  71 enum nvkm_therm_thrs_state
  72 nvkm_therm_sensor_get_threshold_state(struct nvkm_therm *therm,
  73                                       enum nvkm_therm_thrs thrs)
  74 {
  75         struct nvkm_therm_priv *priv = (void *)therm;
  76         return priv->sensor.alarm_state[thrs];
  77 }
  78
  79 static void
  80 nv_poweroff_work(struct work_struct *work)
  81 {
  82         orderly_poweroff(true);
  83         kfree(work);
  84 }
  85
  86 void
  87 nvkm_therm_sensor_event(struct nvkm_therm *therm, enum nvkm_therm_thrs thrs,
  88                         enum nvkm_therm_thrs_direction dir)
  89 {
  90         struct nvkm_therm_priv *priv = (void *)therm;
  91         bool active;
  92         const char *thresolds[] = {
  93                 "fanboost", "downclock", "critical", "shutdown"
  94         };
  95         int temperature = therm->temp_get(therm);
  96
  97         if (thrs < 0 || thrs > 3)
  98                 return;
  99
 100         if (dir == NVKM_THERM_THRS_FALLING)
 101                 nv_info(therm, "temperature (%i C) went below the '%s' threshold\n",
 102                         temperature, thresolds[thrs]);
 103         else
 104                 nv_info(therm, "temperature (%i C) hit the '%s' threshold\n",
 105                         temperature, thresolds[thrs]);
 106
 107         active = (dir == NVKM_THERM_THRS_RISING);
 108         switch (thrs) {
 109         case NVKM_THERM_THRS_FANBOOST:
 110                 if (active) {
 111                         nvkm_therm_fan_set(therm, true, 100);
 112                         nvkm_therm_fan_mode(therm, NVKM_THERM_CTRL_AUTO);
 113                 }
 114                 break;
 115         case NVKM_THERM_THRS_DOWNCLOCK:
 116                 if (priv->emergency.downclock)
 117                         priv->emergency.downclock(therm, active);
 118                 break;
 119         case NVKM_THERM_THRS_CRITICAL:
 120                 if (priv->emergency.pause)
 121                         priv->emergency.pause(therm, active);
 122                 break;
 123         case NVKM_THERM_THRS_SHUTDOWN:
 124                 if (active) {
 125                         struct work_struct *work;
 126
 127                         work = kmalloc(sizeof(*work), GFP_ATOMIC);
 128                         if (work) {
 129                                 INIT_WORK(work, nv_poweroff_work);
 130                                 schedule_work(work);
 131                         }
 132                 }
 133                 break;
 134         case NVKM_THERM_THRS_NR:
 135                 break;
 136         }
 137
 138 }
 139
 140 /* must be called with alarm_program_lock taken ! */
 141 static void
 142 nvkm_therm_threshold_hyst_polling(struct nvkm_therm *therm,
 143                                   const struct nvbios_therm_threshold *thrs,
 144                                   enum nvkm_therm_thrs thrs_name)
 145 {
 146         enum nvkm_therm_thrs_direction direction;
 147         enum nvkm_therm_thrs_state prev_state, new_state;
 148         int temp = therm->temp_get(therm);
 149
 150         prev_state = nvkm_therm_sensor_get_threshold_state(therm, thrs_name);
 151
 152         if (temp >= thrs->temp && prev_state == NVKM_THERM_THRS_LOWER) {
 153                 direction = NVKM_THERM_THRS_RISING;
 154                 new_state = NVKM_THERM_THRS_HIGHER;
 155         } else if (temp <= thrs->temp - thrs->hysteresis &&
 156                         prev_state == NVKM_THERM_THRS_HIGHER) {
 157                 direction = NVKM_THERM_THRS_FALLING;
 158                 new_state = NVKM_THERM_THRS_LOWER;
 159         } else
 160                 return; /* nothing to do */
 161
 162         nvkm_therm_sensor_set_threshold_state(therm, thrs_name, new_state);
 163         nvkm_therm_sensor_event(therm, thrs_name, direction);
 164 }
 165
 166 static void
 167 alarm_timer_callback(struct nvkm_alarm *alarm)
 168 {
 169         struct nvkm_therm_priv *priv =
 170         container_of(alarm, struct nvkm_therm_priv, sensor.therm_poll_alarm);
 171         struct nvbios_therm_sensor *sensor = &priv->bios_sensor;
 172         struct nvkm_timer *ptimer = nvkm_timer(priv);
 173         struct nvkm_therm *therm = &priv->base;
 174         unsigned long flags;
 175
 176         spin_lock_irqsave(&priv->sensor.alarm_program_lock, flags);
 177
 178         nvkm_therm_threshold_hyst_polling(therm, &sensor->thrs_fan_boost,
 179                                           NVKM_THERM_THRS_FANBOOST);
 180
 181         nvkm_therm_threshold_hyst_polling(therm, &sensor->thrs_down_clock,
 182                                           NVKM_THERM_THRS_DOWNCLOCK);
 183
 184         nvkm_therm_threshold_hyst_polling(therm, &sensor->thrs_critical,
 185                                           NVKM_THERM_THRS_CRITICAL);
 186
 187         nvkm_therm_threshold_hyst_polling(therm, &sensor->thrs_shutdown,
 188                                           NVKM_THERM_THRS_SHUTDOWN);
 189
 190         spin_unlock_irqrestore(&priv->sensor.alarm_program_lock, flags);
 191
 192         /* schedule the next poll in one second */
 193         if (therm->temp_get(therm) >= 0 && list_empty(&alarm->head))
 194                 ptimer->alarm(ptimer, 1000000000ULL, alarm);
 195 }
 196
 197 void
 198 nvkm_therm_program_alarms_polling(struct nvkm_therm *therm)
 199 {
 200         struct nvkm_therm_priv *priv = (void *)therm;
 201         struct nvbios_therm_sensor *sensor = &priv->bios_sensor;
 202
 203         nv_debug(therm,
 204                  "programmed thresholds [ %d(%d), %d(%d), %d(%d), %d(%d) ]\n",
 205                  sensor->thrs_fan_boost.temp, sensor->thrs_fan_boost.hysteresis,
 206                  sensor->thrs_down_clock.temp,
 207                  sensor->thrs_down_clock.hysteresis,
 208                  sensor->thrs_critical.temp, sensor->thrs_critical.hysteresis,
 209                  sensor->thrs_shutdown.temp, sensor->thrs_shutdown.hysteresis);
 210
 211         alarm_timer_callback(&priv->sensor.therm_poll_alarm);
 212 }
 213
 214 int
 215 nvkm_therm_sensor_init(struct nvkm_therm *therm)
 216 {
 217         struct nvkm_therm_priv *priv = (void *)therm;
 218         priv->sensor.program_alarms(therm);
 219         return 0;
 220 }
 221
 222 int
 223 nvkm_therm_sensor_fini(struct nvkm_therm *therm, bool suspend)
 224 {
 225         struct nvkm_therm_priv *priv = (void *)therm;
 226         struct nvkm_timer *ptimer = nvkm_timer(therm);
 227
 228         if (suspend)
 229                 ptimer->alarm_cancel(ptimer, &priv->sensor.therm_poll_alarm);
 230         return 0;
 231 }
 232
 233 void
 234 nvkm_therm_sensor_preinit(struct nvkm_therm *therm)
 235 {
 236         const char *sensor_avail = "yes";
 237
 238         if (therm->temp_get(therm) < 0)
 239                 sensor_avail = "no";
 240
 241         nv_info(therm, "internal sensor: %s\n", sensor_avail);
 242 }
 243
 244 int
 245 nvkm_therm_sensor_ctor(struct nvkm_therm *therm)
 246 {
 247         struct nvkm_therm_priv *priv = (void *)therm;
 248         struct nvkm_bios *bios = nvkm_bios(therm);
 249
 250         nvkm_alarm_init(&priv->sensor.therm_poll_alarm, alarm_timer_callback);
 251
 252         nvkm_therm_temp_set_defaults(therm);
 253         if (nvbios_therm_sensor_parse(bios, NVBIOS_THERM_DOMAIN_CORE,
 254                                       &priv->bios_sensor))
 255                 nv_error(therm, "nvbios_therm_sensor_parse failed\n");
 256         nvkm_therm_temp_safety_checks(therm);
 257
 258         return 0;
 259 }