arch/x86_64/kernel/pmtimer.c

   1 /* Ported over from i386 by AK, original copyright was:
   2  *
   3  * (C) Dominik Brodowski <linux@brodo.de> 2003
   4  *
   5  * Driver to use the Power Management Timer (PMTMR) available in some
   6  * southbridges as primary timing source for the Linux kernel.
   7  *
   8  * Based on parts of linux/drivers/acpi/hardware/hwtimer.c, timer_pit.c,
   9  * timer_hpet.c, and on Arjan van de Ven's implementation for 2.4.
  10  *
  11  * This file is licensed under the GPL v2.
  12  *
  13  * Dropped all the hardware bug workarounds for now. Hopefully they
  14  * are not needed on 64bit chipsets.
  15  */
  16
  17 #include <linux/jiffies.h>
  18 #include <linux/kernel.h>
  19 #include <linux/time.h>
  20 #include <linux/init.h>
  21 #include <linux/cpumask.h>
  22 #include <asm/io.h>
  23 #include <asm/proto.h>
  24 #include <asm/msr.h>
  25 #include <asm/vsyscall.h>
  26
  27 /* The I/O port the PMTMR resides at.
  28  * The location is detected during setup_arch(),
  29  * in arch/i386/kernel/acpi/boot.c */
  30 u32 pmtmr_ioport;
  31
  32 /* value of the Power timer at last timer interrupt */
  33 static u32 offset_delay;
  34 static u32 last_pmtmr_tick;
  35
  36 #define ACPI_PM_MASK 0xFFFFFF /* limit it to 24 bits */
  37
  38 static inline u32 cyc2us(u32 cycles)
  39 {
  40         /* The Power Management Timer ticks at 3.579545 ticks per microsecond.
  41          * 1 / PM_TIMER_FREQUENCY == 0.27936511 =~ 286/1024 [error: 0.024%]
  42          *
  43          * Even with HZ = 100, delta is at maximum 35796 ticks, so it can
  44          * easily be multiplied with 286 (=0x11E) without having to fear
  45          * u32 overflows.
  46          */
  47         cycles *= 286;
  48         return (cycles >> 10);
  49 }
  50
  51 int pmtimer_mark_offset(void)
  52 {
  53         static int first_run = 1;
  54         unsigned long tsc;
  55         u32 lost;
  56
  57         u32 tick = inl(pmtmr_ioport);
  58         u32 delta;
  59
  60         delta = cyc2us((tick - last_pmtmr_tick) & ACPI_PM_MASK);
  61
  62         last_pmtmr_tick = tick;
  63 #ifndef CONFIG_XEN
  64         monotonic_base += delta * NSEC_PER_USEC;
  65 #endif
  66
  67         delta += offset_delay;
  68
  69         lost = delta / (USEC_PER_SEC / HZ);
  70         offset_delay = delta % (USEC_PER_SEC / HZ);
  71
  72         rdtscll(tsc);
  73         vxtime.last_tsc = tsc - offset_delay * (u64)cpu_khz / 1000;
  74
  75         /* don't calculate delay for first run,
  76            or if we've got less then a tick */
  77         if (first_run || (lost < 1)) {
  78                 first_run = 0;
  79                 offset_delay = 0;
  80         }
  81
  82         return lost - 1;
  83 }
  84
  85 static unsigned pmtimer_wait_tick(void)
  86 {
  87         u32 a, b;
  88         for (a = b = inl(pmtmr_ioport) & ACPI_PM_MASK;
  89              a == b;
  90              b = inl(pmtmr_ioport) & ACPI_PM_MASK)
  91                 cpu_relax();
  92         return b;
  93 }
  94
  95 /* note: wait time is rounded up to one tick */
  96 void pmtimer_wait(unsigned us)
  97 {
  98         u32 a, b;
  99         a = pmtimer_wait_tick();
 100         do {
 101                 b = inl(pmtmr_ioport);
 102                 cpu_relax();
 103         } while (cyc2us(b - a) < us);
 104 }
 105
 106 void pmtimer_resume(void)
 107 {
 108         last_pmtmr_tick = inl(pmtmr_ioport);
 109 }
 110
 111 unsigned int do_gettimeoffset_pm(void)
 112 {
 113         u32 now, offset, delta = 0;
 114
 115         offset = last_pmtmr_tick;
 116         now = inl(pmtmr_ioport);
 117         delta = (now - offset) & ACPI_PM_MASK;
 118
 119         return offset_delay + cyc2us(delta);
 120 }
 121
 122
 123 static int __init nopmtimer_setup(char *s)
 124 {
 125         pmtmr_ioport = 0;
 126         return 1;
 127 }
 128
 129 __setup("nopmtimer", nopmtimer_setup);