[timer] Formalise the timer API

We now have two implementations for the timer API: one using the
time-of-day counter at 40:70 and one using RDTSC.  Both make use of
timer2_udelay().

src/arch/i386/core/rdtsc_timer.c

+/*
+ * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * 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 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/** @file
+ *
+ * RDTSC timer
+ *
+ */
+
+#include <assert.h>
+#include <gpxe/timer.h>
+#include <gpxe/timer2.h>
+
+/**
+ * Number of TSC ticks per microsecond
+ *
+ * This is calibrated on the first use of the timer.
+ */
+static unsigned long rdtsc_ticks_per_usec;
+
+/**
+ * Delay for a fixed number of microseconds
+ *
+ * @v usecs		Number of microseconds for which to delay
+ */
+static void rdtsc_udelay ( unsigned long usecs ) {
+	unsigned long start;
+	unsigned long elapsed;
+
+	/* 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 timer2 and calibrate
+		 * based on result.
+		 */
+		timer2_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 ) );
+	}
+}
+
+/**
+ * Get number of ticks per second
+ *
+ * @ret ticks_per_sec	Number of ticks per second
+ */
+static unsigned long rdtsc_ticks_per_sec ( void ) {
+
+	/* Calibrate timer, if not already done */
+	if ( ! rdtsc_ticks_per_usec )
+		udelay ( 1 );
+
+	/* Sanity check */
+	assert ( rdtsc_ticks_per_usec != 0 );
+
+	return ( rdtsc_ticks_per_usec * 1000 * 1000 );
+}
+
+PROVIDE_TIMER ( rdtsc, udelay, rdtsc_udelay );
+PROVIDE_TIMER_INLINE ( rdtsc, currticks );
+PROVIDE_TIMER ( rdtsc, ticks_per_sec, rdtsc_ticks_per_sec );

src/arch/i386/core/i386_timer.c → src/arch/i386/core/timer2.c

  */
 
 #include <stddef.h>
-#include <bits/timer2.h>
-#include <gpxe/timer.h>
+#include <gpxe/timer2.h>
 #include <gpxe/io.h>
 
 /* Timers tick over at this rate */
-#define TIMER2_TICK_RATE	1193180U
+#define TIMER2_TICKS_PER_SEC	1193180U
 
 /* Parallel Peripheral Controller Port B */
 #define	PPC_PORTB	0x61
 #define	BINARY_COUNT	0x00
 #define	BCD_COUNT	0x01
 
-static void load_timer2(unsigned int ticks)
-{
+static void load_timer2 ( unsigned int ticks ) {
 	/*
 	 * Now let's take care of PPC channel 2
 	 *
 	outb(ticks >> 8, TIMER2_PORT);
 }
 
-static int timer2_running(void)
-{
+static int timer2_running ( void ) {
 	return ((inb(PPC_PORTB) & PPCB_T2OUT) == 0);
 }
 
-void i386_timer2_udelay(unsigned int usecs)
-{
-		load_timer2((usecs * TIMER2_TICK_RATE)/USECS_IN_SEC);
-		while (timer2_running())
-			;
+void timer2_udelay ( unsigned long usecs ) {
+	load_timer2 ( ( usecs * TIMER2_TICKS_PER_SEC ) / ( 1000 * 1000 ) );
+	while (timer2_running()) {
+		/* Do nothing */
+	}
 }
-

src/arch/i386/drivers/timer_bios.c

-/*
- * Etherboot routines for PCBIOS firmware.
- *
- * Body of routines taken from old pcbios.S
- */
-
-#include <gpxe/init.h>
-#include <gpxe/timer.h>
-#include <stdio.h>
-#include <realmode.h>
-#include <bios.h>
-#include <bits/timer2.h>
-
-/* A bit faster actually, but we don't care. */
-#define	TIMER2_TICKS_PER_SEC	18
-
-/*
- * Use direct memory access to BIOS variables, longword 0040:006C (ticks
- * today) and byte 0040:0070 (midnight crossover flag) instead of calling
- * timeofday BIOS interrupt.
- */
-
-static tick_t bios_currticks ( void ) {
-	static int days = 0;
-	uint32_t ticks;
-	uint8_t midnight;
-
-	/* Re-enable interrupts so that the timer interrupt can occur */
-	__asm__ __volatile__ ( REAL_CODE ( "sti\n\t"
-					   "nop\n\t"
-					   "nop\n\t"
-					   "cli\n\t" ) : : );
-
-	get_real ( ticks, BDA_SEG, 0x006c );
-	get_real ( midnight, BDA_SEG, 0x0070 );
-
-	if ( midnight ) {
-		midnight = 0;
-		put_real ( midnight, BDA_SEG, 0x0070 );
-		days += 0x1800b0;
-	}
-
-	return ( (days + ticks) * (USECS_IN_SEC / TIMER2_TICKS_PER_SEC) );
-}
-
-static int bios_ts_init(void)
-{
-	DBG("BIOS timer installed\n");
-	return 0;
-}
-
-struct timer bios_ts __timer ( 02 ) = {
-	.init = bios_ts_init,
-	.udelay = i386_timer2_udelay,
-	.currticks = bios_currticks,
-};
-

