1 // SPDX-License-Identifier: GPL-2.0
3 * R-Car THS/TSC thermal sensor driver
5 * Copyright (C) 2012 Renesas Solutions Corp.
6 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
8 #include <linux/delay.h>
10 #include <linux/irq.h>
11 #include <linux/interrupt.h>
13 #include <linux/module.h>
14 #include <linux/of_device.h>
15 #include <linux/platform_device.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/reboot.h>
18 #include <linux/slab.h>
19 #include <linux/spinlock.h>
20 #include <linux/thermal.h>
22 #include "thermal_hwmon.h"
24 #define IDLE_INTERVAL 5000
26 #define COMMON_STR 0x00
27 #define COMMON_ENR 0x04
28 #define COMMON_INTMSK 0x0c
30 #define REG_POSNEG 0x20
31 #define REG_FILONOFF 0x28
32 #define REG_THSCR 0x2c
33 #define REG_THSSR 0x30
34 #define REG_INTCTRL 0x34
37 #define CPCTL (1 << 12)
42 struct rcar_thermal_common
{
45 struct list_head head
;
49 struct rcar_thermal_chip
{
50 unsigned int use_of_thermal
: 1;
51 unsigned int has_filonoff
: 1;
52 unsigned int irq_per_ch
: 1;
53 unsigned int needs_suspend_resume
: 1;
57 static const struct rcar_thermal_chip rcar_thermal
= {
61 .needs_suspend_resume
= 0,
65 static const struct rcar_thermal_chip rcar_gen2_thermal
= {
69 .needs_suspend_resume
= 0,
73 static const struct rcar_thermal_chip rcar_gen3_thermal
= {
77 .needs_suspend_resume
= 1,
79 * The Gen3 chip has 3 interrupts, but this driver uses only 2
80 * interrupts to detect a temperature change, rise or fall.
85 struct rcar_thermal_priv
{
87 struct rcar_thermal_common
*common
;
88 struct thermal_zone_device
*zone
;
89 const struct rcar_thermal_chip
*chip
;
90 struct delayed_work work
;
92 struct list_head list
;
97 #define rcar_thermal_for_each_priv(pos, common) \
98 list_for_each_entry(pos, &common->head, list)
100 #define MCELSIUS(temp) ((temp) * 1000)
101 #define rcar_zone_to_priv(zone) ((zone)->devdata)
102 #define rcar_priv_to_dev(priv) ((priv)->common->dev)
103 #define rcar_has_irq_support(priv) ((priv)->common->base)
104 #define rcar_id_to_shift(priv) ((priv)->id * 8)
106 static const struct of_device_id rcar_thermal_dt_ids
[] = {
108 .compatible
= "renesas,rcar-thermal",
109 .data
= &rcar_thermal
,
112 .compatible
= "renesas,rcar-gen2-thermal",
113 .data
= &rcar_gen2_thermal
,
116 .compatible
= "renesas,thermal-r8a77970",
117 .data
= &rcar_gen3_thermal
,
120 .compatible
= "renesas,thermal-r8a77995",
121 .data
= &rcar_gen3_thermal
,
125 MODULE_DEVICE_TABLE(of
, rcar_thermal_dt_ids
);
130 #define rcar_thermal_common_read(c, r) \
131 _rcar_thermal_common_read(c, COMMON_ ##r)
132 static u32
_rcar_thermal_common_read(struct rcar_thermal_common
*common
,
135 return ioread32(common
->base
+ reg
);
138 #define rcar_thermal_common_write(c, r, d) \
139 _rcar_thermal_common_write(c, COMMON_ ##r, d)
140 static void _rcar_thermal_common_write(struct rcar_thermal_common
*common
,
143 iowrite32(data
, common
->base
+ reg
);
146 #define rcar_thermal_common_bset(c, r, m, d) \
147 _rcar_thermal_common_bset(c, COMMON_ ##r, m, d)
148 static void _rcar_thermal_common_bset(struct rcar_thermal_common
*common
,
149 u32 reg
, u32 mask
, u32 data
)
153 val
= ioread32(common
->base
+ reg
);
155 val
|= (data
& mask
);
156 iowrite32(val
, common
->base
+ reg
);
159 #define rcar_thermal_read(p, r) _rcar_thermal_read(p, REG_ ##r)
160 static u32
_rcar_thermal_read(struct rcar_thermal_priv
*priv
, u32 reg
)
162 return ioread32(priv
->base
+ reg
);
165 #define rcar_thermal_write(p, r, d) _rcar_thermal_write(p, REG_ ##r, d)
166 static void _rcar_thermal_write(struct rcar_thermal_priv
*priv
,
169 iowrite32(data
, priv
->base
+ reg
);
172 #define rcar_thermal_bset(p, r, m, d) _rcar_thermal_bset(p, REG_ ##r, m, d)
173 static void _rcar_thermal_bset(struct rcar_thermal_priv
*priv
, u32 reg
,
178 val
= ioread32(priv
->base
+ reg
);
180 val
|= (data
& mask
);
181 iowrite32(val
, priv
->base
+ reg
);
185 * zone device functions
187 static int rcar_thermal_update_temp(struct rcar_thermal_priv
*priv
)
189 struct device
*dev
= rcar_priv_to_dev(priv
);
194 mutex_lock(&priv
->lock
);
197 * TSC decides a value of CPTAP automatically,
198 * and this is the conditions which validate interrupt.
200 rcar_thermal_bset(priv
, THSCR
, CPCTL
, CPCTL
);
204 for (i
= 0; i
< 128; i
++) {
206 * we need to wait 300us after changing comparator offset
207 * to get stable temperature.
208 * see "Usage Notes" on datasheet
212 new = rcar_thermal_read(priv
, THSSR
) & CTEMP
;
221 dev_err(dev
, "thermal sensor was broken\n");
228 if (rcar_has_irq_support(priv
)) {
229 if (priv
->chip
->has_filonoff
)
230 rcar_thermal_write(priv
, FILONOFF
, 0);
232 /* enable Rising/Falling edge interrupt */
233 rcar_thermal_write(priv
, POSNEG
, 0x1);
234 rcar_thermal_write(priv
, INTCTRL
, (((ctemp
- 0) << 8) |
235 ((ctemp
- 1) << 0)));
238 dev_dbg(dev
, "thermal%d %d -> %d\n", priv
->id
, priv
->ctemp
, ctemp
);
243 mutex_unlock(&priv
->lock
);
247 static int rcar_thermal_get_current_temp(struct rcar_thermal_priv
*priv
,
253 ret
= rcar_thermal_update_temp(priv
);
257 mutex_lock(&priv
->lock
);
258 tmp
= MCELSIUS((priv
->ctemp
* 5) - 65);
259 mutex_unlock(&priv
->lock
);
261 if ((tmp
< MCELSIUS(-45)) || (tmp
> MCELSIUS(125))) {
262 struct device
*dev
= rcar_priv_to_dev(priv
);
264 dev_err(dev
, "it couldn't measure temperature correctly\n");
273 static int rcar_thermal_of_get_temp(void *data
, int *temp
)
275 struct rcar_thermal_priv
*priv
= data
;
277 return rcar_thermal_get_current_temp(priv
, temp
);
280 static int rcar_thermal_get_temp(struct thermal_zone_device
*zone
, int *temp
)
282 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
284 return rcar_thermal_get_current_temp(priv
, temp
);
287 static int rcar_thermal_get_trip_type(struct thermal_zone_device
*zone
,
288 int trip
, enum thermal_trip_type
*type
)
290 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
291 struct device
*dev
= rcar_priv_to_dev(priv
);
293 /* see rcar_thermal_get_temp() */
295 case 0: /* +90 <= temp */
296 *type
= THERMAL_TRIP_CRITICAL
;
299 dev_err(dev
, "rcar driver trip error\n");
306 static int rcar_thermal_get_trip_temp(struct thermal_zone_device
*zone
,
309 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
310 struct device
*dev
= rcar_priv_to_dev(priv
);
312 /* see rcar_thermal_get_temp() */
314 case 0: /* +90 <= temp */
315 *temp
= MCELSIUS(90);
318 dev_err(dev
, "rcar driver trip error\n");
325 static int rcar_thermal_notify(struct thermal_zone_device
*zone
,
326 int trip
, enum thermal_trip_type type
)
328 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
329 struct device
*dev
= rcar_priv_to_dev(priv
);
332 case THERMAL_TRIP_CRITICAL
:
334 dev_warn(dev
, "Thermal reached to critical temperature\n");
343 static const struct thermal_zone_of_device_ops rcar_thermal_zone_of_ops
= {
344 .get_temp
= rcar_thermal_of_get_temp
,
347 static struct thermal_zone_device_ops rcar_thermal_zone_ops
= {
348 .get_temp
= rcar_thermal_get_temp
,
349 .get_trip_type
= rcar_thermal_get_trip_type
,
350 .get_trip_temp
= rcar_thermal_get_trip_temp
,
351 .notify
= rcar_thermal_notify
,
357 #define rcar_thermal_irq_enable(p) _rcar_thermal_irq_ctrl(p, 1)
358 #define rcar_thermal_irq_disable(p) _rcar_thermal_irq_ctrl(p, 0)
359 static void _rcar_thermal_irq_ctrl(struct rcar_thermal_priv
*priv
, int enable
)
361 struct rcar_thermal_common
*common
= priv
->common
;
363 u32 mask
= 0x3 << rcar_id_to_shift(priv
); /* enable Rising/Falling */
365 if (!rcar_has_irq_support(priv
))
368 spin_lock_irqsave(&common
->lock
, flags
);
370 rcar_thermal_common_bset(common
, INTMSK
, mask
, enable
? 0 : mask
);
372 spin_unlock_irqrestore(&common
->lock
, flags
);
375 static void rcar_thermal_work(struct work_struct
*work
)
377 struct rcar_thermal_priv
*priv
;
381 priv
= container_of(work
, struct rcar_thermal_priv
, work
.work
);
383 ret
= rcar_thermal_get_current_temp(priv
, &cctemp
);
387 ret
= rcar_thermal_update_temp(priv
);
391 rcar_thermal_irq_enable(priv
);
393 ret
= rcar_thermal_get_current_temp(priv
, &nctemp
);
397 if (nctemp
!= cctemp
)
398 thermal_zone_device_update(priv
->zone
,
399 THERMAL_EVENT_UNSPECIFIED
);
402 static u32
rcar_thermal_had_changed(struct rcar_thermal_priv
*priv
, u32 status
)
404 struct device
*dev
= rcar_priv_to_dev(priv
);
406 status
= (status
>> rcar_id_to_shift(priv
)) & 0x3;
409 dev_dbg(dev
, "thermal%d %s%s\n",
411 (status
& 0x2) ? "Rising " : "",
412 (status
& 0x1) ? "Falling" : "");
418 static irqreturn_t
rcar_thermal_irq(int irq
, void *data
)
420 struct rcar_thermal_common
*common
= data
;
421 struct rcar_thermal_priv
*priv
;
425 spin_lock_irqsave(&common
->lock
, flags
);
427 mask
= rcar_thermal_common_read(common
, INTMSK
);
428 status
= rcar_thermal_common_read(common
, STR
);
429 rcar_thermal_common_write(common
, STR
, 0x000F0F0F & mask
);
431 spin_unlock_irqrestore(&common
->lock
, flags
);
433 status
= status
& ~mask
;
438 rcar_thermal_for_each_priv(priv
, common
) {
439 if (rcar_thermal_had_changed(priv
, status
)) {
440 rcar_thermal_irq_disable(priv
);
441 queue_delayed_work(system_freezable_wq
, &priv
->work
,
442 msecs_to_jiffies(300));
452 static int rcar_thermal_remove(struct platform_device
*pdev
)
454 struct rcar_thermal_common
*common
= platform_get_drvdata(pdev
);
455 struct device
*dev
= &pdev
->dev
;
456 struct rcar_thermal_priv
*priv
;
458 rcar_thermal_for_each_priv(priv
, common
) {
459 rcar_thermal_irq_disable(priv
);
460 cancel_delayed_work_sync(&priv
->work
);
461 if (priv
->chip
->use_of_thermal
)
462 thermal_remove_hwmon_sysfs(priv
->zone
);
464 thermal_zone_device_unregister(priv
->zone
);
468 pm_runtime_disable(dev
);
473 static int rcar_thermal_probe(struct platform_device
*pdev
)
475 struct rcar_thermal_common
*common
;
476 struct rcar_thermal_priv
*priv
;
477 struct device
*dev
= &pdev
->dev
;
478 struct resource
*res
, *irq
;
479 const struct rcar_thermal_chip
*chip
= of_device_get_match_data(dev
);
483 int idle
= IDLE_INTERVAL
;
486 common
= devm_kzalloc(dev
, sizeof(*common
), GFP_KERNEL
);
490 platform_set_drvdata(pdev
, common
);
492 INIT_LIST_HEAD(&common
->head
);
493 spin_lock_init(&common
->lock
);
496 pm_runtime_enable(dev
);
497 pm_runtime_get_sync(dev
);
499 for (i
= 0; i
< chip
->nirqs
; i
++) {
500 irq
= platform_get_resource(pdev
, IORESOURCE_IRQ
, i
);
505 * platform has IRQ support.
506 * Then, driver uses common registers
507 * rcar_has_irq_support() will be enabled
509 res
= platform_get_resource(pdev
, IORESOURCE_MEM
,
511 common
->base
= devm_ioremap_resource(dev
, res
);
512 if (IS_ERR(common
->base
))
513 return PTR_ERR(common
->base
);
515 idle
= 0; /* polling delay is not needed */
518 ret
= devm_request_irq(dev
, irq
->start
, rcar_thermal_irq
,
519 IRQF_SHARED
, dev_name(dev
), common
);
521 dev_err(dev
, "irq request failed\n ");
522 goto error_unregister
;
525 /* update ENR bits */
526 if (chip
->irq_per_ch
)
531 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, mres
++);
535 priv
= devm_kzalloc(dev
, sizeof(*priv
), GFP_KERNEL
);
538 goto error_unregister
;
541 priv
->base
= devm_ioremap_resource(dev
, res
);
542 if (IS_ERR(priv
->base
)) {
543 ret
= PTR_ERR(priv
->base
);
544 goto error_unregister
;
547 priv
->common
= common
;
550 mutex_init(&priv
->lock
);
551 INIT_LIST_HEAD(&priv
->list
);
552 INIT_DELAYED_WORK(&priv
->work
, rcar_thermal_work
);
553 ret
= rcar_thermal_update_temp(priv
);
555 goto error_unregister
;
557 if (chip
->use_of_thermal
)
558 priv
->zone
= devm_thermal_zone_of_sensor_register(
560 &rcar_thermal_zone_of_ops
);
562 priv
->zone
= thermal_zone_device_register(
565 &rcar_thermal_zone_ops
, NULL
, 0,
567 if (IS_ERR(priv
->zone
)) {
568 dev_err(dev
, "can't register thermal zone\n");
569 ret
= PTR_ERR(priv
->zone
);
571 goto error_unregister
;
574 if (chip
->use_of_thermal
) {
576 * thermal_zone doesn't enable hwmon as default,
577 * but, enable it here to keep compatible
579 priv
->zone
->tzp
->no_hwmon
= false;
580 ret
= thermal_add_hwmon_sysfs(priv
->zone
);
582 goto error_unregister
;
585 rcar_thermal_irq_enable(priv
);
587 list_move_tail(&priv
->list
, &common
->head
);
589 /* update ENR bits */
590 if (!chip
->irq_per_ch
)
591 enr_bits
|= 3 << (i
* 8);
594 if (common
->base
&& enr_bits
)
595 rcar_thermal_common_write(common
, ENR
, enr_bits
);
597 dev_info(dev
, "%d sensor probed\n", i
);
602 rcar_thermal_remove(pdev
);
607 #ifdef CONFIG_PM_SLEEP
608 static int rcar_thermal_suspend(struct device
*dev
)
610 struct rcar_thermal_common
*common
= dev_get_drvdata(dev
);
611 struct rcar_thermal_priv
*priv
= list_first_entry(&common
->head
,
612 typeof(*priv
), list
);
614 if (priv
->chip
->needs_suspend_resume
) {
615 rcar_thermal_common_write(common
, ENR
, 0);
616 rcar_thermal_irq_disable(priv
);
617 rcar_thermal_bset(priv
, THSCR
, CPCTL
, 0);
623 static int rcar_thermal_resume(struct device
*dev
)
625 struct rcar_thermal_common
*common
= dev_get_drvdata(dev
);
626 struct rcar_thermal_priv
*priv
= list_first_entry(&common
->head
,
627 typeof(*priv
), list
);
630 if (priv
->chip
->needs_suspend_resume
) {
631 ret
= rcar_thermal_update_temp(priv
);
634 rcar_thermal_irq_enable(priv
);
635 rcar_thermal_common_write(common
, ENR
, 0x03);
642 static SIMPLE_DEV_PM_OPS(rcar_thermal_pm_ops
, rcar_thermal_suspend
,
643 rcar_thermal_resume
);
645 static struct platform_driver rcar_thermal_driver
= {
647 .name
= "rcar_thermal",
648 .pm
= &rcar_thermal_pm_ops
,
649 .of_match_table
= rcar_thermal_dt_ids
,
651 .probe
= rcar_thermal_probe
,
652 .remove
= rcar_thermal_remove
,
654 module_platform_driver(rcar_thermal_driver
);
656 MODULE_LICENSE("GPL v2");
657 MODULE_DESCRIPTION("R-Car THS/TSC thermal sensor driver");
658 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");