2 * exynos_tmu.c - Samsung EXYNOS TMU (Thermal Management Unit)
4 * Copyright (C) 2011 Samsung Electronics
5 * Donggeun Kim <dg77.kim@samsung.com>
6 * Amit Daniel Kachhap <amit.kachhap@linaro.org>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/clk.h>
26 #include <linux/interrupt.h>
27 #include <linux/module.h>
29 #include <linux/of_address.h>
30 #include <linux/of_irq.h>
31 #include <linux/platform_device.h>
32 #include <linux/regulator/consumer.h>
34 #include "exynos_thermal_common.h"
35 #include "exynos_tmu.h"
36 #include "exynos_tmu_data.h"
39 * struct exynos_tmu_data : A structure to hold the private data of the TMU
41 * @id: identifier of the one instance of the TMU controller.
42 * @pdata: pointer to the tmu platform/configuration data
43 * @base: base address of the single instance of the TMU controller.
44 * @base_second: base address of the common registers of the TMU controller.
45 * @irq: irq number of the TMU controller.
46 * @soc: id of the SOC type.
47 * @irq_work: pointer to the irq work structure.
48 * @lock: lock to implement synchronization.
49 * @clk: pointer to the clock structure.
50 * @clk_sec: pointer to the clock structure for accessing the base_second.
51 * @temp_error1: fused value of the first point trim.
52 * @temp_error2: fused value of the second point trim.
53 * @regulator: pointer to the TMU regulator structure.
54 * @reg_conf: pointer to structure to register with core thermal.
55 * @tmu_initialize: SoC specific TMU initialization method
56 * @tmu_control: SoC specific TMU control method
57 * @tmu_read: SoC specific TMU temperature read method
58 * @tmu_set_emulation: SoC specific TMU emulation setting method
60 struct exynos_tmu_data
{
62 struct exynos_tmu_platform_data
*pdata
;
64 void __iomem
*base_second
;
67 struct work_struct irq_work
;
69 struct clk
*clk
, *clk_sec
;
70 u8 temp_error1
, temp_error2
;
71 struct regulator
*regulator
;
72 struct thermal_sensor_conf
*reg_conf
;
73 int (*tmu_initialize
)(struct platform_device
*pdev
);
74 void (*tmu_control
)(struct platform_device
*pdev
, bool on
);
75 int (*tmu_read
)(struct exynos_tmu_data
*data
);
76 void (*tmu_set_emulation
)(struct exynos_tmu_data
*data
,
81 * TMU treats temperature as a mapped temperature code.
82 * The temperature is converted differently depending on the calibration type.
84 static int temp_to_code(struct exynos_tmu_data
*data
, u8 temp
)
86 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
89 switch (pdata
->cal_type
) {
90 case TYPE_TWO_POINT_TRIMMING
:
91 temp_code
= (temp
- pdata
->first_point_trim
) *
92 (data
->temp_error2
- data
->temp_error1
) /
93 (pdata
->second_point_trim
- pdata
->first_point_trim
) +
96 case TYPE_ONE_POINT_TRIMMING
:
97 temp_code
= temp
+ data
->temp_error1
- pdata
->first_point_trim
;
100 temp_code
= temp
+ pdata
->default_temp_offset
;
108 * Calculate a temperature value from a temperature code.
109 * The unit of the temperature is degree Celsius.
111 static int code_to_temp(struct exynos_tmu_data
*data
, u8 temp_code
)
113 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
116 switch (pdata
->cal_type
) {
117 case TYPE_TWO_POINT_TRIMMING
:
118 temp
= (temp_code
- data
->temp_error1
) *
119 (pdata
->second_point_trim
- pdata
->first_point_trim
) /
120 (data
->temp_error2
- data
->temp_error1
) +
121 pdata
->first_point_trim
;
123 case TYPE_ONE_POINT_TRIMMING
:
124 temp
= temp_code
- data
->temp_error1
+ pdata
->first_point_trim
;
127 temp
= temp_code
- pdata
->default_temp_offset
;
134 static void exynos_tmu_clear_irqs(struct exynos_tmu_data
*data
)
136 const struct exynos_tmu_registers
*reg
= data
->pdata
->registers
;
137 unsigned int val_irq
;
139 val_irq
= readl(data
->base
+ reg
->tmu_intstat
);
141 * Clear the interrupts. Please note that the documentation for
142 * Exynos3250, Exynos4412, Exynos5250 and Exynos5260 incorrectly
143 * states that INTCLEAR register has a different placing of bits
144 * responsible for FALL IRQs than INTSTAT register. Exynos5420
145 * and Exynos5440 documentation is correct (Exynos4210 doesn't
146 * support FALL IRQs at all).
148 writel(val_irq
, data
->base
+ reg
->tmu_intclear
);
151 static void sanitize_temp_error(struct exynos_tmu_data
*data
, u32 trim_info
)
153 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
155 data
->temp_error1
= trim_info
& EXYNOS_TMU_TEMP_MASK
;
156 data
->temp_error2
= ((trim_info
>> EXYNOS_TRIMINFO_85_SHIFT
) &
157 EXYNOS_TMU_TEMP_MASK
);
159 if (!data
->temp_error1
||
160 (pdata
->min_efuse_value
> data
->temp_error1
) ||
161 (data
->temp_error1
> pdata
->max_efuse_value
))
162 data
->temp_error1
= pdata
->efuse_value
& EXYNOS_TMU_TEMP_MASK
;
164 if (!data
->temp_error2
)
166 (pdata
->efuse_value
>> EXYNOS_TRIMINFO_85_SHIFT
) &
167 EXYNOS_TMU_TEMP_MASK
;
170 static u32
get_th_reg(struct exynos_tmu_data
*data
, u32 threshold
, bool falling
)
172 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
175 for (i
= 0; i
< pdata
->non_hw_trigger_levels
; i
++) {
176 u8 temp
= pdata
->trigger_levels
[i
];
179 temp
-= pdata
->threshold_falling
;
181 threshold
&= ~(0xff << 8 * i
);
183 threshold
|= temp_to_code(data
, temp
) << 8 * i
;
189 static int exynos_tmu_initialize(struct platform_device
*pdev
)
191 struct exynos_tmu_data
*data
= platform_get_drvdata(pdev
);
194 mutex_lock(&data
->lock
);
195 clk_enable(data
->clk
);
196 if (!IS_ERR(data
->clk_sec
))
197 clk_enable(data
->clk_sec
);
198 ret
= data
->tmu_initialize(pdev
);
199 clk_disable(data
->clk
);
200 mutex_unlock(&data
->lock
);
201 if (!IS_ERR(data
->clk_sec
))
202 clk_disable(data
->clk_sec
);
207 static u32
get_con_reg(struct exynos_tmu_data
*data
, u32 con
)
209 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
212 con
|= (pdata
->test_mux
<< EXYNOS4412_MUX_ADDR_SHIFT
);
214 con
&= ~(EXYNOS_TMU_REF_VOLTAGE_MASK
<< EXYNOS_TMU_REF_VOLTAGE_SHIFT
);
215 con
|= pdata
->reference_voltage
<< EXYNOS_TMU_REF_VOLTAGE_SHIFT
;
217 con
&= ~(EXYNOS_TMU_BUF_SLOPE_SEL_MASK
<< EXYNOS_TMU_BUF_SLOPE_SEL_SHIFT
);
218 con
|= (pdata
->gain
<< EXYNOS_TMU_BUF_SLOPE_SEL_SHIFT
);
220 if (pdata
->noise_cancel_mode
) {
221 con
&= ~(EXYNOS_TMU_TRIP_MODE_MASK
<< EXYNOS_TMU_TRIP_MODE_SHIFT
);
222 con
|= (pdata
->noise_cancel_mode
<< EXYNOS_TMU_TRIP_MODE_SHIFT
);
228 static void exynos_tmu_control(struct platform_device
*pdev
, bool on
)
230 struct exynos_tmu_data
*data
= platform_get_drvdata(pdev
);
232 mutex_lock(&data
->lock
);
233 clk_enable(data
->clk
);
234 data
->tmu_control(pdev
, on
);
235 clk_disable(data
->clk
);
236 mutex_unlock(&data
->lock
);
239 static int exynos4210_tmu_initialize(struct platform_device
*pdev
)
241 struct exynos_tmu_data
*data
= platform_get_drvdata(pdev
);
242 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
244 int ret
= 0, threshold_code
, i
;
246 status
= readb(data
->base
+ EXYNOS_TMU_REG_STATUS
);
252 sanitize_temp_error(data
, readl(data
->base
+ EXYNOS_TMU_REG_TRIMINFO
));
254 /* Write temperature code for threshold */
255 threshold_code
= temp_to_code(data
, pdata
->threshold
);
256 writeb(threshold_code
, data
->base
+ EXYNOS4210_TMU_REG_THRESHOLD_TEMP
);
258 for (i
= 0; i
< pdata
->non_hw_trigger_levels
; i
++)
259 writeb(pdata
->trigger_levels
[i
], data
->base
+
260 EXYNOS4210_TMU_REG_TRIG_LEVEL0
+ i
* 4);
262 exynos_tmu_clear_irqs(data
);
267 static int exynos4412_tmu_initialize(struct platform_device
*pdev
)
269 struct exynos_tmu_data
*data
= platform_get_drvdata(pdev
);
270 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
271 unsigned int status
, trim_info
, con
, ctrl
, rising_threshold
;
272 int ret
= 0, threshold_code
, i
;
274 status
= readb(data
->base
+ EXYNOS_TMU_REG_STATUS
);
280 if (data
->soc
== SOC_ARCH_EXYNOS3250
||
281 data
->soc
== SOC_ARCH_EXYNOS4412
||
282 data
->soc
== SOC_ARCH_EXYNOS5250
) {
283 if (data
->soc
== SOC_ARCH_EXYNOS3250
) {
284 ctrl
= readl(data
->base
+ EXYNOS_TMU_TRIMINFO_CON1
);
285 ctrl
|= EXYNOS_TRIMINFO_RELOAD_ENABLE
;
286 writel(ctrl
, data
->base
+ EXYNOS_TMU_TRIMINFO_CON1
);
288 ctrl
= readl(data
->base
+ EXYNOS_TMU_TRIMINFO_CON2
);
289 ctrl
|= EXYNOS_TRIMINFO_RELOAD_ENABLE
;
290 writel(ctrl
, data
->base
+ EXYNOS_TMU_TRIMINFO_CON2
);
293 /* On exynos5420 the triminfo register is in the shared space */
294 if (data
->soc
== SOC_ARCH_EXYNOS5420_TRIMINFO
)
295 trim_info
= readl(data
->base_second
+ EXYNOS_TMU_REG_TRIMINFO
);
297 trim_info
= readl(data
->base
+ EXYNOS_TMU_REG_TRIMINFO
);
299 sanitize_temp_error(data
, trim_info
);
301 /* Write temperature code for rising and falling threshold */
302 rising_threshold
= readl(data
->base
+ EXYNOS_THD_TEMP_RISE
);
303 rising_threshold
= get_th_reg(data
, rising_threshold
, false);
304 writel(rising_threshold
, data
->base
+ EXYNOS_THD_TEMP_RISE
);
305 writel(get_th_reg(data
, 0, true), data
->base
+ EXYNOS_THD_TEMP_FALL
);
307 exynos_tmu_clear_irqs(data
);
309 /* if last threshold limit is also present */
310 i
= pdata
->max_trigger_level
- 1;
311 if (pdata
->trigger_levels
[i
] && pdata
->trigger_type
[i
] == HW_TRIP
) {
312 threshold_code
= temp_to_code(data
, pdata
->trigger_levels
[i
]);
313 /* 1-4 level to be assigned in th0 reg */
314 rising_threshold
&= ~(0xff << 8 * i
);
315 rising_threshold
|= threshold_code
<< 8 * i
;
316 writel(rising_threshold
, data
->base
+ EXYNOS_THD_TEMP_RISE
);
317 con
= readl(data
->base
+ EXYNOS_TMU_REG_CONTROL
);
318 con
|= (1 << EXYNOS_TMU_THERM_TRIP_EN_SHIFT
);
319 writel(con
, data
->base
+ EXYNOS_TMU_REG_CONTROL
);
325 static int exynos5440_tmu_initialize(struct platform_device
*pdev
)
327 struct exynos_tmu_data
*data
= platform_get_drvdata(pdev
);
328 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
329 unsigned int trim_info
= 0, con
, rising_threshold
;
330 int ret
= 0, threshold_code
, i
;
333 * For exynos5440 soc triminfo value is swapped between TMU0 and
334 * TMU2, so the below logic is needed.
338 trim_info
= readl(data
->base
+ EXYNOS5440_EFUSE_SWAP_OFFSET
+
339 EXYNOS5440_TMU_S0_7_TRIM
);
342 trim_info
= readl(data
->base
+ EXYNOS5440_TMU_S0_7_TRIM
);
345 trim_info
= readl(data
->base
- EXYNOS5440_EFUSE_SWAP_OFFSET
+
346 EXYNOS5440_TMU_S0_7_TRIM
);
348 sanitize_temp_error(data
, trim_info
);
350 /* Write temperature code for rising and falling threshold */
351 rising_threshold
= readl(data
->base
+ EXYNOS5440_TMU_S0_7_TH0
);
352 rising_threshold
= get_th_reg(data
, rising_threshold
, false);
353 writel(rising_threshold
, data
->base
+ EXYNOS5440_TMU_S0_7_TH0
);
354 writel(0, data
->base
+ EXYNOS5440_TMU_S0_7_TH1
);
356 exynos_tmu_clear_irqs(data
);
358 /* if last threshold limit is also present */
359 i
= pdata
->max_trigger_level
- 1;
360 if (pdata
->trigger_levels
[i
] && pdata
->trigger_type
[i
] == HW_TRIP
) {
361 threshold_code
= temp_to_code(data
, pdata
->trigger_levels
[i
]);
362 /* 5th level to be assigned in th2 reg */
364 threshold_code
<< EXYNOS5440_TMU_TH_RISE4_SHIFT
;
365 writel(rising_threshold
, data
->base
+ EXYNOS5440_TMU_S0_7_TH2
);
366 con
= readl(data
->base
+ EXYNOS5440_TMU_S0_7_CTRL
);
367 con
|= (1 << EXYNOS_TMU_THERM_TRIP_EN_SHIFT
);
368 writel(con
, data
->base
+ EXYNOS5440_TMU_S0_7_CTRL
);
370 /* Clear the PMIN in the common TMU register */
372 writel(0, data
->base_second
+ EXYNOS5440_TMU_PMIN
);
376 static void exynos4210_tmu_control(struct platform_device
*pdev
, bool on
)
378 struct exynos_tmu_data
*data
= platform_get_drvdata(pdev
);
379 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
380 unsigned int con
, interrupt_en
;
382 con
= get_con_reg(data
, readl(data
->base
+ EXYNOS_TMU_REG_CONTROL
));
385 con
|= (1 << EXYNOS_TMU_CORE_EN_SHIFT
);
387 pdata
->trigger_enable
[3] << EXYNOS_TMU_INTEN_RISE3_SHIFT
|
388 pdata
->trigger_enable
[2] << EXYNOS_TMU_INTEN_RISE2_SHIFT
|
389 pdata
->trigger_enable
[1] << EXYNOS_TMU_INTEN_RISE1_SHIFT
|
390 pdata
->trigger_enable
[0] << EXYNOS_TMU_INTEN_RISE0_SHIFT
;
391 if (TMU_SUPPORTS(pdata
, FALLING_TRIP
))
393 interrupt_en
<< EXYNOS_TMU_INTEN_FALL0_SHIFT
;
395 con
&= ~(1 << EXYNOS_TMU_CORE_EN_SHIFT
);
396 interrupt_en
= 0; /* Disable all interrupts */
398 writel(interrupt_en
, data
->base
+ EXYNOS_TMU_REG_INTEN
);
399 writel(con
, data
->base
+ EXYNOS_TMU_REG_CONTROL
);
402 static void exynos5440_tmu_control(struct platform_device
*pdev
, bool on
)
404 struct exynos_tmu_data
*data
= platform_get_drvdata(pdev
);
405 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
406 unsigned int con
, interrupt_en
;
408 con
= get_con_reg(data
, readl(data
->base
+ EXYNOS5440_TMU_S0_7_CTRL
));
411 con
|= (1 << EXYNOS_TMU_CORE_EN_SHIFT
);
413 pdata
->trigger_enable
[3] << EXYNOS5440_TMU_INTEN_RISE3_SHIFT
|
414 pdata
->trigger_enable
[2] << EXYNOS5440_TMU_INTEN_RISE2_SHIFT
|
415 pdata
->trigger_enable
[1] << EXYNOS5440_TMU_INTEN_RISE1_SHIFT
|
416 pdata
->trigger_enable
[0] << EXYNOS5440_TMU_INTEN_RISE0_SHIFT
;
417 if (TMU_SUPPORTS(pdata
, FALLING_TRIP
))
419 interrupt_en
<< EXYNOS5440_TMU_INTEN_FALL0_SHIFT
;
421 con
&= ~(1 << EXYNOS_TMU_CORE_EN_SHIFT
);
422 interrupt_en
= 0; /* Disable all interrupts */
424 writel(interrupt_en
, data
->base
+ EXYNOS5440_TMU_S0_7_IRQEN
);
425 writel(con
, data
->base
+ EXYNOS5440_TMU_S0_7_CTRL
);
428 static int exynos_tmu_read(struct exynos_tmu_data
*data
)
432 mutex_lock(&data
->lock
);
433 clk_enable(data
->clk
);
434 ret
= data
->tmu_read(data
);
436 ret
= code_to_temp(data
, ret
);
437 clk_disable(data
->clk
);
438 mutex_unlock(&data
->lock
);
443 #ifdef CONFIG_THERMAL_EMULATION
444 static u32
get_emul_con_reg(struct exynos_tmu_data
*data
, unsigned int val
,
447 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
452 if (TMU_SUPPORTS(pdata
, EMUL_TIME
)) {
453 val
&= ~(EXYNOS_EMUL_TIME_MASK
<< EXYNOS_EMUL_TIME_SHIFT
);
454 val
|= (EXYNOS_EMUL_TIME
<< EXYNOS_EMUL_TIME_SHIFT
);
456 val
&= ~(EXYNOS_EMUL_DATA_MASK
<< EXYNOS_EMUL_DATA_SHIFT
);
457 val
|= (temp_to_code(data
, temp
) << EXYNOS_EMUL_DATA_SHIFT
) |
460 val
&= ~EXYNOS_EMUL_ENABLE
;
466 static void exynos4412_tmu_set_emulation(struct exynos_tmu_data
*data
,
472 if (data
->soc
== SOC_ARCH_EXYNOS5260
)
473 emul_con
= EXYNOS5260_EMUL_CON
;
475 emul_con
= EXYNOS_EMUL_CON
;
477 val
= readl(data
->base
+ emul_con
);
478 val
= get_emul_con_reg(data
, val
, temp
);
479 writel(val
, data
->base
+ emul_con
);
482 static void exynos5440_tmu_set_emulation(struct exynos_tmu_data
*data
,
487 val
= readl(data
->base
+ EXYNOS5440_TMU_S0_7_DEBUG
);
488 val
= get_emul_con_reg(data
, val
, temp
);
489 writel(val
, data
->base
+ EXYNOS5440_TMU_S0_7_DEBUG
);
492 static int exynos_tmu_set_emulation(void *drv_data
, unsigned long temp
)
494 struct exynos_tmu_data
*data
= drv_data
;
495 struct exynos_tmu_platform_data
*pdata
= data
->pdata
;
498 if (!TMU_SUPPORTS(pdata
, EMULATION
))
501 if (temp
&& temp
< MCELSIUS
)
504 mutex_lock(&data
->lock
);
505 clk_enable(data
->clk
);
506 data
->tmu_set_emulation(data
, temp
);
507 clk_disable(data
->clk
);
508 mutex_unlock(&data
->lock
);
514 #define exynos4412_tmu_set_emulation NULL
515 #define exynos5440_tmu_set_emulation NULL
516 static int exynos_tmu_set_emulation(void *drv_data
, unsigned long temp
)
518 #endif/*CONFIG_THERMAL_EMULATION*/
520 static int exynos4210_tmu_read(struct exynos_tmu_data
*data
)
522 int ret
= readb(data
->base
+ EXYNOS_TMU_REG_CURRENT_TEMP
);
524 /* "temp_code" should range between 75 and 175 */
525 return (ret
< 75 || ret
> 175) ? -ENODATA
: ret
;
528 static int exynos4412_tmu_read(struct exynos_tmu_data
*data
)
530 return readb(data
->base
+ EXYNOS_TMU_REG_CURRENT_TEMP
);
533 static int exynos5440_tmu_read(struct exynos_tmu_data
*data
)
535 return readb(data
->base
+ EXYNOS5440_TMU_S0_7_TEMP
);
538 static void exynos_tmu_work(struct work_struct
*work
)
540 struct exynos_tmu_data
*data
= container_of(work
,
541 struct exynos_tmu_data
, irq_work
);
542 unsigned int val_type
;
544 if (!IS_ERR(data
->clk_sec
))
545 clk_enable(data
->clk_sec
);
546 /* Find which sensor generated this interrupt */
547 if (data
->soc
== SOC_ARCH_EXYNOS5440
) {
548 val_type
= readl(data
->base_second
+ EXYNOS5440_TMU_IRQ_STATUS
);
549 if (!((val_type
>> data
->id
) & 0x1))
552 if (!IS_ERR(data
->clk_sec
))
553 clk_disable(data
->clk_sec
);
555 exynos_report_trigger(data
->reg_conf
);
556 mutex_lock(&data
->lock
);
557 clk_enable(data
->clk
);
559 /* TODO: take action based on particular interrupt */
560 exynos_tmu_clear_irqs(data
);
562 clk_disable(data
->clk
);
563 mutex_unlock(&data
->lock
);
565 enable_irq(data
->irq
);
568 static irqreturn_t
exynos_tmu_irq(int irq
, void *id
)
570 struct exynos_tmu_data
*data
= id
;
572 disable_irq_nosync(irq
);
573 schedule_work(&data
->irq_work
);
578 static const struct of_device_id exynos_tmu_match
[] = {
580 .compatible
= "samsung,exynos3250-tmu",
581 .data
= (void *)EXYNOS3250_TMU_DRV_DATA
,
584 .compatible
= "samsung,exynos4210-tmu",
585 .data
= (void *)EXYNOS4210_TMU_DRV_DATA
,
588 .compatible
= "samsung,exynos4412-tmu",
589 .data
= (void *)EXYNOS4412_TMU_DRV_DATA
,
592 .compatible
= "samsung,exynos5250-tmu",
593 .data
= (void *)EXYNOS5250_TMU_DRV_DATA
,
596 .compatible
= "samsung,exynos5260-tmu",
597 .data
= (void *)EXYNOS5260_TMU_DRV_DATA
,
600 .compatible
= "samsung,exynos5420-tmu",
601 .data
= (void *)EXYNOS5420_TMU_DRV_DATA
,
604 .compatible
= "samsung,exynos5420-tmu-ext-triminfo",
605 .data
= (void *)EXYNOS5420_TMU_DRV_DATA
,
608 .compatible
= "samsung,exynos5440-tmu",
609 .data
= (void *)EXYNOS5440_TMU_DRV_DATA
,
613 MODULE_DEVICE_TABLE(of
, exynos_tmu_match
);
615 static inline struct exynos_tmu_platform_data
*exynos_get_driver_data(
616 struct platform_device
*pdev
, int id
)
618 struct exynos_tmu_init_data
*data_table
;
619 struct exynos_tmu_platform_data
*tmu_data
;
620 const struct of_device_id
*match
;
622 match
= of_match_node(exynos_tmu_match
, pdev
->dev
.of_node
);
625 data_table
= (struct exynos_tmu_init_data
*) match
->data
;
626 if (!data_table
|| id
>= data_table
->tmu_count
)
628 tmu_data
= data_table
->tmu_data
;
629 return (struct exynos_tmu_platform_data
*) (tmu_data
+ id
);
632 static int exynos_map_dt_data(struct platform_device
*pdev
)
634 struct exynos_tmu_data
*data
= platform_get_drvdata(pdev
);
635 struct exynos_tmu_platform_data
*pdata
;
639 if (!data
|| !pdev
->dev
.of_node
)
643 * Try enabling the regulator if found
644 * TODO: Add regulator as an SOC feature, so that regulator enable
645 * is a compulsory call.
647 data
->regulator
= devm_regulator_get(&pdev
->dev
, "vtmu");
648 if (!IS_ERR(data
->regulator
)) {
649 ret
= regulator_enable(data
->regulator
);
651 dev_err(&pdev
->dev
, "failed to enable vtmu\n");
655 dev_info(&pdev
->dev
, "Regulator node (vtmu) not found\n");
658 data
->id
= of_alias_get_id(pdev
->dev
.of_node
, "tmuctrl");
662 data
->irq
= irq_of_parse_and_map(pdev
->dev
.of_node
, 0);
663 if (data
->irq
<= 0) {
664 dev_err(&pdev
->dev
, "failed to get IRQ\n");
668 if (of_address_to_resource(pdev
->dev
.of_node
, 0, &res
)) {
669 dev_err(&pdev
->dev
, "failed to get Resource 0\n");
673 data
->base
= devm_ioremap(&pdev
->dev
, res
.start
, resource_size(&res
));
675 dev_err(&pdev
->dev
, "Failed to ioremap memory\n");
676 return -EADDRNOTAVAIL
;
679 pdata
= exynos_get_driver_data(pdev
, data
->id
);
681 dev_err(&pdev
->dev
, "No platform init data supplied.\n");
686 * Check if the TMU shares some registers and then try to map the
687 * memory of common registers.
689 if (!TMU_SUPPORTS(pdata
, ADDRESS_MULTIPLE
))
692 if (of_address_to_resource(pdev
->dev
.of_node
, 1, &res
)) {
693 dev_err(&pdev
->dev
, "failed to get Resource 1\n");
697 data
->base_second
= devm_ioremap(&pdev
->dev
, res
.start
,
698 resource_size(&res
));
699 if (!data
->base_second
) {
700 dev_err(&pdev
->dev
, "Failed to ioremap memory\n");
707 static int exynos_tmu_probe(struct platform_device
*pdev
)
709 struct exynos_tmu_data
*data
;
710 struct exynos_tmu_platform_data
*pdata
;
711 struct thermal_sensor_conf
*sensor_conf
;
714 data
= devm_kzalloc(&pdev
->dev
, sizeof(struct exynos_tmu_data
),
719 platform_set_drvdata(pdev
, data
);
720 mutex_init(&data
->lock
);
722 ret
= exynos_map_dt_data(pdev
);
728 INIT_WORK(&data
->irq_work
, exynos_tmu_work
);
730 data
->clk
= devm_clk_get(&pdev
->dev
, "tmu_apbif");
731 if (IS_ERR(data
->clk
)) {
732 dev_err(&pdev
->dev
, "Failed to get clock\n");
733 return PTR_ERR(data
->clk
);
736 data
->clk_sec
= devm_clk_get(&pdev
->dev
, "tmu_triminfo_apbif");
737 if (IS_ERR(data
->clk_sec
)) {
738 if (data
->soc
== SOC_ARCH_EXYNOS5420_TRIMINFO
) {
739 dev_err(&pdev
->dev
, "Failed to get triminfo clock\n");
740 return PTR_ERR(data
->clk_sec
);
743 ret
= clk_prepare(data
->clk_sec
);
745 dev_err(&pdev
->dev
, "Failed to get clock\n");
750 ret
= clk_prepare(data
->clk
);
752 dev_err(&pdev
->dev
, "Failed to get clock\n");
756 data
->soc
= pdata
->type
;
759 case SOC_ARCH_EXYNOS4210
:
760 data
->tmu_initialize
= exynos4210_tmu_initialize
;
761 data
->tmu_control
= exynos4210_tmu_control
;
762 data
->tmu_read
= exynos4210_tmu_read
;
764 case SOC_ARCH_EXYNOS3250
:
765 case SOC_ARCH_EXYNOS4412
:
766 case SOC_ARCH_EXYNOS5250
:
767 case SOC_ARCH_EXYNOS5260
:
768 case SOC_ARCH_EXYNOS5420
:
769 case SOC_ARCH_EXYNOS5420_TRIMINFO
:
770 data
->tmu_initialize
= exynos4412_tmu_initialize
;
771 data
->tmu_control
= exynos4210_tmu_control
;
772 data
->tmu_read
= exynos4412_tmu_read
;
773 data
->tmu_set_emulation
= exynos4412_tmu_set_emulation
;
775 case SOC_ARCH_EXYNOS5440
:
776 data
->tmu_initialize
= exynos5440_tmu_initialize
;
777 data
->tmu_control
= exynos5440_tmu_control
;
778 data
->tmu_read
= exynos5440_tmu_read
;
779 data
->tmu_set_emulation
= exynos5440_tmu_set_emulation
;
783 dev_err(&pdev
->dev
, "Platform not supported\n");
787 ret
= exynos_tmu_initialize(pdev
);
789 dev_err(&pdev
->dev
, "Failed to initialize TMU\n");
793 exynos_tmu_control(pdev
, true);
795 /* Allocate a structure to register with the exynos core thermal */
796 sensor_conf
= devm_kzalloc(&pdev
->dev
,
797 sizeof(struct thermal_sensor_conf
), GFP_KERNEL
);
802 sprintf(sensor_conf
->name
, "therm_zone%d", data
->id
);
803 sensor_conf
->read_temperature
= (int (*)(void *))exynos_tmu_read
;
804 sensor_conf
->write_emul_temp
=
805 (int (*)(void *, unsigned long))exynos_tmu_set_emulation
;
806 sensor_conf
->driver_data
= data
;
807 sensor_conf
->trip_data
.trip_count
= pdata
->trigger_enable
[0] +
808 pdata
->trigger_enable
[1] + pdata
->trigger_enable
[2]+
809 pdata
->trigger_enable
[3];
811 for (i
= 0; i
< sensor_conf
->trip_data
.trip_count
; i
++) {
812 sensor_conf
->trip_data
.trip_val
[i
] =
813 pdata
->threshold
+ pdata
->trigger_levels
[i
];
814 sensor_conf
->trip_data
.trip_type
[i
] =
815 pdata
->trigger_type
[i
];
818 sensor_conf
->trip_data
.trigger_falling
= pdata
->threshold_falling
;
820 sensor_conf
->cooling_data
.freq_clip_count
= pdata
->freq_tab_count
;
821 for (i
= 0; i
< pdata
->freq_tab_count
; i
++) {
822 sensor_conf
->cooling_data
.freq_data
[i
].freq_clip_max
=
823 pdata
->freq_tab
[i
].freq_clip_max
;
824 sensor_conf
->cooling_data
.freq_data
[i
].temp_level
=
825 pdata
->freq_tab
[i
].temp_level
;
827 sensor_conf
->dev
= &pdev
->dev
;
828 /* Register the sensor with thermal management interface */
829 ret
= exynos_register_thermal(sensor_conf
);
831 dev_err(&pdev
->dev
, "Failed to register thermal interface\n");
834 data
->reg_conf
= sensor_conf
;
836 ret
= devm_request_irq(&pdev
->dev
, data
->irq
, exynos_tmu_irq
,
837 IRQF_TRIGGER_RISING
| IRQF_SHARED
, dev_name(&pdev
->dev
), data
);
839 dev_err(&pdev
->dev
, "Failed to request irq: %d\n", data
->irq
);
845 clk_unprepare(data
->clk
);
847 if (!IS_ERR(data
->clk_sec
))
848 clk_unprepare(data
->clk_sec
);
852 static int exynos_tmu_remove(struct platform_device
*pdev
)
854 struct exynos_tmu_data
*data
= platform_get_drvdata(pdev
);
856 exynos_unregister_thermal(data
->reg_conf
);
858 exynos_tmu_control(pdev
, false);
860 clk_unprepare(data
->clk
);
861 if (!IS_ERR(data
->clk_sec
))
862 clk_unprepare(data
->clk_sec
);
864 if (!IS_ERR(data
->regulator
))
865 regulator_disable(data
->regulator
);
870 #ifdef CONFIG_PM_SLEEP
871 static int exynos_tmu_suspend(struct device
*dev
)
873 exynos_tmu_control(to_platform_device(dev
), false);
878 static int exynos_tmu_resume(struct device
*dev
)
880 struct platform_device
*pdev
= to_platform_device(dev
);
882 exynos_tmu_initialize(pdev
);
883 exynos_tmu_control(pdev
, true);
888 static SIMPLE_DEV_PM_OPS(exynos_tmu_pm
,
889 exynos_tmu_suspend
, exynos_tmu_resume
);
890 #define EXYNOS_TMU_PM (&exynos_tmu_pm)
892 #define EXYNOS_TMU_PM NULL
895 static struct platform_driver exynos_tmu_driver
= {
897 .name
= "exynos-tmu",
898 .owner
= THIS_MODULE
,
900 .of_match_table
= exynos_tmu_match
,
902 .probe
= exynos_tmu_probe
,
903 .remove
= exynos_tmu_remove
,
906 module_platform_driver(exynos_tmu_driver
);
908 MODULE_DESCRIPTION("EXYNOS TMU Driver");
909 MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
910 MODULE_LICENSE("GPL");
911 MODULE_ALIAS("platform:exynos-tmu");