LCOV - code coverage report
Current view: top level - include/linux - thermal.h (source / functions) Hit Total Coverage
Test: Real Lines: 0 2 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 0 -
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  *  thermal.h  ($Revision: 0 $)
       4                 :            :  *
       5                 :            :  *  Copyright (C) 2008  Intel Corp
       6                 :            :  *  Copyright (C) 2008  Zhang Rui <rui.zhang@intel.com>
       7                 :            :  *  Copyright (C) 2008  Sujith Thomas <sujith.thomas@intel.com>
       8                 :            :  */
       9                 :            : 
      10                 :            : #ifndef __THERMAL_H__
      11                 :            : #define __THERMAL_H__
      12                 :            : 
      13                 :            : #include <linux/of.h>
      14                 :            : #include <linux/idr.h>
      15                 :            : #include <linux/device.h>
      16                 :            : #include <linux/sysfs.h>
      17                 :            : #include <linux/workqueue.h>
      18                 :            : #include <uapi/linux/thermal.h>
      19                 :            : 
      20                 :            : #define THERMAL_TRIPS_NONE      -1
      21                 :            : #define THERMAL_MAX_TRIPS       12
      22                 :            : 
      23                 :            : /* invalid cooling state */
      24                 :            : #define THERMAL_CSTATE_INVALID -1UL
      25                 :            : 
      26                 :            : /* No upper/lower limit requirement */
      27                 :            : #define THERMAL_NO_LIMIT        ((u32)~0)
      28                 :            : 
      29                 :            : /* Default weight of a bound cooling device */
      30                 :            : #define THERMAL_WEIGHT_DEFAULT 0
      31                 :            : 
      32                 :            : /* use value, which < 0K, to indicate an invalid/uninitialized temperature */
      33                 :            : #define THERMAL_TEMP_INVALID    -274000
      34                 :            : 
      35                 :            : /* Unit conversion macros */
      36                 :            : #define DECI_KELVIN_TO_CELSIUS(t)       ({                      \
      37                 :            :         long _t = (t);                                          \
      38                 :            :         ((_t-2732 >= 0) ? (_t-2732+5)/10 : (_t-2732-5)/10);  \
      39                 :            : })
      40                 :            : #define CELSIUS_TO_DECI_KELVIN(t)       ((t)*10+2732)
      41                 :            : #define DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(t, off) (((t) - (off)) * 100)
      42                 :            : #define DECI_KELVIN_TO_MILLICELSIUS(t) DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(t, 2732)
      43                 :            : #define MILLICELSIUS_TO_DECI_KELVIN_WITH_OFFSET(t, off) (((t) / 100) + (off))
      44                 :            : #define MILLICELSIUS_TO_DECI_KELVIN(t) MILLICELSIUS_TO_DECI_KELVIN_WITH_OFFSET(t, 2732)
      45                 :            : 
      46                 :            : /* Default Thermal Governor */
      47                 :            : #if defined(CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE)
      48                 :            : #define DEFAULT_THERMAL_GOVERNOR       "step_wise"
      49                 :            : #elif defined(CONFIG_THERMAL_DEFAULT_GOV_FAIR_SHARE)
      50                 :            : #define DEFAULT_THERMAL_GOVERNOR       "fair_share"
      51                 :            : #elif defined(CONFIG_THERMAL_DEFAULT_GOV_USER_SPACE)
      52                 :            : #define DEFAULT_THERMAL_GOVERNOR       "user_space"
      53                 :            : #elif defined(CONFIG_THERMAL_DEFAULT_GOV_POWER_ALLOCATOR)
      54                 :            : #define DEFAULT_THERMAL_GOVERNOR       "power_allocator"
      55                 :            : #endif
      56                 :            : 
      57                 :            : struct thermal_zone_device;
      58                 :            : struct thermal_cooling_device;
      59                 :            : struct thermal_instance;
      60                 :            : 
      61                 :            : enum thermal_device_mode {
      62                 :            :         THERMAL_DEVICE_DISABLED = 0,
      63                 :            :         THERMAL_DEVICE_ENABLED,
      64                 :            : };
      65                 :            : 
      66                 :            : enum thermal_trip_type {
      67                 :            :         THERMAL_TRIP_ACTIVE = 0,
      68                 :            :         THERMAL_TRIP_PASSIVE,
      69                 :            :         THERMAL_TRIP_HOT,
      70                 :            :         THERMAL_TRIP_CRITICAL,
      71                 :            : };
      72                 :            : 
      73                 :            : enum thermal_trend {
      74                 :            :         THERMAL_TREND_STABLE, /* temperature is stable */
      75                 :            :         THERMAL_TREND_RAISING, /* temperature is raising */
      76                 :            :         THERMAL_TREND_DROPPING, /* temperature is dropping */
      77                 :            :         THERMAL_TREND_RAISE_FULL, /* apply highest cooling action */
      78                 :            :         THERMAL_TREND_DROP_FULL, /* apply lowest cooling action */
      79                 :            : };
      80                 :            : 
      81                 :            : /* Thermal notification reason */
      82                 :            : enum thermal_notify_event {
      83                 :            :         THERMAL_EVENT_UNSPECIFIED, /* Unspecified event */
      84                 :            :         THERMAL_EVENT_TEMP_SAMPLE, /* New Temperature sample */
      85                 :            :         THERMAL_TRIP_VIOLATED, /* TRIP Point violation */
      86                 :            :         THERMAL_TRIP_CHANGED, /* TRIP Point temperature changed */
      87                 :            :         THERMAL_DEVICE_DOWN, /* Thermal device is down */
      88                 :            :         THERMAL_DEVICE_UP, /* Thermal device is up after a down event */
      89                 :            :         THERMAL_DEVICE_POWER_CAPABILITY_CHANGED, /* power capability changed */
      90                 :            :         THERMAL_TABLE_CHANGED, /* Thermal table(s) changed */
      91                 :            : };
      92                 :            : 
      93                 :            : struct thermal_zone_device_ops {
      94                 :            :         int (*bind) (struct thermal_zone_device *,
      95                 :            :                      struct thermal_cooling_device *);
      96                 :            :         int (*unbind) (struct thermal_zone_device *,
      97                 :            :                        struct thermal_cooling_device *);
      98                 :            :         int (*get_temp) (struct thermal_zone_device *, int *);
      99                 :            :         int (*set_trips) (struct thermal_zone_device *, int, int);
     100                 :            :         int (*get_mode) (struct thermal_zone_device *,
     101                 :            :                          enum thermal_device_mode *);
     102                 :            :         int (*set_mode) (struct thermal_zone_device *,
     103                 :            :                 enum thermal_device_mode);
     104                 :            :         int (*get_trip_type) (struct thermal_zone_device *, int,
     105                 :            :                 enum thermal_trip_type *);
     106                 :            :         int (*get_trip_temp) (struct thermal_zone_device *, int, int *);
     107                 :            :         int (*set_trip_temp) (struct thermal_zone_device *, int, int);
     108                 :            :         int (*get_trip_hyst) (struct thermal_zone_device *, int, int *);
     109                 :            :         int (*set_trip_hyst) (struct thermal_zone_device *, int, int);
     110                 :            :         int (*get_crit_temp) (struct thermal_zone_device *, int *);
     111                 :            :         int (*set_emul_temp) (struct thermal_zone_device *, int);
     112                 :            :         int (*get_trend) (struct thermal_zone_device *, int,
     113                 :            :                           enum thermal_trend *);
     114                 :            :         int (*notify) (struct thermal_zone_device *, int,
     115                 :            :                        enum thermal_trip_type);
     116                 :            : };
     117                 :            : 
     118                 :            : struct thermal_cooling_device_ops {
     119                 :            :         int (*get_max_state) (struct thermal_cooling_device *, unsigned long *);
     120                 :            :         int (*get_cur_state) (struct thermal_cooling_device *, unsigned long *);
     121                 :            :         int (*set_cur_state) (struct thermal_cooling_device *, unsigned long);
     122                 :            :         int (*get_requested_power)(struct thermal_cooling_device *,
     123                 :            :                                    struct thermal_zone_device *, u32 *);
     124                 :            :         int (*state2power)(struct thermal_cooling_device *,
     125                 :            :                            struct thermal_zone_device *, unsigned long, u32 *);
     126                 :            :         int (*power2state)(struct thermal_cooling_device *,
     127                 :            :                            struct thermal_zone_device *, u32, unsigned long *);
     128                 :            : };
     129                 :            : 
     130                 :            : struct thermal_cooling_device {
     131                 :            :         int id;
     132                 :            :         char type[THERMAL_NAME_LENGTH];
     133                 :            :         struct device device;
     134                 :            :         struct device_node *np;
     135                 :            :         void *devdata;
     136                 :            :         void *stats;
     137                 :            :         const struct thermal_cooling_device_ops *ops;
     138                 :            :         bool updated; /* true if the cooling device does not need update */
     139                 :            :         struct mutex lock; /* protect thermal_instances list */
     140                 :            :         struct list_head thermal_instances;
     141                 :            :         struct list_head node;
     142                 :            : };
     143                 :            : 
     144                 :            : struct thermal_attr {
     145                 :            :         struct device_attribute attr;
     146                 :            :         char name[THERMAL_NAME_LENGTH];
     147                 :            : };
     148                 :            : 
     149                 :            : /**
     150                 :            :  * struct thermal_zone_device - structure for a thermal zone
     151                 :            :  * @id:         unique id number for each thermal zone
     152                 :            :  * @type:       the thermal zone device type
     153                 :            :  * @device:     &struct device for this thermal zone
     154                 :            :  * @trip_temp_attrs:    attributes for trip points for sysfs: trip temperature
     155                 :            :  * @trip_type_attrs:    attributes for trip points for sysfs: trip type
     156                 :            :  * @trip_hyst_attrs:    attributes for trip points for sysfs: trip hysteresis
     157                 :            :  * @devdata:    private pointer for device private data
     158                 :            :  * @trips:      number of trip points the thermal zone supports
     159                 :            :  * @trips_disabled;     bitmap for disabled trips
     160                 :            :  * @passive_delay:      number of milliseconds to wait between polls when
     161                 :            :  *                      performing passive cooling.
     162                 :            :  * @polling_delay:      number of milliseconds to wait between polls when
     163                 :            :  *                      checking whether trip points have been crossed (0 for
     164                 :            :  *                      interrupt driven systems)
     165                 :            :  * @temperature:        current temperature.  This is only for core code,
     166                 :            :  *                      drivers should use thermal_zone_get_temp() to get the
     167                 :            :  *                      current temperature
     168                 :            :  * @last_temperature:   previous temperature read
     169                 :            :  * @emul_temperature:   emulated temperature when using CONFIG_THERMAL_EMULATION
     170                 :            :  * @passive:            1 if you've crossed a passive trip point, 0 otherwise.
     171                 :            :  * @prev_low_trip:      the low current temperature if you've crossed a passive
     172                 :            :                         trip point.
     173                 :            :  * @prev_high_trip:     the above current temperature if you've crossed a
     174                 :            :                         passive trip point.
     175                 :            :  * @forced_passive:     If > 0, temperature at which to switch on all ACPI
     176                 :            :  *                      processor cooling devices.  Currently only used by the
     177                 :            :  *                      step-wise governor.
     178                 :            :  * @need_update:        if equals 1, thermal_zone_device_update needs to be invoked.
     179                 :            :  * @ops:        operations this &thermal_zone_device supports
     180                 :            :  * @tzp:        thermal zone parameters
     181                 :            :  * @governor:   pointer to the governor for this thermal zone
     182                 :            :  * @governor_data:      private pointer for governor data
     183                 :            :  * @thermal_instances:  list of &struct thermal_instance of this thermal zone
     184                 :            :  * @ida:        &struct ida to generate unique id for this zone's cooling
     185                 :            :  *              devices
     186                 :            :  * @lock:       lock to protect thermal_instances list
     187                 :            :  * @node:       node in thermal_tz_list (in thermal_core.c)
     188                 :            :  * @poll_queue: delayed work for polling
     189                 :            :  * @notify_event: Last notification event
     190                 :            :  */
     191                 :            : struct thermal_zone_device {
     192                 :            :         int id;
     193                 :            :         char type[THERMAL_NAME_LENGTH];
     194                 :            :         struct device device;
     195                 :            :         struct attribute_group trips_attribute_group;
     196                 :            :         struct thermal_attr *trip_temp_attrs;
     197                 :            :         struct thermal_attr *trip_type_attrs;
     198                 :            :         struct thermal_attr *trip_hyst_attrs;
     199                 :            :         void *devdata;
     200                 :            :         int trips;
     201                 :            :         unsigned long trips_disabled;   /* bitmap for disabled trips */
     202                 :            :         int passive_delay;
     203                 :            :         int polling_delay;
     204                 :            :         int temperature;
     205                 :            :         int last_temperature;
     206                 :            :         int emul_temperature;
     207                 :            :         int passive;
     208                 :            :         int prev_low_trip;
     209                 :            :         int prev_high_trip;
     210                 :            :         unsigned int forced_passive;
     211                 :            :         atomic_t need_update;
     212                 :            :         struct thermal_zone_device_ops *ops;
     213                 :            :         struct thermal_zone_params *tzp;
     214                 :            :         struct thermal_governor *governor;
     215                 :            :         void *governor_data;
     216                 :            :         struct list_head thermal_instances;
     217                 :            :         struct ida ida;
     218                 :            :         struct mutex lock;
     219                 :            :         struct list_head node;
     220                 :            :         struct delayed_work poll_queue;
     221                 :            :         enum thermal_notify_event notify_event;
     222                 :            : };
     223                 :            : 
     224                 :            : /**
     225                 :            :  * struct thermal_governor - structure that holds thermal governor information
     226                 :            :  * @name:       name of the governor
     227                 :            :  * @bind_to_tz: callback called when binding to a thermal zone.  If it
     228                 :            :  *              returns 0, the governor is bound to the thermal zone,
     229                 :            :  *              otherwise it fails.
     230                 :            :  * @unbind_from_tz:     callback called when a governor is unbound from a
     231                 :            :  *                      thermal zone.
     232                 :            :  * @throttle:   callback called for every trip point even if temperature is
     233                 :            :  *              below the trip point temperature
     234                 :            :  * @governor_list:      node in thermal_governor_list (in thermal_core.c)
     235                 :            :  */
     236                 :            : struct thermal_governor {
     237                 :            :         char name[THERMAL_NAME_LENGTH];
     238                 :            :         int (*bind_to_tz)(struct thermal_zone_device *tz);
     239                 :            :         void (*unbind_from_tz)(struct thermal_zone_device *tz);
     240                 :            :         int (*throttle)(struct thermal_zone_device *tz, int trip);
     241                 :            :         struct list_head        governor_list;
     242                 :            : };
     243                 :            : 
     244                 :            : /* Structure that holds binding parameters for a zone */
     245                 :            : struct thermal_bind_params {
     246                 :            :         struct thermal_cooling_device *cdev;
     247                 :            : 
     248                 :            :         /*
     249                 :            :          * This is a measure of 'how effectively these devices can
     250                 :            :          * cool 'this' thermal zone. It shall be determined by
     251                 :            :          * platform characterization. This value is relative to the
     252                 :            :          * rest of the weights so a cooling device whose weight is
     253                 :            :          * double that of another cooling device is twice as
     254                 :            :          * effective. See Documentation/driver-api/thermal/sysfs-api.rst for more
     255                 :            :          * information.
     256                 :            :          */
     257                 :            :         int weight;
     258                 :            : 
     259                 :            :         /*
     260                 :            :          * This is a bit mask that gives the binding relation between this
     261                 :            :          * thermal zone and cdev, for a particular trip point.
     262                 :            :          * See Documentation/driver-api/thermal/sysfs-api.rst for more information.
     263                 :            :          */
     264                 :            :         int trip_mask;
     265                 :            : 
     266                 :            :         /*
     267                 :            :          * This is an array of cooling state limits. Must have exactly
     268                 :            :          * 2 * thermal_zone.number_of_trip_points. It is an array consisting
     269                 :            :          * of tuples <lower-state upper-state> of state limits. Each trip
     270                 :            :          * will be associated with one state limit tuple when binding.
     271                 :            :          * A NULL pointer means <THERMAL_NO_LIMITS THERMAL_NO_LIMITS>
     272                 :            :          * on all trips.
     273                 :            :          */
     274                 :            :         unsigned long *binding_limits;
     275                 :            :         int (*match) (struct thermal_zone_device *tz,
     276                 :            :                         struct thermal_cooling_device *cdev);
     277                 :            : };
     278                 :            : 
     279                 :            : /* Structure to define Thermal Zone parameters */
     280                 :            : struct thermal_zone_params {
     281                 :            :         char governor_name[THERMAL_NAME_LENGTH];
     282                 :            : 
     283                 :            :         /*
     284                 :            :          * a boolean to indicate if the thermal to hwmon sysfs interface
     285                 :            :          * is required. when no_hwmon == false, a hwmon sysfs interface
     286                 :            :          * will be created. when no_hwmon == true, nothing will be done
     287                 :            :          */
     288                 :            :         bool no_hwmon;
     289                 :            : 
     290                 :            :         int num_tbps;   /* Number of tbp entries */
     291                 :            :         struct thermal_bind_params *tbp;
     292                 :            : 
     293                 :            :         /*
     294                 :            :          * Sustainable power (heat) that this thermal zone can dissipate in
     295                 :            :          * mW
     296                 :            :          */
     297                 :            :         u32 sustainable_power;
     298                 :            : 
     299                 :            :         /*
     300                 :            :          * Proportional parameter of the PID controller when
     301                 :            :          * overshooting (i.e., when temperature is below the target)
     302                 :            :          */
     303                 :            :         s32 k_po;
     304                 :            : 
     305                 :            :         /*
     306                 :            :          * Proportional parameter of the PID controller when
     307                 :            :          * undershooting
     308                 :            :          */
     309                 :            :         s32 k_pu;
     310                 :            : 
     311                 :            :         /* Integral parameter of the PID controller */
     312                 :            :         s32 k_i;
     313                 :            : 
     314                 :            :         /* Derivative parameter of the PID controller */
     315                 :            :         s32 k_d;
     316                 :            : 
     317                 :            :         /* threshold below which the error is no longer accumulated */
     318                 :            :         s32 integral_cutoff;
     319                 :            : 
     320                 :            :         /*
     321                 :            :          * @slope:      slope of a linear temperature adjustment curve.
     322                 :            :          *              Used by thermal zone drivers.
     323                 :            :          */
     324                 :            :         int slope;
     325                 :            :         /*
     326                 :            :          * @offset:     offset of a linear temperature adjustment curve.
     327                 :            :          *              Used by thermal zone drivers (default 0).
     328                 :            :          */
     329                 :            :         int offset;
     330                 :            : };
     331                 :            : 
     332                 :            : struct thermal_genl_event {
     333                 :            :         u32 orig;
     334                 :            :         enum events event;
     335                 :            : };
     336                 :            : 
     337                 :            : /**
     338                 :            :  * struct thermal_zone_of_device_ops - scallbacks for handling DT based zones
     339                 :            :  *
     340                 :            :  * Mandatory:
     341                 :            :  * @get_temp: a pointer to a function that reads the sensor temperature.
     342                 :            :  *
     343                 :            :  * Optional:
     344                 :            :  * @get_trend: a pointer to a function that reads the sensor temperature trend.
     345                 :            :  * @set_trips: a pointer to a function that sets a temperature window. When
     346                 :            :  *             this window is left the driver must inform the thermal core via
     347                 :            :  *             thermal_zone_device_update.
     348                 :            :  * @set_emul_temp: a pointer to a function that sets sensor emulated
     349                 :            :  *                 temperature.
     350                 :            :  * @set_trip_temp: a pointer to a function that sets the trip temperature on
     351                 :            :  *                 hardware.
     352                 :            :  */
     353                 :            : struct thermal_zone_of_device_ops {
     354                 :            :         int (*get_temp)(void *, int *);
     355                 :            :         int (*get_trend)(void *, int, enum thermal_trend *);
     356                 :            :         int (*set_trips)(void *, int, int);
     357                 :            :         int (*set_emul_temp)(void *, int);
     358                 :            :         int (*set_trip_temp)(void *, int, int);
     359                 :            : };
     360                 :            : 
     361                 :            : /**
     362                 :            :  * struct thermal_trip - representation of a point in temperature domain
     363                 :            :  * @np: pointer to struct device_node that this trip point was created from
     364                 :            :  * @temperature: temperature value in miliCelsius
     365                 :            :  * @hysteresis: relative hysteresis in miliCelsius
     366                 :            :  * @type: trip point type
     367                 :            :  */
     368                 :            : 
     369                 :            : struct thermal_trip {
     370                 :            :         struct device_node *np;
     371                 :            :         int temperature;
     372                 :            :         int hysteresis;
     373                 :            :         enum thermal_trip_type type;
     374                 :            : };
     375                 :            : 
     376                 :            : /* Function declarations */
     377                 :            : #ifdef CONFIG_THERMAL_OF
     378                 :            : struct thermal_zone_device *
     379                 :            : thermal_zone_of_sensor_register(struct device *dev, int id, void *data,
     380                 :            :                                 const struct thermal_zone_of_device_ops *ops);
     381                 :            : void thermal_zone_of_sensor_unregister(struct device *dev,
     382                 :            :                                        struct thermal_zone_device *tz);
     383                 :            : struct thermal_zone_device *devm_thermal_zone_of_sensor_register(
     384                 :            :                 struct device *dev, int id, void *data,
     385                 :            :                 const struct thermal_zone_of_device_ops *ops);
     386                 :            : void devm_thermal_zone_of_sensor_unregister(struct device *dev,
     387                 :            :                                             struct thermal_zone_device *tz);
     388                 :            : #else
     389                 :            : static inline struct thermal_zone_device *
     390                 :            : thermal_zone_of_sensor_register(struct device *dev, int id, void *data,
     391                 :            :                                 const struct thermal_zone_of_device_ops *ops)
     392                 :            : {
     393                 :            :         return ERR_PTR(-ENODEV);
     394                 :            : }
     395                 :            : 
     396                 :            : static inline
     397                 :            : void thermal_zone_of_sensor_unregister(struct device *dev,
     398                 :            :                                        struct thermal_zone_device *tz)
     399                 :            : {
     400                 :            : }
     401                 :            : 
     402                 :            : static inline struct thermal_zone_device *devm_thermal_zone_of_sensor_register(
     403                 :            :                 struct device *dev, int id, void *data,
     404                 :            :                 const struct thermal_zone_of_device_ops *ops)
     405                 :            : {
     406                 :            :         return ERR_PTR(-ENODEV);
     407                 :            : }
     408                 :            : 
     409                 :            : static inline
     410                 :            : void devm_thermal_zone_of_sensor_unregister(struct device *dev,
     411                 :            :                                             struct thermal_zone_device *tz)
     412                 :            : {
     413                 :            : }
     414                 :            : 
     415                 :            : #endif
     416                 :            : 
     417                 :            : #if IS_ENABLED(CONFIG_THERMAL)
     418                 :            : static inline bool cdev_is_power_actor(struct thermal_cooling_device *cdev)
     419                 :            : {
     420                 :          0 :         return cdev->ops->get_requested_power && cdev->ops->state2power &&
     421                 :          0 :                 cdev->ops->power2state;
     422                 :            : }
     423                 :            : 
     424                 :            : int power_actor_get_max_power(struct thermal_cooling_device *,
     425                 :            :                               struct thermal_zone_device *tz, u32 *max_power);
     426                 :            : int power_actor_get_min_power(struct thermal_cooling_device *,
     427                 :            :                               struct thermal_zone_device *tz, u32 *min_power);
     428                 :            : int power_actor_set_power(struct thermal_cooling_device *,
     429                 :            :                           struct thermal_instance *, u32);
     430                 :            : struct thermal_zone_device *thermal_zone_device_register(const char *, int, int,
     431                 :            :                 void *, struct thermal_zone_device_ops *,
     432                 :            :                 struct thermal_zone_params *, int, int);
     433                 :            : void thermal_zone_device_unregister(struct thermal_zone_device *);
     434                 :            : 
     435                 :            : int thermal_zone_bind_cooling_device(struct thermal_zone_device *, int,
     436                 :            :                                      struct thermal_cooling_device *,
     437                 :            :                                      unsigned long, unsigned long,
     438                 :            :                                      unsigned int);
     439                 :            : int thermal_zone_unbind_cooling_device(struct thermal_zone_device *, int,
     440                 :            :                                        struct thermal_cooling_device *);
     441                 :            : void thermal_zone_device_update(struct thermal_zone_device *,
     442                 :            :                                 enum thermal_notify_event);
     443                 :            : void thermal_zone_set_trips(struct thermal_zone_device *);
     444                 :            : 
     445                 :            : struct thermal_cooling_device *thermal_cooling_device_register(const char *,
     446                 :            :                 void *, const struct thermal_cooling_device_ops *);
     447                 :            : struct thermal_cooling_device *
     448                 :            : thermal_of_cooling_device_register(struct device_node *np, const char *, void *,
     449                 :            :                                    const struct thermal_cooling_device_ops *);
     450                 :            : struct thermal_cooling_device *
     451                 :            : devm_thermal_of_cooling_device_register(struct device *dev,
     452                 :            :                                 struct device_node *np,
     453                 :            :                                 char *type, void *devdata,
     454                 :            :                                 const struct thermal_cooling_device_ops *ops);
     455                 :            : void thermal_cooling_device_unregister(struct thermal_cooling_device *);
     456                 :            : struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name);
     457                 :            : int thermal_zone_get_temp(struct thermal_zone_device *tz, int *temp);
     458                 :            : int thermal_zone_get_slope(struct thermal_zone_device *tz);
     459                 :            : int thermal_zone_get_offset(struct thermal_zone_device *tz);
     460                 :            : 
     461                 :            : int get_tz_trend(struct thermal_zone_device *, int);
     462                 :            : struct thermal_instance *get_thermal_instance(struct thermal_zone_device *,
     463                 :            :                 struct thermal_cooling_device *, int);
     464                 :            : void thermal_cdev_update(struct thermal_cooling_device *);
     465                 :            : void thermal_notify_framework(struct thermal_zone_device *, int);
     466                 :            : #else
     467                 :            : static inline bool cdev_is_power_actor(struct thermal_cooling_device *cdev)
     468                 :            : { return false; }
     469                 :            : static inline int power_actor_get_max_power(struct thermal_cooling_device *cdev,
     470                 :            :                               struct thermal_zone_device *tz, u32 *max_power)
     471                 :            : { return 0; }
     472                 :            : static inline int power_actor_get_min_power(struct thermal_cooling_device *cdev,
     473                 :            :                                             struct thermal_zone_device *tz,
     474                 :            :                                             u32 *min_power)
     475                 :            : { return -ENODEV; }
     476                 :            : static inline int power_actor_set_power(struct thermal_cooling_device *cdev,
     477                 :            :                           struct thermal_instance *tz, u32 power)
     478                 :            : { return 0; }
     479                 :            : static inline struct thermal_zone_device *thermal_zone_device_register(
     480                 :            :         const char *type, int trips, int mask, void *devdata,
     481                 :            :         struct thermal_zone_device_ops *ops,
     482                 :            :         struct thermal_zone_params *tzp,
     483                 :            :         int passive_delay, int polling_delay)
     484                 :            : { return ERR_PTR(-ENODEV); }
     485                 :            : static inline void thermal_zone_device_unregister(
     486                 :            :         struct thermal_zone_device *tz)
     487                 :            : { }
     488                 :            : static inline int thermal_zone_bind_cooling_device(
     489                 :            :         struct thermal_zone_device *tz, int trip,
     490                 :            :         struct thermal_cooling_device *cdev,
     491                 :            :         unsigned long upper, unsigned long lower,
     492                 :            :         unsigned int weight)
     493                 :            : { return -ENODEV; }
     494                 :            : static inline int thermal_zone_unbind_cooling_device(
     495                 :            :         struct thermal_zone_device *tz, int trip,
     496                 :            :         struct thermal_cooling_device *cdev)
     497                 :            : { return -ENODEV; }
     498                 :            : static inline void thermal_zone_device_update(struct thermal_zone_device *tz,
     499                 :            :                                               enum thermal_notify_event event)
     500                 :            : { }
     501                 :            : static inline void thermal_zone_set_trips(struct thermal_zone_device *tz)
     502                 :            : { }
     503                 :            : static inline struct thermal_cooling_device *
     504                 :            : thermal_cooling_device_register(char *type, void *devdata,
     505                 :            :         const struct thermal_cooling_device_ops *ops)
     506                 :            : { return ERR_PTR(-ENODEV); }
     507                 :            : static inline struct thermal_cooling_device *
     508                 :            : thermal_of_cooling_device_register(struct device_node *np,
     509                 :            :         char *type, void *devdata, const struct thermal_cooling_device_ops *ops)
     510                 :            : { return ERR_PTR(-ENODEV); }
     511                 :            : static inline struct thermal_cooling_device *
     512                 :            : devm_thermal_of_cooling_device_register(struct device *dev,
     513                 :            :                                 struct device_node *np,
     514                 :            :                                 char *type, void *devdata,
     515                 :            :                                 const struct thermal_cooling_device_ops *ops)
     516                 :            : {
     517                 :            :         return ERR_PTR(-ENODEV);
     518                 :            : }
     519                 :            : static inline void thermal_cooling_device_unregister(
     520                 :            :         struct thermal_cooling_device *cdev)
     521                 :            : { }
     522                 :            : static inline struct thermal_zone_device *thermal_zone_get_zone_by_name(
     523                 :            :                 const char *name)
     524                 :            : { return ERR_PTR(-ENODEV); }
     525                 :            : static inline int thermal_zone_get_temp(
     526                 :            :                 struct thermal_zone_device *tz, int *temp)
     527                 :            : { return -ENODEV; }
     528                 :            : static inline int thermal_zone_get_slope(
     529                 :            :                 struct thermal_zone_device *tz)
     530                 :            : { return -ENODEV; }
     531                 :            : static inline int thermal_zone_get_offset(
     532                 :            :                 struct thermal_zone_device *tz)
     533                 :            : { return -ENODEV; }
     534                 :            : static inline int get_tz_trend(struct thermal_zone_device *tz, int trip)
     535                 :            : { return -ENODEV; }
     536                 :            : static inline struct thermal_instance *
     537                 :            : get_thermal_instance(struct thermal_zone_device *tz,
     538                 :            :         struct thermal_cooling_device *cdev, int trip)
     539                 :            : { return ERR_PTR(-ENODEV); }
     540                 :            : static inline void thermal_cdev_update(struct thermal_cooling_device *cdev)
     541                 :            : { }
     542                 :            : static inline void thermal_notify_framework(struct thermal_zone_device *tz,
     543                 :            :         int trip)
     544                 :            : { }
     545                 :            : #endif /* CONFIG_THERMAL */
     546                 :            : 
     547                 :            : #if defined(CONFIG_NET) && IS_ENABLED(CONFIG_THERMAL)
     548                 :            : extern int thermal_generate_netlink_event(struct thermal_zone_device *tz,
     549                 :            :                                                 enum events event);
     550                 :            : #else
     551                 :            : static inline int thermal_generate_netlink_event(struct thermal_zone_device *tz,
     552                 :            :                                                 enum events event)
     553                 :            : {
     554                 :            :         return 0;
     555                 :            : }
     556                 :            : #endif
     557                 :            : 
     558                 :            : #endif /* __THERMAL_H__ */
    

Generated by: LCOV version 1.14