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