2 * R-Car THS/TSC thermal sensor driver
4 * Copyright (C) 2012 Renesas Solutions Corp.
5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; version 2 of the License.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
20 #include <linux/delay.h>
21 #include <linux/err.h>
22 #include <linux/irq.h>
23 #include <linux/interrupt.h>
25 #include <linux/module.h>
26 #include <linux/platform_device.h>
27 #include <linux/pm_runtime.h>
28 #include <linux/reboot.h>
29 #include <linux/slab.h>
30 #include <linux/spinlock.h>
31 #include <linux/thermal.h>
33 #define IDLE_INTERVAL 5000
35 #define COMMON_STR 0x00
36 #define COMMON_ENR 0x04
37 #define COMMON_INTMSK 0x0c
39 #define REG_POSNEG 0x20
40 #define REG_FILONOFF 0x28
41 #define REG_THSCR 0x2c
42 #define REG_THSSR 0x30
43 #define REG_INTCTRL 0x34
46 #define CPCTL (1 << 12)
51 struct rcar_thermal_common
{
54 struct list_head head
;
58 struct rcar_thermal_priv
{
60 struct rcar_thermal_common
*common
;
61 struct thermal_zone_device
*zone
;
62 struct delayed_work work
;
64 struct list_head list
;
69 #define rcar_thermal_for_each_priv(pos, common) \
70 list_for_each_entry(pos, &common->head, list)
72 #define MCELSIUS(temp) ((temp) * 1000)
73 #define rcar_zone_to_priv(zone) ((zone)->devdata)
74 #define rcar_priv_to_dev(priv) ((priv)->common->dev)
75 #define rcar_has_irq_support(priv) ((priv)->common->base)
76 #define rcar_id_to_shift(priv) ((priv)->id * 8)
78 static const struct of_device_id rcar_thermal_dt_ids
[] = {
79 { .compatible
= "renesas,rcar-thermal", },
82 MODULE_DEVICE_TABLE(of
, rcar_thermal_dt_ids
);
87 #define rcar_thermal_common_read(c, r) \
88 _rcar_thermal_common_read(c, COMMON_ ##r)
89 static u32
_rcar_thermal_common_read(struct rcar_thermal_common
*common
,
92 return ioread32(common
->base
+ reg
);
95 #define rcar_thermal_common_write(c, r, d) \
96 _rcar_thermal_common_write(c, COMMON_ ##r, d)
97 static void _rcar_thermal_common_write(struct rcar_thermal_common
*common
,
100 iowrite32(data
, common
->base
+ reg
);
103 #define rcar_thermal_common_bset(c, r, m, d) \
104 _rcar_thermal_common_bset(c, COMMON_ ##r, m, d)
105 static void _rcar_thermal_common_bset(struct rcar_thermal_common
*common
,
106 u32 reg
, u32 mask
, u32 data
)
110 val
= ioread32(common
->base
+ reg
);
112 val
|= (data
& mask
);
113 iowrite32(val
, common
->base
+ reg
);
116 #define rcar_thermal_read(p, r) _rcar_thermal_read(p, REG_ ##r)
117 static u32
_rcar_thermal_read(struct rcar_thermal_priv
*priv
, u32 reg
)
119 return ioread32(priv
->base
+ reg
);
122 #define rcar_thermal_write(p, r, d) _rcar_thermal_write(p, REG_ ##r, d)
123 static void _rcar_thermal_write(struct rcar_thermal_priv
*priv
,
126 iowrite32(data
, priv
->base
+ reg
);
129 #define rcar_thermal_bset(p, r, m, d) _rcar_thermal_bset(p, REG_ ##r, m, d)
130 static void _rcar_thermal_bset(struct rcar_thermal_priv
*priv
, u32 reg
,
135 val
= ioread32(priv
->base
+ reg
);
137 val
|= (data
& mask
);
138 iowrite32(val
, priv
->base
+ reg
);
142 * zone device functions
144 static int rcar_thermal_update_temp(struct rcar_thermal_priv
*priv
)
146 struct device
*dev
= rcar_priv_to_dev(priv
);
151 mutex_lock(&priv
->lock
);
154 * TSC decides a value of CPTAP automatically,
155 * and this is the conditions which validate interrupt.
157 rcar_thermal_bset(priv
, THSCR
, CPCTL
, CPCTL
);
161 for (i
= 0; i
< 128; i
++) {
163 * we need to wait 300us after changing comparator offset
164 * to get stable temperature.
165 * see "Usage Notes" on datasheet
169 new = rcar_thermal_read(priv
, THSSR
) & CTEMP
;
178 dev_err(dev
, "thermal sensor was broken\n");
185 if (rcar_has_irq_support(priv
)) {
186 rcar_thermal_write(priv
, FILONOFF
, 0);
188 /* enable Rising/Falling edge interrupt */
189 rcar_thermal_write(priv
, POSNEG
, 0x1);
190 rcar_thermal_write(priv
, INTCTRL
, (((ctemp
- 0) << 8) |
191 ((ctemp
- 1) << 0)));
194 dev_dbg(dev
, "thermal%d %d -> %d\n", priv
->id
, priv
->ctemp
, ctemp
);
199 mutex_unlock(&priv
->lock
);
203 static int rcar_thermal_get_temp(struct thermal_zone_device
*zone
, int *temp
)
205 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
209 ret
= rcar_thermal_update_temp(priv
);
213 mutex_lock(&priv
->lock
);
214 tmp
= MCELSIUS((priv
->ctemp
* 5) - 65);
215 mutex_unlock(&priv
->lock
);
217 if ((tmp
< MCELSIUS(-45)) || (tmp
> MCELSIUS(125))) {
218 struct device
*dev
= rcar_priv_to_dev(priv
);
220 dev_err(dev
, "it couldn't measure temperature correctly\n");
229 static int rcar_thermal_get_trip_type(struct thermal_zone_device
*zone
,
230 int trip
, enum thermal_trip_type
*type
)
232 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
233 struct device
*dev
= rcar_priv_to_dev(priv
);
235 /* see rcar_thermal_get_temp() */
237 case 0: /* +90 <= temp */
238 *type
= THERMAL_TRIP_CRITICAL
;
241 dev_err(dev
, "rcar driver trip error\n");
248 static int rcar_thermal_get_trip_temp(struct thermal_zone_device
*zone
,
251 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
252 struct device
*dev
= rcar_priv_to_dev(priv
);
254 /* see rcar_thermal_get_temp() */
256 case 0: /* +90 <= temp */
257 *temp
= MCELSIUS(90);
260 dev_err(dev
, "rcar driver trip error\n");
267 static int rcar_thermal_notify(struct thermal_zone_device
*zone
,
268 int trip
, enum thermal_trip_type type
)
270 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
271 struct device
*dev
= rcar_priv_to_dev(priv
);
274 case THERMAL_TRIP_CRITICAL
:
276 dev_warn(dev
, "Thermal reached to critical temperature\n");
285 static struct thermal_zone_device_ops rcar_thermal_zone_ops
= {
286 .get_temp
= rcar_thermal_get_temp
,
287 .get_trip_type
= rcar_thermal_get_trip_type
,
288 .get_trip_temp
= rcar_thermal_get_trip_temp
,
289 .notify
= rcar_thermal_notify
,
295 #define rcar_thermal_irq_enable(p) _rcar_thermal_irq_ctrl(p, 1)
296 #define rcar_thermal_irq_disable(p) _rcar_thermal_irq_ctrl(p, 0)
297 static void _rcar_thermal_irq_ctrl(struct rcar_thermal_priv
*priv
, int enable
)
299 struct rcar_thermal_common
*common
= priv
->common
;
301 u32 mask
= 0x3 << rcar_id_to_shift(priv
); /* enable Rising/Falling */
303 if (!rcar_has_irq_support(priv
))
306 spin_lock_irqsave(&common
->lock
, flags
);
308 rcar_thermal_common_bset(common
, INTMSK
, mask
, enable
? 0 : mask
);
310 spin_unlock_irqrestore(&common
->lock
, flags
);
313 static void rcar_thermal_work(struct work_struct
*work
)
315 struct rcar_thermal_priv
*priv
;
319 priv
= container_of(work
, struct rcar_thermal_priv
, work
.work
);
321 rcar_thermal_get_temp(priv
->zone
, &cctemp
);
322 ret
= rcar_thermal_update_temp(priv
);
326 rcar_thermal_irq_enable(priv
);
328 rcar_thermal_get_temp(priv
->zone
, &nctemp
);
329 if (nctemp
!= cctemp
)
330 thermal_zone_device_update(priv
->zone
);
333 static u32
rcar_thermal_had_changed(struct rcar_thermal_priv
*priv
, u32 status
)
335 struct device
*dev
= rcar_priv_to_dev(priv
);
337 status
= (status
>> rcar_id_to_shift(priv
)) & 0x3;
340 dev_dbg(dev
, "thermal%d %s%s\n",
342 (status
& 0x2) ? "Rising " : "",
343 (status
& 0x1) ? "Falling" : "");
349 static irqreturn_t
rcar_thermal_irq(int irq
, void *data
)
351 struct rcar_thermal_common
*common
= data
;
352 struct rcar_thermal_priv
*priv
;
356 spin_lock_irqsave(&common
->lock
, flags
);
358 mask
= rcar_thermal_common_read(common
, INTMSK
);
359 status
= rcar_thermal_common_read(common
, STR
);
360 rcar_thermal_common_write(common
, STR
, 0x000F0F0F & mask
);
362 spin_unlock_irqrestore(&common
->lock
, flags
);
364 status
= status
& ~mask
;
369 rcar_thermal_for_each_priv(priv
, common
) {
370 if (rcar_thermal_had_changed(priv
, status
)) {
371 rcar_thermal_irq_disable(priv
);
372 schedule_delayed_work(&priv
->work
,
373 msecs_to_jiffies(300));
383 static int rcar_thermal_remove(struct platform_device
*pdev
)
385 struct rcar_thermal_common
*common
= platform_get_drvdata(pdev
);
386 struct device
*dev
= &pdev
->dev
;
387 struct rcar_thermal_priv
*priv
;
389 rcar_thermal_for_each_priv(priv
, common
) {
390 rcar_thermal_irq_disable(priv
);
391 thermal_zone_device_unregister(priv
->zone
);
395 pm_runtime_disable(dev
);
400 static int rcar_thermal_probe(struct platform_device
*pdev
)
402 struct rcar_thermal_common
*common
;
403 struct rcar_thermal_priv
*priv
;
404 struct device
*dev
= &pdev
->dev
;
405 struct resource
*res
, *irq
;
409 int idle
= IDLE_INTERVAL
;
412 common
= devm_kzalloc(dev
, sizeof(*common
), GFP_KERNEL
);
416 platform_set_drvdata(pdev
, common
);
418 INIT_LIST_HEAD(&common
->head
);
419 spin_lock_init(&common
->lock
);
422 pm_runtime_enable(dev
);
423 pm_runtime_get_sync(dev
);
425 irq
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
428 * platform has IRQ support.
429 * Then, driver uses common registers
430 * rcar_has_irq_support() will be enabled
432 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, mres
++);
433 common
->base
= devm_ioremap_resource(dev
, res
);
434 if (IS_ERR(common
->base
))
435 return PTR_ERR(common
->base
);
437 idle
= 0; /* polling delay is not needed */
441 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, mres
++);
445 priv
= devm_kzalloc(dev
, sizeof(*priv
), GFP_KERNEL
);
448 goto error_unregister
;
451 priv
->base
= devm_ioremap_resource(dev
, res
);
452 if (IS_ERR(priv
->base
)) {
453 ret
= PTR_ERR(priv
->base
);
454 goto error_unregister
;
457 priv
->common
= common
;
459 mutex_init(&priv
->lock
);
460 INIT_LIST_HEAD(&priv
->list
);
461 INIT_DELAYED_WORK(&priv
->work
, rcar_thermal_work
);
462 ret
= rcar_thermal_update_temp(priv
);
464 goto error_unregister
;
466 priv
->zone
= thermal_zone_device_register("rcar_thermal",
468 &rcar_thermal_zone_ops
, NULL
, 0,
470 if (IS_ERR(priv
->zone
)) {
471 dev_err(dev
, "can't register thermal zone\n");
472 ret
= PTR_ERR(priv
->zone
);
473 goto error_unregister
;
476 rcar_thermal_irq_enable(priv
);
478 list_move_tail(&priv
->list
, &common
->head
);
480 /* update ENR bits */
481 enr_bits
|= 3 << (i
* 8);
484 /* enable temperature comparation */
486 ret
= devm_request_irq(dev
, irq
->start
, rcar_thermal_irq
, 0,
487 dev_name(dev
), common
);
489 dev_err(dev
, "irq request failed\n ");
490 goto error_unregister
;
493 rcar_thermal_common_write(common
, ENR
, enr_bits
);
496 dev_info(dev
, "%d sensor probed\n", i
);
501 rcar_thermal_remove(pdev
);
506 static struct platform_driver rcar_thermal_driver
= {
508 .name
= "rcar_thermal",
509 .of_match_table
= rcar_thermal_dt_ids
,
511 .probe
= rcar_thermal_probe
,
512 .remove
= rcar_thermal_remove
,
514 module_platform_driver(rcar_thermal_driver
);
516 MODULE_LICENSE("GPL");
517 MODULE_DESCRIPTION("R-Car THS/TSC thermal sensor driver");
518 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");