Root/drivers/staging/omap-thermal/omap-thermal-common.c

1/*
2 * OMAP thermal driver interface
3 *
4 * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/
5 * Contact:
6 * Eduardo Valentin <eduardo.valentin@ti.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
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/cpufreq.h>
32#include <linux/cpu_cooling.h>
33
34#include "omap-thermal.h"
35#include "omap-bandgap.h"
36
37/* common data structures */
38struct omap_thermal_data {
39    struct thermal_zone_device *omap_thermal;
40    struct thermal_cooling_device *cool_dev;
41    struct omap_bandgap *bg_ptr;
42    enum thermal_device_mode mode;
43    struct work_struct thermal_wq;
44    int sensor_id;
45};
46
47static void omap_thermal_work(struct work_struct *work)
48{
49    struct omap_thermal_data *data = container_of(work,
50                    struct omap_thermal_data, thermal_wq);
51
52    thermal_zone_device_update(data->omap_thermal);
53
54    dev_dbg(&data->omap_thermal->device, "updated thermal zone %s\n",
55        data->omap_thermal->type);
56}
57
58/**
59 * omap_thermal_hotspot_temperature - returns sensor extrapolated temperature
60 * @t: omap sensor temperature
61 * @s: omap sensor slope value
62 * @c: omap sensor const value
63 */
64static inline int omap_thermal_hotspot_temperature(int t, int s, int c)
65{
66    int delta = t * s / 1000 + c;
67
68    if (delta < 0)
69        delta = 0;
70
71    return t + delta;
72}
73
74/* thermal zone ops */
75/* Get temperature callback function for thermal zone*/
76static inline int omap_thermal_get_temp(struct thermal_zone_device *thermal,
77                     unsigned long *temp)
78{
79    struct omap_thermal_data *data = thermal->devdata;
80    struct omap_bandgap *bg_ptr = data->bg_ptr;
81    struct omap_temp_sensor *s = &bg_ptr->conf->sensors[data->sensor_id];
82    int ret, tmp, pcb_temp, slope, constant;
83
84    ret = omap_bandgap_read_temperature(bg_ptr, data->sensor_id, &tmp);
85    if (ret)
86        return ret;
87
88    pcb_temp = 0;
89    /* TODO: Introduce pcb temperature lookup */
90    /* In case pcb zone is available, use the extrapolation rule with it */
91    if (pcb_temp) {
92        tmp -= pcb_temp;
93        slope = s->slope_pcb;
94        constant = s->constant_pcb;
95    } else {
96        slope = s->slope;
97        constant = s->constant;
98    }
99    *temp = omap_thermal_hotspot_temperature(tmp, slope, constant);
100
101    return ret;
102}
103
104/* Bind callback functions for thermal zone */
105static int omap_thermal_bind(struct thermal_zone_device *thermal,
106                  struct thermal_cooling_device *cdev)
107{
108    struct omap_thermal_data *data = thermal->devdata;
109    int max, id;
110
111    if (IS_ERR_OR_NULL(data))
112        return -ENODEV;
113
114    /* check if this is the cooling device we registered */
115    if (data->cool_dev != cdev)
116        return 0;
117
118    id = data->sensor_id;
119    max = data->bg_ptr->conf->sensors[id].cooling_data.freq_clip_count;
120
121    /* TODO: bind with min and max states */
122    /* Simple thing, two trips, one passive another critical */
123    return thermal_zone_bind_cooling_device(thermal, 0, cdev);
124}
125
126/* Unbind callback functions for thermal zone */
127static int omap_thermal_unbind(struct thermal_zone_device *thermal,
128                struct thermal_cooling_device *cdev)
129{
130    struct omap_thermal_data *data = thermal->devdata;
131
132    if (IS_ERR_OR_NULL(data))
133        return -ENODEV;
134
135    /* check if this is the cooling device we registered */
136    if (data->cool_dev != cdev)
137        return 0;
138
139    /* Simple thing, two trips, one passive another critical */
140    return thermal_zone_unbind_cooling_device(thermal, 0, cdev);
141}
142
143/* Get mode callback functions for thermal zone */
144static int omap_thermal_get_mode(struct thermal_zone_device *thermal,
145                  enum thermal_device_mode *mode)
146{
147    struct omap_thermal_data *data = thermal->devdata;
148
149    if (data)
150        *mode = data->mode;
151
152    return 0;
153}
154
155/* Set mode callback functions for thermal zone */
156static int omap_thermal_set_mode(struct thermal_zone_device *thermal,
157                  enum thermal_device_mode mode)
158{
159    struct omap_thermal_data *data = thermal->devdata;
160
161    if (!data->omap_thermal) {
162        dev_notice(&thermal->device, "thermal zone not registered\n");
163        return 0;
164    }
165
166    mutex_lock(&data->omap_thermal->lock);
167
168    if (mode == THERMAL_DEVICE_ENABLED)
169        data->omap_thermal->polling_delay = FAST_TEMP_MONITORING_RATE;
170    else
171        data->omap_thermal->polling_delay = 0;
172
173    mutex_unlock(&data->omap_thermal->lock);
174
175    data->mode = mode;
176    thermal_zone_device_update(data->omap_thermal);
177    dev_dbg(&thermal->device, "thermal polling set for duration=%d msec\n",
178        data->omap_thermal->polling_delay);
179
180    return 0;
181}
182
183/* Get trip type callback functions for thermal zone */
184static int omap_thermal_get_trip_type(struct thermal_zone_device *thermal,
185                       int trip, enum thermal_trip_type *type)
186{
187    if (!omap_thermal_is_valid_trip(trip))
188        return -EINVAL;
189
190    if (trip + 1 == OMAP_TRIP_NUMBER)
191        *type = THERMAL_TRIP_CRITICAL;
192    else
193        *type = THERMAL_TRIP_PASSIVE;
194
195    return 0;
196}
197
198/* Get trip temperature callback functions for thermal zone */
199static int omap_thermal_get_trip_temp(struct thermal_zone_device *thermal,
200                       int trip, unsigned long *temp)
201{
202    if (!omap_thermal_is_valid_trip(trip))
203        return -EINVAL;
204
205    *temp = omap_thermal_get_trip_value(trip);
206
207    return 0;
208}
209
210/* Get critical temperature callback functions for thermal zone */
211static int omap_thermal_get_crit_temp(struct thermal_zone_device *thermal,
212                       unsigned long *temp)
213{
214    /* shutdown zone */
215    return omap_thermal_get_trip_temp(thermal, OMAP_TRIP_NUMBER - 1, temp);
216}
217
218static struct thermal_zone_device_ops omap_thermal_ops = {
219    .get_temp = omap_thermal_get_temp,
220    /* TODO: add .get_trend */
221    .bind = omap_thermal_bind,
222    .unbind = omap_thermal_unbind,
223    .get_mode = omap_thermal_get_mode,
224    .set_mode = omap_thermal_set_mode,
225    .get_trip_type = omap_thermal_get_trip_type,
226    .get_trip_temp = omap_thermal_get_trip_temp,
227    .get_crit_temp = omap_thermal_get_crit_temp,
228};
229
230int omap_thermal_expose_sensor(struct omap_bandgap *bg_ptr, int id,
231                   char *domain)
232{
233    struct omap_thermal_data *data;
234
235    data = devm_kzalloc(bg_ptr->dev, sizeof(*data), GFP_KERNEL);
236    if (!data) {
237        dev_err(bg_ptr->dev, "kzalloc fail\n");
238        return -ENOMEM;
239    }
240    data->sensor_id = id;
241    data->bg_ptr = bg_ptr;
242    data->mode = THERMAL_DEVICE_ENABLED;
243    INIT_WORK(&data->thermal_wq, omap_thermal_work);
244
245    /* TODO: remove TC1 TC2 */
246    /* Create thermal zone */
247    data->omap_thermal = thermal_zone_device_register(domain,
248                OMAP_TRIP_NUMBER, 0, data, &omap_thermal_ops,
249                0, FAST_TEMP_MONITORING_RATE, 0, 0);
250    if (IS_ERR_OR_NULL(data->omap_thermal)) {
251        dev_err(bg_ptr->dev, "thermal zone device is NULL\n");
252        return PTR_ERR(data->omap_thermal);
253    }
254    data->omap_thermal->polling_delay = FAST_TEMP_MONITORING_RATE;
255    omap_bandgap_set_sensor_data(bg_ptr, id, data);
256
257    return 0;
258}
259
260int omap_thermal_remove_sensor(struct omap_bandgap *bg_ptr, int id)
261{
262    struct omap_thermal_data *data;
263
264    data = omap_bandgap_get_sensor_data(bg_ptr, id);
265
266    thermal_zone_device_unregister(data->omap_thermal);
267
268    return 0;
269}
270
271int omap_thermal_report_sensor_temperature(struct omap_bandgap *bg_ptr, int id)
272{
273    struct omap_thermal_data *data;
274
275    data = omap_bandgap_get_sensor_data(bg_ptr, id);
276
277    schedule_work(&data->thermal_wq);
278
279    return 0;
280}
281
282static int omap_thermal_build_cpufreq_clip(struct omap_bandgap *bg_ptr,
283                       struct freq_clip_table **tab_ptr,
284                       int *tab_size)
285{
286    struct cpufreq_frequency_table *freq_table;
287    struct freq_clip_table *tab;
288    int i, count = 0;
289
290    freq_table = cpufreq_frequency_get_table(0);
291    if (IS_ERR_OR_NULL(freq_table)) {
292        dev_err(bg_ptr->dev,
293            "%s: failed to get cpufreq table (%p)\n",
294            __func__, freq_table);
295        return -EINVAL;
296    }
297
298    for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
299        unsigned int freq = freq_table[i].frequency;
300        if (freq == CPUFREQ_ENTRY_INVALID)
301            continue;
302        count++;
303    }
304
305    tab = devm_kzalloc(bg_ptr->dev, sizeof(*tab) * count, GFP_KERNEL);
306    if (!tab) {
307        dev_err(bg_ptr->dev,
308            "%s: no memory available\n", __func__);
309        return -ENOMEM;
310    }
311
312    for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
313        unsigned int freq = freq_table[i].frequency;
314
315        if (freq == CPUFREQ_ENTRY_INVALID)
316            continue;
317
318        tab[count - i - 1].freq_clip_max = freq;
319        tab[count - i - 1].temp_level = OMAP_TRIP_HOT;
320        tab[count - i - 1].mask_val = cpumask_of(0);
321    }
322
323    *tab_ptr = tab;
324    *tab_size = count;
325
326    return 0;
327}
328
329int omap_thermal_register_cpu_cooling(struct omap_bandgap *bg_ptr, int id)
330{
331    struct omap_thermal_data *data;
332    struct freq_clip_table *tab_ptr;
333    int tab_size, ret;
334
335    data = omap_bandgap_get_sensor_data(bg_ptr, id);
336
337    ret = omap_thermal_build_cpufreq_clip(bg_ptr, &tab_ptr, &tab_size);
338    if (ret < 0) {
339        dev_err(bg_ptr->dev,
340            "%s: failed to build cpufreq clip table\n", __func__);
341        return ret;
342    }
343
344    /* Register cooling device */
345    data->cool_dev = cpufreq_cooling_register(tab_ptr, tab_size);
346    if (IS_ERR_OR_NULL(data->cool_dev)) {
347        dev_err(bg_ptr->dev,
348            "Failed to register cpufreq cooling device\n");
349        return PTR_ERR(data->cool_dev);
350    }
351    bg_ptr->conf->sensors[id].cooling_data.freq_clip_count = tab_size;
352
353    return 0;
354}
355
356int omap_thermal_unregister_cpu_cooling(struct omap_bandgap *bg_ptr, int id)
357{
358    struct omap_thermal_data *data;
359
360    data = omap_bandgap_get_sensor_data(bg_ptr, id);
361    cpufreq_cooling_unregister(data->cool_dev);
362
363    return 0;
364}
365

Archive Download this file



interactive