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