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