linux/drivers/thermal/ti-soc-thermal/ti-bandgap.c
<<
>>
Prefs
   1/*
   2 * TI Bandgap temperature sensor driver
   3 *
   4 * Copyright (C) 2011-2012 Texas Instruments Incorporated - http://www.ti.com/
   5 * Author: J Keerthy <j-keerthy@ti.com>
   6 * Author: Moiz Sonasath <m-sonasath@ti.com>
   7 * Couple of fixes, DT and MFD adaptation:
   8 *   Eduardo Valentin <eduardo.valentin@ti.com>
   9 *
  10 * This program is free software; you can redistribute it and/or
  11 * modify it under the terms of the GNU General Public License
  12 * version 2 as published by the Free Software Foundation.
  13 *
  14 * This program is distributed in the hope that it will be useful, but
  15 * WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 * General Public License for more details.
  18 *
  19 * You should have received a copy of the GNU General Public License
  20 * along with this program; if not, write to the Free Software
  21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  22 * 02110-1301 USA
  23 *
  24 */
  25
  26#include <linux/module.h>
  27#include <linux/export.h>
  28#include <linux/init.h>
  29#include <linux/kernel.h>
  30#include <linux/interrupt.h>
  31#include <linux/clk.h>
  32#include <linux/gpio.h>
  33#include <linux/platform_device.h>
  34#include <linux/err.h>
  35#include <linux/types.h>
  36#include <linux/spinlock.h>
  37#include <linux/reboot.h>
  38#include <linux/of_device.h>
  39#include <linux/of_platform.h>
  40#include <linux/of_irq.h>
  41#include <linux/of_gpio.h>
  42#include <linux/io.h>
  43
  44#include "ti-bandgap.h"
  45
  46static int ti_bandgap_force_single_read(struct ti_bandgap *bgp, int id);
  47
  48/***   Helper functions to access registers and their bitfields   ***/
  49
  50/**
  51 * ti_bandgap_readl() - simple read helper function
  52 * @bgp: pointer to ti_bandgap structure
  53 * @reg: desired register (offset) to be read
  54 *
  55 * Helper function to read bandgap registers. It uses the io remapped area.
  56 * Return: the register value.
  57 */
  58static u32 ti_bandgap_readl(struct ti_bandgap *bgp, u32 reg)
  59{
  60        return readl(bgp->base + reg);
  61}
  62
  63/**
  64 * ti_bandgap_writel() - simple write helper function
  65 * @bgp: pointer to ti_bandgap structure
  66 * @val: desired register value to be written
  67 * @reg: desired register (offset) to be written
  68 *
  69 * Helper function to write bandgap registers. It uses the io remapped area.
  70 */
  71static void ti_bandgap_writel(struct ti_bandgap *bgp, u32 val, u32 reg)
  72{
  73        writel(val, bgp->base + reg);
  74}
  75
  76/**
  77 * DOC: macro to update bits.
  78 *
  79 * RMW_BITS() - used to read, modify and update bandgap bitfields.
  80 *            The value passed will be shifted.
  81 */
  82#define RMW_BITS(bgp, id, reg, mask, val)                       \
  83do {                                                            \
  84        struct temp_sensor_registers *t;                        \
  85        u32 r;                                                  \
  86                                                                \
  87        t = bgp->conf->sensors[(id)].registers;         \
  88        r = ti_bandgap_readl(bgp, t->reg);                      \
  89        r &= ~t->mask;                                          \
  90        r |= (val) << __ffs(t->mask);                           \
  91        ti_bandgap_writel(bgp, r, t->reg);                      \
  92} while (0)
  93
  94/***   Basic helper functions   ***/
  95
  96/**
  97 * ti_bandgap_power() - controls the power state of a bandgap device
  98 * @bgp: pointer to ti_bandgap structure
  99 * @on: desired power state (1 - on, 0 - off)
 100 *
 101 * Used to power on/off a bandgap device instance. Only used on those
 102 * that features tempsoff bit.
 103 *
 104 * Return: 0 on success, -ENOTSUPP if tempsoff is not supported.
 105 */
 106static int ti_bandgap_power(struct ti_bandgap *bgp, bool on)
 107{
 108        int i;
 109
 110        if (!TI_BANDGAP_HAS(bgp, POWER_SWITCH))
 111                return -ENOTSUPP;
 112
 113        for (i = 0; i < bgp->conf->sensor_count; i++)
 114                /* active on 0 */
 115                RMW_BITS(bgp, i, temp_sensor_ctrl, bgap_tempsoff_mask, !on);
 116        return 0;
 117}
 118
 119/**
 120 * ti_errata814_bandgap_read_temp() - helper function to read dra7 sensor temperature
 121 * @bgp: pointer to ti_bandgap structure
 122 * @reg: desired register (offset) to be read
 123 *
 124 * Function to read dra7 bandgap sensor temperature. This is done separately
 125 * so as to workaround the errata "Bandgap Temperature read Dtemp can be
 126 * corrupted" - Errata ID: i814".
 127 * Read accesses to registers listed below can be corrupted due to incorrect
 128 * resynchronization between clock domains.
 129 * Read access to registers below can be corrupted :
 130 * CTRL_CORE_DTEMP_MPU/GPU/CORE/DSPEVE/IVA_n (n = 0 to 4)
 131 * CTRL_CORE_TEMP_SENSOR_MPU/GPU/CORE/DSPEVE/IVA_n
 132 *
 133 * Return: the register value.
 134 */
 135static u32 ti_errata814_bandgap_read_temp(struct ti_bandgap *bgp,  u32 reg)
 136{
 137        u32 val1, val2;
 138
 139        val1 = ti_bandgap_readl(bgp, reg);
 140        val2 = ti_bandgap_readl(bgp, reg);
 141
 142        /* If both times we read the same value then that is right */
 143        if (val1 == val2)
 144                return val1;
 145
 146        /* if val1 and val2 are different read it third time */
 147        return ti_bandgap_readl(bgp, reg);
 148}
 149
 150/**
 151 * ti_bandgap_read_temp() - helper function to read sensor temperature
 152 * @bgp: pointer to ti_bandgap structure
 153 * @id: bandgap sensor id
 154 *
 155 * Function to concentrate the steps to read sensor temperature register.
 156 * This function is desired because, depending on bandgap device version,
 157 * it might be needed to freeze the bandgap state machine, before fetching
 158 * the register value.
 159 *
 160 * Return: temperature in ADC values.
 161 */
 162static u32 ti_bandgap_read_temp(struct ti_bandgap *bgp, int id)
 163{
 164        struct temp_sensor_registers *tsr;
 165        u32 temp, reg;
 166
 167        tsr = bgp->conf->sensors[id].registers;
 168        reg = tsr->temp_sensor_ctrl;
 169
 170        if (TI_BANDGAP_HAS(bgp, FREEZE_BIT)) {
 171                RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 1);
 172                /*
 173                 * In case we cannot read from cur_dtemp / dtemp_0,
 174                 * then we read from the last valid temp read
 175                 */
 176                reg = tsr->ctrl_dtemp_1;
 177        }
 178
 179        /* read temperature */
 180        if (TI_BANDGAP_HAS(bgp, ERRATA_814))
 181                temp = ti_errata814_bandgap_read_temp(bgp, reg);
 182        else
 183                temp = ti_bandgap_readl(bgp, reg);
 184
 185        temp &= tsr->bgap_dtemp_mask;
 186
 187        if (TI_BANDGAP_HAS(bgp, FREEZE_BIT))
 188                RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 0);
 189
 190        return temp;
 191}
 192
 193/***   IRQ handlers   ***/
 194
 195/**
 196 * ti_bandgap_talert_irq_handler() - handles Temperature alert IRQs
 197 * @irq: IRQ number
 198 * @data: private data (struct ti_bandgap *)
 199 *
 200 * This is the Talert handler. Use it only if bandgap device features
 201 * HAS(TALERT). This handler goes over all sensors and checks their
 202 * conditions and acts accordingly. In case there are events pending,
 203 * it will reset the event mask to wait for the opposite event (next event).
 204 * Every time there is a new event, it will be reported to thermal layer.
 205 *
 206 * Return: IRQ_HANDLED
 207 */
 208static irqreturn_t ti_bandgap_talert_irq_handler(int irq, void *data)
 209{
 210        struct ti_bandgap *bgp = data;
 211        struct temp_sensor_registers *tsr;
 212        u32 t_hot = 0, t_cold = 0, ctrl;
 213        int i;
 214
 215        spin_lock(&bgp->lock);
 216        for (i = 0; i < bgp->conf->sensor_count; i++) {
 217                tsr = bgp->conf->sensors[i].registers;
 218                ctrl = ti_bandgap_readl(bgp, tsr->bgap_status);
 219
 220                /* Read the status of t_hot */
 221                t_hot = ctrl & tsr->status_hot_mask;
 222
 223                /* Read the status of t_cold */
 224                t_cold = ctrl & tsr->status_cold_mask;
 225
 226                if (!t_cold && !t_hot)
 227                        continue;
 228
 229                ctrl = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
 230                /*
 231                 * One TALERT interrupt: Two sources
 232                 * If the interrupt is due to t_hot then mask t_hot and
 233                 * and unmask t_cold else mask t_cold and unmask t_hot
 234                 */
 235                if (t_hot) {
 236                        ctrl &= ~tsr->mask_hot_mask;
 237                        ctrl |= tsr->mask_cold_mask;
 238                } else if (t_cold) {
 239                        ctrl &= ~tsr->mask_cold_mask;
 240                        ctrl |= tsr->mask_hot_mask;
 241                }
 242
 243                ti_bandgap_writel(bgp, ctrl, tsr->bgap_mask_ctrl);
 244
 245                dev_dbg(bgp->dev,
 246                        "%s: IRQ from %s sensor: hotevent %d coldevent %d\n",
 247                        __func__, bgp->conf->sensors[i].domain,
 248                        t_hot, t_cold);
 249
 250                /* report temperature to whom may concern */
 251                if (bgp->conf->report_temperature)
 252                        bgp->conf->report_temperature(bgp, i);
 253        }
 254        spin_unlock(&bgp->lock);
 255
 256        return IRQ_HANDLED;
 257}
 258
 259/**
 260 * ti_bandgap_tshut_irq_handler() - handles Temperature shutdown signal
 261 * @irq: IRQ number
 262 * @data: private data (unused)
 263 *
 264 * This is the Tshut handler. Use it only if bandgap device features
 265 * HAS(TSHUT). If any sensor fires the Tshut signal, we simply shutdown
 266 * the system.
 267 *
 268 * Return: IRQ_HANDLED
 269 */
 270static irqreturn_t ti_bandgap_tshut_irq_handler(int irq, void *data)
 271{
 272        pr_emerg("%s: TSHUT temperature reached. Needs shut down...\n",
 273                 __func__);
 274
 275        orderly_poweroff(true);
 276
 277        return IRQ_HANDLED;
 278}
 279
 280/***   Helper functions which manipulate conversion ADC <-> mi Celsius   ***/
 281
 282/**
 283 * ti_bandgap_adc_to_mcelsius() - converts an ADC value to mCelsius scale
 284 * @bgp: struct ti_bandgap pointer
 285 * @adc_val: value in ADC representation
 286 * @t: address where to write the resulting temperature in mCelsius
 287 *
 288 * Simple conversion from ADC representation to mCelsius. In case the ADC value
 289 * is out of the ADC conv table range, it returns -ERANGE, 0 on success.
 290 * The conversion table is indexed by the ADC values.
 291 *
 292 * Return: 0 if conversion was successful, else -ERANGE in case the @adc_val
 293 * argument is out of the ADC conv table range.
 294 */
 295static
 296int ti_bandgap_adc_to_mcelsius(struct ti_bandgap *bgp, int adc_val, int *t)
 297{
 298        const struct ti_bandgap_data *conf = bgp->conf;
 299
 300        /* look up for temperature in the table and return the temperature */
 301        if (adc_val < conf->adc_start_val || adc_val > conf->adc_end_val)
 302                return -ERANGE;
 303
 304        *t = bgp->conf->conv_table[adc_val - conf->adc_start_val];
 305        return 0;
 306}
 307
 308/**
 309 * ti_bandgap_mcelsius_to_adc() - converts a mCelsius value to ADC scale
 310 * @bgp: struct ti_bandgap pointer
 311 * @temp: value in mCelsius
 312 * @adc: address where to write the resulting temperature in ADC representation
 313 *
 314 * Simple conversion from mCelsius to ADC values. In case the temp value
 315 * is out of the ADC conv table range, it returns -ERANGE, 0 on success.
 316 * The conversion table is indexed by the ADC values.
 317 *
 318 * Return: 0 if conversion was successful, else -ERANGE in case the @temp
 319 * argument is out of the ADC conv table range.
 320 */
 321static
 322int ti_bandgap_mcelsius_to_adc(struct ti_bandgap *bgp, long temp, int *adc)
 323{
 324        const struct ti_bandgap_data *conf = bgp->conf;
 325        const int *conv_table = bgp->conf->conv_table;
 326        int high, low, mid;
 327
 328        low = 0;
 329        high = conf->adc_end_val - conf->adc_start_val;
 330        mid = (high + low) / 2;
 331
 332        if (temp < conv_table[low] || temp > conv_table[high])
 333                return -ERANGE;
 334
 335        while (low < high) {
 336                if (temp < conv_table[mid])
 337                        high = mid - 1;
 338                else
 339                        low = mid + 1;
 340                mid = (low + high) / 2;
 341        }
 342
 343        *adc = conf->adc_start_val + low;
 344        return 0;
 345}
 346
 347/**
 348 * ti_bandgap_add_hyst() - add hysteresis (in mCelsius) to an ADC value
 349 * @bgp: struct ti_bandgap pointer
 350 * @adc_val: temperature value in ADC representation
 351 * @hyst_val: hysteresis value in mCelsius
 352 * @sum: address where to write the resulting temperature (in ADC scale)
 353 *
 354 * Adds an hysteresis value (in mCelsius) to a ADC temperature value.
 355 *
 356 * Return: 0 on success, -ERANGE otherwise.
 357 */
 358static
 359int ti_bandgap_add_hyst(struct ti_bandgap *bgp, int adc_val, int hyst_val,
 360                        u32 *sum)
 361{
 362        int temp, ret;
 363
 364        /*
 365         * Need to add in the mcelsius domain, so we have a temperature
 366         * the conv_table range
 367         */
 368        ret = ti_bandgap_adc_to_mcelsius(bgp, adc_val, &temp);
 369        if (ret < 0)
 370                return ret;
 371
 372        temp += hyst_val;
 373
 374        ret = ti_bandgap_mcelsius_to_adc(bgp, temp, sum);
 375        return ret;
 376}
 377
 378/***   Helper functions handling device Alert/Shutdown signals   ***/
 379
 380/**
 381 * ti_bandgap_unmask_interrupts() - unmasks the events of thot & tcold
 382 * @bgp: struct ti_bandgap pointer
 383 * @id: bandgap sensor id
 384 * @t_hot: hot temperature value to trigger alert signal
 385 * @t_cold: cold temperature value to trigger alert signal
 386 *
 387 * Checks the requested t_hot and t_cold values and configures the IRQ event
 388 * masks accordingly. Call this function only if bandgap features HAS(TALERT).
 389 */
 390static void ti_bandgap_unmask_interrupts(struct ti_bandgap *bgp, int id,
 391                                         u32 t_hot, u32 t_cold)
 392{
 393        struct temp_sensor_registers *tsr;
 394        u32 temp, reg_val;
 395
 396        /* Read the current on die temperature */
 397        temp = ti_bandgap_read_temp(bgp, id);
 398
 399        tsr = bgp->conf->sensors[id].registers;
 400        reg_val = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
 401
 402        if (temp < t_hot)
 403                reg_val |= tsr->mask_hot_mask;
 404        else
 405                reg_val &= ~tsr->mask_hot_mask;
 406
 407        if (t_cold < temp)
 408                reg_val |= tsr->mask_cold_mask;
 409        else
 410                reg_val &= ~tsr->mask_cold_mask;
 411        ti_bandgap_writel(bgp, reg_val, tsr->bgap_mask_ctrl);
 412}
 413
 414/**
 415 * ti_bandgap_update_alert_threshold() - sequence to update thresholds
 416 * @bgp: struct ti_bandgap pointer
 417 * @id: bandgap sensor id
 418 * @val: value (ADC) of a new threshold
 419 * @hot: desired threshold to be updated. true if threshold hot, false if
 420 *       threshold cold
 421 *
 422 * It will program the required thresholds (hot and cold) for TALERT signal.
 423 * This function can be used to update t_hot or t_cold, depending on @hot value.
 424 * It checks the resulting t_hot and t_cold values, based on the new passed @val
 425 * and configures the thresholds so that t_hot is always greater than t_cold.
 426 * Call this function only if bandgap features HAS(TALERT).
 427 *
 428 * Return: 0 if no error, else corresponding error
 429 */
 430static int ti_bandgap_update_alert_threshold(struct ti_bandgap *bgp, int id,
 431                                             int val, bool hot)
 432{
 433        struct temp_sensor_data *ts_data = bgp->conf->sensors[id].ts_data;
 434        struct temp_sensor_registers *tsr;
 435        u32 thresh_val, reg_val, t_hot, t_cold, ctrl;
 436        int err = 0;
 437
 438        tsr = bgp->conf->sensors[id].registers;
 439
 440        /* obtain the current value */
 441        thresh_val = ti_bandgap_readl(bgp, tsr->bgap_threshold);
 442        t_cold = (thresh_val & tsr->threshold_tcold_mask) >>
 443                __ffs(tsr->threshold_tcold_mask);
 444        t_hot = (thresh_val & tsr->threshold_thot_mask) >>
 445                __ffs(tsr->threshold_thot_mask);
 446        if (hot)
 447                t_hot = val;
 448        else
 449                t_cold = val;
 450
 451        if (t_cold > t_hot) {
 452                if (hot)
 453                        err = ti_bandgap_add_hyst(bgp, t_hot,
 454                                                  -ts_data->hyst_val,
 455                                                  &t_cold);
 456                else
 457                        err = ti_bandgap_add_hyst(bgp, t_cold,
 458                                                  ts_data->hyst_val,
 459                                                  &t_hot);
 460        }
 461
 462        /* write the new threshold values */
 463        reg_val = thresh_val &
 464                  ~(tsr->threshold_thot_mask | tsr->threshold_tcold_mask);
 465        reg_val |= (t_hot << __ffs(tsr->threshold_thot_mask)) |
 466                   (t_cold << __ffs(tsr->threshold_tcold_mask));
 467
 468        /**
 469         * Errata i813:
 470         * Spurious Thermal Alert: Talert can happen randomly while the device
 471         * remains under the temperature limit defined for this event to trig.
 472         * This spurious event is caused by a incorrect re-synchronization
 473         * between clock domains. The comparison between configured threshold
 474         * and current temperature value can happen while the value is
 475         * transitioning (metastable), thus causing inappropriate event
 476         * generation. No spurious event occurs as long as the threshold value
 477         * stays unchanged. Spurious event can be generated while a thermal
 478         * alert threshold is modified in
 479         * CONTROL_BANDGAP_THRESHOLD_MPU/GPU/CORE/DSPEVE/IVA_n.
 480         */
 481
 482        if (TI_BANDGAP_HAS(bgp, ERRATA_813)) {
 483                /* Mask t_hot and t_cold events at the IP Level */
 484                ctrl = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
 485
 486                if (hot)
 487                        ctrl &= ~tsr->mask_hot_mask;
 488                else
 489                        ctrl &= ~tsr->mask_cold_mask;
 490
 491                ti_bandgap_writel(bgp, ctrl, tsr->bgap_mask_ctrl);
 492        }
 493
 494        /* Write the threshold value */
 495        ti_bandgap_writel(bgp, reg_val, tsr->bgap_threshold);
 496
 497        if (TI_BANDGAP_HAS(bgp, ERRATA_813)) {
 498                /* Unmask t_hot and t_cold events at the IP Level */
 499                ctrl = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
 500                if (hot)
 501                        ctrl |= tsr->mask_hot_mask;
 502                else
 503                        ctrl |= tsr->mask_cold_mask;
 504
 505                ti_bandgap_writel(bgp, ctrl, tsr->bgap_mask_ctrl);
 506        }
 507
 508        if (err) {
 509                dev_err(bgp->dev, "failed to reprogram thot threshold\n");
 510                err = -EIO;
 511                goto exit;
 512        }
 513
 514        ti_bandgap_unmask_interrupts(bgp, id, t_hot, t_cold);
 515exit:
 516        return err;
 517}
 518
 519/**
 520 * ti_bandgap_validate() - helper to check the sanity of a struct ti_bandgap
 521 * @bgp: struct ti_bandgap pointer
 522 * @id: bandgap sensor id
 523 *
 524 * Checks if the bandgap pointer is valid and if the sensor id is also
 525 * applicable.
 526 *
 527 * Return: 0 if no errors, -EINVAL for invalid @bgp pointer or -ERANGE if
 528 * @id cannot index @bgp sensors.
 529 */
 530static inline int ti_bandgap_validate(struct ti_bandgap *bgp, int id)
 531{
 532        if (!bgp || IS_ERR(bgp)) {
 533                pr_err("%s: invalid bandgap pointer\n", __func__);
 534                return -EINVAL;
 535        }
 536
 537        if ((id < 0) || (id >= bgp->conf->sensor_count)) {
 538                dev_err(bgp->dev, "%s: sensor id out of range (%d)\n",
 539                        __func__, id);
 540                return -ERANGE;
 541        }
 542
 543        return 0;
 544}
 545
 546/**
 547 * _ti_bandgap_write_threshold() - helper to update TALERT t_cold or t_hot
 548 * @bgp: struct ti_bandgap pointer
 549 * @id: bandgap sensor id
 550 * @val: value (mCelsius) of a new threshold
 551 * @hot: desired threshold to be updated. true if threshold hot, false if
 552 *       threshold cold
 553 *
 554 * It will update the required thresholds (hot and cold) for TALERT signal.
 555 * This function can be used to update t_hot or t_cold, depending on @hot value.
 556 * Validates the mCelsius range and update the requested threshold.
 557 * Call this function only if bandgap features HAS(TALERT).
 558 *
 559 * Return: 0 if no error, else corresponding error value.
 560 */
 561static int _ti_bandgap_write_threshold(struct ti_bandgap *bgp, int id, int val,
 562                                       bool hot)
 563{
 564        struct temp_sensor_data *ts_data;
 565        struct temp_sensor_registers *tsr;
 566        u32 adc_val;
 567        int ret;
 568
 569        ret = ti_bandgap_validate(bgp, id);
 570        if (ret)
 571                return ret;
 572
 573        if (!TI_BANDGAP_HAS(bgp, TALERT))
 574                return -ENOTSUPP;
 575
 576        ts_data = bgp->conf->sensors[id].ts_data;
 577        tsr = bgp->conf->sensors[id].registers;
 578        if (hot) {
 579                if (val < ts_data->min_temp + ts_data->hyst_val)
 580                        ret = -EINVAL;
 581        } else {
 582                if (val > ts_data->max_temp + ts_data->hyst_val)
 583                        ret = -EINVAL;
 584        }
 585
 586        if (ret)
 587                return ret;
 588
 589        ret = ti_bandgap_mcelsius_to_adc(bgp, val, &adc_val);
 590        if (ret < 0)
 591                return ret;
 592
 593        spin_lock(&bgp->lock);
 594        ret = ti_bandgap_update_alert_threshold(bgp, id, adc_val, hot);
 595        spin_unlock(&bgp->lock);
 596        return ret;
 597}
 598
 599/**
 600 * _ti_bandgap_read_threshold() - helper to read TALERT t_cold or t_hot
 601 * @bgp: struct ti_bandgap pointer
 602 * @id: bandgap sensor id
 603 * @val: value (mCelsius) of a threshold
 604 * @hot: desired threshold to be read. true if threshold hot, false if
 605 *       threshold cold
 606 *
 607 * It will fetch the required thresholds (hot and cold) for TALERT signal.
 608 * This function can be used to read t_hot or t_cold, depending on @hot value.
 609 * Call this function only if bandgap features HAS(TALERT).
 610 *
 611 * Return: 0 if no error, -ENOTSUPP if it has no TALERT support, or the
 612 * corresponding error value if some operation fails.
 613 */
 614static int _ti_bandgap_read_threshold(struct ti_bandgap *bgp, int id,
 615                                      int *val, bool hot)
 616{
 617        struct temp_sensor_registers *tsr;
 618        u32 temp, mask;
 619        int ret = 0;
 620
 621        ret = ti_bandgap_validate(bgp, id);
 622        if (ret)
 623                goto exit;
 624
 625        if (!TI_BANDGAP_HAS(bgp, TALERT)) {
 626                ret = -ENOTSUPP;
 627                goto exit;
 628        }
 629
 630        tsr = bgp->conf->sensors[id].registers;
 631        if (hot)
 632                mask = tsr->threshold_thot_mask;
 633        else
 634                mask = tsr->threshold_tcold_mask;
 635
 636        temp = ti_bandgap_readl(bgp, tsr->bgap_threshold);
 637        temp = (temp & mask) >> __ffs(mask);
 638        ret = ti_bandgap_adc_to_mcelsius(bgp, temp, &temp);
 639        if (ret) {
 640                dev_err(bgp->dev, "failed to read thot\n");
 641                ret = -EIO;
 642                goto exit;
 643        }
 644
 645        *val = temp;
 646
 647exit:
 648        return ret;
 649}
 650
 651/***   Exposed APIs   ***/
 652
 653/**
 654 * ti_bandgap_read_thot() - reads sensor current thot
 655 * @bgp: pointer to bandgap instance
 656 * @id: sensor id
 657 * @thot: resulting current thot value
 658 *
 659 * Return: 0 on success or the proper error code
 660 */
 661int ti_bandgap_read_thot(struct ti_bandgap *bgp, int id, int *thot)
 662{
 663        return _ti_bandgap_read_threshold(bgp, id, thot, true);
 664}
 665
 666/**
 667 * ti_bandgap_write_thot() - sets sensor current thot
 668 * @bgp: pointer to bandgap instance
 669 * @id: sensor id
 670 * @val: desired thot value
 671 *
 672 * Return: 0 on success or the proper error code
 673 */
 674int ti_bandgap_write_thot(struct ti_bandgap *bgp, int id, int val)
 675{
 676        return _ti_bandgap_write_threshold(bgp, id, val, true);
 677}
 678
 679/**
 680 * ti_bandgap_read_tcold() - reads sensor current tcold
 681 * @bgp: pointer to bandgap instance
 682 * @id: sensor id
 683 * @tcold: resulting current tcold value
 684 *
 685 * Return: 0 on success or the proper error code
 686 */
 687int ti_bandgap_read_tcold(struct ti_bandgap *bgp, int id, int *tcold)
 688{
 689        return _ti_bandgap_read_threshold(bgp, id, tcold, false);
 690}
 691
 692/**
 693 * ti_bandgap_write_tcold() - sets the sensor tcold
 694 * @bgp: pointer to bandgap instance
 695 * @id: sensor id
 696 * @val: desired tcold value
 697 *
 698 * Return: 0 on success or the proper error code
 699 */
 700int ti_bandgap_write_tcold(struct ti_bandgap *bgp, int id, int val)
 701{
 702        return _ti_bandgap_write_threshold(bgp, id, val, false);
 703}
 704
 705/**
 706 * ti_bandgap_read_counter() - read the sensor counter
 707 * @bgp: pointer to bandgap instance
 708 * @id: sensor id
 709 * @interval: resulting update interval in miliseconds
 710 */
 711static void ti_bandgap_read_counter(struct ti_bandgap *bgp, int id,
 712                                    int *interval)
 713{
 714        struct temp_sensor_registers *tsr;
 715        int time;
 716
 717        tsr = bgp->conf->sensors[id].registers;
 718        time = ti_bandgap_readl(bgp, tsr->bgap_counter);
 719        time = (time & tsr->counter_mask) >>
 720                                        __ffs(tsr->counter_mask);
 721        time = time * 1000 / bgp->clk_rate;
 722        *interval = time;
 723}
 724
 725/**
 726 * ti_bandgap_read_counter_delay() - read the sensor counter delay
 727 * @bgp: pointer to bandgap instance
 728 * @id: sensor id
 729 * @interval: resulting update interval in miliseconds
 730 */
 731static void ti_bandgap_read_counter_delay(struct ti_bandgap *bgp, int id,
 732                                          int *interval)
 733{
 734        struct temp_sensor_registers *tsr;
 735        int reg_val;
 736
 737        tsr = bgp->conf->sensors[id].registers;
 738
 739        reg_val = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
 740        reg_val = (reg_val & tsr->mask_counter_delay_mask) >>
 741                                __ffs(tsr->mask_counter_delay_mask);
 742        switch (reg_val) {
 743        case 0:
 744                *interval = 0;
 745                break;
 746        case 1:
 747                *interval = 1;
 748                break;
 749        case 2:
 750                *interval = 10;
 751                break;
 752        case 3:
 753                *interval = 100;
 754                break;
 755        case 4:
 756                *interval = 250;
 757                break;
 758        case 5:
 759                *interval = 500;
 760                break;
 761        default:
 762                dev_warn(bgp->dev, "Wrong counter delay value read from register %X",
 763                         reg_val);
 764        }
 765}
 766
 767/**
 768 * ti_bandgap_read_update_interval() - read the sensor update interval
 769 * @bgp: pointer to bandgap instance
 770 * @id: sensor id
 771 * @interval: resulting update interval in miliseconds
 772 *
 773 * Return: 0 on success or the proper error code
 774 */
 775int ti_bandgap_read_update_interval(struct ti_bandgap *bgp, int id,
 776                                    int *interval)
 777{
 778        int ret = 0;
 779
 780        ret = ti_bandgap_validate(bgp, id);
 781        if (ret)
 782                goto exit;
 783
 784        if (!TI_BANDGAP_HAS(bgp, COUNTER) &&
 785            !TI_BANDGAP_HAS(bgp, COUNTER_DELAY)) {
 786                ret = -ENOTSUPP;
 787                goto exit;
 788        }
 789
 790        if (TI_BANDGAP_HAS(bgp, COUNTER)) {
 791                ti_bandgap_read_counter(bgp, id, interval);
 792                goto exit;
 793        }
 794
 795        ti_bandgap_read_counter_delay(bgp, id, interval);
 796exit:
 797        return ret;
 798}
 799
 800/**
 801 * ti_bandgap_write_counter_delay() - set the counter_delay
 802 * @bgp: pointer to bandgap instance
 803 * @id: sensor id
 804 * @interval: desired update interval in miliseconds
 805 *
 806 * Return: 0 on success or the proper error code
 807 */
 808static int ti_bandgap_write_counter_delay(struct ti_bandgap *bgp, int id,
 809                                          u32 interval)
 810{
 811        int rval;
 812
 813        switch (interval) {
 814        case 0: /* Immediate conversion */
 815                rval = 0x0;
 816                break;
 817        case 1: /* Conversion after ever 1ms */
 818                rval = 0x1;
 819                break;
 820        case 10: /* Conversion after ever 10ms */
 821                rval = 0x2;
 822                break;
 823        case 100: /* Conversion after ever 100ms */
 824                rval = 0x3;
 825                break;
 826        case 250: /* Conversion after ever 250ms */
 827                rval = 0x4;
 828                break;
 829        case 500: /* Conversion after ever 500ms */
 830                rval = 0x5;
 831                break;
 832        default:
 833                dev_warn(bgp->dev, "Delay %d ms is not supported\n", interval);
 834                return -EINVAL;
 835        }
 836
 837        spin_lock(&bgp->lock);
 838        RMW_BITS(bgp, id, bgap_mask_ctrl, mask_counter_delay_mask, rval);
 839        spin_unlock(&bgp->lock);
 840
 841        return 0;
 842}
 843
 844/**
 845 * ti_bandgap_write_counter() - set the bandgap sensor counter
 846 * @bgp: pointer to bandgap instance
 847 * @id: sensor id
 848 * @interval: desired update interval in miliseconds
 849 */
 850static void ti_bandgap_write_counter(struct ti_bandgap *bgp, int id,
 851                                     u32 interval)
 852{
 853        interval = interval * bgp->clk_rate / 1000;
 854        spin_lock(&bgp->lock);
 855        RMW_BITS(bgp, id, bgap_counter, counter_mask, interval);
 856        spin_unlock(&bgp->lock);
 857}
 858
 859/**
 860 * ti_bandgap_write_update_interval() - set the update interval
 861 * @bgp: pointer to bandgap instance
 862 * @id: sensor id
 863 * @interval: desired update interval in miliseconds
 864 *
 865 * Return: 0 on success or the proper error code
 866 */
 867int ti_bandgap_write_update_interval(struct ti_bandgap *bgp,
 868                                     int id, u32 interval)
 869{
 870        int ret = ti_bandgap_validate(bgp, id);
 871        if (ret)
 872                goto exit;
 873
 874        if (!TI_BANDGAP_HAS(bgp, COUNTER) &&
 875            !TI_BANDGAP_HAS(bgp, COUNTER_DELAY)) {
 876                ret = -ENOTSUPP;
 877                goto exit;
 878        }
 879
 880        if (TI_BANDGAP_HAS(bgp, COUNTER)) {
 881                ti_bandgap_write_counter(bgp, id, interval);
 882                goto exit;
 883        }
 884
 885        ret = ti_bandgap_write_counter_delay(bgp, id, interval);
 886exit:
 887        return ret;
 888}
 889
 890/**
 891 * ti_bandgap_read_temperature() - report current temperature
 892 * @bgp: pointer to bandgap instance
 893 * @id: sensor id
 894 * @temperature: resulting temperature
 895 *
 896 * Return: 0 on success or the proper error code
 897 */
 898int ti_bandgap_read_temperature(struct ti_bandgap *bgp, int id,
 899                                int *temperature)
 900{
 901        u32 temp;
 902        int ret;
 903
 904        ret = ti_bandgap_validate(bgp, id);
 905        if (ret)
 906                return ret;
 907
 908        if (!TI_BANDGAP_HAS(bgp, MODE_CONFIG)) {
 909                ret = ti_bandgap_force_single_read(bgp, id);
 910                if (ret)
 911                        return ret;
 912        }
 913
 914        spin_lock(&bgp->lock);
 915        temp = ti_bandgap_read_temp(bgp, id);
 916        spin_unlock(&bgp->lock);
 917
 918        ret = ti_bandgap_adc_to_mcelsius(bgp, temp, &temp);
 919        if (ret)
 920                return -EIO;
 921
 922        *temperature = temp;
 923
 924        return 0;
 925}
 926
 927/**
 928 * ti_bandgap_set_sensor_data() - helper function to store thermal
 929 * framework related data.
 930 * @bgp: pointer to bandgap instance
 931 * @id: sensor id
 932 * @data: thermal framework related data to be stored
 933 *
 934 * Return: 0 on success or the proper error code
 935 */
 936int ti_bandgap_set_sensor_data(struct ti_bandgap *bgp, int id, void *data)
 937{
 938        int ret = ti_bandgap_validate(bgp, id);
 939        if (ret)
 940                return ret;
 941
 942        bgp->regval[id].data = data;
 943
 944        return 0;
 945}
 946
 947/**
 948 * ti_bandgap_get_sensor_data() - helper function to get thermal
 949 * framework related data.
 950 * @bgp: pointer to bandgap instance
 951 * @id: sensor id
 952 *
 953 * Return: data stored by set function with sensor id on success or NULL
 954 */
 955void *ti_bandgap_get_sensor_data(struct ti_bandgap *bgp, int id)
 956{
 957        int ret = ti_bandgap_validate(bgp, id);
 958        if (ret)
 959                return ERR_PTR(ret);
 960
 961        return bgp->regval[id].data;
 962}
 963
 964/***   Helper functions used during device initialization   ***/
 965
 966/**
 967 * ti_bandgap_force_single_read() - executes 1 single ADC conversion
 968 * @bgp: pointer to struct ti_bandgap
 969 * @id: sensor id which it is desired to read 1 temperature
 970 *
 971 * Used to initialize the conversion state machine and set it to a valid
 972 * state. Called during device initialization and context restore events.
 973 *
 974 * Return: 0
 975 */
 976static int
 977ti_bandgap_force_single_read(struct ti_bandgap *bgp, int id)
 978{
 979        u32 counter = 1000;
 980        struct temp_sensor_registers *tsr;
 981
 982        /* Select single conversion mode */
 983        if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
 984                RMW_BITS(bgp, id, bgap_mode_ctrl, mode_ctrl_mask, 0);
 985
 986        /* Start of Conversion = 1 */
 987        RMW_BITS(bgp, id, temp_sensor_ctrl, bgap_soc_mask, 1);
 988
 989        /* Wait for EOCZ going up */
 990        tsr = bgp->conf->sensors[id].registers;
 991
 992        while (--counter) {
 993                if (ti_bandgap_readl(bgp, tsr->temp_sensor_ctrl) &
 994                    tsr->bgap_eocz_mask)
 995                        break;
 996        }
 997
 998        /* Start of Conversion = 0 */
 999        RMW_BITS(bgp, id, temp_sensor_ctrl, bgap_soc_mask, 0);
1000
1001        /* Wait for EOCZ going down */
1002        counter = 1000;
1003        while (--counter) {
1004                if (!(ti_bandgap_readl(bgp, tsr->temp_sensor_ctrl) &
1005                      tsr->bgap_eocz_mask))
1006                        break;
1007        }
1008
1009        return 0;
1010}
1011
1012/**
1013 * ti_bandgap_set_continous_mode() - One time enabling of continuous mode
1014 * @bgp: pointer to struct ti_bandgap
1015 *
1016 * Call this function only if HAS(MODE_CONFIG) is set. As this driver may
1017 * be used for junction temperature monitoring, it is desirable that the
1018 * sensors are operational all the time, so that alerts are generated
1019 * properly.
1020 *
1021 * Return: 0
1022 */
1023static int ti_bandgap_set_continuous_mode(struct ti_bandgap *bgp)
1024{
1025        int i;
1026
1027        for (i = 0; i < bgp->conf->sensor_count; i++) {
1028                /* Perform a single read just before enabling continuous */
1029                ti_bandgap_force_single_read(bgp, i);
1030                RMW_BITS(bgp, i, bgap_mode_ctrl, mode_ctrl_mask, 1);
1031        }
1032
1033        return 0;
1034}
1035
1036/**
1037 * ti_bandgap_get_trend() - To fetch the temperature trend of a sensor
1038 * @bgp: pointer to struct ti_bandgap
1039 * @id: id of the individual sensor
1040 * @trend: Pointer to trend.
1041 *
1042 * This function needs to be called to fetch the temperature trend of a
1043 * Particular sensor. The function computes the difference in temperature
1044 * w.r.t time. For the bandgaps with built in history buffer the temperatures
1045 * are read from the buffer and for those without the Buffer -ENOTSUPP is
1046 * returned.
1047 *
1048 * Return: 0 if no error, else return corresponding error. If no
1049 *              error then the trend value is passed on to trend parameter
1050 */
1051int ti_bandgap_get_trend(struct ti_bandgap *bgp, int id, int *trend)
1052{
1053        struct temp_sensor_registers *tsr;
1054        u32 temp1, temp2, reg1, reg2;
1055        int t1, t2, interval, ret = 0;
1056
1057        ret = ti_bandgap_validate(bgp, id);
1058        if (ret)
1059                goto exit;
1060
1061        if (!TI_BANDGAP_HAS(bgp, HISTORY_BUFFER) ||
1062            !TI_BANDGAP_HAS(bgp, FREEZE_BIT)) {
1063                ret = -ENOTSUPP;
1064                goto exit;
1065        }
1066
1067        spin_lock(&bgp->lock);
1068
1069        tsr = bgp->conf->sensors[id].registers;
1070
1071        /* Freeze and read the last 2 valid readings */
1072        RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 1);
1073        reg1 = tsr->ctrl_dtemp_1;
1074        reg2 = tsr->ctrl_dtemp_2;
1075
1076        /* read temperature from history buffer */
1077        temp1 = ti_bandgap_readl(bgp, reg1);
1078        temp1 &= tsr->bgap_dtemp_mask;
1079
1080        temp2 = ti_bandgap_readl(bgp, reg2);
1081        temp2 &= tsr->bgap_dtemp_mask;
1082
1083        /* Convert from adc values to mCelsius temperature */
1084        ret = ti_bandgap_adc_to_mcelsius(bgp, temp1, &t1);
1085        if (ret)
1086                goto unfreeze;
1087
1088        ret = ti_bandgap_adc_to_mcelsius(bgp, temp2, &t2);
1089        if (ret)
1090                goto unfreeze;
1091
1092        /* Fetch the update interval */
1093        ret = ti_bandgap_read_update_interval(bgp, id, &interval);
1094        if (ret)
1095                goto unfreeze;
1096
1097        /* Set the interval to 1 ms if bandgap counter delay is not set */
1098        if (interval == 0)
1099                interval = 1;
1100
1101        *trend = (t1 - t2) / interval;
1102
1103        dev_dbg(bgp->dev, "The temperatures are t1 = %d and t2 = %d and trend =%d\n",
1104                t1, t2, *trend);
1105
1106unfreeze:
1107        RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 0);
1108        spin_unlock(&bgp->lock);
1109exit:
1110        return ret;
1111}
1112
1113/**
1114 * ti_bandgap_tshut_init() - setup and initialize tshut handling
1115 * @bgp: pointer to struct ti_bandgap
1116 * @pdev: pointer to device struct platform_device
1117 *
1118 * Call this function only in case the bandgap features HAS(TSHUT).
1119 * In this case, the driver needs to handle the TSHUT signal as an IRQ.
1120 * The IRQ is wired as a GPIO, and for this purpose, it is required
1121 * to specify which GPIO line is used. TSHUT IRQ is fired anytime
1122 * one of the bandgap sensors violates the TSHUT high/hot threshold.
1123 * And in that case, the system must go off.
1124 *
1125 * Return: 0 if no error, else error status
1126 */
1127static int ti_bandgap_tshut_init(struct ti_bandgap *bgp,
1128                                 struct platform_device *pdev)
1129{
1130        int gpio_nr = bgp->tshut_gpio;
1131        int status;
1132
1133        /* Request for gpio_86 line */
1134        status = gpio_request(gpio_nr, "tshut");
1135        if (status < 0) {
1136                dev_err(bgp->dev, "Could not request for TSHUT GPIO:%i\n", 86);
1137                return status;
1138        }
1139        status = gpio_direction_input(gpio_nr);
1140        if (status) {
1141                dev_err(bgp->dev, "Cannot set input TSHUT GPIO %d\n", gpio_nr);
1142                return status;
1143        }
1144
1145        status = request_irq(gpio_to_irq(gpio_nr), ti_bandgap_tshut_irq_handler,
1146                             IRQF_TRIGGER_RISING, "tshut", NULL);
1147        if (status) {
1148                gpio_free(gpio_nr);
1149                dev_err(bgp->dev, "request irq failed for TSHUT");
1150        }
1151
1152        return 0;
1153}
1154
1155/**
1156 * ti_bandgap_alert_init() - setup and initialize talert handling
1157 * @bgp: pointer to struct ti_bandgap
1158 * @pdev: pointer to device struct platform_device
1159 *
1160 * Call this function only in case the bandgap features HAS(TALERT).
1161 * In this case, the driver needs to handle the TALERT signals as an IRQs.
1162 * TALERT is a normal IRQ and it is fired any time thresholds (hot or cold)
1163 * are violated. In these situation, the driver must reprogram the thresholds,
1164 * accordingly to specified policy.
1165 *
1166 * Return: 0 if no error, else return corresponding error.
1167 */
1168static int ti_bandgap_talert_init(struct ti_bandgap *bgp,
1169                                  struct platform_device *pdev)
1170{
1171        int ret;
1172
1173        bgp->irq = platform_get_irq(pdev, 0);
1174        if (bgp->irq < 0) {
1175                dev_err(&pdev->dev, "get_irq failed\n");
1176                return bgp->irq;
1177        }
1178        ret = request_threaded_irq(bgp->irq, NULL,
1179                                   ti_bandgap_talert_irq_handler,
1180                                   IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
1181                                   "talert", bgp);
1182        if (ret) {
1183                dev_err(&pdev->dev, "Request threaded irq failed.\n");
1184                return ret;
1185        }
1186
1187        return 0;
1188}
1189
1190static const struct of_device_id of_ti_bandgap_match[];
1191/**
1192 * ti_bandgap_build() - parse DT and setup a struct ti_bandgap
1193 * @pdev: pointer to device struct platform_device
1194 *
1195 * Used to read the device tree properties accordingly to the bandgap
1196 * matching version. Based on bandgap version and its capabilities it
1197 * will build a struct ti_bandgap out of the required DT entries.
1198 *
1199 * Return: valid bandgap structure if successful, else returns ERR_PTR
1200 * return value must be verified with IS_ERR.
1201 */
1202static struct ti_bandgap *ti_bandgap_build(struct platform_device *pdev)
1203{
1204        struct device_node *node = pdev->dev.of_node;
1205        const struct of_device_id *of_id;
1206        struct ti_bandgap *bgp;
1207        struct resource *res;
1208        int i;
1209
1210        /* just for the sake */
1211        if (!node) {
1212                dev_err(&pdev->dev, "no platform information available\n");
1213                return ERR_PTR(-EINVAL);
1214        }
1215
1216        bgp = devm_kzalloc(&pdev->dev, sizeof(*bgp), GFP_KERNEL);
1217        if (!bgp) {
1218                dev_err(&pdev->dev, "Unable to allocate mem for driver ref\n");
1219                return ERR_PTR(-ENOMEM);
1220        }
1221
1222        of_id = of_match_device(of_ti_bandgap_match, &pdev->dev);
1223        if (of_id)
1224                bgp->conf = of_id->data;
1225
1226        /* register shadow for context save and restore */
1227        bgp->regval = devm_kzalloc(&pdev->dev, sizeof(*bgp->regval) *
1228                                   bgp->conf->sensor_count, GFP_KERNEL);
1229        if (!bgp->regval) {
1230                dev_err(&pdev->dev, "Unable to allocate mem for driver ref\n");
1231                return ERR_PTR(-ENOMEM);
1232        }
1233
1234        i = 0;
1235        do {
1236                void __iomem *chunk;
1237
1238                res = platform_get_resource(pdev, IORESOURCE_MEM, i);
1239                if (!res)
1240                        break;
1241                chunk = devm_ioremap_resource(&pdev->dev, res);
1242                if (i == 0)
1243                        bgp->base = chunk;
1244                if (IS_ERR(chunk))
1245                        return ERR_CAST(chunk);
1246
1247                i++;
1248        } while (res);
1249
1250        if (TI_BANDGAP_HAS(bgp, TSHUT)) {
1251                bgp->tshut_gpio = of_get_gpio(node, 0);
1252                if (!gpio_is_valid(bgp->tshut_gpio)) {
1253                        dev_err(&pdev->dev, "invalid gpio for tshut (%d)\n",
1254                                bgp->tshut_gpio);
1255                        return ERR_PTR(-EINVAL);
1256                }
1257        }
1258
1259        return bgp;
1260}
1261
1262/***   Device driver call backs   ***/
1263
1264static
1265int ti_bandgap_probe(struct platform_device *pdev)
1266{
1267        struct ti_bandgap *bgp;
1268        int clk_rate, ret, i;
1269
1270        bgp = ti_bandgap_build(pdev);
1271        if (IS_ERR(bgp)) {
1272                dev_err(&pdev->dev, "failed to fetch platform data\n");
1273                return PTR_ERR(bgp);
1274        }
1275        bgp->dev = &pdev->dev;
1276
1277        if (TI_BANDGAP_HAS(bgp, UNRELIABLE))
1278                dev_warn(&pdev->dev,
1279                         "This OMAP thermal sensor is unreliable. You've been warned\n");
1280
1281        if (TI_BANDGAP_HAS(bgp, TSHUT)) {
1282                ret = ti_bandgap_tshut_init(bgp, pdev);
1283                if (ret) {
1284                        dev_err(&pdev->dev,
1285                                "failed to initialize system tshut IRQ\n");
1286                        return ret;
1287                }
1288        }
1289
1290        bgp->fclock = clk_get(NULL, bgp->conf->fclock_name);
1291        if (IS_ERR(bgp->fclock)) {
1292                dev_err(&pdev->dev, "failed to request fclock reference\n");
1293                ret = PTR_ERR(bgp->fclock);
1294                goto free_irqs;
1295        }
1296
1297        bgp->div_clk = clk_get(NULL, bgp->conf->div_ck_name);
1298        if (IS_ERR(bgp->div_clk)) {
1299                dev_err(&pdev->dev, "failed to request div_ts_ck clock ref\n");
1300                ret = PTR_ERR(bgp->div_clk);
1301                goto free_irqs;
1302        }
1303
1304        for (i = 0; i < bgp->conf->sensor_count; i++) {
1305                struct temp_sensor_registers *tsr;
1306                u32 val;
1307
1308                tsr = bgp->conf->sensors[i].registers;
1309                /*
1310                 * check if the efuse has a non-zero value if not
1311                 * it is an untrimmed sample and the temperatures
1312                 * may not be accurate
1313                 */
1314                val = ti_bandgap_readl(bgp, tsr->bgap_efuse);
1315                if (!val)
1316                        dev_info(&pdev->dev,
1317                                 "Non-trimmed BGAP, Temp not accurate\n");
1318        }
1319
1320        clk_rate = clk_round_rate(bgp->div_clk,
1321                                  bgp->conf->sensors[0].ts_data->max_freq);
1322        if (clk_rate < bgp->conf->sensors[0].ts_data->min_freq ||
1323            clk_rate <= 0) {
1324                ret = -ENODEV;
1325                dev_err(&pdev->dev, "wrong clock rate (%d)\n", clk_rate);
1326                goto put_clks;
1327        }
1328
1329        ret = clk_set_rate(bgp->div_clk, clk_rate);
1330        if (ret)
1331                dev_err(&pdev->dev, "Cannot re-set clock rate. Continuing\n");
1332
1333        bgp->clk_rate = clk_rate;
1334        if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1335                clk_prepare_enable(bgp->fclock);
1336
1337
1338        spin_lock_init(&bgp->lock);
1339        bgp->dev = &pdev->dev;
1340        platform_set_drvdata(pdev, bgp);
1341
1342        ti_bandgap_power(bgp, true);
1343
1344        /* Set default counter to 1 for now */
1345        if (TI_BANDGAP_HAS(bgp, COUNTER))
1346                for (i = 0; i < bgp->conf->sensor_count; i++)
1347                        RMW_BITS(bgp, i, bgap_counter, counter_mask, 1);
1348
1349        /* Set default thresholds for alert and shutdown */
1350        for (i = 0; i < bgp->conf->sensor_count; i++) {
1351                struct temp_sensor_data *ts_data;
1352
1353                ts_data = bgp->conf->sensors[i].ts_data;
1354
1355                if (TI_BANDGAP_HAS(bgp, TALERT)) {
1356                        /* Set initial Talert thresholds */
1357                        RMW_BITS(bgp, i, bgap_threshold,
1358                                 threshold_tcold_mask, ts_data->t_cold);
1359                        RMW_BITS(bgp, i, bgap_threshold,
1360                                 threshold_thot_mask, ts_data->t_hot);
1361                        /* Enable the alert events */
1362                        RMW_BITS(bgp, i, bgap_mask_ctrl, mask_hot_mask, 1);
1363                        RMW_BITS(bgp, i, bgap_mask_ctrl, mask_cold_mask, 1);
1364                }
1365
1366                if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG)) {
1367                        /* Set initial Tshut thresholds */
1368                        RMW_BITS(bgp, i, tshut_threshold,
1369                                 tshut_hot_mask, ts_data->tshut_hot);
1370                        RMW_BITS(bgp, i, tshut_threshold,
1371                                 tshut_cold_mask, ts_data->tshut_cold);
1372                }
1373        }
1374
1375        if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1376                ti_bandgap_set_continuous_mode(bgp);
1377
1378        /* Set .250 seconds time as default counter */
1379        if (TI_BANDGAP_HAS(bgp, COUNTER))
1380                for (i = 0; i < bgp->conf->sensor_count; i++)
1381                        RMW_BITS(bgp, i, bgap_counter, counter_mask,
1382                                 bgp->clk_rate / 4);
1383
1384        /* Every thing is good? Then expose the sensors */
1385        for (i = 0; i < bgp->conf->sensor_count; i++) {
1386                char *domain;
1387
1388                if (bgp->conf->sensors[i].register_cooling) {
1389                        ret = bgp->conf->sensors[i].register_cooling(bgp, i);
1390                        if (ret)
1391                                goto remove_sensors;
1392                }
1393
1394                if (bgp->conf->expose_sensor) {
1395                        domain = bgp->conf->sensors[i].domain;
1396                        ret = bgp->conf->expose_sensor(bgp, i, domain);
1397                        if (ret)
1398                                goto remove_last_cooling;
1399                }
1400        }
1401
1402        /*
1403         * Enable the Interrupts once everything is set. Otherwise irq handler
1404         * might be called as soon as it is enabled where as rest of framework
1405         * is still getting initialised.
1406         */
1407        if (TI_BANDGAP_HAS(bgp, TALERT)) {
1408                ret = ti_bandgap_talert_init(bgp, pdev);
1409                if (ret) {
1410                        dev_err(&pdev->dev, "failed to initialize Talert IRQ\n");
1411                        i = bgp->conf->sensor_count;
1412                        goto disable_clk;
1413                }
1414        }
1415
1416        return 0;
1417
1418remove_last_cooling:
1419        if (bgp->conf->sensors[i].unregister_cooling)
1420                bgp->conf->sensors[i].unregister_cooling(bgp, i);
1421remove_sensors:
1422        for (i--; i >= 0; i--) {
1423                if (bgp->conf->sensors[i].unregister_cooling)
1424                        bgp->conf->sensors[i].unregister_cooling(bgp, i);
1425                if (bgp->conf->remove_sensor)
1426                        bgp->conf->remove_sensor(bgp, i);
1427        }
1428        ti_bandgap_power(bgp, false);
1429disable_clk:
1430        if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1431                clk_disable_unprepare(bgp->fclock);
1432put_clks:
1433        clk_put(bgp->fclock);
1434        clk_put(bgp->div_clk);
1435free_irqs:
1436        if (TI_BANDGAP_HAS(bgp, TSHUT)) {
1437                free_irq(gpio_to_irq(bgp->tshut_gpio), NULL);
1438                gpio_free(bgp->tshut_gpio);
1439        }
1440
1441        return ret;
1442}
1443
1444static
1445int ti_bandgap_remove(struct platform_device *pdev)
1446{
1447        struct ti_bandgap *bgp = platform_get_drvdata(pdev);
1448        int i;
1449
1450        /* First thing is to remove sensor interfaces */
1451        for (i = 0; i < bgp->conf->sensor_count; i++) {
1452                if (bgp->conf->sensors[i].unregister_cooling)
1453                        bgp->conf->sensors[i].unregister_cooling(bgp, i);
1454
1455                if (bgp->conf->remove_sensor)
1456                        bgp->conf->remove_sensor(bgp, i);
1457        }
1458
1459        ti_bandgap_power(bgp, false);
1460
1461        if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1462                clk_disable_unprepare(bgp->fclock);
1463        clk_put(bgp->fclock);
1464        clk_put(bgp->div_clk);
1465
1466        if (TI_BANDGAP_HAS(bgp, TALERT))
1467                free_irq(bgp->irq, bgp);
1468
1469        if (TI_BANDGAP_HAS(bgp, TSHUT)) {
1470                free_irq(gpio_to_irq(bgp->tshut_gpio), NULL);
1471                gpio_free(bgp->tshut_gpio);
1472        }
1473
1474        return 0;
1475}
1476
1477#ifdef CONFIG_PM_SLEEP
1478static int ti_bandgap_save_ctxt(struct ti_bandgap *bgp)
1479{
1480        int i;
1481
1482        for (i = 0; i < bgp->conf->sensor_count; i++) {
1483                struct temp_sensor_registers *tsr;
1484                struct temp_sensor_regval *rval;
1485
1486                rval = &bgp->regval[i];
1487                tsr = bgp->conf->sensors[i].registers;
1488
1489                if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1490                        rval->bg_mode_ctrl = ti_bandgap_readl(bgp,
1491                                                        tsr->bgap_mode_ctrl);
1492                if (TI_BANDGAP_HAS(bgp, COUNTER))
1493                        rval->bg_counter = ti_bandgap_readl(bgp,
1494                                                        tsr->bgap_counter);
1495                if (TI_BANDGAP_HAS(bgp, TALERT)) {
1496                        rval->bg_threshold = ti_bandgap_readl(bgp,
1497                                                        tsr->bgap_threshold);
1498                        rval->bg_ctrl = ti_bandgap_readl(bgp,
1499                                                   tsr->bgap_mask_ctrl);
1500                }
1501
1502                if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
1503                        rval->tshut_threshold = ti_bandgap_readl(bgp,
1504                                                   tsr->tshut_threshold);
1505        }
1506
1507        return 0;
1508}
1509
1510static int ti_bandgap_restore_ctxt(struct ti_bandgap *bgp)
1511{
1512        int i;
1513
1514        for (i = 0; i < bgp->conf->sensor_count; i++) {
1515                struct temp_sensor_registers *tsr;
1516                struct temp_sensor_regval *rval;
1517                u32 val = 0;
1518
1519                rval = &bgp->regval[i];
1520                tsr = bgp->conf->sensors[i].registers;
1521
1522                if (TI_BANDGAP_HAS(bgp, COUNTER))
1523                        val = ti_bandgap_readl(bgp, tsr->bgap_counter);
1524
1525                if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
1526                        ti_bandgap_writel(bgp, rval->tshut_threshold,
1527                                          tsr->tshut_threshold);
1528                /* Force immediate temperature measurement and update
1529                 * of the DTEMP field
1530                 */
1531                ti_bandgap_force_single_read(bgp, i);
1532
1533                if (TI_BANDGAP_HAS(bgp, COUNTER))
1534                        ti_bandgap_writel(bgp, rval->bg_counter,
1535                                          tsr->bgap_counter);
1536                if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1537                        ti_bandgap_writel(bgp, rval->bg_mode_ctrl,
1538                                          tsr->bgap_mode_ctrl);
1539                if (TI_BANDGAP_HAS(bgp, TALERT)) {
1540                        ti_bandgap_writel(bgp, rval->bg_threshold,
1541                                          tsr->bgap_threshold);
1542                        ti_bandgap_writel(bgp, rval->bg_ctrl,
1543                                          tsr->bgap_mask_ctrl);
1544                }
1545        }
1546
1547        return 0;
1548}
1549
1550static int ti_bandgap_suspend(struct device *dev)
1551{
1552        struct ti_bandgap *bgp = dev_get_drvdata(dev);
1553        int err;
1554
1555        err = ti_bandgap_save_ctxt(bgp);
1556        ti_bandgap_power(bgp, false);
1557
1558        if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1559                clk_disable_unprepare(bgp->fclock);
1560
1561        return err;
1562}
1563
1564static int ti_bandgap_resume(struct device *dev)
1565{
1566        struct ti_bandgap *bgp = dev_get_drvdata(dev);
1567
1568        if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1569                clk_prepare_enable(bgp->fclock);
1570
1571        ti_bandgap_power(bgp, true);
1572
1573        return ti_bandgap_restore_ctxt(bgp);
1574}
1575static SIMPLE_DEV_PM_OPS(ti_bandgap_dev_pm_ops, ti_bandgap_suspend,
1576                         ti_bandgap_resume);
1577
1578#define DEV_PM_OPS      (&ti_bandgap_dev_pm_ops)
1579#else
1580#define DEV_PM_OPS      NULL
1581#endif
1582
1583static const struct of_device_id of_ti_bandgap_match[] = {
1584#ifdef CONFIG_OMAP3_THERMAL
1585        {
1586                .compatible = "ti,omap34xx-bandgap",
1587                .data = (void *)&omap34xx_data,
1588        },
1589        {
1590                .compatible = "ti,omap36xx-bandgap",
1591                .data = (void *)&omap36xx_data,
1592        },
1593#endif
1594#ifdef CONFIG_OMAP4_THERMAL
1595        {
1596                .compatible = "ti,omap4430-bandgap",
1597                .data = (void *)&omap4430_data,
1598        },
1599        {
1600                .compatible = "ti,omap4460-bandgap",
1601                .data = (void *)&omap4460_data,
1602        },
1603        {
1604                .compatible = "ti,omap4470-bandgap",
1605                .data = (void *)&omap4470_data,
1606        },
1607#endif
1608#ifdef CONFIG_OMAP5_THERMAL
1609        {
1610                .compatible = "ti,omap5430-bandgap",
1611                .data = (void *)&omap5430_data,
1612        },
1613#endif
1614#ifdef CONFIG_DRA752_THERMAL
1615        {
1616                .compatible = "ti,dra752-bandgap",
1617                .data = (void *)&dra752_data,
1618        },
1619#endif
1620        /* Sentinel */
1621        { },
1622};
1623MODULE_DEVICE_TABLE(of, of_ti_bandgap_match);
1624
1625static struct platform_driver ti_bandgap_sensor_driver = {
1626        .probe = ti_bandgap_probe,
1627        .remove = ti_bandgap_remove,
1628        .driver = {
1629                        .name = "ti-soc-thermal",
1630                        .pm = DEV_PM_OPS,
1631                        .of_match_table = of_ti_bandgap_match,
1632        },
1633};
1634
1635module_platform_driver(ti_bandgap_sensor_driver);
1636
1637MODULE_DESCRIPTION("OMAP4+ bandgap temperature sensor driver");
1638MODULE_LICENSE("GPL v2");
1639MODULE_ALIAS("platform:ti-soc-thermal");
1640MODULE_AUTHOR("Texas Instrument Inc.");
1641
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.