arch/tile/kernel/time.c

   1 /*
   2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
   3  *
   4  *   This program is free software; you can redistribute it and/or
   5  *   modify it under the terms of the GNU General Public License
   6  *   as published by the Free Software Foundation, version 2.
   7  *
   8  *   This program is distributed in the hope that it will be useful, but
   9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  *   NON INFRINGEMENT.  See the GNU General Public License for
  12  *   more details.
  13  *
  14  * Support the cycle counter clocksource and tile timer clock event device.
  15  */
  16
  17 #include <linux/time.h>
  18 #include <linux/timex.h>
  19 #include <linux/clocksource.h>
  20 #include <linux/clockchips.h>
  21 #include <linux/hardirq.h>
  22 #include <linux/sched.h>
  23 #include <linux/smp.h>
  24 #include <linux/delay.h>
  25 #include <linux/module.h>
  26 #include <asm/irq_regs.h>
  27 #include <asm/traps.h>
  28 #include <hv/hypervisor.h>
  29 #include <arch/interrupts.h>
  30 #include <arch/spr_def.h>
  31
  32
  33 /*
  34  * Define the cycle counter clock source.
  35  */
  36
  37 /* How many cycles per second we are running at. */
  38 static cycles_t cycles_per_sec __write_once;
  39
  40 cycles_t get_clock_rate(void)
  41 {
  42         return cycles_per_sec;
  43 }
  44
  45 #if CHIP_HAS_SPLIT_CYCLE()
  46 cycles_t get_cycles(void)
  47 {
  48         unsigned int high = __insn_mfspr(SPR_CYCLE_HIGH);
  49         unsigned int low = __insn_mfspr(SPR_CYCLE_LOW);
  50         unsigned int high2 = __insn_mfspr(SPR_CYCLE_HIGH);
  51
  52         while (unlikely(high != high2)) {
  53                 low = __insn_mfspr(SPR_CYCLE_LOW);
  54                 high = high2;
  55                 high2 = __insn_mfspr(SPR_CYCLE_HIGH);
  56         }
  57
  58         return (((cycles_t)high) << 32) | low;
  59 }
  60 EXPORT_SYMBOL(get_cycles);
  61 #endif
  62
  63 /*
  64  * We use a relatively small shift value so that sched_clock()
  65  * won't wrap around very often.
  66  */
  67 #define SCHED_CLOCK_SHIFT 10
  68
  69 static unsigned long sched_clock_mult __write_once;
  70
  71 static cycles_t clocksource_get_cycles(struct clocksource *cs)
  72 {
  73         return get_cycles();
  74 }
  75
  76 static struct clocksource cycle_counter_cs = {
  77         .name = "cycle counter",
  78         .rating = 300,
  79         .read = clocksource_get_cycles,
  80         .mask = CLOCKSOURCE_MASK(64),
  81         .shift = 22,   /* typical value, e.g. x86 tsc uses this */
  82         .flags = CLOCK_SOURCE_IS_CONTINUOUS,
  83 };
  84
  85 /*
  86  * Called very early from setup_arch() to set cycles_per_sec.
  87  * We initialize it early so we can use it to set up loops_per_jiffy.
  88  */
  89 void __init setup_clock(void)
  90 {
  91         cycles_per_sec = hv_sysconf(HV_SYSCONF_CPU_SPEED);
  92         sched_clock_mult =
  93                 clocksource_hz2mult(cycles_per_sec, SCHED_CLOCK_SHIFT);
  94         cycle_counter_cs.mult =
  95                 clocksource_hz2mult(cycles_per_sec, cycle_counter_cs.shift);
  96 }
  97
  98 void __init calibrate_delay(void)
  99 {
 100         loops_per_jiffy = get_clock_rate() / HZ;
 101         pr_info("Clock rate yields %lu.%02lu BogoMIPS (lpj=%lu)\n",
 102                 loops_per_jiffy/(500000/HZ),
 103                 (loops_per_jiffy/(5000/HZ)) % 100, loops_per_jiffy);
 104 }
 105
 106 /* Called fairly late in init/main.c, but before we go smp. */
 107 void __init time_init(void)
 108 {
 109         /* Initialize and register the clock source. */
 110         clocksource_register(&cycle_counter_cs);
 111
 112         /* Start up the tile-timer interrupt source on the boot cpu. */
 113         setup_tile_timer();
 114 }
 115
 116
 117 /*
 118  * Define the tile timer clock event device.  The timer is driven by
 119  * the TILE_TIMER_CONTROL register, which consists of a 31-bit down
 120  * counter, plus bit 31, which signifies that the counter has wrapped
 121  * from zero to (2**31) - 1.  The INT_TILE_TIMER interrupt will be
 122  * raised as long as bit 31 is set.
 123  *
 124  * The TILE_MINSEC value represents the largest range of real-time
 125  * we can possibly cover with the timer, based on MAX_TICK combined
 126  * with the slowest reasonable clock rate we might run at.
 127  */
 128
 129 #define MAX_TICK 0x7fffffff   /* we have 31 bits of countdown timer */
 130 #define TILE_MINSEC 5         /* timer covers no more than 5 seconds */
 131
 132 static int tile_timer_set_next_event(unsigned long ticks,
 133                                      struct clock_event_device *evt)
 134 {
 135         BUG_ON(ticks > MAX_TICK);
 136         __insn_mtspr(SPR_TILE_TIMER_CONTROL, ticks);
 137         arch_local_irq_unmask_now(INT_TILE_TIMER);
 138         return 0;
 139 }
 140
 141 /*
 142  * Whenever anyone tries to change modes, we just mask interrupts
 143  * and wait for the next event to get set.
 144  */
 145 static void tile_timer_set_mode(enum clock_event_mode mode,
 146                                 struct clock_event_device *evt)
 147 {
 148         arch_local_irq_mask_now(INT_TILE_TIMER);
 149 }
 150
 151 /*
 152  * Set min_delta_ns to 1 microsecond, since it takes about
 153  * that long to fire the interrupt.
 154  */
 155 static DEFINE_PER_CPU(struct clock_event_device, tile_timer) = {
 156         .name = "tile timer",
 157         .features = CLOCK_EVT_FEAT_ONESHOT,
 158         .min_delta_ns = 1000,
 159         .rating = 100,
 160         .irq = -1,
 161         .set_next_event = tile_timer_set_next_event,
 162         .set_mode = tile_timer_set_mode,
 163 };
 164
 165 void __cpuinit setup_tile_timer(void)
 166 {
 167         struct clock_event_device *evt = &__get_cpu_var(tile_timer);
 168
 169         /* Fill in fields that are speed-specific. */
 170         clockevents_calc_mult_shift(evt, cycles_per_sec, TILE_MINSEC);
 171         evt->max_delta_ns = clockevent_delta2ns(MAX_TICK, evt);
 172
 173         /* Mark as being for this cpu only. */
 174         evt->cpumask = cpumask_of(smp_processor_id());
 175
 176         /* Start out with timer not firing. */
 177         arch_local_irq_mask_now(INT_TILE_TIMER);
 178
 179         /* Register tile timer. */
 180         clockevents_register_device(evt);
 181 }
 182
 183 /* Called from the interrupt vector. */
 184 void do_timer_interrupt(struct pt_regs *regs, int fault_num)
 185 {
 186         struct pt_regs *old_regs = set_irq_regs(regs);
 187         struct clock_event_device *evt = &__get_cpu_var(tile_timer);
 188
 189         /*
 190          * Mask the timer interrupt here, since we are a oneshot timer
 191          * and there are now by definition no events pending.
 192          */
 193         arch_local_irq_mask(INT_TILE_TIMER);
 194
 195         /* Track time spent here in an interrupt context */
 196         irq_enter();
 197
 198         /* Track interrupt count. */
 199         __get_cpu_var(irq_stat).irq_timer_count++;
 200
 201         /* Call the generic timer handler */
 202         evt->event_handler(evt);
 203
 204         /*
 205          * Track time spent against the current process again and
 206          * process any softirqs if they are waiting.
 207          */
 208         irq_exit();
 209
 210         set_irq_regs(old_regs);
 211 }
 212
 213 /*
 214  * Scheduler clock - returns current time in nanosec units.
 215  * Note that with LOCKDEP, this is called during lockdep_init(), and
 216  * we will claim that sched_clock() is zero for a little while, until
 217  * we run setup_clock(), above.
 218  */
 219 unsigned long long sched_clock(void)
 220 {
 221         return clocksource_cyc2ns(get_cycles(),
 222                                   sched_clock_mult, SCHED_CLOCK_SHIFT);
 223 }
 224
 225 int setup_profiling_timer(unsigned int multiplier)
 226 {
 227         return -EINVAL;
 228 }
 229
 230 /*
 231  * Use the tile timer to convert nsecs to core clock cycles, relying
 232  * on it having the same frequency as SPR_CYCLE.
 233  */
 234 cycles_t ns2cycles(unsigned long nsecs)
 235 {
 236         struct clock_event_device *dev = &__get_cpu_var(tile_timer);
 237         return ((u64)nsecs * dev->mult) >> dev->shift;
 238 }