[time] Allow timer to be selected at runtime

Allow the active timer (providing udelay() and currticks()) to be
selected at runtime based on probing during the INIT_EARLY stage of
initialisation.

TICKS_PER_SEC is now a fixed compile-time constant for all builds, and
is independent of the underlying clock tick rate.  We choose the value
1024 to allow multiplications and divisions on seconds to be converted
to bit shifts.

TICKS_PER_MS is defined as 1, allowing multiplications and divisions
on milliseconds to be omitted entirely.  The 2% inaccuracy in this
definition is negligible when using the standard BIOS timer (running
at around 18.2Hz).

TIMER_RDTSC now checks for a constant TSC before claiming to be a
usable timer.  (This timer can be tested in KVM via the command-line
option "-cpu host,+invtsc".)

Signed-off-by: Michael Brown <mcb30@ipxe.org>

src/arch/arm/include/bits/timer.h

-#ifndef _BITS_TIMER_H
-#define _BITS_TIMER_H
-
-/** @file
- *
- * ARM-specific timer API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#endif /* _BITS_TIMER_H */

src/arch/x86/core/rdtsc_timer.c

  *
  */
 
-#include <assert.h>
+#include <string.h>
+#include <errno.h>
 #include <ipxe/timer.h>
+#include <ipxe/cpuid.h>
 #include <ipxe/pit8254.h>
 
+/** Number of microseconds to use for TSC calibration */
+#define TSC_CALIBRATE_US 1024
+
+/** TSC increment per microsecond */
+static unsigned long tsc_per_us;
+
+/** Minimum resolution for scaled TSC timer */
+#define TSC_SCALED_HZ 32
+
+/** TSC scale (expressed as a bit shift)
+ *
+ * We use this to avoid the need for 64-bit divsion on 32-bit systems.
+ */
+static unsigned int tsc_scale;
+
+/** Number of timer ticks per scaled TSC increment */
+static unsigned long ticks_per_scaled_tsc;
+
+/** Colour for debug messages */
+#define colour &tsc_per_us
+
+/**
+ * Get raw TSC value
+ *
+ * @ret tsc		Raw TSC value
+ */
+static inline __always_inline unsigned long rdtsc_raw ( void ) {
+	unsigned long raw;
+
+	__asm__ __volatile__ ( "rdtsc\n\t" : "=a" ( raw ) : : "edx" );
+	return raw;
+}
+
+/**
+ * Get TSC value, shifted to avoid rollover within a realistic timescale
+ *
+ * @ret tsc		Scaled TSC value
+ */
+static inline __always_inline unsigned long rdtsc_scaled ( void ) {
+	unsigned long scaled;
+
+	__asm__ __volatile__ ( "rdtsc\n\t"
+			       "shrdl %b1, %%edx, %%eax\n\t"
+			       : "=a" ( scaled ) : "c" ( tsc_scale ) : "edx" );
+	return scaled;
+}
+
 /**
- * Number of TSC ticks per microsecond
+ * Get current system time in ticks
  *
- * This is calibrated on the first use of the timer.
+ * @ret ticks		Current time, in ticks
  */
