drivers/thermal/hisi_thermal.c

   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");