drivers/thermal/rcar_thermal.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  R-Car THS/TSC thermal sensor driver
   4  *
   5  * Copyright (C) 2012 Renesas Solutions Corp.
   6  * Kuninori Morimoto <[email protected]>
   7  */
   8 #include <linux/delay.h>
   9 #include <linux/err.h>
  10 #include <linux/irq.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/io.h>
  13 #include <linux/module.h>
  14 #include <linux/of_device.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/reboot.h>
  18 #include <linux/slab.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/thermal.h>
  21
  22 #include "thermal_hwmon.h"
  23
  24 #define IDLE_INTERVAL   5000
  25
  26 #define COMMON_STR      0x00
  27 #define COMMON_ENR      0x04
  28 #define COMMON_INTMSK   0x0c
  29
  30 #define REG_POSNEG      0x20
  31 #define REG_FILONOFF    0x28
  32 #define REG_THSCR       0x2c
  33 #define REG_THSSR       0x30
  34 #define REG_INTCTRL     0x34
  35
  36 /* THSCR */
  37 #define CPCTL   (1 << 12)
  38
  39 /* THSSR */
  40 #define CTEMP   0x3f
  41
  42 struct rcar_thermal_common {
  43         void __iomem *base;
  44         struct device *dev;
  45         struct list_head head;
  46         spinlock_t lock;
  47 };
  48
  49 struct rcar_thermal_chip {
  50         unsigned int use_of_thermal : 1;
  51         unsigned int has_filonoff : 1;
  52         unsigned int irq_per_ch : 1;
  53         unsigned int needs_suspend_resume : 1;
  54         unsigned int nirqs;
  55 };
  56
  57 static const struct rcar_thermal_chip rcar_thermal = {
  58         .use_of_thermal = 0,
  59         .has_filonoff = 1,
  60         .irq_per_ch = 0,
  61         .needs_suspend_resume = 0,
  62         .nirqs = 1,
  63 };
  64
  65 static const struct rcar_thermal_chip rcar_gen2_thermal = {
  66         .use_of_thermal = 1,
  67         .has_filonoff = 1,
  68         .irq_per_ch = 0,
  69         .needs_suspend_resume = 0,
  70         .nirqs = 1,
  71 };
  72
  73 static const struct rcar_thermal_chip rcar_gen3_thermal = {
  74         .use_of_thermal = 1,
  75         .has_filonoff = 0,
  76         .irq_per_ch = 1,
  77         .needs_suspend_resume = 1,
  78         /*
  79          * The Gen3 chip has 3 interrupts, but this driver uses only 2
  80          * interrupts to detect a temperature change, rise or fall.
  81          */
  82         .nirqs = 2,
  83 };
  84
  85 struct rcar_thermal_priv {
  86         void __iomem *base;
  87         struct rcar_thermal_common *common;
  88         struct thermal_zone_device *zone;
  89         const struct rcar_thermal_chip *chip;
  90         struct delayed_work work;
  91         struct mutex lock;
  92         struct list_head list;
  93         int id;
  94         u32 ctemp;
  95 };
  96
  97 #define rcar_thermal_for_each_priv(pos, common) \
  98         list_for_each_entry(pos, &common->head, list)
  99
 100 #define MCELSIUS(temp)                  ((temp) * 1000)
 101 #define rcar_zone_to_priv(zone)         ((zone)->devdata)
 102 #define rcar_priv_to_dev(priv)          ((priv)->common->dev)
 103 #define rcar_has_irq_support(priv)      ((priv)->common->base)
 104 #define rcar_id_to_shift(priv)          ((priv)->id * 8)
 105
 106 static const struct of_device_id rcar_thermal_dt_ids[] = {
 107         {
 108                 .compatible = "renesas,rcar-thermal",
 109                 .data = &rcar_thermal,
 110         },
 111         {
 112                 .compatible = "renesas,rcar-gen2-thermal",
 113                  .data = &rcar_gen2_thermal,
 114         },
 115         {
 116                 .compatible = "renesas,thermal-r8a77970",
 117                 .data = &rcar_gen3_thermal,
 118         },
 119         {
 120                 .compatible = "renesas,thermal-r8a77995",
 121                 .data = &rcar_gen3_thermal,
 122         },
 123         {},
 124 };
 125 MODULE_DEVICE_TABLE(of, rcar_thermal_dt_ids);
 126
 127 /*
 128  *              basic functions
 129  */
 130 #define rcar_thermal_common_read(c, r) \
 131         _rcar_thermal_common_read(c, COMMON_ ##r)
 132 static u32 _rcar_thermal_common_read(struct rcar_thermal_common *common,
 133                                      u32 reg)
 134 {
 135         return ioread32(common->base + reg);
 136 }
 137
 138 #define rcar_thermal_common_write(c, r, d) \
 139         _rcar_thermal_common_write(c, COMMON_ ##r, d)
 140 static void _rcar_thermal_common_write(struct rcar_thermal_common *common,
 141                                        u32 reg, u32 data)
 142 {
 143         iowrite32(data, common->base + reg);
 144 }
 145
 146 #define rcar_thermal_common_bset(c, r, m, d) \
 147         _rcar_thermal_common_bset(c, COMMON_ ##r, m, d)
 148 static void _rcar_thermal_common_bset(struct rcar_thermal_common *common,
 149                                       u32 reg, u32 mask, u32 data)
 150 {
 151         u32 val;
 152
 153         val = ioread32(common->base + reg);
 154         val &= ~mask;
 155         val |= (data & mask);
 156         iowrite32(val, common->base + reg);
 157 }
 158
 159 #define rcar_thermal_read(p, r) _rcar_thermal_read(p, REG_ ##r)
 160 static u32 _rcar_thermal_read(struct rcar_thermal_priv *priv, u32 reg)
 161 {
 162         return ioread32(priv->base + reg);
 163 }
 164
 165 #define rcar_thermal_write(p, r, d) _rcar_thermal_write(p, REG_ ##r, d)
 166 static void _rcar_thermal_write(struct rcar_thermal_priv *priv,
 167                                 u32 reg, u32 data)
 168 {
 169         iowrite32(data, priv->base + reg);
 170 }
 171
 172 #define rcar_thermal_bset(p, r, m, d) _rcar_thermal_bset(p, REG_ ##r, m, d)
 173 static void _rcar_thermal_bset(struct rcar_thermal_priv *priv, u32 reg,
 174                                u32 mask, u32 data)
 175 {
 176         u32 val;
 177
 178         val = ioread32(priv->base + reg);
 179         val &= ~mask;
 180         val |= (data & mask);
 181         iowrite32(val, priv->base + reg);
 182 }
 183
 184 /*
 185  *              zone device functions
 186  */
 187 static int rcar_thermal_update_temp(struct rcar_thermal_priv *priv)
 188 {
 189         struct device *dev = rcar_priv_to_dev(priv);
 190         int i;
 191         u32 ctemp, old, new;
 192         int ret = -EINVAL;
 193
 194         mutex_lock(&priv->lock);
 195
 196         /*
 197          * TSC decides a value of CPTAP automatically,
 198          * and this is the conditions which validate interrupt.
 199          */
 200         rcar_thermal_bset(priv, THSCR, CPCTL, CPCTL);
 201
 202         ctemp = 0;
 203         old = ~0;
 204         for (i = 0; i < 128; i++) {
 205                 /*
 206                  * we need to wait 300us after changing comparator offset
 207                  * to get stable temperature.
 208                  * see "Usage Notes" on datasheet
 209                  */
 210                 udelay(300);
 211
 212                 new = rcar_thermal_read(priv, THSSR) & CTEMP;
 213                 if (new == old) {
 214                         ctemp = new;
 215                         break;
 216                 }
 217                 old = new;
 218         }
 219
 220         if (!ctemp) {
 221                 dev_err(dev, "thermal sensor was broken\n");
 222                 goto err_out_unlock;
 223         }
 224
 225         /*
 226          * enable IRQ
 227          */
 228         if (rcar_has_irq_support(priv)) {
 229                 if (priv->chip->has_filonoff)
 230                         rcar_thermal_write(priv, FILONOFF, 0);
 231
 232                 /* enable Rising/Falling edge interrupt */
 233                 rcar_thermal_write(priv, POSNEG,  0x1);
 234                 rcar_thermal_write(priv, INTCTRL, (((ctemp - 0) << 8) |
 235                                                    ((ctemp - 1) << 0)));
 236         }
 237
 238         dev_dbg(dev, "thermal%d  %d -> %d\n", priv->id, priv->ctemp, ctemp);
 239
 240         priv->ctemp = ctemp;
 241         ret = 0;
 242 err_out_unlock:
 243         mutex_unlock(&priv->lock);
 244         return ret;
 245 }
 246
 247 static int rcar_thermal_get_current_temp(struct rcar_thermal_priv *priv,
 248                                          int *temp)
 249 {
 250         int tmp;
 251         int ret;
 252
 253         ret = rcar_thermal_update_temp(priv);
 254         if (ret < 0)
 255                 return ret;
 256
 257         mutex_lock(&priv->lock);
 258         tmp =  MCELSIUS((priv->ctemp * 5) - 65);
 259         mutex_unlock(&priv->lock);
 260
 261         if ((tmp < MCELSIUS(-45)) || (tmp > MCELSIUS(125))) {
 262                 struct device *dev = rcar_priv_to_dev(priv);
 263
 264                 dev_err(dev, "it couldn't measure temperature correctly\n");
 265                 return -EIO;
 266         }
 267
 268         *temp = tmp;
 269
 270         return 0;
 271 }
 272
 273 static int rcar_thermal_of_get_temp(void *data, int *temp)
 274 {
 275         struct rcar_thermal_priv *priv = data;
 276
 277         return rcar_thermal_get_current_temp(priv, temp);
 278 }
 279
 280 static int rcar_thermal_get_temp(struct thermal_zone_device *zone, int *temp)
 281 {
 282         struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone);
 283
 284         return rcar_thermal_get_current_temp(priv, temp);
 285 }
 286
 287 static int rcar_thermal_get_trip_type(struct thermal_zone_device *zone,
 288                                       int trip, enum thermal_trip_type *type)
 289 {
 290         struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone);
 291         struct device *dev = rcar_priv_to_dev(priv);
 292
 293         /* see rcar_thermal_get_temp() */
 294         switch (trip) {
 295         case 0: /* +90 <= temp */
 296                 *type = THERMAL_TRIP_CRITICAL;
 297                 break;
 298         default:
 299                 dev_err(dev, "rcar driver trip error\n");
 300                 return -EINVAL;
 301         }
 302
 303         return 0;
 304 }
 305
 306 static int rcar_thermal_get_trip_temp(struct thermal_zone_device *zone,
 307                                       int trip, int *temp)
 308 {
 309         struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone);
 310         struct device *dev = rcar_priv_to_dev(priv);
 311
 312         /* see rcar_thermal_get_temp() */
 313         switch (trip) {
 314         case 0: /* +90 <= temp */
 315                 *temp = MCELSIUS(90);
 316                 break;
 317         default:
 318                 dev_err(dev, "rcar driver trip error\n");
 319                 return -EINVAL;
 320         }
 321
 322         return 0;
 323 }
 324
 325 static int rcar_thermal_notify(struct thermal_zone_device *zone,
 326                                int trip, enum thermal_trip_type type)
 327 {
 328         struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone);
 329         struct device *dev = rcar_priv_to_dev(priv);
 330
 331         switch (type) {
 332         case THERMAL_TRIP_CRITICAL:
 333                 /* FIXME */
 334                 dev_warn(dev, "Thermal reached to critical temperature\n");
 335                 break;
 336         default:
 337                 break;
 338         }
 339
 340         return 0;
 341 }
 342
 343 static const struct thermal_zone_of_device_ops rcar_thermal_zone_of_ops = {
 344         .get_temp       = rcar_thermal_of_get_temp,
 345 };
 346
 347 static struct thermal_zone_device_ops rcar_thermal_zone_ops = {
 348         .get_temp       = rcar_thermal_get_temp,
 349         .get_trip_type  = rcar_thermal_get_trip_type,
 350         .get_trip_temp  = rcar_thermal_get_trip_temp,
 351         .notify         = rcar_thermal_notify,
 352 };
 353
 354 /*
 355  *              interrupt
 356  */
 357 #define rcar_thermal_irq_enable(p)      _rcar_thermal_irq_ctrl(p, 1)
 358 #define rcar_thermal_irq_disable(p)     _rcar_thermal_irq_ctrl(p, 0)
 359 static void _rcar_thermal_irq_ctrl(struct rcar_thermal_priv *priv, int enable)
 360 {
 361         struct rcar_thermal_common *common = priv->common;
 362         unsigned long flags;
 363         u32 mask = 0x3 << rcar_id_to_shift(priv); /* enable Rising/Falling */
 364
 365         if (!rcar_has_irq_support(priv))
 366                 return;
 367
 368         spin_lock_irqsave(&common->lock, flags);
 369
 370         rcar_thermal_common_bset(common, INTMSK, mask, enable ? 0 : mask);
 371
 372         spin_unlock_irqrestore(&common->lock, flags);
 373 }
 374
 375 static void rcar_thermal_work(struct work_struct *work)
 376 {
 377         struct rcar_thermal_priv *priv;
 378         int cctemp, nctemp;
 379         int ret;
 380
 381         priv = container_of(work, struct rcar_thermal_priv, work.work);
 382
 383         ret = rcar_thermal_get_current_temp(priv, &cctemp);
 384         if (ret < 0)
 385                 return;
 386
 387         ret = rcar_thermal_update_temp(priv);
 388         if (ret < 0)
 389                 return;
 390
 391         rcar_thermal_irq_enable(priv);
 392
 393         ret = rcar_thermal_get_current_temp(priv, &nctemp);
 394         if (ret < 0)
 395                 return;
 396
 397         if (nctemp != cctemp)
 398                 thermal_zone_device_update(priv->zone,
 399                                            THERMAL_EVENT_UNSPECIFIED);
 400 }
 401
 402 static u32 rcar_thermal_had_changed(struct rcar_thermal_priv *priv, u32 status)
 403 {
 404         struct device *dev = rcar_priv_to_dev(priv);
 405
 406         status = (status >> rcar_id_to_shift(priv)) & 0x3;
 407
 408         if (status) {
 409                 dev_dbg(dev, "thermal%d %s%s\n",
 410                         priv->id,
 411                         (status & 0x2) ? "Rising " : "",
 412                         (status & 0x1) ? "Falling" : "");
 413         }
 414
 415         return status;
 416 }
 417
 418 static irqreturn_t rcar_thermal_irq(int irq, void *data)
 419 {
 420         struct rcar_thermal_common *common = data;
 421         struct rcar_thermal_priv *priv;
 422         unsigned long flags;
 423         u32 status, mask;
 424
 425         spin_lock_irqsave(&common->lock, flags);
 426
 427         mask    = rcar_thermal_common_read(common, INTMSK);
 428         status  = rcar_thermal_common_read(common, STR);
 429         rcar_thermal_common_write(common, STR, 0x000F0F0F & mask);
 430
 431         spin_unlock_irqrestore(&common->lock, flags);
 432
 433         status = status & ~mask;
 434
 435         /*
 436          * check the status
 437          */
 438         rcar_thermal_for_each_priv(priv, common) {
 439                 if (rcar_thermal_had_changed(priv, status)) {
 440                         rcar_thermal_irq_disable(priv);
 441                         queue_delayed_work(system_freezable_wq, &priv->work,
 442                                            msecs_to_jiffies(300));
 443                 }
 444         }
 445
 446         return IRQ_HANDLED;
 447 }
 448
 449 /*
 450  *              platform functions
 451  */
 452 static int rcar_thermal_remove(struct platform_device *pdev)
 453 {
 454         struct rcar_thermal_common *common = platform_get_drvdata(pdev);
 455         struct device *dev = &pdev->dev;
 456         struct rcar_thermal_priv *priv;
 457
 458         rcar_thermal_for_each_priv(priv, common) {
 459                 rcar_thermal_irq_disable(priv);
 460                 cancel_delayed_work_sync(&priv->work);
 461                 if (priv->chip->use_of_thermal)
 462                         thermal_remove_hwmon_sysfs(priv->zone);
 463                 else
 464                         thermal_zone_device_unregister(priv->zone);
 465         }
 466
 467         pm_runtime_put(dev);
 468         pm_runtime_disable(dev);
 469
 470         return 0;
 471 }
 472
 473 static int rcar_thermal_probe(struct platform_device *pdev)
 474 {
 475         struct rcar_thermal_common *common;
 476         struct rcar_thermal_priv *priv;
 477         struct device *dev = &pdev->dev;
 478         struct resource *res, *irq;
 479         const struct rcar_thermal_chip *chip = of_device_get_match_data(dev);
 480         int mres = 0;
 481         int i;
 482         int ret = -ENODEV;
 483         int idle = IDLE_INTERVAL;
 484         u32 enr_bits = 0;
 485
 486         common = devm_kzalloc(dev, sizeof(*common), GFP_KERNEL);
 487         if (!common)
 488                 return -ENOMEM;
 489
 490         platform_set_drvdata(pdev, common);
 491
 492         INIT_LIST_HEAD(&common->head);
 493         spin_lock_init(&common->lock);
 494         common->dev = dev;
 495
 496         pm_runtime_enable(dev);
 497         pm_runtime_get_sync(dev);
 498
 499         for (i = 0; i < chip->nirqs; i++) {
 500                 irq = platform_get_resource(pdev, IORESOURCE_IRQ, i);
 501                 if (!irq)
 502                         continue;
 503                 if (!common->base) {
 504                         /*
 505                          * platform has IRQ support.
 506                          * Then, driver uses common registers
 507                          * rcar_has_irq_support() will be enabled
 508                          */
 509                         res = platform_get_resource(pdev, IORESOURCE_MEM,
 510                                                     mres++);
 511                         common->base = devm_ioremap_resource(dev, res);
 512                         if (IS_ERR(common->base))
 513                                 return PTR_ERR(common->base);
 514
 515                         idle = 0; /* polling delay is not needed */
 516                 }
 517
 518                 ret = devm_request_irq(dev, irq->start, rcar_thermal_irq,
 519                                        IRQF_SHARED, dev_name(dev), common);
 520                 if (ret) {
 521                         dev_err(dev, "irq request failed\n ");
 522                         goto error_unregister;
 523                 }
 524
 525                 /* update ENR bits */
 526                 if (chip->irq_per_ch)
 527                         enr_bits |= 1 << i;
 528         }
 529
 530         for (i = 0;; i++) {
 531                 res = platform_get_resource(pdev, IORESOURCE_MEM, mres++);
 532                 if (!res)
 533                         break;
 534
 535                 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 536                 if (!priv) {
 537                         ret = -ENOMEM;
 538                         goto error_unregister;
 539                 }
 540
 541                 priv->base = devm_ioremap_resource(dev, res);
 542                 if (IS_ERR(priv->base)) {
 543                         ret = PTR_ERR(priv->base);
 544                         goto error_unregister;
 545                 }
 546
 547                 priv->common = common;
 548                 priv->id = i;
 549                 priv->chip = chip;
 550                 mutex_init(&priv->lock);
 551                 INIT_LIST_HEAD(&priv->list);
 552                 INIT_DELAYED_WORK(&priv->work, rcar_thermal_work);
 553                 ret = rcar_thermal_update_temp(priv);
 554                 if (ret < 0)
 555                         goto error_unregister;
 556
 557                 if (chip->use_of_thermal)
 558                         priv->zone = devm_thermal_zone_of_sensor_register(
 559                                                 dev, i, priv,
 560                                                 &rcar_thermal_zone_of_ops);
 561                 else
 562                         priv->zone = thermal_zone_device_register(
 563                                                 "rcar_thermal",
 564                                                 1, 0, priv,
 565                                                 &rcar_thermal_zone_ops, NULL, 0,
 566                                                 idle);
 567                 if (IS_ERR(priv->zone)) {
 568                         dev_err(dev, "can't register thermal zone\n");
 569                         ret = PTR_ERR(priv->zone);
 570                         priv->zone = NULL;
 571                         goto error_unregister;
 572                 }
 573
 574                 if (chip->use_of_thermal) {
 575                         /*
 576                          * thermal_zone doesn't enable hwmon as default,
 577                          * but, enable it here to keep compatible
 578                          */
 579                         priv->zone->tzp->no_hwmon = false;
 580                         ret = thermal_add_hwmon_sysfs(priv->zone);
 581                         if (ret)
 582                                 goto error_unregister;
 583                 }
 584
 585                 rcar_thermal_irq_enable(priv);
 586
 587                 list_move_tail(&priv->list, &common->head);
 588
 589                 /* update ENR bits */
 590                 if (!chip->irq_per_ch)
 591                         enr_bits |= 3 << (i * 8);
 592         }
 593
 594         if (common->base && enr_bits)
 595                 rcar_thermal_common_write(common, ENR, enr_bits);
 596
 597         dev_info(dev, "%d sensor probed\n", i);
 598
 599         return 0;
 600
 601 error_unregister:
 602         rcar_thermal_remove(pdev);
 603
 604         return ret;
 605 }
 606
 607 #ifdef CONFIG_PM_SLEEP
 608 static int rcar_thermal_suspend(struct device *dev)
 609 {
 610         struct rcar_thermal_common *common = dev_get_drvdata(dev);
 611         struct rcar_thermal_priv *priv = list_first_entry(&common->head,
 612                                                           typeof(*priv), list);
 613
 614         if (priv->chip->needs_suspend_resume) {
 615                 rcar_thermal_common_write(common, ENR, 0);
 616                 rcar_thermal_irq_disable(priv);
 617                 rcar_thermal_bset(priv, THSCR, CPCTL, 0);
 618         }
 619
 620         return 0;
 621 }
 622
 623 static int rcar_thermal_resume(struct device *dev)
 624 {
 625         struct rcar_thermal_common *common = dev_get_drvdata(dev);
 626         struct rcar_thermal_priv *priv = list_first_entry(&common->head,
 627                                                           typeof(*priv), list);
 628         int ret;
 629
 630         if (priv->chip->needs_suspend_resume) {
 631                 ret = rcar_thermal_update_temp(priv);
 632                 if (ret < 0)
 633                         return ret;
 634                 rcar_thermal_irq_enable(priv);
 635                 rcar_thermal_common_write(common, ENR, 0x03);
 636         }
 637
 638         return 0;
 639 }
 640 #endif
 641
 642 static SIMPLE_DEV_PM_OPS(rcar_thermal_pm_ops, rcar_thermal_suspend,
 643                          rcar_thermal_resume);
 644
 645 static struct platform_driver rcar_thermal_driver = {
 646         .driver = {
 647                 .name   = "rcar_thermal",
 648                 .pm = &rcar_thermal_pm_ops,
 649                 .of_match_table = rcar_thermal_dt_ids,
 650         },
 651         .probe          = rcar_thermal_probe,
 652         .remove         = rcar_thermal_remove,
 653 };
 654 module_platform_driver(rcar_thermal_driver);
 655
 656 MODULE_LICENSE("GPL v2");
 657 MODULE_DESCRIPTION("R-Car THS/TSC thermal sensor driver");
 658 MODULE_AUTHOR("Kuninori Morimoto <[email protected]>");