Root/drivers/thermal/rcar_thermal.c

1/*
2 * R-Car THS/TSC thermal sensor driver
3 *
4 * Copyright (C) 2012 Renesas Solutions Corp.
5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
6 *
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.
10 *
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.
15 *
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.
19 */
20#include <linux/delay.h>
21#include <linux/err.h>
22#include <linux/irq.h>
23#include <linux/interrupt.h>
24#include <linux/io.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>
31
32#define IDLE_INTERVAL 5000
33
34#define COMMON_STR 0x00
35#define COMMON_ENR 0x04
36#define COMMON_INTMSK 0x0c
37
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
43
44/* THSCR */
45#define CPCTL (1 << 12)
46
47/* THSSR */
48#define CTEMP 0x3f
49
50struct rcar_thermal_common {
51    void __iomem *base;
52    struct device *dev;
53    struct list_head head;
54    spinlock_t lock;
55};
56
57struct rcar_thermal_priv {
58    void __iomem *base;
59    struct rcar_thermal_common *common;
60    struct thermal_zone_device *zone;
61    struct delayed_work work;
62    struct mutex lock;
63    struct list_head list;
64    int id;
65    int ctemp;
66};
67
68#define rcar_thermal_for_each_priv(pos, common) \
69    list_for_each_entry(pos, &common->head, list)
70
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)
76
77#ifdef DEBUG
78# define rcar_force_update_temp(priv) 1
79#else
80# define rcar_force_update_temp(priv) 0
81#endif
82
83/*
84 * basic functions
85 */
86#define rcar_thermal_common_read(c, r) \
87    _rcar_thermal_common_read(c, COMMON_ ##r)
88static u32 _rcar_thermal_common_read(struct rcar_thermal_common *common,
89                     u32 reg)
90{
91    return ioread32(common->base + reg);
92}
93
94#define rcar_thermal_common_write(c, r, d) \
95    _rcar_thermal_common_write(c, COMMON_ ##r, d)
96static void _rcar_thermal_common_write(struct rcar_thermal_common *common,
97                       u32 reg, u32 data)
98{
99    iowrite32(data, common->base + reg);
100}
101
102#define rcar_thermal_common_bset(c, r, m, d) \
103    _rcar_thermal_common_bset(c, COMMON_ ##r, m, d)
104static void _rcar_thermal_common_bset(struct rcar_thermal_common *common,
105                      u32 reg, u32 mask, u32 data)
106{
107    u32 val;
108
109    val = ioread32(common->base + reg);
110    val &= ~mask;
111    val |= (data & mask);
112    iowrite32(val, common->base + reg);
113}
114
115#define rcar_thermal_read(p, r) _rcar_thermal_read(p, REG_ ##r)
116static u32 _rcar_thermal_read(struct rcar_thermal_priv *priv, u32 reg)
117{
118    return ioread32(priv->base + reg);
119}
120
121#define rcar_thermal_write(p, r, d) _rcar_thermal_write(p, REG_ ##r, d)
122static void _rcar_thermal_write(struct rcar_thermal_priv *priv,
123                u32 reg, u32 data)
124{
125    iowrite32(data, priv->base + reg);
126}
127
128#define rcar_thermal_bset(p, r, m, d) _rcar_thermal_bset(p, REG_ ##r, m, d)
129static void _rcar_thermal_bset(struct rcar_thermal_priv *priv, u32 reg,
130                   u32 mask, u32 data)
131{
132    u32 val;
133
134    val = ioread32(priv->base + reg);
135    val &= ~mask;
136    val |= (data & mask);
137    iowrite32(val, priv->base + reg);
138}
139
140/*
141 * zone device functions
142 */
143static int rcar_thermal_update_temp(struct rcar_thermal_priv *priv)
144{
145    struct device *dev = rcar_priv_to_dev(priv);
146    int i;
147    int ctemp, old, new;
148    int ret = -EINVAL;
149
150    mutex_lock(&priv->lock);
151
152    /*
153     * TSC decides a value of CPTAP automatically,
154     * and this is the conditions which validate interrupt.
155     */
156    rcar_thermal_bset(priv, THSCR, CPCTL, CPCTL);
157
158    ctemp = 0;
159    old = ~0;
160    for (i = 0; i < 128; i++) {
161        /*
162         * we need to wait 300us after changing comparator offset
163         * to get stable temperature.
164         * see "Usage Notes" on datasheet
165         */
166        udelay(300);
167
168        new = rcar_thermal_read(priv, THSSR) & CTEMP;
169        if (new == old) {
170            ctemp = new;
171            break;
172        }
173        old = new;
174    }
175
176    if (!ctemp) {
177        dev_err(dev, "thermal sensor was broken\n");
178        goto err_out_unlock;
179    }
180
181    /*
182     * enable IRQ
183     */
184    if (rcar_has_irq_support(priv)) {
185        rcar_thermal_write(priv, FILONOFF, 0);
186
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)));
191    }
192
193    dev_dbg(dev, "thermal%d %d -> %d\n", priv->id, priv->ctemp, ctemp);
194
195    priv->ctemp = ctemp;
196    ret = 0;
197err_out_unlock:
198    mutex_unlock(&priv->lock);
199    return ret;
200}
201
202static int rcar_thermal_get_temp(struct thermal_zone_device *zone,
203                 unsigned long *temp)
204{
205    struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone);
206
207    if (!rcar_has_irq_support(priv) || rcar_force_update_temp(priv))
208        rcar_thermal_update_temp(priv);
209
210    mutex_lock(&priv->lock);
211    *temp = MCELSIUS((priv->ctemp * 5) - 65);
212    mutex_unlock(&priv->lock);
213
214    return 0;
215}
216
217static int rcar_thermal_get_trip_type(struct thermal_zone_device *zone,
218                      int trip, enum thermal_trip_type *type)
219{
220    struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone);
221    struct device *dev = rcar_priv_to_dev(priv);
222
223    /* see rcar_thermal_get_temp() */
224    switch (trip) {
225    case 0: /* +90 <= temp */
226        *type = THERMAL_TRIP_CRITICAL;
227        break;
228    default:
229        dev_err(dev, "rcar driver trip error\n");
230        return -EINVAL;
231    }
232
233    return 0;
234}
235
236static int rcar_thermal_get_trip_temp(struct thermal_zone_device *zone,
237                      int trip, unsigned long *temp)
238{
239    struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone);
240    struct device *dev = rcar_priv_to_dev(priv);
241
242    /* see rcar_thermal_get_temp() */
243    switch (trip) {
244    case 0: /* +90 <= temp */
245        *temp = MCELSIUS(90);
246        break;
247    default:
248        dev_err(dev, "rcar driver trip error\n");
249        return -EINVAL;
250    }
251
252    return 0;
253}
254
255static int rcar_thermal_notify(struct thermal_zone_device *zone,
256                   int trip, enum thermal_trip_type type)
257{
258    struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone);
259    struct device *dev = rcar_priv_to_dev(priv);
260
261    switch (type) {
262    case THERMAL_TRIP_CRITICAL:
263        /* FIXME */
264        dev_warn(dev, "Thermal reached to critical temperature\n");
265        break;
266    default:
267        break;
268    }
269
270    return 0;
271}
272
273static 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,
278};
279
280/*
281 * interrupt
282 */
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)
285static void _rcar_thermal_irq_ctrl(struct rcar_thermal_priv *priv, int enable)
286{
287    struct rcar_thermal_common *common = priv->common;
288    unsigned long flags;
289    u32 mask = 0x3 << rcar_id_to_shift(priv); /* enable Rising/Falling */
290
291    spin_lock_irqsave(&common->lock, flags);
292
293    rcar_thermal_common_bset(common, INTMSK, mask, enable ? 0 : mask);
294
295    spin_unlock_irqrestore(&common->lock, flags);
296}
297
298static void rcar_thermal_work(struct work_struct *work)
299{
300    struct rcar_thermal_priv *priv;
301
302    priv = container_of(work, struct rcar_thermal_priv, work.work);
303
304    rcar_thermal_update_temp(priv);
305    rcar_thermal_irq_enable(priv);
306    thermal_zone_device_update(priv->zone);
307}
308
309static u32 rcar_thermal_had_changed(struct rcar_thermal_priv *priv, u32 status)
310{
311    struct device *dev = rcar_priv_to_dev(priv);
312
313    status = (status >> rcar_id_to_shift(priv)) & 0x3;
314
315    if (status & 0x3) {
316        dev_dbg(dev, "thermal%d %s%s\n",
317            priv->id,
318            (status & 0x2) ? "Rising " : "",
319            (status & 0x1) ? "Falling" : "");
320    }
321
322    return status;
323}
324
325static irqreturn_t rcar_thermal_irq(int irq, void *data)
326{
327    struct rcar_thermal_common *common = data;
328    struct rcar_thermal_priv *priv;
329    unsigned long flags;
330    u32 status, mask;
331
332    spin_lock_irqsave(&common->lock, flags);
333
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);
337
338    spin_unlock_irqrestore(&common->lock, flags);
339
340    status = status & ~mask;
341
342    /*
343     * check the status
344     */
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));
350        }
351    }
352
353    return IRQ_HANDLED;
354}
355
356/*
357 * platform functions
358 */
359static int rcar_thermal_probe(struct platform_device *pdev)
360{
361    struct rcar_thermal_common *common;
362    struct rcar_thermal_priv *priv;
363    struct device *dev = &pdev->dev;
364    struct resource *res, *irq;
365    int mres = 0;
366    int i;
367    int ret = -ENODEV;
368    int idle = IDLE_INTERVAL;
369
370    common = devm_kzalloc(dev, sizeof(*common), GFP_KERNEL);
371    if (!common) {
372        dev_err(dev, "Could not allocate common\n");
373        return -ENOMEM;
374    }
375
376    INIT_LIST_HEAD(&common->head);
377    spin_lock_init(&common->lock);
378    common->dev = dev;
379
380    irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
381    if (irq) {
382        int ret;
383
384        /*
385         * platform has IRQ support.
386         * Then, drier use common register
387         */
388        res = platform_get_resource(pdev, IORESOURCE_MEM, mres++);
389        if (!res) {
390            dev_err(dev, "Could not get platform resource\n");
391            return -ENODEV;
392        }
393
394        ret = devm_request_irq(dev, irq->start, rcar_thermal_irq, 0,
395                       dev_name(dev), common);
396        if (ret) {
397            dev_err(dev, "irq request failed\n ");
398            return ret;
399        }
400
401        /*
402         * rcar_has_irq_support() will be enabled
403         */
404        common->base = devm_ioremap_resource(dev, res);
405        if (IS_ERR(common->base))
406            return PTR_ERR(common->base);
407
408        /* enable temperature comparation */
409        rcar_thermal_common_write(common, ENR, 0x00030303);
410
411        idle = 0; /* polling delaye is not needed */
412    }
413
414    for (i = 0;; i++) {
415        res = platform_get_resource(pdev, IORESOURCE_MEM, mres++);
416        if (!res)
417            break;
418
419        priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
420        if (!priv) {
421            dev_err(dev, "Could not allocate priv\n");
422            return -ENOMEM;
423        }
424
425        priv->base = devm_ioremap_resource(dev, res);
426        if (IS_ERR(priv->base))
427            return PTR_ERR(priv->base);
428
429        priv->common = common;
430        priv->id = i;
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);
435
436        priv->zone = thermal_zone_device_register("rcar_thermal",
437                        1, 0, priv,
438                        &rcar_thermal_zone_ops, NULL, 0,
439                        idle);
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;
444        }
445
446        list_move_tail(&priv->list, &common->head);
447
448        if (rcar_has_irq_support(priv))
449            rcar_thermal_irq_enable(priv);
450    }
451
452    platform_set_drvdata(pdev, common);
453
454    dev_info(dev, "%d sensor proved\n", i);
455
456    return 0;
457
458error_unregister:
459    rcar_thermal_for_each_priv(priv, common)
460        thermal_zone_device_unregister(priv->zone);
461
462    return ret;
463}
464
465static int rcar_thermal_remove(struct platform_device *pdev)
466{
467    struct rcar_thermal_common *common = platform_get_drvdata(pdev);
468    struct rcar_thermal_priv *priv;
469
470    rcar_thermal_for_each_priv(priv, common)
471        thermal_zone_device_unregister(priv->zone);
472
473    platform_set_drvdata(pdev, NULL);
474
475    return 0;
476}
477
478static const struct of_device_id rcar_thermal_dt_ids[] = {
479    { .compatible = "renesas,rcar-thermal", },
480    {},
481};
482MODULE_DEVICE_TABLE(of, rcar_thermal_dt_ids);
483
484static struct platform_driver rcar_thermal_driver = {
485    .driver = {
486        .name = "rcar_thermal",
487        .of_match_table = rcar_thermal_dt_ids,
488    },
489    .probe = rcar_thermal_probe,
490    .remove = rcar_thermal_remove,
491};
492module_platform_driver(rcar_thermal_driver);
493
494MODULE_LICENSE("GPL");
495MODULE_DESCRIPTION("R-Car THS/TSC thermal sensor driver");
496MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
497

Archive Download this file



interactive