arch/x86/lib/delay_32.c

   1 /*
   2  *      Precise Delay Loops for i386
   3  *
   4  *      Copyright (C) 1993 Linus Torvalds
   5  *      Copyright (C) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
   6  *
   7  *      The __delay function must _NOT_ be inlined as its execution time
   8  *      depends wildly on alignment on many x86 processors. The additional
   9  *      jump magic is needed to get the timing stable on all the CPU's
  10  *      we have to worry about.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/sched.h>
  15 #include <linux/timex.h>
  16 #include <linux/preempt.h>
  17 #include <linux/delay.h>
  18 #include <linux/init.h>
  19
  20 #include <asm/processor.h>
  21 #include <asm/delay.h>
  22 #include <asm/timer.h>
  23
  24 #ifdef CONFIG_SMP
  25 # include <asm/smp.h>
  26 #endif
  27
  28 /* simple loop based delay: */
  29 static void delay_loop(unsigned long loops)
  30 {
  31         int d0;
  32
  33         __asm__ __volatile__(
  34                 "\tjmp 1f\n"
  35                 ".align 16\n"
  36                 "1:\tjmp 2f\n"
  37                 ".align 16\n"
  38                 "2:\tdecl %0\n\tjns 2b"
  39                 :"=&a" (d0)
  40                 :"0" (loops));
  41 }
  42
  43 /* TSC based delay: */
  44 static void delay_tsc(unsigned long loops)
  45 {
  46         unsigned long bclock, now;
  47         int cpu;
  48
  49         preempt_disable();
  50         cpu = smp_processor_id();
  51         rdtscl(bclock);
  52         for (;;) {
  53                 rdtscl(now);
  54                 if ((now - bclock) >= loops)
  55                         break;
  56
  57                 /* Allow RT tasks to run */
  58                 preempt_enable();
  59                 rep_nop();
  60                 preempt_disable();
  61
  62                 /*
  63                  * It is possible that we moved to another CPU, and
  64                  * since TSC's are per-cpu we need to calculate
  65                  * that. The delay must guarantee that we wait "at
  66                  * least" the amount of time. Being moved to another
  67                  * CPU could make the wait longer but we just need to
  68                  * make sure we waited long enough. Rebalance the
  69                  * counter for this CPU.
  70                  */
  71                 if (unlikely(cpu != smp_processor_id())) {
  72                         loops -= (now - bclock);
  73                         cpu = smp_processor_id();
  74                         rdtscl(bclock);
  75                 }
  76         }
  77         preempt_enable();
  78 }
  79
  80 /*
  81  * Since we calibrate only once at boot, this
  82  * function should be set once at boot and not changed
  83  */
  84 static void (*delay_fn)(unsigned long) = delay_loop;
  85
  86 void use_tsc_delay(void)
  87 {
  88         delay_fn = delay_tsc;
  89 }
  90
  91 int __devinit read_current_timer(unsigned long *timer_val)
  92 {
  93         if (delay_fn == delay_tsc) {
  94                 rdtscl(*timer_val);
  95                 return 0;
  96         }
  97         return -1;
  98 }
  99
 100 void __delay(unsigned long loops)
 101 {
 102         delay_fn(loops);
 103 }
 104
 105 inline void __const_udelay(unsigned long xloops)
 106 {
 107         int d0;
 108
 109         xloops *= 4;
 110         __asm__("mull %0"
 111                 :"=d" (xloops), "=&a" (d0)
 112                 :"1" (xloops), "0"
 113                 (cpu_data(raw_smp_processor_id()).loops_per_jiffy * (HZ/4)));
 114
 115         __delay(++xloops);
 116 }
 117
 118 void __udelay(unsigned long usecs)
 119 {
 120         __const_udelay(usecs * 0x000010c7); /* 2**32 / 1000000 (rounded up) */
 121 }
 122
 123 void __ndelay(unsigned long nsecs)
 124 {
 125         __const_udelay(nsecs * 0x00005); /* 2**32 / 1000000000 (rounded up) */
 126 }
 127
 128 EXPORT_SYMBOL(__delay);
 129 EXPORT_SYMBOL(__const_udelay);
 130 EXPORT_SYMBOL(__udelay);
 131 EXPORT_SYMBOL(__ndelay);