-static unsigned long rdtsc_ticks_per_usec;
+static unsigned long rdtsc_currticks ( void ) {
+	unsigned long scaled;
+
+	scaled = rdtsc_scaled();
+	return ( scaled * ticks_per_scaled_tsc );
+}
 
 /**
  * Delay for a fixed number of microseconds
 static void rdtsc_udelay ( unsigned long usecs ) {
 	unsigned long start;
 	unsigned long elapsed;
+	unsigned long threshold;
 
-	/* Sanity guard, since we may divide by this */
-	if ( ! usecs )
-		usecs = 1;
-
-	start = currticks();
-	if ( rdtsc_ticks_per_usec ) {
-		/* Already calibrated; busy-wait until done */
-		do {
-			elapsed = ( currticks() - start );
-		} while ( elapsed < ( usecs * rdtsc_ticks_per_usec ) );
-	} else {
-		/* Not yet calibrated; use 8254 PIT and calibrate
-		 * based on result.
-		 */
-		pit8254_udelay ( usecs );
-		elapsed = ( currticks() - start );
-		rdtsc_ticks_per_usec = ( elapsed / usecs );
-		DBG ( "RDTSC timer calibrated: %ld ticks in %ld usecs "
-		      "(%ld MHz)\n", elapsed, usecs,
-		      ( rdtsc_ticks_per_usec << TSC_SHIFT ) );
-	}
+	start = rdtsc_raw();
+	threshold = ( usecs * tsc_per_us );
+	do {
+		elapsed = ( rdtsc_raw() - start );
+	} while ( elapsed < threshold );
 }
 
 /**
- * Get number of ticks per second
+ * Probe RDTSC timer
  *
- * @ret ticks_per_sec	Number of ticks per second
+ * @ret rc		Return status code
  */
