// 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 … /* * 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 … /** * 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 { … }; /** * 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 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 { … }; /** * 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 { … }; /** * 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 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 { … }; void thermal_debug_init(void) { … } static struct thermal_debugfs *thermal_debugfs_add_id(struct dentry *d, int id) { … } static void thermal_debugfs_remove_id(struct thermal_debugfs *thermal_dbg) { … } static struct cdev_record * thermal_debugfs_cdev_record_alloc(struct thermal_debugfs *thermal_dbg, struct list_head *lists, int id) { … } static struct cdev_record * thermal_debugfs_cdev_record_find(struct thermal_debugfs *thermal_dbg, struct list_head *lists, int id) { … } static struct cdev_record * thermal_debugfs_cdev_record_get(struct thermal_debugfs *thermal_dbg, struct list_head *lists, int id) { … } static void thermal_debugfs_cdev_clear(struct cdev_debugfs *cdev_dbg) { … } static void *cdev_seq_start(struct seq_file *s, loff_t *pos) { … } static void *cdev_seq_next(struct seq_file *s, void *v, loff_t *pos) { … } static void cdev_seq_stop(struct seq_file *s, void *v) { … } static int cdev_tt_seq_show(struct seq_file *s, void *v) { … } static const struct seq_operations tt_sops = …; DEFINE_SEQ_ATTRIBUTE(…); static int cdev_dt_seq_show(struct seq_file *s, void *v) { … } static const struct seq_operations dt_sops = …; DEFINE_SEQ_ATTRIBUTE(…); static int cdev_clear_set(void *data, u64 val) { … } DEFINE_DEBUGFS_ATTRIBUTE(…); /** * 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) { … } /** * 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) { … } /** * 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) { … } static struct tz_episode *thermal_debugfs_tz_event_alloc(struct thermal_zone_device *tz, ktime_t now) { … } void thermal_debug_tz_trip_up(struct thermal_zone_device *tz, const struct thermal_trip *trip) { … } static void tz_episode_close_trip(struct tz_episode *tze, int trip_id, ktime_t now) { … } void thermal_debug_tz_trip_down(struct thermal_zone_device *tz, const struct thermal_trip *trip) { … } void thermal_debug_update_trip_stats(struct thermal_zone_device *tz) { … } static void *tze_seq_start(struct seq_file *s, loff_t *pos) { … } static void *tze_seq_next(struct seq_file *s, void *v, loff_t *pos) { … } static void tze_seq_stop(struct seq_file *s, void *v) { … } static int tze_seq_show(struct seq_file *s, void *v) { … } static const struct seq_operations tze_sops = …; DEFINE_SEQ_ATTRIBUTE(…); void thermal_debug_tz_add(struct thermal_zone_device *tz) { … } void thermal_debug_tz_remove(struct thermal_zone_device *tz) { … } void thermal_debug_tz_resume(struct thermal_zone_device *tz) { … }
Codebase Browser
linux