arch/mips/mips-boards/generic/time.c

   1 /*
   2  * Carsten Langgaard, carstenl@mips.com
   3  * Copyright (C) 1999,2000 MIPS Technologies, Inc.  All rights reserved.
   4  *
   5  *  This program is free software; you can distribute it and/or modify it
   6  *  under the terms of the GNU General Public License (Version 2) as
   7  *  published by the Free Software Foundation.
   8  *
   9  *  This program is distributed in the hope it will be useful, but WITHOUT
  10  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  *  for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License along
  15  *  with this program; if not, write to the Free Software Foundation, Inc.,
  16  *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  17  *
  18  * Setting up the clock on the MIPS boards.
  19  */
  20
  21 #include <linux/types.h>
  22 #include <linux/init.h>
  23 #include <linux/kernel_stat.h>
  24 #include <linux/sched.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/time.h>
  28 #include <linux/timex.h>
  29 #include <linux/mc146818rtc.h>
  30
  31 #include <asm/mipsregs.h>
  32 #include <asm/mipsmtregs.h>
  33 #include <asm/hardirq.h>
  34 #include <asm/irq.h>
  35 #include <asm/div64.h>
  36 #include <asm/cpu.h>
  37 #include <asm/time.h>
  38 #include <asm/mc146818-time.h>
  39 #include <asm/msc01_ic.h>
  40
  41 #include <asm/mips-boards/generic.h>
  42 #include <asm/mips-boards/prom.h>
  43
  44 #ifdef CONFIG_MIPS_ATLAS
  45 #include <asm/mips-boards/atlasint.h>
  46 #endif
  47 #ifdef CONFIG_MIPS_MALTA
  48 #include <asm/mips-boards/maltaint.h>
  49 #endif
  50 #ifdef CONFIG_MIPS_SEAD
  51 #include <asm/mips-boards/seadint.h>
  52 #endif
  53
  54 unsigned long cpu_khz;
  55
  56 #define CPUCTR_IMASKBIT (0x100 << MIPSCPU_INT_CPUCTR)
  57
  58 static int mips_cpu_timer_irq;
  59 extern void smtc_timer_broadcast(int);
  60
  61 static void mips_timer_dispatch(void)
  62 {
  63         do_IRQ(mips_cpu_timer_irq);
  64 }
  65
  66 /*
  67  * Redeclare until I get around mopping the timer code insanity on MIPS.
  68  */
  69 extern int null_perf_irq(void);
  70
  71 extern int (*perf_irq)(void);
  72
  73 irqreturn_t mips_timer_interrupt(int irq, void *dev_id)
  74 {
  75         int cpu = smp_processor_id();
  76
  77 #ifdef CONFIG_MIPS_MT_SMTC
  78         /*
  79          *  In an SMTC system, one Count/Compare set exists per VPE.
  80          *  Which TC within a VPE gets the interrupt is essentially
  81          *  random - we only know that it shouldn't be one with
  82          *  IXMT set. Whichever TC gets the interrupt needs to
  83          *  send special interprocessor interrupts to the other
  84          *  TCs to make sure that they schedule, etc.
  85          *
  86          *  That code is specific to the SMTC kernel, not to
  87          *  the a particular platform, so it's invoked from
  88          *  the general MIPS timer_interrupt routine.
  89          */
  90
  91         /*
  92          * We could be here due to timer interrupt,
  93          * perf counter overflow, or both.
  94          */
  95         if (read_c0_cause() & (1 << 26))
  96                 perf_irq();
  97
  98         if (read_c0_cause() & (1 << 30)) {
  99                 /*
 100                  * There are things we only want to do once per tick
 101                  * in an "MP" system.   One TC of each VPE will take
 102                  * the actual timer interrupt.  The others will get
 103                  * timer broadcast IPIs. We use whoever it is that takes
 104                  * the tick on VPE 0 to run the full timer_interrupt().
 105                  */
 106                 if (cpu_data[cpu].vpe_id == 0) {
 107                         timer_interrupt(irq, NULL);
 108                 } else {
 109                         write_c0_compare(read_c0_count() +
 110                                          (mips_hpt_frequency/HZ));
 111                         local_timer_interrupt(irq, dev_id);
 112                 }
 113                 smtc_timer_broadcast(cpu_data[cpu].vpe_id);
 114         }
 115 #else /* CONFIG_MIPS_MT_SMTC */
 116         int r2 = cpu_has_mips_r2;
 117
 118         if (cpu == 0) {
 119                 /*
 120                  * CPU 0 handles the global timer interrupt job and process
 121                  * accounting resets count/compare registers to trigger next
 122                  * timer int.
 123                  */
 124                 if (!r2 || (read_c0_cause() & (1 << 26)))
 125                         if (perf_irq())
 126                                 goto out;
 127
 128                 /* we keep interrupt disabled all the time */
 129                 if (!r2 || (read_c0_cause() & (1 << 30)))
 130                         timer_interrupt(irq, NULL);
 131         } else {
 132                 /* Everyone else needs to reset the timer int here as
 133                    ll_local_timer_interrupt doesn't */
 134                 /*
 135                  * FIXME: need to cope with counter underflow.
 136                  * More support needs to be added to kernel/time for
 137                  * counter/timer interrupts on multiple CPU's
 138                  */
 139                 write_c0_compare(read_c0_count() + (mips_hpt_frequency/HZ));
 140
 141                 /*
 142                  * Other CPUs should do profiling and process accounting
 143                  */
 144                 local_timer_interrupt(irq, dev_id);
 145         }
 146 out:
 147 #endif /* CONFIG_MIPS_MT_SMTC */
 148         return IRQ_HANDLED;
 149 }
 150
 151 /*
 152  * Estimate CPU frequency.  Sets mips_hpt_frequency as a side-effect
 153  */
 154 static unsigned int __init estimate_cpu_frequency(void)
 155 {
 156         unsigned int prid = read_c0_prid() & 0xffff00;
 157         unsigned int count;
 158
 159 #if defined(CONFIG_MIPS_SEAD) || defined(CONFIG_MIPS_SIM)
 160         /*
 161          * The SEAD board doesn't have a real time clock, so we can't
 162          * really calculate the timer frequency
 163          * For now we hardwire the SEAD board frequency to 12MHz.
 164          */
 165
 166         if ((prid == (PRID_COMP_MIPS | PRID_IMP_20KC)) ||
 167             (prid == (PRID_COMP_MIPS | PRID_IMP_25KF)))
 168                 count = 12000000;
 169         else
 170                 count = 6000000;
 171 #endif
 172 #if defined(CONFIG_MIPS_ATLAS) || defined(CONFIG_MIPS_MALTA)
 173         unsigned long flags;
 174         unsigned int start;
 175
 176         local_irq_save(flags);
 177
 178         /* Start counter exactly on falling edge of update flag */
 179         while (CMOS_READ(RTC_REG_A) & RTC_UIP);
 180         while (!(CMOS_READ(RTC_REG_A) & RTC_UIP));
 181
 182         /* Start r4k counter. */
 183         start = read_c0_count();
 184
 185         /* Read counter exactly on falling edge of update flag */
 186         while (CMOS_READ(RTC_REG_A) & RTC_UIP);
 187         while (!(CMOS_READ(RTC_REG_A) & RTC_UIP));
 188
 189         count = read_c0_count() - start;
 190
 191         /* restore interrupts */
 192         local_irq_restore(flags);
 193 #endif
 194
 195         mips_hpt_frequency = count;
 196         if ((prid != (PRID_COMP_MIPS | PRID_IMP_20KC)) &&
 197             (prid != (PRID_COMP_MIPS | PRID_IMP_25KF)))
 198                 count *= 2;
 199
 200         count += 5000;    /* round */
 201         count -= count%10000;
 202
 203         return count;
 204 }
 205
 206 unsigned long __init mips_rtc_get_time(void)
 207 {
 208         return mc146818_get_cmos_time();
 209 }
 210
 211 void __init mips_time_init(void)
 212 {
 213         unsigned int est_freq;
 214
 215         /* Set Data mode - binary. */
 216         CMOS_WRITE(CMOS_READ(RTC_CONTROL) | RTC_DM_BINARY, RTC_CONTROL);
 217
 218         est_freq = estimate_cpu_frequency ();
 219
 220         printk("CPU frequency %d.%02d MHz\n", est_freq/1000000,
 221                (est_freq%1000000)*100/1000000);
 222
 223         cpu_khz = est_freq / 1000;
 224
 225         mips_scroll_message();
 226 }
 227
 228 void __init plat_timer_setup(struct irqaction *irq)
 229 {
 230 #ifdef MSC01E_INT_BASE
 231         if (cpu_has_veic) {
 232                 set_vi_handler (MSC01E_INT_CPUCTR, mips_timer_dispatch);
 233                 mips_cpu_timer_irq = MSC01E_INT_BASE + MSC01E_INT_CPUCTR;
 234         } else
 235 #endif
 236         {
 237                 if (cpu_has_vint)
 238                         set_vi_handler (MIPSCPU_INT_CPUCTR, mips_timer_dispatch);
 239                 mips_cpu_timer_irq = MIPSCPU_INT_BASE + MIPSCPU_INT_CPUCTR;
 240         }
 241
 242
 243         /* we are using the cpu counter for timer interrupts */
 244         irq->handler = mips_timer_interrupt;    /* we use our own handler */
 245 #ifdef CONFIG_MIPS_MT_SMTC
 246         setup_irq_smtc(mips_cpu_timer_irq, irq, CPUCTR_IMASKBIT);
 247 #else
 248         setup_irq(mips_cpu_timer_irq, irq);
 249 #endif /* CONFIG_MIPS_MT_SMTC */
 250
 251 #ifdef CONFIG_SMP
 252         /* irq_desc(riptor) is a global resource, when the interrupt overlaps
 253            on seperate cpu's the first one tries to handle the second interrupt.
 254            The effect is that the int remains disabled on the second cpu.
 255            Mark the interrupt with IRQ_PER_CPU to avoid any confusion */
 256         irq_desc[mips_cpu_timer_irq].status |= IRQ_PER_CPU;
 257         set_irq_handler(mips_cpu_timer_irq, handle_percpu_irq);
 258 #endif
 259 }