-static unsigned long rdtsc_ticks_per_sec ( void ) {
+static int rdtsc_probe ( void ) {
+	unsigned long before;
+	unsigned long after;
+	unsigned long elapsed;
+	uint32_t apm;
+	uint32_t discard_a;
+	uint32_t discard_b;
+	uint32_t discard_c;
+	int rc;
 
-	/* Calibrate timer, if not already done */
-	if ( ! rdtsc_ticks_per_usec )
-		udelay ( 1 );
+	/* Check that TSC is invariant */
+	if ( ( rc = cpuid_supported ( CPUID_APM ) ) != 0 ) {
+		DBGC ( colour, "RDTSC cannot determine APM features: %s\n",
+		       strerror ( rc ) );
+		return rc;
+	}
+	cpuid ( CPUID_APM, &discard_a, &discard_b, &discard_c, &apm );
+	if ( ! ( apm & CPUID_APM_EDX_TSC_INVARIANT ) ) {
+		DBGC ( colour, "RDTSC has non-invariant TSC (%#08x)\n",
+		       apm );
+		return -ENOTTY;
+	}
 
-	/* Sanity check */
-	assert ( rdtsc_ticks_per_usec != 0 );
+	/* Calibrate udelay() timer via 8254 PIT */
+	before = rdtsc_raw();
+	pit8254_udelay ( TSC_CALIBRATE_US );
+	after = rdtsc_raw();
+	elapsed = ( after - before );
+	tsc_per_us = ( elapsed / TSC_CALIBRATE_US );
+	if ( ! tsc_per_us ) {
+		DBGC ( colour, "RDTSC has zero TSC per microsecond\n" );
+		return -EIO;
+	}
+
+	/* Calibrate currticks() scaling factor */
+	tsc_scale = 31;
+	ticks_per_scaled_tsc = ( ( 1UL << tsc_scale ) /
+				 ( tsc_per_us * ( 1000000 / TICKS_PER_SEC ) ) );
+	while ( ticks_per_scaled_tsc > ( TICKS_PER_SEC / TSC_SCALED_HZ ) ) {
+		tsc_scale--;
+		ticks_per_scaled_tsc >>= 1;
+	}
+	DBGC ( colour, "RDTSC has %ld tsc per us, %ld ticks per 2^%d tsc\n",
+	       tsc_per_us, ticks_per_scaled_tsc, tsc_scale );
+	if ( ! ticks_per_scaled_tsc ) {
+		DBGC ( colour, "RDTSC has zero ticks per TSC\n" );
+		return -EIO;
+	}
 
-	return ( rdtsc_ticks_per_usec * 1000 * 1000 );
+	return 0;
 }
 
-PROVIDE_TIMER ( rdtsc, udelay, rdtsc_udelay );
-PROVIDE_TIMER_INLINE ( rdtsc, currticks );
-PROVIDE_TIMER ( rdtsc, ticks_per_sec, rdtsc_ticks_per_sec );
+/** RDTSC timer */
+struct timer rdtsc_timer __timer ( TIMER_PREFERRED ) = {
+	.name = "rdtsc",
+	.probe = rdtsc_probe,
+	.currticks = rdtsc_currticks,
+	.udelay = rdtsc_udelay,
+};

src/arch/x86/include/bios.h

 #define BDA_EBDA 0x000e
 #define BDA_EQUIPMENT_WORD 0x0010
 #define BDA_FBMS 0x0013
+#define BDA_TICKS 0x006c
+#define BDA_MIDNIGHT 0x0070
 #define BDA_REBOOT 0x0072
 #define BDA_REBOOT_WARM 0x1234
 #define BDA_NUM_DRIVES 0x0075

src/arch/x86/include/bits/errfile.h

 #define ERRFILE_rtc_entropy	( ERRFILE_ARCH | ERRFILE_CORE | 0x000f0000 )
 #define ERRFILE_acpipwr		( ERRFILE_ARCH | ERRFILE_CORE | 0x00100000 )
 #define ERRFILE_cpuid		( ERRFILE_ARCH | ERRFILE_CORE | 0x00110000 )
+#define ERRFILE_rdtsc_timer	( ERRFILE_ARCH | ERRFILE_CORE | 0x00120000 )
 
 #define ERRFILE_bootsector     ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x00000000 )
 #define ERRFILE_bzimage	       ( ERRFILE_ARCH | ERRFILE_IMAGE | 0x00010000 )

src/arch/x86/include/bits/timer.h

-#ifndef _BITS_TIMER_H
-#define _BITS_TIMER_H
-
-/** @file
- *
- * x86-specific timer API implementations
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <ipxe/bios_timer.h>
-#include <ipxe/rdtsc_timer.h>
-
-#endif /* _BITS_TIMER_H */

src/arch/x86/include/ipxe/bios_timer.h

-#ifndef _IPXE_BIOS_TIMER_H
-#define _IPXE_BIOS_TIMER_H
-
-/** @file
- *
- * BIOS timer
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#ifdef TIMER_PCBIOS
-#define TIMER_PREFIX_pcbios
-#else
-#define TIMER_PREFIX_pcbios __pcbios_
-#endif
-
-#include <ipxe/pit8254.h>
-
-/**
- * Delay for a fixed number of microseconds
- *
- * @v usecs		Number of microseconds for which to delay
- */
-static inline __always_inline void
-TIMER_INLINE ( pcbios, udelay ) ( unsigned long usecs ) {
-	/* BIOS timer is not high-resolution enough for udelay(), so
-	 * we use the 8254 Programmable Interval Timer.
-	 */
-	pit8254_udelay ( usecs );
-}
-
-/**
- * Get number of ticks per second
- *
- * @ret ticks_per_sec	Number of ticks per second
- */
-static inline __always_inline unsigned long
-TIMER_INLINE ( pcbios, ticks_per_sec ) ( void ) {
-	/* BIOS timer ticks over at 18.2 ticks per second */
-	return 18;
-}
-
-#endif /* _IPXE_BIOS_TIMER_H */

src/arch/x86/include/ipxe/cpuid.h

 /** Get CPU model */
 #define CPUID_MODEL 0x80000002UL
 
+/** Get APM information */
+#define CPUID_APM 0x80000007UL
+
+/** Invariant TSC */
+#define CPUID_APM_EDX_TSC_INVARIANT 0x00000100UL
+
 /**
  * Issue CPUID instruction
  *

src/arch/x86/include/ipxe/rdtsc_timer.h

-#ifndef _IPXE_RDTSC_TIMER_H
-#define _IPXE_RDTSC_TIMER_H
-
-/** @file
- *
- * RDTSC timer
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#ifdef TIMER_RDTSC
-#define TIMER_PREFIX_rdtsc
-#else
-#define TIMER_PREFIX_rdtsc __rdtsc_
-#endif
-
-/**
- * RDTSC values can easily overflow an unsigned long.  We discard the
- * low-order bits in order to obtain sensibly-scaled values.
- */
-#define TSC_SHIFT 8
-
-/**
- * Get current system time in ticks
- *
- * @ret ticks		Current time, in ticks
- */
-static inline __always_inline unsigned long
-TIMER_INLINE ( rdtsc, currticks ) ( void ) {
-	unsigned long ticks;
-
-	__asm__ __volatile__ ( "rdtsc\n\t"
-			       "shrdl %1, %%edx, %%eax\n\t"
-			       : "=a" ( ticks ) : "i" ( TSC_SHIFT ) : "edx" );
-	return ticks;
-}
-
-#endif /* _IPXE_RDTSC_TIMER_H */

src/arch/x86/interface/pcbios/bios_timer.c

 #include <ipxe/timer.h>
 #include <realmode.h>
 #include <bios.h>
+#include <ipxe/pit8254.h>
+
+/** Number of ticks per day
+ *
+ * This seems to be the normative value, as used by e.g. SeaBIOS to
+ * decide when to set the midnight rollover flag.
+ */
+#define BIOS_TICKS_PER_DAY 0x1800b0
+
+/** Number of ticks per BIOS tick */
+#define TICKS_PER_BIOS_TICK \
+	( ( TICKS_PER_SEC * 60 * 60 * 24 ) / BIOS_TICKS_PER_DAY )
 
 /**
  * Get current system time in ticks
  * of calling timeofday BIOS interrupt.
  */
 static unsigned long bios_currticks ( void ) {
-	static int days = 0;
+	static uint32_t offset;
 	uint32_t ticks;
 	uint8_t midnight;
 
 			       "nop\n\t"
 			       "cli\n\t" );
 
-	get_real ( ticks, BDA_SEG, 0x006c );
-	get_real ( midnight, BDA_SEG, 0x0070 );
+	/* Read current BIOS time of day */
+	get_real ( ticks, BDA_SEG, BDA_TICKS );
+	get_real ( midnight, BDA_SEG, BDA_MIDNIGHT );
 
+	/* Handle midnight rollover */
 	if ( midnight ) {
 		midnight = 0;
-		put_real ( midnight, BDA_SEG, 0x0070 );
-		days += 0x1800b0;
+		put_real ( midnight, BDA_SEG, BDA_MIDNIGHT );
+		offset += BIOS_TICKS_PER_DAY;
 	}
+	ticks += offset;
 
-	return ( days + ticks );
+	/* Convert to timer ticks */
+	return ( ticks * TICKS_PER_BIOS_TICK );
 }
 
