drivers/clocksource/metag_generic.c

   1 /*
   2  * Copyright (C) 2005-2013 Imagination Technologies Ltd.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  *
  17  * Support for Meta per-thread timers.
  18  *
  19  * Meta hardware threads have 2 timers. The background timer (TXTIMER) is used
  20  * as a free-running time base (hz clocksource), and the interrupt timer
  21  * (TXTIMERI) is used for the timer interrupt (clock event). Both counters
  22  * traditionally count at approximately 1MHz.
  23  */
  24
  25 #include <clocksource/metag_generic.h>
  26 #include <linux/cpu.h>
  27 #include <linux/errno.h>
  28 #include <linux/sched.h>
  29 #include <linux/kernel.h>
  30 #include <linux/param.h>
  31 #include <linux/time.h>
  32 #include <linux/init.h>
  33 #include <linux/proc_fs.h>
  34 #include <linux/clocksource.h>
  35 #include <linux/clockchips.h>
  36 #include <linux/interrupt.h>
  37
  38 #include <asm/clock.h>
  39 #include <asm/hwthread.h>
  40 #include <asm/core_reg.h>
  41 #include <asm/metag_mem.h>
  42 #include <asm/tbx.h>
  43
  44 #define HARDWARE_FREQ           1000000 /* 1MHz */
  45 #define HARDWARE_DIV            1       /* divide by 1 = 1MHz clock */
  46 #define HARDWARE_TO_NS_SHIFT    10      /* convert ticks to ns */
  47
  48 static unsigned int hwtimer_freq = HARDWARE_FREQ;
  49 static DEFINE_PER_CPU(struct clock_event_device, local_clockevent);
  50 static DEFINE_PER_CPU(char [11], local_clockevent_name);
  51
  52 static int metag_timer_set_next_event(unsigned long delta,
  53                                       struct clock_event_device *dev)
  54 {
  55         __core_reg_set(TXTIMERI, -delta);
  56         return 0;
  57 }
  58
  59 static u64 metag_clocksource_read(struct clocksource *cs)
  60 {
  61         return __core_reg_get(TXTIMER);
  62 }
  63
  64 static struct clocksource clocksource_metag = {
  65         .name = "META",
  66         .rating = 200,
  67         .mask = CLOCKSOURCE_MASK(32),
  68         .read = metag_clocksource_read,
  69         .flags = CLOCK_SOURCE_IS_CONTINUOUS,
  70 };
  71
  72 static irqreturn_t metag_timer_interrupt(int irq, void *dummy)
  73 {
  74         struct clock_event_device *evt = this_cpu_ptr(&local_clockevent);
  75
  76         evt->event_handler(evt);
  77
  78         return IRQ_HANDLED;
  79 }
  80
  81 static struct irqaction metag_timer_irq = {
  82         .name = "META core timer",
  83         .handler = metag_timer_interrupt,
  84         .flags = IRQF_TIMER | IRQF_IRQPOLL | IRQF_PERCPU,
  85 };
  86
  87 unsigned long long sched_clock(void)
  88 {
  89         unsigned long long ticks = __core_reg_get(TXTIMER);
  90         return ticks << HARDWARE_TO_NS_SHIFT;
  91 }
  92
  93 static int arch_timer_starting_cpu(unsigned int cpu)
  94 {
  95         unsigned int txdivtime;
  96         struct clock_event_device *clk = &per_cpu(local_clockevent, cpu);
  97         char *name = per_cpu(local_clockevent_name, cpu);
  98
  99         txdivtime = __core_reg_get(TXDIVTIME);
 100
 101         txdivtime &= ~TXDIVTIME_DIV_BITS;
 102         txdivtime |= (HARDWARE_DIV & TXDIVTIME_DIV_BITS);
 103
 104         __core_reg_set(TXDIVTIME, txdivtime);
 105
 106         sprintf(name, "META %d", cpu);
 107         clk->name = name;
 108         clk->features = CLOCK_EVT_FEAT_ONESHOT,
 109
 110         clk->rating = 200,
 111         clk->shift = 12,
 112         clk->irq = tbisig_map(TBID_SIGNUM_TRT),
 113         clk->set_next_event = metag_timer_set_next_event,
 114
 115         clk->mult = div_sc(hwtimer_freq, NSEC_PER_SEC, clk->shift);
 116         clk->max_delta_ns = clockevent_delta2ns(0x7fffffff, clk);
 117         clk->max_delta_ticks = 0x7fffffff;
 118         clk->min_delta_ns = clockevent_delta2ns(0xf, clk);
 119         clk->min_delta_ticks = 0xf;
 120         clk->cpumask = cpumask_of(cpu);
 121
 122         clockevents_register_device(clk);
 123
 124         /*
 125          * For all non-boot CPUs we need to synchronize our free
 126          * running clock (TXTIMER) with the boot CPU's clock.
 127          *
 128          * While this won't be accurate, it should be close enough.
 129          */
 130         if (cpu) {
 131                 unsigned int thread0 = cpu_2_hwthread_id[0];
 132                 unsigned long val;
 133
 134                 val = core_reg_read(TXUCT_ID, TXTIMER_REGNUM, thread0);
 135                 __core_reg_set(TXTIMER, val);
 136         }
 137         return 0;
 138 }
 139
 140 int __init metag_generic_timer_init(void)
 141 {
 142         /*
 143          * On Meta 2 SoCs, the actual frequency of the timer is based on the
 144          * Meta core clock speed divided by an integer, so it is only
 145          * approximately 1MHz. Calculating the real frequency here drastically
 146          * reduces clock skew on these SoCs.
 147          */
 148 #ifdef CONFIG_METAG_META21
 149         hwtimer_freq = get_coreclock() / (metag_in32(EXPAND_TIMER_DIV) + 1);
 150 #endif
 151         pr_info("Timer frequency: %u Hz\n", hwtimer_freq);
 152
 153         clocksource_register_hz(&clocksource_metag, hwtimer_freq);
 154
 155         setup_irq(tbisig_map(TBID_SIGNUM_TRT), &metag_timer_irq);
 156
 157         /* Hook cpu boot to configure the CPU's timers */
 158         return cpuhp_setup_state(CPUHP_AP_METAG_TIMER_STARTING,
 159                                  "clockevents/metag:starting",
 160                                  arch_timer_starting_cpu, NULL);
 161 }