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