drivers/staging/omap-thermal/omap-bandgap.c

   1 /*
   2  * OMAP4 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/mutex.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/io.h>
  42
  43 #include "omap-bandgap.h"
  44
  45 /**
  46  * omap_bandgap_readl() - simple read helper function
  47  * @bg_ptr: pointer to omap_bandgap structure
  48  * @reg: desired register (offset) to be read
  49  *
  50  * Helper function to read bandgap registers. It uses the io remapped area.
  51  * Returns the register value.
  52  */
  53 static u32 omap_bandgap_readl(struct omap_bandgap *bg_ptr, u32 reg)
  54 {
  55         return readl(bg_ptr->base + reg);
  56 }
  57
  58 /**
  59  * omap_bandgap_writel() - simple write helper function
  60  * @bg_ptr: pointer to omap_bandgap structure
  61  * @val: desired register value to be written
  62  * @reg: desired register (offset) to be written
  63  *
  64  * Helper function to write bandgap registers. It uses the io remapped area.
  65  */
  66 static void omap_bandgap_writel(struct omap_bandgap *bg_ptr, u32 val, u32 reg)
  67 {
  68         writel(val, bg_ptr->base + reg);
  69 }
  70
  71 /**
  72  * DOC: macro to update bits.
  73  *
  74  * RMW_BITS() - used to read, modify and update bandgap bitfields.
  75  *            The value passed will be shifted.
  76  */
  77 #define RMW_BITS(bg_ptr, id, reg, mask, val)                    \
  78 do {                                                            \
  79         struct temp_sensor_registers *t;                        \
  80         u32 r;                                                  \
  81                                                                 \
  82         t = bg_ptr->conf->sensors[(id)].registers;              \
  83         r = omap_bandgap_readl(bg_ptr, t->reg);                 \
  84         r &= ~t->mask;                                          \
  85         r |= (val) << __ffs(t->mask);                           \
  86         omap_bandgap_writel(bg_ptr, r, t->reg);                 \
  87 } while (0)
  88
  89 /**
  90  * omap_bandgap_power() - controls the power state of a bandgap device
  91  * @bg_ptr: pointer to omap_bandgap structure
  92  * @on: desired power state (1 - on, 0 - off)
  93  *
  94  * Used to power on/off a bandgap device instance. Only used on those
  95  * that features tempsoff bit.
  96  */
  97 static int omap_bandgap_power(struct omap_bandgap *bg_ptr, bool on)
  98 {
  99         int i;
 100
 101         if (!OMAP_BANDGAP_HAS(bg_ptr, POWER_SWITCH))
 102                 goto exit;
 103
 104         for (i = 0; i < bg_ptr->conf->sensor_count; i++)
 105                 /* active on 0 */
 106                 RMW_BITS(bg_ptr, i, temp_sensor_ctrl, bgap_tempsoff_mask, !on);
 107
 108 exit:
 109         return 0;
 110 }
 111
 112 /**
 113  * omap_bandgap_read_temp() - helper function to read sensor temperature
 114  * @bg_ptr: pointer to omap_bandgap structure
 115  * @id: bandgap sensor id
 116  *
 117  * Function to concentrate the steps to read sensor temperature register.
 118  * This function is desired because, depending on bandgap device version,
 119  * it might be needed to freeze the bandgap state machine, before fetching
 120  * the register value.
 121  */
 122 static u32 omap_bandgap_read_temp(struct omap_bandgap *bg_ptr, int id)
 123 {
 124         struct temp_sensor_registers *tsr;
 125         u32 temp, reg;
 126
 127         tsr = bg_ptr->conf->sensors[id].registers;
 128         reg = tsr->temp_sensor_ctrl;
 129
 130         if (OMAP_BANDGAP_HAS(bg_ptr, FREEZE_BIT)) {
 131                 RMW_BITS(bg_ptr, id, bgap_mask_ctrl, mask_freeze_mask, 1);
 132                 /*
 133                  * In case we cannot read from cur_dtemp / dtemp_0,
 134                  * then we read from the last valid temp read
 135                  */
 136                 reg = tsr->ctrl_dtemp_1;
 137         }
 138
 139         /* read temperature */
 140         temp = omap_bandgap_readl(bg_ptr, reg);
 141         temp &= tsr->bgap_dtemp_mask;
 142
 143         if (OMAP_BANDGAP_HAS(bg_ptr, FREEZE_BIT))
 144                 RMW_BITS(bg_ptr, id, bgap_mask_ctrl, mask_freeze_mask, 0);
 145
 146         return temp;
 147 }
 148
 149 /* This is the Talert handler. Call it only if HAS(TALERT) is set */
 150 static irqreturn_t talert_irq_handler(int irq, void *data)
 151 {
 152         struct omap_bandgap *bg_ptr = data;
 153         struct temp_sensor_registers *tsr;
 154         u32 t_hot = 0, t_cold = 0, ctrl;
 155         int i;
 156
 157         bg_ptr = data;
 158         /* Read the status of t_hot */
 159         for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
 160                 tsr = bg_ptr->conf->sensors[i].registers;
 161                 t_hot = omap_bandgap_readl(bg_ptr, tsr->bgap_status);
 162                 t_hot &= tsr->status_hot_mask;
 163
 164                 /* Read the status of t_cold */
 165                 t_cold = omap_bandgap_readl(bg_ptr, tsr->bgap_status);
 166                 t_cold &= tsr->status_cold_mask;
 167
 168                 if (!t_cold && !t_hot)
 169                         continue;
 170
 171                 ctrl = omap_bandgap_readl(bg_ptr, tsr->bgap_mask_ctrl);
 172                 /*
 173                  * One TALERT interrupt: Two sources
 174                  * If the interrupt is due to t_hot then mask t_hot and
 175                  * and unmask t_cold else mask t_cold and unmask t_hot
 176                  */
 177                 if (t_hot) {
 178                         ctrl &= ~tsr->mask_hot_mask;
 179                         ctrl |= tsr->mask_cold_mask;
 180                 } else if (t_cold) {
 181                         ctrl &= ~tsr->mask_cold_mask;
 182                         ctrl |= tsr->mask_hot_mask;
 183                 }
 184
 185                 omap_bandgap_writel(bg_ptr, ctrl, tsr->bgap_mask_ctrl);
 186
 187                 dev_dbg(bg_ptr->dev,
 188                         "%s: IRQ from %s sensor: hotevent %d coldevent %d\n",
 189                         __func__, bg_ptr->conf->sensors[i].domain,
 190                         t_hot, t_cold);
 191
 192                 /* report temperature to whom may concern */
 193                 if (bg_ptr->conf->report_temperature)
 194                         bg_ptr->conf->report_temperature(bg_ptr, i);
 195         }
 196
 197         return IRQ_HANDLED;
 198 }
 199
 200 /* This is the Tshut handler. Call it only if HAS(TSHUT) is set */
 201 static irqreturn_t omap_bandgap_tshut_irq_handler(int irq, void *data)
 202 {
 203         pr_emerg("%s: TSHUT temperature reached. Needs shut down...\n",
 204                  __func__);
 205
 206         orderly_poweroff(true);
 207
 208         return IRQ_HANDLED;
 209 }
 210
 211 static
 212 int adc_to_temp_conversion(struct omap_bandgap *bg_ptr, int id, int adc_val,
 213                            int *t)
 214 {
 215         struct temp_sensor_data *ts_data = bg_ptr->conf->sensors[id].ts_data;
 216
 217         /* look up for temperature in the table and return the temperature */
 218         if (adc_val < ts_data->adc_start_val || adc_val > ts_data->adc_end_val)
 219                 return -ERANGE;
 220
 221         *t = bg_ptr->conf->conv_table[adc_val - ts_data->adc_start_val];
 222
 223         return 0;
 224 }
 225
 226 static int temp_to_adc_conversion(long temp, struct omap_bandgap *bg_ptr, int i,
 227                                   int *adc)
 228 {
 229         struct temp_sensor_data *ts_data = bg_ptr->conf->sensors[i].ts_data;
 230         const int *conv_table = bg_ptr->conf->conv_table;
 231         int high, low, mid;
 232
 233         low = 0;
 234         high = ts_data->adc_end_val - ts_data->adc_start_val;
 235         mid = (high + low) / 2;
 236
 237         if (temp < conv_table[low] || temp > conv_table[high])
 238                 return -EINVAL;
 239
 240         while (low < high) {
 241                 if (temp < conv_table[mid])
 242                         high = mid - 1;
 243                 else
 244                         low = mid + 1;
 245                 mid = (low + high) / 2;
 246         }
 247
 248         *adc = ts_data->adc_start_val + low;
 249
 250         return 0;
 251 }
 252
 253 /* Talert masks. Call it only if HAS(TALERT) is set */
 254 static int temp_sensor_unmask_interrupts(struct omap_bandgap *bg_ptr, int id,
 255                                          u32 t_hot, u32 t_cold)
 256 {
 257         struct temp_sensor_registers *tsr;
 258         u32 temp, reg_val;
 259
 260         /* Read the current on die temperature */
 261         temp = omap_bandgap_read_temp(bg_ptr, id);
 262
 263         tsr = bg_ptr->conf->sensors[id].registers;
 264         reg_val = omap_bandgap_readl(bg_ptr, tsr->bgap_mask_ctrl);
 265
 266         if (temp < t_hot)
 267                 reg_val |= tsr->mask_hot_mask;
 268         else
 269                 reg_val &= ~tsr->mask_hot_mask;
 270
 271         if (t_cold < temp)
 272                 reg_val |= tsr->mask_cold_mask;
 273         else
 274                 reg_val &= ~tsr->mask_cold_mask;
 275         omap_bandgap_writel(bg_ptr, reg_val, tsr->bgap_mask_ctrl);
 276
 277         return 0;
 278 }
 279
 280 static
 281 int add_hyst(int adc_val, int hyst_val, struct omap_bandgap *bg_ptr, int i,
 282              u32 *sum)
 283 {
 284         int temp, ret;
 285
 286         ret = adc_to_temp_conversion(bg_ptr, i, adc_val, &temp);
 287         if (ret < 0)
 288                 return ret;
 289
 290         temp += hyst_val;
 291
 292         return temp_to_adc_conversion(temp, bg_ptr, i, sum);
 293 }
 294
 295 /* Talert Thot threshold. Call it only if HAS(TALERT) is set */
 296 static
 297 int temp_sensor_configure_thot(struct omap_bandgap *bg_ptr, int id, int t_hot)
 298 {
 299         struct temp_sensor_data *ts_data = bg_ptr->conf->sensors[id].ts_data;
 300         struct temp_sensor_registers *tsr;
 301         u32 thresh_val, reg_val;
 302         int cold, err = 0;
 303
 304         tsr = bg_ptr->conf->sensors[id].registers;
 305
 306         /* obtain the T cold value */
 307         thresh_val = omap_bandgap_readl(bg_ptr, tsr->bgap_threshold);
 308         cold = (thresh_val & tsr->threshold_tcold_mask) >>
 309             __ffs(tsr->threshold_tcold_mask);
 310         if (t_hot <= cold) {
 311                 /* change the t_cold to t_hot - 5000 millidegrees */
 312                 err |= add_hyst(t_hot, -ts_data->hyst_val, bg_ptr, id, &cold);
 313                 /* write the new t_cold value */
 314                 reg_val = thresh_val & (~tsr->threshold_tcold_mask);
 315                 reg_val |= cold << __ffs(tsr->threshold_tcold_mask);
 316                 omap_bandgap_writel(bg_ptr, reg_val, tsr->bgap_threshold);
 317                 thresh_val = reg_val;
 318         }
 319
 320         /* write the new t_hot value */
 321         reg_val = thresh_val & ~tsr->threshold_thot_mask;
 322         reg_val |= (t_hot << __ffs(tsr->threshold_thot_mask));
 323         omap_bandgap_writel(bg_ptr, reg_val, tsr->bgap_threshold);
 324         if (err) {
 325                 dev_err(bg_ptr->dev, "failed to reprogram thot threshold\n");
 326                 return -EIO;
 327         }
 328
 329         return temp_sensor_unmask_interrupts(bg_ptr, id, t_hot, cold);
 330 }
 331
 332 /* Talert Tcold threshold. Call it only if HAS(TALERT) is set */
 333 static
 334 int temp_sensor_configure_tcold(struct omap_bandgap *bg_ptr, int id,
 335                                 int t_cold)
 336 {
 337         struct temp_sensor_data *ts_data = bg_ptr->conf->sensors[id].ts_data;
 338         struct temp_sensor_registers *tsr;
 339         u32 thresh_val, reg_val;
 340         int hot, err = 0;
 341
 342         tsr = bg_ptr->conf->sensors[id].registers;
 343         /* obtain the T cold value */
 344         thresh_val = omap_bandgap_readl(bg_ptr, tsr->bgap_threshold);
 345         hot = (thresh_val & tsr->threshold_thot_mask) >>
 346             __ffs(tsr->threshold_thot_mask);
 347
 348         if (t_cold >= hot) {
 349                 /* change the t_hot to t_cold + 5000 millidegrees */
 350                 err |= add_hyst(t_cold, ts_data->hyst_val, bg_ptr, id, &hot);
 351                 /* write the new t_hot value */
 352                 reg_val = thresh_val & (~tsr->threshold_thot_mask);
 353                 reg_val |= hot << __ffs(tsr->threshold_thot_mask);
 354                 omap_bandgap_writel(bg_ptr, reg_val, tsr->bgap_threshold);
 355                 thresh_val = reg_val;
 356         }
 357
 358         /* write the new t_cold value */
 359         reg_val = thresh_val & ~tsr->threshold_tcold_mask;
 360         reg_val |= (t_cold << __ffs(tsr->threshold_tcold_mask));
 361         omap_bandgap_writel(bg_ptr, reg_val, tsr->bgap_threshold);
 362         if (err) {
 363                 dev_err(bg_ptr->dev, "failed to reprogram tcold threshold\n");
 364                 return -EIO;
 365         }
 366
 367         return temp_sensor_unmask_interrupts(bg_ptr, id, hot, t_cold);
 368 }
 369
 370 #define bandgap_is_valid(b)                                             \
 371                         (!IS_ERR_OR_NULL(b))
 372 #define bandgap_is_valid_sensor_id(b, i)                                \
 373                         ((i) >= 0 && (i) < (b)->conf->sensor_count)
 374 static inline int omap_bandgap_validate(struct omap_bandgap *bg_ptr, int id)
 375 {
 376         if (!bandgap_is_valid(bg_ptr)) {
 377                 pr_err("%s: invalid bandgap pointer\n", __func__);
 378                 return -EINVAL;
 379         }
 380
 381         if (!bandgap_is_valid_sensor_id(bg_ptr, id)) {
 382                 dev_err(bg_ptr->dev, "%s: sensor id out of range (%d)\n",
 383                         __func__, id);
 384                 return -ERANGE;
 385         }
 386
 387         return 0;
 388 }
 389
 390 /* Exposed APIs */
 391 /**
 392  * omap_bandgap_read_thot() - reads sensor current thot
 393  * @bg_ptr - pointer to bandgap instance
 394  * @id - sensor id
 395  * @thot - resulting current thot value
 396  *
 397  * returns 0 on success or the proper error code
 398  */
 399 int omap_bandgap_read_thot(struct omap_bandgap *bg_ptr, int id,
 400                            int *thot)
 401 {
 402         struct temp_sensor_registers *tsr;
 403         u32 temp;
 404         int ret;
 405
 406         ret = omap_bandgap_validate(bg_ptr, id);
 407         if (ret)
 408                 return ret;
 409
 410         if (!OMAP_BANDGAP_HAS(bg_ptr, TALERT))
 411                 return -ENOTSUPP;
 412
 413         tsr = bg_ptr->conf->sensors[id].registers;
 414         temp = omap_bandgap_readl(bg_ptr, tsr->bgap_threshold);
 415         temp = (temp & tsr->threshold_thot_mask) >>
 416                 __ffs(tsr->threshold_thot_mask);
 417         ret |= adc_to_temp_conversion(bg_ptr, id, temp, &temp);
 418         if (ret) {
 419                 dev_err(bg_ptr->dev, "failed to read thot\n");
 420                 return -EIO;
 421         }
 422
 423         *thot = temp;
 424
 425         return 0;
 426 }
 427
 428 /**
 429  * omap_bandgap_write_thot() - sets sensor current thot
 430  * @bg_ptr - pointer to bandgap instance
 431  * @id - sensor id
 432  * @val - desired thot value
 433  *
 434  * returns 0 on success or the proper error code
 435  */
 436 int omap_bandgap_write_thot(struct omap_bandgap *bg_ptr, int id, int val)
 437 {
 438         struct temp_sensor_data *ts_data;
 439         struct temp_sensor_registers *tsr;
 440         u32 t_hot;
 441         int ret;
 442
 443         ret = omap_bandgap_validate(bg_ptr, id);
 444         if (ret)
 445                 return ret;
 446
 447         if (!OMAP_BANDGAP_HAS(bg_ptr, TALERT))
 448                 return -ENOTSUPP;
 449
 450         ts_data = bg_ptr->conf->sensors[id].ts_data;
 451         tsr = bg_ptr->conf->sensors[id].registers;
 452
 453         if (val < ts_data->min_temp + ts_data->hyst_val)
 454                 return -EINVAL;
 455         ret = temp_to_adc_conversion(val, bg_ptr, id, &t_hot);
 456         if (ret < 0)
 457                 return ret;
 458
 459         mutex_lock(&bg_ptr->bg_mutex);
 460         temp_sensor_configure_thot(bg_ptr, id, t_hot);
 461         mutex_unlock(&bg_ptr->bg_mutex);
 462
 463         return 0;
 464 }
 465
 466 /**
 467  * omap_bandgap_read_tcold() - reads sensor current tcold
 468  * @bg_ptr - pointer to bandgap instance
 469  * @id - sensor id
 470  * @tcold - resulting current tcold value
 471  *
 472  * returns 0 on success or the proper error code
 473  */
 474 int omap_bandgap_read_tcold(struct omap_bandgap *bg_ptr, int id,
 475                             int *tcold)
 476 {
 477         struct temp_sensor_registers *tsr;
 478         u32 temp;
 479         int ret;
 480
 481         ret = omap_bandgap_validate(bg_ptr, id);
 482         if (ret)
 483                 return ret;
 484
 485         if (!OMAP_BANDGAP_HAS(bg_ptr, TALERT))
 486                 return -ENOTSUPP;
 487
 488         tsr = bg_ptr->conf->sensors[id].registers;
 489         temp = omap_bandgap_readl(bg_ptr, tsr->bgap_threshold);
 490         temp = (temp & tsr->threshold_tcold_mask)
 491             >> __ffs(tsr->threshold_tcold_mask);
 492         ret |= adc_to_temp_conversion(bg_ptr, id, temp, &temp);
 493         if (ret)
 494                 return -EIO;
 495
 496         *tcold = temp;
 497
 498         return 0;
 499 }
 500
 501 /**
 502  * omap_bandgap_write_tcold() - sets the sensor tcold
 503  * @bg_ptr - pointer to bandgap instance
 504  * @id - sensor id
 505  * @val - desired tcold value
 506  *
 507  * returns 0 on success or the proper error code
 508  */
 509 int omap_bandgap_write_tcold(struct omap_bandgap *bg_ptr, int id, int val)
 510 {
 511         struct temp_sensor_data *ts_data;
 512         struct temp_sensor_registers *tsr;
 513         u32 t_cold;
 514         int ret;
 515
 516         ret = omap_bandgap_validate(bg_ptr, id);
 517         if (ret)
 518                 return ret;
 519
 520         if (!OMAP_BANDGAP_HAS(bg_ptr, TALERT))
 521                 return -ENOTSUPP;
 522
 523         ts_data = bg_ptr->conf->sensors[id].ts_data;
 524         tsr = bg_ptr->conf->sensors[id].registers;
 525         if (val > ts_data->max_temp + ts_data->hyst_val)
 526                 return -EINVAL;
 527
 528         ret = temp_to_adc_conversion(val, bg_ptr, id, &t_cold);
 529         if (ret < 0)
 530                 return ret;
 531
 532         mutex_lock(&bg_ptr->bg_mutex);
 533         temp_sensor_configure_tcold(bg_ptr, id, t_cold);
 534         mutex_unlock(&bg_ptr->bg_mutex);
 535
 536         return 0;
 537 }
 538
 539 /**
 540  * omap_bandgap_read_update_interval() - read the sensor update interval
 541  * @bg_ptr - pointer to bandgap instance
 542  * @id - sensor id
 543  * @interval - resulting update interval in miliseconds
 544  *
 545  * returns 0 on success or the proper error code
 546  */
 547 int omap_bandgap_read_update_interval(struct omap_bandgap *bg_ptr, int id,
 548                                          int *interval)
 549 {
 550         struct temp_sensor_registers *tsr;
 551         u32 time;
 552         int ret;
 553
 554         ret = omap_bandgap_validate(bg_ptr, id);
 555         if (ret)
 556                 return ret;
 557
 558         if (!OMAP_BANDGAP_HAS(bg_ptr, COUNTER))
 559                 return -ENOTSUPP;
 560
 561         tsr = bg_ptr->conf->sensors[id].registers;
 562         time = omap_bandgap_readl(bg_ptr, tsr->bgap_counter);
 563         time = (time & tsr->counter_mask) >> __ffs(tsr->counter_mask);
 564         time = time * 1000 / bg_ptr->clk_rate;
 565
 566         *interval = time;
 567
 568         return 0;
 569 }
 570
 571 /**
 572  * omap_bandgap_write_update_interval() - set the update interval
 573  * @bg_ptr - pointer to bandgap instance
 574  * @id - sensor id
 575  * @interval - desired update interval in miliseconds
 576  *
 577  * returns 0 on success or the proper error code
 578  */
 579 int omap_bandgap_write_update_interval(struct omap_bandgap *bg_ptr,
 580                                        int id, u32 interval)
 581 {
 582         int ret = omap_bandgap_validate(bg_ptr, id);
 583         if (ret)
 584                 return ret;
 585
 586         if (!OMAP_BANDGAP_HAS(bg_ptr, COUNTER))
 587                 return -ENOTSUPP;
 588
 589         interval = interval * bg_ptr->clk_rate / 1000;
 590         mutex_lock(&bg_ptr->bg_mutex);
 591         RMW_BITS(bg_ptr, id, bgap_counter, counter_mask, interval);
 592         mutex_unlock(&bg_ptr->bg_mutex);
 593
 594         return 0;
 595 }
 596
 597 /**
 598  * omap_bandgap_read_temperature() - report current temperature
 599  * @bg_ptr - pointer to bandgap instance
 600  * @id - sensor id
 601  * @temperature - resulting temperature
 602  *
 603  * returns 0 on success or the proper error code
 604  */
 605 int omap_bandgap_read_temperature(struct omap_bandgap *bg_ptr, int id,
 606                                   int *temperature)
 607 {
 608         u32 temp;
 609         int ret;
 610
 611         ret = omap_bandgap_validate(bg_ptr, id);
 612         if (ret)
 613                 return ret;
 614
 615         mutex_lock(&bg_ptr->bg_mutex);
 616         temp = omap_bandgap_read_temp(bg_ptr, id);
 617         mutex_unlock(&bg_ptr->bg_mutex);
 618
 619         ret |= adc_to_temp_conversion(bg_ptr, id, temp, &temp);
 620         if (ret)
 621                 return -EIO;
 622
 623         *temperature = temp;
 624
 625         return 0;
 626 }
 627
 628 /**
 629  * omap_bandgap_set_sensor_data() - helper function to store thermal
 630  * framework related data.
 631  * @bg_ptr - pointer to bandgap instance
 632  * @id - sensor id
 633  * @data - thermal framework related data to be stored
 634  *
 635  * returns 0 on success or the proper error code
 636  */
 637 int omap_bandgap_set_sensor_data(struct omap_bandgap *bg_ptr, int id,
 638                                  void *data)
 639 {
 640         int ret = omap_bandgap_validate(bg_ptr, id);
 641         if (ret)
 642                 return ret;
 643
 644         bg_ptr->conf->sensors[id].data = data;
 645
 646         return 0;
 647 }
 648
 649 /**
 650  * omap_bandgap_get_sensor_data() - helper function to get thermal
 651  * framework related data.
 652  * @bg_ptr - pointer to bandgap instance
 653  * @id - sensor id
 654  *
 655  * returns data stored by set function with sensor id on success or NULL
 656  */
 657 void *omap_bandgap_get_sensor_data(struct omap_bandgap *bg_ptr, int id)
 658 {
 659         int ret = omap_bandgap_validate(bg_ptr, id);
 660         if (ret)
 661                 return ERR_PTR(ret);
 662
 663         return bg_ptr->conf->sensors[id].data;
 664 }
 665
 666 static int
 667 omap_bandgap_force_single_read(struct omap_bandgap *bg_ptr, int id)
 668 {
 669         u32 temp = 0, counter = 1000;
 670
 671         /* Select single conversion mode */
 672         if (OMAP_BANDGAP_HAS(bg_ptr, MODE_CONFIG))
 673                 RMW_BITS(bg_ptr, id, bgap_mode_ctrl, mode_ctrl_mask, 0);
 674
 675         /* Start of Conversion = 1 */
 676         RMW_BITS(bg_ptr, id, temp_sensor_ctrl, bgap_soc_mask, 1);
 677         /* Wait until DTEMP is updated */
 678         temp = omap_bandgap_read_temp(bg_ptr, id);
 679
 680         while ((temp == 0) && --counter)
 681                 temp = omap_bandgap_read_temp(bg_ptr, id);
 682         /* REVISIT: Check correct condition for end of conversion */
 683
 684         /* Start of Conversion = 0 */
 685         RMW_BITS(bg_ptr, id, temp_sensor_ctrl, bgap_soc_mask, 0);
 686
 687         return 0;
 688 }
 689
 690 /**
 691  * enable_continuous_mode() - One time enabling of continuous conversion mode
 692  * @bg_ptr - pointer to scm instance
 693  *
 694  * Call this function only if HAS(MODE_CONFIG) is set
 695  */
 696 static int enable_continuous_mode(struct omap_bandgap *bg_ptr)
 697 {
 698         int i;
 699
 700         for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
 701                 /* Perform a single read just before enabling continuous */
 702                 omap_bandgap_force_single_read(bg_ptr, i);
 703                 RMW_BITS(bg_ptr, i, bgap_mode_ctrl, mode_ctrl_mask, 1);
 704         }
 705
 706         return 0;
 707 }
 708
 709 static int omap_bandgap_tshut_init(struct omap_bandgap *bg_ptr,
 710                                    struct platform_device *pdev)
 711 {
 712         int gpio_nr = bg_ptr->tshut_gpio;
 713         int status;
 714
 715         /* Request for gpio_86 line */
 716         status = gpio_request(gpio_nr, "tshut");
 717         if (status < 0) {
 718                 dev_err(bg_ptr->dev,
 719                         "Could not request for TSHUT GPIO:%i\n", 86);
 720                 return status;
 721         }
 722         status = gpio_direction_input(gpio_nr);
 723         if (status) {
 724                 dev_err(bg_ptr->dev,
 725                         "Cannot set input TSHUT GPIO %d\n", gpio_nr);
 726                 return status;
 727         }
 728
 729         status = request_irq(gpio_to_irq(gpio_nr),
 730                              omap_bandgap_tshut_irq_handler,
 731                              IRQF_TRIGGER_RISING, "tshut",
 732                              NULL);
 733         if (status) {
 734                 gpio_free(gpio_nr);
 735                 dev_err(bg_ptr->dev, "request irq failed for TSHUT");
 736         }
 737
 738         return 0;
 739 }
 740
 741 /* Initialization of Talert. Call it only if HAS(TALERT) is set */
 742 static int omap_bandgap_talert_init(struct omap_bandgap *bg_ptr,
 743                                     struct platform_device *pdev)
 744 {
 745         int ret;
 746
 747         bg_ptr->irq = platform_get_irq(pdev, 0);
 748         if (bg_ptr->irq < 0) {
 749                 dev_err(&pdev->dev, "get_irq failed\n");
 750                 return bg_ptr->irq;
 751         }
 752         ret = request_threaded_irq(bg_ptr->irq, NULL,
 753                                    talert_irq_handler,
 754                                    IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
 755                                    "talert", bg_ptr);
 756         if (ret) {
 757                 dev_err(&pdev->dev, "Request threaded irq failed.\n");
 758                 return ret;
 759         }
 760
 761         return 0;
 762 }
 763
 764 static const struct of_device_id of_omap_bandgap_match[];
 765 static struct omap_bandgap *omap_bandgap_build(struct platform_device *pdev)
 766 {
 767         struct device_node *node = pdev->dev.of_node;
 768         const struct of_device_id *of_id;
 769         struct omap_bandgap *bg_ptr;
 770         struct resource *res;
 771         u32 prop;
 772         int i;
 773
 774         /* just for the sake */
 775         if (!node) {
 776                 dev_err(&pdev->dev, "no platform information available\n");
 777                 return ERR_PTR(-EINVAL);
 778         }
 779
 780         bg_ptr = devm_kzalloc(&pdev->dev, sizeof(struct omap_bandgap),
 781                                     GFP_KERNEL);
 782         if (!bg_ptr) {
 783                 dev_err(&pdev->dev, "Unable to allocate mem for driver ref\n");
 784                 return ERR_PTR(-ENOMEM);
 785         }
 786
 787         of_id = of_match_device(of_omap_bandgap_match, &pdev->dev);
 788         if (of_id)
 789                 bg_ptr->conf = of_id->data;
 790
 791         i = 0;
 792         do {
 793                 void __iomem *chunk;
 794
 795                 res = platform_get_resource(pdev, IORESOURCE_MEM, i);
 796                 if (!res)
 797                         break;
 798                 chunk = devm_ioremap_resource(&pdev->dev, res);
 799                 if (i == 0)
 800                         bg_ptr->base = chunk;
 801                 if (IS_ERR(chunk))
 802                         return ERR_CAST(chunk);
 803
 804                 i++;
 805         } while (res);
 806
 807         if (OMAP_BANDGAP_HAS(bg_ptr, TSHUT)) {
 808                 if (of_property_read_u32(node, "ti,tshut-gpio", &prop) < 0) {
 809                         dev_err(&pdev->dev, "missing tshut gpio in device tree\n");
 810                         return ERR_PTR(-EINVAL);
 811                 }
 812                 bg_ptr->tshut_gpio = prop;
 813                 if (!gpio_is_valid(bg_ptr->tshut_gpio)) {
 814                         dev_err(&pdev->dev, "invalid gpio for tshut (%d)\n",
 815                                 bg_ptr->tshut_gpio);
 816                         return ERR_PTR(-EINVAL);
 817                 }
 818         }
 819
 820         return bg_ptr;
 821 }
 822
 823 static
 824 int omap_bandgap_probe(struct platform_device *pdev)
 825 {
 826         struct omap_bandgap *bg_ptr;
 827         int clk_rate, ret = 0, i;
 828
 829         bg_ptr = omap_bandgap_build(pdev);
 830         if (IS_ERR_OR_NULL(bg_ptr)) {
 831                 dev_err(&pdev->dev, "failed to fetch platform data\n");
 832                 return PTR_ERR(bg_ptr);
 833         }
 834         bg_ptr->dev = &pdev->dev;
 835
 836         if (OMAP_BANDGAP_HAS(bg_ptr, TSHUT)) {
 837                 ret = omap_bandgap_tshut_init(bg_ptr, pdev);
 838                 if (ret) {
 839                         dev_err(&pdev->dev,
 840                                 "failed to initialize system tshut IRQ\n");
 841                         return ret;
 842                 }
 843         }
 844
 845         bg_ptr->fclock = clk_get(NULL, bg_ptr->conf->fclock_name);
 846         ret = IS_ERR_OR_NULL(bg_ptr->fclock);
 847         if (ret) {
 848                 dev_err(&pdev->dev, "failed to request fclock reference\n");
 849                 goto free_irqs;
 850         }
 851
 852         bg_ptr->div_clk = clk_get(NULL,  bg_ptr->conf->div_ck_name);
 853         ret = IS_ERR_OR_NULL(bg_ptr->div_clk);
 854         if (ret) {
 855                 dev_err(&pdev->dev,
 856                         "failed to request div_ts_ck clock ref\n");
 857                 goto free_irqs;
 858         }
 859
 860         for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
 861                 struct temp_sensor_registers *tsr;
 862                 u32 val;
 863
 864                 tsr = bg_ptr->conf->sensors[i].registers;
 865                 /*
 866                  * check if the efuse has a non-zero value if not
 867                  * it is an untrimmed sample and the temperatures
 868                  * may not be accurate
 869                  */
 870                 val = omap_bandgap_readl(bg_ptr, tsr->bgap_efuse);
 871                 if (ret || !val)
 872                         dev_info(&pdev->dev,
 873                                  "Non-trimmed BGAP, Temp not accurate\n");
 874         }
 875
 876         clk_rate = clk_round_rate(bg_ptr->div_clk,
 877                                   bg_ptr->conf->sensors[0].ts_data->max_freq);
 878         if (clk_rate < bg_ptr->conf->sensors[0].ts_data->min_freq ||
 879             clk_rate == 0xffffffff) {
 880                 ret = -ENODEV;
 881                 dev_err(&pdev->dev, "wrong clock rate (%d)\n", clk_rate);
 882                 goto put_clks;
 883         }
 884
 885         ret = clk_set_rate(bg_ptr->div_clk, clk_rate);
 886         if (ret)
 887                 dev_err(&pdev->dev, "Cannot re-set clock rate. Continuing\n");
 888
 889         bg_ptr->clk_rate = clk_rate;
 890         if (OMAP_BANDGAP_HAS(bg_ptr, CLK_CTRL))
 891                 clk_prepare_enable(bg_ptr->fclock);
 892
 893
 894         mutex_init(&bg_ptr->bg_mutex);
 895         bg_ptr->dev = &pdev->dev;
 896         platform_set_drvdata(pdev, bg_ptr);
 897
 898         omap_bandgap_power(bg_ptr, true);
 899
 900         /* Set default counter to 1 for now */
 901         if (OMAP_BANDGAP_HAS(bg_ptr, COUNTER))
 902                 for (i = 0; i < bg_ptr->conf->sensor_count; i++)
 903                         RMW_BITS(bg_ptr, i, bgap_counter, counter_mask, 1);
 904
 905         /* Set default thresholds for alert and shutdown */
 906         for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
 907                 struct temp_sensor_data *ts_data;
 908
 909                 ts_data = bg_ptr->conf->sensors[i].ts_data;
 910
 911                 if (OMAP_BANDGAP_HAS(bg_ptr, TALERT)) {
 912                         /* Set initial Talert thresholds */
 913                         RMW_BITS(bg_ptr, i, bgap_threshold,
 914                                  threshold_tcold_mask, ts_data->t_cold);
 915                         RMW_BITS(bg_ptr, i, bgap_threshold,
 916                                  threshold_thot_mask, ts_data->t_hot);
 917                         /* Enable the alert events */
 918                         RMW_BITS(bg_ptr, i, bgap_mask_ctrl, mask_hot_mask, 1);
 919                         RMW_BITS(bg_ptr, i, bgap_mask_ctrl, mask_cold_mask, 1);
 920                 }
 921
 922                 if (OMAP_BANDGAP_HAS(bg_ptr, TSHUT_CONFIG)) {
 923                         /* Set initial Tshut thresholds */
 924                         RMW_BITS(bg_ptr, i, tshut_threshold,
 925                                  tshut_hot_mask, ts_data->tshut_hot);
 926                         RMW_BITS(bg_ptr, i, tshut_threshold,
 927                                  tshut_cold_mask, ts_data->tshut_cold);
 928                 }
 929         }
 930
 931         if (OMAP_BANDGAP_HAS(bg_ptr, MODE_CONFIG))
 932                 enable_continuous_mode(bg_ptr);
 933
 934         /* Set .250 seconds time as default counter */
 935         if (OMAP_BANDGAP_HAS(bg_ptr, COUNTER))
 936                 for (i = 0; i < bg_ptr->conf->sensor_count; i++)
 937                         RMW_BITS(bg_ptr, i, bgap_counter, counter_mask,
 938                                  bg_ptr->clk_rate / 4);
 939
 940         /* Every thing is good? Then expose the sensors */
 941         for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
 942                 char *domain;
 943
 944                 if (bg_ptr->conf->sensors[i].register_cooling)
 945                         bg_ptr->conf->sensors[i].register_cooling(bg_ptr, i);
 946
 947                 domain = bg_ptr->conf->sensors[i].domain;
 948                 if (bg_ptr->conf->expose_sensor)
 949                         bg_ptr->conf->expose_sensor(bg_ptr, i, domain);
 950         }
 951
 952         /*
 953          * Enable the Interrupts once everything is set. Otherwise irq handler
 954          * might be called as soon as it is enabled where as rest of framework
 955          * is still getting initialised.
 956          */
 957         if (OMAP_BANDGAP_HAS(bg_ptr, TALERT)) {
 958                 ret = omap_bandgap_talert_init(bg_ptr, pdev);
 959                 if (ret) {
 960                         dev_err(&pdev->dev, "failed to initialize Talert IRQ\n");
 961                         i = bg_ptr->conf->sensor_count;
 962                         goto disable_clk;
 963                 }
 964         }
 965
 966         return 0;
 967
 968 disable_clk:
 969         if (OMAP_BANDGAP_HAS(bg_ptr, CLK_CTRL))
 970                 clk_disable_unprepare(bg_ptr->fclock);
 971 put_clks:
 972         clk_put(bg_ptr->fclock);
 973         clk_put(bg_ptr->div_clk);
 974 free_irqs:
 975         if (OMAP_BANDGAP_HAS(bg_ptr, TSHUT)) {
 976                 free_irq(gpio_to_irq(bg_ptr->tshut_gpio), NULL);
 977                 gpio_free(bg_ptr->tshut_gpio);
 978         }
 979
 980         return ret;
 981 }
 982
 983 static
 984 int omap_bandgap_remove(struct platform_device *pdev)
 985 {
 986         struct omap_bandgap *bg_ptr = platform_get_drvdata(pdev);
 987         int i;
 988
 989         /* First thing is to remove sensor interfaces */
 990         for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
 991                 if (bg_ptr->conf->sensors[i].register_cooling)
 992                         bg_ptr->conf->sensors[i].unregister_cooling(bg_ptr, i);
 993
 994                 if (bg_ptr->conf->remove_sensor)
 995                         bg_ptr->conf->remove_sensor(bg_ptr, i);
 996         }
 997
 998         omap_bandgap_power(bg_ptr, false);
 999
