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
);
150 mutex_lock(&priv
->lock
);
153 * TSC decides a value of CPTAP automatically,
154 * and this is the conditions which validate interrupt.
156 rcar_thermal_bset(priv
, THSCR
, CPCTL
, CPCTL
);
160 for (i
= 0; i
< 128; i
++) {
162 * we need to wait 300us after changing comparator offset
163 * to get stable temperature.
164 * see "Usage Notes" on datasheet
168 new = rcar_thermal_read(priv
, THSSR
) & CTEMP
;
177 dev_err(dev
, "thermal sensor was broken\n");
184 if (rcar_has_irq_support(priv
)) {
185 rcar_thermal_write(priv
, FILONOFF
, 0);
187 /* enable Rising/Falling edge interrupt */
188 rcar_thermal_write(priv
, POSNEG
, 0x1);
189 rcar_thermal_write(priv
, INTCTRL
, (((ctemp
- 0) << 8) |
190 ((ctemp
- 1) << 0)));
193 dev_dbg(dev
, "thermal%d %d -> %d\n", priv
->id
, priv
->ctemp
, ctemp
);
198 mutex_unlock(&priv
->lock
);
202 static int rcar_thermal_get_temp(struct thermal_zone_device
*zone
,
205 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
207 if (!rcar_has_irq_support(priv
) || rcar_force_update_temp(priv
))
208 rcar_thermal_update_temp(priv
);
210 mutex_lock(&priv
->lock
);
211 *temp
= MCELSIUS((priv
->ctemp
* 5) - 65);
212 mutex_unlock(&priv
->lock
);
217 static int rcar_thermal_get_trip_type(struct thermal_zone_device
*zone
,
218 int trip
, enum thermal_trip_type
*type
)
220 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
221 struct device
*dev
= rcar_priv_to_dev(priv
);
223 /* see rcar_thermal_get_temp() */
225 case 0: /* +90 <= temp */
226 *type
= THERMAL_TRIP_CRITICAL
;
229 dev_err(dev
, "rcar driver trip error\n");
236 static int rcar_thermal_get_trip_temp(struct thermal_zone_device
*zone
,
237 int trip
, unsigned long *temp
)
239 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
240 struct device
*dev
= rcar_priv_to_dev(priv
);
242 /* see rcar_thermal_get_temp() */
244 case 0: /* +90 <= temp */
245 *temp
= MCELSIUS(90);
248 dev_err(dev
, "rcar driver trip error\n");
255 static int rcar_thermal_notify(struct thermal_zone_device
*zone
,
256 int trip
, enum thermal_trip_type type
)
258 struct rcar_thermal_priv
*priv
= rcar_zone_to_priv(zone
);
259 struct device
*dev
= rcar_priv_to_dev(priv
);
262 case THERMAL_TRIP_CRITICAL
:
264 dev_warn(dev
, "Thermal reached to critical temperature\n");
273 static struct thermal_zone_device_ops rcar_thermal_zone_ops
= {
274 .get_temp
= rcar_thermal_get_temp
,
275 .get_trip_type
= rcar_thermal_get_trip_type
,
276 .get_trip_temp
= rcar_thermal_get_trip_temp
,
277 .notify
= rcar_thermal_notify
,
283 #define rcar_thermal_irq_enable(p) _rcar_thermal_irq_ctrl(p, 1)
284 #define rcar_thermal_irq_disable(p) _rcar_thermal_irq_ctrl(p, 0)
285 static void _rcar_thermal_irq_ctrl(struct rcar_thermal_priv
*priv
, int enable
)
287 struct rcar_thermal_common
*common
= priv
->common
;
289 u32 mask
= 0x3 << rcar_id_to_shift(priv
); /* enable Rising/Falling */
291 spin_lock_irqsave(&common
->lock
, flags
);
293 rcar_thermal_common_bset(common
, INTMSK
, mask
, enable
? 0 : mask
);
295 spin_unlock_irqrestore(&common
->lock
, flags
);
298 static void rcar_thermal_work(struct work_struct
*work
)
300 struct rcar_thermal_priv
*priv
;
302 priv
= container_of(work
, struct rcar_thermal_priv
, work
.work
);
304 rcar_thermal_update_temp(priv
);
305 rcar_thermal_irq_enable(priv
);
306 thermal_zone_device_update(priv
->zone
);
309 static u32
rcar_thermal_had_changed(struct rcar_thermal_priv
*priv
, u32 status
)
311 struct device
*dev
= rcar_priv_to_dev(priv
);
313 status
= (status
>> rcar_id_to_shift(priv
)) & 0x3;
316 dev_dbg(dev
, "thermal%d %s%s\n",
318 (status
& 0x2) ? "Rising " : "",
319 (status
& 0x1) ? "Falling" : "");
325 static irqreturn_t
rcar_thermal_irq(int irq
, void *data
)
327 struct rcar_thermal_common
*common
= data
;
328 struct rcar_thermal_priv
*priv
;
332 spin_lock_irqsave(&common
->lock
, flags
);
334 mask
= rcar_thermal_common_read(common
, INTMSK
);
335 status
= rcar_thermal_common_read(common
, STR
);
336 rcar_thermal_common_write(common
, STR
, 0x000F0F0F & mask
);
338 spin_unlock_irqrestore(&common
->lock
, flags
);
340 status
= status
& ~mask
;
345 rcar_thermal_for_each_priv(priv
, common
) {
346 if (rcar_thermal_had_changed(priv
, status
)) {
347 rcar_thermal_irq_disable(priv
);
348 schedule_delayed_work(&priv
->work
,
349 msecs_to_jiffies(300));
359 static int rcar_thermal_probe(struct platform_device
*pdev
)
361 struct rcar_thermal_common
*common
;
362 struct rcar_thermal_priv
*priv
;
363 struct device
*dev
= &pdev
->dev
;
364 struct resource
*res
, *irq
;
368 int idle
= IDLE_INTERVAL
;
370 common
= devm_kzalloc(dev
, sizeof(*common
), GFP_KERNEL
);
372 dev_err(dev
, "Could not allocate common\n");
376 INIT_LIST_HEAD(&common
->head
);
377 spin_lock_init(&common
->lock
);
380 irq
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
385 * platform has IRQ support.
386 * Then, drier use common register
388 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, mres
++);
390 dev_err(dev
, "Could not get platform resource\n");
394 ret
= devm_request_irq(dev
, irq
->start
, rcar_thermal_irq
, 0,
395 dev_name(dev
), common
);
397 dev_err(dev
, "irq request failed\n ");
402 * rcar_has_irq_support() will be enabled
404 common
->base
= devm_ioremap_resource(dev
, res
);
405 if (IS_ERR(common
->base
))
406 return PTR_ERR(common
->base
);
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_ioremap_resource(dev
, res
);
426 if (IS_ERR(priv
->base
))
427 return PTR_ERR(priv
->base
);
429 priv
->common
= common
;
431 mutex_init(&priv
->lock
);
432 INIT_LIST_HEAD(&priv
->list
);
433 INIT_DELAYED_WORK(&priv
->work
, rcar_thermal_work
);
434 rcar_thermal_update_temp(priv
);
436 priv
->zone
= thermal_zone_device_register("rcar_thermal",
438 &rcar_thermal_zone_ops
, NULL
, 0,
440 if (IS_ERR(priv
->zone
)) {
441 dev_err(dev
, "can't register thermal zone\n");
442 ret
= PTR_ERR(priv
->zone
);
443 goto error_unregister
;
446 list_move_tail(&priv
->list
, &common
->head
);
448 if (rcar_has_irq_support(priv
))
449 rcar_thermal_irq_enable(priv
);
452 platform_set_drvdata(pdev
, common
);
454 dev_info(dev
, "%d sensor proved\n", i
);
459 rcar_thermal_for_each_priv(priv
, common
)
460 thermal_zone_device_unregister(priv
->zone
);
465 static int rcar_thermal_remove(struct platform_device
*pdev
)
467 struct rcar_thermal_common
*common
= platform_get_drvdata(pdev
);
468 struct rcar_thermal_priv
*priv
;
470 rcar_thermal_for_each_priv(priv
, common
)
471 thermal_zone_device_unregister(priv
->zone
);
473 platform_set_drvdata(pdev
, NULL
);
478 static const struct of_device_id rcar_thermal_dt_ids
[] = {
479 { .compatible
= "renesas,rcar-thermal", },
482 MODULE_DEVICE_TABLE(of
, rcar_thermal_dt_ids
);
484 static struct platform_driver rcar_thermal_driver
= {
486 .name
= "rcar_thermal",
487 .of_match_table
= rcar_thermal_dt_ids
,
489 .probe
= rcar_thermal_probe
,
490 .remove
= rcar_thermal_remove
,
492 module_platform_driver(rcar_thermal_driver
);
494 MODULE_LICENSE("GPL");
495 MODULE_DESCRIPTION("R-Car THS/TSC thermal sensor driver");
496 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");