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