src/arch/i386/drivers/timer_rdtsc.c

-
-#include <gpxe/init.h>
-#include <gpxe/timer.h>
-#include <errno.h>
-#include <stdio.h>
-#include <bits/cpu.h>
-#include <bits/timer2.h>
-#include <gpxe/io.h>
-
-
-#define rdtsc(low,high) \
-     __asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high))
-
-#define rdtscll(val) \
-     __asm__ __volatile__ ("rdtsc" : "=A" (val))
-
-
-/* Measure how many clocks we get in one microsecond */
-static inline uint64_t calibrate_tsc(void)
-{
-
-	uint64_t rdtsc_start;
-	uint64_t rdtsc_end;
-
-	rdtscll(rdtsc_start);
-	i386_timer2_udelay(USECS_IN_MSEC);
-	rdtscll(rdtsc_end);
-	
-	return (rdtsc_end - rdtsc_start) / USECS_IN_MSEC;
-}
-
-static uint32_t clocks_per_usec = 0;
-
-/* We measure time in microseconds. */
-static tick_t rdtsc_currticks(void)
-{
-	uint64_t clocks;
-
-	/* Read the Time Stamp Counter */
-	rdtscll(clocks);
-
-	return clocks / clocks_per_usec;
-}
-
-static int rdtsc_ts_init(void)
-{
-
-	struct cpuinfo_x86 cpu_info;
-
-	get_cpuinfo(&cpu_info);
-	if (cpu_info.features & X86_FEATURE_TSC) {
-		clocks_per_usec= calibrate_tsc();
-		if (clocks_per_usec) {
-			DBG("RDTSC ticksource installed. CPU running at %ld Mhz\n",
-				clocks_per_usec);
-			return 0;
-		}
-	}
-
-	DBG("RDTSC ticksource not available on this machine.\n");
-	return -ENODEV;
-}
-
-struct timer rdtsc_ts __timer (01) = {
-	.init = rdtsc_ts_init,
-	.udelay = generic_currticks_udelay,
-	.currticks = rdtsc_currticks,
-};
-

src/arch/i386/include/bios.h

 #define BDA_FBMS 0x0013
 #define BDA_NUM_DRIVES 0x0075
 
-extern unsigned long currticks ( void );
 extern void cpu_nap ( void );
 
 #endif /* BIOS_H */

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

+#ifndef _BITS_TIMER_H
+#define _BITS_TIMER_H
+
+/** @file
+ *
+ * i386-specific timer API implementations
+ *
+ */
+
+#include <gpxe/bios_timer.h>
+#include <gpxe/rdtsc_timer.h>
+
+#endif /* _BITS_TIMER_H */

src/arch/i386/include/bits/timer2.h

-#ifndef BITS_TIMER2_H
-#define BITS_TIMER2_H
-
-#include <stddef.h>
-
-void i386_timer2_udelay(unsigned int usecs);
-
-#endif

src/arch/i386/include/gpxe/bios_timer.h

+#ifndef _GPXE_BIOS_TIMER_H
+#define _GPXE_BIOS_TIMER_H
+
+/** @file
+ *
+ * BIOS timer
+ *
+ */
+
+#ifdef TIMER_PCBIOS
+#define TIMER_PREFIX_pcbios
+#else
+#define TIMER_PREFIX_pcbios __pcbios_
+#endif
+
+#include <gpxe/timer2.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 timer2
+	 */
+	timer2_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 /* _GPXE_BIOS_TIMER_H */

src/arch/i386/include/gpxe/rdtsc_timer.h

+#ifndef _GPXE_RDTSC_TIMER_H
+#define _GPXE_RDTSC_TIMER_H
+
+/** @file
+ *
+ * RDTSC timer
+ *
+ */
+
+#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 /* _GPXE_RDTSC_TIMER_H */

src/arch/i386/include/gpxe/timer2.h

+#ifndef _GPXE_TIMER2_H
+#define _GPXE_TIMER2_H
+
+/** @file
+ *
+ * Timer chip control
+ *
+ */
+
+extern void timer2_udelay ( unsigned long usecs );
+
+#endif /* _GPXE_TIMER2_H */

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