-PROVIDE_TIMER_INLINE ( pcbios, udelay );
-PROVIDE_TIMER ( pcbios, currticks, bios_currticks );
-PROVIDE_TIMER_INLINE ( pcbios, ticks_per_sec );
+/** BIOS timer */
+struct timer bios_timer __timer ( TIMER_NORMAL ) = {
+	.name = "bios",
+	.currticks = bios_currticks,
+	.udelay = pit8254_udelay,
+};

src/config/config_timer.c

+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ * You can also choose to distribute this program under the terms of
+ * the Unmodified Binary Distribution Licence (as given in the file
+ * COPYING.UBDL), provided that you have satisfied its requirements.
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <config/timer.h>
+
+/** @file
+ *
+ * Timer configuration options
+ *
+ */
+
+PROVIDE_REQUIRING_SYMBOL();
+
+/*
+ * Drag in timers
+ */
+#ifdef TIMER_PCBIOS
+REQUIRE_OBJECT ( bios_timer );
+#endif
+#ifdef TIMER_RDTSC
+REQUIRE_OBJECT ( rdtsc_timer );
+#endif
+#ifdef TIMER_EFI
+REQUIRE_OBJECT ( efi_timer );
+#endif
+#ifdef TIMER_LINUX
+REQUIRE_OBJECT ( linux_timer );
+#endif

