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