1 /* 2 * Hisilicon thermal sensor driver 3 * 4 * Copyright (c) 2014-2015 Hisilicon Limited. 5 * Copyright (c) 2014-2015 Linaro Limited. 6 * 7 * Xinwei Kong <kong.kongxinwei@hisilicon.com> 8 * Leo Yan <leo.yan@linaro.org> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 * 14 * This program is distributed "as is" WITHOUT ANY WARRANTY of any 15 * kind, whether express or implied; without even the implied warranty 16 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 */ 19 20 #include <linux/cpufreq.h> 21 #include <linux/delay.h> 22 #include <linux/interrupt.h> 23 #include <linux/module.h> 24 #include <linux/platform_device.h> 25 #include <linux/io.h> 26 27 #include "thermal_core.h" 28 29 #define TEMP0_TH (0x4) 30 #define TEMP0_RST_TH (0x8) 31 #define TEMP0_CFG (0xC) 32 #define TEMP0_EN (0x10) 33 #define TEMP0_INT_EN (0x14) 34 #define TEMP0_INT_CLR (0x18) 35 #define TEMP0_RST_MSK (0x1C) 36 #define TEMP0_VALUE (0x28) 37 38 #define HISI_TEMP_BASE (-60) 39 #define HISI_TEMP_RESET (100000) 40 41 #define HISI_MAX_SENSORS 4 42 43 struct hisi_thermal_sensor { 44 struct hisi_thermal_data *thermal; 45 struct thermal_zone_device *tzd; 46 47 long sensor_temp; 48 uint32_t id; 49 uint32_t thres_temp; 50 }; 51 52 struct hisi_thermal_data { 53 struct mutex thermal_lock; /* protects register data */ 54 struct platform_device *pdev; 55 struct clk *clk; 56 struct hisi_thermal_sensor sensors[HISI_MAX_SENSORS]; 57 58 int irq, irq_bind_sensor; 59 bool irq_enabled; 60 61 void __iomem *regs; 62 }; 63 64 /* in millicelsius */ 65 static inline int _step_to_temp(int step) 66 { 67 /* 68 * Every step equals (1 * 200) / 255 celsius, and finally 69 * need convert to millicelsius. 70 */ 71 return (HISI_TEMP_BASE * 1000 + (step * 200000 / 255)); 72 } 73 74 static inline long _temp_to_step(long temp) 75 { 76 return ((temp - HISI_TEMP_BASE * 1000) * 255) / 200000; 77 } 78 79 static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data, 80 struct hisi_thermal_sensor *sensor) 81 { 82 long val; 83 84 mutex_lock(&data->thermal_lock); 85 86 /* disable interrupt */ 87 writel(0x0, data->regs + TEMP0_INT_EN); 88 writel(0x1, data->regs + TEMP0_INT_CLR); 89 90 /* disable module firstly */ 91 writel(0x0, data->regs + TEMP0_EN); 92 93 /* select sensor id */ 94 writel((sensor->id << 12), data->regs + TEMP0_CFG); 95 96 /* enable module */ 97 writel(0x1, data->regs + TEMP0_EN); 98 99 usleep_range(3000, 5000); 100 101 val = readl(data->regs + TEMP0_VALUE); 102 val = _step_to_temp(val); 103 104 mutex_unlock(&data->thermal_lock); 105 106 return val; 107 } 108 109 static void hisi_thermal_enable_bind_irq_sensor 110 (struct hisi_thermal_data *data) 111 { 112 struct hisi_thermal_sensor *sensor; 113 114 mutex_lock(&data->thermal_lock); 115 116 sensor = &data->sensors[data->irq_bind_sensor]; 117 118 /* setting the hdak time */ 119 writel(0x0, data->regs + TEMP0_CFG); 120 121 /* disable module firstly */ 122 writel(0x0, data->regs + TEMP0_RST_MSK); 123 writel(0x0, data->regs + TEMP0_EN); 124 125 /* select sensor id */ 126 writel((sensor->id << 12), data->regs + TEMP0_CFG); 127 128 /* enable for interrupt */ 129 writel(_temp_to_step(sensor->thres_temp) | 0x0FFFFFF00, 130 data->regs + TEMP0_TH); 131 132 writel(_temp_to_step(HISI_TEMP_RESET), data->regs + TEMP0_RST_TH); 133 134 /* enable module */ 135 writel(0x1, data->regs + TEMP0_RST_MSK); 136 writel(0x1, data->regs + TEMP0_EN); 137 138 writel(0x0, data->regs + TEMP0_INT_CLR); 139 writel(0x1, data->regs + TEMP0_INT_EN); 140 141 usleep_range(3000, 5000); 142 143 mutex_unlock(&data->thermal_lock); 144 } 145 146 static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data) 147 { 148 mutex_lock(&data->thermal_lock); 149 150 /* disable sensor module */ 151 writel(0x0, data->regs + TEMP0_INT_EN); 152 writel(0x0, data->regs + TEMP0_RST_MSK); 153 writel(0x0, data->regs + TEMP0_EN); 154 155 mutex_unlock(&data->thermal_lock); 156 } 157 158 static int hisi_thermal_get_temp(void *_sensor, int *temp) 159 { 160 struct hisi_thermal_sensor *sensor = _sensor; 161 struct hisi_thermal_data *data = sensor->thermal; 162 163 int sensor_id = -1, i; 164 long max_temp = 0; 165 166 *temp = hisi_thermal_get_sensor_temp(data, sensor); 167 168 sensor->sensor_temp = *temp; 169 170 for (i = 0; i < HISI_MAX_SENSORS; i++) { 171 if (!data->sensors[i].tzd) 172 continue; 173 174 if (data->sensors[i].sensor_temp >= max_temp) { 175 max_temp = data->sensors[i].sensor_temp; 176 sensor_id = i; 177 } 178 } 179 180 /* If no sensor has been enabled, then skip to enable irq */ 181 if (sensor_id == -1) 182 return 0; 183 184 mutex_lock(&data->thermal_lock); 185 data->irq_bind_sensor = sensor_id; 186 mutex_unlock(&data->thermal_lock); 187 188 dev_dbg(&data->pdev->dev, "id=%d, irq=%d, temp=%d, thres=%d\n", 189 sensor->id, data->irq_enabled, *temp, sensor->thres_temp); 190 /* 191 * Bind irq to sensor for two cases: 192 * Reenable alarm IRQ if temperature below threshold; 193 * if irq has been enabled, always set it; 194 */ 195 if (data->irq_enabled) { 196 hisi_thermal_enable_bind_irq_sensor(data); 197 return 0; 198 } 199 200 if (max_temp < sensor->thres_temp) { 201 data->irq_enabled = true; 202 hisi_thermal_enable_bind_irq_sensor(data); 203 enable_irq(data->irq); 204 } 205 206 return 0; 207 } 208 209 static struct thermal_zone_of_device_ops hisi_of_thermal_ops = { 210 .get_temp = hisi_thermal_get_temp, 211 }; 212 213 static irqreturn_t hisi_thermal_alarm_irq(int irq, void *dev) 214 { 215 struct hisi_thermal_data *data = dev; 216 217 disable_irq_nosync(irq); 218 data->irq_enabled = false; 219 220 return IRQ_WAKE_THREAD; 221 } 222 223 static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev) 224 { 225 struct hisi_thermal_data *data = dev; 226 struct hisi_thermal_sensor *sensor; 227 int i; 228 229 mutex_lock(&data->thermal_lock); 230 sensor = &data->sensors[data->irq_bind_sensor]; 231 232 dev_crit(&data->pdev->dev, "THERMAL ALARM: T > %d\n", 233 sensor->thres_temp / 1000); 234 mutex_unlock(&data->thermal_lock); 235 236 for (i = 0; i < HISI_MAX_SENSORS; i++) { 237 if (!data->sensors[i].tzd) 238 continue; 239 240 thermal_zone_device_update(data->sensors[i].tzd); 241 } 242 243 return IRQ_HANDLED; 244 } 245 246 static int hisi_thermal_register_sensor(struct platform_device *pdev, 247 struct hisi_thermal_data *data, 248 struct hisi_thermal_sensor *sensor, 249 int index) 250 { 251 int ret, i; 252 const struct thermal_trip *trip; 253 254 sensor->id = index; 255 sensor->thermal = data; 256 257 sensor->tzd = devm_thermal_zone_of_sensor_register(&pdev->dev, 258 sensor->id, sensor, &hisi_of_thermal_ops); 259 if (IS_ERR(sensor->tzd)) { 260 ret = PTR_ERR(sensor->tzd); 261 sensor->tzd = NULL; 262 dev_err(&pdev->dev, "failed to register sensor id %d: %d\n", 263 sensor->id, ret); 264 return ret; 265 } 266 267 trip = of_thermal_get_trip_points(sensor->tzd); 268 269 for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) { 270 if (trip[i].type == THERMAL_TRIP_PASSIVE) { 271 sensor->thres_temp = trip[i].temperature; 272 break; 273 } 274 } 275 276 return 0; 277 } 278 279 static const struct of_device_id of_hisi_thermal_match[] = { 280 { .compatible = "hisilicon,tsensor" }, 281 { /* end */ } 282 }; 283 MODULE_DEVICE_TABLE(of, of_hisi_thermal_match); 284 285 static void hisi_thermal_toggle_sensor(struct hisi_thermal_sensor *sensor, 286 bool on) 287 { 288 struct thermal_zone_device *tzd = sensor->tzd; 289 290 tzd->ops->set_mode(tzd, 291 on ? THERMAL_DEVICE_ENABLED : THERMAL_DEVICE_DISABLED); 292 } 293 294 static int hisi_thermal_probe(struct platform_device *pdev) 295 { 296 struct hisi_thermal_data *data; 297 struct resource *res; 298 int i; 299 int ret; 300 301 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 302 if (!data) 303 return -ENOMEM; 304 305 mutex_init(&data->thermal_lock); 306 data->pdev = pdev; 307 308 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 309 data->regs = devm_ioremap_resource(&pdev->dev, res); 310 if (IS_ERR(data->regs)) { 311 dev_err(&pdev->dev, "failed to get io address\n"); 312 return PTR_ERR(data->regs); 313 } 314 315 data->irq = platform_get_irq(pdev, 0); 316 if (data->irq < 0) 317 return data->irq; 318 319 ret = devm_request_threaded_irq(&pdev->dev, data->irq, 320 hisi_thermal_alarm_irq, 321 hisi_thermal_alarm_irq_thread, 322 0, "hisi_thermal", data); 323 if (ret < 0) { 324 dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret); 325 return ret; 326 } 327 328 platform_set_drvdata(pdev, data); 329 330 data->clk = devm_clk_get(&pdev->dev, "thermal_clk"); 331 if (IS_ERR(data->clk)) { 332 ret = PTR_ERR(data->clk); 333 if (ret != -EPROBE_DEFER) 334 dev_err(&pdev->dev, 335 "failed to get thermal clk: %d\n", ret); 336 return ret; 337 } 338 339 /* enable clock for thermal */ 340 ret = clk_prepare_enable(data->clk); 341 if (ret) { 342 dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret); 343 return ret; 344 } 345 346 hisi_thermal_enable_bind_irq_sensor(data); 347 irq_get_irqchip_state(data->irq, IRQCHIP_STATE_MASKED, 348 &data->irq_enabled); 349 350 for (i = 0; i < HISI_MAX_SENSORS; ++i) { 351 ret = hisi_thermal_register_sensor(pdev, data, 352 &data->sensors[i], i); 353 if (ret) 354 dev_err(&pdev->dev, 355 "failed to register thermal sensor: %d\n", ret); 356 else 357 hisi_thermal_toggle_sensor(&data->sensors[i], true); 358 } 359 360 return 0; 361 } 362 363 static int hisi_thermal_remove(struct platform_device *pdev) 364 { 365 struct hisi_thermal_data *data = platform_get_drvdata(pdev); 366 int i; 367 368 for (i = 0; i < HISI_MAX_SENSORS; i++) { 369 struct hisi_thermal_sensor *sensor = &data->sensors[i]; 370 371 if (!sensor->tzd) 372 continue; 373 374 hisi_thermal_toggle_sensor(sensor, false); 375 } 376 377 hisi_thermal_disable_sensor(data); 378 clk_disable_unprepare(data->clk); 379 380 return 0; 381 } 382 383 #ifdef CONFIG_PM_SLEEP 384 static int hisi_thermal_suspend(struct device *dev) 385 { 386 struct hisi_thermal_data *data = dev_get_drvdata(dev); 387 388 hisi_thermal_disable_sensor(data); 389 data->irq_enabled = false; 390 391 clk_disable_unprepare(data->clk); 392 393 return 0; 394 } 395 396 static int hisi_thermal_resume(struct device *dev) 397 { 398 struct hisi_thermal_data *data = dev_get_drvdata(dev); 399 400 clk_prepare_enable(data->clk); 401 402 data->irq_enabled = true; 403 hisi_thermal_enable_bind_irq_sensor(data); 404 405 return 0; 406 } 407 #endif 408 409 static SIMPLE_DEV_PM_OPS(hisi_thermal_pm_ops, 410 hisi_thermal_suspend, hisi_thermal_resume); 411 412 static struct platform_driver hisi_thermal_driver = { 413 .driver = { 414 .name = "hisi_thermal", 415 .pm = &hisi_thermal_pm_ops, 416 .of_match_table = of_hisi_thermal_match, 417 }, 418 .probe = hisi_thermal_probe, 419 .remove = hisi_thermal_remove, 420 }; 421 422 module_platform_driver(hisi_thermal_driver); 423 424 MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>"); 425 MODULE_AUTHOR("Leo Yan <leo.yan@linaro.org>"); 426 MODULE_DESCRIPTION("Hisilicon thermal driver"); 427 MODULE_LICENSE("GPL v2"); 428