arch/arm/mach-realview/localtimer.c

   1 /*
   2  *  linux/arch/arm/mach-realview/localtimer.c
   3  *
   4  *  Copyright (C) 2002 ARM Ltd.
   5  *  All Rights Reserved
   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 version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #include <linux/init.h>
  12 #include <linux/kernel.h>
  13 #include <linux/delay.h>
  14 #include <linux/device.h>
  15 #include <linux/smp.h>
  16 #include <linux/jiffies.h>
  17 #include <linux/percpu.h>
  18 #include <linux/clockchips.h>
  19 #include <linux/irq.h>
  20
  21 #include <asm/hardware/arm_twd.h>
  22 #include <asm/hardware/gic.h>
  23 #include <asm/hardware.h>
  24 #include <asm/io.h>
  25 #include <asm/irq.h>
  26
  27 static DEFINE_PER_CPU(struct clock_event_device, local_clockevent);
  28
  29 /*
  30  * Used on SMP for either the local timer or IPI_TIMER
  31  */
  32 void local_timer_interrupt(void)
  33 {
  34         struct clock_event_device *clk = &__get_cpu_var(local_clockevent);
  35
  36         clk->event_handler(clk);
  37 }
  38
  39 #ifdef CONFIG_LOCAL_TIMERS
  40
  41 #define TWD_BASE(cpu)   (twd_base_addr + (cpu) * twd_size)
  42
  43 /* set up by the platform code */
  44 void __iomem *twd_base_addr;
  45 unsigned int twd_size;
  46
  47 static unsigned long mpcore_timer_rate;
  48
  49 static void local_timer_set_mode(enum clock_event_mode mode,
  50                                  struct clock_event_device *clk)
  51 {
  52         void __iomem *base = TWD_BASE(smp_processor_id());
  53         unsigned long ctrl;
  54
  55         switch(mode) {
  56         case CLOCK_EVT_MODE_PERIODIC:
  57                 /* timer load already set up */
  58                 ctrl = TWD_TIMER_CONTROL_ENABLE | TWD_TIMER_CONTROL_IT_ENABLE
  59                         | TWD_TIMER_CONTROL_PERIODIC;
  60                 break;
  61         case CLOCK_EVT_MODE_ONESHOT:
  62                 /* period set, and timer enabled in 'next_event' hook */
  63                 ctrl = TWD_TIMER_CONTROL_IT_ENABLE | TWD_TIMER_CONTROL_ONESHOT;
  64                 break;
  65         case CLOCK_EVT_MODE_UNUSED:
  66         case CLOCK_EVT_MODE_SHUTDOWN:
  67         default:
  68                 ctrl = 0;
  69         }
  70
  71         __raw_writel(ctrl, base + TWD_TIMER_CONTROL);
  72 }
  73
  74 static int local_timer_set_next_event(unsigned long evt,
  75                                       struct clock_event_device *unused)
  76 {
  77         void __iomem *base = TWD_BASE(smp_processor_id());
  78         unsigned long ctrl = __raw_readl(base + TWD_TIMER_CONTROL);
  79
  80         __raw_writel(evt, base + TWD_TIMER_COUNTER);
  81         __raw_writel(ctrl | TWD_TIMER_CONTROL_ENABLE, base + TWD_TIMER_CONTROL);
  82
  83         return 0;
  84 }
  85
  86 /*
  87  * local_timer_ack: checks for a local timer interrupt.
  88  *
  89  * If a local timer interrupt has occurred, acknowledge and return 1.
  90  * Otherwise, return 0.
  91  */
  92 int local_timer_ack(void)
  93 {
  94         void __iomem *base = TWD_BASE(smp_processor_id());
  95
  96         if (__raw_readl(base + TWD_TIMER_INTSTAT)) {
  97                 __raw_writel(1, base + TWD_TIMER_INTSTAT);
  98                 return 1;
  99         }
 100
 101         return 0;
 102 }
 103
 104 static void __cpuinit twd_calibrate_rate(unsigned int cpu)
 105 {
 106         void __iomem *base = TWD_BASE(cpu);
 107         unsigned long load, count;
 108         u64 waitjiffies;
 109
 110         /*
 111          * If this is the first time round, we need to work out how fast
 112          * the timer ticks
 113          */
 114         if (mpcore_timer_rate == 0) {
 115                 printk("Calibrating local timer... ");
 116
 117                 /* Wait for a tick to start */
 118                 waitjiffies = get_jiffies_64() + 1;
 119
 120                 while (get_jiffies_64() < waitjiffies)
 121                         udelay(10);
 122
 123                 /* OK, now the tick has started, let's get the timer going */
 124                 waitjiffies += 5;
 125
 126                                  /* enable, no interrupt or reload */
 127                 __raw_writel(0x1, base + TWD_TIMER_CONTROL);
 128
 129                                  /* maximum value */
 130                 __raw_writel(0xFFFFFFFFU, base + TWD_TIMER_COUNTER);
 131
 132                 while (get_jiffies_64() < waitjiffies)
 133                         udelay(10);
 134
 135                 count = __raw_readl(base + TWD_TIMER_COUNTER);
 136
 137                 mpcore_timer_rate = (0xFFFFFFFFU - count) * (HZ / 5);
 138
 139                 printk("%lu.%02luMHz.\n", mpcore_timer_rate / 1000000,
 140                         (mpcore_timer_rate / 100000) % 100);
 141         }
 142
 143         load = mpcore_timer_rate / HZ;
 144
 145         __raw_writel(load, base + TWD_TIMER_LOAD);
 146 }
 147
 148 /*
 149  * Setup the local clock events for a CPU.
 150  */
 151 void __cpuinit local_timer_setup(unsigned int cpu)
 152 {
 153         struct clock_event_device *clk = &per_cpu(local_clockevent, cpu);
 154         unsigned long flags;
 155
 156         twd_calibrate_rate(cpu);
 157
 158         clk->name               = "local_timer";
 159         clk->features           = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;
 160         clk->rating             = 350;
 161         clk->set_mode           = local_timer_set_mode;
 162         clk->set_next_event     = local_timer_set_next_event;
 163         clk->irq                = IRQ_LOCALTIMER;
 164         clk->cpumask            = cpumask_of_cpu(cpu);
 165         clk->shift              = 20;
 166         clk->mult               = div_sc(mpcore_timer_rate, NSEC_PER_SEC, clk->shift);
 167         clk->max_delta_ns       = clockevent_delta2ns(0xffffffff, clk);
 168         clk->min_delta_ns       = clockevent_delta2ns(0xf, clk);
 169
 170         /* Make sure our local interrupt controller has this enabled */
 171         local_irq_save(flags);
 172         get_irq_chip(IRQ_LOCALTIMER)->unmask(IRQ_LOCALTIMER);
 173         local_irq_restore(flags);
 174
 175         clockevents_register_device(clk);
 176 }
 177
 178 /*
 179  * take a local timer down
 180  */
 181 void __cpuexit local_timer_stop(unsigned int cpu)
 182 {
 183         __raw_writel(0, TWD_BASE(cpu) + TWD_TIMER_CONTROL);
 184 }
 185
 186 #else   /* CONFIG_LOCAL_TIMERS */
 187
 188 static void dummy_timer_set_mode(enum clock_event_mode mode,
 189                                  struct clock_event_device *clk)
 190 {
 191 }
 192
 193 void __cpuinit local_timer_setup(unsigned int cpu)
 194 {
 195         struct clock_event_device *clk = &per_cpu(local_clockevent, cpu);
 196
 197         clk->name               = "dummy_timer";
 198         clk->features           = CLOCK_EVT_FEAT_DUMMY;
 199         clk->rating             = 200;
 200         clk->set_mode           = dummy_timer_set_mode;
 201         clk->broadcast          = smp_timer_broadcast;
 202         clk->cpumask            = cpumask_of_cpu(cpu);
 203
 204         clockevents_register_device(clk);
 205 }
 206
 207 #endif  /* !CONFIG_LOCAL_TIMERS */