arch/mips/mipssim/sim_time.c

   1 #include <linux/types.h>
   2 #include <linux/init.h>
   3 #include <linux/kernel_stat.h>
   4 #include <linux/sched.h>
   5 #include <linux/spinlock.h>
   6 #include <linux/interrupt.h>
   7 #include <linux/mc146818rtc.h>
   8 #include <linux/smp.h>
   9 #include <linux/timex.h>
  10
  11 #include <asm/hardirq.h>
  12 #include <asm/div64.h>
  13 #include <asm/cpu.h>
  14 #include <asm/time.h>
  15 #include <asm/irq.h>
  16 #include <asm/mc146818-time.h>
  17 #include <asm/msc01_ic.h>
  18
  19 #include <asm/mips-boards/generic.h>
  20 #include <asm/mips-boards/prom.h>
  21 #include <asm/mips-boards/simint.h>
  22
  23
  24 unsigned long cpu_khz;
  25
  26 irqreturn_t sim_timer_interrupt(int irq, void *dev_id)
  27 {
  28 #ifdef CONFIG_SMP
  29         int cpu = smp_processor_id();
  30
  31         /*
  32          * CPU 0 handles the global timer interrupt job
  33          * resets count/compare registers to trigger next timer int.
  34          */
  35 #ifndef CONFIG_MIPS_MT_SMTC
  36         if (cpu == 0) {
  37                 timer_interrupt(irq, dev_id);
  38         } else {
  39                 /* Everyone else needs to reset the timer int here as
  40                    ll_local_timer_interrupt doesn't */
  41                 /*
  42                  * FIXME: need to cope with counter underflow.
  43                  * More support needs to be added to kernel/time for
  44                  * counter/timer interrupts on multiple CPU's
  45                  */
  46                 write_c0_compare (read_c0_count() + ( mips_hpt_frequency/HZ));
  47         }
  48 #else /* SMTC */
  49         /*
  50          *  In SMTC system, one Count/Compare set exists per VPE.
  51          *  Which TC within a VPE gets the interrupt is essentially
  52          *  random - we only know that it shouldn't be one with
  53          *  IXMT set. Whichever TC gets the interrupt needs to
  54          *  send special interprocessor interrupts to the other
  55          *  TCs to make sure that they schedule, etc.
  56          *
  57          *  That code is specific to the SMTC kernel, not to
  58          *  the simulation platform, so it's invoked from
  59          *  the general MIPS timer_interrupt routine.
  60          *
  61          * We have a problem in that the interrupt vector code
  62          * had to turn off the timer IM bit to avoid redundant
  63          * entries, but we may never get to mips_cpu_irq_end
  64          * to turn it back on again if the scheduler gets
  65          * involved.  So we clear the pending timer here,
  66          * and re-enable the mask...
  67          */
  68
  69         int vpflags = dvpe();
  70         write_c0_compare (read_c0_count() - 1);
  71         clear_c0_cause(0x100 << cp0_compare_irq);
  72         set_c0_status(0x100 << cp0_compare_irq);
  73         irq_enable_hazard();
  74         evpe(vpflags);
  75
  76         if (cpu_data[cpu].vpe_id == 0)
  77                 timer_interrupt(irq, dev_id);
  78         else
  79                 write_c0_compare (read_c0_count() + ( mips_hpt_frequency/HZ));
  80         smtc_timer_broadcast(cpu_data[cpu].vpe_id);
  81
  82 #endif /* CONFIG_MIPS_MT_SMTC */
  83
  84         /*
  85          * every CPU should do profiling and process accounting
  86          */
  87         local_timer_interrupt (irq, dev_id);
  88
  89         return IRQ_HANDLED;
  90 #else
  91         return timer_interrupt (irq, dev_id);
  92 #endif
  93 }
  94
  95
  96
  97 /*
  98  * Estimate CPU frequency.  Sets mips_hpt_frequency as a side-effect
  99  */
 100 static unsigned int __init estimate_cpu_frequency(void)
 101 {
 102         unsigned int prid = read_c0_prid() & 0xffff00;
 103         unsigned int count;
 104
 105 #if 1
 106         /*
 107          * hardwire the board frequency to 12MHz.
 108          */
 109
 110         if ((prid == (PRID_COMP_MIPS | PRID_IMP_20KC)) ||
 111             (prid == (PRID_COMP_MIPS | PRID_IMP_25KF)))
 112                 count = 12000000;
 113         else
 114                 count =  6000000;
 115 #else
 116         unsigned int flags;
 117
 118         local_irq_save(flags);
 119
 120         /* Start counter exactly on falling edge of update flag */
 121         while (CMOS_READ(RTC_REG_A) & RTC_UIP);
 122         while (!(CMOS_READ(RTC_REG_A) & RTC_UIP));
 123
 124         /* Start r4k counter. */
 125         write_c0_count(0);
 126
 127         /* Read counter exactly on falling edge of update flag */
 128         while (CMOS_READ(RTC_REG_A) & RTC_UIP);
 129         while (!(CMOS_READ(RTC_REG_A) & RTC_UIP));
 130
 131         count = read_c0_count();
 132
 133         /* restore interrupts */
 134         local_irq_restore(flags);
 135 #endif
 136
 137         mips_hpt_frequency = count;
 138
 139         if ((prid != (PRID_COMP_MIPS | PRID_IMP_20KC)) &&
 140             (prid != (PRID_COMP_MIPS | PRID_IMP_25KF)))
 141                 count *= 2;
 142
 143         count += 5000;    /* round */
 144         count -= count%10000;
 145
 146         return count;
 147 }
 148
 149 void __init sim_time_init(void)
 150 {
 151         unsigned int est_freq, flags;
 152
 153         local_irq_save(flags);
 154
 155         /* Set Data mode - binary. */
 156         CMOS_WRITE(CMOS_READ(RTC_CONTROL) | RTC_DM_BINARY, RTC_CONTROL);
 157
 158         est_freq = estimate_cpu_frequency ();
 159
 160         printk(KERN_INFO "CPU frequency %d.%02d MHz\n", est_freq / 1000000,
 161                (est_freq % 1000000) * 100 / 1000000);
 162
 163         cpu_khz = est_freq / 1000;
 164
 165         local_irq_restore(flags);
 166 }
 167
 168 static int mips_cpu_timer_irq;
 169
 170 static void mips_timer_dispatch(void)
 171 {
 172         do_IRQ(mips_cpu_timer_irq);
 173 }
 174
 175
 176 void __init plat_timer_setup(struct irqaction *irq)
 177 {
 178         if (cpu_has_veic) {
 179                 set_vi_handler(MSC01E_INT_CPUCTR, mips_timer_dispatch);
 180                 mips_cpu_timer_irq = MSC01E_INT_BASE + MSC01E_INT_CPUCTR;
 181         } else {
 182                 if (cpu_has_vint)
 183                         set_vi_handler(cp0_compare_irq, mips_timer_dispatch);
 184                 mips_cpu_timer_irq = MIPS_CPU_IRQ_BASE + cp0_compare_irq;
 185         }
 186
 187         /* we are using the cpu counter for timer interrupts */
 188         irq->handler = sim_timer_interrupt;
 189         setup_irq(mips_cpu_timer_irq, irq);
 190
 191 #ifdef CONFIG_SMP
 192         /* irq_desc(riptor) is a global resource, when the interrupt overlaps
 193            on seperate cpu's the first one tries to handle the second interrupt.
 194            The effect is that the int remains disabled on the second cpu.
 195            Mark the interrupt with IRQ_PER_CPU to avoid any confusion */
 196         irq_desc[mips_cpu_timer_irq].flags |= IRQ_PER_CPU;
 197         set_irq_handler(mips_cpu_timer_irq, handle_percpu_irq);
 198 #endif
 199 }