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;
|
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 */
|
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
|
|
|
|
* @type: trip point type
|
|
|
|
* @priv: pointer to driver data associated with this trip
|
|
|
|
*/
|
|
|
|
struct thermal_trip {
|
|
|
|
int temperature;
|
|
|
|
int hysteresis;
|
|
|
|
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-08-22 11:40:06 +00:00
|
|
|
int (*get_trend) (struct thermal_zone_device *, struct thermal_trip *,
|
2012-06-27 01:54:33 +00:00
|
|
|
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;
|
2021-03-14 11:13:29 +00:00
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
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
|
|
|
|
* @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
|
2016-03-18 02:03:24 +00:00
|
|
|
* @trips_disabled; bitmap for disabled trips
|
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
|
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;
|
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;
|
2016-03-18 02:03:24 +00:00
|
|
|
unsigned long trips_disabled; /* bitmap for disabled 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;
|
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
|
|
|
|
* @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);
|
2012-09-18 05:34:57 +00:00
|
|
|
int (*throttle)(struct thermal_zone_device *tz, int trip);
|
|
|
|
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);
|
|
|
|
|
2022-10-03 09:25:36 +00:00
|
|
|
int thermal_zone_set_trip(struct thermal_zone_device *tz, int trip_id,
|
|
|
|
const 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);
|
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);
|
|
|
|
|
|
|
|
int thermal_zone_get_crit_temp(struct thermal_zone_device *tz, int *temp);
|
|
|
|
|
2023-01-23 18:38:31 +00:00
|
|
|
#ifdef CONFIG_THERMAL_ACPI
|
2023-01-27 18:17:03 +00:00
|
|
|
int thermal_acpi_active_trip_temp(struct acpi_device *adev, int id, int *ret_temp);
|
|
|
|
int thermal_acpi_passive_trip_temp(struct acpi_device *adev, int *ret_temp);
|
|
|
|
int thermal_acpi_hot_trip_temp(struct acpi_device *adev, int *ret_temp);
|
|
|
|
int thermal_acpi_critical_trip_temp(struct acpi_device *adev, int *ret_temp);
|
2023-01-23 18:38:31 +00:00
|
|
|
#endif
|
|
|
|
|
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
|
|
|
|
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);
|
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);
|
2023-08-17 09:23:32 +00:00
|
|
|
void thermal_zone_device_exec(struct thermal_zone_device *tz,
|
|
|
|
void (*cb)(struct thermal_zone_device *,
|
|
|
|
unsigned long),
|
|
|
|
unsigned long data);
|
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__ */
|