// SPDX-License-Identifier: GPL-2.0/* * Copyright 2023 Linaro Limited * * Author: Daniel Lezcano <daniel.lezcano@linaro.org> * * 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_obj(*thermal_dbg);	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_obj(*cdev_record);	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\tOccurrences\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.

Lines 1–500 of 968. Load more