drivers/thermal/uniphier_thermal.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * uniphier_thermal.c - Socionext UniPhier thermal driver
   4  * Copyright 2014      Panasonic Corporation
   5  * Copyright 2016-2017 Socionext Inc.
   6  * Author:
   7  *      Kunihiko Hayashi <hayashi.kunihiko@socionext.com>
   8  */
   9
  10 #include <linux/bitops.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/mfd/syscon.h>
  13 #include <linux/module.h>
  14 #include <linux/of.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/regmap.h>
  17 #include <linux/thermal.h>
  18
  19 /*
  20  * block registers
  21  * addresses are the offset from .block_base
  22  */
  23 #define PVTCTLEN                        0x0000
  24 #define PVTCTLEN_EN                     BIT(0)
  25
  26 #define PVTCTLMODE                      0x0004
  27 #define PVTCTLMODE_MASK                 0xf
  28 #define PVTCTLMODE_TEMPMON              0x5
  29
  30 #define EMONREPEAT                      0x0040
  31 #define EMONREPEAT_ENDLESS              BIT(24)
  32 #define EMONREPEAT_PERIOD               GENMASK(3, 0)
  33 #define EMONREPEAT_PERIOD_1000000       0x9
  34
  35 /*
  36  * common registers
  37  * addresses are the offset from .map_base
  38  */
  39 #define PVTCTLSEL                       0x0900
  40 #define PVTCTLSEL_MASK                  GENMASK(2, 0)
  41 #define PVTCTLSEL_MONITOR               0
  42
  43 #define SETALERT0                       0x0910
  44 #define SETALERT1                       0x0914
  45 #define SETALERT2                       0x0918
  46 #define SETALERT_TEMP_OVF               (GENMASK(7, 0) << 16)
  47 #define SETALERT_TEMP_OVF_VALUE(val)    (((val) & GENMASK(7, 0)) << 16)
  48 #define SETALERT_EN                     BIT(0)
  49
  50 #define PMALERTINTCTL                   0x0920
  51 #define PMALERTINTCTL_CLR(ch)           BIT(4 * (ch) + 2)
  52 #define PMALERTINTCTL_SET(ch)           BIT(4 * (ch) + 1)
  53 #define PMALERTINTCTL_EN(ch)            BIT(4 * (ch) + 0)
  54 #define PMALERTINTCTL_MASK              (GENMASK(10, 8) | GENMASK(6, 4) | \
  55                                          GENMASK(2, 0))
  56
  57 #define TMOD                            0x0928
  58 #define TMOD_WIDTH                      9
  59
  60 #define TMODCOEF                        0x0e5c
  61
  62 #define TMODSETUP0_EN                   BIT(30)
  63 #define TMODSETUP0_VAL(val)             (((val) & GENMASK(13, 0)) << 16)
  64 #define TMODSETUP1_EN                   BIT(15)
  65 #define TMODSETUP1_VAL(val)             ((val) & GENMASK(14, 0))
  66
  67 /* SoC critical temperature */
  68 #define CRITICAL_TEMP_LIMIT             (120 * 1000)
  69
  70 /* Max # of alert channels */
  71 #define ALERT_CH_NUM                    3
  72
  73 /* SoC specific thermal sensor data */
  74 struct uniphier_tm_soc_data {
  75         u32 map_base;
  76         u32 block_base;
  77         u32 tmod_setup_addr;
  78 };
  79
  80 struct uniphier_tm_dev {
  81         struct regmap *regmap;
  82         struct device *dev;
  83         bool alert_en[ALERT_CH_NUM];
  84         struct thermal_zone_device *tz_dev;
  85         const struct uniphier_tm_soc_data *data;
  86 };
  87
  88 static int uniphier_tm_initialize_sensor(struct uniphier_tm_dev *tdev)
  89 {
  90         struct regmap *map = tdev->regmap;
  91         u32 val;
  92         u32 tmod_calib[2];
  93         int ret;
  94
  95         /* stop PVT */
  96         regmap_write_bits(map, tdev->data->block_base + PVTCTLEN,
  97                           PVTCTLEN_EN, 0);
  98
  99         /*
 100          * Since SoC has a calibrated value that was set in advance,
 101          * TMODCOEF shows non-zero and PVT refers the value internally.
 102          *
 103          * If TMODCOEF shows zero, the boards don't have the calibrated
 104          * value, and the driver has to set default value from DT.
 105          */
 106         ret = regmap_read(map, tdev->data->map_base + TMODCOEF, &val);
 107         if (ret)
 108                 return ret;
 109         if (!val) {
 110                 /* look for the default values in DT */
 111                 ret = of_property_read_u32_array(tdev->dev->of_node,
 112                                                  "socionext,tmod-calibration",
 113                                                  tmod_calib,
 114                                                  ARRAY_SIZE(tmod_calib));
 115                 if (ret)
 116                         return ret;
 117
 118                 regmap_write(map, tdev->data->tmod_setup_addr,
 119                         TMODSETUP0_EN | TMODSETUP0_VAL(tmod_calib[0]) |
 120                         TMODSETUP1_EN | TMODSETUP1_VAL(tmod_calib[1]));
 121         }
 122
 123         /* select temperature mode */
 124         regmap_write_bits(map, tdev->data->block_base + PVTCTLMODE,
 125                           PVTCTLMODE_MASK, PVTCTLMODE_TEMPMON);
 126
 127         /* set monitoring period */
 128         regmap_write_bits(map, tdev->data->block_base + EMONREPEAT,
 129                           EMONREPEAT_ENDLESS | EMONREPEAT_PERIOD,
 130                           EMONREPEAT_ENDLESS | EMONREPEAT_PERIOD_1000000);
 131
 132         /* set monitor mode */
 133         regmap_write_bits(map, tdev->data->map_base + PVTCTLSEL,
 134                           PVTCTLSEL_MASK, PVTCTLSEL_MONITOR);
 135
 136         return 0;
 137 }
 138
 139 static void uniphier_tm_set_alert(struct uniphier_tm_dev *tdev, u32 ch,
 140                                   u32 temp)
 141 {
 142         struct regmap *map = tdev->regmap;
 143
 144         /* set alert temperature */
 145         regmap_write_bits(map, tdev->data->map_base + SETALERT0 + (ch << 2),
 146                           SETALERT_EN | SETALERT_TEMP_OVF,
 147                           SETALERT_EN |
 148                           SETALERT_TEMP_OVF_VALUE(temp / 1000));
 149 }
 150
 151 static void uniphier_tm_enable_sensor(struct uniphier_tm_dev *tdev)
 152 {
 153         struct regmap *map = tdev->regmap;
 154         int i;
 155         u32 bits = 0;
 156
 157         for (i = 0; i < ALERT_CH_NUM; i++)
 158                 if (tdev->alert_en[i])
 159                         bits |= PMALERTINTCTL_EN(i);
 160
 161         /* enable alert interrupt */
 162         regmap_write_bits(map, tdev->data->map_base + PMALERTINTCTL,
 163                           PMALERTINTCTL_MASK, bits);
 164
 165         /* start PVT */
 166         regmap_write_bits(map, tdev->data->block_base + PVTCTLEN,
 167                           PVTCTLEN_EN, PVTCTLEN_EN);
 168
 169         usleep_range(700, 1500);        /* The spec note says at least 700us */
 170 }
 171
 172 static void uniphier_tm_disable_sensor(struct uniphier_tm_dev *tdev)
 173 {
 174         struct regmap *map = tdev->regmap;
 175
 176         /* disable alert interrupt */
 177         regmap_write_bits(map, tdev->data->map_base + PMALERTINTCTL,
 178                           PMALERTINTCTL_MASK, 0);
 179
 180         /* stop PVT */
 181         regmap_write_bits(map, tdev->data->block_base + PVTCTLEN,
 182                           PVTCTLEN_EN, 0);
 183
 184         usleep_range(1000, 2000);       /* The spec note says at least 1ms */
 185 }
 186
 187 static int uniphier_tm_get_temp(struct thermal_zone_device *tz, int *out_temp)
 188 {
 189         struct uniphier_tm_dev *tdev = thermal_zone_device_priv(tz);
 190         struct regmap *map = tdev->regmap;
 191         int ret;
 192         u32 temp;
 193
 194         ret = regmap_read(map, tdev->data->map_base + TMOD, &temp);
 195         if (ret)
 196                 return ret;
 197
 198         /* MSB of the TMOD field is a sign bit */
 199         *out_temp = sign_extend32(temp, TMOD_WIDTH - 1) * 1000;
 200
 201         return 0;
 202 }
 203
 204 static const struct thermal_zone_device_ops uniphier_of_thermal_ops = {
 205         .get_temp = uniphier_tm_get_temp,
 206 };
 207
 208 static void uniphier_tm_irq_clear(struct uniphier_tm_dev *tdev)
 209 {
 210         u32 mask = 0, bits = 0;
 211         int i;
 212
 213         for (i = 0; i < ALERT_CH_NUM; i++) {
 214                 mask |= (PMALERTINTCTL_CLR(i) | PMALERTINTCTL_SET(i));
 215                 bits |= PMALERTINTCTL_CLR(i);
 216         }
 217
 218         /* clear alert interrupt */
 219         regmap_write_bits(tdev->regmap,
 220                           tdev->data->map_base + PMALERTINTCTL, mask, bits);
 221 }
 222
 223 static irqreturn_t uniphier_tm_alarm_irq(int irq, void *_tdev)
 224 {
 225         struct uniphier_tm_dev *tdev = _tdev;
 226
 227         disable_irq_nosync(irq);
 228         uniphier_tm_irq_clear(tdev);
 229
 230         return IRQ_WAKE_THREAD;
 231 }
 232
 233 static irqreturn_t uniphier_tm_alarm_irq_thread(int irq, void *_tdev)
 234 {
 235         struct uniphier_tm_dev *tdev = _tdev;
 236
 237         thermal_zone_device_update(tdev->tz_dev, THERMAL_EVENT_UNSPECIFIED);
 238
 239         return IRQ_HANDLED;
 240 }
 241
 242 static int uniphier_tm_probe(struct platform_device *pdev)
 243 {
 244         struct device *dev = &pdev->dev;
 245         struct regmap *regmap;
 246         struct device_node *parent;
 247         struct uniphier_tm_dev *tdev;
 248         int i, ret, irq, crit_temp = INT_MAX;
 249
 250         tdev = devm_kzalloc(dev, sizeof(*tdev), GFP_KERNEL);
 251         if (!tdev)
 252                 return -ENOMEM;
 253         tdev->dev = dev;
 254
 255         tdev->data = of_device_get_match_data(dev);
 256         if (WARN_ON(!tdev->data))
 257                 return -EINVAL;
 258
 259         irq = platform_get_irq(pdev, 0);
 260         if (irq < 0)
 261                 return irq;
 262
 263         /* get regmap from syscon node */
 264         parent = of_get_parent(dev->of_node); /* parent should be syscon node */
 265         regmap = syscon_node_to_regmap(parent);
 266         of_node_put(parent);
 267         if (IS_ERR(regmap)) {
 268                 dev_err(dev, "failed to get regmap (error %ld)\n",
 269                         PTR_ERR(regmap));
 270                 return PTR_ERR(regmap);
 271         }
 272         tdev->regmap = regmap;
 273
 274         ret = uniphier_tm_initialize_sensor(tdev);
 275         if (ret) {
 276                 dev_err(dev, "failed to initialize sensor\n");
 277                 return ret;
 278         }
 279
 280         ret = devm_request_threaded_irq(dev, irq, uniphier_tm_alarm_irq,
 281                                         uniphier_tm_alarm_irq_thread,
 282                                         0, "thermal", tdev);
 283         if (ret)
 284                 return ret;
 285
 286         platform_set_drvdata(pdev, tdev);
 287
 288         tdev->tz_dev = devm_thermal_of_zone_register(dev, 0, tdev,
 289                                                      &uniphier_of_thermal_ops);
 290         if (IS_ERR(tdev->tz_dev)) {
 291                 dev_err(dev, "failed to register sensor device\n");
 292                 return PTR_ERR(tdev->tz_dev);
 293         }
 294
 295         /* set alert temperatures */
 296         for (i = 0; i < thermal_zone_get_num_trips(tdev->tz_dev); i++) {
 297                 struct thermal_trip trip;
 298
 299                 ret = thermal_zone_get_trip(tdev->tz_dev, i, &trip);
 300                 if (ret)
 301                         return ret;
 302
 303                 if (trip.type == THERMAL_TRIP_CRITICAL &&
 304                     trip.temperature < crit_temp)
 305                         crit_temp = trip.temperature;
 306                 uniphier_tm_set_alert(tdev, i, trip.temperature);
 307                 tdev->alert_en[i] = true;
 308         }
 309         if (crit_temp > CRITICAL_TEMP_LIMIT) {
 310                 dev_err(dev, "critical trip is over limit(>%d), or not set\n",
 311                         CRITICAL_TEMP_LIMIT);
 312                 return -EINVAL;
 313         }
 314
 315         uniphier_tm_enable_sensor(tdev);
 316
 317         return 0;
 318 }
 319
 320 static void uniphier_tm_remove(struct platform_device *pdev)
 321 {
 322         struct uniphier_tm_dev *tdev = platform_get_drvdata(pdev);
 323
 324         /* disable sensor */
 325         uniphier_tm_disable_sensor(tdev);
 326 }
 327
 328 static const struct uniphier_tm_soc_data uniphier_pxs2_tm_data = {
 329         .map_base        = 0xe000,
 330         .block_base      = 0xe000,
 331         .tmod_setup_addr = 0xe904,
 332 };
 333
 334 static const struct uniphier_tm_soc_data uniphier_ld20_tm_data = {
 335         .map_base        = 0xe000,
 336         .block_base      = 0xe800,
 337         .tmod_setup_addr = 0xe938,
 338 };
 339
 340 static const struct of_device_id uniphier_tm_dt_ids[] = {
 341         {
 342                 .compatible = "socionext,uniphier-pxs2-thermal",
 343                 .data       = &uniphier_pxs2_tm_data,
 344         },
 345         {
 346                 .compatible = "socionext,uniphier-ld20-thermal",
 347                 .data       = &uniphier_ld20_tm_data,
 348         },
 349         {
 350                 .compatible = "socionext,uniphier-pxs3-thermal",
 351                 .data       = &uniphier_ld20_tm_data,
 352         },
 353         {
 354                 .compatible = "socionext,uniphier-nx1-thermal",
 355                 .data       = &uniphier_ld20_tm_data,
 356         },
 357         { /* sentinel */ }
 358 };
 359 MODULE_DEVICE_TABLE(of, uniphier_tm_dt_ids);
 360
 361 static struct platform_driver uniphier_tm_driver = {
 362         .probe = uniphier_tm_probe,
 363         .remove_new = uniphier_tm_remove,
 364         .driver = {
 365                 .name = "uniphier-thermal",
 366                 .of_match_table = uniphier_tm_dt_ids,
 367         },
 368 };
 369 module_platform_driver(uniphier_tm_driver);
 370
 371 MODULE_AUTHOR("Kunihiko Hayashi <hayashi.kunihiko@socionext.com>");
 372 MODULE_DESCRIPTION("UniPhier thermal driver");
 373 MODULE_LICENSE("GPL v2");