arch/arm/mach-gemini/time.c

   1 /*
   2  *  Copyright (C) 2001-2006 Storlink, Corp.
   3  *  Copyright (C) 2008-2009 Paulius Zaleckas <paulius.zaleckas@teltonika.lt>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  */
  10 #include <linux/interrupt.h>
  11 #include <linux/irq.h>
  12 #include <linux/io.h>
  13 #include <mach/hardware.h>
  14 #include <mach/global_reg.h>
  15 #include <asm/mach/time.h>
  16 #include <linux/clockchips.h>
  17 #include <linux/clocksource.h>
  18
  19 /*
  20  * Register definitions for the timers
  21  */
  22
  23 #define TIMER1_BASE             GEMINI_TIMER_BASE
  24 #define TIMER2_BASE             (GEMINI_TIMER_BASE + 0x10)
  25 #define TIMER3_BASE             (GEMINI_TIMER_BASE + 0x20)
  26
  27 #define TIMER_COUNT(BASE)       (IO_ADDRESS(BASE) + 0x00)
  28 #define TIMER_LOAD(BASE)        (IO_ADDRESS(BASE) + 0x04)
  29 #define TIMER_MATCH1(BASE)      (IO_ADDRESS(BASE) + 0x08)
  30 #define TIMER_MATCH2(BASE)      (IO_ADDRESS(BASE) + 0x0C)
  31 #define TIMER_CR                (IO_ADDRESS(GEMINI_TIMER_BASE) + 0x30)
  32 #define TIMER_INTR_STATE        (IO_ADDRESS(GEMINI_TIMER_BASE) + 0x34)
  33 #define TIMER_INTR_MASK         (IO_ADDRESS(GEMINI_TIMER_BASE) + 0x38)
  34
  35 #define TIMER_1_CR_ENABLE       (1 << 0)
  36 #define TIMER_1_CR_CLOCK        (1 << 1)
  37 #define TIMER_1_CR_INT          (1 << 2)
  38 #define TIMER_2_CR_ENABLE       (1 << 3)
  39 #define TIMER_2_CR_CLOCK        (1 << 4)
  40 #define TIMER_2_CR_INT          (1 << 5)
  41 #define TIMER_3_CR_ENABLE       (1 << 6)
  42 #define TIMER_3_CR_CLOCK        (1 << 7)
  43 #define TIMER_3_CR_INT          (1 << 8)
  44 #define TIMER_1_CR_UPDOWN       (1 << 9)
  45 #define TIMER_2_CR_UPDOWN       (1 << 10)
  46 #define TIMER_3_CR_UPDOWN       (1 << 11)
  47 #define TIMER_DEFAULT_FLAGS     (TIMER_1_CR_UPDOWN | \
  48                                  TIMER_3_CR_ENABLE | \
  49                                  TIMER_3_CR_UPDOWN)
  50
  51 #define TIMER_1_INT_MATCH1      (1 << 0)
  52 #define TIMER_1_INT_MATCH2      (1 << 1)
  53 #define TIMER_1_INT_OVERFLOW    (1 << 2)
  54 #define TIMER_2_INT_MATCH1      (1 << 3)
  55 #define TIMER_2_INT_MATCH2      (1 << 4)
  56 #define TIMER_2_INT_OVERFLOW    (1 << 5)
  57 #define TIMER_3_INT_MATCH1      (1 << 6)
  58 #define TIMER_3_INT_MATCH2      (1 << 7)
  59 #define TIMER_3_INT_OVERFLOW    (1 << 8)
  60 #define TIMER_INT_ALL_MASK      0x1ff
  61
  62
  63 static unsigned int tick_rate;
  64
  65 static int gemini_timer_set_next_event(unsigned long cycles,
  66                                        struct clock_event_device *evt)
  67 {
  68         u32 cr;
  69
  70         /* Setup the match register */
  71         cr = readl(TIMER_COUNT(TIMER1_BASE));
  72         writel(cr + cycles, TIMER_MATCH1(TIMER1_BASE));
  73         if (readl(TIMER_COUNT(TIMER1_BASE)) - cr > cycles)
  74                 return -ETIME;
  75
  76         return 0;
  77 }
  78
  79 static int gemini_timer_shutdown(struct clock_event_device *evt)
  80 {
  81         u32 cr;
  82
  83         /*
  84          * Disable also for oneshot: the set_next() call will arm the timer
  85          * instead.
  86          */
  87         /* Stop timer and interrupt. */
  88         cr = readl(TIMER_CR);
  89         cr &= ~(TIMER_1_CR_ENABLE | TIMER_1_CR_INT);
  90         writel(cr, TIMER_CR);
  91
  92         /* Setup counter start from 0 */
  93         writel(0, TIMER_COUNT(TIMER1_BASE));
  94         writel(0, TIMER_LOAD(TIMER1_BASE));
  95
  96         /* enable interrupt */
  97         cr = readl(TIMER_INTR_MASK);
  98         cr &= ~(TIMER_1_INT_OVERFLOW | TIMER_1_INT_MATCH2);
  99         cr |= TIMER_1_INT_MATCH1;
 100         writel(cr, TIMER_INTR_MASK);
 101
 102         /* start the timer */
 103         cr = readl(TIMER_CR);
 104         cr |= TIMER_1_CR_ENABLE;
 105         writel(cr, TIMER_CR);
 106
 107         return 0;
 108 }
 109
 110 static int gemini_timer_set_periodic(struct clock_event_device *evt)
 111 {
 112         u32 period = DIV_ROUND_CLOSEST(tick_rate, HZ);
 113         u32 cr;
 114
 115         /* Stop timer and interrupt */
 116         cr = readl(TIMER_CR);
 117         cr &= ~(TIMER_1_CR_ENABLE | TIMER_1_CR_INT);
 118         writel(cr, TIMER_CR);
 119
 120         /* Setup timer to fire at 1/HT intervals. */
 121         cr = 0xffffffff - (period - 1);
 122         writel(cr, TIMER_COUNT(TIMER1_BASE));
 123         writel(cr, TIMER_LOAD(TIMER1_BASE));
 124
 125         /* enable interrupt on overflow */
 126         cr = readl(TIMER_INTR_MASK);
 127         cr &= ~(TIMER_1_INT_MATCH1 | TIMER_1_INT_MATCH2);
 128         cr |= TIMER_1_INT_OVERFLOW;
 129         writel(cr, TIMER_INTR_MASK);
 130
 131         /* Start the timer */
 132         cr = readl(TIMER_CR);
 133         cr |= TIMER_1_CR_ENABLE;
 134         cr |= TIMER_1_CR_INT;
 135         writel(cr, TIMER_CR);
 136
 137         return 0;
 138 }
 139
 140 /* Use TIMER1 as clock event */
 141 static struct clock_event_device gemini_clockevent = {
 142         .name                   = "TIMER1",
 143         /* Reasonably fast and accurate clock event */
 144         .rating                 = 300,
 145         .shift                  = 32,
 146         .features               = CLOCK_EVT_FEAT_PERIODIC |
 147                                   CLOCK_EVT_FEAT_ONESHOT,
 148         .set_next_event         = gemini_timer_set_next_event,
 149         .set_state_shutdown     = gemini_timer_shutdown,
 150         .set_state_periodic     = gemini_timer_set_periodic,
 151         .set_state_oneshot      = gemini_timer_shutdown,
 152         .tick_resume            = gemini_timer_shutdown,
 153 };
 154
 155 /*
 156  * IRQ handler for the timer
 157  */
 158 static irqreturn_t gemini_timer_interrupt(int irq, void *dev_id)
 159 {
 160         struct clock_event_device *evt = &gemini_clockevent;
 161
 162         evt->event_handler(evt);
 163         return IRQ_HANDLED;
 164 }
 165
 166 static struct irqaction gemini_timer_irq = {
 167         .name           = "Gemini Timer Tick",
 168         .flags          = IRQF_TIMER,
 169         .handler        = gemini_timer_interrupt,
 170 };
 171
 172 /*
 173  * Set up timer interrupt, and return the current time in seconds.
 174  */
 175 void __init gemini_timer_init(void)
 176 {
 177         u32 reg_v;
 178
 179         reg_v = readl(IO_ADDRESS(GEMINI_GLOBAL_BASE + GLOBAL_STATUS));
 180         tick_rate = REG_TO_AHB_SPEED(reg_v) * 1000000;
 181
 182         printk(KERN_INFO "Bus: %dMHz", tick_rate / 1000000);
 183
 184         tick_rate /= 6;         /* APB bus run AHB*(1/6) */
 185
 186         switch(reg_v & CPU_AHB_RATIO_MASK) {
 187         case CPU_AHB_1_1:
 188                 printk(KERN_CONT "(1/1)\n");
 189                 break;
 190         case CPU_AHB_3_2:
 191                 printk(KERN_CONT "(3/2)\n");
 192                 break;
 193         case CPU_AHB_24_13:
 194                 printk(KERN_CONT "(24/13)\n");
 195                 break;
 196         case CPU_AHB_2_1:
 197                 printk(KERN_CONT "(2/1)\n");
 198                 break;
 199         }
 200
 201         /*
 202          * Reset the interrupt mask and status
 203          */
 204         writel(TIMER_INT_ALL_MASK, TIMER_INTR_MASK);
 205         writel(0, TIMER_INTR_STATE);
 206         writel(TIMER_DEFAULT_FLAGS, TIMER_CR);
 207
 208         /*
 209          * Setup clockevent timer (interrupt-driven.)
 210          */
 211         writel(0, TIMER_COUNT(TIMER1_BASE));
 212         writel(0, TIMER_LOAD(TIMER1_BASE));
 213         writel(0, TIMER_MATCH1(TIMER1_BASE));
 214         writel(0, TIMER_MATCH2(TIMER1_BASE));
 215         setup_irq(IRQ_TIMER1, &gemini_timer_irq);
 216         gemini_clockevent.cpumask = cpumask_of(0);
 217         clockevents_config_and_register(&gemini_clockevent, tick_rate,
 218                                         1, 0xffffffff);
 219
 220 }