// SPDX-License-Identifier: GPL-2.0
/*
* Copyright 2023 Linaro Limited
*
* Author: Daniel Lezcano <[email protected]>
*
* Thermal subsystem debug support
*/
#include <linux/debugfs.h>
#include <linux/ktime.h>
#include <linux/list.h>
#include <linux/minmax.h>
#include <linux/mutex.h>
#include <linux/thermal.h>
#include "thermal_core.h"
static struct dentry *d_root;
static struct dentry *d_cdev;
static struct dentry *d_tz;
/*
* Length of the string containing the thermal zone id or the cooling
* device id, including the ending nul character. We can reasonably
* assume there won't be more than 256 thermal zones as the maximum
* observed today is around 32.
*/
#define IDSLENGTH 4
/*
* The cooling device transition list is stored in a hash table where
* the size is CDEVSTATS_HASH_SIZE. The majority of cooling devices
* have dozen of states but some can have much more, so a hash table
* is more adequate in this case, because the cost of browsing the entire
* list when storing the transitions may not be negligible.
*/
#define CDEVSTATS_HASH_SIZE 16
/**
* struct cdev_debugfs - per cooling device statistics structure
* A cooling device can have a high number of states. Showing the
* transitions on a matrix based representation can be overkill given
* most of the transitions won't happen and we end up with a matrix
* filled with zero. Instead, we show the transitions which actually
* happened.
*
* Every transition updates the current_state and the timestamp. The
* transitions and the durations are stored in lists.
*
* @total: the number of transitions for this cooling device
* @current_state: the current cooling device state
* @timestamp: the state change timestamp
* @transitions: an array of lists containing the state transitions
* @durations: an array of lists containing the residencies of each state
*/
struct cdev_debugfs {
u32 total;
int current_state;
ktime_t timestamp;
struct list_head transitions[CDEVSTATS_HASH_SIZE];
struct list_head durations[CDEVSTATS_HASH_SIZE];
};
/**
* struct cdev_record - Common structure for cooling device entry
*
* The following common structure allows to store the information
* related to the transitions and to the state residencies. They are
* identified with a id which is associated to a value. It is used as
* nodes for the "transitions" and "durations" above.
*
* @node: node to insert the structure in a list
* @id: identifier of the value which can be a state or a transition
* @residency: a ktime_t representing a state residency duration
* @count: a number of occurrences
*/
struct cdev_record {
struct list_head node;
int id;
union {
ktime_t residency;
u64 count;
};
};
/**
* struct trip_stats - Thermal trip statistics
*
* The trip_stats structure has the relevant information to show the
* statistics related to temperature going above a trip point.
*
* @timestamp: the trip crossing timestamp
* @duration: total time when the zone temperature was above the trip point
* @trip_temp: trip temperature at mitigation start
* @trip_hyst: trip hysteresis at mitigation start
* @count: the number of times the zone temperature was above the trip point
* @min: minimum recorded temperature above the trip point
* @avg: average temperature above the trip point
*/
struct trip_stats {
ktime_t timestamp;
ktime_t duration;
int trip_temp;
int trip_hyst;
int count;
int min;
int avg;
};
/**
* struct tz_episode - A mitigation episode information
*
* The tz_episode structure describes a mitigation episode. A
* mitigation episode begins the trip point with the lower temperature
* is crossed the way up and ends when it is crossed the way
* down. During this episode we can have multiple trip points crossed
* the way up and down if there are multiple trip described in the
* firmware after the lowest temperature trip point.
*
* @timestamp: first trip point crossed the way up
* @duration: total duration of the mitigation episode
* @node: a list element to be added to the list of tz events
* @max_temp: maximum zone temperature during this episode
* @trip_stats: per trip point statistics, flexible array
*/
struct tz_episode {
ktime_t timestamp;
ktime_t duration;
struct list_head node;
int max_temp;
struct trip_stats trip_stats[];
};
/**
* struct tz_debugfs - Store all mitigation episodes for a thermal zone
*
* The tz_debugfs structure contains the list of the mitigation
* episodes and has to track which trip point has been crossed in
* order to handle correctly nested trip point mitigation episodes.
*
* We keep the history of the trip point crossed in an array and as we
* can go back and forth inside this history, eg. trip 0,1,2,1,2,1,0,
* we keep track of the current position in the history array.
*
* @tz_episodes: a list of thermal mitigation episodes
* @tz: thermal zone this object belongs to
* @trips_crossed: an array of trip points crossed by id
* @nr_trips: the number of trip points currently being crossed
*/
struct tz_debugfs {
struct list_head tz_episodes;
struct thermal_zone_device *tz;
int *trips_crossed;
int nr_trips;
};
/**
* struct thermal_debugfs - High level structure for a thermal object in debugfs
*
* The thermal_debugfs structure is the common structure used by the
* cooling device or the thermal zone to store the statistics.
*
* @d_top: top directory of the thermal object directory
* @lock: per object lock to protect the internals
*
* @cdev_dbg: a cooling device debug structure
* @tz_dbg: a thermal zone debug structure
*/
struct thermal_debugfs {
struct dentry *d_top;
struct mutex lock;
union {
struct cdev_debugfs cdev_dbg;
struct tz_debugfs tz_dbg;
};
};
void thermal_debug_init(void)
{
d_root = debugfs_create_dir("thermal", NULL);
if (IS_ERR(d_root))
return;
d_cdev = debugfs_create_dir("cooling_devices", d_root);
if (IS_ERR(d_cdev))
return;
d_tz = debugfs_create_dir("thermal_zones", d_root);
}
static struct thermal_debugfs *thermal_debugfs_add_id(struct dentry *d, int id)
{
struct thermal_debugfs *thermal_dbg;
char ids[IDSLENGTH];
thermal_dbg = kzalloc(sizeof(*thermal_dbg), GFP_KERNEL);
if (!thermal_dbg)
return NULL;
mutex_init(&thermal_dbg->lock);
snprintf(ids, IDSLENGTH, "%d", id);
thermal_dbg->d_top = debugfs_create_dir(ids, d);
if (IS_ERR(thermal_dbg->d_top)) {
kfree(thermal_dbg);
return NULL;
}
return thermal_dbg;
}
static void thermal_debugfs_remove_id(struct thermal_debugfs *thermal_dbg)
{
if (!thermal_dbg)
return;
debugfs_remove(thermal_dbg->d_top);
kfree(thermal_dbg);
}
static struct cdev_record *
thermal_debugfs_cdev_record_alloc(struct thermal_debugfs *thermal_dbg,
struct list_head *lists, int id)
{
struct cdev_record *cdev_record;
cdev_record = kzalloc(sizeof(*cdev_record), GFP_KERNEL);
if (!cdev_record)
return NULL;
cdev_record->id = id;
INIT_LIST_HEAD(&cdev_record->node);
list_add_tail(&cdev_record->node,
&lists[cdev_record->id % CDEVSTATS_HASH_SIZE]);
return cdev_record;
}
static struct cdev_record *
thermal_debugfs_cdev_record_find(struct thermal_debugfs *thermal_dbg,
struct list_head *lists, int id)
{
struct cdev_record *entry;
list_for_each_entry(entry, &lists[id % CDEVSTATS_HASH_SIZE], node)
if (entry->id == id)
return entry;
return NULL;
}
static struct cdev_record *
thermal_debugfs_cdev_record_get(struct thermal_debugfs *thermal_dbg,
struct list_head *lists, int id)
{
struct cdev_record *cdev_record;
cdev_record = thermal_debugfs_cdev_record_find(thermal_dbg, lists, id);
if (cdev_record)
return cdev_record;
return thermal_debugfs_cdev_record_alloc(thermal_dbg, lists, id);
}
static void thermal_debugfs_cdev_clear(struct cdev_debugfs *cdev_dbg)
{
int i;
struct cdev_record *entry, *tmp;
for (i = 0; i < CDEVSTATS_HASH_SIZE; i++) {
list_for_each_entry_safe(entry, tmp,
&cdev_dbg->transitions[i], node) {
list_del(&entry->node);
kfree(entry);
}
list_for_each_entry_safe(entry, tmp,
&cdev_dbg->durations[i], node) {
list_del(&entry->node);
kfree(entry);
}
}
cdev_dbg->total = 0;
}
static void *cdev_seq_start(struct seq_file *s, loff_t *pos)
{
struct thermal_debugfs *thermal_dbg = s->private;
mutex_lock(&thermal_dbg->lock);
return (*pos < CDEVSTATS_HASH_SIZE) ? pos : NULL;
}
static void *cdev_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
(*pos)++;
return (*pos < CDEVSTATS_HASH_SIZE) ? pos : NULL;
}
static void cdev_seq_stop(struct seq_file *s, void *v)
{
struct thermal_debugfs *thermal_dbg = s->private;
mutex_unlock(&thermal_dbg->lock);
}
static int cdev_tt_seq_show(struct seq_file *s, void *v)
{
struct thermal_debugfs *thermal_dbg = s->private;
struct cdev_debugfs *cdev_dbg = &thermal_dbg->cdev_dbg;
struct list_head *transitions = cdev_dbg->transitions;
struct cdev_record *entry;
int i = *(loff_t *)v;
if (!i)
seq_puts(s, "Transition\tOccurences\n");
list_for_each_entry(entry, &transitions[i], node) {
/*
* Assuming maximum cdev states is 1024, the longer
* string for a transition would be "1024->1024\0"
*/
char buffer[11];
snprintf(buffer, ARRAY_SIZE(buffer), "%d->%d",
entry->id >> 16, entry->id & 0xFFFF);
seq_printf(s, "%-10s\t%-10llu\n", buffer, entry->count);
}
return 0;
}
static const struct seq_operations tt_sops = {
.start = cdev_seq_start,
.next = cdev_seq_next,
.stop = cdev_seq_stop,
.show = cdev_tt_seq_show,
};
DEFINE_SEQ_ATTRIBUTE(tt);
static int cdev_dt_seq_show(struct seq_file *s, void *v)
{
struct thermal_debugfs *thermal_dbg = s->private;
struct cdev_debugfs *cdev_dbg = &thermal_dbg->cdev_dbg;
struct list_head *durations = cdev_dbg->durations;
struct cdev_record *entry;
int i = *(loff_t *)v;
if (!i)
seq_puts(s, "State\tResidency\n");
list_for_each_entry(entry, &durations[i], node) {
s64 duration = ktime_to_ms(entry->residency);
if (entry->id == cdev_dbg->current_state)
duration += ktime_ms_delta(ktime_get(),
cdev_dbg->timestamp);
seq_printf(s, "%-5d\t%-10llu\n", entry->id, duration);
}
return 0;
}
static const struct seq_operations dt_sops = {
.start = cdev_seq_start,
.next = cdev_seq_next,
.stop = cdev_seq_stop,
.show = cdev_dt_seq_show,
};
DEFINE_SEQ_ATTRIBUTE(dt);
static int cdev_clear_set(void *data, u64 val)
{
struct thermal_debugfs *thermal_dbg = data;
if (!val)
return -EINVAL;
mutex_lock(&thermal_dbg->lock);
thermal_debugfs_cdev_clear(&thermal_dbg->cdev_dbg);
mutex_unlock(&thermal_dbg->lock);
return 0;
}
DEFINE_DEBUGFS_ATTRIBUTE(cdev_clear_fops, NULL, cdev_clear_set, "%llu\n");
/**
* thermal_debug_cdev_state_update - Update a cooling device state change
*
* Computes a transition and the duration of the previous state residency.
*
* @cdev : a pointer to a cooling device
* @new_state: an integer corresponding to the new cooling device state
*/
void thermal_debug_cdev_state_update(const struct thermal_cooling_device *cdev,
int new_state)
{
struct thermal_debugfs *thermal_dbg = cdev->debugfs;
struct cdev_debugfs *cdev_dbg;
struct cdev_record *cdev_record;
int transition, old_state;
if (!thermal_dbg || (thermal_dbg->cdev_dbg.current_state == new_state))
return;
mutex_lock(&thermal_dbg->lock);
cdev_dbg = &thermal_dbg->cdev_dbg;
old_state = cdev_dbg->current_state;
/*
* Get the old state information in the durations list. If
* this one does not exist, a new allocated one will be
* returned. Recompute the total duration in the old state and
* get a new timestamp for the new state.
*/
cdev_record = thermal_debugfs_cdev_record_get(thermal_dbg,
cdev_dbg->durations,
old_state);
if (cdev_record) {
ktime_t now = ktime_get();
ktime_t delta = ktime_sub(now, cdev_dbg->timestamp);
cdev_record->residency = ktime_add(cdev_record->residency, delta);
cdev_dbg->timestamp = now;
}
cdev_dbg->current_state = new_state;
/*
* Create a record for the new state if it is not there, so its
* duration will be printed by cdev_dt_seq_show() as expected if it
* runs before the next state transition.
*/
thermal_debugfs_cdev_record_get(thermal_dbg, cdev_dbg->durations, new_state);
transition = (old_state << 16) | new_state;
/*
* Get the transition in the transitions list. If this one
* does not exist, a new allocated one will be returned.
* Increment the occurrence of this transition which is stored
* in the value field.
*/
cdev_record = thermal_debugfs_cdev_record_get(thermal_dbg,
cdev_dbg->transitions,
transition);
if (cdev_record)
cdev_record->count++;
cdev_dbg->total++;
mutex_unlock(&thermal_dbg->lock);
}
/**
* thermal_debug_cdev_add - Add a cooling device debugfs entry
*
* Allocates a cooling device object for debug, initializes the
* statistics and create the entries in sysfs.
* @cdev: a pointer to a cooling device
* @state: current state of the cooling device
*/
void thermal_debug_cdev_add(struct thermal_cooling_device *cdev, int state)
{
struct thermal_debugfs *thermal_dbg;
struct cdev_debugfs *cdev_dbg;
int i;
thermal_dbg = thermal_debugfs_add_id(d_cdev, cdev->id);
if (!thermal_dbg)
return;
cdev_dbg = &thermal_dbg->cdev_dbg;
for (i = 0; i < CDEVSTATS_HASH_SIZE; i++) {
INIT_LIST_HEAD(&cdev_dbg->transitions[i]);
INIT_LIST_HEAD(&cdev_dbg->durations[i]);
}
cdev_dbg->current_state = state;
cdev_dbg->timestamp = ktime_get();
/*
* Create a record for the initial cooling device state, so its
* duration will be printed by cdev_dt_seq_show() as expected if it
* runs before the first state transition.
*/
thermal_debugfs_cdev_record_get(thermal_dbg, cdev_dbg->durations, state);
debugfs_create_file("trans_table", 0400, thermal_dbg->d_top,
thermal_dbg, &tt_fops);
debugfs_create_file("time_in_state_ms", 0400, thermal_dbg->d_top,
thermal_dbg, &dt_fops);
debugfs_create_file("clear", 0200, thermal_dbg->d_top,
thermal_dbg, &cdev_clear_fops);
debugfs_create_u32("total_trans", 0400, thermal_dbg->d_top,
&cdev_dbg->total);
cdev->debugfs = thermal_dbg;
}
/**
* thermal_debug_cdev_remove - Remove a cooling device debugfs entry
*
* Frees the statistics memory data and remove the debugfs entry
*
* @cdev: a pointer to a cooling device
*/
void thermal_debug_cdev_remove(struct thermal_cooling_device *cdev)
{
struct thermal_debugfs *thermal_dbg;
mutex_lock(&cdev->lock);
thermal_dbg = cdev->debugfs;
if (!thermal_dbg) {
mutex_unlock(&cdev->lock);
return;
}
cdev->debugfs = NULL;
mutex_unlock(&cdev->lock);
mutex_lock(&thermal_dbg->lock);
thermal_debugfs_cdev_clear(&thermal_dbg->cdev_dbg);
mutex_unlock(&thermal_dbg->lock);
thermal_debugfs_remove_id(thermal_dbg);
}
static struct tz_episode *thermal_debugfs_tz_event_alloc(struct thermal_zone_device *tz,
ktime_t now)
{
struct tz_episode *tze;
int i;
tze = kzalloc(struct_size(tze, trip_stats, tz->num_trips), GFP_KERNEL);
if (!tze)
return NULL;
INIT_LIST_HEAD(&tze->node);
tze->timestamp = now;
tze->duration = KTIME_MIN;
tze->max_temp = INT_MIN;
for (i = 0; i < tz->num_trips; i++) {
tze->trip_stats[i].trip_temp = THERMAL_TEMP_INVALID;
tze->trip_stats[i].min = INT_MAX;
}
return tze;
}
void thermal_debug_tz_trip_up(struct thermal_zone_device *tz,
const struct thermal_trip *trip)
{
struct thermal_debugfs *thermal_dbg = tz->debugfs;
int trip_id = thermal_zone_trip_id(tz, trip);
ktime_t now = ktime_get();
struct trip_stats *trip_stats;
struct tz_debugfs *tz_dbg;
struct tz_episode *tze;
if (!thermal_dbg)
return;
tz_dbg = &thermal_dbg->tz_dbg;
mutex_lock(&thermal_dbg->lock);
/*
* The mitigation is starting. A mitigation can contain
* several episodes where each of them is related to a
* temperature crossing a trip point. The episodes are
* nested. That means when the temperature is crossing the
* first trip point, the duration begins to be measured. If
* the temperature continues to increase and reaches the
* second trip point, the duration of the first trip must be
* also accumulated.
*
* eg.
*
* temp
* ^
* | --------
* trip 2 / \ ------
* | /| |\ /| |\
* trip 1 / | | `---- | | \
* | /| | | | | |\
* trip 0 / | | | | | | \
* | /| | | | | | | |\
* | / | | | | | | | | `--
* | / | | | | | | | |
* |----- | | | | | | | |
* | | | | | | | | |
* --------|-|-|--------|--------|------|-|-|------------------> time
* | | |<--t2-->| |<-t2'>| | |
* | | | |
* | |<------------t1------------>| |
* | |
* |<-------------t0--------------->|
*
*/
if (!tz_dbg->nr_trips) {
tze = thermal_debugfs_tz_event_alloc(tz, now);
if (!tze)
goto unlock;
list_add(&tze->node, &tz_dbg->tz_episodes);
}
/*
* Each time a trip point is crossed the way up, the trip_id
* is stored in the trip_crossed array and the nr_trips is
* incremented. A nr_trips equal to zero means we are entering
* a mitigation episode.
*
* The trip ids may not be in the ascending order but the
* result in the array trips_crossed will be in the ascending
* temperature order. The function detecting when a trip point
* is crossed the way down will handle the very rare case when
* the trip points may have been reordered during this
* mitigation episode.
*/
tz_dbg->trips_crossed[tz_dbg->nr_trips++] = trip_id;
tze = list_first_entry(&tz_dbg->tz_episodes, struct tz_episode, node);
trip_stats = &tze->trip_stats[trip_id];
trip_stats->trip_temp = trip->temperature;
trip_stats->trip_hyst = trip->hysteresis;
trip_stats->timestamp = now;
unlock:
mutex_unlock(&thermal_dbg->lock);
}
static void tz_episode_close_trip(struct tz_episode *tze, int trip_id, ktime_t now)
{
struct trip_stats *trip_stats = &tze->trip_stats[trip_id];
ktime_t delta = ktime_sub(now, trip_stats->timestamp);
trip_stats->duration = ktime_add(delta, trip_stats->duration);
/* Mark the end of mitigation for this trip point. */
trip_stats->timestamp = KTIME_MAX;
}
void thermal_debug_tz_trip_down(struct thermal_zone_device *tz,
const struct thermal_trip *trip)
{
struct thermal_debugfs *thermal_dbg = tz->debugfs;
int trip_id = thermal_zone_trip_id(tz, trip);
ktime_t now = ktime_get();
struct tz_episode *tze;
struct tz_debugfs *tz_dbg;
int i;
if (!thermal_dbg)
return;
tz_dbg = &thermal_dbg->tz_dbg;
mutex_lock(&thermal_dbg->lock);
/*
* The temperature crosses the way down but there was not
* mitigation detected before. That may happen when the
* temperature is greater than a trip point when registering a
* thermal zone, which is a common use case as the kernel has
* no mitigation mechanism yet at boot time.
*/
if (!tz_dbg->nr_trips)
goto out;
for (i = tz_dbg->nr_trips - 1; i >= 0; i--) {
if (tz_dbg->trips_crossed[i] == trip_id)
break;
}
if (i < 0)
goto out;
tz_dbg->nr_trips--;
if (i < tz_dbg->nr_trips)
tz_dbg->trips_crossed[i] = tz_dbg->trips_crossed[tz_dbg->nr_trips];
tze = list_first_entry(&tz_dbg->tz_episodes, struct tz_episode, node);
tz_episode_close_trip(tze, trip_id, now);
/*
* This event closes the mitigation as we are crossing the
* last trip point the way down.
*/
if (!tz_dbg->nr_trips)
tze->duration = ktime_sub(now, tze->timestamp);
out:
mutex_unlock(&thermal_dbg->lock);
}
void thermal_debug_update_trip_stats(struct thermal_zone_device *tz)
{
struct thermal_debugfs *thermal_dbg = tz->debugfs;
struct tz_debugfs *tz_dbg;
struct tz_episode *tze;
int i;
if (!thermal_dbg)
return;
tz_dbg = &thermal_dbg->tz_dbg;
mutex_lock(&thermal_dbg->lock);
if (!tz_dbg->nr_trips)
goto out;
tze = list_first_entry(&tz_dbg->tz_episodes, struct tz_episode, node);
if (tz->temperature > tze->max_temp)
tze->max_temp = tz->temperature;
for (i = 0; i < tz_dbg->nr_trips; i++) {
int trip_id = tz_dbg->trips_crossed[i];
struct trip_stats *trip_stats = &tze->trip_stats[trip_id];
trip_stats->min = min(trip_stats->min, tz->temperature);
trip_stats->avg += (tz->temperature - trip_stats->avg) /
++trip_stats->count;
}
out:
mutex_unlock(&thermal_dbg->lock);
}
static void *tze_seq_start(struct seq_file *s, loff_t *pos)
{
struct thermal_debugfs *thermal_dbg = s->private;
struct tz_debugfs *tz_dbg = &thermal_dbg->tz_dbg;
mutex_lock(&thermal_dbg->lock);
return seq_list_start(&tz_dbg->tz_episodes, *pos);
}
static void *tze_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
struct thermal_debugfs *thermal_dbg = s->private;
struct tz_debugfs *tz_dbg = &thermal_dbg->tz_dbg;
return seq_list_next(v, &tz_dbg->tz_episodes, pos);
}
static void tze_seq_stop(struct seq_file *s, void *v)
{
struct thermal_debugfs *thermal_dbg = s->private;
mutex_unlock(&thermal_dbg->lock);
}
static int tze_seq_show(struct seq_file *s, void *v)
{
struct thermal_debugfs *thermal_dbg = s->private;
struct thermal_zone_device *tz = thermal_dbg->tz_dbg.tz;
struct thermal_trip_desc *td;
struct tz_episode *tze;
u64 duration_ms;
int trip_id;
char c;
tze = list_entry((struct list_head *)v, struct tz_episode, node);
if (tze->duration == KTIME_MIN) {
/* Mitigation in progress. */
duration_ms = ktime_to_ms(ktime_sub(ktime_get(), tze->timestamp));
c = '>';
} else {
duration_ms = ktime_to_ms(tze->duration);
c = '=';
}
seq_printf(s, ",-Mitigation at %llums, duration%c%llums, max. temp=%dm°C\n",
ktime_to_ms(tze->timestamp), c, duration_ms, tze->max_temp);
seq_printf(s, "| trip | type | temp(m°C) | hyst(m°C) | duration(ms) | avg(m°C) | min(m°C) |\n");
for_each_trip_desc(tz, td) {
const struct thermal_trip *trip = &td->trip;
struct trip_stats *trip_stats;
/*
* There is no possible mitigation happening at the
* critical trip point, so the stats will be always
* zero, skip this trip point
*/
if (trip->type == THERMAL_TRIP_CRITICAL)
continue;
trip_id = thermal_zone_trip_id(tz, trip);
trip_stats = &tze->trip_stats[trip_id];
/* Skip trips without any stats. */
if (trip_stats->trip_temp == THERMAL_TEMP_INVALID)
continue;
if (trip_stats->timestamp != KTIME_MAX) {
/* Mitigation in progress. */
ktime_t delta = ktime_sub(ktime_get(),
trip_stats->timestamp);
delta = ktime_add(delta, trip_stats->duration);
duration_ms = ktime_to_ms(delta);
c = '>';
} else {
duration_ms = ktime_to_ms(trip_stats->duration);
c = ' ';
}
seq_printf(s, "| %*d | %*s | %*d | %*d | %c%*lld | %*d | %*d |\n",
4 , trip_id,
8, thermal_trip_type_name(trip->type),
9, trip_stats->trip_temp,
9, trip_stats->trip_hyst,
c, 11, duration_ms,
9, trip_stats->avg,
9, trip_stats->min);
}
return 0;
}
static const struct seq_operations tze_sops = {
.start = tze_seq_start,
.next = tze_seq_next,
.stop = tze_seq_stop,
.show = tze_seq_show,
};
DEFINE_SEQ_ATTRIBUTE(tze);
void thermal_debug_tz_add(struct thermal_zone_device *tz)
{
struct thermal_debugfs *thermal_dbg;
struct tz_debugfs *tz_dbg;
thermal_dbg = thermal_debugfs_add_id(d_tz, tz->id);
if (!thermal_dbg)
return;
tz_dbg = &thermal_dbg->tz_dbg;
tz_dbg->tz = tz;
tz_dbg->trips_crossed = kzalloc(sizeof(int) * tz->num_trips, GFP_KERNEL);
if (!tz_dbg->trips_crossed) {
thermal_debugfs_remove_id(thermal_dbg);
return;
}
INIT_LIST_HEAD(&tz_dbg->tz_episodes);
debugfs_create_file("mitigations", 0400, thermal_dbg->d_top,
thermal_dbg, &tze_fops);
tz->debugfs = thermal_dbg;
}
void thermal_debug_tz_remove(struct thermal_zone_device *tz)
{
struct thermal_debugfs *thermal_dbg;
struct tz_episode *tze, *tmp;
struct tz_debugfs *tz_dbg;
int *trips_crossed;
mutex_lock(&tz->lock);
thermal_dbg = tz->debugfs;
if (!thermal_dbg) {
mutex_unlock(&tz->lock);
return;
}
tz->debugfs = NULL;
mutex_unlock(&tz->lock);
tz_dbg = &thermal_dbg->tz_dbg;
mutex_lock(&thermal_dbg->lock);
trips_crossed = tz_dbg->trips_crossed;
list_for_each_entry_safe(tze, tmp, &tz_dbg->tz_episodes, node) {
list_del(&tze->node);
kfree(tze);
}
mutex_unlock(&thermal_dbg->lock);
thermal_debugfs_remove_id(thermal_dbg);
kfree(trips_crossed);
}
void thermal_debug_tz_resume(struct thermal_zone_device *tz)
{
struct thermal_debugfs *thermal_dbg = tz->debugfs;
ktime_t now = ktime_get();
struct tz_debugfs *tz_dbg;
struct tz_episode *tze;
int i;
if (!thermal_dbg)
return;
mutex_lock(&thermal_dbg->lock);
tz_dbg = &thermal_dbg->tz_dbg;
if (!tz_dbg->nr_trips)
goto out;
/*
* A mitigation episode was in progress before the preceding system
* suspend transition, so close it because the zone handling is starting
* over from scratch.
*/
tze = list_first_entry(&tz_dbg->tz_episodes, struct tz_episode, node);
for (i = 0; i < tz_dbg->nr_trips; i++)
tz_episode_close_trip(tze, tz_dbg->trips_crossed[i], now);
tze->duration = ktime_sub(now, tze->timestamp);
tz_dbg->nr_trips = 0;
out:
mutex_unlock(&thermal_dbg->lock);
}
Codebase Browser
linux