1000         if (OMAP_BANDGAP_HAS(bg_ptr, CLK_CTRL))
1001                 clk_disable_unprepare(bg_ptr->fclock);
1002         clk_put(bg_ptr->fclock);
1003         clk_put(bg_ptr->div_clk);
1004
1005         if (OMAP_BANDGAP_HAS(bg_ptr, TALERT))
1006                 free_irq(bg_ptr->irq, bg_ptr);
1007
1008         if (OMAP_BANDGAP_HAS(bg_ptr, TSHUT)) {
1009                 free_irq(gpio_to_irq(bg_ptr->tshut_gpio), NULL);
1010                 gpio_free(bg_ptr->tshut_gpio);
1011         }
1012
1013         return 0;
1014 }
1015
1016 #ifdef CONFIG_PM
1017 static int omap_bandgap_save_ctxt(struct omap_bandgap *bg_ptr)
1018 {
1019         int i;
1020
1021         for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
1022                 struct temp_sensor_registers *tsr;
1023                 struct temp_sensor_regval *rval;
1024
1025                 rval = &bg_ptr->conf->sensors[i].regval;
1026                 tsr = bg_ptr->conf->sensors[i].registers;
1027
1028                 if (OMAP_BANDGAP_HAS(bg_ptr, MODE_CONFIG))
1029                         rval->bg_mode_ctrl = omap_bandgap_readl(bg_ptr,
1030                                                         tsr->bgap_mode_ctrl);
1031                 if (OMAP_BANDGAP_HAS(bg_ptr, COUNTER))
1032                         rval->bg_counter = omap_bandgap_readl(bg_ptr,
1033                                                         tsr->bgap_counter);
1034                 if (OMAP_BANDGAP_HAS(bg_ptr, TALERT)) {
1035                         rval->bg_threshold = omap_bandgap_readl(bg_ptr,
1036                                                         tsr->bgap_threshold);
1037                         rval->bg_ctrl = omap_bandgap_readl(bg_ptr,
1038                                                    tsr->bgap_mask_ctrl);
1039                 }
1040
1041                 if (OMAP_BANDGAP_HAS(bg_ptr, TSHUT_CONFIG))
1042                         rval->tshut_threshold = omap_bandgap_readl(bg_ptr,
1043                                                    tsr->tshut_threshold);
1044         }
1045
1046         return 0;
1047 }
1048
1049 static int omap_bandgap_restore_ctxt(struct omap_bandgap *bg_ptr)
1050 {
1051         int i;
1052
1053         for (i = 0; i < bg_ptr->conf->sensor_count; i++) {
1054                 struct temp_sensor_registers *tsr;
1055                 struct temp_sensor_regval *rval;
1056                 u32 val = 0;
1057
1058                 rval = &bg_ptr->conf->sensors[i].regval;
1059                 tsr = bg_ptr->conf->sensors[i].registers;
1060
1061                 if (OMAP_BANDGAP_HAS(bg_ptr, COUNTER))
1062                         val = omap_bandgap_readl(bg_ptr, tsr->bgap_counter);
1063
1064                 if (OMAP_BANDGAP_HAS(bg_ptr, TSHUT_CONFIG))
1065                         omap_bandgap_writel(bg_ptr, rval->tshut_threshold,
1066                                             tsr->tshut_threshold);
1067                 /* Force immediate temperature measurement and update
1068                  * of the DTEMP field
1069                  */
1070                 omap_bandgap_force_single_read(bg_ptr, i);
1071
1072                 if (OMAP_BANDGAP_HAS(bg_ptr, COUNTER))
1073                         omap_bandgap_writel(bg_ptr, rval->bg_counter,
1074                                             tsr->bgap_counter);
1075                 if (OMAP_BANDGAP_HAS(bg_ptr, MODE_CONFIG))
1076                         omap_bandgap_writel(bg_ptr, rval->bg_mode_ctrl,
1077                                             tsr->bgap_mode_ctrl);
1078                 if (OMAP_BANDGAP_HAS(bg_ptr, TALERT)) {
1079                         omap_bandgap_writel(bg_ptr, rval->bg_threshold,
1080                                             tsr->bgap_threshold);
1081                         omap_bandgap_writel(bg_ptr, rval->bg_ctrl,
1082                                             tsr->bgap_mask_ctrl);
1083                 }
1084         }
1085
1086         return 0;
1087 }
1088
1089 static int omap_bandgap_suspend(struct device *dev)
1090 {
1091         struct omap_bandgap *bg_ptr = dev_get_drvdata(dev);
1092         int err;
1093
1094         err = omap_bandgap_save_ctxt(bg_ptr);
1095         omap_bandgap_power(bg_ptr, false);
1096
1097         if (OMAP_BANDGAP_HAS(bg_ptr, CLK_CTRL))
1098                 clk_disable_unprepare(bg_ptr->fclock);
1099
1100         return err;
1101 }
1102
1103 static int omap_bandgap_resume(struct device *dev)
1104 {
1105         struct omap_bandgap *bg_ptr = dev_get_drvdata(dev);
1106
1107         if (OMAP_BANDGAP_HAS(bg_ptr, CLK_CTRL))
1108                 clk_prepare_enable(bg_ptr->fclock);
1109
1110         omap_bandgap_power(bg_ptr, true);
1111
1112         return omap_bandgap_restore_ctxt(bg_ptr);
1113 }
1114 static const struct dev_pm_ops omap_bandgap_dev_pm_ops = {
1115         SET_SYSTEM_SLEEP_PM_OPS(omap_bandgap_suspend,
1116                                 omap_bandgap_resume)
1117 };
1118
1119 #define DEV_PM_OPS      (&omap_bandgap_dev_pm_ops)
1120 #else
1121 #define DEV_PM_OPS      NULL
1122 #endif
1123
1124 static const struct of_device_id of_omap_bandgap_match[] = {
1125 #ifdef CONFIG_OMAP4_THERMAL
1126         {
1127                 .compatible = "ti,omap4430-bandgap",
1128                 .data = (void *)&omap4430_data,
1129         },
1130         {
1131                 .compatible = "ti,omap4460-bandgap",
1132                 .data = (void *)&omap4460_data,
1133         },
1134         {
1135                 .compatible = "ti,omap4470-bandgap",
1136                 .data = (void *)&omap4470_data,
1137         },
1138 #endif
1139 #ifdef CONFIG_OMAP5_THERMAL
1140         {
1141                 .compatible = "ti,omap5430-bandgap",
1142                 .data = (void *)&omap5430_data,
1143         },
1144 #endif
1145         /* Sentinel */
1146         { },
1147 };
1148 MODULE_DEVICE_TABLE(of, of_omap_bandgap_match);
1149
1150 static struct platform_driver omap_bandgap_sensor_driver = {
1151         .probe = omap_bandgap_probe,
1152         .remove = omap_bandgap_remove,
1153         .driver = {
1154                         .name = "omap-bandgap",
1155                         .pm = DEV_PM_OPS,
1156                         .of_match_table = of_omap_bandgap_match,
1157         },
1158 };
1159
1160 module_platform_driver(omap_bandgap_sensor_driver);
1161
1162 MODULE_DESCRIPTION("OMAP4+ bandgap temperature sensor driver");
1163 MODULE_LICENSE("GPL v2");
1164 MODULE_ALIAS("platform:omap-bandgap");
1165 MODULE_AUTHOR("Texas Instrument Inc.");