1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/device.h>
25#include <linux/err.h>
26#include <linux/mutex.h>
27#include <linux/gfp.h>
28#include <linux/kernel.h>
29#include <linux/workqueue.h>
30#include <linux/thermal.h>
31#include <linux/cpumask.h>
32#include <linux/cpu_cooling.h>
33#include <linux/of.h>
34
35#include "ti-thermal.h"
36#include "ti-bandgap.h"
37
38
39struct ti_thermal_data {
40 struct thermal_zone_device *ti_thermal;
41 struct thermal_zone_device *pcb_tz;
42 struct thermal_cooling_device *cool_dev;
43 struct ti_bandgap *bgp;
44 enum thermal_device_mode mode;
45 struct work_struct thermal_wq;
46 int sensor_id;
47 bool our_zone;
48};
49
50static void ti_thermal_work(struct work_struct *work)
51{
52 struct ti_thermal_data *data = container_of(work,
53 struct ti_thermal_data, thermal_wq);
54
55 thermal_zone_device_update(data->ti_thermal, THERMAL_EVENT_UNSPECIFIED);
56
57 dev_dbg(&data->ti_thermal->device, "updated thermal zone %s\n",
58 data->ti_thermal->type);
59}
60
61
62
63
64
65
66
67static inline int ti_thermal_hotspot_temperature(int t, int s, int c)
68{
69 int delta = t * s / 1000 + c;
70
71 if (delta < 0)
72 delta = 0;
73
74 return t + delta;
75}
76
77
78
79static inline int __ti_thermal_get_temp(void *devdata, int *temp)
80{
81 struct thermal_zone_device *pcb_tz = NULL;
82 struct ti_thermal_data *data = devdata;
83 struct ti_bandgap *bgp;
84 const struct ti_temp_sensor *s;
85 int ret, tmp, slope, constant;
86 int pcb_temp;
87
88 if (!data)
89 return 0;
90
91 bgp = data->bgp;
92 s = &bgp->conf->sensors[data->sensor_id];
93
94 ret = ti_bandgap_read_temperature(bgp, data->sensor_id, &tmp);
95 if (ret)
96 return ret;
97
98
99 slope = s->slope;
100 constant = s->constant;
101
102 pcb_tz = data->pcb_tz;
103
104 if (!IS_ERR(pcb_tz)) {
105 ret = thermal_zone_get_temp(pcb_tz, &pcb_temp);
106 if (!ret) {
107 tmp -= pcb_temp;
108 slope = s->slope_pcb;
109 constant = s->constant_pcb;
110 } else {
111 dev_err(bgp->dev,
112 "Failed to read PCB state. Using defaults\n");
113 ret = 0;
114 }
115 }
116 *temp = ti_thermal_hotspot_temperature(tmp, slope, constant);
117
118 return ret;
119}
120
121static inline int ti_thermal_get_temp(struct thermal_zone_device *thermal,
122 int *temp)
123{
124 struct ti_thermal_data *data = thermal->devdata;
125
126 return __ti_thermal_get_temp(data, temp);
127}
128
129
130static int ti_thermal_bind(struct thermal_zone_device *thermal,
131 struct thermal_cooling_device *cdev)
132{
133 struct ti_thermal_data *data = thermal->devdata;
134 int id;
135
136 if (!data || IS_ERR(data))
137 return -ENODEV;
138
139
140 if (data->cool_dev != cdev)
141 return 0;
142
143 id = data->sensor_id;
144
145
146 return thermal_zone_bind_cooling_device(thermal, 0, cdev,
147
148 THERMAL_NO_LIMIT,
149 THERMAL_NO_LIMIT,
150 THERMAL_WEIGHT_DEFAULT);
151}
152
153
154static int ti_thermal_unbind(struct thermal_zone_device *thermal,
155 struct thermal_cooling_device *cdev)
156{
157 struct ti_thermal_data *data = thermal->devdata;
158
159 if (!data || IS_ERR(data))
160 return -ENODEV;
161
162
163 if (data->cool_dev != cdev)
164 return 0;
165
166
167 return thermal_zone_unbind_cooling_device(thermal, 0, cdev);
168}
169
170
171static int ti_thermal_get_mode(struct thermal_zone_device *thermal,
172 enum thermal_device_mode *mode)
173{
174 struct ti_thermal_data *data = thermal->devdata;
175
176 if (data)
177 *mode = data->mode;
178
179 return 0;
180}
181
182
183static int ti_thermal_set_mode(struct thermal_zone_device *thermal,
184 enum thermal_device_mode mode)
185{
186 struct ti_thermal_data *data = thermal->devdata;
187 struct ti_bandgap *bgp;
188
189 bgp = data->bgp;
190
191 if (!data->ti_thermal) {
192 dev_notice(&thermal->device, "thermal zone not registered\n");
193 return 0;
194 }
195
196 mutex_lock(&data->ti_thermal->lock);
197
198 if (mode == THERMAL_DEVICE_ENABLED)
199 data->ti_thermal->polling_delay = FAST_TEMP_MONITORING_RATE;
200 else
201 data->ti_thermal->polling_delay = 0;
202
203 mutex_unlock(&data->ti_thermal->lock);
204
205 data->mode = mode;
206 ti_bandgap_write_update_interval(bgp, data->sensor_id,
207 data->ti_thermal->polling_delay);
208 thermal_zone_device_update(data->ti_thermal, THERMAL_EVENT_UNSPECIFIED);
209 dev_dbg(&thermal->device, "thermal polling set for duration=%d msec\n",
210 data->ti_thermal->polling_delay);
211
212 return 0;
213}
214
215
216static int ti_thermal_get_trip_type(struct thermal_zone_device *thermal,
217 int trip, enum thermal_trip_type *type)
218{
219 if (!ti_thermal_is_valid_trip(trip))
220 return -EINVAL;
221
222 if (trip + 1 == OMAP_TRIP_NUMBER)
223 *type = THERMAL_TRIP_CRITICAL;
224 else
225 *type = THERMAL_TRIP_PASSIVE;
226
227 return 0;
228}
229
230
231static int ti_thermal_get_trip_temp(struct thermal_zone_device *thermal,
232 int trip, int *temp)
233{
234 if (!ti_thermal_is_valid_trip(trip))
235 return -EINVAL;
236
237 *temp = ti_thermal_get_trip_value(trip);
238
239 return 0;
240}
241
242static int __ti_thermal_get_trend(void *p, int trip, enum thermal_trend *trend)
243{
244 struct ti_thermal_data *data = p;
245 struct ti_bandgap *bgp;
246 int id, tr, ret = 0;
247
248 bgp = data->bgp;
249 id = data->sensor_id;
250
251 ret = ti_bandgap_get_trend(bgp, id, &tr);
252 if (ret)
253 return ret;
254
255 if (tr > 0)
256 *trend = THERMAL_TREND_RAISING;
257 else if (tr < 0)
258 *trend = THERMAL_TREND_DROPPING;
259 else
260 *trend = THERMAL_TREND_STABLE;
261
262 return 0;
263}
264
265
266static int ti_thermal_get_trend(struct thermal_zone_device *thermal,
267 int trip, enum thermal_trend *trend)
268{
269 return __ti_thermal_get_trend(thermal->devdata, trip, trend);
270}
271
272
273static int ti_thermal_get_crit_temp(struct thermal_zone_device *thermal,
274 int *temp)
275{
276
277 return ti_thermal_get_trip_temp(thermal, OMAP_TRIP_NUMBER - 1, temp);
278}
279
280static const struct thermal_zone_of_device_ops ti_of_thermal_ops = {
281 .get_temp = __ti_thermal_get_temp,
282 .get_trend = __ti_thermal_get_trend,
283};
284
285static struct thermal_zone_device_ops ti_thermal_ops = {
286 .get_temp = ti_thermal_get_temp,
287 .get_trend = ti_thermal_get_trend,
288 .bind = ti_thermal_bind,
289 .unbind = ti_thermal_unbind,
290 .get_mode = ti_thermal_get_mode,
291 .set_mode = ti_thermal_set_mode,
292 .get_trip_type = ti_thermal_get_trip_type,
293 .get_trip_temp = ti_thermal_get_trip_temp,
294 .get_crit_temp = ti_thermal_get_crit_temp,
295};
296
297static struct ti_thermal_data
298*ti_thermal_build_data(struct ti_bandgap *bgp, int id)
299{
300 struct ti_thermal_data *data;
301
302 data = devm_kzalloc(bgp->dev, sizeof(*data), GFP_KERNEL);
303 if (!data) {
304 dev_err(bgp->dev, "kzalloc fail\n");
305 return NULL;
306 }
307 data->sensor_id = id;
308 data->bgp = bgp;
309 data->mode = THERMAL_DEVICE_ENABLED;
310
311 data->pcb_tz = thermal_zone_get_zone_by_name("pcb");
312 INIT_WORK(&data->thermal_wq, ti_thermal_work);
313
314 return data;
315}
316
317int ti_thermal_expose_sensor(struct ti_bandgap *bgp, int id,
318 char *domain)
319{
320 struct ti_thermal_data *data;
321
322 data = ti_bandgap_get_sensor_data(bgp, id);
323
324 if (!data || IS_ERR(data))
325 data = ti_thermal_build_data(bgp, id);
326
327 if (!data)
328 return -EINVAL;
329
330
331 data->ti_thermal = devm_thermal_zone_of_sensor_register(bgp->dev, id,
332 data, &ti_of_thermal_ops);
333 if (IS_ERR(data->ti_thermal)) {
334
335 data->ti_thermal = thermal_zone_device_register(domain,
336 OMAP_TRIP_NUMBER, 0, data, &ti_thermal_ops,
337 NULL, FAST_TEMP_MONITORING_RATE,
338 FAST_TEMP_MONITORING_RATE);
339 if (IS_ERR(data->ti_thermal)) {
340 dev_err(bgp->dev, "thermal zone device is NULL\n");
341 return PTR_ERR(data->ti_thermal);
342 }
343 data->ti_thermal->polling_delay = FAST_TEMP_MONITORING_RATE;
344 data->our_zone = true;
345 }
346 ti_bandgap_set_sensor_data(bgp, id, data);
347 ti_bandgap_write_update_interval(bgp, data->sensor_id,
348 data->ti_thermal->polling_delay);
349
350 return 0;
351}
352
353int ti_thermal_remove_sensor(struct ti_bandgap *bgp, int id)
354{
355 struct ti_thermal_data *data;
356
357 data = ti_bandgap_get_sensor_data(bgp, id);
358
359 if (data && data->ti_thermal) {
360 if (data->our_zone)
361 thermal_zone_device_unregister(data->ti_thermal);
362 }
363
364 return 0;
365}
366
367int ti_thermal_report_sensor_temperature(struct ti_bandgap *bgp, int id)
368{
369 struct ti_thermal_data *data;
370
371 data = ti_bandgap_get_sensor_data(bgp, id);
372
373 schedule_work(&data->thermal_wq);
374
375 return 0;
376}
377
378int ti_thermal_register_cpu_cooling(struct ti_bandgap *bgp, int id)
379{
380 struct ti_thermal_data *data;
381 struct device_node *np = bgp->dev->of_node;
382
383
384
385
386
387
388 if (of_find_property(np, "#thermal-sensor-cells", NULL))
389 return 0;
390
391 data = ti_bandgap_get_sensor_data(bgp, id);
392 if (!data || IS_ERR(data))
393 data = ti_thermal_build_data(bgp, id);
394
395 if (!data)
396 return -EINVAL;
397
398
399 data->cool_dev = cpufreq_cooling_register(cpu_present_mask);
400 if (IS_ERR(data->cool_dev)) {
401 int ret = PTR_ERR(data->cool_dev);
402
403 if (ret != -EPROBE_DEFER)
404 dev_err(bgp->dev,
405 "Failed to register cpu cooling device %d\n",
406 ret);
407
408 return ret;
409 }
410 ti_bandgap_set_sensor_data(bgp, id, data);
411
412 return 0;
413}
414
415int ti_thermal_unregister_cpu_cooling(struct ti_bandgap *bgp, int id)
416{
417 struct ti_thermal_data *data;
418
419 data = ti_bandgap_get_sensor_data(bgp, id);
420
421 if (data)
422 cpufreq_cooling_unregister(data->cool_dev);
423
424 return 0;
425}
426