src/core/parseopt.c

 		return rc;
 
 	/* Convert to a number of timer ticks */
-	*value = ( ( value_ms * TICKS_PER_SEC ) / 1000 );
+	*value = ( value_ms * TICKS_PER_MS );
 
 	return 0;
 }

src/core/timer.c

 
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
-#include <unistd.h>
+#include <string.h>
+#include <assert.h>
 #include <ipxe/process.h>
 #include <ipxe/console.h>
 #include <ipxe/keys.h>
 #include <ipxe/nap.h>
+#include <ipxe/init.h>
+#include <ipxe/timer.h>
+
+/** Current timer */
+static struct timer *timer;
+
+/**
+ * Get current system time in ticks
+ *
+ * @ret ticks		Current time, in ticks
+ */
+unsigned long currticks ( void ) {
+
+	assert ( timer != NULL );
+	return timer->currticks();
+}
+
+/**
+ * Delay for a fixed number of microseconds
+ *
+ * @v usecs		Number of microseconds for which to delay
+ */
+void udelay ( unsigned long usecs ) {
+
+	assert ( timer != NULL );
+	timer->udelay ( usecs );
+}
 
 /**
  * Delay for a fixed number of milliseconds
 
 	return 0;
 }
+
+/**
+ * Find a working timer
+ *
+ */
+static void timer_probe ( void ) {
+	int rc;
+
+	/* Use first working timer */
+	for_each_table_entry ( timer, TIMERS ) {
+		if ( ( timer->probe == NULL ) ||
+		     ( ( rc = timer->probe() ) == 0 ) ) {
+			DBGC ( &timer, "TIMER using %s\n", timer->name );
+			return;
+		}
+		DBGC ( &timer, "TIMER could not initialise %s: %s\n",
+		       timer->name, strerror ( rc ) );
+	}
+
+	/* This is a fatal error */
+	DBGC ( &timer, "TIMER found no working timers!\n" );
+	while ( 1 ) {}
+}
+
+/** Timer initialisation function */
+struct init_fn timer_init_fn __init_fn ( INIT_EARLY ) = {
+	.initialise = timer_probe,
+};
+
+/* Drag in timer configuration */
+REQUIRING_SYMBOL ( timer_init_fn );
+REQUIRE_OBJECT ( config_timer );

src/drivers/net/ath/ath5k/ath5k.c

 	unsigned int counter = 1000;
 
 	if (currticks() - sc->last_calib_ticks >
-	    ATH5K_CALIB_INTERVAL * ticks_per_sec()) {
+	    ATH5K_CALIB_INTERVAL * TICKS_PER_SEC) {
 		ath5k_calibrate(sc);
 		sc->last_calib_ticks = currticks();
 	}

src/drivers/net/forcedeth.c

 		ioaddr + NvRegTransmitterControl );
 	start = currticks();
 