+/*
+ * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * 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 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/** @file
+ *
+ * BIOS timer
+ *
+ */
+
+#include <gpxe/timer.h>
+#include <realmode.h>
+#include <bios.h>
+
+/**
+ * Get current system time in ticks
+ *
+ * @ret ticks		Current time, in ticks
+ *
+ * Use direct memory access to BIOS variables, longword 0040:006C
+ * (ticks today) and byte 0040:0070 (midnight crossover flag) instead
+ * of calling timeofday BIOS interrupt.
+ */
+static unsigned long bios_currticks ( void ) {
+	static int days = 0;
+	uint32_t ticks;
+	uint8_t midnight;
+
+	/* Re-enable interrupts so that the timer interrupt can occur */
+	__asm__ __volatile__ ( REAL_CODE ( "sti\n\t"
+					   "nop\n\t"
+					   "nop\n\t"
+					   "cli\n\t" ) : : );
+
+	get_real ( ticks, BDA_SEG, 0x006c );
+	get_real ( midnight, BDA_SEG, 0x0070 );
+
+	if ( midnight ) {
+		midnight = 0;
+		put_real ( midnight, BDA_SEG, 0x0070 );
+		days += 0x1800b0;
+	}
+
+	return ( days + ticks );
+}
+
+PROVIDE_TIMER_INLINE ( pcbios, udelay );
+PROVIDE_TIMER ( pcbios, currticks, bios_currticks );
+PROVIDE_TIMER_INLINE ( pcbios, ticks_per_sec );

src/config/defaults/pcbios.h

 
 #define IOAPI_X86
 #define PCIAPI_PCBIOS
+#define TIMER_PCBIOS
 #define CONSOLE_PCBIOS
 
 #endif /* CONFIG_DEFAULTS_PCBIOS_H */

src/config/timer.h

+#ifndef CONFIG_TIMER_H
+#define CONFIG_TIMER_H
+
+/** @file
+ *
+ * Timer configuration.
+ *
+ */
+
+#include <config/defaults.h>
+
+//#undef		TIMER_PCBIOS
+//#define		TIMER_RDTSC
+
+#endif /* CONFIG_TIMER_H */

src/core/monojob.c

 int monojob_wait ( const char *string ) {
 	int key;
 	int rc;
-	tick_t last_progress_dot;
+	unsigned long last_progress_dot;
+	unsigned long elapsed;
 
 	printf ( "%s.", string );
 	monojob_rc = -EINPROGRESS;
 				break;
 			}
 		}
