Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/thermal/ti-soc-thermal/ti-bandgap.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us