Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 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

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_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 

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