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