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