-	while ( currticks() > start + 5 * ticks_per_sec() ) {
+	while ( currticks() > start + 5 * TICKS_PER_SEC ) {
 		data_ready2 = readl ( ioaddr + NvRegTransmitterControl );
 		if ( ( data_ready & NVREG_XMITCTL_DATA_READY ) !=
 		     ( data_ready2 & NVREG_XMITCTL_DATA_READY ) ) {

src/hci/commands/time_cmd.c

 	start = currticks();
 	rc = execv ( argv[1], argv + 1 );
 	elapsed = ( currticks() - start );
-	decisecs = ( 10 * elapsed / ticks_per_sec() );
+	decisecs = ( 10 * elapsed / TICKS_PER_SEC );
 
 	printf ( "%s: %d.%ds\n", argv[0],
 		 ( decisecs / 10 ), ( decisecs % 10 ) );

src/include/ipxe/efi/efi_timer.h

-#ifndef _IPXE_EFI_TIMER_H
-#define _IPXE_EFI_TIMER_H
-
-/** @file
- *
- * iPXE timer API for EFI
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#ifdef TIMER_EFI
-#define TIMER_PREFIX_efi
-#else
-#define TIMER_PREFIX_efi __efi_
-#endif
-
-/**
- * Number of ticks per second
- *
- * This is a policy decision.
- */
-#define EFI_TICKS_PER_SEC 20
-
-/**
- * Get number of ticks per second
- *
- * @ret ticks_per_sec	Number of ticks per second
- */
-static inline __attribute__ (( always_inline )) unsigned long
-TIMER_INLINE ( efi, ticks_per_sec ) ( void ) {
-
-	return EFI_TICKS_PER_SEC;
-}
-
-#endif /* _IPXE_EFI_TIMER_H */

src/include/ipxe/linux/linux_timer.h

-#ifndef _IPXE_LINUX_TIMER_H
-#define _IPXE_LINUX_TIMER_H
-
-/** @file
- *
- * iPXE timer API for Linux
- *
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#ifdef TIMER_LINUX
-#define TIMER_PREFIX_linux
-#else
-#define TIMER_PREFIX_linux __linux_
-#endif
-
-#endif /* _IPXE_LINUX_TIMER_H */

src/include/ipxe/timer.h

 
 /** @file
  *
- * iPXE timer API
+ * iPXE timers
  *
- * The timer API provides udelay() for fixed delays, and currticks()
- * for a monotonically increasing tick counter.
  */
 
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
-#include <ipxe/api.h>
-#include <config/timer.h>
+#include <ipxe/tables.h>
 
-/**
- * Calculate static inline timer API function name
- *
- * @v _prefix		Subsystem prefix
- * @v _api_func		API function
- * @ret _subsys_func	Subsystem API function
- */
-#define TIMER_INLINE( _subsys, _api_func ) \
-	SINGLE_API_INLINE ( TIMER_PREFIX_ ## _subsys, _api_func )
+/** Number of ticks per second */
+#define TICKS_PER_SEC 1024
 
-/**
- * Provide a timer API implementation
+/** Number of ticks per millisecond
  *
- * @v _prefix		Subsystem prefix
- * @v _api_func		API function
- * @v _func		Implementing function
+ * This is (obviously) not 100% consistent with the definition of
+ * TICKS_PER_SEC, but it allows for multiplications and divisions to
+ * be elided.  In any case, timer ticks are not expected to be a
+ * precision timing source; for example, the standard BIOS timer is
+ * based on an 18.2Hz clock.
  */
-#define PROVIDE_TIMER( _subsys, _api_func, _func ) \
-	PROVIDE_SINGLE_API ( TIMER_PREFIX_ ## _subsys, _api_func, _func )
+#define TICKS_PER_MS 1
 
-/**
- * Provide a static inline timer API implementation
- *
- * @v _prefix		Subsystem prefix
- * @v _api_func		API function
- */
-#define PROVIDE_TIMER_INLINE( _subsys, _api_func ) \
-	PROVIDE_SINGLE_API_INLINE ( TIMER_PREFIX_ ## _subsys, _api_func )
+/** A timer */
+struct timer {
+	/** Name */
+	const char *name;
+	/**
+	 * Probe timer
+	 *
+	 * @ret rc		Return status code
+	 */
+	int ( * probe ) ( void );
+	/**
+	 * Get current system time in ticks
+	 *
+	 * @ret ticks		Current time, in ticks
+	 */
+	unsigned long ( * currticks ) ( void );
+	/**
+	 * Delay for a fixed number of microseconds
+	 *
+	 * @v usecs		Number of microseconds for which to delay
+	 */
+	void ( * udelay ) ( unsigned long usecs );
+};
 
-/* Include all architecture-independent I/O API headers */
-#include <ipxe/efi/efi_timer.h>
-#include <ipxe/linux/linux_timer.h>
+/** Timer table */
+#define TIMERS __table ( struct timer, "timers" )
 
-/* Include all architecture-dependent I/O API headers */
-#include <bits/timer.h>
+/** Declare a timer */
+#define __timer( order ) __table_entry ( TIMERS, order )
 
-/**
- * Delay for a fixed number of microseconds
+/** @defgroup timer_order Timer detection order
  *
- * @v usecs		Number of microseconds for which to delay
+ * @{
  */
-void udelay ( unsigned long usecs );
 
-/**
- * Get current system time in ticks
- *
- * @ret ticks		Current time, in ticks
- */
-unsigned long currticks ( void );
+#define TIMER_PREFERRED	01	/**< Preferred timer */
+#define TIMER_NORMAL	02	/**< Normal timer */
 
-/**
- * Get number of ticks per second
+/** @} */
+
+/*
+ * sleep() prototype is defined by POSIX.1.  usleep() prototype is
+ * defined by 4.3BSD.  udelay() and mdelay() prototypes are chosen to
+ * be reasonably sensible.
  *
- * @ret ticks_per_sec	Number of ticks per second
  */
-unsigned long ticks_per_sec ( void );
 
-/** Number of ticks per second */
-#define TICKS_PER_SEC ( ticks_per_sec() )
+extern void udelay ( unsigned long usecs );
+extern void mdelay ( unsigned long msecs );
+extern unsigned long currticks ( void );
+extern unsigned int sleep ( unsigned int seconds );
 
 #endif /* _IPXE_TIMER_H */

src/include/unistd.h

 		rc;							\
 	} )
 
-/* Pick up udelay() */
+/* Pick up udelay() and sleep() */
 #include <ipxe/timer.h>
 
-/*
- * sleep() prototype is defined by POSIX.1.  usleep() prototype is
- * defined by 4.3BSD.  udelay() and mdelay() prototypes are chosen to
- * be reasonably sensible.
- *
- */
-
-extern unsigned int sleep ( unsigned int seconds );
-extern void mdelay ( unsigned long msecs );
-
 static inline __always_inline void usleep ( unsigned long usecs ) {
 	udelay ( usecs );
 }

src/interface/efi/efi_timer.c

  *
  */
 
+/**
+ * Number of jiffies per second
+ *
+ * This is a policy decision.
+ */
+#define EFI_JIFFIES_PER_SEC 32
+
 /** Current tick count */
 static unsigned long efi_jiffies;
 
 	if ( efi_shutdown_in_progress )
 		efi_jiffies++;
 
-	return efi_jiffies;
+	return ( efi_jiffies * ( TICKS_PER_SEC / EFI_JIFFIES_PER_SEC ) );
 }
 
 /**
 
 	/* Start timer tick */
 	if ( ( efirc = bs->SetTimer ( efi_tick_event, TimerPeriodic,
-				      ( 10000000 / EFI_TICKS_PER_SEC ) ) ) !=0){
+				      ( 10000000 / EFI_JIFFIES_PER_SEC ) ))!=0){
 		rc = -EEFI ( efirc );
 		DBGC ( colour, "EFI could not start timer tick: %s\n",
 		       strerror ( rc ) );
 		return;
 	}
 	DBGC ( colour, "EFI timer started at %d ticks per second\n",
-	       EFI_TICKS_PER_SEC );
+	       EFI_JIFFIES_PER_SEC );
 }
 
 /**
 	.shutdown = efi_tick_shutdown,
 };
 
-PROVIDE_TIMER ( efi, udelay, efi_udelay );
-PROVIDE_TIMER ( efi, currticks, efi_currticks );
-PROVIDE_TIMER_INLINE ( efi, ticks_per_sec );
+/** EFI timer */
+struct timer efi_timer __timer ( TIMER_NORMAL ) = {
+	.name = "efi",
+	.currticks = efi_currticks,
+	.udelay = efi_udelay,
+};

