drivers/thermal/ti-soc-thermal/ti-bandgap.c

   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
  46 static 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  */
  58 static 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  */
  71 static 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)                       \
  83 do {                                                            \
  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  */
 106 static 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  */
 135 static 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  */
 162 static 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  */
 208 static 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  */
 270 static 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  */
 295 static
 296 int 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  */
 321 static
 322 int 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  */
 358 static
 359 int 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  */
 390 static 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  */
 430 static 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);
 515 exit:
 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  */
 530 static 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  */
 561 static 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  */
 614 static 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
 647 exit:
 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  */
 661 int 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  */
 674 int 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  */
 687 int 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  */
 700 int 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  */
 711 static 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  */
 731 static 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  */
 775 int 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);
 796 exit:
 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  */
 808 static 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  */
 850 static 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  */
 867 int 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);
 886 exit:
 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  */
 898 int 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  */
 936 int 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  */
 955 void *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  */
 976 static int
 977 ti_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_continuous_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  */
1023 static 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  */
1051 int 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
1106 unfreeze:
1107         RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 0);
1108         spin_unlock(&bgp->lock);
1109 exit:
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  */
1127 static 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  */
1168 static 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
1190 static 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  */
1202 static 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                 return ERR_PTR(-ENOMEM);
1219
1220         of_id = of_match_device(of_ti_bandgap_match, &pdev->dev);
1221         if (of_id)
1222                 bgp->conf = of_id->data;
1223
1224         /* register shadow for context save and restore */
1225         bgp->regval = devm_kcalloc(&pdev->dev, bgp->conf->sensor_count,
1226                                    sizeof(*bgp->regval), GFP_KERNEL);
1227         if (!bgp->regval)
1228                 return ERR_PTR(-ENOMEM);
1229
1230         i = 0;
1231         do {
1232                 void __iomem *chunk;
1233
1234                 res = platform_get_resource(pdev, IORESOURCE_MEM, i);
1235                 if (!res)
1236                         break;
1237                 chunk = devm_ioremap_resource(&pdev->dev, res);
1238                 if (i == 0)
1239                         bgp->base = chunk;
1240                 if (IS_ERR(chunk))
1241                         return ERR_CAST(chunk);
1242
1243                 i++;
1244         } while (res);
1245
1246         if (TI_BANDGAP_HAS(bgp, TSHUT)) {
1247                 bgp->tshut_gpio = of_get_gpio(node, 0);
1248                 if (!gpio_is_valid(bgp->tshut_gpio)) {
1249                         dev_err(&pdev->dev, "invalid gpio for tshut (%d)\n",
1250                                 bgp->tshut_gpio);
1251                         return ERR_PTR(-EINVAL);
1252                 }
1253         }
1254
1255         return bgp;
1256 }
1257
1258 /***   Device driver call backs   ***/
1259
1260 static
1261 int ti_bandgap_probe(struct platform_device *pdev)
1262 {
1263         struct ti_bandgap *bgp;
1264         int clk_rate, ret, i;
1265
1266         bgp = ti_bandgap_build(pdev);
1267         if (IS_ERR(bgp)) {
1268                 dev_err(&pdev->dev, "failed to fetch platform data\n");
1269                 return PTR_ERR(bgp);
1270         }
1271         bgp->dev = &pdev->dev;
1272
1273         if (TI_BANDGAP_HAS(bgp, UNRELIABLE))
1274                 dev_warn(&pdev->dev,
1275                          "This OMAP thermal sensor is unreliable. You've been warned\n");
1276
1277         if (TI_BANDGAP_HAS(bgp, TSHUT)) {
1278                 ret = ti_bandgap_tshut_init(bgp, pdev);
1279                 if (ret) {
1280                         dev_err(&pdev->dev,
1281                                 "failed to initialize system tshut IRQ\n");
1282                         return ret;
1283                 }
1284         }
1285
1286         bgp->fclock = clk_get(NULL, bgp->conf->fclock_name);
1287         if (IS_ERR(bgp->fclock)) {
1288                 dev_err(&pdev->dev, "failed to request fclock reference\n");
1289                 ret = PTR_ERR(bgp->fclock);
1290                 goto free_irqs;
1291         }
1292
1293         bgp->div_clk = clk_get(NULL, bgp->conf->div_ck_name);
1294         if (IS_ERR(bgp->div_clk)) {
1295                 dev_err(&pdev->dev, "failed to request div_ts_ck clock ref\n");
1296                 ret = PTR_ERR(bgp->div_clk);
1297                 goto put_fclock;
1298         }
1299
1300         for (i = 0; i < bgp->conf->sensor_count; i++) {
1301                 struct temp_sensor_registers *tsr;
1302                 u32 val;
1303
1304                 tsr = bgp->conf->sensors[i].registers;
1305                 /*
1306                  * check if the efuse has a non-zero value if not
1307                  * it is an untrimmed sample and the temperatures
1308                  * may not be accurate
1309                  */
1310                 val = ti_bandgap_readl(bgp, tsr->bgap_efuse);
1311                 if (!val)
1312                         dev_info(&pdev->dev,
1313                                  "Non-trimmed BGAP, Temp not accurate\n");
1314         }
1315
1316         clk_rate = clk_round_rate(bgp->div_clk,
1317                                   bgp->conf->sensors[0].ts_data->max_freq);
1318         if (clk_rate < bgp->conf->sensors[0].ts_data->min_freq ||
1319             clk_rate <= 0) {
1320                 ret = -ENODEV;
1321                 dev_err(&pdev->dev, "wrong clock rate (%d)\n", clk_rate);
1322                 goto put_clks;
1323         }
1324
1325         ret = clk_set_rate(bgp->div_clk, clk_rate);
1326         if (ret)
1327                 dev_err(&pdev->dev, "Cannot re-set clock rate. Continuing\n");
1328
1329         bgp->clk_rate = clk_rate;
1330         if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1331                 clk_prepare_enable(bgp->fclock);
1332
1333
1334         spin_lock_init(&bgp->lock);
1335         bgp->dev = &pdev->dev;
1336         platform_set_drvdata(pdev, bgp);
1337
1338         ti_bandgap_power(bgp, true);
1339
1340         /* Set default counter to 1 for now */
1341         if (TI_BANDGAP_HAS(bgp, COUNTER))
1342                 for (i = 0; i < bgp->conf->sensor_count; i++)
1343                         RMW_BITS(bgp, i, bgap_counter, counter_mask, 1);
1344
1345         /* Set default thresholds for alert and shutdown */
1346         for (i = 0; i < bgp->conf->sensor_count; i++) {
1347                 struct temp_sensor_data *ts_data;
1348
1349                 ts_data = bgp->conf->sensors[i].ts_data;
1350
1351                 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1352                         /* Set initial Talert thresholds */
1353                         RMW_BITS(bgp, i, bgap_threshold,
1354                                  threshold_tcold_mask, ts_data->t_cold);
1355                         RMW_BITS(bgp, i, bgap_threshold,
1356                                  threshold_thot_mask, ts_data->t_hot);
1357                         /* Enable the alert events */
1358                         RMW_BITS(bgp, i, bgap_mask_ctrl, mask_hot_mask, 1);
1359                         RMW_BITS(bgp, i, bgap_mask_ctrl, mask_cold_mask, 1);
1360                 }
1361
1362                 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG)) {
1363                         /* Set initial Tshut thresholds */
1364                         RMW_BITS(bgp, i, tshut_threshold,
1365                                  tshut_hot_mask, ts_data->tshut_hot);
1366                         RMW_BITS(bgp, i, tshut_threshold,
1367                                  tshut_cold_mask, ts_data->tshut_cold);
1368                 }
1369         }
1370
1371         if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1372                 ti_bandgap_set_continuous_mode(bgp);
1373
1374         /* Set .250 seconds time as default counter */
1375         if (TI_BANDGAP_HAS(bgp, COUNTER))
1376                 for (i = 0; i < bgp->conf->sensor_count; i++)
1377                         RMW_BITS(bgp, i, bgap_counter, counter_mask,
1378                                  bgp->clk_rate / 4);
1379
1380         /* Every thing is good? Then expose the sensors */
1381         for (i = 0; i < bgp->conf->sensor_count; i++) {
1382                 char *domain;
1383
1384                 if (bgp->conf->sensors[i].register_cooling) {
1385                         ret = bgp->conf->sensors[i].register_cooling(bgp, i);
1386                         if (ret)
1387                                 goto remove_sensors;
1388                 }
1389
1390                 if (bgp->conf->expose_sensor) {
1391                         domain = bgp->conf->sensors[i].domain;
1392                         ret = bgp->conf->expose_sensor(bgp, i, domain);
1393                         if (ret)
1394                                 goto remove_last_cooling;
1395                 }
1396         }
1397
1398         /*
1399          * Enable the Interrupts once everything is set. Otherwise irq handler
1400          * might be called as soon as it is enabled where as rest of framework
1401          * is still getting initialised.
1402          */
1403         if (TI_BANDGAP_HAS(bgp, TALERT)) {
1404                 ret = ti_bandgap_talert_init(bgp, pdev);
1405                 if (ret) {
1406                         dev_err(&pdev->dev, "failed to initialize Talert IRQ\n");
1407                         i = bgp->conf->sensor_count;
1408                         goto disable_clk;
1409                 }
1410         }
1411
1412         return 0;
1413
1414 remove_last_cooling:
1415         if (bgp->conf->sensors[i].unregister_cooling)
1416                 bgp->conf->sensors[i].unregister_cooling(bgp, i);
1417 remove_sensors:
1418         for (i--; i >= 0; i--) {
1419                 if (bgp->conf->sensors[i].unregister_cooling)
1420                         bgp->conf->sensors[i].unregister_cooling(bgp, i);
1421                 if (bgp->conf->remove_sensor)
1422                         bgp->conf->remove_sensor(bgp, i);
1423         }
1424         ti_bandgap_power(bgp, false);
1425 disable_clk:
1426         if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1427                 clk_disable_unprepare(bgp->fclock);
1428 put_clks:
1429         clk_put(bgp->div_clk);
1430 put_fclock:
1431         clk_put(bgp->fclock);
1432 free_irqs:
1433         if (TI_BANDGAP_HAS(bgp, TSHUT)) {
1434                 free_irq(gpio_to_irq(bgp->tshut_gpio), NULL);
1435                 gpio_free(bgp->tshut_gpio);
1436         }
1437
1438         return ret;
1439 }
1440
1441 static
1442 int ti_bandgap_remove(struct platform_device *pdev)
1443 {
1444         struct ti_bandgap *bgp = platform_get_drvdata(pdev);
1445         int i;
1446
1447         /* First thing is to remove sensor interfaces */
1448         for (i = 0; i < bgp->conf->sensor_count; i++) {
1449                 if (bgp->conf->sensors[i].unregister_cooling)
1450                         bgp->conf->sensors[i].unregister_cooling(bgp, i);
1451
1452                 if (bgp->conf->remove_sensor)
1453                         bgp->conf->remove_sensor(bgp, i);
1454         }
1455
1456         ti_bandgap_power(bgp, false);
1457
1458         if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1459                 clk_disable_unprepare(bgp->fclock);
1460         clk_put(bgp->fclock);
1461         clk_put(bgp->div_clk);
1462
1463         if (TI_BANDGAP_HAS(bgp, TALERT))
1464                 free_irq(bgp->irq, bgp);
1465
1466         if (TI_BANDGAP_HAS(bgp, TSHUT)) {
1467                 free_irq(gpio_to_irq(bgp->tshut_gpio), NULL);
1468                 gpio_free(bgp->tshut_gpio);
1469         }
1470
1471         return 0;
1472 }
1473
1474 #ifdef CONFIG_PM_SLEEP
1475 static int ti_bandgap_save_ctxt(struct ti_bandgap *bgp)
1476 {
1477         int i;
1478
1479         for (i = 0; i < bgp->conf->sensor_count; i++) {
1480                 struct temp_sensor_registers *tsr;
1481                 struct temp_sensor_regval *rval;
1482
1483                 rval = &bgp->regval[i];
1484                 tsr = bgp->conf->sensors[i].registers;
1485
1486                 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1487                         rval->bg_mode_ctrl = ti_bandgap_readl(bgp,
1488                                                         tsr->bgap_mode_ctrl);
1489                 if (TI_BANDGAP_HAS(bgp, COUNTER))
1490                         rval->bg_counter = ti_bandgap_readl(bgp,
1491                                                         tsr->bgap_counter);
1492                 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1493                         rval->bg_threshold = ti_bandgap_readl(bgp,
1494                                                         tsr->bgap_threshold);
1495                         rval->bg_ctrl = ti_bandgap_readl(bgp,
1496                                                    tsr->bgap_mask_ctrl);
1497                 }
1498
1499                 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
1500                         rval->tshut_threshold = ti_bandgap_readl(bgp,
1501                                                    tsr->tshut_threshold);
1502         }
1503
1504         return 0;
1505 }
1506
1507 static int ti_bandgap_restore_ctxt(struct ti_bandgap *bgp)
1508 {
1509         int i;
1510
1511         for (i = 0; i < bgp->conf->sensor_count; i++) {
1512                 struct temp_sensor_registers *tsr;
1513                 struct temp_sensor_regval *rval;
1514                 u32 val = 0;
1515
1516                 rval = &bgp->regval[i];
1517                 tsr = bgp->conf->sensors[i].registers;
1518
1519                 if (TI_BANDGAP_HAS(bgp, COUNTER))
1520                         val = ti_bandgap_readl(bgp, tsr->bgap_counter);
1521
1522                 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
1523                         ti_bandgap_writel(bgp, rval->tshut_threshold,
1524                                           tsr->tshut_threshold);
1525                 /* Force immediate temperature measurement and update
1526                  * of the DTEMP field
1527                  */
1528                 ti_bandgap_force_single_read(bgp, i);
1529
1530                 if (TI_BANDGAP_HAS(bgp, COUNTER))
1531                         ti_bandgap_writel(bgp, rval->bg_counter,
1532                                           tsr->bgap_counter);
1533                 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1534                         ti_bandgap_writel(bgp, rval->bg_mode_ctrl,
1535                                           tsr->bgap_mode_ctrl);
1536                 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1537                         ti_bandgap_writel(bgp, rval->bg_threshold,
1538                                           tsr->bgap_threshold);
1539                         ti_bandgap_writel(bgp, rval->bg_ctrl,
1540                                           tsr->bgap_mask_ctrl);
1541                 }
1542         }
1543
1544         return 0;
1545 }
1546
1547 static int ti_bandgap_suspend(struct device *dev)
1548 {
1549         struct ti_bandgap *bgp = dev_get_drvdata(dev);
1550         int err;
1551
1552         err = ti_bandgap_save_ctxt(bgp);
1553         ti_bandgap_power(bgp, false);
1554
1555         if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1556                 clk_disable_unprepare(bgp->fclock);
1557
1558         return err;
1559 }
1560
1561 static int ti_bandgap_resume(struct device *dev)
1562 {
1563         struct ti_bandgap *bgp = dev_get_drvdata(dev);
1564
1565         if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1566                 clk_prepare_enable(bgp->fclock);
1567
1568         ti_bandgap_power(bgp, true);
1569
1570         return ti_bandgap_restore_ctxt(bgp);
1571 }
1572 static SIMPLE_DEV_PM_OPS(ti_bandgap_dev_pm_ops, ti_bandgap_suspend,
1573                          ti_bandgap_resume);
1574
1575 #define DEV_PM_OPS      (&ti_bandgap_dev_pm_ops)
1576 #else
1577 #define DEV_PM_OPS      NULL
1578 #endif
1579
1580 static const struct of_device_id of_ti_bandgap_match[] = {
1581 #ifdef CONFIG_OMAP3_THERMAL
1582         {
1583                 .compatible = "ti,omap34xx-bandgap",
1584                 .data = (void *)&omap34xx_data,
1585         },
1586         {
1587                 .compatible = "ti,omap36xx-bandgap",
1588                 .data = (void *)&omap36xx_data,
1589         },
1590 #endif
1591 #ifdef CONFIG_OMAP4_THERMAL
1592         {
1593                 .compatible = "ti,omap4430-bandgap",
1594                 .data = (void *)&omap4430_data,
1595         },
1596         {
1597                 .compatible = "ti,omap4460-bandgap",
1598                 .data = (void *)&omap4460_data,
1599         },
1600         {
1601                 .compatible = "ti,omap4470-bandgap",
1602                 .data = (void *)&omap4470_data,
1603         },
1604 #endif
1605 #ifdef CONFIG_OMAP5_THERMAL
1606         {
1607                 .compatible = "ti,omap5430-bandgap",
1608                 .data = (void *)&omap5430_data,
1609         },
1610 #endif
1611 #ifdef CONFIG_DRA752_THERMAL
1612         {
1613                 .compatible = "ti,dra752-bandgap",
1614                 .data = (void *)&dra752_data,
1615         },
1616 #endif
1617         /* Sentinel */
1618         { },
1619 };
1620 MODULE_DEVICE_TABLE(of, of_ti_bandgap_match);
1621
1622 static struct platform_driver ti_bandgap_sensor_driver = {
1623         .probe = ti_bandgap_probe,
1624         .remove = ti_bandgap_remove,
1625         .driver = {
1626                         .name = "ti-soc-thermal",
1627                         .pm = DEV_PM_OPS,
1628                         .of_match_table = of_ti_bandgap_match,
1629         },
1630 };
1631
1632 module_platform_driver(ti_bandgap_sensor_driver);
1633
1634 MODULE_DESCRIPTION("OMAP4+ bandgap temperature sensor driver");
1635 MODULE_LICENSE("GPL v2");
1636 MODULE_ALIAS("platform:ti-soc-thermal");
1637 MODULE_AUTHOR("Texas Instrument Inc.");