drivers/thermal/thermal_debugfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2023 Linaro Limited
   4  *
   5  * Author: Daniel Lezcano <[email protected]>
   6  *
   7  * Thermal subsystem debug support
   8  */
   9 #include <linux/debugfs.h>
  10 #include <linux/ktime.h>
  11 #include <linux/list.h>
  12 #include <linux/minmax.h>
  13 #include <linux/mutex.h>
  14 #include <linux/thermal.h>
  15
  16 #include "thermal_core.h"
  17
  18 static struct dentry *d_root;
  19 static struct dentry *d_cdev;
  20 static struct dentry *d_tz;
  21
  22 /*
  23  * Length of the string containing the thermal zone id or the cooling
  24  * device id, including the ending nul character. We can reasonably
  25  * assume there won't be more than 256 thermal zones as the maximum
  26  * observed today is around 32.
  27  */
  28 #define IDSLENGTH 4
  29
  30 /*
  31  * The cooling device transition list is stored in a hash table where
  32  * the size is CDEVSTATS_HASH_SIZE. The majority of cooling devices
  33  * have dozen of states but some can have much more, so a hash table
  34  * is more adequate in this case, because the cost of browsing the entire
  35  * list when storing the transitions may not be negligible.
  36  */
  37 #define CDEVSTATS_HASH_SIZE 16
  38
  39 /**
  40  * struct cdev_debugfs - per cooling device statistics structure
  41  * A cooling device can have a high number of states. Showing the
  42  * transitions on a matrix based representation can be overkill given
  43  * most of the transitions won't happen and we end up with a matrix
  44  * filled with zero. Instead, we show the transitions which actually
  45  * happened.
  46  *
  47  * Every transition updates the current_state and the timestamp. The
  48  * transitions and the durations are stored in lists.
  49  *
  50  * @total: the number of transitions for this cooling device
  51  * @current_state: the current cooling device state
  52  * @timestamp: the state change timestamp
  53  * @transitions: an array of lists containing the state transitions
  54  * @durations: an array of lists containing the residencies of each state
  55  */
  56 struct cdev_debugfs {
  57         u32 total;
  58         int current_state;
  59         ktime_t timestamp;
  60         struct list_head transitions[CDEVSTATS_HASH_SIZE];
  61         struct list_head durations[CDEVSTATS_HASH_SIZE];
  62 };
  63
  64 /**
  65  * struct cdev_record - Common structure for cooling device entry
  66  *
  67  * The following common structure allows to store the information
  68  * related to the transitions and to the state residencies. They are
  69  * identified with a id which is associated to a value. It is used as
  70  * nodes for the "transitions" and "durations" above.
  71  *
  72  * @node: node to insert the structure in a list
  73  * @id: identifier of the value which can be a state or a transition
  74  * @residency: a ktime_t representing a state residency duration
  75  * @count: a number of occurrences
  76  */
  77 struct cdev_record {
  78         struct list_head node;
  79         int id;
  80         union {
  81                 ktime_t residency;
  82                 u64 count;
  83         };
  84 };
  85
  86 /**
  87  * struct trip_stats - Thermal trip statistics
  88  *
  89  * The trip_stats structure has the relevant information to show the
  90  * statistics related to temperature going above a trip point.
  91  *
  92  * @timestamp: the trip crossing timestamp
  93  * @duration: total time when the zone temperature was above the trip point
  94  * @trip_temp: trip temperature at mitigation start
  95  * @trip_hyst: trip hysteresis at mitigation start
  96  * @count: the number of times the zone temperature was above the trip point
  97  * @min: minimum recorded temperature above the trip point
  98  * @avg: average temperature above the trip point
  99  */
 100 struct trip_stats {
 101         ktime_t timestamp;
 102         ktime_t duration;
 103         int trip_temp;
 104         int trip_hyst;
 105         int count;
 106         int min;
 107         int avg;
 108 };
 109
 110 /**
 111  * struct tz_episode - A mitigation episode information
 112  *
 113  * The tz_episode structure describes a mitigation episode. A
 114  * mitigation episode begins the trip point with the lower temperature
 115  * is crossed the way up and ends when it is crossed the way
 116  * down. During this episode we can have multiple trip points crossed
 117  * the way up and down if there are multiple trip described in the
 118  * firmware after the lowest temperature trip point.
 119  *
 120  * @timestamp: first trip point crossed the way up
 121  * @duration: total duration of the mitigation episode
 122  * @node: a list element to be added to the list of tz events
 123  * @max_temp: maximum zone temperature during this episode
 124  * @trip_stats: per trip point statistics, flexible array
 125  */
 126 struct tz_episode {
 127         ktime_t timestamp;
 128         ktime_t duration;
 129         struct list_head node;
 130         int max_temp;
 131         struct trip_stats trip_stats[];
 132 };
 133
 134 /**
 135  * struct tz_debugfs - Store all mitigation episodes for a thermal zone
 136  *
 137  * The tz_debugfs structure contains the list of the mitigation
 138  * episodes and has to track which trip point has been crossed in
 139  * order to handle correctly nested trip point mitigation episodes.
 140  *
 141  * We keep the history of the trip point crossed in an array and as we
 142  * can go back and forth inside this history, eg. trip 0,1,2,1,2,1,0,
 143  * we keep track of the current position in the history array.
 144  *
 145  * @tz_episodes: a list of thermal mitigation episodes
 146  * @tz: thermal zone this object belongs to
 147  * @trips_crossed: an array of trip points crossed by id
 148  * @nr_trips: the number of trip points currently being crossed
 149  */
 150 struct tz_debugfs {
 151         struct list_head tz_episodes;
 152         struct thermal_zone_device *tz;
 153         int *trips_crossed;
 154         int nr_trips;
 155 };
 156
 157 /**
 158  * struct thermal_debugfs - High level structure for a thermal object in debugfs
 159  *
 160  * The thermal_debugfs structure is the common structure used by the
 161  * cooling device or the thermal zone to store the statistics.
 162  *
 163  * @d_top: top directory of the thermal object directory
 164  * @lock: per object lock to protect the internals
 165  *
 166  * @cdev_dbg: a cooling device debug structure
 167  * @tz_dbg: a thermal zone debug structure
 168  */
 169 struct thermal_debugfs {
 170         struct dentry *d_top;
 171         struct mutex lock;
 172         union {
 173                 struct cdev_debugfs cdev_dbg;
 174                 struct tz_debugfs tz_dbg;
 175         };
 176 };
 177
 178 void thermal_debug_init(void)
 179 {
 180         d_root = debugfs_create_dir("thermal", NULL);
 181         if (!d_root)
 182                 return;
 183
 184         d_cdev = debugfs_create_dir("cooling_devices", d_root);
 185         if (!d_cdev)
 186                 return;
 187
 188         d_tz = debugfs_create_dir("thermal_zones", d_root);
 189 }
 190
 191 static struct thermal_debugfs *thermal_debugfs_add_id(struct dentry *d, int id)
 192 {
 193         struct thermal_debugfs *thermal_dbg;
 194         char ids[IDSLENGTH];
 195
 196         thermal_dbg = kzalloc(sizeof(*thermal_dbg), GFP_KERNEL);
 197         if (!thermal_dbg)
 198                 return NULL;
 199
 200         mutex_init(&thermal_dbg->lock);
 201
 202         snprintf(ids, IDSLENGTH, "%d", id);
 203
 204         thermal_dbg->d_top = debugfs_create_dir(ids, d);
 205         if (!thermal_dbg->d_top) {
 206                 kfree(thermal_dbg);
 207                 return NULL;
 208         }
 209
 210         return thermal_dbg;
 211 }
 212
 213 static void thermal_debugfs_remove_id(struct thermal_debugfs *thermal_dbg)
 214 {
 215         if (!thermal_dbg)
 216                 return;
 217
 218         debugfs_remove(thermal_dbg->d_top);
 219
 220         kfree(thermal_dbg);
 221 }
 222
 223 static struct cdev_record *
 224 thermal_debugfs_cdev_record_alloc(struct thermal_debugfs *thermal_dbg,
 225                                   struct list_head *lists, int id)
 226 {
 227         struct cdev_record *cdev_record;
 228
 229         cdev_record = kzalloc(sizeof(*cdev_record), GFP_KERNEL);
 230         if (!cdev_record)
 231                 return NULL;
 232
 233         cdev_record->id = id;
 234         INIT_LIST_HEAD(&cdev_record->node);
 235         list_add_tail(&cdev_record->node,
 236                       &lists[cdev_record->id % CDEVSTATS_HASH_SIZE]);
 237
 238         return cdev_record;
 239 }
 240
 241 static struct cdev_record *
 242 thermal_debugfs_cdev_record_find(struct thermal_debugfs *thermal_dbg,
 243                                  struct list_head *lists, int id)
 244 {
 245         struct cdev_record *entry;
 246
 247         list_for_each_entry(entry, &lists[id % CDEVSTATS_HASH_SIZE], node)
 248                 if (entry->id == id)
 249                         return entry;
 250
 251         return NULL;
 252 }
 253
 254 static struct cdev_record *
 255 thermal_debugfs_cdev_record_get(struct thermal_debugfs *thermal_dbg,
 256                                 struct list_head *lists, int id)
 257 {
 258         struct cdev_record *cdev_record;
 259
 260         cdev_record = thermal_debugfs_cdev_record_find(thermal_dbg, lists, id);
 261         if (cdev_record)
 262                 return cdev_record;
 263
 264         return thermal_debugfs_cdev_record_alloc(thermal_dbg, lists, id);
 265 }
 266
 267 static void thermal_debugfs_cdev_clear(struct cdev_debugfs *cdev_dbg)
 268 {
 269         int i;
 270         struct cdev_record *entry, *tmp;
 271
 272         for (i = 0; i < CDEVSTATS_HASH_SIZE; i++) {
 273
 274                 list_for_each_entry_safe(entry, tmp,
 275                                          &cdev_dbg->transitions[i], node) {
 276                         list_del(&entry->node);
 277                         kfree(entry);
 278                 }
 279
 280                 list_for_each_entry_safe(entry, tmp,
 281                                          &cdev_dbg->durations[i], node) {
 282                         list_del(&entry->node);
 283                         kfree(entry);
 284                 }
 285         }
 286
 287         cdev_dbg->total = 0;
 288 }
 289
 290 static void *cdev_seq_start(struct seq_file *s, loff_t *pos)
 291 {
 292         struct thermal_debugfs *thermal_dbg = s->private;
 293
 294         mutex_lock(&thermal_dbg->lock);
 295
 296         return (*pos < CDEVSTATS_HASH_SIZE) ? pos : NULL;
 297 }
 298
 299 static void *cdev_seq_next(struct seq_file *s, void *v, loff_t *pos)
 300 {
 301         (*pos)++;
 302
 303         return (*pos < CDEVSTATS_HASH_SIZE) ? pos : NULL;
 304 }
 305
 306 static void cdev_seq_stop(struct seq_file *s, void *v)
 307 {
 308         struct thermal_debugfs *thermal_dbg = s->private;
 309
 310         mutex_unlock(&thermal_dbg->lock);
 311 }
 312
 313 static int cdev_tt_seq_show(struct seq_file *s, void *v)
 314 {
 315         struct thermal_debugfs *thermal_dbg = s->private;
 316         struct cdev_debugfs *cdev_dbg = &thermal_dbg->cdev_dbg;
 317         struct list_head *transitions = cdev_dbg->transitions;
 318         struct cdev_record *entry;
 319         int i = *(loff_t *)v;
 320
 321         if (!i)
 322                 seq_puts(s, "Transition\tOccurences\n");
 323
 324         list_for_each_entry(entry, &transitions[i], node) {
 325                 /*
 326                  * Assuming maximum cdev states is 1024, the longer
 327                  * string for a transition would be "1024->1024\0"
 328                  */
 329                 char buffer[11];
 330
 331                 snprintf(buffer, ARRAY_SIZE(buffer), "%d->%d",
 332                          entry->id >> 16, entry->id & 0xFFFF);
 333
 334                 seq_printf(s, "%-10s\t%-10llu\n", buffer, entry->count);
 335         }
 336
 337         return 0;
 338 }
 339
 340 static const struct seq_operations tt_sops = {
 341         .start = cdev_seq_start,
 342         .next = cdev_seq_next,
 343         .stop = cdev_seq_stop,
 344         .show = cdev_tt_seq_show,
 345 };
 346
 347 DEFINE_SEQ_ATTRIBUTE(tt);
 348
 349 static int cdev_dt_seq_show(struct seq_file *s, void *v)
 350 {
 351         struct thermal_debugfs *thermal_dbg = s->private;
 352         struct cdev_debugfs *cdev_dbg = &thermal_dbg->cdev_dbg;
 353         struct list_head *durations = cdev_dbg->durations;
 354         struct cdev_record *entry;
 355         int i = *(loff_t *)v;
 356
 357         if (!i)
 358                 seq_puts(s, "State\tResidency\n");
 359
 360         list_for_each_entry(entry, &durations[i], node) {
 361                 s64 duration = ktime_to_ms(entry->residency);
 362
 363                 if (entry->id == cdev_dbg->current_state)
 364                         duration += ktime_ms_delta(ktime_get(),
 365                                                    cdev_dbg->timestamp);
 366
 367                 seq_printf(s, "%-5d\t%-10llu\n", entry->id, duration);
 368         }
 369
 370         return 0;
 371 }
 372
 373 static const struct seq_operations dt_sops = {
 374         .start = cdev_seq_start,
 375         .next = cdev_seq_next,
 376         .stop = cdev_seq_stop,
 377         .show = cdev_dt_seq_show,
 378 };
 379
 380 DEFINE_SEQ_ATTRIBUTE(dt);
 381
 382 static int cdev_clear_set(void *data, u64 val)
 383 {
 384         struct thermal_debugfs *thermal_dbg = data;
 385
 386         if (!val)
 387                 return -EINVAL;
 388
 389         mutex_lock(&thermal_dbg->lock);
 390
 391         thermal_debugfs_cdev_clear(&thermal_dbg->cdev_dbg);
 392
 393         mutex_unlock(&thermal_dbg->lock);
 394
 395         return 0;
 396 }
 397
 398 DEFINE_DEBUGFS_ATTRIBUTE(cdev_clear_fops, NULL, cdev_clear_set, "%llu\n");
 399
 400 /**
 401  * thermal_debug_cdev_state_update - Update a cooling device state change
 402  *
 403  * Computes a transition and the duration of the previous state residency.
 404  *
 405  * @cdev : a pointer to a cooling device
 406  * @new_state: an integer corresponding to the new cooling device state
 407  */
 408 void thermal_debug_cdev_state_update(const struct thermal_cooling_device *cdev,
 409                                      int new_state)
 410 {
 411         struct thermal_debugfs *thermal_dbg = cdev->debugfs;
 412         struct cdev_debugfs *cdev_dbg;
 413         struct cdev_record *cdev_record;
 414         int transition, old_state;
 415
 416         if (!thermal_dbg || (thermal_dbg->cdev_dbg.current_state == new_state))
 417                 return;
 418
 419         mutex_lock(&thermal_dbg->lock);
 420
 421         cdev_dbg = &thermal_dbg->cdev_dbg;
 422
 423         old_state = cdev_dbg->current_state;
 424
 425         /*
 426          * Get the old state information in the durations list. If
 427          * this one does not exist, a new allocated one will be
 428          * returned. Recompute the total duration in the old state and
 429          * get a new timestamp for the new state.
 430          */
 431         cdev_record = thermal_debugfs_cdev_record_get(thermal_dbg,
 432                                                       cdev_dbg->durations,
 433                                                       old_state);
 434         if (cdev_record) {
 435                 ktime_t now = ktime_get();
 436                 ktime_t delta = ktime_sub(now, cdev_dbg->timestamp);
 437                 cdev_record->residency = ktime_add(cdev_record->residency, delta);
 438                 cdev_dbg->timestamp = now;
 439         }
 440
 441         cdev_dbg->current_state = new_state;
 442
 443         /*
 444          * Create a record for the new state if it is not there, so its
 445          * duration will be printed by cdev_dt_seq_show() as expected if it
 446          * runs before the next state transition.
 447          */
 448         thermal_debugfs_cdev_record_get(thermal_dbg, cdev_dbg->durations, new_state);
 449
 450         transition = (old_state << 16) | new_state;
 451
 452         /*
 453          * Get the transition in the transitions list. If this one
 454          * does not exist, a new allocated one will be returned.
 455          * Increment the occurrence of this transition which is stored
 456          * in the value field.
 457          */
 458         cdev_record = thermal_debugfs_cdev_record_get(thermal_dbg,
 459                                                       cdev_dbg->transitions,
 460                                                       transition);
 461         if (cdev_record)
 462                 cdev_record->count++;
 463
 464         cdev_dbg->total++;
 465
 466         mutex_unlock(&thermal_dbg->lock);
 467 }
 468
 469 /**
 470  * thermal_debug_cdev_add - Add a cooling device debugfs entry
 471  *
 472  * Allocates a cooling device object for debug, initializes the
 473  * statistics and create the entries in sysfs.
 474  * @cdev: a pointer to a cooling device
 475  * @state: current state of the cooling device
 476  */
 477 void thermal_debug_cdev_add(struct thermal_cooling_device *cdev, int state)
 478 {
 479         struct thermal_debugfs *thermal_dbg;
 480         struct cdev_debugfs *cdev_dbg;
 481         int i;
 482
 483         thermal_dbg = thermal_debugfs_add_id(d_cdev, cdev->id);
 484         if (!thermal_dbg)
 485                 return;
 486
 487         cdev_dbg = &thermal_dbg->cdev_dbg;
 488
 489         for (i = 0; i < CDEVSTATS_HASH_SIZE; i++) {
 490                 INIT_LIST_HEAD(&cdev_dbg->transitions[i]);
 491                 INIT_LIST_HEAD(&cdev_dbg->durations[i]);
 492         }
 493
 494         cdev_dbg->current_state = state;
 495         cdev_dbg->timestamp = ktime_get();
 496
 497         /*
 498          * Create a record for the initial cooling device state, so its
 499          * duration will be printed by cdev_dt_seq_show() as expected if it
 500          * runs before the first state transition.
 501          */
 502         thermal_debugfs_cdev_record_get(thermal_dbg, cdev_dbg->durations, state);
 503
 504         debugfs_create_file("trans_table", 0400, thermal_dbg->d_top,
 505                             thermal_dbg, &tt_fops);
 506
 507         debugfs_create_file("time_in_state_ms", 0400, thermal_dbg->d_top,
 508                             thermal_dbg, &dt_fops);
 509
 510         debugfs_create_file("clear", 0200, thermal_dbg->d_top,
 511                             thermal_dbg, &cdev_clear_fops);
 512
 513         debugfs_create_u32("total_trans", 0400, thermal_dbg->d_top,
 514                            &cdev_dbg->total);
 515
 516         cdev->debugfs = thermal_dbg;
 517 }
 518
 519 /**
 520  * thermal_debug_cdev_remove - Remove a cooling device debugfs entry
 521  *
 522  * Frees the statistics memory data and remove the debugfs entry
 523  *
 524  * @cdev: a pointer to a cooling device
 525  */
 526 void thermal_debug_cdev_remove(struct thermal_cooling_device *cdev)
 527 {
 528         struct thermal_debugfs *thermal_dbg;
 529
 530         mutex_lock(&cdev->lock);
 531
 532         thermal_dbg = cdev->debugfs;
 533         if (!thermal_dbg) {
 534                 mutex_unlock(&cdev->lock);
 535                 return;
 536         }
 537
 538         cdev->debugfs = NULL;
 539
 540         mutex_unlock(&cdev->lock);
 541
 542         mutex_lock(&thermal_dbg->lock);
 543
 544         thermal_debugfs_cdev_clear(&thermal_dbg->cdev_dbg);
 545
 546         mutex_unlock(&thermal_dbg->lock);
 547
 548         thermal_debugfs_remove_id(thermal_dbg);
 549 }
 550
 551 static struct tz_episode *thermal_debugfs_tz_event_alloc(struct thermal_zone_device *tz,
 552                                                         ktime_t now)
 553 {
 554         struct tz_episode *tze;
 555         int i;
 556
 557         tze = kzalloc(struct_size(tze, trip_stats, tz->num_trips), GFP_KERNEL);
 558         if (!tze)
 559                 return NULL;
 560
 561         INIT_LIST_HEAD(&tze->node);
 562         tze->timestamp = now;
 563         tze->duration = KTIME_MIN;
 564         tze->max_temp = INT_MIN;
 565
 566         for (i = 0; i < tz->num_trips; i++) {
 567                 tze->trip_stats[i].trip_temp = THERMAL_TEMP_INVALID;
 568                 tze->trip_stats[i].min = INT_MAX;
 569         }
 570
 571         return tze;
 572 }
 573
 574 void thermal_debug_tz_trip_up(struct thermal_zone_device *tz,
 575                               const struct thermal_trip *trip)
 576 {
 577         struct thermal_debugfs *thermal_dbg = tz->debugfs;
 578         int trip_id = thermal_zone_trip_id(tz, trip);
 579         ktime_t now = ktime_get();
 580         struct trip_stats *trip_stats;
 581         struct tz_debugfs *tz_dbg;
 582         struct tz_episode *tze;
 583
 584         if (!thermal_dbg)
 585                 return;
 586
 587         tz_dbg = &thermal_dbg->tz_dbg;
 588
 589         mutex_lock(&thermal_dbg->lock);
 590
 591         /*
 592          * The mitigation is starting. A mitigation can contain
 593          * several episodes where each of them is related to a
 594          * temperature crossing a trip point. The episodes are
 595          * nested. That means when the temperature is crossing the
 596          * first trip point, the duration begins to be measured. If
 597          * the temperature continues to increase and reaches the
 598          * second trip point, the duration of the first trip must be
 599          * also accumulated.
 600          *
 601          * eg.
 602          *
 603          * temp
 604          *   ^
 605          *   |             --------
 606          * trip 2         /        \         ------
 607          *   |           /|        |\      /|      |\
 608          * trip 1       / |        | `----  |      | \
 609          *   |         /| |        |        |      | |\
 610          * trip 0     / | |        |        |      | | \
 611          *   |       /| | |        |        |      | | |\
 612          *   |      / | | |        |        |      | | | `--
 613          *   |     /  | | |        |        |      | | |
 614          *   |-----   | | |        |        |      | | |
 615          *   |        | | |        |        |      | | |
 616          *    --------|-|-|--------|--------|------|-|-|------------------> time
 617          *            | | |<--t2-->|        |<-t2'>| | |
 618          *            | |                            | |
 619          *            | |<------------t1------------>| |
 620          *            |                                |
 621          *            |<-------------t0--------------->|
 622          *
 623          */
 624         if (!tz_dbg->nr_trips) {
 625                 tze = thermal_debugfs_tz_event_alloc(tz, now);
 626                 if (!tze)
 627                         goto unlock;
 628
 629                 list_add(&tze->node, &tz_dbg->tz_episodes);
 630         }
 631
 632         /*
 633          * Each time a trip point is crossed the way up, the trip_id
 634          * is stored in the trip_crossed array and the nr_trips is
 635          * incremented. A nr_trips equal to zero means we are entering
 636          * a mitigation episode.
 637          *
 638          * The trip ids may not be in the ascending order but the
 639          * result in the array trips_crossed will be in the ascending
 640          * temperature order. The function detecting when a trip point
 641          * is crossed the way down will handle the very rare case when
 642          * the trip points may have been reordered during this
 643          * mitigation episode.
 644          */
 645         tz_dbg->trips_crossed[tz_dbg->nr_trips++] = trip_id;
 646
 647         tze = list_first_entry(&tz_dbg->tz_episodes, struct tz_episode, node);
 648         trip_stats = &tze->trip_stats[trip_id];
 649         trip_stats->trip_temp = trip->temperature;
 650         trip_stats->trip_hyst = trip->hysteresis;
 651         trip_stats->timestamp = now;
 652
 653 unlock:
 654         mutex_unlock(&thermal_dbg->lock);
 655 }
 656
 657 static void tz_episode_close_trip(struct tz_episode *tze, int trip_id, ktime_t now)
 658 {
 659         struct trip_stats *trip_stats = &tze->trip_stats[trip_id];
 660         ktime_t delta = ktime_sub(now, trip_stats->timestamp);
 661
 662         trip_stats->duration = ktime_add(delta, trip_stats->duration);
 663         /* Mark the end of mitigation for this trip point. */
 664         trip_stats->timestamp = KTIME_MAX;
 665 }
 666
 667 void thermal_debug_tz_trip_down(struct thermal_zone_device *tz,
 668                                 const struct thermal_trip *trip)
 669 {
 670         struct thermal_debugfs *thermal_dbg = tz->debugfs;
 671         int trip_id = thermal_zone_trip_id(tz, trip);
 672         ktime_t now = ktime_get();
 673         struct tz_episode *tze;
 674         struct tz_debugfs *tz_dbg;
 675         int i;
 676
 677         if (!thermal_dbg)
 678                 return;
 679
 680         tz_dbg = &thermal_dbg->tz_dbg;
 681
 682         mutex_lock(&thermal_dbg->lock);
 683
 684         /*
 685          * The temperature crosses the way down but there was not
 686          * mitigation detected before. That may happen when the
 687          * temperature is greater than a trip point when registering a
 688          * thermal zone, which is a common use case as the kernel has
 689          * no mitigation mechanism yet at boot time.
 690          */
 691         if (!tz_dbg->nr_trips)
 692                 goto out;
 693
 694         for (i = tz_dbg->nr_trips - 1; i >= 0; i--) {
 695                 if (tz_dbg->trips_crossed[i] == trip_id)
 696                         break;
 697         }
 698
 699         if (i < 0)
 700                 goto out;
 701
 702         tz_dbg->nr_trips--;
 703
 704         if (i < tz_dbg->nr_trips)
 705                 tz_dbg->trips_crossed[i] = tz_dbg->trips_crossed[tz_dbg->nr_trips];
 706
 707         tze = list_first_entry(&tz_dbg->tz_episodes, struct tz_episode, node);
 708
 709         tz_episode_close_trip(tze, trip_id, now);
 710
 711         /*
 712          * This event closes the mitigation as we are crossing the
 713          * last trip point the way down.
 714          */
 715         if (!tz_dbg->nr_trips)
 716                 tze->duration = ktime_sub(now, tze->timestamp);
 717
 718 out:
 719         mutex_unlock(&thermal_dbg->lock);
 720 }
 721
 722 void thermal_debug_update_trip_stats(struct thermal_zone_device *tz)
 723 {
 724         struct thermal_debugfs *thermal_dbg = tz->debugfs;
 725         struct tz_debugfs *tz_dbg;
 726         struct tz_episode *tze;
 727         int i;
 728
 729         if (!thermal_dbg)
 730                 return;
 731
 732         tz_dbg = &thermal_dbg->tz_dbg;
 733
 734         mutex_lock(&thermal_dbg->lock);
 735
 736         if (!tz_dbg->nr_trips)
 737                 goto out;
 738
 739         tze = list_first_entry(&tz_dbg->tz_episodes, struct tz_episode, node);
 740
 741         if (tz->temperature > tze->max_temp)
 742                 tze->max_temp = tz->temperature;
 743
 744         for (i = 0; i < tz_dbg->nr_trips; i++) {
 745                 int trip_id = tz_dbg->trips_crossed[i];
 746                 struct trip_stats *trip_stats = &tze->trip_stats[trip_id];
 747
 748                 trip_stats->min = min(trip_stats->min, tz->temperature);
 749                 trip_stats->avg += (tz->temperature - trip_stats->avg) /
 750                                         ++trip_stats->count;
 751         }
 752 out:
 753         mutex_unlock(&thermal_dbg->lock);
 754 }
 755
 756 static void *tze_seq_start(struct seq_file *s, loff_t *pos)
 757 {
 758         struct thermal_debugfs *thermal_dbg = s->private;
 759         struct tz_debugfs *tz_dbg = &thermal_dbg->tz_dbg;
 760
 761         mutex_lock(&thermal_dbg->lock);
 762
 763         return seq_list_start(&tz_dbg->tz_episodes, *pos);
 764 }
 765
 766 static void *tze_seq_next(struct seq_file *s, void *v, loff_t *pos)
 767 {
 768         struct thermal_debugfs *thermal_dbg = s->private;
 769         struct tz_debugfs *tz_dbg = &thermal_dbg->tz_dbg;
 770
 771         return seq_list_next(v, &tz_dbg->tz_episodes, pos);
 772 }
 773
 774 static void tze_seq_stop(struct seq_file *s, void *v)
 775 {
 776         struct thermal_debugfs *thermal_dbg = s->private;
 777
 778         mutex_unlock(&thermal_dbg->lock);
 779 }
 780
 781 static int tze_seq_show(struct seq_file *s, void *v)
 782 {
 783         struct thermal_debugfs *thermal_dbg = s->private;
 784         struct thermal_zone_device *tz = thermal_dbg->tz_dbg.tz;
 785         struct thermal_trip_desc *td;
 786         struct tz_episode *tze;
 787         u64 duration_ms;
 788         int trip_id;
 789         char c;
 790
 791         tze = list_entry((struct list_head *)v, struct tz_episode, node);
 792
 793         if (tze->duration == KTIME_MIN) {
 794                 /* Mitigation in progress. */
 795                 duration_ms = ktime_to_ms(ktime_sub(ktime_get(), tze->timestamp));
 796                 c = '>';
 797         } else {
 798                 duration_ms = ktime_to_ms(tze->duration);
 799                 c = '=';
 800         }
 801
 802         seq_printf(s, ",-Mitigation at %llums, duration%c%llums, max. temp=%dm°C\n",
 803                    ktime_to_ms(tze->timestamp), c, duration_ms, tze->max_temp);
 804
 805         seq_printf(s, "| trip |     type | temp(m°C) | hyst(m°C) | duration(ms) |  avg(m°C) |  min(m°C) |\n");
 806
 807         for_each_trip_desc(tz, td) {
 808                 const struct thermal_trip *trip = &td->trip;
 809                 struct trip_stats *trip_stats;
 810
 811                 /*
 812                  * There is no possible mitigation happening at the
 813                  * critical trip point, so the stats will be always
 814                  * zero, skip this trip point
 815                  */
 816                 if (trip->type == THERMAL_TRIP_CRITICAL)
 817                         continue;
 818
 819                 trip_id = thermal_zone_trip_id(tz, trip);
 820                 trip_stats = &tze->trip_stats[trip_id];
 821
 822                 /* Skip trips without any stats. */
 823                 if (trip_stats->trip_temp == THERMAL_TEMP_INVALID)
 824                         continue;
 825
 826                 if (trip_stats->timestamp != KTIME_MAX) {
 827                         /* Mitigation in progress. */
 828                         ktime_t delta = ktime_sub(ktime_get(),
 829                                                   trip_stats->timestamp);
 830
 831                         delta = ktime_add(delta, trip_stats->duration);
 832                         duration_ms = ktime_to_ms(delta);
 833                         c = '>';
 834                 } else {
 835                         duration_ms = ktime_to_ms(trip_stats->duration);
 836                         c = ' ';
 837                 }
 838
 839                 seq_printf(s, "| %*d | %*s | %*d | %*d | %c%*lld | %*d | %*d |\n",
 840                            4 , trip_id,
 841                            8, thermal_trip_type_name(trip->type),
 842                            9, trip_stats->trip_temp,
 843                            9, trip_stats->trip_hyst,
 844                            c, 11, duration_ms,
 845                            9, trip_stats->avg,
 846                            9, trip_stats->min);
 847         }
 848
 849         return 0;
 850 }
 851
 852 static const struct seq_operations tze_sops = {
 853         .start = tze_seq_start,
 854         .next = tze_seq_next,
 855         .stop = tze_seq_stop,
 856         .show = tze_seq_show,
 857 };
 858
 859 DEFINE_SEQ_ATTRIBUTE(tze);
 860
 861 void thermal_debug_tz_add(struct thermal_zone_device *tz)
 862 {
 863         struct thermal_debugfs *thermal_dbg;
 864         struct tz_debugfs *tz_dbg;
 865
 866         thermal_dbg = thermal_debugfs_add_id(d_tz, tz->id);
 867         if (!thermal_dbg)
 868                 return;
 869
 870         tz_dbg = &thermal_dbg->tz_dbg;
 871
 872         tz_dbg->tz = tz;
 873
 874         tz_dbg->trips_crossed = kzalloc(sizeof(int) * tz->num_trips, GFP_KERNEL);
 875         if (!tz_dbg->trips_crossed) {
 876                 thermal_debugfs_remove_id(thermal_dbg);
 877                 return;
 878         }
 879
 880         INIT_LIST_HEAD(&tz_dbg->tz_episodes);
 881
 882         debugfs_create_file("mitigations", 0400, thermal_dbg->d_top,
 883                             thermal_dbg, &tze_fops);
 884
 885         tz->debugfs = thermal_dbg;
 886 }
 887
 888 void thermal_debug_tz_remove(struct thermal_zone_device *tz)
 889 {
 890         struct thermal_debugfs *thermal_dbg;
 891         struct tz_episode *tze, *tmp;
 892         struct tz_debugfs *tz_dbg;
 893         int *trips_crossed;
 894
 895         mutex_lock(&tz->lock);
 896
 897         thermal_dbg = tz->debugfs;
 898         if (!thermal_dbg) {
 899                 mutex_unlock(&tz->lock);
 900                 return;
 901         }
 902
 903         tz->debugfs = NULL;
 904
 905         mutex_unlock(&tz->lock);
 906
 907         tz_dbg = &thermal_dbg->tz_dbg;
 908
 909         mutex_lock(&thermal_dbg->lock);
 910
 911         trips_crossed = tz_dbg->trips_crossed;
 912
 913         list_for_each_entry_safe(tze, tmp, &tz_dbg->tz_episodes, node) {
 914                 list_del(&tze->node);
 915                 kfree(tze);
 916         }
 917
 918         mutex_unlock(&thermal_dbg->lock);
 919
 920         thermal_debugfs_remove_id(thermal_dbg);
 921         kfree(trips_crossed);
 922 }
 923
 924 void thermal_debug_tz_resume(struct thermal_zone_device *tz)
 925 {
 926         struct thermal_debugfs *thermal_dbg = tz->debugfs;
 927         ktime_t now = ktime_get();
 928         struct tz_debugfs *tz_dbg;
 929         struct tz_episode *tze;
 930         int i;
 931
 932         if (!thermal_dbg)
 933                 return;
 934
 935         mutex_lock(&thermal_dbg->lock);
 936
 937         tz_dbg = &thermal_dbg->tz_dbg;
 938
 939         if (!tz_dbg->nr_trips)
 940                 goto out;
 941
 942         /*
 943          * A mitigation episode was in progress before the preceding system
 944          * suspend transition, so close it because the zone handling is starting
 945          * over from scratch.
 946          */
 947         tze = list_first_entry(&tz_dbg->tz_episodes, struct tz_episode, node);
 948
 949         for (i = 0; i < tz_dbg->nr_trips; i++)
 950                 tz_episode_close_trip(tze, tz_dbg->trips_crossed[i], now);
 951
 952         tze->duration = ktime_sub(now, tze->timestamp);
 953
 954         tz_dbg->nr_trips = 0;
 955
 956 out:
 957         mutex_unlock(&thermal_dbg->lock);
 958 }