2018-05-07 17:52:29 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2008-01-17 07:51:08 +00:00
|
|
|
/*
|
|
|
|
* thermal.h ($Revision: 0 $)
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Intel Corp
|
|
|
|
* Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
|
|
|
|
* Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __THERMAL_H__
|
|
|
|
#define __THERMAL_H__
|
|
|
|
|
2013-09-26 19:55:01 +00:00
|
|
|
#include <linux/of.h>
|
2008-01-17 07:51:08 +00:00
|
|
|
#include <linux/idr.h>
|
|
|
|
#include <linux/device.h>
|
2016-11-08 05:08:52 +00:00
|
|
|
#include <linux/sysfs.h>
|
2008-12-03 17:55:32 +00:00
|
|
|
#include <linux/workqueue.h>
|
2014-11-20 02:11:00 +00:00
|
|
|
#include <uapi/linux/thermal.h>
|
2008-01-17 07:51:08 +00:00
|
|
|
|
2013-02-08 06:52:06 +00:00
|
|
|
/* invalid cooling state */
|
|
|
|
#define THERMAL_CSTATE_INVALID -1UL
|
|
|
|
|
2012-09-18 05:34:52 +00:00
|
|
|
/* No upper/lower limit requirement */
|
2014-12-09 12:22:01 +00:00
|
|
|
#define THERMAL_NO_LIMIT ((u32)~0)
|
2012-09-18 05:34:52 +00:00
|
|
|
|
2015-02-18 16:04:21 +00:00
|
|
|
/* Default weight of a bound cooling device */
|
|
|
|
#define THERMAL_WEIGHT_DEFAULT 0
|
|
|
|
|
2015-10-30 08:31:47 +00:00
|
|
|
/* use value, which < 0K, to indicate an invalid/uninitialized temperature */
|
|
|
|
#define THERMAL_TEMP_INVALID -274000
|
|
|
|
|
2008-01-17 07:51:08 +00:00
|
|
|
struct thermal_zone_device;
|
|
|
|
struct thermal_cooling_device;
|
2015-02-26 19:00:28 +00:00
|
|
|
struct thermal_instance;
|
2024-01-09 09:41:11 +00:00
|
|
|
struct thermal_debugfs;
|
2020-04-02 14:27:40 +00:00
|
|
|
struct thermal_attr;
|
2008-01-17 07:51:08 +00:00
|
|
|
|
2012-06-27 01:54:33 +00:00
|
|
|
enum thermal_trend {
|
|
|
|
THERMAL_TREND_STABLE, /* temperature is stable */
|
|
|
|
THERMAL_TREND_RAISING, /* temperature is raising */
|
|
|
|
THERMAL_TREND_DROPPING, /* temperature is dropping */
|
|
|
|
};
|
|
|
|
|
2016-08-26 23:21:16 +00:00
|
|
|
/* Thermal notification reason */
|
|
|
|
enum thermal_notify_event {
|
|
|
|
THERMAL_EVENT_UNSPECIFIED, /* Unspecified event */
|
|
|
|
THERMAL_EVENT_TEMP_SAMPLE, /* New Temperature sample */
|
|
|
|
THERMAL_TRIP_VIOLATED, /* TRIP Point violation */
|
|
|
|
THERMAL_TRIP_CHANGED, /* TRIP Point temperature changed */
|
|
|
|
THERMAL_DEVICE_DOWN, /* Thermal device is down */
|
|
|
|
THERMAL_DEVICE_UP, /* Thermal device is up after a down event */
|
|
|
|
THERMAL_DEVICE_POWER_CAPABILITY_CHANGED, /* power capability changed */
|
2017-08-09 18:45:40 +00:00
|
|
|
THERMAL_TABLE_CHANGED, /* Thermal table(s) changed */
|
2020-09-15 22:36:49 +00:00
|
|
|
THERMAL_EVENT_KEEP_ALIVE, /* Request for user space handler to respond */
|
2023-12-20 23:17:45 +00:00
|
|
|
THERMAL_TZ_BIND_CDEV, /* Cooling dev is bind to the thermal zone */
|
|
|
|
THERMAL_TZ_UNBIND_CDEV, /* Cooling dev is unbind from the thermal zone */
|
2023-12-20 23:17:52 +00:00
|
|
|
THERMAL_INSTANCE_WEIGHT_CHANGED, /* Thermal instance weight changed */
|
2016-08-26 23:21:16 +00:00
|
|
|
};
|
|
|
|
|
2023-08-22 11:40:06 +00:00
|
|
|
/**
|
|
|
|
* struct thermal_trip - representation of a point in temperature domain
|
|
|
|
* @temperature: temperature value in miliCelsius
|
|
|
|
* @hysteresis: relative hysteresis in miliCelsius
|
thermal: core: Add trip thresholds for trip crossing detection
The trip crossing detection in handle_thermal_trip() does not work
correctly in the cases when a trip point is crossed on the way up and
then the zone temperature stays above its low temperature (that is, its
temperature decreased by its hysteresis). The trip temperature may
be passed by the zone temperature subsequently in that case, even
multiple times, but that does not count as the trip crossing as long as
the zone temperature does not fall below the trip's low temperature or,
in other words, until the trip is crossed on the way down.
|-----------low--------high------------|
|<--------->|
| hyst |
| |
| -|--> crossed on the way up
|
<---|-- crossed on the way down
However, handle_thermal_trip() will invoke thermal_notify_tz_trip_up()
every time the trip temperature is passed by the zone temperature on
the way up regardless of whether or not the trip has been crossed on
the way down yet. Moreover, it will not call thermal_notify_tz_trip_down()
if the last zone temperature was between the trip's temperature and its
low temperature, so some "trip crossed on the way down" events may not
be reported.
To address this issue, introduce trip thresholds equal to either the
temperature of the given trip, or its low temperature, such that if
the trip's threshold is passed by the zone temperature on the way up,
its value will be set to the trip's low temperature and
thermal_notify_tz_trip_up() will be called, and if the trip's threshold
is passed by the zone temperature on the way down, its value will be set
to the trip's temperature (high) and thermal_notify_tz_trip_down() will
be called. Accordingly, if the threshold is passed on the way up, it
cannot be passed on the way up again until its passed on the way down
and if it is passed on the way down, it cannot be passed on the way down
again until it is passed on the way up which guarantees correct
triggering of trip crossing notifications.
If the last temperature of the zone is invalid, the trip's threshold
will be set depending of the zone's current temperature: If that
temperature is above the trip's temperature, its threshold will be
set to its low temperature or otherwise its threshold will be set to
its (high) temperature. Because the zone temperature is initially
set to invalid and tz->last_temperature is only updated by
update_temperature(), this is sufficient to set the correct initial
threshold values for all trips.
Link: https://lore.kernel.org/all/20220718145038.1114379-4-daniel.lezcano@linaro.org
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2023-11-09 15:01:48 +00:00
|
|
|
* @threshold: trip crossing notification threshold miliCelsius
|
2023-08-22 11:40:06 +00:00
|
|
|
* @type: trip point type
|
|
|
|
* @priv: pointer to driver data associated with this trip
|
|
|
|
*/
|
|
|
|
struct thermal_trip {
|
|
|
|
int temperature;
|
|
|
|
int hysteresis;
|
thermal: core: Add trip thresholds for trip crossing detection
The trip crossing detection in handle_thermal_trip() does not work
correctly in the cases when a trip point is crossed on the way up and
then the zone temperature stays above its low temperature (that is, its
temperature decreased by its hysteresis). The trip temperature may
be passed by the zone temperature subsequently in that case, even
multiple times, but that does not count as the trip crossing as long as
the zone temperature does not fall below the trip's low temperature or,
in other words, until the trip is crossed on the way down.
|-----------low--------high------------|
|<--------->|
| hyst |
| |
| -|--> crossed on the way up
|
<---|-- crossed on the way down
However, handle_thermal_trip() will invoke thermal_notify_tz_trip_up()
every time the trip temperature is passed by the zone temperature on
the way up regardless of whether or not the trip has been crossed on
the way down yet. Moreover, it will not call thermal_notify_tz_trip_down()
if the last zone temperature was between the trip's temperature and its
low temperature, so some "trip crossed on the way down" events may not
be reported.
To address this issue, introduce trip thresholds equal to either the
temperature of the given trip, or its low temperature, such that if
the trip's threshold is passed by the zone temperature on the way up,
its value will be set to the trip's low temperature and
thermal_notify_tz_trip_up() will be called, and if the trip's threshold
is passed by the zone temperature on the way down, its value will be set
to the trip's temperature (high) and thermal_notify_tz_trip_down() will
be called. Accordingly, if the threshold is passed on the way up, it
cannot be passed on the way up again until its passed on the way down
and if it is passed on the way down, it cannot be passed on the way down
again until it is passed on the way up which guarantees correct
triggering of trip crossing notifications.
If the last temperature of the zone is invalid, the trip's threshold
will be set depending of the zone's current temperature: If that
temperature is above the trip's temperature, its threshold will be
set to its low temperature or otherwise its threshold will be set to
its (high) temperature. Because the zone temperature is initially
set to invalid and tz->last_temperature is only updated by
update_temperature(), this is sufficient to set the correct initial
threshold values for all trips.
Link: https://lore.kernel.org/all/20220718145038.1114379-4-daniel.lezcano@linaro.org
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2023-11-09 15:01:48 +00:00
|
|
|
int threshold;
|
2023-08-22 11:40:06 +00:00
|
|
|
enum thermal_trip_type type;
|
|
|
|
void *priv;
|
|
|
|
};
|
|
|
|
|
2008-01-17 07:51:08 +00:00
|
|
|
struct thermal_zone_device_ops {
|
|
|
|
int (*bind) (struct thermal_zone_device *,
|
|
|
|
struct thermal_cooling_device *);
|
|
|
|
int (*unbind) (struct thermal_zone_device *,
|
|
|
|
struct thermal_cooling_device *);
|
2015-07-24 06:12:54 +00:00
|
|
|
int (*get_temp) (struct thermal_zone_device *, int *);
|
2016-06-22 08:42:01 +00:00
|
|
|
int (*set_trips) (struct thermal_zone_device *, int, int);
|
2020-06-29 12:29:25 +00:00
|
|
|
int (*change_mode) (struct thermal_zone_device *,
|
2008-11-27 17:48:13 +00:00
|
|
|
enum thermal_device_mode);
|
2015-07-24 06:12:54 +00:00
|
|
|
int (*set_trip_temp) (struct thermal_zone_device *, int, int);
|
|
|
|
int (*set_trip_hyst) (struct thermal_zone_device *, int, int);
|
|
|
|
int (*get_crit_temp) (struct thermal_zone_device *, int *);
|
|
|
|
int (*set_emul_temp) (struct thermal_zone_device *, int);
|
2023-09-07 18:18:56 +00:00
|
|
|
int (*get_trend) (struct thermal_zone_device *,
|
|
|
|
const struct thermal_trip *, enum thermal_trend *);
|
2020-12-10 12:15:11 +00:00
|
|
|
void (*hot)(struct thermal_zone_device *);
|
|
|
|
void (*critical)(struct thermal_zone_device *);
|
2008-01-17 07:51:08 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct thermal_cooling_device_ops {
|
2008-11-27 17:48:13 +00:00
|
|
|
int (*get_max_state) (struct thermal_cooling_device *, unsigned long *);
|
|
|
|
int (*get_cur_state) (struct thermal_cooling_device *, unsigned long *);
|
|
|
|
int (*set_cur_state) (struct thermal_cooling_device *, unsigned long);
|
2020-09-14 07:11:01 +00:00
|
|
|
int (*get_requested_power)(struct thermal_cooling_device *, u32 *);
|
|
|
|
int (*state2power)(struct thermal_cooling_device *, unsigned long, u32 *);
|
|
|
|
int (*power2state)(struct thermal_cooling_device *, u32, unsigned long *);
|
2008-01-17 07:51:08 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct thermal_cooling_device {
|
|
|
|
int id;
|
2024-01-05 13:45:11 +00:00
|
|
|
const char *type;
|
2022-10-17 10:03:01 +00:00
|
|
|
unsigned long max_state;
|
2008-01-17 07:51:08 +00:00
|
|
|
struct device device;
|
2013-07-03 19:35:39 +00:00
|
|
|
struct device_node *np;
|
2008-01-17 07:51:08 +00:00
|
|
|
void *devdata;
|
2018-04-02 10:56:25 +00:00
|
|
|
void *stats;
|
2010-11-11 15:27:29 +00:00
|
|
|
const struct thermal_cooling_device_ops *ops;
|
2012-06-27 06:13:04 +00:00
|
|
|
bool updated; /* true if the cooling device does not need update */
|
2012-07-24 08:56:21 +00:00
|
|
|
struct mutex lock; /* protect thermal_instances list */
|
2012-06-27 06:11:52 +00:00
|
|
|
struct list_head thermal_instances;
|
2008-01-17 07:51:08 +00:00
|
|
|
struct list_head node;
|
2024-01-09 09:41:11 +00:00
|
|
|
#ifdef CONFIG_THERMAL_DEBUGFS
|
|
|
|
struct thermal_debugfs *debugfs;
|
|
|
|
#endif
|
2008-01-17 07:51:08 +00:00
|
|
|
};
|
|
|
|
|
2014-06-25 10:00:12 +00:00
|
|
|
/**
|
|
|
|
* struct thermal_zone_device - structure for a thermal zone
|
|
|
|
* @id: unique id number for each thermal zone
|
|
|
|
* @type: the thermal zone device type
|
|
|
|
* @device: &struct device for this thermal zone
|
2023-12-08 19:13:44 +00:00
|
|
|
* @removal: removal completion
|
2014-06-25 10:00:12 +00:00
|
|
|
* @trip_temp_attrs: attributes for trip points for sysfs: trip temperature
|
|
|
|
* @trip_type_attrs: attributes for trip points for sysfs: trip type
|
|
|
|
* @trip_hyst_attrs: attributes for trip points for sysfs: trip hysteresis
|
2020-06-29 12:29:17 +00:00
|
|
|
* @mode: current mode of this thermal zone
|
2014-06-25 10:00:12 +00:00
|
|
|
* @devdata: private pointer for device private data
|
2022-07-22 20:00:05 +00:00
|
|
|
* @trips: an array of struct thermal_trip
|
2022-07-22 20:00:04 +00:00
|
|
|
* @num_trips: number of trip points the thermal zone supports
|
2020-12-16 22:03:35 +00:00
|
|
|
* @passive_delay_jiffies: number of jiffies to wait between polls when
|
|
|
|
* performing passive cooling.
|
|
|
|
* @polling_delay_jiffies: number of jiffies to wait between polls when
|
|
|
|
* checking whether trip points have been crossed (0 for
|
|
|
|
* interrupt driven systems)
|
2014-06-25 10:00:12 +00:00
|
|
|
* @temperature: current temperature. This is only for core code,
|
|
|
|
* drivers should use thermal_zone_get_temp() to get the
|
|
|
|
* current temperature
|
|
|
|
* @last_temperature: previous temperature read
|
|
|
|
* @emul_temperature: emulated temperature when using CONFIG_THERMAL_EMULATION
|
|
|
|
* @passive: 1 if you've crossed a passive trip point, 0 otherwise.
|
2016-06-22 08:42:01 +00:00
|
|
|
* @prev_low_trip: the low current temperature if you've crossed a passive
|
|
|
|
trip point.
|
|
|
|
* @prev_high_trip: the above current temperature if you've crossed a
|
|
|
|
passive trip point.
|
2015-10-30 08:32:10 +00:00
|
|
|
* @need_update: if equals 1, thermal_zone_device_update needs to be invoked.
|
2014-06-25 10:00:12 +00:00
|
|
|
* @ops: operations this &thermal_zone_device supports
|
|
|
|
* @tzp: thermal zone parameters
|
|
|
|
* @governor: pointer to the governor for this thermal zone
|
2015-02-26 19:00:27 +00:00
|
|
|
* @governor_data: private pointer for governor data
|
2014-06-25 10:00:12 +00:00
|
|
|
* @thermal_instances: list of &struct thermal_instance of this thermal zone
|
2016-12-21 17:47:03 +00:00
|
|
|
* @ida: &struct ida to generate unique id for this zone's cooling
|
2014-06-25 10:00:12 +00:00
|
|
|
* devices
|
|
|
|
* @lock: lock to protect thermal_instances list
|
|
|
|
* @node: node in thermal_tz_list (in thermal_core.c)
|
|
|
|
* @poll_queue: delayed work for polling
|
2016-08-26 23:21:16 +00:00
|
|
|
* @notify_event: Last notification event
|
2023-12-18 19:25:02 +00:00
|
|
|
* @suspended: thermal zone suspend indicator
|
2014-06-25 10:00:12 +00:00
|
|
|
*/
|
2008-01-17 07:51:08 +00:00
|
|
|
struct thermal_zone_device {
|
|
|
|
int id;
|
|
|
|
char type[THERMAL_NAME_LENGTH];
|
|
|
|
struct device device;
|
2023-12-08 19:13:44 +00:00
|
|
|
struct completion removal;
|
2016-11-08 05:08:52 +00:00
|
|
|
struct attribute_group trips_attribute_group;
|
2012-07-25 02:10:58 +00:00
|
|
|
struct thermal_attr *trip_temp_attrs;
|
|
|
|
struct thermal_attr *trip_type_attrs;
|
2012-07-25 02:10:59 +00:00
|
|
|
struct thermal_attr *trip_hyst_attrs;
|
2020-06-29 12:29:17 +00:00
|
|
|
enum thermal_device_mode mode;
|
2008-01-17 07:51:08 +00:00
|
|
|
void *devdata;
|
2022-07-22 20:00:05 +00:00
|
|
|
struct thermal_trip *trips;
|
2022-07-22 20:00:04 +00:00
|
|
|
int num_trips;
|
2020-12-16 22:03:35 +00:00
|
|
|
unsigned long passive_delay_jiffies;
|
|
|
|
unsigned long polling_delay_jiffies;
|
2012-06-27 01:54:33 +00:00
|
|
|
int temperature;
|
2008-12-03 17:55:32 +00:00
|
|
|
int last_temperature;
|
2013-02-04 00:30:15 +00:00
|
|
|
int emul_temperature;
|
2012-06-27 06:14:05 +00:00
|
|
|
int passive;
|
2016-06-22 08:42:01 +00:00
|
|
|
int prev_low_trip;
|
|
|
|
int prev_high_trip;
|
2015-10-30 08:32:10 +00:00
|
|
|
atomic_t need_update;
|
2013-07-03 19:35:39 +00:00
|
|
|
struct thermal_zone_device_ops *ops;
|
2015-03-02 17:17:19 +00:00
|
|
|
struct thermal_zone_params *tzp;
|
2012-09-18 05:34:57 +00:00
|
|
|
struct thermal_governor *governor;
|
2015-02-26 19:00:27 +00:00
|
|
|
void *governor_data;
|
2012-06-27 02:09:00 +00:00
|
|
|
struct list_head thermal_instances;
|
2016-12-21 17:47:03 +00:00
|
|
|
struct ida ida;
|
2014-06-25 10:00:12 +00:00
|
|
|
struct mutex lock;
|
2008-01-17 07:51:08 +00:00
|
|
|
struct list_head node;
|
2008-12-03 17:55:32 +00:00
|
|
|
struct delayed_work poll_queue;
|
2016-08-26 23:21:16 +00:00
|
|
|
enum thermal_notify_event notify_event;
|
2024-01-09 09:41:11 +00:00
|
|
|
#ifdef CONFIG_THERMAL_DEBUGFS
|
|
|
|
struct thermal_debugfs *debugfs;
|
|
|
|
#endif
|
2023-12-18 19:25:02 +00:00
|
|
|
bool suspended;
|
2008-01-17 07:51:08 +00:00
|
|
|
};
|
2010-10-26 22:03:29 +00:00
|
|
|
|
2014-06-25 10:00:12 +00:00
|
|
|
/**
|
|
|
|
* struct thermal_governor - structure that holds thermal governor information
|
|
|
|
* @name: name of the governor
|
2015-02-26 19:00:27 +00:00
|
|
|
* @bind_to_tz: callback called when binding to a thermal zone. If it
|
|
|
|
* returns 0, the governor is bound to the thermal zone,
|
|
|
|
* otherwise it fails.
|
|
|
|
* @unbind_from_tz: callback called when a governor is unbound from a
|
|
|
|
* thermal zone.
|
2014-06-25 10:00:12 +00:00
|
|
|
* @throttle: callback called for every trip point even if temperature is
|
|
|
|
* below the trip point temperature
|
2023-12-20 23:17:45 +00:00
|
|
|
* @update_tz: callback called when thermal zone internals have changed, e.g.
|
|
|
|
* thermal cooling instance was added/removed
|
2014-06-25 10:00:12 +00:00
|
|
|
* @governor_list: node in thermal_governor_list (in thermal_core.c)
|
|
|
|
*/
|
2012-09-18 05:34:57 +00:00
|
|
|
struct thermal_governor {
|
|
|
|
char name[THERMAL_NAME_LENGTH];
|
2015-02-26 19:00:27 +00:00
|
|
|
int (*bind_to_tz)(struct thermal_zone_device *tz);
|
|
|
|
void (*unbind_from_tz)(struct thermal_zone_device *tz);
|
2023-10-12 18:34:50 +00:00
|
|
|
int (*throttle)(struct thermal_zone_device *tz,
|
|
|
|
const struct thermal_trip *trip);
|
2023-12-20 23:17:45 +00:00
|
|
|
void (*update_tz)(struct thermal_zone_device *tz,
|
|
|
|
enum thermal_notify_event reason);
|
2012-09-18 05:34:57 +00:00
|
|
|
struct list_head governor_list;
|
|
|
|
};
|
|
|
|
|
2012-09-18 05:34:55 +00:00
|
|
|
/* Structure to define Thermal Zone parameters */
|
|
|
|
struct thermal_zone_params {
|
2012-09-18 05:34:57 +00:00
|
|
|
char governor_name[THERMAL_NAME_LENGTH];
|
2013-08-15 15:34:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* a boolean to indicate if the thermal to hwmon sysfs interface
|
|
|
|
* is required. when no_hwmon == false, a hwmon sysfs interface
|
|
|
|
* will be created. when no_hwmon == true, nothing will be done
|
|
|
|
*/
|
|
|
|
bool no_hwmon;
|
|
|
|
|
2015-03-02 17:17:19 +00:00
|
|
|
/*
|
|
|
|
* Sustainable power (heat) that this thermal zone can dissipate in
|
|
|
|
* mW
|
|
|
|
*/
|
|
|
|
u32 sustainable_power;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Proportional parameter of the PID controller when
|
|
|
|
* overshooting (i.e., when temperature is below the target)
|
|
|
|
*/
|
|
|
|
s32 k_po;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Proportional parameter of the PID controller when
|
|
|
|
* undershooting
|
|
|
|
*/
|
|
|
|
s32 k_pu;
|
|
|
|
|
|
|
|
/* Integral parameter of the PID controller */
|
|
|
|
s32 k_i;
|
|
|
|
|
|
|
|
/* Derivative parameter of the PID controller */
|
|
|
|
s32 k_d;
|
|
|
|
|
|
|
|
/* threshold below which the error is no longer accumulated */
|
|
|
|
s32 integral_cutoff;
|
2015-05-12 02:34:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* @slope: slope of a linear temperature adjustment curve.
|
|
|
|
* Used by thermal zone drivers.
|
|
|
|
*/
|
|
|
|
int slope;
|
|
|
|
/*
|
|
|
|
* @offset: offset of a linear temperature adjustment curve.
|
|
|
|
* Used by thermal zone drivers (default 0).
|
|
|
|
*/
|
|
|
|
int offset;
|
2012-09-18 05:34:55 +00:00
|
|
|
};
|
|
|
|
|
2012-09-18 05:34:52 +00:00
|
|
|
/* Function declarations */
|
2013-07-03 19:35:39 +00:00
|
|
|
#ifdef CONFIG_THERMAL_OF
|
2022-08-04 22:43:17 +00:00
|
|
|
struct thermal_zone_device *devm_thermal_of_zone_register(struct device *dev, int id, void *data,
|
|
|
|
const struct thermal_zone_device_ops *ops);
|
|
|
|
|
|
|
|
void devm_thermal_of_zone_unregister(struct device *dev, struct thermal_zone_device *tz);
|
|
|
|
|
2013-07-03 19:35:39 +00:00
|
|
|
#else
|
|
|
|
|
2022-08-04 22:43:49 +00:00
|
|
|
static inline
|
|
|
|
struct thermal_zone_device *devm_thermal_of_zone_register(struct device *dev, int id, void *data,
|
|
|
|
const struct thermal_zone_device_ops *ops)
|
2016-03-09 13:10:06 +00:00
|
|
|
{
|
2022-08-04 22:43:49 +00:00
|
|
|
return ERR_PTR(-ENOTSUPP);
|
2016-03-09 13:10:06 +00:00
|
|
|
}
|
|
|
|
|
2022-08-04 22:43:49 +00:00
|
|
|
static inline void devm_thermal_of_zone_unregister(struct device *dev,
|
|
|
|
struct thermal_zone_device *tz)
|
2022-08-04 22:43:17 +00:00
|
|
|
{
|
|
|
|
}
|
2013-07-03 19:35:39 +00:00
|
|
|
#endif
|
2015-02-14 01:28:02 +00:00
|
|
|
|
2022-12-14 13:16:14 +00:00
|
|
|
int __thermal_zone_get_trip(struct thermal_zone_device *tz, int trip_id,
|
|
|
|
struct thermal_trip *trip);
|
thermal/core: Add a generic thermal_zone_get_trip() function
The thermal_zone_device_ops structure defines a set of ops family,
get_trip_temp(), get_trip_hyst(), get_trip_type(). Each of them is
returning a property of a trip point.
The result is the code is calling the ops everywhere to get a trip
point which is supposed to be defined in the backend driver. It is a
non-sense as a thermal trip can be generic and used by the backend
driver to declare its trip points.
Part of the thermal framework has been changed and all the OF thermal
drivers are using the same definition for the trip point and use a
thermal zone registration variant to pass those trip points which are
part of the thermal zone device structure.
Consequently, we can use a generic function to get the trip points
when they are stored in the thermal zone device structure.
This approach can be generalized to all the drivers and we can get rid
of the ops->get_trip_*. That will result to a much more simpler code
and make possible to rework how the thermal trip are handled in the
thermal core framework as discussed previously.
This change adds a function thermal_zone_get_trip() where we get the
thermal trip point structure which contains all the properties (type,
temp, hyst) instead of doing multiple calls to ops->get_trip_*.
That opens the door for trip point extension with more attributes. For
instance, replacing the trip points disabled bitmask with a 'disabled'
field in the structure.
Here we replace all the calls to ops->get_trip_* in the thermal core
code with a call to the thermal_zone_get_trip() function.
The thermal zone ops defines a callback to retrieve the critical
temperature. As the trip handling is being reworked, all the trip
points will be the same whatever the driver and consequently finding
the critical trip temperature will be just a loop to search for a
critical trip point type.
Provide such a generic function, so we encapsulate the ops
get_crit_temp() which can be removed when all the backend drivers are
using the generic trip points handling.
While at it, add the thermal_zone_get_num_trips() to encapsulate the
code more and reduce the grip with the thermal framework internals.
Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org>
Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Zhang Rui <rui.zhang@intel.com>
Link: https://lore.kernel.org/r/20221003092602.1323944-2-daniel.lezcano@linaro.org
2022-10-03 09:25:34 +00:00
|
|
|
int thermal_zone_get_trip(struct thermal_zone_device *tz, int trip_id,
|
|
|
|
struct thermal_trip *trip);
|
2023-08-07 18:11:07 +00:00
|
|
|
int for_each_thermal_trip(struct thermal_zone_device *tz,
|
|
|
|
int (*cb)(struct thermal_trip *, void *),
|
|
|
|
void *data);
|
2023-10-03 13:17:24 +00:00
|
|
|
int thermal_zone_for_each_trip(struct thermal_zone_device *tz,
|
|
|
|
int (*cb)(struct thermal_trip *, void *),
|
|
|
|
void *data);
|
thermal/core: Add a generic thermal_zone_get_trip() function
The thermal_zone_device_ops structure defines a set of ops family,
get_trip_temp(), get_trip_hyst(), get_trip_type(). Each of them is
returning a property of a trip point.
The result is the code is calling the ops everywhere to get a trip
point which is supposed to be defined in the backend driver. It is a
non-sense as a thermal trip can be generic and used by the backend
driver to declare its trip points.
Part of the thermal framework has been changed and all the OF thermal
drivers are using the same definition for the trip point and use a
thermal zone registration variant to pass those trip points which are
part of the thermal zone device structure.
Consequently, we can use a generic function to get the trip points
when they are stored in the thermal zone device structure.
This approach can be generalized to all the drivers and we can get rid
of the ops->get_trip_*. That will result to a much more simpler code
and make possible to rework how the thermal trip are handled in the
thermal core framework as discussed previously.
This change adds a function thermal_zone_get_trip() where we get the
thermal trip point structure which contains all the properties (type,
temp, hyst) instead of doing multiple calls to ops->get_trip_*.
That opens the door for trip point extension with more attributes. For
instance, replacing the trip points disabled bitmask with a 'disabled'
field in the structure.
Here we replace all the calls to ops->get_trip_* in the thermal core
code with a call to the thermal_zone_get_trip() function.
The thermal zone ops defines a callback to retrieve the critical
temperature. As the trip handling is being reworked, all the trip
points will be the same whatever the driver and consequently finding
the critical trip temperature will be just a loop to search for a
critical trip point type.
Provide such a generic function, so we encapsulate the ops
get_crit_temp() which can be removed when all the backend drivers are
using the generic trip points handling.
While at it, add the thermal_zone_get_num_trips() to encapsulate the
code more and reduce the grip with the thermal framework internals.
Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org>
Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Zhang Rui <rui.zhang@intel.com>
Link: https://lore.kernel.org/r/20221003092602.1323944-2-daniel.lezcano@linaro.org
2022-10-03 09:25:34 +00:00
|
|
|
int thermal_zone_get_num_trips(struct thermal_zone_device *tz);
|
2023-12-05 19:18:39 +00:00
|
|
|
void thermal_zone_set_trip_temp(struct thermal_zone_device *tz,
|
|
|
|
struct thermal_trip *trip, int temp);
|
thermal/core: Add a generic thermal_zone_get_trip() function
The thermal_zone_device_ops structure defines a set of ops family,
get_trip_temp(), get_trip_hyst(), get_trip_type(). Each of them is
returning a property of a trip point.
The result is the code is calling the ops everywhere to get a trip
point which is supposed to be defined in the backend driver. It is a
non-sense as a thermal trip can be generic and used by the backend
driver to declare its trip points.
Part of the thermal framework has been changed and all the OF thermal
drivers are using the same definition for the trip point and use a
thermal zone registration variant to pass those trip points which are
part of the thermal zone device structure.
Consequently, we can use a generic function to get the trip points
when they are stored in the thermal zone device structure.
This approach can be generalized to all the drivers and we can get rid
of the ops->get_trip_*. That will result to a much more simpler code
and make possible to rework how the thermal trip are handled in the
thermal core framework as discussed previously.
This change adds a function thermal_zone_get_trip() where we get the
thermal trip point structure which contains all the properties (type,
temp, hyst) instead of doing multiple calls to ops->get_trip_*.
That opens the door for trip point extension with more attributes. For
instance, replacing the trip points disabled bitmask with a 'disabled'
field in the structure.
Here we replace all the calls to ops->get_trip_* in the thermal core
code with a call to the thermal_zone_get_trip() function.
The thermal zone ops defines a callback to retrieve the critical
temperature. As the trip handling is being reworked, all the trip
points will be the same whatever the driver and consequently finding
the critical trip temperature will be just a loop to search for a
critical trip point type.
Provide such a generic function, so we encapsulate the ops
get_crit_temp() which can be removed when all the backend drivers are
using the generic trip points handling.
While at it, add the thermal_zone_get_num_trips() to encapsulate the
code more and reduce the grip with the thermal framework internals.
Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org>
Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Zhang Rui <rui.zhang@intel.com>
Link: https://lore.kernel.org/r/20221003092602.1323944-2-daniel.lezcano@linaro.org
2022-10-03 09:25:34 +00:00
|
|
|
|
|
|
|
int thermal_zone_get_crit_temp(struct thermal_zone_device *tz, int *temp);
|
|
|
|
|
2020-04-02 14:27:45 +00:00
|
|
|
#ifdef CONFIG_THERMAL
|
2023-08-30 16:11:38 +00:00
|
|
|
struct thermal_zone_device *thermal_zone_device_register_with_trips(
|
|
|
|
const char *type,
|
|
|
|
struct thermal_trip *trips,
|
|
|
|
int num_trips, int mask,
|
|
|
|
void *devdata,
|
|
|
|
struct thermal_zone_device_ops *ops,
|
|
|
|
const struct thermal_zone_params *tzp,
|
|
|
|
int passive_delay, int polling_delay);
|
|
|
|
|
2023-08-30 16:13:35 +00:00
|
|
|
struct thermal_zone_device *thermal_tripless_zone_device_register(
|
|
|
|
const char *type,
|
|
|
|
void *devdata,
|
|
|
|
struct thermal_zone_device_ops *ops,
|
|
|
|
const struct thermal_zone_params *tzp);
|
|
|
|
|
2023-08-30 16:11:38 +00:00
|
|
|
void thermal_zone_device_unregister(struct thermal_zone_device *tz);
|
2022-07-22 20:00:05 +00:00
|
|
|
|
2023-03-01 20:14:29 +00:00
|
|
|
void *thermal_zone_device_priv(struct thermal_zone_device *tzd);
|
2023-03-01 20:14:38 +00:00
|
|
|
const char *thermal_zone_device_type(struct thermal_zone_device *tzd);
|
2023-03-01 20:14:40 +00:00
|
|
|
int thermal_zone_device_id(struct thermal_zone_device *tzd);
|
2023-04-19 08:33:38 +00:00
|
|
|
struct device *thermal_zone_device(struct thermal_zone_device *tzd);
|
2023-03-01 20:14:29 +00:00
|
|
|
|
2023-09-21 18:01:43 +00:00
|
|
|
int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz,
|
|
|
|
const struct thermal_trip *trip,
|
|
|
|
struct thermal_cooling_device *cdev,
|
|
|
|
unsigned long upper, unsigned long lower,
|
|
|
|
unsigned int weight);
|
2008-01-17 07:51:08 +00:00
|
|
|
int thermal_zone_bind_cooling_device(struct thermal_zone_device *, int,
|
2012-06-26 08:35:57 +00:00
|
|
|
struct thermal_cooling_device *,
|
2015-02-18 16:04:21 +00:00
|
|
|
unsigned long, unsigned long,
|
|
|
|
unsigned int);
|
2023-09-21 18:01:43 +00:00
|
|
|
int thermal_unbind_cdev_from_trip(struct thermal_zone_device *tz,
|
|
|
|
const struct thermal_trip *trip,
|
|
|
|
struct thermal_cooling_device *cdev);
|
2008-01-17 07:51:08 +00:00
|
|
|
int thermal_zone_unbind_cooling_device(struct thermal_zone_device *, int,
|
|
|
|
struct thermal_cooling_device *);
|
2016-08-26 23:21:16 +00:00
|
|
|
void thermal_zone_device_update(struct thermal_zone_device *,
|
|
|
|
enum thermal_notify_event);
|
2012-09-18 05:34:52 +00:00
|
|
|
|
2019-04-18 16:36:39 +00:00
|
|
|
struct thermal_cooling_device *thermal_cooling_device_register(const char *,
|
|
|
|
void *, const struct thermal_cooling_device_ops *);
|
2013-09-26 19:55:01 +00:00
|
|
|
struct thermal_cooling_device *
|
2019-04-18 16:36:39 +00:00
|
|
|
thermal_of_cooling_device_register(struct device_node *np, const char *, void *,
|
2013-09-26 19:55:01 +00:00
|
|
|
const struct thermal_cooling_device_ops *);
|
2019-04-18 19:58:15 +00:00
|
|
|
struct thermal_cooling_device *
|
|
|
|
devm_thermal_of_cooling_device_register(struct device *dev,
|
|
|
|
struct device_node *np,
|
|
|
|
char *type, void *devdata,
|
|
|
|
const struct thermal_cooling_device_ops *ops);
|
2023-03-17 17:01:26 +00:00
|
|
|
void thermal_cooling_device_update(struct thermal_cooling_device *);
|
2008-01-17 07:51:08 +00:00
|
|
|
void thermal_cooling_device_unregister(struct thermal_cooling_device *);
|
2013-04-05 12:32:28 +00:00
|
|
|
struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name);
|
2015-07-24 06:12:54 +00:00
|
|
|
int thermal_zone_get_temp(struct thermal_zone_device *tz, int *temp);
|
2016-05-05 08:51:42 +00:00
|
|
|
int thermal_zone_get_slope(struct thermal_zone_device *tz);
|
|
|
|
int thermal_zone_get_offset(struct thermal_zone_device *tz);
|
2011-03-01 00:12:19 +00:00
|
|
|
|
2020-06-29 12:29:20 +00:00
|
|
|
int thermal_zone_device_enable(struct thermal_zone_device *tz);
|
|
|
|
int thermal_zone_device_disable(struct thermal_zone_device *tz);
|
2020-12-10 12:15:11 +00:00
|
|
|
void thermal_zone_device_critical(struct thermal_zone_device *tz);
|
2015-02-14 01:28:02 +00:00
|
|
|
#else
|
2023-08-30 16:11:38 +00:00
|
|
|
static inline struct thermal_zone_device *thermal_zone_device_register_with_trips(
|
|
|
|
const char *type,
|
|
|
|
struct thermal_trip *trips,
|
|
|
|
int num_trips, int mask,
|
|
|
|
void *devdata,
|
|
|
|
struct thermal_zone_device_ops *ops,
|
|
|
|
const struct thermal_zone_params *tzp,
|
|
|
|
int passive_delay, int polling_delay)
|
2015-02-14 01:28:02 +00:00
|
|
|
{ return ERR_PTR(-ENODEV); }
|
2023-08-30 16:11:38 +00:00
|
|
|
|
2023-08-30 16:13:35 +00:00
|
|
|
static inline struct thermal_zone_device *thermal_tripless_zone_device_register(
|
|
|
|
const char *type,
|
|
|
|
void *devdata,
|
|
|
|
struct thermal_zone_device_ops *ops,
|
|
|
|
const struct thermal_zone_params *tzp)
|
|
|
|
{ return ERR_PTR(-ENODEV); }
|
|
|
|
|
2023-08-30 16:11:38 +00:00
|
|
|
static inline void thermal_zone_device_unregister(struct thermal_zone_device *tz)
|
2015-02-14 01:28:02 +00:00
|
|
|
{ }
|
2023-08-30 16:11:38 +00:00
|
|
|
|
2015-02-14 01:28:02 +00:00
|
|
|
static inline struct thermal_cooling_device *
|
2021-07-22 09:06:44 +00:00
|
|
|
thermal_cooling_device_register(const char *type, void *devdata,
|
2015-02-14 01:28:02 +00:00
|
|
|
const struct thermal_cooling_device_ops *ops)
|
|
|
|
{ return ERR_PTR(-ENODEV); }
|
|
|
|
static inline struct thermal_cooling_device *
|
|
|
|
thermal_of_cooling_device_register(struct device_node *np,
|
2021-07-22 09:06:44 +00:00
|
|
|
const char *type, void *devdata,
|
|
|
|
const struct thermal_cooling_device_ops *ops)
|
2015-02-14 01:28:02 +00:00
|
|
|
{ return ERR_PTR(-ENODEV); }
|
2019-04-18 19:58:15 +00:00
|
|
|
static inline struct thermal_cooling_device *
|
|
|
|
devm_thermal_of_cooling_device_register(struct device *dev,
|
|
|
|
struct device_node *np,
|
|
|
|
char *type, void *devdata,
|
|
|
|
const struct thermal_cooling_device_ops *ops)
|
|
|
|
{
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
2015-02-14 01:28:02 +00:00
|
|
|
static inline void thermal_cooling_device_unregister(
|
|
|
|
struct thermal_cooling_device *cdev)
|
|
|
|
{ }
|
|
|
|
static inline struct thermal_zone_device *thermal_zone_get_zone_by_name(
|
|
|
|
const char *name)
|
|
|
|
{ return ERR_PTR(-ENODEV); }
|
|
|
|
static inline int thermal_zone_get_temp(
|
2015-07-24 06:12:54 +00:00
|
|
|
struct thermal_zone_device *tz, int *temp)
|
2015-02-14 01:28:02 +00:00
|
|
|
{ return -ENODEV; }
|
2016-05-05 08:51:42 +00:00
|
|
|
static inline int thermal_zone_get_slope(
|
|
|
|
struct thermal_zone_device *tz)
|
|
|
|
{ return -ENODEV; }
|
|
|
|
static inline int thermal_zone_get_offset(
|
|
|
|
struct thermal_zone_device *tz)
|
|
|
|
{ return -ENODEV; }
|
2020-04-02 14:27:43 +00:00
|
|
|
|
2023-03-01 20:14:29 +00:00
|
|
|
static inline void *thermal_zone_device_priv(struct thermal_zone_device *tz)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2023-03-01 20:14:38 +00:00
|
|
|
static inline const char *thermal_zone_device_type(struct thermal_zone_device *tzd)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2023-03-01 20:14:40 +00:00
|
|
|
static inline int thermal_zone_device_id(struct thermal_zone_device *tzd)
|
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2020-06-29 12:29:20 +00:00
|
|
|
static inline int thermal_zone_device_enable(struct thermal_zone_device *tz)
|
|
|
|
{ return -ENODEV; }
|
|
|
|
|
|
|
|
static inline int thermal_zone_device_disable(struct thermal_zone_device *tz)
|
|
|
|
{ return -ENODEV; }
|
2015-02-14 01:28:02 +00:00
|
|
|
#endif /* CONFIG_THERMAL */
|
|
|
|
|
2008-02-09 09:01:48 +00:00
|
|
|
#endif /* __THERMAL_H__ */
|