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