?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / thermal / samsung / exynos_tmu.c
blobfc9399d9c0820d59a4321520fd5dcf9242620867
1 /*
2 * exynos_tmu.c - Samsung EXYNOS TMU (Thermal Management Unit)
3 *
4 * Copyright (C) 2014 Samsung Electronics
5 * Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
6 * Lukasz Majewski <l.majewski@samsung.com>
7 *
8 * Copyright (C) 2011 Samsung Electronics
9 * Donggeun Kim <dg77.kim@samsung.com>
10 * Amit Daniel Kachhap <amit.kachhap@linaro.org>
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 */
27
28 #include <linux/clk.h>
29 #include <linux/io.h>
30 #include <linux/interrupt.h>
31 #include <linux/module.h>
32 #include <linux/of_device.h>
33 #include <linux/of_address.h>
34 #include <linux/of_irq.h>
35 #include <linux/platform_device.h>
36 #include <linux/regulator/consumer.h>
37
38 #include <dt-bindings/thermal/thermal_exynos.h>
39
40 #include "../thermal_core.h"
41
42 /* Exynos generic registers */
43 #define EXYNOS_TMU_REG_TRIMINFO 0x0
44 #define EXYNOS_TMU_REG_CONTROL 0x20
45 #define EXYNOS_TMU_REG_STATUS 0x28
46 #define EXYNOS_TMU_REG_CURRENT_TEMP 0x40
47 #define EXYNOS_TMU_REG_INTEN 0x70
48 #define EXYNOS_TMU_REG_INTSTAT 0x74
49 #define EXYNOS_TMU_REG_INTCLEAR 0x78
50
51 #define EXYNOS_TMU_TEMP_MASK 0xff
52 #define EXYNOS_TMU_REF_VOLTAGE_SHIFT 24
53 #define EXYNOS_TMU_REF_VOLTAGE_MASK 0x1f
54 #define EXYNOS_TMU_BUF_SLOPE_SEL_MASK 0xf
55 #define EXYNOS_TMU_BUF_SLOPE_SEL_SHIFT 8
56 #define EXYNOS_TMU_CORE_EN_SHIFT 0
57
58 /* Exynos3250 specific registers */
59 #define EXYNOS_TMU_TRIMINFO_CON1 0x10
60
61 /* Exynos4210 specific registers */
62 #define EXYNOS4210_TMU_REG_THRESHOLD_TEMP 0x44
63 #define EXYNOS4210_TMU_REG_TRIG_LEVEL0 0x50
64
65 /* Exynos5250, Exynos4412, Exynos3250 specific registers */
66 #define EXYNOS_TMU_TRIMINFO_CON2 0x14
67 #define EXYNOS_THD_TEMP_RISE 0x50
68 #define EXYNOS_THD_TEMP_FALL 0x54
69 #define EXYNOS_EMUL_CON 0x80
70
71 #define EXYNOS_TRIMINFO_RELOAD_ENABLE 1
72 #define EXYNOS_TRIMINFO_25_SHIFT 0
73 #define EXYNOS_TRIMINFO_85_SHIFT 8
74 #define EXYNOS_TMU_TRIP_MODE_SHIFT 13
75 #define EXYNOS_TMU_TRIP_MODE_MASK 0x7
76 #define EXYNOS_TMU_THERM_TRIP_EN_SHIFT 12
77
78 #define EXYNOS_TMU_INTEN_RISE0_SHIFT 0
79 #define EXYNOS_TMU_INTEN_FALL0_SHIFT 16
80
81 #define EXYNOS_EMUL_TIME 0x57F0
82 #define EXYNOS_EMUL_TIME_MASK 0xffff
83 #define EXYNOS_EMUL_TIME_SHIFT 16
84 #define EXYNOS_EMUL_DATA_SHIFT 8
85 #define EXYNOS_EMUL_DATA_MASK 0xFF
86 #define EXYNOS_EMUL_ENABLE 0x1
87
88 /* Exynos5260 specific */
89 #define EXYNOS5260_TMU_REG_INTEN 0xC0
90 #define EXYNOS5260_TMU_REG_INTSTAT 0xC4
91 #define EXYNOS5260_TMU_REG_INTCLEAR 0xC8
92 #define EXYNOS5260_EMUL_CON 0x100
93
94 /* Exynos4412 specific */
95 #define EXYNOS4412_MUX_ADDR_VALUE 6
96 #define EXYNOS4412_MUX_ADDR_SHIFT 20
97
98 /* Exynos5433 specific registers */
99 #define EXYNOS5433_THD_TEMP_RISE3_0 0x050
100 #define EXYNOS5433_THD_TEMP_RISE7_4 0x054
101 #define EXYNOS5433_THD_TEMP_FALL3_0 0x060
102 #define EXYNOS5433_THD_TEMP_FALL7_4 0x064
103 #define EXYNOS5433_TMU_REG_INTEN 0x0c0
104 #define EXYNOS5433_TMU_REG_INTPEND 0x0c8
105 #define EXYNOS5433_TMU_EMUL_CON 0x110
106 #define EXYNOS5433_TMU_PD_DET_EN 0x130
107
108 #define EXYNOS5433_TRIMINFO_SENSOR_ID_SHIFT 16
109 #define EXYNOS5433_TRIMINFO_CALIB_SEL_SHIFT 23
110 #define EXYNOS5433_TRIMINFO_SENSOR_ID_MASK \
111 (0xf << EXYNOS5433_TRIMINFO_SENSOR_ID_SHIFT)
112 #define EXYNOS5433_TRIMINFO_CALIB_SEL_MASK BIT(23)
113
114 #define EXYNOS5433_TRIMINFO_ONE_POINT_TRIMMING 0
115 #define EXYNOS5433_TRIMINFO_TWO_POINT_TRIMMING 1
116
117 #define EXYNOS5433_PD_DET_EN 1
118
119 #define EXYNOS5433_G3D_BASE 0x10070000
120
121 /* Exynos7 specific registers */
122 #define EXYNOS7_THD_TEMP_RISE7_6 0x50
123 #define EXYNOS7_THD_TEMP_FALL7_6 0x60
124 #define EXYNOS7_TMU_REG_INTEN 0x110
125 #define EXYNOS7_TMU_REG_INTPEND 0x118
126 #define EXYNOS7_TMU_REG_EMUL_CON 0x160
127
128 #define EXYNOS7_TMU_TEMP_MASK 0x1ff
129 #define EXYNOS7_PD_DET_EN_SHIFT 23
130 #define EXYNOS7_TMU_INTEN_RISE0_SHIFT 0
131 #define EXYNOS7_EMUL_DATA_SHIFT 7
132 #define EXYNOS7_EMUL_DATA_MASK 0x1ff
133
134 #define EXYNOS_FIRST_POINT_TRIM 25
135 #define EXYNOS_SECOND_POINT_TRIM 85
136
137 #define EXYNOS_NOISE_CANCEL_MODE 4
138
139 #define MCELSIUS 1000
140
141 enum soc_type {
142 SOC_ARCH_EXYNOS3250 = 1,
143 SOC_ARCH_EXYNOS4210,
144 SOC_ARCH_EXYNOS4412,
145 SOC_ARCH_EXYNOS5250,
146 SOC_ARCH_EXYNOS5260,
147 SOC_ARCH_EXYNOS5420,
148 SOC_ARCH_EXYNOS5420_TRIMINFO,
149 SOC_ARCH_EXYNOS5433,
150 SOC_ARCH_EXYNOS7,
151 };
152
153 /**
154 * struct exynos_tmu_data : A structure to hold the private data of the TMU
155 driver
156 * @id: identifier of the one instance of the TMU controller.
157 * @base: base address of the single instance of the TMU controller.
158 * @base_second: base address of the common registers of the TMU controller.
159 * @irq: irq number of the TMU controller.
160 * @soc: id of the SOC type.
161 * @irq_work: pointer to the irq work structure.
162 * @lock: lock to implement synchronization.
163 * @clk: pointer to the clock structure.
164 * @clk_sec: pointer to the clock structure for accessing the base_second.
165 * @sclk: pointer to the clock structure for accessing the tmu special clk.
166 * @cal_type: calibration type for temperature
167 * @efuse_value: SoC defined fuse value
168 * @min_efuse_value: minimum valid trimming data
169 * @max_efuse_value: maximum valid trimming data
170 * @temp_error1: fused value of the first point trim.
171 * @temp_error2: fused value of the second point trim.
172 * @gain: gain of amplifier in the positive-TC generator block
173 * 0 < gain <= 15
174 * @reference_voltage: reference voltage of amplifier
175 * in the positive-TC generator block
176 * 0 < reference_voltage <= 31
177 * @regulator: pointer to the TMU regulator structure.
178 * @reg_conf: pointer to structure to register with core thermal.
179 * @ntrip: number of supported trip points.
180 * @enabled: current status of TMU device
181 * @tmu_initialize: SoC specific TMU initialization method
182 * @tmu_control: SoC specific TMU control method
183 * @tmu_read: SoC specific TMU temperature read method
184 * @tmu_set_emulation: SoC specific TMU emulation setting method
185 * @tmu_clear_irqs: SoC specific TMU interrupts clearing method
186 */
187 struct exynos_tmu_data {
188 int id;
189 void __iomem *base;
190 void __iomem *base_second;
191 int irq;
192 enum soc_type soc;
193 struct work_struct irq_work;
194 struct mutex lock;
195 struct clk *clk, *clk_sec, *sclk;
196 u32 cal_type;
197 u32 efuse_value;
198 u32 min_efuse_value;
199 u32 max_efuse_value;
200 u16 temp_error1, temp_error2;
201 u8 gain;
202 u8 reference_voltage;
203 struct regulator *regulator;
204 struct thermal_zone_device *tzd;
205 unsigned int ntrip;
206 bool enabled;
207
208 void (*tmu_set_trip_temp)(struct exynos_tmu_data *data, int trip,
209 u8 temp);
210 void (*tmu_set_trip_hyst)(struct exynos_tmu_data *data, int trip,
211 u8 temp, u8 hyst);
212 void (*tmu_initialize)(struct platform_device *pdev);
213 void (*tmu_control)(struct platform_device *pdev, bool on);
214 int (*tmu_read)(struct exynos_tmu_data *data);
215 void (*tmu_set_emulation)(struct exynos_tmu_data *data, int temp);
216 void (*tmu_clear_irqs)(struct exynos_tmu_data *data);
217 };
218
219 /*
220 * TMU treats temperature as a mapped temperature code.
221 * The temperature is converted differently depending on the calibration type.
222 */
223 static int temp_to_code(struct exynos_tmu_data *data, u8 temp)
224 {
225 if (data->cal_type == TYPE_ONE_POINT_TRIMMING)
226 return temp + data->temp_error1 - EXYNOS_FIRST_POINT_TRIM;
227
228 return (temp - EXYNOS_FIRST_POINT_TRIM) *
229 (data->temp_error2 - data->temp_error1) /
230 (EXYNOS_SECOND_POINT_TRIM - EXYNOS_FIRST_POINT_TRIM) +
231 data->temp_error1;
232 }
233
234 /*
235 * Calculate a temperature value from a temperature code.
236 * The unit of the temperature is degree Celsius.
237 */
238 static int code_to_temp(struct exynos_tmu_data *data, u16 temp_code)
239 {
240 if (data->cal_type == TYPE_ONE_POINT_TRIMMING)
241 return temp_code - data->temp_error1 + EXYNOS_FIRST_POINT_TRIM;
242
243 return (temp_code - data->temp_error1) *
244 (EXYNOS_SECOND_POINT_TRIM - EXYNOS_FIRST_POINT_TRIM) /
245 (data->temp_error2 - data->temp_error1) +
246 EXYNOS_FIRST_POINT_TRIM;
247 }
248
249 static void sanitize_temp_error(struct exynos_tmu_data *data, u32 trim_info)
250 {
251 u16 tmu_temp_mask =
252 (data->soc == SOC_ARCH_EXYNOS7) ? EXYNOS7_TMU_TEMP_MASK
253 : EXYNOS_TMU_TEMP_MASK;
254
255 data->temp_error1 = trim_info & tmu_temp_mask;
256 data->temp_error2 = ((trim_info >> EXYNOS_TRIMINFO_85_SHIFT) &
257 EXYNOS_TMU_TEMP_MASK);
258
259 if (!data->temp_error1 ||
260 (data->min_efuse_value > data->temp_error1) ||
261 (data->temp_error1 > data->max_efuse_value))
262 data->temp_error1 = data->efuse_value & EXYNOS_TMU_TEMP_MASK;
263
264 if (!data->temp_error2)
265 data->temp_error2 =
266 (data->efuse_value >> EXYNOS_TRIMINFO_85_SHIFT) &
267 EXYNOS_TMU_TEMP_MASK;
268 }
269
270 static int exynos_tmu_initialize(struct platform_device *pdev)
271 {
272 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
273 struct thermal_zone_device *tzd = data->tzd;
274 const struct thermal_trip * const trips =
275 of_thermal_get_trip_points(tzd);
276 unsigned int status;
277 int ret = 0, temp, hyst;
278
279 if (!trips) {
280 dev_err(&pdev->dev,
281 "Cannot get trip points from device tree!\n");
282 return -ENODEV;
283 }
284
285 if (data->soc != SOC_ARCH_EXYNOS5433) /* FIXME */
286 ret = tzd->ops->get_crit_temp(tzd, &temp);
287 if (ret) {
288 dev_err(&pdev->dev,
289 "No CRITICAL trip point defined in device tree!\n");
290 goto out;
291 }
292
293 if (of_thermal_get_ntrips(tzd) > data->ntrip) {
294 dev_info(&pdev->dev,
295 "More trip points than supported by this TMU.\n");
296 dev_info(&pdev->dev,
297 "%d trip points should be configured in polling mode.\n",
298 (of_thermal_get_ntrips(tzd) - data->ntrip));
299 }
300
301 mutex_lock(&data->lock);
302 clk_enable(data->clk);
303 if (!IS_ERR(data->clk_sec))
304 clk_enable(data->clk_sec);
305
306 status = readb(data->base + EXYNOS_TMU_REG_STATUS);
307 if (!status) {
308 ret = -EBUSY;
309 } else {
310 int i, ntrips =
311 min_t(int, of_thermal_get_ntrips(tzd), data->ntrip);
312
313 data->tmu_initialize(pdev);
314
315 /* Write temperature code for rising and falling threshold */
316 for (i = 0; i < ntrips; i++) {
317 /* Write temperature code for rising threshold */
318 ret = tzd->ops->get_trip_temp(tzd, i, &temp);
319 if (ret)
320 goto err;
321 temp /= MCELSIUS;
322 data->tmu_set_trip_temp(data, i, temp);
323
324 /* Write temperature code for falling threshold */
325 ret = tzd->ops->get_trip_hyst(tzd, i, &hyst);
326 if (ret)
327 goto err;
328 hyst /= MCELSIUS;
329 data->tmu_set_trip_hyst(data, i, temp, hyst);
330 }
331
332 data->tmu_clear_irqs(data);
333 }
334 err:
335 clk_disable(data->clk);
336 mutex_unlock(&data->lock);
337 if (!IS_ERR(data->clk_sec))
338 clk_disable(data->clk_sec);
339 out:
340 return ret;
341 }
342
343 static u32 get_con_reg(struct exynos_tmu_data *data, u32 con)
344 {
345 if (data->soc == SOC_ARCH_EXYNOS4412 ||
346 data->soc == SOC_ARCH_EXYNOS3250)
347 con |= (EXYNOS4412_MUX_ADDR_VALUE << EXYNOS4412_MUX_ADDR_SHIFT);
348
349 con &= ~(EXYNOS_TMU_REF_VOLTAGE_MASK << EXYNOS_TMU_REF_VOLTAGE_SHIFT);
350 con |= data->reference_voltage << EXYNOS_TMU_REF_VOLTAGE_SHIFT;
351
352 con &= ~(EXYNOS_TMU_BUF_SLOPE_SEL_MASK << EXYNOS_TMU_BUF_SLOPE_SEL_SHIFT);
353 con |= (data->gain << EXYNOS_TMU_BUF_SLOPE_SEL_SHIFT);
354
355 con &= ~(EXYNOS_TMU_TRIP_MODE_MASK << EXYNOS_TMU_TRIP_MODE_SHIFT);
356 con |= (EXYNOS_NOISE_CANCEL_MODE << EXYNOS_TMU_TRIP_MODE_SHIFT);
357
358 return con;
359 }
360
361 static void exynos_tmu_control(struct platform_device *pdev, bool on)
362 {
363 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
364
365 mutex_lock(&data->lock);
366 clk_enable(data->clk);
367 data->tmu_control(pdev, on);
368 data->enabled = on;
369 clk_disable(data->clk);
370 mutex_unlock(&data->lock);
371 }
372
373 static void exynos4210_tmu_set_trip_temp(struct exynos_tmu_data *data,
374 int trip, u8 temp)
375 {
376 const struct thermal_trip * const trips =
377 of_thermal_get_trip_points(data->tzd);
378 u8 ref, th_code;
379
380 ref = trips[0].temperature / MCELSIUS;
381
382 if (trip == 0) {
383 th_code = temp_to_code(data, ref);
384 writeb(th_code, data->base + EXYNOS4210_TMU_REG_THRESHOLD_TEMP);
385 }
386
387 temp -= ref;
388 writeb(temp, data->base + EXYNOS4210_TMU_REG_TRIG_LEVEL0 + trip * 4);
389 }
390
391 /* failing thresholds are not supported on Exynos4210 */
392 static void exynos4210_tmu_set_trip_hyst(struct exynos_tmu_data *data,
393 int trip, u8 temp, u8 hyst)
394 {
395 }
396
397 static void exynos4210_tmu_initialize(struct platform_device *pdev)
398 {
399 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
400
401 sanitize_temp_error(data, readl(data->base + EXYNOS_TMU_REG_TRIMINFO));
402 }
403
404 static void exynos4412_tmu_set_trip_temp(struct exynos_tmu_data *data,
405 int trip, u8 temp)
406 {
407 u32 th, con;
408
409 th = readl(data->base + EXYNOS_THD_TEMP_RISE);
410 th &= ~(0xff << 8 * trip);
411 th |= temp_to_code(data, temp) << 8 * trip;
412 writel(th, data->base + EXYNOS_THD_TEMP_RISE);
413
414 if (trip == 3) {
415 con = readl(data->base + EXYNOS_TMU_REG_CONTROL);
416 con |= (1 << EXYNOS_TMU_THERM_TRIP_EN_SHIFT);
417 writel(con, data->base + EXYNOS_TMU_REG_CONTROL);
418 }
419 }
420
421 static void exynos4412_tmu_set_trip_hyst(struct exynos_tmu_data *data,
422 int trip, u8 temp, u8 hyst)
423 {
424 u32 th;
425
426 th = readl(data->base + EXYNOS_THD_TEMP_FALL);
427 th &= ~(0xff << 8 * trip);
428 if (hyst)
429 th |= temp_to_code(data, temp - hyst) << 8 * trip;
430 writel(th, data->base + EXYNOS_THD_TEMP_FALL);
431 }
432
433 static void exynos4412_tmu_initialize(struct platform_device *pdev)
434 {
435 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
436 unsigned int trim_info, ctrl;
437
438 if (data->soc == SOC_ARCH_EXYNOS3250 ||
439 data->soc == SOC_ARCH_EXYNOS4412 ||
440 data->soc == SOC_ARCH_EXYNOS5250) {
441 if (data->soc == SOC_ARCH_EXYNOS3250) {
442 ctrl = readl(data->base + EXYNOS_TMU_TRIMINFO_CON1);
443 ctrl |= EXYNOS_TRIMINFO_RELOAD_ENABLE;
444 writel(ctrl, data->base + EXYNOS_TMU_TRIMINFO_CON1);
445 }
446 ctrl = readl(data->base + EXYNOS_TMU_TRIMINFO_CON2);
447 ctrl |= EXYNOS_TRIMINFO_RELOAD_ENABLE;
448 writel(ctrl, data->base + EXYNOS_TMU_TRIMINFO_CON2);
449 }
450
451 /* On exynos5420 the triminfo register is in the shared space */
452 if (data->soc == SOC_ARCH_EXYNOS5420_TRIMINFO)
453 trim_info = readl(data->base_second + EXYNOS_TMU_REG_TRIMINFO);
454 else
455 trim_info = readl(data->base + EXYNOS_TMU_REG_TRIMINFO);
456
457 sanitize_temp_error(data, trim_info);
458 }
459
460 static void exynos5433_tmu_set_trip_temp(struct exynos_tmu_data *data,
461 int trip, u8 temp)
462 {
463 unsigned int reg_off, j;
464 u32 th;
465
466 if (trip > 3) {
467 reg_off = EXYNOS5433_THD_TEMP_RISE7_4;
468 j = trip - 4;
469 } else {
470 reg_off = EXYNOS5433_THD_TEMP_RISE3_0;
471 j = trip;
472 }
473
474 th = readl(data->base + reg_off);
475 th &= ~(0xff << j * 8);
476 th |= (temp_to_code(data, temp) << j * 8);
477 writel(th, data->base + reg_off);
478 }
479
480 static void exynos5433_tmu_set_trip_hyst(struct exynos_tmu_data *data,
481 int trip, u8 temp, u8 hyst)
482 {
483 unsigned int reg_off, j;
484 u32 th;
485
486 if (trip > 3) {
487 reg_off = EXYNOS5433_THD_TEMP_FALL7_4;
488 j = trip - 4;
489 } else {
490 reg_off = EXYNOS5433_THD_TEMP_FALL3_0;
491 j = trip;
492 }
493
494 th = readl(data->base + reg_off);
495 th &= ~(0xff << j * 8);
496 th |= (temp_to_code(data, temp - hyst) << j * 8);
497 writel(th, data->base + reg_off);
498 }
499
500 static void exynos5433_tmu_initialize(struct platform_device *pdev)
501 {
502 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
503 unsigned int trim_info;
504 int sensor_id, cal_type;
505
506 trim_info = readl(data->base + EXYNOS_TMU_REG_TRIMINFO);
507 sanitize_temp_error(data, trim_info);
508
509 /* Read the temperature sensor id */
510 sensor_id = (trim_info & EXYNOS5433_TRIMINFO_SENSOR_ID_MASK)
511 >> EXYNOS5433_TRIMINFO_SENSOR_ID_SHIFT;
512 dev_info(&pdev->dev, "Temperature sensor ID: 0x%x\n", sensor_id);
513
514 /* Read the calibration mode */
515 writel(trim_info, data->base + EXYNOS_TMU_REG_TRIMINFO);
516 cal_type = (trim_info & EXYNOS5433_TRIMINFO_CALIB_SEL_MASK)
517 >> EXYNOS5433_TRIMINFO_CALIB_SEL_SHIFT;
518
519 switch (cal_type) {
520 case EXYNOS5433_TRIMINFO_TWO_POINT_TRIMMING:
521 data->cal_type = TYPE_TWO_POINT_TRIMMING;
522 break;
523 case EXYNOS5433_TRIMINFO_ONE_POINT_TRIMMING:
524 default:
525 data->cal_type = TYPE_ONE_POINT_TRIMMING;
526 break;
527 }
528
529 dev_info(&pdev->dev, "Calibration type is %d-point calibration\n",
530 cal_type ? 2 : 1);
531 }
532
533 static void exynos7_tmu_set_trip_temp(struct exynos_tmu_data *data,
534 int trip, u8 temp)
535 {
536 unsigned int reg_off, bit_off;
537 u32 th;
538
539 reg_off = ((7 - trip) / 2) * 4;
540 bit_off = ((8 - trip) % 2);
541
542 th = readl(data->base + EXYNOS7_THD_TEMP_RISE7_6 + reg_off);
543 th &= ~(EXYNOS7_TMU_TEMP_MASK << (16 * bit_off));
544 th |= temp_to_code(data, temp) << (16 * bit_off);
545 writel(th, data->base + EXYNOS7_THD_TEMP_RISE7_6 + reg_off);
546 }
547
548 static void exynos7_tmu_set_trip_hyst(struct exynos_tmu_data *data,
549 int trip, u8 temp, u8 hyst)
550 {
551 unsigned int reg_off, bit_off;
552 u32 th;
553
554 reg_off = ((7 - trip) / 2) * 4;
555 bit_off = ((8 - trip) % 2);
556
557 th = readl(data->base + EXYNOS7_THD_TEMP_FALL7_6 + reg_off);
558 th &= ~(EXYNOS7_TMU_TEMP_MASK << (16 * bit_off));
559 th |= temp_to_code(data, temp - hyst) << (16 * bit_off);
560 writel(th, data->base + EXYNOS7_THD_TEMP_FALL7_6 + reg_off);
561 }
562
563 static void exynos7_tmu_initialize(struct platform_device *pdev)
564 {
565 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
566 unsigned int trim_info;
567
568 trim_info = readl(data->base + EXYNOS_TMU_REG_TRIMINFO);
569 sanitize_temp_error(data, trim_info);
570 }
571
572 static void exynos4210_tmu_control(struct platform_device *pdev, bool on)
573 {
574 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
575 struct thermal_zone_device *tz = data->tzd;
576 unsigned int con, interrupt_en = 0, i;
577
578 con = get_con_reg(data, readl(data->base + EXYNOS_TMU_REG_CONTROL));
579
580 if (on) {
581 for (i = 0; i < data->ntrip; i++) {
582 if (!of_thermal_is_trip_valid(tz, i))
583 continue;
584
585 interrupt_en |=
586 (1 << (EXYNOS_TMU_INTEN_RISE0_SHIFT + i * 4));
587 }
588
589 if (data->soc != SOC_ARCH_EXYNOS4210)
590 interrupt_en |=
591 interrupt_en << EXYNOS_TMU_INTEN_FALL0_SHIFT;
592
593 con |= (1 << EXYNOS_TMU_CORE_EN_SHIFT);
594 } else {
595 con &= ~(1 << EXYNOS_TMU_CORE_EN_SHIFT);
596 }
597
598 writel(interrupt_en, data->base + EXYNOS_TMU_REG_INTEN);
599 writel(con, data->base + EXYNOS_TMU_REG_CONTROL);
600 }
601
602 static void exynos5433_tmu_control(struct platform_device *pdev, bool on)
603 {
604 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
605 struct thermal_zone_device *tz = data->tzd;
606 unsigned int con, interrupt_en = 0, pd_det_en, i;
607
608 con = get_con_reg(data, readl(data->base + EXYNOS_TMU_REG_CONTROL));
609
610 if (on) {
611 for (i = 0; i < data->ntrip; i++) {
612 if (!of_thermal_is_trip_valid(tz, i))
613 continue;
614
615 interrupt_en |=
616 (1 << (EXYNOS7_TMU_INTEN_RISE0_SHIFT + i));
617 }
618
619 interrupt_en |=
620 interrupt_en << EXYNOS_TMU_INTEN_FALL0_SHIFT;
621
622 con |= (1 << EXYNOS_TMU_CORE_EN_SHIFT);
623 } else
624 con &= ~(1 << EXYNOS_TMU_CORE_EN_SHIFT);
625
626 pd_det_en = on ? EXYNOS5433_PD_DET_EN : 0;
627
628 writel(pd_det_en, data->base + EXYNOS5433_TMU_PD_DET_EN);
629 writel(interrupt_en, data->base + EXYNOS5433_TMU_REG_INTEN);
630 writel(con, data->base + EXYNOS_TMU_REG_CONTROL);
631 }
632
633 static void exynos7_tmu_control(struct platform_device *pdev, bool on)
634 {
635 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
636 struct thermal_zone_device *tz = data->tzd;
637 unsigned int con, interrupt_en = 0, i;
638
639 con = get_con_reg(data, readl(data->base + EXYNOS_TMU_REG_CONTROL));
640
641 if (on) {
642 for (i = 0; i < data->ntrip; i++) {
643 if (!of_thermal_is_trip_valid(tz, i))
644 continue;
645
646 interrupt_en |=
647 (1 << (EXYNOS7_TMU_INTEN_RISE0_SHIFT + i));
648 }
649
650 interrupt_en |=
651 interrupt_en << EXYNOS_TMU_INTEN_FALL0_SHIFT;
652
653 con |= (1 << EXYNOS_TMU_CORE_EN_SHIFT);
654 con |= (1 << EXYNOS7_PD_DET_EN_SHIFT);
655 } else {
656 con &= ~(1 << EXYNOS_TMU_CORE_EN_SHIFT);
657 con &= ~(1 << EXYNOS7_PD_DET_EN_SHIFT);
658 }
659
660 writel(interrupt_en, data->base + EXYNOS7_TMU_REG_INTEN);
661 writel(con, data->base + EXYNOS_TMU_REG_CONTROL);
662 }
663
664 static int exynos_get_temp(void *p, int *temp)
665 {
666 struct exynos_tmu_data *data = p;
667 int value, ret = 0;
668
669 if (!data || !data->tmu_read)
670 return -EINVAL;
671 else if (!data->enabled)
672 /*
673 * Called too early, probably
674 * from thermal_zone_of_sensor_register().
675 */
676 return -EAGAIN;
677
678 mutex_lock(&data->lock);
679 clk_enable(data->clk);
680
681 value = data->tmu_read(data);
682 if (value < 0)
683 ret = value;
684 else
685 *temp = code_to_temp(data, value) * MCELSIUS;
686
687 clk_disable(data->clk);
688 mutex_unlock(&data->lock);
689
690 return ret;
691 }
692
693 #ifdef CONFIG_THERMAL_EMULATION
694 static u32 get_emul_con_reg(struct exynos_tmu_data *data, unsigned int val,
695 int temp)
696 {
697 if (temp) {
698 temp /= MCELSIUS;
699
700 val &= ~(EXYNOS_EMUL_TIME_MASK << EXYNOS_EMUL_TIME_SHIFT);
701 val |= (EXYNOS_EMUL_TIME << EXYNOS_EMUL_TIME_SHIFT);
702 if (data->soc == SOC_ARCH_EXYNOS7) {
703 val &= ~(EXYNOS7_EMUL_DATA_MASK <<
704 EXYNOS7_EMUL_DATA_SHIFT);
705 val |= (temp_to_code(data, temp) <<
706 EXYNOS7_EMUL_DATA_SHIFT) |
707 EXYNOS_EMUL_ENABLE;
708 } else {
709 val &= ~(EXYNOS_EMUL_DATA_MASK <<
710 EXYNOS_EMUL_DATA_SHIFT);
711 val |= (temp_to_code(data, temp) <<
712 EXYNOS_EMUL_DATA_SHIFT) |
713 EXYNOS_EMUL_ENABLE;
714 }
715 } else {
716 val &= ~EXYNOS_EMUL_ENABLE;
717 }
718
719 return val;
720 }
721
722 static void exynos4412_tmu_set_emulation(struct exynos_tmu_data *data,
723 int temp)
724 {
725 unsigned int val;
726 u32 emul_con;
727
728 if (data->soc == SOC_ARCH_EXYNOS5260)
729 emul_con = EXYNOS5260_EMUL_CON;
730 else if (data->soc == SOC_ARCH_EXYNOS5433)
731 emul_con = EXYNOS5433_TMU_EMUL_CON;
732 else if (data->soc == SOC_ARCH_EXYNOS7)
733 emul_con = EXYNOS7_TMU_REG_EMUL_CON;
734 else
735 emul_con = EXYNOS_EMUL_CON;
736
737 val = readl(data->base + emul_con);
738 val = get_emul_con_reg(data, val, temp);
739 writel(val, data->base + emul_con);
740 }
741
742 static int exynos_tmu_set_emulation(void *drv_data, int temp)
743 {
744 struct exynos_tmu_data *data = drv_data;
745 int ret = -EINVAL;
746
747 if (data->soc == SOC_ARCH_EXYNOS4210)
748 goto out;
749
750 if (temp && temp < MCELSIUS)
751 goto out;
752
753 mutex_lock(&data->lock);
754 clk_enable(data->clk);
755 data->tmu_set_emulation(data, temp);
756 clk_disable(data->clk);
757 mutex_unlock(&data->lock);
758 return 0;
759 out:
760 return ret;
761 }
762 #else
763 #define exynos4412_tmu_set_emulation NULL
764 static int exynos_tmu_set_emulation(void *drv_data, int temp)
765 { return -EINVAL; }
766 #endif /* CONFIG_THERMAL_EMULATION */
767
768 static int exynos4210_tmu_read(struct exynos_tmu_data *data)
769 {
770 int ret = readb(data->base + EXYNOS_TMU_REG_CURRENT_TEMP);
771
772 /* "temp_code" should range between 75 and 175 */
773 return (ret < 75 || ret > 175) ? -ENODATA : ret;
774 }
775
776 static int exynos4412_tmu_read(struct exynos_tmu_data *data)
777 {
778 return readb(data->base + EXYNOS_TMU_REG_CURRENT_TEMP);
779 }
780
781 static int exynos7_tmu_read(struct exynos_tmu_data *data)
782 {
783 return readw(data->base + EXYNOS_TMU_REG_CURRENT_TEMP) &
784 EXYNOS7_TMU_TEMP_MASK;
785 }
786
787 static void exynos_tmu_work(struct work_struct *work)
788 {
789 struct exynos_tmu_data *data = container_of(work,
790 struct exynos_tmu_data, irq_work);
791
792 thermal_zone_device_update(data->tzd, THERMAL_EVENT_UNSPECIFIED);
793
794 mutex_lock(&data->lock);
795 clk_enable(data->clk);
796
797 /* TODO: take action based on particular interrupt */
798 data->tmu_clear_irqs(data);
799
800 clk_disable(data->clk);
801 mutex_unlock(&data->lock);
802 enable_irq(data->irq);
803 }
804
805 static void exynos4210_tmu_clear_irqs(struct exynos_tmu_data *data)
806 {
807 unsigned int val_irq;
808 u32 tmu_intstat, tmu_intclear;
809
810 if (data->soc == SOC_ARCH_EXYNOS5260) {
811 tmu_intstat = EXYNOS5260_TMU_REG_INTSTAT;
812 tmu_intclear = EXYNOS5260_TMU_REG_INTCLEAR;
813 } else if (data->soc == SOC_ARCH_EXYNOS7) {
814 tmu_intstat = EXYNOS7_TMU_REG_INTPEND;
815 tmu_intclear = EXYNOS7_TMU_REG_INTPEND;
816 } else if (data->soc == SOC_ARCH_EXYNOS5433) {
817 tmu_intstat = EXYNOS5433_TMU_REG_INTPEND;
818 tmu_intclear = EXYNOS5433_TMU_REG_INTPEND;
819 } else {
820 tmu_intstat = EXYNOS_TMU_REG_INTSTAT;
821 tmu_intclear = EXYNOS_TMU_REG_INTCLEAR;
822 }
823
824 val_irq = readl(data->base + tmu_intstat);
825 /*
826 * Clear the interrupts. Please note that the documentation for
827 * Exynos3250, Exynos4412, Exynos5250 and Exynos5260 incorrectly
828 * states that INTCLEAR register has a different placing of bits
829 * responsible for FALL IRQs than INTSTAT register. Exynos5420
830 * and Exynos5440 documentation is correct (Exynos4210 doesn't
831 * support FALL IRQs at all).
832 */
833 writel(val_irq, data->base + tmu_intclear);
834 }
835
836 static irqreturn_t exynos_tmu_irq(int irq, void *id)
837 {
838 struct exynos_tmu_data *data = id;
839
840 disable_irq_nosync(irq);
841 schedule_work(&data->irq_work);
842
843 return IRQ_HANDLED;
844 }
845
846 static const struct of_device_id exynos_tmu_match[] = {
847 {
848 .compatible = "samsung,exynos3250-tmu",
849 .data = (const void *)SOC_ARCH_EXYNOS3250,
850 }, {
851 .compatible = "samsung,exynos4210-tmu",
852 .data = (const void *)SOC_ARCH_EXYNOS4210,
853 }, {
854 .compatible = "samsung,exynos4412-tmu",
855 .data = (const void *)SOC_ARCH_EXYNOS4412,
856 }, {
857 .compatible = "samsung,exynos5250-tmu",
858 .data = (const void *)SOC_ARCH_EXYNOS5250,
859 }, {
860 .compatible = "samsung,exynos5260-tmu",
861 .data = (const void *)SOC_ARCH_EXYNOS5260,
862 }, {
863 .compatible = "samsung,exynos5420-tmu",
864 .data = (const void *)SOC_ARCH_EXYNOS5420,
865 }, {
866 .compatible = "samsung,exynos5420-tmu-ext-triminfo",
867 .data = (const void *)SOC_ARCH_EXYNOS5420_TRIMINFO,
868 }, {
869 .compatible = "samsung,exynos5433-tmu",
870 .data = (const void *)SOC_ARCH_EXYNOS5433,
871 }, {
872 .compatible = "samsung,exynos7-tmu",
873 .data = (const void *)SOC_ARCH_EXYNOS7,
874 },
875 { },
876 };
877 MODULE_DEVICE_TABLE(of, exynos_tmu_match);
878
879 static int exynos_map_dt_data(struct platform_device *pdev)
880 {
881 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
882 struct resource res;
883
884 if (!data || !pdev->dev.of_node)
885 return -ENODEV;
886
887 data->id = of_alias_get_id(pdev->dev.of_node, "tmuctrl");
888 if (data->id < 0)
889 data->id = 0;
890
891 data->irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
892 if (data->irq <= 0) {
893 dev_err(&pdev->dev, "failed to get IRQ\n");
894 return -ENODEV;
895 }
896
897 if (of_address_to_resource(pdev->dev.of_node, 0, &res)) {
898 dev_err(&pdev->dev, "failed to get Resource 0\n");
899 return -ENODEV;
900 }
901
902 data->base = devm_ioremap(&pdev->dev, res.start, resource_size(&res));
903 if (!data->base) {
904 dev_err(&pdev->dev, "Failed to ioremap memory\n");
905 return -EADDRNOTAVAIL;
906 }
907
908 data->soc = (enum soc_type)of_device_get_match_data(&pdev->dev);
909
910 switch (data->soc) {
911 case SOC_ARCH_EXYNOS4210:
912 data->tmu_set_trip_temp = exynos4210_tmu_set_trip_temp;
913 data->tmu_set_trip_hyst = exynos4210_tmu_set_trip_hyst;
914 data->tmu_initialize = exynos4210_tmu_initialize;
915 data->tmu_control = exynos4210_tmu_control;
916 data->tmu_read = exynos4210_tmu_read;
917 data->tmu_clear_irqs = exynos4210_tmu_clear_irqs;
918 data->ntrip = 4;
919 data->gain = 15;
920 data->reference_voltage = 7;
921 data->efuse_value = 55;
922 data->min_efuse_value = 40;
923 data->max_efuse_value = 100;
924 break;
925 case SOC_ARCH_EXYNOS3250:
926 case SOC_ARCH_EXYNOS4412:
927 case SOC_ARCH_EXYNOS5250:
928 case SOC_ARCH_EXYNOS5260:
929 case SOC_ARCH_EXYNOS5420:
930 case SOC_ARCH_EXYNOS5420_TRIMINFO:
931 data->tmu_set_trip_temp = exynos4412_tmu_set_trip_temp;
932 data->tmu_set_trip_hyst = exynos4412_tmu_set_trip_hyst;
933 data->tmu_initialize = exynos4412_tmu_initialize;
934 data->tmu_control = exynos4210_tmu_control;
935 data->tmu_read = exynos4412_tmu_read;
936 data->tmu_set_emulation = exynos4412_tmu_set_emulation;
937 data->tmu_clear_irqs = exynos4210_tmu_clear_irqs;
938 data->ntrip = 4;
939 data->gain = 8;
940 data->reference_voltage = 16;
941 data->efuse_value = 55;
942 if (data->soc != SOC_ARCH_EXYNOS5420 &&
943 data->soc != SOC_ARCH_EXYNOS5420_TRIMINFO)
944 data->min_efuse_value = 40;
945 else
946 data->min_efuse_value = 0;
947 data->max_efuse_value = 100;
948 break;
949 case SOC_ARCH_EXYNOS5433:
950 data->tmu_set_trip_temp = exynos5433_tmu_set_trip_temp;
951 data->tmu_set_trip_hyst = exynos5433_tmu_set_trip_hyst;
952 data->tmu_initialize = exynos5433_tmu_initialize;
953 data->tmu_control = exynos5433_tmu_control;
954 data->tmu_read = exynos4412_tmu_read;
955 data->tmu_set_emulation = exynos4412_tmu_set_emulation;
956 data->tmu_clear_irqs = exynos4210_tmu_clear_irqs;
957 data->ntrip = 8;
958 data->gain = 8;
959 if (res.start == EXYNOS5433_G3D_BASE)
960 data->reference_voltage = 23;
961 else
962 data->reference_voltage = 16;
963 data->efuse_value = 75;
964 data->min_efuse_value = 40;
965 data->max_efuse_value = 150;
966 break;
967 case SOC_ARCH_EXYNOS7:
968 data->tmu_set_trip_temp = exynos7_tmu_set_trip_temp;
969 data->tmu_set_trip_hyst = exynos7_tmu_set_trip_hyst;
970 data->tmu_initialize = exynos7_tmu_initialize;
971 data->tmu_control = exynos7_tmu_control;
972 data->tmu_read = exynos7_tmu_read;
973 data->tmu_set_emulation = exynos4412_tmu_set_emulation;
974 data->tmu_clear_irqs = exynos4210_tmu_clear_irqs;
975 data->ntrip = 8;
976 data->gain = 9;
977 data->reference_voltage = 17;
978 data->efuse_value = 75;
979 data->min_efuse_value = 15;
980 data->max_efuse_value = 100;
981 break;
982 default:
983 dev_err(&pdev->dev, "Platform not supported\n");
984 return -EINVAL;
985 }
986
987 data->cal_type = TYPE_ONE_POINT_TRIMMING;
988
989 /*
990 * Check if the TMU shares some registers and then try to map the
991 * memory of common registers.
992 */
993 if (data->soc != SOC_ARCH_EXYNOS5420_TRIMINFO)
994 return 0;
995
996 if (of_address_to_resource(pdev->dev.of_node, 1, &res)) {
997 dev_err(&pdev->dev, "failed to get Resource 1\n");
998 return -ENODEV;
999 }
1000
1001 data->base_second = devm_ioremap(&pdev->dev, res.start,
1002 resource_size(&res));
1003 if (!data->base_second) {
1004 dev_err(&pdev->dev, "Failed to ioremap memory\n");
1005 return -ENOMEM;
1006 }
1007
1008 return 0;
1009 }
1010
1011 static const struct thermal_zone_of_device_ops exynos_sensor_ops = {
1012 .get_temp = exynos_get_temp,
1013 .set_emul_temp = exynos_tmu_set_emulation,
1014 };
1015
1016 static int exynos_tmu_probe(struct platform_device *pdev)
1017 {
1018 struct exynos_tmu_data *data;
1019 int ret;
1020
1021 data = devm_kzalloc(&pdev->dev, sizeof(struct exynos_tmu_data),
1022 GFP_KERNEL);
1023 if (!data)
1024 return -ENOMEM;
1025
1026 platform_set_drvdata(pdev, data);
1027 mutex_init(&data->lock);
1028
1029 /*
1030 * Try enabling the regulator if found
1031 * TODO: Add regulator as an SOC feature, so that regulator enable
1032 * is a compulsory call.
1033 */
1034 data->regulator = devm_regulator_get_optional(&pdev->dev, "vtmu");
1035 if (!IS_ERR(data->regulator)) {
1036 ret = regulator_enable(data->regulator);
1037 if (ret) {
1038 dev_err(&pdev->dev, "failed to enable vtmu\n");
1039 return ret;
1040 }
1041 } else {
1042 if (PTR_ERR(data->regulator) == -EPROBE_DEFER)
1043 return -EPROBE_DEFER;
1044 dev_info(&pdev->dev, "Regulator node (vtmu) not found\n");
1045 }
1046
1047 ret = exynos_map_dt_data(pdev);
1048 if (ret)
1049 goto err_sensor;
1050
1051 INIT_WORK(&data->irq_work, exynos_tmu_work);
1052
1053 data->clk = devm_clk_get(&pdev->dev, "tmu_apbif");
1054 if (IS_ERR(data->clk)) {
1055 dev_err(&pdev->dev, "Failed to get clock\n");
1056 ret = PTR_ERR(data->clk);
1057 goto err_sensor;
1058 }
1059
1060 data->clk_sec = devm_clk_get(&pdev->dev, "tmu_triminfo_apbif");
1061 if (IS_ERR(data->clk_sec)) {
1062 if (data->soc == SOC_ARCH_EXYNOS5420_TRIMINFO) {
1063 dev_err(&pdev->dev, "Failed to get triminfo clock\n");
1064 ret = PTR_ERR(data->clk_sec);
1065 goto err_sensor;
1066 }
1067 } else {
1068 ret = clk_prepare(data->clk_sec);
1069 if (ret) {
1070 dev_err(&pdev->dev, "Failed to get clock\n");
1071 goto err_sensor;
1072 }
1073 }
1074
1075 ret = clk_prepare(data->clk);
1076 if (ret) {
1077 dev_err(&pdev->dev, "Failed to get clock\n");
1078 goto err_clk_sec;
1079 }
1080
1081 switch (data->soc) {
1082 case SOC_ARCH_EXYNOS5433:
1083 case SOC_ARCH_EXYNOS7:
1084 data->sclk = devm_clk_get(&pdev->dev, "tmu_sclk");
1085 if (IS_ERR(data->sclk)) {
1086 dev_err(&pdev->dev, "Failed to get sclk\n");
1087 goto err_clk;
1088 } else {
1089 ret = clk_prepare_enable(data->sclk);
1090 if (ret) {
1091 dev_err(&pdev->dev, "Failed to enable sclk\n");
1092 goto err_clk;
1093 }
1094 }
1095 break;
1096 default:
1097 break;
1098 }
1099
1100 /*
1101 * data->tzd must be registered before calling exynos_tmu_initialize(),
1102 * requesting irq and calling exynos_tmu_control().
1103 */
1104 data->tzd = thermal_zone_of_sensor_register(&pdev->dev, 0, data,
1105 &exynos_sensor_ops);
1106 if (IS_ERR(data->tzd)) {
1107 ret = PTR_ERR(data->tzd);
1108 dev_err(&pdev->dev, "Failed to register sensor: %d\n", ret);
1109 goto err_sclk;
1110 }
1111
1112 ret = exynos_tmu_initialize(pdev);
1113 if (ret) {
1114 dev_err(&pdev->dev, "Failed to initialize TMU\n");
1115 goto err_thermal;
1116 }
1117
1118 ret = devm_request_irq(&pdev->dev, data->irq, exynos_tmu_irq,
1119 IRQF_TRIGGER_RISING | IRQF_SHARED, dev_name(&pdev->dev), data);
1120 if (ret) {
1121 dev_err(&pdev->dev, "Failed to request irq: %d\n", data->irq);
1122 goto err_thermal;
1123 }
1124
1125 exynos_tmu_control(pdev, true);
1126 return 0;
1127
1128 err_thermal:
1129 thermal_zone_of_sensor_unregister(&pdev->dev, data->tzd);
1130 err_sclk:
1131 clk_disable_unprepare(data->sclk);
1132 err_clk:
1133 clk_unprepare(data->clk);
1134 err_clk_sec:
1135 if (!IS_ERR(data->clk_sec))
1136 clk_unprepare(data->clk_sec);
1137 err_sensor:
1138 if (!IS_ERR(data->regulator))
1139 regulator_disable(data->regulator);
1140
1141 return ret;
1142 }
1143
1144 static int exynos_tmu_remove(struct platform_device *pdev)
1145 {
1146 struct exynos_tmu_data *data = platform_get_drvdata(pdev);
1147 struct thermal_zone_device *tzd = data->tzd;
1148
1149 thermal_zone_of_sensor_unregister(&pdev->dev, tzd);
1150 exynos_tmu_control(pdev, false);
1151
1152 clk_disable_unprepare(data->sclk);
1153 clk_unprepare(data->clk);
1154 if (!IS_ERR(data->clk_sec))
1155 clk_unprepare(data->clk_sec);
1156
1157 if (!IS_ERR(data->regulator))
1158 regulator_disable(data->regulator);
1159
1160 return 0;
1161 }
1162
1163 #ifdef CONFIG_PM_SLEEP
1164 static int exynos_tmu_suspend(struct device *dev)
1165 {
1166 exynos_tmu_control(to_platform_device(dev), false);
1167
1168 return 0;
1169 }
1170
1171 static int exynos_tmu_resume(struct device *dev)
1172 {
1173 struct platform_device *pdev = to_platform_device(dev);
1174
1175 exynos_tmu_initialize(pdev);
1176 exynos_tmu_control(pdev, true);
1177
1178 return 0;
1179 }
1180
1181 static SIMPLE_DEV_PM_OPS(exynos_tmu_pm,
1182 exynos_tmu_suspend, exynos_tmu_resume);
1183 #define EXYNOS_TMU_PM (&exynos_tmu_pm)
1184 #else
1185 #define EXYNOS_TMU_PM NULL
1186 #endif
1187
1188 static struct platform_driver exynos_tmu_driver = {
1189 .driver = {
1190 .name = "exynos-tmu",
1191 .pm = EXYNOS_TMU_PM,
1192 .of_match_table = exynos_tmu_match,
1193 },
1194 .probe = exynos_tmu_probe,
1195 .remove = exynos_tmu_remove,
1196 };
1197
1198 module_platform_driver(exynos_tmu_driver);
1199
1200 MODULE_DESCRIPTION("EXYNOS TMU Driver");
1201 MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
1202 MODULE_LICENSE("GPL");
1203 MODULE_ALIAS("platform:exynos-tmu");
Linux with added FPC-III support