src/interface/linux/linux_timer.c

 	linux_usleep(usecs);
 }
 
-/**
- * Get number of ticks per second
- *
- * @ret ticks_per_sec	Number of ticks per second
- */
-static unsigned long linux_ticks_per_sec(void)
-{
-	return 1000;
-}
-
 /**
  * Get current system time in ticks
  *
 {
 	static struct timeval start;
 	static int initialized = 0;
+	struct timeval now;
+	unsigned long ticks;
 
 	if (! initialized) {
 		linux_gettimeofday(&start, NULL);
 		initialized = 1;
 	}
 
-	struct timeval now;
 	linux_gettimeofday(&now, NULL);
 
-	unsigned long ticks = (now.tv_sec - start.tv_sec) * linux_ticks_per_sec();
-	ticks += now.tv_usec / (long)(1000000 / linux_ticks_per_sec());
+	ticks = ( ( now.tv_sec - start.tv_sec ) * TICKS_PER_SEC );
+	ticks += ( now.tv_usec / ( 1000000 / TICKS_PER_SEC ) );
 
 	return ticks;
 }
 
-PROVIDE_TIMER(linux, udelay, linux_udelay);
-PROVIDE_TIMER(linux, currticks, linux_currticks);
-PROVIDE_TIMER(linux, ticks_per_sec, linux_ticks_per_sec);
+/** Linux timer */
+struct timer linux_timer __timer ( TIMER_NORMAL ) = {
+	.name = "linux",
+	.currticks = linux_currticks,
+	.udelay = linux_udelay,
+};

