drivers/clocksource/em_sti.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Emma Mobile Timer Support - STI
   4  *
   5  *  Copyright (C) 2012 Magnus Damm
   6  */
   7
   8 #include <linux/init.h>
   9 #include <linux/platform_device.h>
  10 #include <linux/spinlock.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/ioport.h>
  13 #include <linux/io.h>
  14 #include <linux/clk.h>
  15 #include <linux/irq.h>
  16 #include <linux/err.h>
  17 #include <linux/delay.h>
  18 #include <linux/clocksource.h>
  19 #include <linux/clockchips.h>
  20 #include <linux/slab.h>
  21 #include <linux/module.h>
  22
  23 enum { USER_CLOCKSOURCE, USER_CLOCKEVENT, USER_NR };
  24
  25 struct em_sti_priv {
  26         void __iomem *base;
  27         struct clk *clk;
  28         struct platform_device *pdev;
  29         unsigned int active[USER_NR];
  30         unsigned long rate;
  31         raw_spinlock_t lock;
  32         struct clock_event_device ced;
  33         struct clocksource cs;
  34 };
  35
  36 #define STI_CONTROL 0x00
  37 #define STI_COMPA_H 0x10
  38 #define STI_COMPA_L 0x14
  39 #define STI_COMPB_H 0x18
  40 #define STI_COMPB_L 0x1c
  41 #define STI_COUNT_H 0x20
  42 #define STI_COUNT_L 0x24
  43 #define STI_COUNT_RAW_H 0x28
  44 #define STI_COUNT_RAW_L 0x2c
  45 #define STI_SET_H 0x30
  46 #define STI_SET_L 0x34
  47 #define STI_INTSTATUS 0x40
  48 #define STI_INTRAWSTATUS 0x44
  49 #define STI_INTENSET 0x48
  50 #define STI_INTENCLR 0x4c
  51 #define STI_INTFFCLR 0x50
  52
  53 static inline unsigned long em_sti_read(struct em_sti_priv *p, int offs)
  54 {
  55         return ioread32(p->base + offs);
  56 }
  57
  58 static inline void em_sti_write(struct em_sti_priv *p, int offs,
  59                                 unsigned long value)
  60 {
  61         iowrite32(value, p->base + offs);
  62 }
  63
  64 static int em_sti_enable(struct em_sti_priv *p)
  65 {
  66         int ret;
  67
  68         /* enable clock */
  69         ret = clk_enable(p->clk);
  70         if (ret) {
  71                 dev_err(&p->pdev->dev, "cannot enable clock\n");
  72                 return ret;
  73         }
  74
  75         /* reset the counter */
  76         em_sti_write(p, STI_SET_H, 0x40000000);
  77         em_sti_write(p, STI_SET_L, 0x00000000);
  78
  79         /* mask and clear pending interrupts */
  80         em_sti_write(p, STI_INTENCLR, 3);
  81         em_sti_write(p, STI_INTFFCLR, 3);
  82
  83         /* enable updates of counter registers */
  84         em_sti_write(p, STI_CONTROL, 1);
  85
  86         return 0;
  87 }
  88
  89 static void em_sti_disable(struct em_sti_priv *p)
  90 {
  91         /* mask interrupts */
  92         em_sti_write(p, STI_INTENCLR, 3);
  93
  94         /* stop clock */
  95         clk_disable(p->clk);
  96 }
  97
  98 static u64 em_sti_count(struct em_sti_priv *p)
  99 {
 100         u64 ticks;
 101         unsigned long flags;
 102
 103         /* the STI hardware buffers the 48-bit count, but to
 104          * break it out into two 32-bit access the registers
 105          * must be accessed in a certain order.
 106          * Always read STI_COUNT_H before STI_COUNT_L.
 107          */
 108         raw_spin_lock_irqsave(&p->lock, flags);
 109         ticks = (u64)(em_sti_read(p, STI_COUNT_H) & 0xffff) << 32;
 110         ticks |= em_sti_read(p, STI_COUNT_L);
 111         raw_spin_unlock_irqrestore(&p->lock, flags);
 112
 113         return ticks;
 114 }
 115
 116 static u64 em_sti_set_next(struct em_sti_priv *p, u64 next)
 117 {
 118         unsigned long flags;
 119
 120         raw_spin_lock_irqsave(&p->lock, flags);
 121
 122         /* mask compare A interrupt */
 123         em_sti_write(p, STI_INTENCLR, 1);
 124
 125         /* update compare A value */
 126         em_sti_write(p, STI_COMPA_H, next >> 32);
 127         em_sti_write(p, STI_COMPA_L, next & 0xffffffff);
 128
 129         /* clear compare A interrupt source */
 130         em_sti_write(p, STI_INTFFCLR, 1);
 131
 132         /* unmask compare A interrupt */
 133         em_sti_write(p, STI_INTENSET, 1);
 134
 135         raw_spin_unlock_irqrestore(&p->lock, flags);
 136
 137         return next;
 138 }
 139
 140 static irqreturn_t em_sti_interrupt(int irq, void *dev_id)
 141 {
 142         struct em_sti_priv *p = dev_id;
 143
 144         p->ced.event_handler(&p->ced);
 145         return IRQ_HANDLED;
 146 }
 147
 148 static int em_sti_start(struct em_sti_priv *p, unsigned int user)
 149 {
 150         unsigned long flags;
 151         int used_before;
 152         int ret = 0;
 153
 154         raw_spin_lock_irqsave(&p->lock, flags);
 155         used_before = p->active[USER_CLOCKSOURCE] | p->active[USER_CLOCKEVENT];
 156         if (!used_before)
 157                 ret = em_sti_enable(p);
 158
 159         if (!ret)
 160                 p->active[user] = 1;
 161         raw_spin_unlock_irqrestore(&p->lock, flags);
 162
 163         return ret;
 164 }
 165
 166 static void em_sti_stop(struct em_sti_priv *p, unsigned int user)
 167 {
 168         unsigned long flags;
 169         int used_before, used_after;
 170
 171         raw_spin_lock_irqsave(&p->lock, flags);
 172         used_before = p->active[USER_CLOCKSOURCE] | p->active[USER_CLOCKEVENT];
 173         p->active[user] = 0;
 174         used_after = p->active[USER_CLOCKSOURCE] | p->active[USER_CLOCKEVENT];
 175
 176         if (used_before && !used_after)
 177                 em_sti_disable(p);
 178         raw_spin_unlock_irqrestore(&p->lock, flags);
 179 }
 180
 181 static struct em_sti_priv *cs_to_em_sti(struct clocksource *cs)
 182 {
 183         return container_of(cs, struct em_sti_priv, cs);
 184 }
 185
 186 static u64 em_sti_clocksource_read(struct clocksource *cs)
 187 {
 188         return em_sti_count(cs_to_em_sti(cs));
 189 }
 190
 191 static int em_sti_clocksource_enable(struct clocksource *cs)
 192 {
 193         struct em_sti_priv *p = cs_to_em_sti(cs);
 194
 195         return em_sti_start(p, USER_CLOCKSOURCE);
 196 }
 197
 198 static void em_sti_clocksource_disable(struct clocksource *cs)
 199 {
 200         em_sti_stop(cs_to_em_sti(cs), USER_CLOCKSOURCE);
 201 }
 202
 203 static void em_sti_clocksource_resume(struct clocksource *cs)
 204 {
 205         em_sti_clocksource_enable(cs);
 206 }
 207
 208 static int em_sti_register_clocksource(struct em_sti_priv *p)
 209 {
 210         struct clocksource *cs = &p->cs;
 211
 212         cs->name = dev_name(&p->pdev->dev);
 213         cs->rating = 200;
 214         cs->read = em_sti_clocksource_read;
 215         cs->enable = em_sti_clocksource_enable;
 216         cs->disable = em_sti_clocksource_disable;
 217         cs->suspend = em_sti_clocksource_disable;
 218         cs->resume = em_sti_clocksource_resume;
 219         cs->mask = CLOCKSOURCE_MASK(48);
 220         cs->flags = CLOCK_SOURCE_IS_CONTINUOUS;
 221
 222         dev_info(&p->pdev->dev, "used as clock source\n");
 223
 224         clocksource_register_hz(cs, p->rate);
 225         return 0;
 226 }
 227
 228 static struct em_sti_priv *ced_to_em_sti(struct clock_event_device *ced)
 229 {
 230         return container_of(ced, struct em_sti_priv, ced);
 231 }
 232
 233 static int em_sti_clock_event_shutdown(struct clock_event_device *ced)
 234 {
 235         struct em_sti_priv *p = ced_to_em_sti(ced);
 236         em_sti_stop(p, USER_CLOCKEVENT);
 237         return 0;
 238 }
 239
 240 static int em_sti_clock_event_set_oneshot(struct clock_event_device *ced)
 241 {
 242         struct em_sti_priv *p = ced_to_em_sti(ced);
 243
 244         dev_info(&p->pdev->dev, "used for oneshot clock events\n");
 245         em_sti_start(p, USER_CLOCKEVENT);
 246         return 0;
 247 }
 248
 249 static int em_sti_clock_event_next(unsigned long delta,
 250                                    struct clock_event_device *ced)
 251 {
 252         struct em_sti_priv *p = ced_to_em_sti(ced);
 253         u64 next;
 254         int safe;
 255
 256         next = em_sti_set_next(p, em_sti_count(p) + delta);
 257         safe = em_sti_count(p) < (next - 1);
 258
 259         return !safe;
 260 }
 261
 262 static void em_sti_register_clockevent(struct em_sti_priv *p)
 263 {
 264         struct clock_event_device *ced = &p->ced;
 265
 266         ced->name = dev_name(&p->pdev->dev);
 267         ced->features = CLOCK_EVT_FEAT_ONESHOT;
 268         ced->rating = 200;
 269         ced->cpumask = cpu_possible_mask;
 270         ced->set_next_event = em_sti_clock_event_next;
 271         ced->set_state_shutdown = em_sti_clock_event_shutdown;
 272         ced->set_state_oneshot = em_sti_clock_event_set_oneshot;
 273
 274         dev_info(&p->pdev->dev, "used for clock events\n");
 275
 276         clockevents_config_and_register(ced, p->rate, 2, 0xffffffff);
 277 }
 278
 279 static int em_sti_probe(struct platform_device *pdev)
 280 {
 281         struct em_sti_priv *p;
 282         struct resource *res;
 283         int irq;
 284         int ret;
 285
 286         p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
 287         if (p == NULL)
 288                 return -ENOMEM;
 289
 290         p->pdev = pdev;
 291         platform_set_drvdata(pdev, p);
 292
 293         irq = platform_get_irq(pdev, 0);
 294         if (irq < 0) {
 295                 dev_err(&pdev->dev, "failed to get irq\n");
 296                 return irq;
 297         }
 298
 299         /* map memory, let base point to the STI instance */
 300         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 301         p->base = devm_ioremap_resource(&pdev->dev, res);
 302         if (IS_ERR(p->base))
 303                 return PTR_ERR(p->base);
 304
 305         ret = devm_request_irq(&pdev->dev, irq, em_sti_interrupt,
 306                                IRQF_TIMER | IRQF_IRQPOLL | IRQF_NOBALANCING,
 307                                dev_name(&pdev->dev), p);
 308         if (ret) {
 309                 dev_err(&pdev->dev, "failed to request low IRQ\n");
 310                 return ret;
 311         }
 312
 313         /* get hold of clock */
 314         p->clk = devm_clk_get(&pdev->dev, "sclk");
 315         if (IS_ERR(p->clk)) {
 316                 dev_err(&pdev->dev, "cannot get clock\n");
 317                 return PTR_ERR(p->clk);
 318         }
 319
 320         ret = clk_prepare(p->clk);
 321         if (ret < 0) {
 322                 dev_err(&pdev->dev, "cannot prepare clock\n");
 323                 return ret;
 324         }
 325
 326         ret = clk_enable(p->clk);
 327         if (ret < 0) {
 328                 dev_err(&p->pdev->dev, "cannot enable clock\n");
 329                 clk_unprepare(p->clk);
 330                 return ret;
 331         }
 332         p->rate = clk_get_rate(p->clk);
 333         clk_disable(p->clk);
 334
 335         raw_spin_lock_init(&p->lock);
 336         em_sti_register_clockevent(p);
 337         em_sti_register_clocksource(p);
 338         return 0;
 339 }
 340
 341 static int em_sti_remove(struct platform_device *pdev)
 342 {
 343         return -EBUSY; /* cannot unregister clockevent and clocksource */
 344 }
 345
 346 static const struct of_device_id em_sti_dt_ids[] = {
 347         { .compatible = "renesas,em-sti", },
 348         {},
 349 };
 350 MODULE_DEVICE_TABLE(of, em_sti_dt_ids);
 351
 352 static struct platform_driver em_sti_device_driver = {
 353         .probe          = em_sti_probe,
 354         .remove         = em_sti_remove,
 355         .driver         = {
 356                 .name   = "em_sti",
 357                 .of_match_table = em_sti_dt_ids,
 358         }
 359 };
 360
 361 static int __init em_sti_init(void)
 362 {
 363         return platform_driver_register(&em_sti_device_driver);
 364 }
 365
 366 static void __exit em_sti_exit(void)
 367 {
 368         platform_driver_unregister(&em_sti_device_driver);
 369 }
 370
 371 subsys_initcall(em_sti_init);
 372 module_exit(em_sti_exit);
 373
 374 MODULE_AUTHOR("Magnus Damm");
 375 MODULE_DESCRIPTION("Renesas Emma Mobile STI Timer Driver");
 376 MODULE_LICENSE("GPL v2");