-		if ( ( currticks() - last_progress_dot ) > TICKS_PER_SEC ) {
+		elapsed = ( currticks() - last_progress_dot );
+		if ( elapsed > TICKS_PER_SEC ) {
 			printf ( "." );
 			last_progress_dot = currticks();
 		}

src/core/timer.c

 /*
- * core/timer.c
- *
- * Copyright (C) 2007 Alexey Zaytsev <alexey.zaytsev@gmail.com>
+ * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <stddef.h>
-#include <assert.h>
-#include <gpxe/timer.h>
-
-static struct timer ts_table[0]
-	__table_start ( struct timer, timers );
-static struct timer ts_table_end[0]
-	__table_end ( struct timer, timers );
-
-/*
- * This function may be used in custom timer driver.
- *
- * This udelay implementation works well if you've got a
- * fast currticks().
- */
-void generic_currticks_udelay ( unsigned int usecs ) {
-	tick_t start;
-	tick_t elapsed;
-	
-	start = currticks();
-	do {
-		/* xxx: Relax the cpu some way. */
-		elapsed = ( currticks() - start );
-	} while ( elapsed < usecs );
-}
-
-/**
- * Identify timer source
- *
- * @ret timer		Timer source
- */
-static struct timer * timer ( void ) {
-	static struct timer *ts = NULL;
-
-	/* If we have a timer, use it */
-	if ( ts )
-		return ts;
-
-	/* Scan for a usable timer */
-	for ( ts = ts_table ; ts < ts_table_end ; ts++ ) {
-		if ( ts->init() == 0 )
-			return ts;
-	}
-
-	/* No timer found; we cannot continue */
-	assert ( 0 );
-	while ( 1 ) {};
-}
-
-/**
- * Read current time
- *
- * @ret ticks	Current time, in ticks
- */
-tick_t currticks ( void ) {
-	tick_t ct;
-
-	ct = timer()->currticks();
-	DBG ( "currticks: %ld.%06ld seconds\n",
-	      ct / USECS_IN_SEC, ct % USECS_IN_SEC );
-
-	return ct;
-}
-
-/**
- * Delay
- *
- * @v usecs	Time to delay, in microseconds
- */
-void udelay ( unsigned int usecs ) {
-	timer()->udelay ( usecs );
-}
+#include <unistd.h>
 
 /**
- * Delay
+ * Delay for a fixed number of milliseconds
  *
- * @v msecs	Time to delay, in milliseconds
+ * @v msecs		Number of milliseconds for which to delay
  */
-void mdelay ( unsigned int msecs ) {
+void mdelay ( unsigned long msecs ) {
 	while ( msecs-- )
-		udelay ( USECS_IN_MSEC );
+		udelay ( 1000 );
 }
 
 /**
- * Delay
+ * Delay for a fixed number of seconds
  *
- * @v secs	Time to delay, in seconds
+ * @v secs		Number of seconds for which to delay
  */
 unsigned int sleep ( unsigned int secs ) {
 	while ( secs-- )
-		mdelay ( MSECS_IN_SEC );
+		mdelay ( 1000 );
 	return 0;
 }

src/drivers/net/3c90x.c

 
     unsigned char status;
     unsigned i, retries;
-    tick_t ct;
+    unsigned long ct;
 
     for (retries=0; retries < XMIT_RETRIES ; retries++)
 	{
 	ct = currticks();
 
 	while (!(inw(INF_3C90X.IOAddr + regCommandIntStatus_w)&0x0004) &&
-		ct + 10*USECS_IN_MSEC < currticks());
+		ct + 10*1000 < currticks());
 		;
 
 	if (!(inw(INF_3C90X.IOAddr + regCommandIntStatus_w)&0x0004))

src/drivers/net/eepro100.c

 	} hdr;
 	unsigned short status;
 	int s1, s2;
-	tick_t ct;
+	unsigned long ct;
 
 	status = inw(ioaddr + SCBStatus);
 	/* Acknowledge all of the current interrupt sources ASAP. */
 
 	ct = currticks();
 	/* timeout 10 ms for transmit */
-	while (!txfd.status && ct + 10*USECS_IN_MSEC)
+	while (!txfd.status && ct + 10*1000)
 		/* Wait */;
 	s2 = inw (ioaddr + SCBStatus);
 
 	int read_cmd, ee_size;
 	int options;
 	int rx_mode;
-	tick_t ct;
+	unsigned long ct;
 
 	/* we cache only the first few words of the EEPROM data
 	   be careful not to access beyond this array */
 	whereami ("started TX thingy (config, iasetup).");
 
 	ct = currticks();
-	while (!txfd.status && ct + 10*USECS_IN_MSEC < currticks())
+	while (!txfd.status && ct + 10*1000 < currticks())
 		/* Wait */;
 
 	/* Read the status register once to disgard stale data */

src/drivers/net/epic100.c

     unsigned short nstype;
     unsigned char *txp;
     int entry;
-    tick_t ct;
+    unsigned long ct;
 
     /* Calculate the next Tx descriptor entry. */
     entry = cur_tx % TX_RING_SIZE;
     ct = currticks();
     /* timeout 10 ms for transmit */
     while ((le32_to_cpu(tx_ring[entry].status) & (TRING_OWN)) &&
-		ct + 10*USECS_IN_MSEC < currticks())
+		ct + 10*1000 < currticks())
 	/* Wait */;
 
     if ((le32_to_cpu(tx_ring[entry].status) & TRING_OWN) != 0)

src/drivers/net/via-rhine.c

     char byMIIAdrbak;
     char byMIICRbak;
     char byMIItemp;
-    tick_t ct;
+    unsigned long ct;
 
     byMIIAdrbak = inb (byMIIAD);
     byMIICRbak = inb (byMIICR);
     byMIItemp = byMIItemp & 0x40;
 
     ct = currticks();