src/net/80211/net80211.c

 	ctx->ticks_start = currticks();
 	ctx->ticks_beacon = 0;
 	ctx->ticks_channel = currticks();
-	ctx->hop_time = ticks_per_sec() / ( active ? 2 : 6 );
+	ctx->hop_time = TICKS_PER_SEC / ( active ? 2 : 6 );
 
 	/*
 	 * Channels on 2.4GHz overlap, and the most commonly used
 int net80211_probe_step ( struct net80211_probe_ctx *ctx )
 {
 	struct net80211_device *dev = ctx->dev;
-	u32 start_timeout = NET80211_PROBE_TIMEOUT * ticks_per_sec();
-	u32 gather_timeout = ticks_per_sec();
+	u32 start_timeout = NET80211_PROBE_TIMEOUT * TICKS_PER_SEC;
+	u32 gather_timeout = TICKS_PER_SEC;
 	u32 now = currticks();
 	struct io_buffer *iob;
 	int signal;
 		/* start a frag cache entry */
 		int i, newest = -1;
 		u32 curr_ticks = currticks(), newest_ticks = 0;
-		u32 timeout = ticks_per_sec() * NET80211_FRAG_TIMEOUT;
+		u32 timeout = TICKS_PER_SEC * NET80211_FRAG_TIMEOUT;
 
 		for ( i = 0; i < NET80211_NR_CONCURRENT_FRAGS; i++ ) {
 			if ( dev->frags[i].in_use == 0 )

src/net/fcoe.c

 
 		/* Send keepalive */
 		start_timer_fixed ( &fcoe->timer,
-			      ( ( fcoe->keepalive * TICKS_PER_SEC ) / 1000 ) );
+				    ( fcoe->keepalive * TICKS_PER_MS ) );
 		fcoe_fip_tx_keepalive ( fcoe );
 
 		/* Abandon FCF if we have not seen its advertisements */

src/net/stp.c

 		       "forwarding\n",
 		       netdev->name, eth_ntoa ( stp->sender.mac ),
 		       ntohs ( stp->port ), stp->flags );
-		hello = ( ( ntohs ( stp->hello ) * TICKS_PER_SEC ) / 256 );
+		hello = ( ntohs ( stp->hello ) * ( TICKS_PER_SEC / 256 ) );
 		netdev_link_block ( netdev, ( hello * 2 ) );
 		rc = -ENETUNREACH;
 		goto done;