forked from Minki/linux
3f4a0b917c
Avoid possible PIT livelock issues seen on SMP systems (and reported by Andi), by not allowing it as a clocksource on SMP boxes. However, since the PIT may no longer be present, we have to properly handle the cases where SMP systems have TSC skew and fall back from the TSC. Since the PIT isn't there, it would "fall back" to the TSC again. So this changes the jiffies rating to 1, and the TSC-bad rating value to 0. Thus you will get the following behavior priority on i386 systems: tsc [if present & stable] hpet [if present] cyclone [if present] acpi_pm [if present] pit [if UP] jiffies Rather then the current more complicated: tsc [if present & stable] hpet [if present] cyclone [if present] acpi_pm [if present] pit [if cpus < 4] tsc [if present & unstable] jiffies Signed-off-by: John Stultz <johnstul@us.ibm.com> Cc: Andi Kleen <ak@suse.de> Cc: Ingo Molnar <mingo@elte.hu> Cc: Thomas Gleixner <tglx@linutronix.de> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
119 lines
3.1 KiB
C
119 lines
3.1 KiB
C
/*
|
|
* i8253.c 8253/PIT functions
|
|
*
|
|
*/
|
|
#include <linux/clocksource.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/sysdev.h>
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
|
|
#include <asm/smp.h>
|
|
#include <asm/delay.h>
|
|
#include <asm/i8253.h>
|
|
#include <asm/io.h>
|
|
|
|
#include "io_ports.h"
|
|
|
|
DEFINE_SPINLOCK(i8253_lock);
|
|
EXPORT_SYMBOL(i8253_lock);
|
|
|
|
void setup_pit_timer(void)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&i8253_lock, flags);
|
|
outb_p(0x34,PIT_MODE); /* binary, mode 2, LSB/MSB, ch 0 */
|
|
udelay(10);
|
|
outb_p(LATCH & 0xff , PIT_CH0); /* LSB */
|
|
udelay(10);
|
|
outb(LATCH >> 8 , PIT_CH0); /* MSB */
|
|
spin_unlock_irqrestore(&i8253_lock, flags);
|
|
}
|
|
|
|
/*
|
|
* Since the PIT overflows every tick, its not very useful
|
|
* to just read by itself. So use jiffies to emulate a free
|
|
* running counter:
|
|
*/
|
|
static cycle_t pit_read(void)
|
|
{
|
|
unsigned long flags;
|
|
int count;
|
|
u32 jifs;
|
|
static int old_count;
|
|
static u32 old_jifs;
|
|
|
|
spin_lock_irqsave(&i8253_lock, flags);
|
|
/*
|
|
* Although our caller may have the read side of xtime_lock,
|
|
* this is now a seqlock, and we are cheating in this routine
|
|
* by having side effects on state that we cannot undo if
|
|
* there is a collision on the seqlock and our caller has to
|
|
* retry. (Namely, old_jifs and old_count.) So we must treat
|
|
* jiffies as volatile despite the lock. We read jiffies
|
|
* before latching the timer count to guarantee that although
|
|
* the jiffies value might be older than the count (that is,
|
|
* the counter may underflow between the last point where
|
|
* jiffies was incremented and the point where we latch the
|
|
* count), it cannot be newer.
|
|
*/
|
|
jifs = jiffies;
|
|
outb_p(0x00, PIT_MODE); /* latch the count ASAP */
|
|
count = inb_p(PIT_CH0); /* read the latched count */
|
|
count |= inb_p(PIT_CH0) << 8;
|
|
|
|
/* VIA686a test code... reset the latch if count > max + 1 */
|
|
if (count > LATCH) {
|
|
outb_p(0x34, PIT_MODE);
|
|
outb_p(LATCH & 0xff, PIT_CH0);
|
|
outb(LATCH >> 8, PIT_CH0);
|
|
count = LATCH - 1;
|
|
}
|
|
|
|
/*
|
|
* It's possible for count to appear to go the wrong way for a
|
|
* couple of reasons:
|
|
*
|
|
* 1. The timer counter underflows, but we haven't handled the
|
|
* resulting interrupt and incremented jiffies yet.
|
|
* 2. Hardware problem with the timer, not giving us continuous time,
|
|
* the counter does small "jumps" upwards on some Pentium systems,
|
|
* (see c't 95/10 page 335 for Neptun bug.)
|
|
*
|
|
* Previous attempts to handle these cases intelligently were
|
|
* buggy, so we just do the simple thing now.
|
|
*/
|
|
if (count > old_count && jifs == old_jifs) {
|
|
count = old_count;
|
|
}
|
|
old_count = count;
|
|
old_jifs = jifs;
|
|
|
|
spin_unlock_irqrestore(&i8253_lock, flags);
|
|
|
|
count = (LATCH - 1) - count;
|
|
|
|
return (cycle_t)(jifs * LATCH) + count;
|
|
}
|
|
|
|
static struct clocksource clocksource_pit = {
|
|
.name = "pit",
|
|
.rating = 110,
|
|
.read = pit_read,
|
|
.mask = CLOCKSOURCE_MASK(32),
|
|
.mult = 0,
|
|
.shift = 20,
|
|
};
|
|
|
|
static int __init init_pit_clocksource(void)
|
|
{
|
|
if (num_possible_cpus() > 1) /* PIT does not scale! */
|
|
return 0;
|
|
|
|
clocksource_pit.mult = clocksource_hz2mult(CLOCK_TICK_RATE, 20);
|
|
return clocksource_register(&clocksource_pit);
|
|
}
|
|
module_init(init_pit_clocksource);
|