arch/arm/mach-mx3/time.c

   1 /*
   2  * System Timer Interrupt reconfigured to run in free-run mode.
   3  * Author: Vitaly Wool
   4  * Copyright 2004 MontaVista Software Inc.
   5  * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
   6  */
   7
   8 /*
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 /*!
  15  * @file time.c
  16  * @brief This file contains OS tick and wdog timer implementations.
  17  *
  18  * This file contains OS tick and wdog timer implementations.
  19  *
  20  * @ingroup Timers
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/irq.h>
  27 #include <asm/hardware.h>
  28 #include <asm/mach/time.h>
  29 #include <asm/io.h>
  30 #include <asm/arch/common.h>
  31
  32 /*!
  33  * This is the timer interrupt service routine to do required tasks.
  34  * It also services the WDOG timer at the frequency of twice per WDOG
  35  * timeout value. For example, if the WDOG's timeout value is 4 (2
  36  * seconds since the WDOG runs at 0.5Hz), it will be serviced once
  37  * every 2/2=1 second.
  38  *
  39  * @param  irq          GPT interrupt source number (not used)
  40  * @param  dev_id       this parameter is not used
  41  * @return always returns \b IRQ_HANDLED as defined in
  42  *         include/linux/interrupt.h.
  43  */
  44 static irqreturn_t mxc_timer_interrupt(int irq, void *dev_id)
  45 {
  46         unsigned int next_match;
  47
  48         if (__raw_readl(MXC_GPT_GPTSR) & GPTSR_OF1) {
  49                 do {
  50                         timer_tick();
  51                         next_match = __raw_readl(MXC_GPT_GPTOCR1) + LATCH;
  52                         __raw_writel(GPTSR_OF1, MXC_GPT_GPTSR);
  53                         __raw_writel(next_match, MXC_GPT_GPTOCR1);
  54                 } while ((signed long)(next_match -
  55                                        __raw_readl(MXC_GPT_GPTCNT)) <= 0);
  56         }
  57
  58         return IRQ_HANDLED;
  59 }
  60
  61 /*!
  62  * This function is used to obtain the number of microseconds since the last
  63  * timer interrupt. Note that interrupts is disabled by do_gettimeofday().
  64  *
  65  * @return the number of microseconds since the last timer interrupt.
  66  */
  67 static unsigned long mxc_gettimeoffset(void)
  68 {
  69         unsigned long ticks_to_match, elapsed, usec, tick_usec, i;
  70
  71         /* Get ticks before next timer match */
  72         ticks_to_match =
  73             __raw_readl(MXC_GPT_GPTOCR1) - __raw_readl(MXC_GPT_GPTCNT);
  74
  75         /* We need elapsed ticks since last match */
  76         elapsed = LATCH - ticks_to_match;
  77
  78         /* Now convert them to usec */
  79         /* Insure no overflow when calculating the usec below */
  80         for (i = 1, tick_usec = tick_nsec / 1000;; i *= 2) {
  81                 tick_usec /= i;
  82                 if ((0xFFFFFFFF / tick_usec) > elapsed)
  83                         break;
  84         }
  85         usec = (unsigned long)(elapsed * tick_usec) / (LATCH / i);
  86
  87         return usec;
  88 }
  89
  90 /*!
  91  * The OS tick timer interrupt structure.
  92  */
  93 static struct irqaction timer_irq = {
  94         .name = "MXC Timer Tick",
  95         .flags = IRQF_DISABLED | IRQF_TIMER,
  96         .handler = mxc_timer_interrupt
  97 };
  98
  99 /*!
 100  * This function is used to initialize the GPT to produce an interrupt
 101  * based on HZ.  It is called by start_kernel() during system startup.
 102  */
 103 void __init mxc_init_time(void)
 104 {
 105         u32 reg, v;
 106         reg = __raw_readl(MXC_GPT_GPTCR);
 107         reg &= ~GPTCR_ENABLE;
 108         __raw_writel(reg, MXC_GPT_GPTCR);
 109         reg |= GPTCR_SWR;
 110         __raw_writel(reg, MXC_GPT_GPTCR);
 111
 112         while ((__raw_readl(MXC_GPT_GPTCR) & GPTCR_SWR) != 0)
 113                 cpu_relax();
 114
 115         reg = GPTCR_FRR | GPTCR_CLKSRC_HIGHFREQ;
 116         __raw_writel(reg, MXC_GPT_GPTCR);
 117
 118         /* TODO: get timer rate from clk driver */
 119         v = 66500000;
 120
 121         __raw_writel((v / CLOCK_TICK_RATE) - 1, MXC_GPT_GPTPR);
 122
 123         if ((v % CLOCK_TICK_RATE) != 0) {
 124                 pr_info("\nWARNING: Can't generate CLOCK_TICK_RATE at %d Hz\n",
 125                         CLOCK_TICK_RATE);
 126         }
 127         pr_info("Actual CLOCK_TICK_RATE is %d Hz\n",
 128                 v / ((__raw_readl(MXC_GPT_GPTPR) & 0xFFF) + 1));
 129
 130         reg = __raw_readl(MXC_GPT_GPTCNT);
 131         reg += LATCH;
 132         __raw_writel(reg, MXC_GPT_GPTOCR1);
 133
 134         setup_irq(MXC_INT_GPT, &timer_irq);
 135
 136         reg = __raw_readl(MXC_GPT_GPTCR);
 137         reg =
 138             GPTCR_FRR | GPTCR_CLKSRC_HIGHFREQ | GPTCR_STOPEN | GPTCR_DOZEN |
 139             GPTCR_WAITEN | GPTCR_ENMOD | GPTCR_ENABLE;
 140         __raw_writel(reg, MXC_GPT_GPTCR);
 141
 142         __raw_writel(GPTIR_OF1IE, MXC_GPT_GPTIR);
 143 }
 144
 145 struct sys_timer mxc_timer = {
 146         .init = mxc_init_time,
 147         .offset = mxc_gettimeoffset,
 148 };