time.c

Go to the documentation of this file.

/*
 * Copyright 2010 Tilera Corporation. All Rights Reserved.
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation, version 2.
 *
 *   This program is distributed in the hope that it will be useful, but
 *   WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 *   NON INFRINGEMENT.  See the GNU General Public License for
 *   more details.
 *
 * Support the cycle counter clocksource and tile timer clock event device.
 */

#include <linux/time.h>
#include <linux/timex.h>
#include <linux/clocksource.h>
#include <linux/clockchips.h>
#include <linux/hardirq.h>
#include <linux/sched.h>
#include <linux/smp.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <asm/irq_regs.h>
#include <asm/traps.h>
#include <hv/hypervisor.h>
#include <arch/interrupts.h>
#include <arch/spr_def.h>


/*
 * Define the cycle counter clock source.
 */

/* How many cycles per second we are running at. */
static cycles_t cycles_per_sec __write_once;

cycles_t get_clock_rate(void)
{
    return cycles_per_sec;
}

#if CHIP_HAS_SPLIT_CYCLE()
cycles_t get_cycles(void)
{
    unsigned int high = __insn_mfspr(SPR_CYCLE_HIGH);
    unsigned int low = __insn_mfspr(SPR_CYCLE_LOW);
    unsigned int high2 = __insn_mfspr(SPR_CYCLE_HIGH);

    while (unlikely(high != high2)) {
        low = __insn_mfspr(SPR_CYCLE_LOW);
        high = high2;
        high2 = __insn_mfspr(SPR_CYCLE_HIGH);
    }

    return (((cycles_t)high) << 32) | low;
}
EXPORT_SYMBOL(get_cycles);
#endif

/*
 * We use a relatively small shift value so that sched_clock()
 * won't wrap around very often.
 */
#define SCHED_CLOCK_SHIFT 10

static unsigned long sched_clock_mult __write_once;

static cycles_t clocksource_get_cycles(struct clocksource *cs)
{
    return get_cycles();
}

static struct clocksource cycle_counter_cs = {
    .name = "cycle counter",
    .rating = 300,
    .read = clocksource_get_cycles,
    .mask = CLOCKSOURCE_MASK(64),
    .flags = CLOCK_SOURCE_IS_CONTINUOUS,
};

/*
 * Called very early from setup_arch() to set cycles_per_sec.
 * We initialize it early so we can use it to set up loops_per_jiffy.
 */
void __init setup_clock(void)
{
    cycles_per_sec = hv_sysconf(HV_SYSCONF_CPU_SPEED);
    sched_clock_mult =
        clocksource_hz2mult(cycles_per_sec, SCHED_CLOCK_SHIFT);
}

void __init calibrate_delay(void)
{
    loops_per_jiffy = get_clock_rate() / HZ;
    pr_info("Clock rate yields %lu.%02lu BogoMIPS (lpj=%lu)\n",
        loops_per_jiffy/(500000/HZ),
        (loops_per_jiffy/(5000/HZ)) % 100, loops_per_jiffy);
}

/* Called fairly late in init/main.c, but before we go smp. */
void __init time_init(void)
{
    /* Initialize and register the clock source. */
    clocksource_register_hz(&cycle_counter_cs, cycles_per_sec);

    /* Start up the tile-timer interrupt source on the boot cpu. */
    setup_tile_timer();
}


/*
 * Define the tile timer clock event device.  The timer is driven by
 * the TILE_TIMER_CONTROL register, which consists of a 31-bit down
 * counter, plus bit 31, which signifies that the counter has wrapped
 * from zero to (2**31) - 1.  The INT_TILE_TIMER interrupt will be
 * raised as long as bit 31 is set.
 *
 * The TILE_MINSEC value represents the largest range of real-time
 * we can possibly cover with the timer, based on MAX_TICK combined
 * with the slowest reasonable clock rate we might run at.
 */

#define MAX_TICK 0x7fffffff   /* we have 31 bits of countdown timer */
#define TILE_MINSEC 5         /* timer covers no more than 5 seconds */

static int tile_timer_set_next_event(unsigned long ticks,
                     struct clock_event_device *evt)
{
    BUG_ON(ticks > MAX_TICK);
    __insn_mtspr(SPR_TILE_TIMER_CONTROL, ticks);
    arch_local_irq_unmask_now(INT_TILE_TIMER);
    return 0;
}

/*
 * Whenever anyone tries to change modes, we just mask interrupts
 * and wait for the next event to get set.
 */
static void tile_timer_set_mode(enum clock_event_mode mode,
                struct clock_event_device *evt)
{
    arch_local_irq_mask_now(INT_TILE_TIMER);
}

/*
 * Set min_delta_ns to 1 microsecond, since it takes about
 * that long to fire the interrupt.
 */
static DEFINE_PER_CPU(struct clock_event_device, tile_timer) = {
    .name = "tile timer",
    .features = CLOCK_EVT_FEAT_ONESHOT,
    .min_delta_ns = 1000,
    .rating = 100,
    .irq = -1,
    .set_next_event = tile_timer_set_next_event,
    .set_mode = tile_timer_set_mode,
};

void __cpuinit setup_tile_timer(void)
{
    struct clock_event_device *evt = &__get_cpu_var(tile_timer);

    /* Fill in fields that are speed-specific. */
    clockevents_calc_mult_shift(evt, cycles_per_sec, TILE_MINSEC);
    evt->max_delta_ns = clockevent_delta2ns(MAX_TICK, evt);

    /* Mark as being for this cpu only. */
    evt->cpumask = cpumask_of(smp_processor_id());

    /* Start out with timer not firing. */
    arch_local_irq_mask_now(INT_TILE_TIMER);

    /* Register tile timer. */
    clockevents_register_device(evt);
}

/* Called from the interrupt vector. */
void do_timer_interrupt(struct pt_regs *regs, int fault_num)
{
    struct pt_regs *old_regs = set_irq_regs(regs);
    struct clock_event_device *evt = &__get_cpu_var(tile_timer);

    /*
     * Mask the timer interrupt here, since we are a oneshot timer
     * and there are now by definition no events pending.
     */
    arch_local_irq_mask(INT_TILE_TIMER);

    /* Track time spent here in an interrupt context */
    irq_enter();

    /* Track interrupt count. */
    __get_cpu_var(irq_stat).irq_timer_count++;

    /* Call the generic timer handler */
    evt->event_handler(evt);

    /*
     * Track time spent against the current process again and
     * process any softirqs if they are waiting.
     */
    irq_exit();

    set_irq_regs(old_regs);
}

/*
 * Scheduler clock - returns current time in nanosec units.
 * Note that with LOCKDEP, this is called during lockdep_init(), and
 * we will claim that sched_clock() is zero for a little while, until
 * we run setup_clock(), above.
 */
unsigned long long sched_clock(void)
{
    return clocksource_cyc2ns(get_cycles(),
                  sched_clock_mult, SCHED_CLOCK_SHIFT);
}

int setup_profiling_timer(unsigned int multiplier)
{
    return -EINVAL;
}

/*
 * Use the tile timer to convert nsecs to core clock cycles, relying
 * on it having the same frequency as SPR_CYCLE.
 */
cycles_t ns2cycles(unsigned long nsecs)
{
    struct clock_event_device *dev = &__get_cpu_var(tile_timer);
    return ((u64)nsecs * dev->mult) >> dev->shift;
}