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>");