1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * thermal_helpers.c - helper functions to handle thermal devices |
4 | * |
5 | * Copyright (C) 2016 Eduardo Valentin <edubezval@gmail.com> |
6 | * |
7 | * Highly based on original thermal_core.c |
8 | * Copyright (C) 2008 Intel Corp |
9 | * Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com> |
10 | * Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com> |
11 | */ |
12 | |
13 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
14 | |
15 | #include <linux/device.h> |
16 | #include <linux/err.h> |
17 | #include <linux/export.h> |
18 | #include <linux/slab.h> |
19 | #include <linux/string.h> |
20 | #include <linux/sysfs.h> |
21 | |
22 | #include "thermal_core.h" |
23 | #include "thermal_trace.h" |
24 | |
25 | int get_tz_trend(struct thermal_zone_device *tz, const struct thermal_trip *trip) |
26 | { |
27 | enum thermal_trend trend; |
28 | |
29 | if (tz->emul_temperature || !tz->ops->get_trend || |
30 | tz->ops->get_trend(tz, trip, &trend)) { |
31 | if (tz->temperature > tz->last_temperature) |
32 | trend = THERMAL_TREND_RAISING; |
33 | else if (tz->temperature < tz->last_temperature) |
34 | trend = THERMAL_TREND_DROPPING; |
35 | else |
36 | trend = THERMAL_TREND_STABLE; |
37 | } |
38 | |
39 | return trend; |
40 | } |
41 | |
42 | struct thermal_instance * |
43 | get_thermal_instance(struct thermal_zone_device *tz, |
44 | struct thermal_cooling_device *cdev, int trip_index) |
45 | { |
46 | struct thermal_instance *pos = NULL; |
47 | struct thermal_instance *target_instance = NULL; |
48 | const struct thermal_trip *trip; |
49 | |
50 | mutex_lock(&tz->lock); |
51 | mutex_lock(&cdev->lock); |
52 | |
53 | trip = &tz->trips[trip_index]; |
54 | |
55 | list_for_each_entry(pos, &tz->thermal_instances, tz_node) { |
56 | if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) { |
57 | target_instance = pos; |
58 | break; |
59 | } |
60 | } |
61 | |
62 | mutex_unlock(lock: &cdev->lock); |
63 | mutex_unlock(lock: &tz->lock); |
64 | |
65 | return target_instance; |
66 | } |
67 | EXPORT_SYMBOL(get_thermal_instance); |
68 | |
69 | /** |
70 | * __thermal_zone_get_temp() - returns the temperature of a thermal zone |
71 | * @tz: a valid pointer to a struct thermal_zone_device |
72 | * @temp: a valid pointer to where to store the resulting temperature. |
73 | * |
74 | * When a valid thermal zone reference is passed, it will fetch its |
75 | * temperature and fill @temp. |
76 | * |
77 | * Both tz and tz->ops must be valid pointers when calling this function, |
78 | * and the tz->ops->get_temp callback must be provided. |
79 | * The function must be called under tz->lock. |
80 | * |
81 | * Return: On success returns 0, an error code otherwise |
82 | */ |
83 | int __thermal_zone_get_temp(struct thermal_zone_device *tz, int *temp) |
84 | { |
85 | int ret = -EINVAL; |
86 | int count; |
87 | int crit_temp = INT_MAX; |
88 | struct thermal_trip trip; |
89 | |
90 | lockdep_assert_held(&tz->lock); |
91 | |
92 | ret = tz->ops->get_temp(tz, temp); |
93 | |
94 | if (IS_ENABLED(CONFIG_THERMAL_EMULATION) && tz->emul_temperature) { |
95 | for (count = 0; count < tz->num_trips; count++) { |
96 | ret = __thermal_zone_get_trip(tz, trip_id: count, trip: &trip); |
97 | if (!ret && trip.type == THERMAL_TRIP_CRITICAL) { |
98 | crit_temp = trip.temperature; |
99 | break; |
100 | } |
101 | } |
102 | |
103 | /* |
104 | * Only allow emulating a temperature when the real temperature |
105 | * is below the critical temperature so that the emulation code |
106 | * cannot hide critical conditions. |
107 | */ |
108 | if (!ret && *temp < crit_temp) |
109 | *temp = tz->emul_temperature; |
110 | } |
111 | |
112 | if (ret) |
113 | dev_dbg(&tz->device, "Failed to get temperature: %d\n" , ret); |
114 | |
115 | return ret; |
116 | } |
117 | |
118 | /** |
119 | * thermal_zone_get_temp() - returns the temperature of a thermal zone |
120 | * @tz: a valid pointer to a struct thermal_zone_device |
121 | * @temp: a valid pointer to where to store the resulting temperature. |
122 | * |
123 | * When a valid thermal zone reference is passed, it will fetch its |
124 | * temperature and fill @temp. |
125 | * |
126 | * Return: On success returns 0, an error code otherwise |
127 | */ |
128 | int thermal_zone_get_temp(struct thermal_zone_device *tz, int *temp) |
129 | { |
130 | int ret; |
131 | |
132 | if (IS_ERR_OR_NULL(ptr: tz)) |
133 | return -EINVAL; |
134 | |
135 | mutex_lock(&tz->lock); |
136 | |
137 | if (!tz->ops->get_temp) { |
138 | ret = -EINVAL; |
139 | goto unlock; |
140 | } |
141 | |
142 | if (device_is_registered(dev: &tz->device)) |
143 | ret = __thermal_zone_get_temp(tz, temp); |
144 | else |
145 | ret = -ENODEV; |
146 | |
147 | unlock: |
148 | mutex_unlock(lock: &tz->lock); |
149 | |
150 | return ret; |
151 | } |
152 | EXPORT_SYMBOL_GPL(thermal_zone_get_temp); |
153 | |
154 | static void thermal_cdev_set_cur_state(struct thermal_cooling_device *cdev, |
155 | int target) |
156 | { |
157 | if (cdev->ops->set_cur_state(cdev, target)) |
158 | return; |
159 | |
160 | thermal_notify_cdev_state_update(cdev_id: cdev->id, state: target); |
161 | thermal_cooling_device_stats_update(cdev, new_state: target); |
162 | } |
163 | |
164 | void __thermal_cdev_update(struct thermal_cooling_device *cdev) |
165 | { |
166 | struct thermal_instance *instance; |
167 | unsigned long target = 0; |
168 | |
169 | /* Make sure cdev enters the deepest cooling state */ |
170 | list_for_each_entry(instance, &cdev->thermal_instances, cdev_node) { |
171 | dev_dbg(&cdev->device, "zone%d->target=%lu\n" , |
172 | instance->tz->id, instance->target); |
173 | if (instance->target == THERMAL_NO_TARGET) |
174 | continue; |
175 | if (instance->target > target) |
176 | target = instance->target; |
177 | } |
178 | |
179 | thermal_cdev_set_cur_state(cdev, target); |
180 | |
181 | trace_cdev_update(cdev, target); |
182 | dev_dbg(&cdev->device, "set to state %lu\n" , target); |
183 | } |
184 | |
185 | /** |
186 | * thermal_cdev_update - update cooling device state if needed |
187 | * @cdev: pointer to struct thermal_cooling_device |
188 | * |
189 | * Update the cooling device state if there is a need. |
190 | */ |
191 | void thermal_cdev_update(struct thermal_cooling_device *cdev) |
192 | { |
193 | mutex_lock(&cdev->lock); |
194 | if (!cdev->updated) { |
195 | __thermal_cdev_update(cdev); |
196 | cdev->updated = true; |
197 | } |
198 | mutex_unlock(lock: &cdev->lock); |
199 | } |
200 | |
201 | /** |
202 | * thermal_zone_get_slope - return the slope attribute of the thermal zone |
203 | * @tz: thermal zone device with the slope attribute |
204 | * |
205 | * Return: If the thermal zone device has a slope attribute, return it, else |
206 | * return 1. |
207 | */ |
208 | int thermal_zone_get_slope(struct thermal_zone_device *tz) |
209 | { |
210 | if (tz && tz->tzp) |
211 | return tz->tzp->slope; |
212 | return 1; |
213 | } |
214 | EXPORT_SYMBOL_GPL(thermal_zone_get_slope); |
215 | |
216 | /** |
217 | * thermal_zone_get_offset - return the offset attribute of the thermal zone |
218 | * @tz: thermal zone device with the offset attribute |
219 | * |
220 | * Return: If the thermal zone device has a offset attribute, return it, else |
221 | * return 0. |
222 | */ |
223 | int thermal_zone_get_offset(struct thermal_zone_device *tz) |
224 | { |
225 | if (tz && tz->tzp) |
226 | return tz->tzp->offset; |
227 | return 0; |
228 | } |
229 | EXPORT_SYMBOL_GPL(thermal_zone_get_offset); |
230 | |