Version:  2.0.40 2.2.26 2.4.37 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6

Linux/drivers/thermal/db8500_thermal.c

  1 /*
  2  * db8500_thermal.c - DB8500 Thermal Management Implementation
  3  *
  4  * Copyright (C) 2012 ST-Ericsson
  5  * Copyright (C) 2012 Linaro Ltd.
  6  *
  7  * Author: Hongbo Zhang <hongbo.zhang@linaro.com>
  8  *
  9  * This program is free software; you can redistribute it and/or modify
 10  * it under the terms of the GNU General Public License as published by
 11  * the Free Software Foundation; either version 2 of the License, or
 12  * (at your option) any later version.
 13  *
 14  * This program is distributed in the hope that it will be useful,
 15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17  * GNU General Public License for more details.
 18  */
 19 
 20 #include <linux/cpu_cooling.h>
 21 #include <linux/interrupt.h>
 22 #include <linux/mfd/dbx500-prcmu.h>
 23 #include <linux/module.h>
 24 #include <linux/of.h>
 25 #include <linux/platform_data/db8500_thermal.h>
 26 #include <linux/platform_device.h>
 27 #include <linux/slab.h>
 28 #include <linux/thermal.h>
 29 
 30 #define PRCMU_DEFAULT_MEASURE_TIME      0xFFF
 31 #define PRCMU_DEFAULT_LOW_TEMP          0
 32 
 33 struct db8500_thermal_zone {
 34         struct thermal_zone_device *therm_dev;
 35         struct mutex th_lock;
 36         struct work_struct therm_work;
 37         struct db8500_thsens_platform_data *trip_tab;
 38         enum thermal_device_mode mode;
 39         enum thermal_trend trend;
 40         unsigned long cur_temp_pseudo;
 41         unsigned int cur_index;
 42 };
 43 
 44 /* Local function to check if thermal zone matches cooling devices */
 45 static int db8500_thermal_match_cdev(struct thermal_cooling_device *cdev,
 46                 struct db8500_trip_point *trip_point)
 47 {
 48         int i;
 49 
 50         if (!strlen(cdev->type))
 51                 return -EINVAL;
 52 
 53         for (i = 0; i < COOLING_DEV_MAX; i++) {
 54                 if (!strcmp(trip_point->cdev_name[i], cdev->type))
 55                         return 0;
 56         }
 57 
 58         return -ENODEV;
 59 }
 60 
 61 /* Callback to bind cooling device to thermal zone */
 62 static int db8500_cdev_bind(struct thermal_zone_device *thermal,
 63                 struct thermal_cooling_device *cdev)
 64 {
 65         struct db8500_thermal_zone *pzone = thermal->devdata;
 66         struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
 67         unsigned long max_state, upper, lower;
 68         int i, ret = -EINVAL;
 69 
 70         cdev->ops->get_max_state(cdev, &max_state);
 71 
 72         for (i = 0; i < ptrips->num_trips; i++) {
 73                 if (db8500_thermal_match_cdev(cdev, &ptrips->trip_points[i]))
 74                         continue;
 75 
 76                 upper = lower = i > max_state ? max_state : i;
 77 
 78                 ret = thermal_zone_bind_cooling_device(thermal, i, cdev,
 79                         upper, lower, THERMAL_WEIGHT_DEFAULT);
 80 
 81                 dev_info(&cdev->device, "%s bind to %d: %d-%s\n", cdev->type,
 82                         i, ret, ret ? "fail" : "succeed");
 83         }
 84 
 85         return ret;
 86 }
 87 
 88 /* Callback to unbind cooling device from thermal zone */
 89 static int db8500_cdev_unbind(struct thermal_zone_device *thermal,
 90                 struct thermal_cooling_device *cdev)
 91 {
 92         struct db8500_thermal_zone *pzone = thermal->devdata;
 93         struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
 94         int i, ret = -EINVAL;
 95 
 96         for (i = 0; i < ptrips->num_trips; i++) {
 97                 if (db8500_thermal_match_cdev(cdev, &ptrips->trip_points[i]))
 98                         continue;
 99 
100                 ret = thermal_zone_unbind_cooling_device(thermal, i, cdev);
101 
102                 dev_info(&cdev->device, "%s unbind from %d: %s\n", cdev->type,
103                         i, ret ? "fail" : "succeed");
104         }
105 
106         return ret;
107 }
108 
109 /* Callback to get current temperature */
110 static int db8500_sys_get_temp(struct thermal_zone_device *thermal, int *temp)
111 {
112         struct db8500_thermal_zone *pzone = thermal->devdata;
113 
114         /*
115          * TODO: There is no PRCMU interface to get temperature data currently,
116          * so a pseudo temperature is returned , it works for thermal framework
117          * and this will be fixed when the PRCMU interface is available.
118          */
119         *temp = pzone->cur_temp_pseudo;
120 
121         return 0;
122 }
123 
124 /* Callback to get temperature changing trend */
125 static int db8500_sys_get_trend(struct thermal_zone_device *thermal,
126                 int trip, enum thermal_trend *trend)
127 {
128         struct db8500_thermal_zone *pzone = thermal->devdata;
129 
130         *trend = pzone->trend;
131 
132         return 0;
133 }
134 
135 /* Callback to get thermal zone mode */
136 static int db8500_sys_get_mode(struct thermal_zone_device *thermal,
137                 enum thermal_device_mode *mode)
138 {
139         struct db8500_thermal_zone *pzone = thermal->devdata;
140 
141         mutex_lock(&pzone->th_lock);
142         *mode = pzone->mode;
143         mutex_unlock(&pzone->th_lock);
144 
145         return 0;
146 }
147 
148 /* Callback to set thermal zone mode */
149 static int db8500_sys_set_mode(struct thermal_zone_device *thermal,
150                 enum thermal_device_mode mode)
151 {
152         struct db8500_thermal_zone *pzone = thermal->devdata;
153 
154         mutex_lock(&pzone->th_lock);
155 
156         pzone->mode = mode;
157         if (mode == THERMAL_DEVICE_ENABLED)
158                 schedule_work(&pzone->therm_work);
159 
160         mutex_unlock(&pzone->th_lock);
161 
162         return 0;
163 }
164 
165 /* Callback to get trip point type */
166 static int db8500_sys_get_trip_type(struct thermal_zone_device *thermal,
167                 int trip, enum thermal_trip_type *type)
168 {
169         struct db8500_thermal_zone *pzone = thermal->devdata;
170         struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
171 
172         if (trip >= ptrips->num_trips)
173                 return -EINVAL;
174 
175         *type = ptrips->trip_points[trip].type;
176 
177         return 0;
178 }
179 
180 /* Callback to get trip point temperature */
181 static int db8500_sys_get_trip_temp(struct thermal_zone_device *thermal,
182                 int trip, int *temp)
183 {
184         struct db8500_thermal_zone *pzone = thermal->devdata;
185         struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
186 
187         if (trip >= ptrips->num_trips)
188                 return -EINVAL;
189 
190         *temp = ptrips->trip_points[trip].temp;
191 
192         return 0;
193 }
194 
195 /* Callback to get critical trip point temperature */
196 static int db8500_sys_get_crit_temp(struct thermal_zone_device *thermal,
197                 int *temp)
198 {
199         struct db8500_thermal_zone *pzone = thermal->devdata;
200         struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
201         int i;
202 
203         for (i = ptrips->num_trips - 1; i > 0; i--) {
204                 if (ptrips->trip_points[i].type == THERMAL_TRIP_CRITICAL) {
205                         *temp = ptrips->trip_points[i].temp;
206                         return 0;
207                 }
208         }
209 
210         return -EINVAL;
211 }
212 
213 static struct thermal_zone_device_ops thdev_ops = {
214         .bind = db8500_cdev_bind,
215         .unbind = db8500_cdev_unbind,
216         .get_temp = db8500_sys_get_temp,
217         .get_trend = db8500_sys_get_trend,
218         .get_mode = db8500_sys_get_mode,
219         .set_mode = db8500_sys_set_mode,
220         .get_trip_type = db8500_sys_get_trip_type,
221         .get_trip_temp = db8500_sys_get_trip_temp,
222         .get_crit_temp = db8500_sys_get_crit_temp,
223 };
224 
225 static void db8500_thermal_update_config(struct db8500_thermal_zone *pzone,
226                 unsigned int idx, enum thermal_trend trend,
227                 unsigned long next_low, unsigned long next_high)
228 {
229         prcmu_stop_temp_sense();
230 
231         pzone->cur_index = idx;
232         pzone->cur_temp_pseudo = (next_low + next_high)/2;
233         pzone->trend = trend;
234 
235         prcmu_config_hotmon((u8)(next_low/1000), (u8)(next_high/1000));
236         prcmu_start_temp_sense(PRCMU_DEFAULT_MEASURE_TIME);
237 }
238 
239 static irqreturn_t prcmu_low_irq_handler(int irq, void *irq_data)
240 {
241         struct db8500_thermal_zone *pzone = irq_data;
242         struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
243         unsigned int idx = pzone->cur_index;
244         unsigned long next_low, next_high;
245 
246         if (unlikely(idx == 0))
247                 /* Meaningless for thermal management, ignoring it */
248                 return IRQ_HANDLED;
249 
250         if (idx == 1) {
251                 next_high = ptrips->trip_points[0].temp;
252                 next_low = PRCMU_DEFAULT_LOW_TEMP;
253         } else {
254                 next_high = ptrips->trip_points[idx-1].temp;
255                 next_low = ptrips->trip_points[idx-2].temp;
256         }
257         idx -= 1;
258 
259         db8500_thermal_update_config(pzone, idx, THERMAL_TREND_DROPPING,
260                 next_low, next_high);
261 
262         dev_dbg(&pzone->therm_dev->device,
263                 "PRCMU set max %ld, min %ld\n", next_high, next_low);
264 
265         schedule_work(&pzone->therm_work);
266 
267         return IRQ_HANDLED;
268 }
269 
270 static irqreturn_t prcmu_high_irq_handler(int irq, void *irq_data)
271 {
272         struct db8500_thermal_zone *pzone = irq_data;
273         struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
274         unsigned int idx = pzone->cur_index;
275         unsigned long next_low, next_high;
276 
277         if (idx < ptrips->num_trips - 1) {
278                 next_high = ptrips->trip_points[idx+1].temp;
279                 next_low = ptrips->trip_points[idx].temp;
280                 idx += 1;
281 
282                 db8500_thermal_update_config(pzone, idx, THERMAL_TREND_RAISING,
283                         next_low, next_high);
284 
285                 dev_dbg(&pzone->therm_dev->device,
286                 "PRCMU set max %ld, min %ld\n", next_high, next_low);
287         } else if (idx == ptrips->num_trips - 1)
288                 pzone->cur_temp_pseudo = ptrips->trip_points[idx].temp + 1;
289 
290         schedule_work(&pzone->therm_work);
291 
292         return IRQ_HANDLED;
293 }
294 
295 static void db8500_thermal_work(struct work_struct *work)
296 {
297         enum thermal_device_mode cur_mode;
298         struct db8500_thermal_zone *pzone;
299 
300         pzone = container_of(work, struct db8500_thermal_zone, therm_work);
301 
302         mutex_lock(&pzone->th_lock);
303         cur_mode = pzone->mode;
304         mutex_unlock(&pzone->th_lock);
305 
306         if (cur_mode == THERMAL_DEVICE_DISABLED)
307                 return;
308 
309         thermal_zone_device_update(pzone->therm_dev);
310         dev_dbg(&pzone->therm_dev->device, "thermal work finished.\n");
311 }
312 
313 #ifdef CONFIG_OF
314 static struct db8500_thsens_platform_data*
315                 db8500_thermal_parse_dt(struct platform_device *pdev)
316 {
317         struct db8500_thsens_platform_data *ptrips;
318         struct device_node *np = pdev->dev.of_node;
319         char prop_name[32];
320         const char *tmp_str;
321         u32 tmp_data;
322         int i, j;
323 
324         ptrips = devm_kzalloc(&pdev->dev, sizeof(*ptrips), GFP_KERNEL);
325         if (!ptrips)
326                 return NULL;
327 
328         if (of_property_read_u32(np, "num-trips", &tmp_data))
329                 goto err_parse_dt;
330 
331         if (tmp_data > THERMAL_MAX_TRIPS)
332                 goto err_parse_dt;
333 
334         ptrips->num_trips = tmp_data;
335 
336         for (i = 0; i < ptrips->num_trips; i++) {
337                 sprintf(prop_name, "trip%d-temp", i);
338                 if (of_property_read_u32(np, prop_name, &tmp_data))
339                         goto err_parse_dt;
340 
341                 ptrips->trip_points[i].temp = tmp_data;
342 
343                 sprintf(prop_name, "trip%d-type", i);
344                 if (of_property_read_string(np, prop_name, &tmp_str))
345                         goto err_parse_dt;
346 
347                 if (!strcmp(tmp_str, "active"))
348                         ptrips->trip_points[i].type = THERMAL_TRIP_ACTIVE;
349                 else if (!strcmp(tmp_str, "passive"))
350                         ptrips->trip_points[i].type = THERMAL_TRIP_PASSIVE;
351                 else if (!strcmp(tmp_str, "hot"))
352                         ptrips->trip_points[i].type = THERMAL_TRIP_HOT;
353                 else if (!strcmp(tmp_str, "critical"))
354                         ptrips->trip_points[i].type = THERMAL_TRIP_CRITICAL;
355                 else
356                         goto err_parse_dt;
357 
358                 sprintf(prop_name, "trip%d-cdev-num", i);
359                 if (of_property_read_u32(np, prop_name, &tmp_data))
360                         goto err_parse_dt;
361 
362                 if (tmp_data > COOLING_DEV_MAX)
363                         goto err_parse_dt;
364 
365                 for (j = 0; j < tmp_data; j++) {
366                         sprintf(prop_name, "trip%d-cdev-name%d", i, j);
367                         if (of_property_read_string(np, prop_name, &tmp_str))
368                                 goto err_parse_dt;
369 
370                         if (strlen(tmp_str) >= THERMAL_NAME_LENGTH)
371                                 goto err_parse_dt;
372 
373                         strcpy(ptrips->trip_points[i].cdev_name[j], tmp_str);
374                 }
375         }
376         return ptrips;
377 
378 err_parse_dt:
379         dev_err(&pdev->dev, "Parsing device tree data error.\n");
380         return NULL;
381 }
382 #else
383 static inline struct db8500_thsens_platform_data*
384                 db8500_thermal_parse_dt(struct platform_device *pdev)
385 {
386         return NULL;
387 }
388 #endif
389 
390 static int db8500_thermal_probe(struct platform_device *pdev)
391 {
392         struct db8500_thermal_zone *pzone = NULL;
393         struct db8500_thsens_platform_data *ptrips = NULL;
394         struct device_node *np = pdev->dev.of_node;
395         int low_irq, high_irq, ret = 0;
396         unsigned long dft_low, dft_high;
397 
398         if (np)
399                 ptrips = db8500_thermal_parse_dt(pdev);
400         else
401                 ptrips = dev_get_platdata(&pdev->dev);
402 
403         if (!ptrips)
404                 return -EINVAL;
405 
406         pzone = devm_kzalloc(&pdev->dev, sizeof(*pzone), GFP_KERNEL);
407         if (!pzone)
408                 return -ENOMEM;
409 
410         mutex_init(&pzone->th_lock);
411         mutex_lock(&pzone->th_lock);
412 
413         pzone->mode = THERMAL_DEVICE_DISABLED;
414         pzone->trip_tab = ptrips;
415 
416         INIT_WORK(&pzone->therm_work, db8500_thermal_work);
417 
418         low_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_LOW");
419         if (low_irq < 0) {
420                 dev_err(&pdev->dev, "Get IRQ_HOTMON_LOW failed.\n");
421                 ret = low_irq;
422                 goto out_unlock;
423         }
424 
425         ret = devm_request_threaded_irq(&pdev->dev, low_irq, NULL,
426                 prcmu_low_irq_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT,
427                 "dbx500_temp_low", pzone);
428         if (ret < 0) {
429                 dev_err(&pdev->dev, "Failed to allocate temp low irq.\n");
430                 goto out_unlock;
431         }
432 
433         high_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_HIGH");
434         if (high_irq < 0) {
435                 dev_err(&pdev->dev, "Get IRQ_HOTMON_HIGH failed.\n");
436                 ret = high_irq;
437                 goto out_unlock;
438         }
439 
440         ret = devm_request_threaded_irq(&pdev->dev, high_irq, NULL,
441                 prcmu_high_irq_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT,
442                 "dbx500_temp_high", pzone);
443         if (ret < 0) {
444                 dev_err(&pdev->dev, "Failed to allocate temp high irq.\n");
445                 goto out_unlock;
446         }
447 
448         pzone->therm_dev = thermal_zone_device_register("db8500_thermal_zone",
449                 ptrips->num_trips, 0, pzone, &thdev_ops, NULL, 0, 0);
450 
451         if (IS_ERR(pzone->therm_dev)) {
452                 dev_err(&pdev->dev, "Register thermal zone device failed.\n");
453                 ret = PTR_ERR(pzone->therm_dev);
454                 goto out_unlock;
455         }
456         dev_info(&pdev->dev, "Thermal zone device registered.\n");
457 
458         dft_low = PRCMU_DEFAULT_LOW_TEMP;
459         dft_high = ptrips->trip_points[0].temp;
460 
461         db8500_thermal_update_config(pzone, 0, THERMAL_TREND_STABLE,
462                 dft_low, dft_high);
463 
464         platform_set_drvdata(pdev, pzone);
465         pzone->mode = THERMAL_DEVICE_ENABLED;
466 
467 out_unlock:
468         mutex_unlock(&pzone->th_lock);
469 
470         return ret;
471 }
472 
473 static int db8500_thermal_remove(struct platform_device *pdev)
474 {
475         struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev);
476 
477         thermal_zone_device_unregister(pzone->therm_dev);
478         cancel_work_sync(&pzone->therm_work);
479         mutex_destroy(&pzone->th_lock);
480 
481         return 0;
482 }
483 
484 static int db8500_thermal_suspend(struct platform_device *pdev,
485                 pm_message_t state)
486 {
487         struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev);
488 
489         flush_work(&pzone->therm_work);
490         prcmu_stop_temp_sense();
491 
492         return 0;
493 }
494 
495 static int db8500_thermal_resume(struct platform_device *pdev)
496 {
497         struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev);
498         struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
499         unsigned long dft_low, dft_high;
500 
501         dft_low = PRCMU_DEFAULT_LOW_TEMP;
502         dft_high = ptrips->trip_points[0].temp;
503 
504         db8500_thermal_update_config(pzone, 0, THERMAL_TREND_STABLE,
505                 dft_low, dft_high);
506 
507         return 0;
508 }
509 
510 #ifdef CONFIG_OF
511 static const struct of_device_id db8500_thermal_match[] = {
512         { .compatible = "stericsson,db8500-thermal" },
513         {},
514 };
515 #endif
516 
517 static struct platform_driver db8500_thermal_driver = {
518         .driver = {
519                 .name = "db8500-thermal",
520                 .of_match_table = of_match_ptr(db8500_thermal_match),
521         },
522         .probe = db8500_thermal_probe,
523         .suspend = db8500_thermal_suspend,
524         .resume = db8500_thermal_resume,
525         .remove = db8500_thermal_remove,
526 };
527 
528 module_platform_driver(db8500_thermal_driver);
529 
530 MODULE_AUTHOR("Hongbo Zhang <hongbo.zhang@stericsson.com>");
531 MODULE_DESCRIPTION("DB8500 thermal driver");
532 MODULE_LICENSE("GPL");
533 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us