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/reboot.h>
28 #include <linux/slab.h>
29 #include <linux/spinlock.h>
30 #include <linux/thermal.h>
32 #define IDLE_INTERVAL 5000
34 #define COMMON_STR 0x00
35 #define COMMON_ENR 0x04
36 #define COMMON_INTMSK 0x0c
38 #define REG_POSNEG 0x20
39 #define REG_FILONOFF 0x28
40 #define REG_THSCR 0x2c
41 #define REG_THSSR 0x30
42 #define REG_INTCTRL 0x34
45 #define CPCTL (1 << 12)
50 struct rcar_thermal_common
{
53 struct list_head head
;
57 struct rcar_thermal_priv
{
59 struct rcar_thermal_common
*common
;
60 struct thermal_zone_device
*zone
;
61 struct delayed_work work
;
63 struct list_head list
;
68 #define rcar_thermal_for_each_priv(pos, common) \
69 list_for_each_entry(pos, &common->head, list)
71 #define MCELSIUS(temp) ((temp) * 1000)
72 #define rcar_zone_to_priv(zone) ((zone)->devdata)
73 #define rcar_priv_to_dev(priv) ((priv)->common->dev)
74 #define rcar_has_irq_support(priv) ((priv)->common->base)
75 #define rcar_id_to_shift(priv) ((priv)->id * 8)
78 # define rcar_force_update_temp(priv) 1
80 # define rcar_force_update_temp(priv) 0
86 #define rcar_thermal_common_read(c, r) \
87 _rcar_thermal_common_read(c, COMMON_ ##r)
88 static u32
_rcar_thermal_common_read(struct rcar_thermal_common
*common
,
91 return ioread32(common
->base
+ reg
);
94 #define rcar_thermal_common_write(c, r, d) \
95 _rcar_thermal_common_write(c, COMMON_ ##r, d)
96 static void _rcar_thermal_common_write(struct rcar_thermal_common
*common
,
99 iowrite32(data
, common
->base
+ reg
);
102 #define rcar_thermal_common_bset(c, r, m, d) \
103 _rcar_thermal_common_bset(c, COMMON_ ##r, m, d)
104 static void _rcar_thermal_common_bset(struct rcar_thermal_common
*common
,
105 u32 reg
, u32 mask
, u32 data
)
109 val
= ioread32(common
->base
+ reg
);
111 val
|= (data
& mask
);
112 iowrite32(val
, common
->base
+ reg
);
115 #define rcar_thermal_read(p, r) _rcar_thermal_read(p, REG_ ##r)
116 static u32
_rcar_thermal_read(struct rcar_thermal_priv
*priv
, u32 reg
)
118 return ioread32(priv
->base
+ reg
);
121 #define rcar_thermal_write(p, r, d) _rcar_thermal_write(p, REG_ ##r, d)
122 static void _rcar_thermal_write(struct rcar_thermal_priv
*priv
,
125 iowrite32(data
, priv
->base
+ reg
);
128 #define rcar_thermal_bset(p, r, m, d) _rcar_thermal_bset(p, REG_ ##r, m, d)
129 static void _rcar_thermal_bset(struct rcar_thermal_priv
*priv
, u32 reg
,
134 val
= ioread32(priv
->base
+ reg
);
136 val
|= (data
& mask
);
137 iowrite32(val
, priv
->base
+ reg
);
141 * zone device functions
143 static int rcar_thermal_update_temp(struct rcar_thermal_priv
*priv
)
145 struct device
*dev
= rcar_priv_to_dev(priv
);
149 mutex_lock(&priv
->lock
);
152 * TSC decides a value of CPTAP automatically,
153 * and this is the conditions which validate interrupt.
155 rcar_thermal_bset(priv
, THSCR
, CPCTL
, CPCTL
);
159 for (i
= 0; i
< 128; i
++) {
161 * we need to wait 300us after changing comparator offset
162 * to get stable temperature.
163 * see "Usage Notes" on datasheet
167 new = rcar_thermal_read(priv
, THSSR
) & CTEMP
;
176 dev_err(dev
, "thermal sensor was broken\n");
183 if (rcar_has_irq_support(priv
)) {
184 rcar_thermal_write(priv
, FILONOFF
, 0);
186 /* enable Rising/Falling edge interrupt */
187 rcar_thermal_write(priv
, POSNEG
, 0x1);
188 rcar_thermal_write(priv
, INTCTRL
, (((ctemp
- 0) << 8) |
189 ((ctemp
- 1) << 0)));
192 dev_dbg(dev
, "thermal%d %d -> %d\n", priv
->id
, priv
->ctemp
, ctemp
);
196 mutex_unlock(&priv
->lock
);
201 static int rcar_thermal_get_temp(struct thermal_zone_device
*zone
,
204 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
206 if (!rcar_has_irq_support(priv
) || rcar_force_update_temp(priv
))
207 rcar_thermal_update_temp(priv
);
209 mutex_lock(&priv
->lock
);
210 *temp
= MCELSIUS((priv
->ctemp
* 5) - 65);
211 mutex_unlock(&priv
->lock
);
216 static int rcar_thermal_get_trip_type(struct thermal_zone_device
*zone
,
217 int trip
, enum thermal_trip_type
*type
)
219 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
220 struct device
*dev
= rcar_priv_to_dev(priv
);
222 /* see rcar_thermal_get_temp() */
224 case 0: /* +90 <= temp */
225 *type
= THERMAL_TRIP_CRITICAL
;
228 dev_err(dev
, "rcar driver trip error\n");
235 static int rcar_thermal_get_trip_temp(struct thermal_zone_device
*zone
,
236 int trip
, unsigned long *temp
)
238 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
239 struct device
*dev
= rcar_priv_to_dev(priv
);
241 /* see rcar_thermal_get_temp() */
243 case 0: /* +90 <= temp */
244 *temp
= MCELSIUS(90);
247 dev_err(dev
, "rcar driver trip error\n");
254 static int rcar_thermal_notify(struct thermal_zone_device
*zone
,
255 int trip
, enum thermal_trip_type type
)
257 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
258 struct device
*dev
= rcar_priv_to_dev(priv
);
261 case THERMAL_TRIP_CRITICAL
:
263 dev_warn(dev
, "Thermal reached to critical temperature\n");
272 static struct thermal_zone_device_ops rcar_thermal_zone_ops
= {
273 .get_temp
= rcar_thermal_get_temp
,
274 .get_trip_type
= rcar_thermal_get_trip_type
,
275 .get_trip_temp
= rcar_thermal_get_trip_temp
,
276 .notify
= rcar_thermal_notify
,
282 #define rcar_thermal_irq_enable(p) _rcar_thermal_irq_ctrl(p, 1)
283 #define rcar_thermal_irq_disable(p) _rcar_thermal_irq_ctrl(p, 0)
284 static void _rcar_thermal_irq_ctrl(struct rcar_thermal_priv
*priv
, int enable
)
286 struct rcar_thermal_common
*common
= priv
->common
;
288 u32 mask
= 0x3 << rcar_id_to_shift(priv
); /* enable Rising/Falling */
290 spin_lock_irqsave(&common
->lock
, flags
);
292 rcar_thermal_common_bset(common
, INTMSK
, mask
, enable
? 0 : mask
);
294 spin_unlock_irqrestore(&common
->lock
, flags
);
297 static void rcar_thermal_work(struct work_struct
*work
)
299 struct rcar_thermal_priv
*priv
;
301 priv
= container_of(work
, struct rcar_thermal_priv
, work
.work
);
303 rcar_thermal_update_temp(priv
);
304 rcar_thermal_irq_enable(priv
);
305 thermal_zone_device_update(priv
->zone
);
308 static u32
rcar_thermal_had_changed(struct rcar_thermal_priv
*priv
, u32 status
)
310 struct device
*dev
= rcar_priv_to_dev(priv
);
312 status
= (status
>> rcar_id_to_shift(priv
)) & 0x3;
315 dev_dbg(dev
, "thermal%d %s%s\n",
317 (status
& 0x2) ? "Rising " : "",
318 (status
& 0x1) ? "Falling" : "");
324 static irqreturn_t
rcar_thermal_irq(int irq
, void *data
)
326 struct rcar_thermal_common
*common
= data
;
327 struct rcar_thermal_priv
*priv
;
331 spin_lock_irqsave(&common
->lock
, flags
);
333 mask
= rcar_thermal_common_read(common
, INTMSK
);
334 status
= rcar_thermal_common_read(common
, STR
);
335 rcar_thermal_common_write(common
, STR
, 0x000F0F0F & mask
);
337 spin_unlock_irqrestore(&common
->lock
, flags
);
339 status
= status
& ~mask
;
344 rcar_thermal_for_each_priv(priv
, common
) {
345 if (rcar_thermal_had_changed(priv
, status
)) {
346 rcar_thermal_irq_disable(priv
);
347 schedule_delayed_work(&priv
->work
,
348 msecs_to_jiffies(300));
358 static int rcar_thermal_probe(struct platform_device
*pdev
)
360 struct rcar_thermal_common
*common
;
361 struct rcar_thermal_priv
*priv
;
362 struct device
*dev
= &pdev
->dev
;
363 struct resource
*res
, *irq
;
366 int idle
= IDLE_INTERVAL
;
368 common
= devm_kzalloc(dev
, sizeof(*common
), GFP_KERNEL
);
370 dev_err(dev
, "Could not allocate common\n");
374 INIT_LIST_HEAD(&common
->head
);
375 spin_lock_init(&common
->lock
);
378 irq
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
383 * platform has IRQ support.
384 * Then, drier use common register
386 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, mres
++);
388 dev_err(dev
, "Could not get platform resource\n");
392 ret
= devm_request_irq(dev
, irq
->start
, rcar_thermal_irq
, 0,
393 dev_name(dev
), common
);
395 dev_err(dev
, "irq request failed\n ");
400 * rcar_has_irq_support() will be enabled
402 common
->base
= devm_request_and_ioremap(dev
, res
);
404 dev_err(dev
, "Unable to ioremap thermal register\n");
408 /* enable temperature comparation */
409 rcar_thermal_common_write(common
, ENR
, 0x00030303);
411 idle
= 0; /* polling delaye is not needed */
415 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, mres
++);
419 priv
= devm_kzalloc(dev
, sizeof(*priv
), GFP_KERNEL
);
421 dev_err(dev
, "Could not allocate priv\n");
425 priv
->base
= devm_request_and_ioremap(dev
, res
);
427 dev_err(dev
, "Unable to ioremap priv register\n");
431 priv
->common
= common
;
433 mutex_init(&priv
->lock
);
434 INIT_LIST_HEAD(&priv
->list
);
435 INIT_DELAYED_WORK(&priv
->work
, rcar_thermal_work
);
436 rcar_thermal_update_temp(priv
);
438 priv
->zone
= thermal_zone_device_register("rcar_thermal",
440 &rcar_thermal_zone_ops
, NULL
, 0,
442 if (IS_ERR(priv
->zone
)) {
443 dev_err(dev
, "can't register thermal zone\n");
444 goto error_unregister
;
447 list_move_tail(&priv
->list
, &common
->head
);
449 if (rcar_has_irq_support(priv
))
450 rcar_thermal_irq_enable(priv
);
453 platform_set_drvdata(pdev
, common
);
455 dev_info(dev
, "%d sensor proved\n", i
);
460 rcar_thermal_for_each_priv(priv
, common
)
461 thermal_zone_device_unregister(priv
->zone
);
466 static int rcar_thermal_remove(struct platform_device
*pdev
)
468 struct rcar_thermal_common
*common
= platform_get_drvdata(pdev
);
469 struct rcar_thermal_priv
*priv
;
471 rcar_thermal_for_each_priv(priv
, common
)
472 thermal_zone_device_unregister(priv
->zone
);
474 platform_set_drvdata(pdev
, NULL
);
479 static const struct of_device_id rcar_thermal_dt_ids
[] = {
480 { .compatible
= "renesas,rcar-thermal", },
483 MODULE_DEVICE_TABLE(of
, rcar_thermal_dt_ids
);
485 static struct platform_driver rcar_thermal_driver
= {
487 .name
= "rcar_thermal",
488 .of_match_table
= rcar_thermal_dt_ids
,
490 .probe
= rcar_thermal_probe
,
491 .remove
= rcar_thermal_remove
,
493 module_platform_driver(rcar_thermal_driver
);
495 MODULE_LICENSE("GPL");
496 MODULE_DESCRIPTION("R-Car THS/TSC thermal sensor driver");
497 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");