sys/arm64/rockchip/rk_tsadc.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2019 Michal Meloun <mmel@FreeBSD.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 /*
  30  * Thermometer and thermal zones driver for RockChip SoCs.
  31  * Calibration data are taken from Linux, because this part of SoC
  32  * is undocumented in TRM.
  33  */
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/bus.h>
  38 #include <sys/gpio.h>
  39 #include <sys/kernel.h>
  40 #include <sys/module.h>
  41 #include <sys/malloc.h>
  42 #include <sys/rman.h>
  43 #include <sys/sysctl.h>
  44
  45 #include <machine/bus.h>
  46
  47 #include <dev/clk/clk.h>
  48 #include <dev/hwreset/hwreset.h>
  49 #include <dev/syscon/syscon.h>
  50 #include <dev/ofw/ofw_bus.h>
  51 #include <dev/ofw/ofw_bus_subr.h>
  52
  53 #include "syscon_if.h"
  54 #include "rk_tsadc_if.h"
  55
  56 /* Version of HW */
  57 #define TSADC_V2                                1
  58 #define TSADC_V3                                2
  59 #define TSADC_V7                                3
  60
  61 /* Global registers */
  62 #define TSADC_USER_CON                          0x000
  63 #define TSADC_AUTO_CON                          0x004
  64 #define  TSADC_AUTO_CON_POL_HI                          (1 << 8)
  65 #define  TSADC_AUTO_SRC_EN(x)                           (1 << (4 + (x)))
  66 #define  TSADC_AUTO_Q_SEL                               (1 << 1) /* V3 only */
  67 #define  TSADC_AUTO_CON_AUTO                            (1 << 0)
  68
  69 #define TSADC_INT_EN                            0x008
  70 #define  TSADC_INT_EN_2CRU_EN_SRC(x)                    (1 << (8 + (x)))
  71 #define  TSADC_INT_EN_2GPIO_EN_SRC(x)                   (1 << (4 + (x)))
  72 #define TSADC_INT_PD                            0x00c
  73 #define TSADC_DATA(x)                           (0x20 + (x) * 0x04)
  74 #define TSADC_COMP_INT(x)                       (0x30 + (x) * 0x04)
  75 #define  TSADC_COMP_INT_SRC_EN(x)                       (1 << (0 + (x)))
  76 #define TSADC_COMP_SHUT(x)                      (0x40 + (x) * 0x04)
  77 #define TSADC_HIGHT_INT_DEBOUNCE                0x060
  78 #define TSADC_HIGHT_TSHUT_DEBOUNCE              0x064
  79 #define TSADC_AUTO_PERIOD                       0x068
  80 #define TSADC_AUTO_PERIOD_HT                    0x06c
  81 #define TSADC_COMP0_LOW_INT                     0x080   /* V3 only */
  82 #define TSADC_COMP1_LOW_INT                     0x084   /* V3 only */
  83
  84 /* V3 GFR registers */
  85 #define GRF_SARADC_TESTBIT                      0x0e644
  86 #define  GRF_SARADC_TESTBIT_ON                          (0x10001 << 2)
  87 #define GRF_TSADC_TESTBIT_L                     0x0e648
  88 #define  GRF_TSADC_VCM_EN_L                             (0x10001 << 7)
  89 #define GRF_TSADC_TESTBIT_H                     0x0e64c
  90 #define  GRF_TSADC_VCM_EN_H                             (0x10001 << 7)
  91 #define  GRF_TSADC_TESTBIT_H_ON                         (0x10001 << 2)
  92
  93 /* V7 GRF register */
  94 #define GRF_TSADC_CON                           0x0600
  95 #define  GRF_TSADC_ANA_REG0                     (0x10001 << 0)
  96 #define  GRF_TSADC_ANA_REG1                     (0x10001 << 1)
  97 #define  GRF_TSADC_ANA_REG2                     (0x10001 << 2)
  98 #define  GRF_TSADC_TSEN                         (0x10001 << 8)
  99
 100 #define WR4(_sc, _r, _v)        bus_write_4((_sc)->mem_res, (_r), (_v))
 101 #define RD4(_sc, _r)            bus_read_4((_sc)->mem_res, (_r))
 102
 103 static struct sysctl_ctx_list tsadc_sysctl_ctx;
 104
 105 struct tsensor {
 106         char                    *name;
 107         int                     id;
 108         int                     channel;
 109 };
 110
 111 struct rk_calib_entry {
 112         uint32_t        raw;
 113         int             temp;
 114 };
 115
 116 struct tsadc_calib_info {
 117         struct rk_calib_entry   *table;
 118         int                     nentries;
 119 };
 120
 121 struct tsadc_conf {
 122         int                     version;
 123         int                     q_sel_ntc;
 124         int                     shutdown_temp;
 125         int                     shutdown_mode;
 126         int                     shutdown_pol;
 127         struct tsensor          *tsensors;
 128         int                     ntsensors;
 129         struct tsadc_calib_info calib_info;
 130 };
 131
 132 struct tsadc_softc {
 133         device_t                dev;
 134         struct resource         *mem_res;
 135         struct resource         *irq_res;
 136         void                    *irq_ih;
 137
 138         clk_t                   tsadc_clk;
 139         clk_t                   apb_pclk_clk;
 140         hwreset_array_t         hwreset;
 141         struct syscon           *grf;
 142
 143         struct tsadc_conf       *conf;
 144
 145         int                     shutdown_temp;
 146         int                     shutdown_mode;
 147         int                     shutdown_pol;
 148
 149         int                     alarm_temp;
 150 };
 151
 152 static struct rk_calib_entry rk3288_calib_data[] = {
 153         {3800, -40000},
 154         {3792, -35000},
 155         {3783, -30000},
 156         {3774, -25000},
 157         {3765, -20000},
 158         {3756, -15000},
 159         {3747, -10000},
 160         {3737, -5000},
 161         {3728, 0},
 162         {3718, 5000},
 163         {3708, 10000},
 164         {3698, 15000},
 165         {3688, 20000},
 166         {3678, 25000},
 167         {3667, 30000},
 168         {3656, 35000},
 169         {3645, 40000},
 170         {3634, 45000},
 171         {3623, 50000},
 172         {3611, 55000},
 173         {3600, 60000},
 174         {3588, 65000},
 175         {3575, 70000},
 176         {3563, 75000},
 177         {3550, 80000},
 178         {3537, 85000},
 179         {3524, 90000},
 180         {3510, 95000},
 181         {3496, 100000},
 182         {3482, 105000},
 183         {3467, 110000},
 184         {3452, 115000},
 185         {3437, 120000},
 186         {3421, 125000},
 187 };
 188
 189 struct tsensor rk3288_tsensors[] = {
 190         { .channel = 0, .id = 2, .name = "reserved"},
 191         { .channel = 1, .id = 0, .name = "CPU"},
 192         { .channel = 2, .id = 1, .name = "GPU"},
 193 };
 194
 195 struct tsadc_conf rk3288_tsadc_conf = {
 196         .version =              TSADC_V2,
 197         .q_sel_ntc =            0,
 198         .shutdown_temp =        95000,
 199         .shutdown_mode =        1, /* GPIO */
 200         .shutdown_pol =         0, /* Low  */
 201         .tsensors =             rk3288_tsensors,
 202         .ntsensors =            nitems(rk3288_tsensors),
 203         .calib_info =   {
 204                         .table = rk3288_calib_data,
 205                         .nentries = nitems(rk3288_calib_data),
 206         }
 207 };
 208
 209 static struct rk_calib_entry rk3328_calib_data[] = {
 210         {296, -40000},
 211         {304, -35000},
 212         {313, -30000},
 213         {331, -20000},
 214         {340, -15000},
 215         {349, -10000},
 216         {359, -5000},
 217         {368, 0},
 218         {378, 5000},
 219         {388, 10000},
 220         {398, 15000},
 221         {408, 20000},
 222         {418, 25000},
 223         {429, 30000},
 224         {440, 35000},
 225         {451, 40000},
 226         {462, 45000},
 227         {473, 50000},
 228         {485, 55000},
 229         {496, 60000},
 230         {508, 65000},
 231         {521, 70000},
 232         {533, 75000},
 233         {546, 80000},
 234         {559, 85000},
 235         {572, 90000},
 236         {586, 95000},
 237         {600, 100000},
 238         {614, 105000},
 239         {629, 110000},
 240         {644, 115000},
 241         {659, 120000},
 242         {675, 125000},
 243 };
 244
 245 static struct tsensor rk3328_tsensors[] = {
 246         { .channel = 0, .id = 0, .name = "CPU"},
 247 };
 248
 249 static struct tsadc_conf rk3328_tsadc_conf = {
 250         .version =              TSADC_V2,
 251         .q_sel_ntc =            1,
 252         .shutdown_temp =        95000,
 253         .shutdown_mode =        0, /* CRU */
 254         .shutdown_pol =         0, /* Low  */
 255         .tsensors =             rk3328_tsensors,
 256         .ntsensors =            nitems(rk3328_tsensors),
 257         .calib_info =   {
 258                         .table = rk3328_calib_data,
 259                         .nentries = nitems(rk3328_calib_data),
 260         }
 261 };
 262
 263 static struct rk_calib_entry rk3399_calib_data[] = {
 264         {402, -40000},
 265         {410, -35000},
 266         {419, -30000},
 267         {427, -25000},
 268         {436, -20000},
 269         {444, -15000},
 270         {453, -10000},
 271         {461, -5000},
 272         {470, 0},
 273         {478, 5000},
 274         {487, 10000},
 275         {496, 15000},
 276         {504, 20000},
 277         {513, 25000},
 278         {521, 30000},
 279         {530, 35000},
 280         {538, 40000},
 281         {547, 45000},
 282         {555, 50000},
 283         {564, 55000},
 284         {573, 60000},
 285         {581, 65000},
 286         {590, 70000},
 287         {599, 75000},
 288         {607, 80000},
 289         {616, 85000},
 290         {624, 90000},
 291         {633, 95000},
 292         {642, 100000},
 293         {650, 105000},
 294         {659, 110000},
 295         {668, 115000},
 296         {677, 120000},
 297         {685, 125000},
 298 };
 299
 300 static struct tsensor rk3399_tsensors[] = {
 301         { .channel = 0, .id = 0, .name = "CPU"},
 302         { .channel = 1, .id = 1, .name = "GPU"},
 303 };
 304
 305 static struct tsadc_conf rk3399_tsadc_conf = {
 306         .version =              TSADC_V3,
 307         .q_sel_ntc =            1,
 308         .shutdown_temp =        95000,
 309         .shutdown_mode =        1, /* GPIO */
 310         .shutdown_pol =         0, /* Low  */
 311         .tsensors =             rk3399_tsensors,
 312         .ntsensors =            nitems(rk3399_tsensors),
 313         .calib_info =   {
 314                         .table = rk3399_calib_data,
 315                         .nentries = nitems(rk3399_calib_data),
 316         }
 317 };
 318
 319 static struct rk_calib_entry rk3568_calib_data[] = {
 320         {0, -40000},
 321         {1584, -40000},
 322         {1620, -35000},
 323         {1652, -30000},
 324         {1688, -25000},
 325         {1720, -20000},
 326         {1756, -15000},
 327         {1788, -10000},
 328         {1824, -5000},
 329         {1856, 0},
 330         {1892, 5000},
 331         {1924, 10000},
 332         {1956, 15000},
 333         {1992, 20000},
 334         {2024, 25000},
 335         {2060, 30000},
 336         {2092, 35000},
 337         {2128, 40000},
 338         {2160, 45000},
 339         {2196, 50000},
 340         {2228, 55000},
 341         {2264, 60000},
 342         {2300, 65000},
 343         {2332, 70000},
 344         {2368, 75000},
 345         {2400, 80000},
 346         {2436, 85000},
 347         {2468, 90000},
 348         {2500, 95000},
 349         {2536, 100000},
 350         {2572, 105000},
 351         {2604, 110000},
 352         {2636, 115000},
 353         {2672, 120000},
 354         {2704, 125000},
 355 };
 356
 357 static struct tsensor rk3568_tsensors[] = {
 358         { .channel = 0, .id = 0, .name = "CPU"},
 359         { .channel = 1, .id = 1, .name = "GPU"},
 360 };
 361
 362 static struct tsadc_conf rk3568_tsadc_conf = {
 363         .version =              TSADC_V7,
 364         .q_sel_ntc =            1,
 365         .shutdown_temp =        95000,
 366         .shutdown_mode =        1, /* GPIO */
 367         .shutdown_pol =         0, /* Low  */
 368         .tsensors =             rk3568_tsensors,
 369         .ntsensors =            nitems(rk3568_tsensors),
 370         .calib_info =   {
 371                         .table = rk3568_calib_data,
 372                         .nentries = nitems(rk3568_calib_data),
 373         }
 374 };
 375
 376 static struct ofw_compat_data compat_data[] = {
 377         {"rockchip,rk3288-tsadc",       (uintptr_t)&rk3288_tsadc_conf},
 378         {"rockchip,rk3328-tsadc",       (uintptr_t)&rk3328_tsadc_conf},
 379         {"rockchip,rk3399-tsadc",       (uintptr_t)&rk3399_tsadc_conf},
 380         {"rockchip,rk3568-tsadc",       (uintptr_t)&rk3568_tsadc_conf},
 381         {NULL,          0}
 382 };
 383
 384 static uint32_t
 385 tsadc_temp_to_raw(struct tsadc_softc *sc, int temp)
 386 {
 387         struct rk_calib_entry *tbl;
 388         int denom, ntbl, raw, i;
 389
 390         tbl = sc->conf->calib_info.table;
 391         ntbl = sc->conf->calib_info.nentries;
 392
 393         if (temp <= tbl[0].temp)
 394                 return (tbl[0].raw);
 395
 396         if (temp >= tbl[ntbl - 1].temp)
 397                 return (tbl[ntbl - 1].raw);
 398
 399         for (i = 1; i < (ntbl - 1); i++) {
 400                 /* Exact match */
 401                 if (temp == tbl[i].temp)
 402                         return (tbl[i].raw);
 403                 if (temp < tbl[i].temp)
 404                         break;
 405         }
 406
 407         /*
 408         * Translated value is between i and i - 1 table entries.
 409         * Do linear interpolation for it.
 410         */
 411         raw = (int)tbl[i - 1].raw - (int)tbl[i].raw;
 412         raw *= temp - tbl[i - 1].temp;
 413         denom = tbl[i - 1].temp - tbl[i].temp;
 414         raw = tbl[i - 1].raw + raw / denom;
 415         return (raw);
 416 }
 417
 418 static int
 419 tsadc_raw_to_temp(struct tsadc_softc *sc, uint32_t raw)
 420 {
 421         struct rk_calib_entry *tbl;
 422         int denom, ntbl, temp, i;
 423         bool descending;
 424
 425         tbl = sc->conf->calib_info.table;
 426         ntbl = sc->conf->calib_info.nentries;
 427         descending = tbl[0].raw > tbl[1].raw;
 428
 429         if (descending) {
 430                 /* Raw column is in descending order. */
 431                 if (raw >= tbl[0].raw)
 432                         return (tbl[0].temp);
 433                 if (raw <= tbl[ntbl - 1].raw)
 434                         return (tbl[ntbl - 1].temp);
 435
 436                 for (i = ntbl - 2; i > 0; i--) {
 437                         /* Exact match */
 438                         if (raw == tbl[i].raw)
 439                                 return (tbl[i].temp);
 440                         if (raw < tbl[i].raw)
 441                                 break;
 442                 }
 443         } else {
 444                 /* Raw column is in ascending order. */
 445                 if (raw <= tbl[0].raw)
 446                         return (tbl[0].temp);
 447                 if (raw >= tbl[ntbl - 1].raw)
 448                         return (tbl[ntbl - 1].temp);
 449                 for (i = 1; i < (ntbl - 1); i++) {
 450                         /* Exact match */
 451                         if (raw == tbl[i].raw)
 452                                 return (tbl[i].temp);
 453                         if (raw < tbl[i].raw)
 454                                 break;
 455                 }
 456         }
 457
 458         /*
 459         * Translated value is between i and i - 1 table entries.
 460         * Do linear interpolation for it.
 461         */
 462         temp  = (int)tbl[i - 1].temp - (int)tbl[i].temp;
 463         temp *= raw - tbl[i - 1].raw;
 464         denom = tbl[i - 1].raw - tbl[i].raw;
 465         temp = tbl[i - 1].temp + temp / denom;
 466         return (temp);
 467 }
 468
 469 static void
 470 tsadc_init_tsensor(struct tsadc_softc *sc, struct tsensor *sensor)
 471 {
 472         uint32_t val;
 473
 474         /* Shutdown mode */
 475         val = RD4(sc, TSADC_INT_EN);
 476         if (sc->shutdown_mode != 0) {
 477                 /* Signal shutdown of GPIO pin */
 478                 val &= ~TSADC_INT_EN_2CRU_EN_SRC(sensor->channel);
 479                 val |= TSADC_INT_EN_2GPIO_EN_SRC(sensor->channel);
 480         } else {
 481                 val |= TSADC_INT_EN_2CRU_EN_SRC(sensor->channel);
 482                 val &= ~TSADC_INT_EN_2GPIO_EN_SRC(sensor->channel);
 483         }
 484         WR4(sc, TSADC_INT_EN, val);
 485
 486         /* Shutdown temperature */
 487         val =  tsadc_raw_to_temp(sc, sc->shutdown_temp);
 488         WR4(sc, TSADC_COMP_SHUT(sensor->channel), val);
 489         val = RD4(sc, TSADC_AUTO_CON);
 490         val |= TSADC_AUTO_SRC_EN(sensor->channel);
 491         WR4(sc, TSADC_AUTO_CON, val);
 492
 493         /* Alarm temperature */
 494         val =  tsadc_temp_to_raw(sc, sc->alarm_temp);
 495         WR4(sc, TSADC_COMP_INT(sensor->channel), val);
 496         val = RD4(sc, TSADC_INT_EN);
 497         val |= TSADC_COMP_INT_SRC_EN(sensor->channel);
 498         WR4(sc, TSADC_INT_EN, val);
 499 }
 500
 501 static void
 502 tsadc_init(struct tsadc_softc *sc)
 503 {
 504         uint32_t val;
 505
 506         /* Common part */
 507         val = 0;        /* XXX Is this right? */
 508         if (sc->shutdown_pol != 0)
 509                 val |= TSADC_AUTO_CON_POL_HI;
 510         else
 511                 val &= ~TSADC_AUTO_CON_POL_HI;
 512         if (sc->conf->q_sel_ntc)
 513                 val |= TSADC_AUTO_Q_SEL;
 514         WR4(sc, TSADC_AUTO_CON, val);
 515
 516         switch (sc->conf->version) {
 517         case TSADC_V2:
 518                 /* V2 init */
 519                 WR4(sc, TSADC_AUTO_PERIOD, 250);        /* 250 ms */
 520                 WR4(sc, TSADC_AUTO_PERIOD_HT, 50);      /*  50 ms */
 521                 WR4(sc, TSADC_HIGHT_INT_DEBOUNCE, 4);
 522                 WR4(sc, TSADC_HIGHT_TSHUT_DEBOUNCE, 4);
 523                 break;
 524         case TSADC_V3:
 525                 /* V3 init */
 526                 if (sc->grf == NULL) {
 527                         /* Errata: adjust interleave to working value */
 528                         WR4(sc, TSADC_USER_CON, 13 << 6);       /* 13 clks */
 529                 } else {
 530                         SYSCON_WRITE_4(sc->grf, GRF_TSADC_TESTBIT_L,
 531                             GRF_TSADC_VCM_EN_L);
 532                         SYSCON_WRITE_4(sc->grf, GRF_TSADC_TESTBIT_H,
 533                             GRF_TSADC_VCM_EN_H);
 534                         DELAY(30);  /* 15 usec min */
 535
 536                         SYSCON_WRITE_4(sc->grf, GRF_SARADC_TESTBIT,
 537                             GRF_SARADC_TESTBIT_ON);
 538                         SYSCON_WRITE_4(sc->grf, GRF_TSADC_TESTBIT_H,
 539                             GRF_TSADC_TESTBIT_H_ON);
 540                         DELAY(180);  /* 90 usec min */
 541                 }
 542                 WR4(sc, TSADC_AUTO_PERIOD, 1875);       /* 2.5 ms */
 543                 WR4(sc, TSADC_AUTO_PERIOD_HT, 1875);    /* 2.5 ms */
 544                 WR4(sc, TSADC_HIGHT_INT_DEBOUNCE, 4);
 545                 WR4(sc, TSADC_HIGHT_TSHUT_DEBOUNCE, 4);
 546                 break;
 547         case TSADC_V7:
 548                 /* V7 init */
 549                 WR4(sc, TSADC_USER_CON, 0xfc0);         /* 97us, at least 90us */
 550                 WR4(sc, TSADC_AUTO_PERIOD, 1622);       /* 2.5ms */
 551                 WR4(sc, TSADC_HIGHT_INT_DEBOUNCE, 4);
 552                 WR4(sc, TSADC_AUTO_PERIOD_HT, 1622);    /* 2.5ms */
 553                 WR4(sc, TSADC_HIGHT_TSHUT_DEBOUNCE, 4);
 554                 if (sc->grf) {
 555                         SYSCON_WRITE_4(sc->grf, GRF_TSADC_CON, GRF_TSADC_TSEN);
 556                         DELAY(15);                      /* 10 usec min */
 557                         SYSCON_WRITE_4(sc->grf, GRF_TSADC_CON,
 558                             GRF_TSADC_ANA_REG0);
 559                         SYSCON_WRITE_4(sc->grf, GRF_TSADC_CON,
 560                             GRF_TSADC_ANA_REG1);
 561                         SYSCON_WRITE_4(sc->grf, GRF_TSADC_CON,
 562                             GRF_TSADC_ANA_REG2);
 563                         DELAY(100);                     /* 90 usec min */
 564                 }
 565                 break;
 566         }
 567 }
 568
 569 static int
 570 tsadc_read_temp(struct tsadc_softc *sc, struct tsensor *sensor, int *temp)
 571 {
 572         uint32_t val;
 573
 574         val = RD4(sc, TSADC_DATA(sensor->channel));
 575         *temp = tsadc_raw_to_temp(sc, val);
 576
 577 #ifdef DEBUG
 578         device_printf(sc->dev, "%s: Sensor(id: %d, ch: %d), val: %d temp: %d\n",
 579             __func__, sensor->id, sensor->channel, val, *temp);
 580         device_printf(sc->dev, "%s: user_con=0x%08x auto_con=0x%08x "
 581             "comp_int=0x%08x comp_shut=0x%08x\n",
 582             __func__, RD4(sc, TSADC_USER_CON), RD4(sc, TSADC_AUTO_CON),
 583             RD4(sc, TSADC_COMP_INT(sensor->channel)),
 584             RD4(sc, TSADC_COMP_SHUT(sensor->channel)));
 585 #endif
 586         return (0);
 587 }
 588
 589 static int
 590 tsadc_get_temp(device_t dev, device_t cdev, uintptr_t id, int *val)
 591 {
 592         struct tsadc_softc *sc;
 593         int i, rv;
 594
 595         sc = device_get_softc(dev);
 596
 597         if (id >= sc->conf->ntsensors)
 598                 return (ERANGE);
 599
 600         for (i = 0; i < sc->conf->ntsensors; i++) {
 601                 if (sc->conf->tsensors->id == id) {
 602                         rv =tsadc_read_temp(sc, sc->conf->tsensors + id, val);
 603                         return (rv);
 604                 }
 605         }
 606         return (ERANGE);
 607 }
 608
 609 static int
 610 tsadc_sysctl_temperature(SYSCTL_HANDLER_ARGS)
 611 {
 612         struct tsadc_softc *sc;
 613         int val;
 614         int rv;
 615         int id;
 616
 617         /* Write request */
 618         if (req->newptr != NULL)
 619                 return (EINVAL);
 620
 621         sc = arg1;
 622         id = arg2;
 623
 624         if (id >= sc->conf->ntsensors)
 625                 return (ERANGE);
 626         rv =  tsadc_read_temp(sc, sc->conf->tsensors + id, &val);
 627         if (rv != 0)
 628                 return (rv);
 629
 630         val = val / 100;
 631         val +=  2731;
 632         rv = sysctl_handle_int(oidp, &val, 0, req);
 633         return (rv);
 634 }
 635
 636 static int
 637 tsadc_init_sysctl(struct tsadc_softc *sc)
 638 {
 639         int i;
 640         struct sysctl_oid *oid, *tmp;
 641
 642         sysctl_ctx_init(&tsadc_sysctl_ctx);
 643         /* create node for hw.temp */
 644         oid = SYSCTL_ADD_NODE(&tsadc_sysctl_ctx,
 645             SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO, "temperature",
 646             CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
 647         if (oid == NULL)
 648                 return (ENXIO);
 649
 650         /* Add sensors */
 651         for (i = sc->conf->ntsensors  - 1; i >= 0; i--) {
 652                 tmp = SYSCTL_ADD_PROC(&tsadc_sysctl_ctx,
 653                     SYSCTL_CHILDREN(oid), OID_AUTO, sc->conf->tsensors[i].name,
 654                     CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, i,
 655                     tsadc_sysctl_temperature, "IK", "SoC Temperature");
 656                 if (tmp == NULL)
 657                         return (ENXIO);
 658         }
 659
 660         return (0);
 661 }
 662
 663 static int
 664 tsadc_intr(void *arg)
 665 {
 666         struct tsadc_softc *sc;
 667         uint32_t val;
 668
 669         sc = (struct tsadc_softc *)arg;
 670
 671         val = RD4(sc, TSADC_INT_PD);
 672         WR4(sc, TSADC_INT_PD, val);
 673
 674         /* XXX Handle shutdown and alarm interrupts. */
 675         if (val & 0x00F0) {
 676                 device_printf(sc->dev, "Alarm: device temperature "
 677                     "is above of shutdown level.\n");
 678         } else if (val & 0x000F) {
 679                 device_printf(sc->dev, "Alarm: device temperature "
 680                     "is above of alarm level.\n");
 681         }
 682         return (FILTER_HANDLED);
 683 }
 684
 685 static int
 686 tsadc_probe(device_t dev)
 687 {
 688
 689         if (!ofw_bus_status_okay(dev))
 690                 return (ENXIO);
 691
 692         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
 693                 return (ENXIO);
 694
 695         device_set_desc(dev, "RockChip temperature sensors");
 696         return (BUS_PROBE_DEFAULT);
 697 }
 698
 699 static int
 700 tsadc_attach(device_t dev)
 701 {
 702         struct tsadc_softc *sc;
 703         phandle_t node;
 704         uint32_t val;
 705         int i, rid, rv;
 706
 707         sc = device_get_softc(dev);
 708         sc->dev = dev;
 709         node = ofw_bus_get_node(sc->dev);
 710         sc->conf = (struct tsadc_conf *)
 711             ofw_bus_search_compatible(dev, compat_data)->ocd_data;
 712         sc->alarm_temp = 90000;
 713
 714         rid = 0;
 715         sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
 716             RF_ACTIVE);
 717         if (sc->mem_res == NULL) {
 718                 device_printf(dev, "Cannot allocate memory resources\n");
 719                 goto fail;
 720         }
 721
 722         rid = 0;
 723         sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE);
 724         if (sc->irq_res == NULL) {
 725                 device_printf(dev, "Cannot allocate IRQ resources\n");
 726                 goto fail;
 727         }
 728
 729         if ((bus_setup_intr(dev, sc->irq_res, INTR_TYPE_MISC | INTR_MPSAFE,
 730             tsadc_intr, NULL, sc, &sc->irq_ih))) {
 731                 device_printf(dev,
 732                     "WARNING: unable to register interrupt handler\n");
 733                 goto fail;
 734         }
 735
 736         /* FDT resources */
 737         rv = hwreset_array_get_ofw(dev, 0, &sc->hwreset);
 738         if (rv != 0) {
 739                 device_printf(dev, "Cannot get resets\n");
 740                 goto fail;
 741         }
 742         rv = clk_get_by_ofw_name(dev, 0, "tsadc", &sc->tsadc_clk);
 743         if (rv != 0) {
 744                 device_printf(dev, "Cannot get 'tsadc' clock: %d\n", rv);
 745                 goto fail;
 746         }
 747         rv = clk_get_by_ofw_name(dev, 0, "apb_pclk", &sc->apb_pclk_clk);
 748         if (rv != 0) {
 749                 device_printf(dev, "Cannot get 'apb_pclk' clock: %d\n", rv);
 750                 goto fail;
 751         }
 752
 753         /* grf is optional */
 754         rv = syscon_get_by_ofw_property(dev, node, "rockchip,grf", &sc->grf);
 755         if (rv != 0 && rv != ENOENT) {
 756                 device_printf(dev, "Cannot get 'grf' syscon: %d\n", rv);
 757                 goto fail;
 758         }
 759
 760         rv = OF_getencprop(node, "rockchip,hw-tshut-temp",
 761             &sc->shutdown_temp, sizeof(sc->shutdown_temp));
 762         if (rv <= 0)
 763                 sc->shutdown_temp = sc->conf->shutdown_temp;
 764
 765         rv = OF_getencprop(node, "rockchip,hw-tshut-mode",
 766             &sc->shutdown_mode, sizeof(sc->shutdown_mode));
 767         if (rv <= 0)
 768                 sc->shutdown_mode = sc->conf->shutdown_mode;
 769
 770         rv = OF_getencprop(node, "rockchip,hw-tshut-polarity",
 771             &sc->shutdown_pol, sizeof(sc->shutdown_pol));
 772         if (rv <= 0)
 773                 sc->shutdown_pol = sc->conf->shutdown_pol;
 774
 775         /* Wakeup controller */
 776         rv = hwreset_array_assert(sc->hwreset);
 777         if (rv != 0) {
 778                 device_printf(dev, "Cannot assert reset\n");
 779                 goto fail;
 780         }
 781
 782         /* Set the assigned clocks parent and freq */
 783         rv = clk_set_assigned(sc->dev, node);
 784         if (rv != 0 && rv != ENOENT) {
 785                 device_printf(dev, "clk_set_assigned failed\n");
 786                 goto fail;
 787         }
 788
 789         rv = clk_enable(sc->tsadc_clk);
 790         if (rv != 0) {
 791                 device_printf(dev, "Cannot enable 'tsadc_clk' clock: %d\n", rv);
 792                 goto fail;
 793         }
 794         rv = clk_enable(sc->apb_pclk_clk);
 795         if (rv != 0) {
 796                 device_printf(dev, "Cannot enable 'apb_pclk' clock: %d\n", rv);
 797                 goto fail;
 798         }
 799         rv = hwreset_array_deassert(sc->hwreset);
 800         if (rv != 0) {
 801                 device_printf(dev, "Cannot deassert reset\n");
 802                 goto fail;
 803         }
 804
 805         tsadc_init(sc);
 806         for (i = 0; i < sc->conf->ntsensors; i++)
 807                 tsadc_init_tsensor(sc, sc->conf->tsensors + i);
 808
 809         /* Enable auto mode */
 810         val = RD4(sc, TSADC_AUTO_CON);
 811         val |= TSADC_AUTO_CON_AUTO;
 812         WR4(sc, TSADC_AUTO_CON, val);
 813
 814         rv = tsadc_init_sysctl(sc);
 815         if (rv != 0) {
 816                 device_printf(sc->dev, "Cannot initialize sysctls\n");
 817                 goto fail_sysctl;
 818         }
 819
 820         OF_device_register_xref(OF_xref_from_node(node), dev);
 821         return (bus_generic_attach(dev));
 822
 823 fail_sysctl:
 824         sysctl_ctx_free(&tsadc_sysctl_ctx);
 825 fail:
 826         if (sc->irq_ih != NULL)
 827                 bus_teardown_intr(dev, sc->irq_res, sc->irq_ih);
 828         if (sc->tsadc_clk != NULL)
 829                 clk_release(sc->tsadc_clk);
 830         if (sc->apb_pclk_clk != NULL)
 831                 clk_release(sc->apb_pclk_clk);
 832         if (sc->hwreset != NULL)
 833                 hwreset_array_release(sc->hwreset);
 834         if (sc->irq_res != NULL)
 835                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res);
 836         if (sc->mem_res != NULL)
 837                 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
 838
 839         return (ENXIO);
 840 }
 841
 842 static int
 843 tsadc_detach(device_t dev)
 844 {
 845         struct tsadc_softc *sc;
 846         sc = device_get_softc(dev);
 847
 848         if (sc->irq_ih != NULL)
 849                 bus_teardown_intr(dev, sc->irq_res, sc->irq_ih);
 850         sysctl_ctx_free(&tsadc_sysctl_ctx);
 851         if (sc->tsadc_clk != NULL)
 852                 clk_release(sc->tsadc_clk);
 853         if (sc->apb_pclk_clk != NULL)
 854                 clk_release(sc->apb_pclk_clk);
 855         if (sc->hwreset != NULL)
 856                 hwreset_array_release(sc->hwreset);
 857         if (sc->irq_res != NULL)
 858                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res);
 859         if (sc->mem_res != NULL)
 860                 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
 861
 862         return (ENXIO);
 863 }
 864
 865 static device_method_t rk_tsadc_methods[] = {
 866         /* Device interface */
 867         DEVMETHOD(device_probe,                 tsadc_probe),
 868         DEVMETHOD(device_attach,                tsadc_attach),
 869         DEVMETHOD(device_detach,                tsadc_detach),
 870
 871         /* TSADC interface */
 872         DEVMETHOD(rk_tsadc_get_temperature,     tsadc_get_temp),
 873
 874         DEVMETHOD_END
 875 };
 876
 877 static DEFINE_CLASS_0(rk_tsadc, rk_tsadc_driver, rk_tsadc_methods,
 878     sizeof(struct tsadc_softc));
 879 EARLY_DRIVER_MODULE(rk_tsadc, simplebus, rk_tsadc_driver, NULL, NULL,
 880     BUS_PASS_TIMER + BUS_PASS_ORDER_LAST);