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, THERMAL_EVENT_UNSPECIFIED);
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 MODULE_DEVICE_TABLE(of, db8500_thermal_match);
516 #endif
517 
518 static struct platform_driver db8500_thermal_driver = {
519 	.driver = {
520 		.name = "db8500-thermal",
521 		.of_match_table = of_match_ptr(db8500_thermal_match),
522 	},
523 	.probe = db8500_thermal_probe,
524 	.suspend = db8500_thermal_suspend,
525 	.resume = db8500_thermal_resume,
526 	.remove = db8500_thermal_remove,
527 };
528 
529 module_platform_driver(db8500_thermal_driver);
530 
531 MODULE_AUTHOR("Hongbo Zhang <hongbo.zhang@stericsson.com>");
532 MODULE_DESCRIPTION("DB8500 thermal driver");
533 MODULE_LICENSE("GPL");
534