-    while (byMIItemp != 0 && ct + 2*USECS_IN_MSEC < currticks())
+    while (byMIItemp != 0 && ct + 2*1000 < currticks())
     {
 	byMIItemp = inb (byMIICR);
 	byMIItemp = byMIItemp & 0x40;
     char byMIIAdrbak;
     char byMIICRbak;
     char byMIItemp;
-    tick_t ct;
+    unsigned long ct;
 
 
     byMIIAdrbak = inb (byMIIAD);
     byMIItemp = byMIItemp & 0x40;
 
     ct = currticks();
-    while (byMIItemp != 0 && ct + 2*USECS_IN_MSEC < currticks())
+    while (byMIItemp != 0 && ct + 2*1000 < currticks())
     {
 	byMIItemp = inb (byMIICR);
 	byMIItemp = byMIItemp & 0x40;
     byMIItemp = byMIItemp & 0x20;
 
     ct = currticks();
-    while (byMIItemp != 0 && ct + 2*USECS_IN_MSEC < currticks())
+    while (byMIItemp != 0 && ct + 2*1000 < currticks())
     {
 	byMIItemp = inb (byMIICR);
 	byMIItemp = byMIItemp & 0x20;
     unsigned char CR1bak;
     unsigned char CR0bak;
     unsigned int nstype;
-    tick_t ct;
+    unsigned long ct;
 
 
     /*printf ("rhine_transmit\n"); */
 	ct = currticks();
         /* Wait until transmit is finished or timeout*/
         while((tp->tx_ring[entry].tx_status.bits.own_bit !=0) &&
-		ct + 10*USECS_IN_MSEC < currticks())
+		ct + 10*1000 < currticks())
         ;
 
         if(tp->tx_ring[entry].tx_status.bits.terr == 0)

src/drivers/net/w89c840.c

 
 /* Operational parameters that usually are not changed. */
 /* Time in jiffies before concluding the transmitter is hung. */
-#define TX_TIMEOUT  (10*USECS_IN_MSEC)
+#define TX_TIMEOUT  (10*1000)
 
 #define PKT_BUF_SZ  1536  /* Size of each temporary Rx buffer.*/
 
     /* send the packet to destination */
     unsigned entry;
     int transmit_status;
-    tick_t ct;
+    unsigned long ct;
 
     /* Caution: the write order is important here, set the field
        with the "ownership" bits last. */

src/include/gpxe/timer.h

-#ifndef	GPXE_TIMER_H
-#define GPXE_TIMER_H
+#ifndef	_GPXE_TIMER_H
+#define _GPXE_TIMER_H
 
-#include <stddef.h>
-#include <gpxe/tables.h>
+/** @file
+ *
+ * gPXE timer API
+ *
+ * The timer API provides udelay() for fixed delays, and currticks()
+ * for a monotonically increasing tick counter.
+ */
 
-typedef unsigned long tick_t;
+#include <gpxe/api.h>
+#include <config/timer.h>
 
-#define MSECS_IN_SEC (1000)
-#define USECS_IN_SEC (1000*1000)
-#define USECS_IN_MSEC (1000)
+/**
+ * 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 )
 
-#define	TICKS_PER_SEC	USECS_IN_SEC
+/**
+ * Provide a timer API implementation
+ *
+ * @v _prefix		Subsystem prefix
+ * @v _api_func		API function
+ * @v _func		Implementing function
+ */
+#define PROVIDE_TIMER( _subsys, _api_func, _func ) \
+	PROVIDE_SINGLE_API ( TIMER_PREFIX_ ## _subsys, _api_func, _func )
 
-extern tick_t currticks ( void );
+/**
+ * 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 )
 
-extern void generic_currticks_udelay ( unsigned int usecs );
+/* Include all architecture-independent I/O API headers */
 
-/** A timer */
-struct timer {
-	/** Initialise timer
-	 *
-	 * @ret rc	Return status code
-	 */
-	int ( * init ) ( void );
-	/** Read current time
-	 *
-	 * @ret ticks	Current time, in ticks
-	 */
-	tick_t ( * currticks ) ( void );
-	/** Delay
-	 *
-	 * @v usecs	Time to delay, in microseconds
-	 */
-	void ( * udelay ) ( unsigned int usecs );
-};
+/* Include all architecture-dependent I/O API headers */
+#include <bits/timer.h>
 
-#define __timer( order ) __table ( struct timer, timers, order )
+/**
+ * Delay for a fixed number of microseconds
+ *
+ * @v usecs		Number of microseconds for which to delay
+ */
+void udelay ( unsigned long usecs );
 
-#endif	/* GPXE_TIMER_H */
+/**
+ * Get current system time in ticks
+ *
+ * @ret ticks		Current time, in ticks
+ */
+unsigned long currticks ( void );
 
+/**
+ * Get number of ticks per second
+ *
+ * @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() )
+
+#endif /* _GPXE_TIMER_H */

src/include/unistd.h

 #include <stddef.h>
 #include <stdarg.h>
 
-unsigned int sleep ( unsigned int seconds );
 extern int execv ( const char *command, char * const argv[] );
 
 /**
 		rc;							\
 	} )
 
-void udelay(unsigned int usecs);
-void mdelay(unsigned int msecs);
+/* Pick up udelay() */
+#include <gpxe/timer.h>
 
-#define usleep(x) udelay(x)
+/*
+ * 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 );
+}
 
 #endif /* _UNISTD_H */