Rewrote to use the new net driver API, the updated PCI API, and the

generic three-wire serial device support for EEPROM access.

src/drivers/net/rtl8139.c

@@ -17,6 +17,10 @@
 /*********************************************************************/
 
 /*
+  27 May 2006	mcb30@users.sourceforge.net (Michael Brown)
+     Rewrote to use the new net driver API, the updated PCI API, and
+     the generic three-wire serial device support for EEPROM access.
+
   28 Dec 2002	ken_yap@users.sourceforge.net (Ken Yap)
      Put in virt_to_bus calls to allow Etherboot relocation.
 
@@ -62,26 +66,47 @@
 
 */
 
-#include "etherboot.h"
-#include "nic.h"
+#include <io.h>
+#include <errno.h>
+#include <vsprintf.h>
+#include <timer.h>
+#include <malloc.h>
+#include <byteswap.h>
 #include <gpxe/pci.h>
-#include "timer.h"
+#include <gpxe/if_ether.h>
+#include <gpxe/ethernet.h>
+#include <gpxe/pkbuff.h>
+#include <gpxe/netdevice.h>
+#include <gpxe/nvs/threewire.h>
+
+#define TX_RING_SIZE 4
 
-#define RTL_TIMEOUT (1*TICKS_PER_SEC)
+struct rtl8139_tx {
+	unsigned int next;
+	struct pk_buff *pkb[TX_RING_SIZE];
+};
+
+struct rtl8139_rx {
+	void *ring;
+	unsigned int offset;
+};
 
-/* PCI Tuning Parameters
-   Threshold is bytes transferred to chip before transmission starts. */
-#define TX_FIFO_THRESH 256      /* In bytes, rounded down to 32 byte units. */
-#define RX_FIFO_THRESH  4       /* Rx buffer level before first PCI xfer.  */
-#define RX_DMA_BURST    4       /* Maximum PCI burst, '4' is 256 bytes */
-#define TX_DMA_BURST    4       /* Calculate as 16<<val. */
-#define NUM_TX_DESC     4       /* Number of Tx descriptor registers. */
-#define TX_BUF_SIZE	ETH_FRAME_LEN	/* FCS is added by the chip */
-#define RX_BUF_LEN_IDX 0	/* 0, 1, 2 is allowed - 8,16,32K rx buffer */
-#define RX_BUF_LEN (8192 << RX_BUF_LEN_IDX)
+struct rtl8139_nic {
+	struct threewire eeprom;
+	unsigned short ioaddr;
+	struct rtl8139_tx tx;
+	struct rtl8139_rx rx;
+};
 
-#undef DEBUG_TX
-#undef DEBUG_RX
+/* Tuning Parameters */
+#define TX_FIFO_THRESH	256	/* In bytes, rounded down to 32 byte units. */
+#define RX_FIFO_THRESH	4	/* Rx buffer level before first PCI xfer.  */
+#define RX_DMA_BURST	4	/* Maximum PCI burst, '4' is 256 bytes */
+#define TX_DMA_BURST	4	/* Calculate as 16<<val. */
+#define TX_IPG		3	/* This is the only valid value */
+#define RX_BUF_LEN_IDX	0	/* 0, 1, 2 is allowed - 8,16,32K rx buffer */
+#define RX_BUF_LEN ( (8192 << RX_BUF_LEN_IDX) )
+#define RX_BUF_PAD 4
 
 /* Symbolic offsets to registers. */
 enum RTL8139_registers {
@@ -159,327 +184,300 @@ enum CSCRBits {
 	CSCR_LinkDownCmd=0x0f3c0,
 };
 
-/* Bits in RxConfig. */
-enum rx_mode_bits {
+enum RxConfigBits {
 	RxCfgWrap=0x80,
+	Eeprom9356=0x40,
 	AcceptErr=0x20, AcceptRunt=0x10, AcceptBroadcast=0x08,
 	AcceptMulticast=0x04, AcceptMyPhys=0x02, AcceptAllPhys=0x01,
 };
 
-static unsigned int cur_rx,cur_tx;
-
-/* The RTL8139 can only transmit from a contiguous, aligned memory block.  */
-struct {
-	unsigned char tx_buffer[TX_BUF_SIZE] __attribute__((aligned(4)));
-	unsigned char rx_ring[RX_BUF_LEN+16] __attribute__((aligned(4)));
-} rtl8139_bufs __shared;
-#define tx_buffer rtl8139_bufs.tx_buffer
-#define rx_ring rtl8139_bufs.rx_ring
-
-static int rtl8139_probe(struct nic *nic,struct pci_device *pci);
-static int read_eeprom(struct nic *nic, int location, int addr_len);
-static void rtl_reset(struct nic *nic);
-static void rtl_transmit(struct nic *nic, const char *destaddr,
-	unsigned int type, unsigned int len, const char *data);
-static int rtl_poll(struct nic *nic, int retrieve);
-static void rtl_disable(struct nic *nic, struct pci_device *pci);
-static void rtl_irq(struct nic *nic, irq_action_t action);
-static struct nic_operations rtl_operations;
-static struct pci_driver rtl8139_driver;
-
-static int rtl8139_probe ( struct nic *nic, struct pci_device *pci ) {
+/*  EEPROM access */
+#define EE_MODE_PROGRAM	0x80
+#define EE_MODE_NORMAL	0x00
+#define EE_CS		0x08	/* EEPROM chip select */
+#define EE_SK		0x04	/* EEPROM shift clock */
+#define EE_DI		0x02	/* Data in */
+#define EE_DO		0x01	/* Data out */
 
-	int i;
-	int speed10, fullduplex;
-	int addr_len;
-	unsigned short *ap = (unsigned short*)nic->node_addr;
+/* Offsets within EEPROM (these are word offsets) */
+#define EE_MAC 7
 
-	/* Copy ioaddr and IRQ from PCI information */
-	pci_fill_nic ( nic, pci );
-	nic->ioaddr = pci->ioaddr;
-	nic->irqno = pci->irq;
+static inline struct rtl8139_nic * three_to_rtl ( struct threewire *three ) {
+	return container_of ( three, struct rtl8139_nic, eeprom );
+}
 
-	adjust_pci_device(pci);
+static void rtl_setcs ( struct threewire *three, int cs ) {
+	struct rtl8139_nic *rtl = three_to_rtl ( three );
+	unsigned int eereg;
 
-	/* Bring the chip out of low-power mode. */
-	outb(0x00, nic->ioaddr + Config1);
+	eereg = cs ? ( EE_MODE_PROGRAM | EE_CS ) : ( EE_MODE_NORMAL );
+	outb ( eereg, rtl->ioaddr + Cfg9346 );
+}
 
-	addr_len = read_eeprom(nic,0,8) == 0x8129 ? 8 : 6;
-	for (i = 0; i < 3; i++)
-	  *ap++ = read_eeprom(nic,i + 7,addr_len);
+static void rtl_setsk ( struct threewire *three, int sk ) {
+	struct rtl8139_nic *rtl = three_to_rtl ( three );
+	unsigned int eereg;
 
-	rtl_reset(nic);
+	eereg = inb ( rtl->ioaddr + Cfg9346 );
+	eereg = ( eereg & ~EE_SK ) | ( sk ? EE_SK : 0 );
+	outb ( eereg, rtl->ioaddr + Cfg9346 );
+}
 
-	speed10 = inb(nic->ioaddr + MediaStatus) & MSRSpeed10;
-	nic->mbps = speed10 ? 10 : 100;
-	fullduplex = inw(nic->ioaddr + MII_BMCR) & BMCRDuplex;
-	nic->duplex = fullduplex ? FULL_DUPLEX : HALF_DUPLEX;
+static void rtl_setdi ( struct threewire *three, int di ) {
+	struct rtl8139_nic *rtl = three_to_rtl ( three );
+	unsigned int eereg;
 
-	nic->nic_op	= &rtl_operations;
-	return 1;
+	eereg = inb ( rtl->ioaddr + Cfg9346 );
+	eereg = ( eereg & ~EE_DI ) | ( di ? EE_DI : 0 );
+	outb ( eereg, rtl->ioaddr + Cfg9346 );
 }
 
-/* Serial EEPROM section. */
+static int rtl_getdo ( struct threewire *three ) {
+	struct rtl8139_nic *rtl = three_to_rtl ( three );
+	unsigned int eereg;
 
-/*  EEPROM_Ctrl bits. */
-#define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
-#define EE_CS           0x08    /* EEPROM chip select. */
-#define EE_DATA_WRITE   0x02    /* EEPROM chip data in. */
-#define EE_WRITE_0      0x00
-#define EE_WRITE_1      0x02
-#define EE_DATA_READ    0x01    /* EEPROM chip data out. */
-#define EE_ENB          (0x80 | EE_CS)
-
-/*
-	Delay between EEPROM clock transitions.
-	No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
-*/
+	eereg = ( inb ( rtl->ioaddr + Cfg9346 ) & EE_DO );
+	return eereg;
+}
 
-#define eeprom_delay()  inl(ee_addr)
+static struct threewire_operations rtl_three_ops = {
+	.setcs = rtl_setcs,
+	.setsk = rtl_setsk,
+	.setdi = rtl_setdi,
+	.getdo = rtl_getdo,
+};
 
-/* The EEPROM commands include the alway-set leading bit. */
-#define EE_WRITE_CMD    (5)
-#define EE_READ_CMD     (6)
-#define EE_ERASE_CMD    (7)
+/**
+ * Set up for EEPROM access
+ *
+ * @v rtl		RTL8139 NIC
+ */
+static void rtl_init_eeprom ( struct rtl8139_nic *rtl ) {
+	int ee9356;
+
+	ee9356 = ( inw ( rtl->ioaddr + RxConfig ) & Eeprom9356 );
+	DBG ( "EEPROM is an %s\n", ee9356 ? "AT93C56" : "AT93C46" );
+	rtl->eeprom.ops = &rtl_three_ops;
+	rtl->eeprom.adrsize =
+		( ee9356 ? AT93C56_ORG16_ADRSIZE : AT93C46_ORG16_ADRSIZE );
+	rtl->eeprom.datasize =
+		( ee9356 ? AT93C56_ORG16_DATASIZE : AT93C46_ORG16_DATASIZE );
+	rtl->eeprom.udelay = 1;
+}
 
-static int read_eeprom(struct nic *nic, int location, int addr_len)
-{
+/**
+ * Read the MAC address
+ *
+ * @v rtl		RTL8139 NIC
+ * @v mac_addr		Buffer to contain MAC address (ETH_ALEN bytes)
+ */
+static void rtl_read_mac ( struct rtl8139_nic *rtl, uint8_t *mac_addr ) {
+	union {
+		uint16_t word;
+		uint8_t bytes[2];
+	} u;
 	int i;
-	unsigned int retval = 0;
-	long ee_addr = nic->ioaddr + Cfg9346;
-	int read_cmd = location | (EE_READ_CMD << addr_len);
-
-	outb(EE_ENB & ~EE_CS, ee_addr);
-	outb(EE_ENB, ee_addr);
-	eeprom_delay();
-
-	/* Shift the read command bits out. */
-	for (i = 4 + addr_len; i >= 0; i--) {
-		int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
-		outb(EE_ENB | dataval, ee_addr);
-		eeprom_delay();
-		outb(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
-		eeprom_delay();
-	}
-	outb(EE_ENB, ee_addr);
-	eeprom_delay();
-
-	for (i = 16; i > 0; i--) {
-		outb(EE_ENB | EE_SHIFT_CLK, ee_addr);
-		eeprom_delay();
-		retval = (retval << 1) | ((inb(ee_addr) & EE_DATA_READ) ? 1 : 0);
-		outb(EE_ENB, ee_addr);
-		eeprom_delay();
+	
+	DBG ( "MAC address is " );
+	for ( i = 0 ; i < ( ETH_ALEN / 2 ) ; i++ ) {
+		u.word = cpu_to_le16 ( threewire_read ( &rtl->eeprom,
+							EE_MAC + i ) );
+		*mac_addr++ = u.bytes[0];
+		*mac_addr++ = u.bytes[1];
+		DBG ( "%02x%02x", u.bytes[0], u.bytes[1] );
 	}
-
-	/* Terminate the EEPROM access. */
-	outb(~EE_CS, ee_addr);
-	eeprom_delay();
-	return retval;
+	DBG ( "\n" );
 }
 
-static const unsigned int rtl8139_rx_config = 
-	(RX_BUF_LEN_IDX << 11) |
-	(RX_FIFO_THRESH << 13) |
-	(RX_DMA_BURST << 8);
-	
-static void set_rx_mode(struct nic *nic) {
-	unsigned int mc_filter[2];
-	int rx_mode;
-	/* !IFF_PROMISC */
-	rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
-	mc_filter[1] = mc_filter[0] = 0xffffffff;
-
-	outl(rtl8139_rx_config | rx_mode, nic->ioaddr + RxConfig);
-
-	outl(mc_filter[0], nic->ioaddr + MAR0 + 0);
-	outl(mc_filter[1], nic->ioaddr + MAR0 + 4);
+/**
+ * Reset NIC
+ *
+ * @v rtl		RTL8139 NIC
+ *
+ * Issues a hardware reset and waits for the reset to complete.
+ */
+static void rtl_reset ( struct rtl8139_nic *rtl ) {
+
+	/* Reset chip */
+	outb ( CmdReset, rtl->ioaddr + ChipCmd );
+	mdelay ( 10 );
+	rtl->tx.next = 0;
+	rtl->rx.offset = 0;
 }
 
-static int rtl_connect ( struct nic *nic ) {
-	if (inb(nic->ioaddr + MediaStatus) & MSRLinkFail) {
-		printf("Cable not connected or other link failure\n");
-		return 0;
-	}
-	return 1;
-}
-	
-static void rtl_reset(struct nic* nic)
-{
+/**
+ * Open NIC
+ *
+ * @v netdev		Net device
+ * @ret rc		Return status code
+ */
+static int rtl_open ( struct net_device *netdev ) {
+	struct rtl8139_nic *rtl = netdev->priv;
 	int i;
 
-	outb(CmdReset, nic->ioaddr + ChipCmd);
-
-	cur_rx = 0;
-	cur_tx = 0;
-
-	/* Give the chip 10ms to finish the reset. */
-	load_timer2(10*TICKS_PER_MS);
-	while ((inb(nic->ioaddr + ChipCmd) & CmdReset) != 0 &&
-	       timer2_running())
-		/* wait */;
-
-	for (i = 0; i < ETH_ALEN; i++)
-		outb(nic->node_addr[i], nic->ioaddr + MAC0 + i);
-
-	/* Must enable Tx/Rx before setting transfer thresholds! */
-	outb(CmdRxEnb | CmdTxEnb, nic->ioaddr + ChipCmd);
-	outl((RX_FIFO_THRESH<<13) | (RX_BUF_LEN_IDX<<11) | (RX_DMA_BURST<<8),
-		nic->ioaddr + RxConfig);	  /* accept no frames yet!  */
-	outl((TX_DMA_BURST<<8)|0x03000000, nic->ioaddr + TxConfig);
-
-	/* The Linux driver changes Config1 here to use a different LED pattern
-	 * for half duplex or full/autodetect duplex (for full/autodetect, the
-	 * outputs are TX/RX, Link10/100, FULL, while for half duplex it uses
-	 * TX/RX, Link100, Link10).  This is messy, because it doesn't match
-	 * the inscription on the mounting bracket.  It should not be changed
-	 * from the configuration EEPROM default, because the card manufacturer
-	 * should have set that to match the card.  */
-
-#ifdef	DEBUG_RX
-	printf("rx ring address is %X\n",(unsigned long)rx_ring);
-#endif
-	outl((unsigned long)virt_to_bus(rx_ring), nic->ioaddr + RxBuf);
-
-
-
-	/* If we add multicast support, the MAR0 register would have to be
-	 * initialized to 0xffffffffffffffff (two 32 bit accesses).  Etherboot
-	 * only needs broadcast (for ARP/RARP/BOOTP/DHCP) and unicast.  */
-
-	outb(CmdRxEnb | CmdTxEnb, nic->ioaddr + ChipCmd);
-	
-	outl(rtl8139_rx_config, nic->ioaddr + RxConfig);
-	
-	/* Start the chip's Tx and Rx process. */
-	outl(0, nic->ioaddr + RxMissed);
-
-	/* set_rx_mode */
-	set_rx_mode(nic);
-	
-	/* Disable all known interrupts by setting the interrupt mask. */
-	outw(0, nic->ioaddr + IntrMask);
+	/* Program the MAC address */
+	for ( i = 0 ; i < ETH_ALEN ; i++ )
+		outb ( netdev->ll_addr[i], rtl->ioaddr + MAC0 + i );
+
+	/* Set up RX ring */
+	rtl->rx.ring = malloc ( RX_BUF_LEN + RX_BUF_PAD );
+	if ( ! rtl->rx.ring )
+		return -ENOMEM;
+	outl ( virt_to_bus ( rtl->rx.ring ), rtl->ioaddr + RxBuf );
+	DBG ( "RX ring at %lx\n", virt_to_bus ( rtl->rx.ring ) );
+
+	/* Enable TX and RX */
+	outb ( ( CmdRxEnb | CmdTxEnb ), rtl->ioaddr + ChipCmd );
+	outl ( ( ( RX_FIFO_THRESH << 13 ) | ( RX_BUF_LEN_IDX << 11 ) |
+		 ( RX_DMA_BURST << 8 ) | AcceptBroadcast | AcceptMulticast |
+		 AcceptMyPhys ), rtl->ioaddr + RxConfig );
+	outl ( 0xffffffffUL, rtl->ioaddr + MAR0 + 0 );
+	outl ( 0xffffffffUL, rtl->ioaddr + MAR0 + 4 );
+	outl ( ( ( TX_DMA_BURST << 8 ) | ( TX_IPG << 24 ) ),
+	       rtl->ioaddr + TxConfig );
+
+	return 0;
 }
 
-static void rtl_transmit(struct nic *nic, const char *destaddr,
-	unsigned int type, unsigned int len, const char *data)
-{
-	unsigned int status, to, nstype;
-	unsigned long txstatus;
-
-	/* nstype assignment moved up here to avoid gcc 3.0.3 compiler bug */
-	nstype = htons(type);
-	memcpy(tx_buffer, destaddr, ETH_ALEN);
-	memcpy(tx_buffer + ETH_ALEN, nic->node_addr, ETH_ALEN);
-	memcpy(tx_buffer + 2 * ETH_ALEN, &nstype, 2);
-	memcpy(tx_buffer + ETH_HLEN, data, len);
-
-	len += ETH_HLEN;
-#ifdef	DEBUG_TX
-	printf("sending %d bytes ethtype %hX\n", len, type);
-#endif
-
-	/* Note: RTL8139 doesn't auto-pad, send minimum payload (another 4
-	 * bytes are sent automatically for the FCS, totalling to 64 bytes). */
-	while (len < ETH_ZLEN) {
-		tx_buffer[len++] = '\0';
-	}
-
-	outl((unsigned long)virt_to_bus(tx_buffer), nic->ioaddr + TxAddr0 + cur_tx*4);
-	outl(((TX_FIFO_THRESH<<11) & 0x003f0000) | len,
-		nic->ioaddr + TxStatus0 + cur_tx*4);
-
-	to = currticks() + RTL_TIMEOUT;
+/**
+ * Close NIC
+ *
+ * @v netdev		Net device
+ */
+static void rtl_close ( struct net_device *netdev ) {
+	struct rtl8139_nic *rtl = netdev->priv;
+	int i;
 
-	do {
-		status = inw(nic->ioaddr + IntrStatus);
-		/* Only acknlowledge interrupt sources we can properly handle
-		 * here - the RxOverflow/RxFIFOOver MUST be handled in the
-		 * rtl_poll() function.  */
-		outw(status & (TxOK | TxErr | PCIErr), nic->ioaddr + IntrStatus);
-		if ((status & (TxOK | TxErr | PCIErr)) != 0) break;
-	} while (currticks() < to);
+	/* Reset the hardware to disable everything in one go */
+	rtl_reset ( rtl );
 
-	txstatus = inl(nic->ioaddr+ TxStatus0 + cur_tx*4);
+	/* Free RX ring */
+	free ( rtl->rx.ring );
+	rtl->rx.ring = NULL;
 
-	if (status & TxOK) {
-		cur_tx = (cur_tx + 1) % NUM_TX_DESC;
-#ifdef	DEBUG_TX
-		printf("tx done (%d ticks), status %hX txstatus %X\n",
-			to-currticks(), status, txstatus);
-#endif
-	} else {
-#ifdef	DEBUG_TX
-		printf("tx timeout/error (%d ticks), status %hX txstatus %X\n",
-			currticks()-to, status, txstatus);
-#endif
-		rtl_reset(nic);
+	/* Free any old TX buffers that hadn't yet completed */
+	for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
+		if ( rtl->tx.pkb[i] ) {
+			free_pkb ( rtl->tx.pkb[i] );
+			rtl->tx.pkb[i] = NULL;
+			DBG ( "TX id %d discarded\n", i );
+		}
 	}
 }
 
-static int rtl_poll(struct nic *nic, int retrieve)
-{
-	unsigned int status;
-	unsigned int ring_offs;
-	unsigned int rx_size, rx_status;
-
-	if (inb(nic->ioaddr + ChipCmd) & RxBufEmpty) {
-		return 0;
+/** 
+ * Transmit packet
+ *
+ * @v netdev	Network device
+ * @v pkb	Packet buffer
+ * @ret rc	Return status code
+ */
+static int rtl_transmit ( struct net_device *netdev, struct pk_buff *pkb ) {
+	struct rtl8139_nic *rtl = netdev->priv;
+	int align;
+	int pad_len;
+
+	/* Check for space in TX ring */
+	if ( rtl->tx.pkb[rtl->tx.next] != NULL ) {
+		printf ( "TX overflow\n" );
+		free_pkb ( pkb );
+		return -ENOBUFS;
 	}
 
-	/* There is a packet ready */
-	if ( ! retrieve ) return 1;
-
-	status = inw(nic->ioaddr + IntrStatus);
-	/* See below for the rest of the interrupt acknowledges.  */
-	outw(status & ~(RxFIFOOver | RxOverflow | RxOK), nic->ioaddr + IntrStatus);
-
-#ifdef	DEBUG_RX
-	printf("rtl_poll: int %hX ", status);
-#endif
+	/* Align packet data */
+	align = ( virt_to_bus ( pkb->data ) & 0x3 );
+	pkb_push ( pkb, align );
+	memmove ( pkb->data, pkb->data + align, pkb_len ( pkb ) - align );
+	pkb_unput ( pkb, align );
+
+	/* Pad to minimum packet length */
+	pad_len = ( ETH_ZLEN - pkb_len ( pkb ) );
+	if ( pad_len > 0 )
+		memset ( pkb_put ( pkb, pad_len ), 0, pad_len );
+
+	/* Add to TX ring */
+	DBG ( "TX id %d at %lx+%x\n", rtl->tx.next,
+	      virt_to_bus ( pkb->data ), pkb_len ( pkb ) );
+	rtl->tx.pkb[rtl->tx.next] = pkb;
+	outl ( virt_to_bus ( pkb->data ),
+	       rtl->ioaddr + TxAddr0 + 4 * rtl->tx.next );
+	outl ( ( ( ( TX_FIFO_THRESH & 0x7e0 ) << 11 ) | pkb_len ( pkb ) ),
+	       rtl->ioaddr + TxStatus0 + 4 * rtl->tx.next );
+	rtl->tx.next = ( rtl->tx.next + 1 ) % TX_RING_SIZE;
+
+	return 0;
+}
 
-	ring_offs = cur_rx % RX_BUF_LEN;
-	rx_status = *(unsigned int*)(rx_ring + ring_offs);
-	rx_size = rx_status >> 16;
-	rx_status &= 0xffff;
+/** 
+ * Poll for received packets
+ *
+ * @v netdev	Network device
+ */
+static void rtl_poll ( struct net_device *netdev ) {
+	struct rtl8139_nic *rtl = netdev->priv;
+	unsigned int status;
+	unsigned int tsad;
+	unsigned int rx_status;
+	unsigned int rx_len;
+	struct pk_buff *rx_pkb;
+	int wrapped_len;
+	int i;
 
-	if ((rx_status & (RxBadSymbol|RxRunt|RxTooLong|RxCRCErr|RxBadAlign)) ||
-	    (rx_size < ETH_ZLEN) || (rx_size > ETH_FRAME_LEN + 4)) {
-		printf("rx error %hX\n", rx_status);
-		rtl_reset(nic);	/* this clears all interrupts still pending */
-		return 0;
+	/* Acknowledge interrupts */
+	status = inw ( rtl->ioaddr + IntrStatus );
+	if ( ! status )
+		return;
+	outw ( status, rtl->ioaddr + IntrStatus );
+
+	/* Handle TX completions */
+	tsad = inw ( rtl->ioaddr + TxSummary );
+	for ( i = 0 ; i < TX_RING_SIZE ; i++ ) {
+		if ( ( rtl->tx.pkb[i] != NULL ) && ( tsad & ( 1 << i ) ) ) {
+			DBG ( "TX id %d complete\n", i );
+			free_pkb ( rtl->tx.pkb[i] );
+			rtl->tx.pkb[i] = NULL;
+		}
 	}
 
-	/* Received a good packet */
-	nic->packetlen = rx_size - 4;	/* no one cares about the FCS */
-	if (ring_offs+4+rx_size-4 > RX_BUF_LEN) {
-		int semi_count = RX_BUF_LEN - ring_offs - 4;
-
-		memcpy(nic->packet, rx_ring + ring_offs + 4, semi_count);
-		memcpy(nic->packet+semi_count, rx_ring, rx_size-4-semi_count);
-#ifdef	DEBUG_RX
-		printf("rx packet %d+%d bytes", semi_count,rx_size-4-semi_count);
-#endif
-	} else {
-		memcpy(nic->packet, rx_ring + ring_offs + 4, nic->packetlen);
-#ifdef	DEBUG_RX
-		printf("rx packet %d bytes", rx_size-4);
-#endif
+	/* Handle received packets */
+	while ( ! ( inw ( rtl->ioaddr + ChipCmd ) & RxBufEmpty ) ) {
+		rx_status = * ( ( uint16_t * )
+				( rtl->rx.ring + rtl->rx.offset ) );
+		rx_len = * ( ( uint16_t * )
+			     ( rtl->rx.ring + rtl->rx.offset + 2 ) );
+		if ( rx_status & RxOK ) {
+			DBG ( "RX packet at offset %x+%x\n", rtl->rx.offset,
+			      rx_len );
+
+			rx_pkb = alloc_pkb ( rx_len );
+			if ( ! rx_pkb ) {
+				/* Leave packet for next call to poll() */
+				break;
+			}
+
+			wrapped_len = ( ( rtl->rx.offset + 4 + rx_len )
+					- RX_BUF_LEN );
+			if ( wrapped_len < 0 )
+				wrapped_len = 0;
+
+			memcpy ( pkb_put ( rx_pkb, rx_len - wrapped_len ),
+				 rtl->rx.ring + rtl->rx.offset + 4,
+				 rx_len - wrapped_len );
+			memcpy ( pkb_put ( rx_pkb, wrapped_len ),
+				 rtl->rx.ring, wrapped_len );
+
+			netdev_rx ( netdev, rx_pkb );
+		} else {
+			DBG ( "RX bad packet (status %#04x len %d)\n",
+			      rx_status, rx_len );
+		}
+		rtl->rx.offset = ( ( ( rtl->rx.offset + 4 + rx_len + 3 ) & ~3 )
+				   % RX_BUF_LEN );
+		outw ( rtl->rx.offset - 16, rtl->ioaddr + RxBufPtr );
 	}
-#ifdef	DEBUG_RX
-	printf(" at %X type %hhX%hhX rxstatus %hX\n",
-		(unsigned long)(rx_ring+ring_offs+4),
-		nic->packet[12], nic->packet[13], rx_status);
-#endif
-	cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
-	outw(cur_rx - 16, nic->ioaddr + RxBufPtr);
-	/* See RTL8139 Programming Guide V0.1 for the official handling of
-	 * Rx overflow situations.  The document itself contains basically no
-	 * usable information, except for a few exception handling rules.  */
-	outw(status & (RxFIFOOver | RxOverflow | RxOK), nic->ioaddr + IntrStatus);
-	return 1;
 }
 
+#if 0
 static void rtl_irq(struct nic *nic, irq_action_t action)
 {
 	unsigned int mask;
@@ -489,10 +487,10 @@ static void rtl_irq(struct nic *nic, irq_action_t action)
 	switch ( action ) {
 	case DISABLE :
 	case ENABLE :
-		mask = inw(nic->ioaddr + IntrMask);
+		mask = inw(rtl->ioaddr + IntrMask);
 		mask = mask & ~interested;
 		if ( action == ENABLE ) mask = mask | interested;
-		outw(mask, nic->ioaddr + IntrMask);
+		outw(mask, rtl->ioaddr + IntrMask);
 		break;
 	case FORCE :
 		/* Apparently writing a 1 to this read-only bit of a
@@ -501,32 +499,88 @@ static void rtl_irq(struct nic *nic, irq_action_t action)
 		 * not to write a datasheet, read the one for the
 		 * RTL8139...
 		 */
-		outb(EROK, nic->ioaddr + RxEarlyStatus);
+		outb(EROK, rtl->ioaddr + RxEarlyStatus);
 		break;
 	}
 }
+#endif
+
+/**
+ * Probe PCI device
+ *
+ * @v pci	PCI device
+ * @v id	PCI ID
+ * @ret rc	Return status code
+ */
+static int rtl_probe ( struct pci_device *pci,
+		       const struct pci_device_id *id __unused ) {
+	struct net_device *netdev;
+	struct rtl8139_nic *rtl = NULL;
+	int rc;
+
+	/* Fix up PCI device */
+	adjust_pci_device ( pci );
+
+	/* Allocate net device */
+	netdev = alloc_etherdev ( sizeof ( *rtl ) );
+	if ( ! netdev ) {
+		rc = -ENOMEM;
+		goto err;
+	}
+	rtl = netdev->priv;
+	pci_set_drvdata ( pci, netdev );
+	memset ( rtl, 0, sizeof ( *rtl ) );
+	rtl->ioaddr = pci->ioaddr;
+
+	/* Reset the NIC, set up EEPROM access and read MAC address */
+	rtl_reset ( rtl );
+	rtl_init_eeprom ( rtl );
+	rtl_read_mac ( rtl, netdev->ll_addr );
+	
+	/* Point to NIC specific routines */
+	//	netdev->open	 = rtl_open;
+	//	netdev->close	 = rtl_close;
+	netdev->transmit = rtl_transmit;
+	netdev->poll	 = rtl_poll;
+
+	/* Register network device */
+	if ( ( rc = register_netdev ( netdev ) ) != 0 )
+		goto err;
 
-static void rtl_disable ( struct nic *nic, struct pci_device *pci __unused ) {
-	nic_disable ( nic );
-	/* merge reset and disable */
-	rtl_reset(nic);
 
-	/* reset the chip */
-	outb(CmdReset, nic->ioaddr + ChipCmd);
+#warning "Hack alert"
+	rtl_open ( netdev );
 
-	/* 10 ms timeout */
-	load_timer2(10*TICKS_PER_MS);
-	while ((inb(nic->ioaddr + ChipCmd) & CmdReset) != 0 && timer2_running())
-		/* wait */;
+
+	return 0;
+
+ err:
+	/* Disable NIC */
+	if ( rtl )
+		rtl_reset ( rtl );
+	/* Free net device */
+	free_netdev ( netdev );
+	return rc;
 }
 
-static struct nic_operations rtl_operations = {
-	.connect	= rtl_connect,
-	.poll		= rtl_poll,
-	.transmit	= rtl_transmit,
-	.irq		= rtl_irq,
+/**
+ * Remove PCI device
+ *
+ * @v pci	PCI device
+ */
+static void rtl_remove ( struct pci_device *pci ) {
+	struct net_device *netdev = pci_get_drvdata ( pci );
+	struct rtl8139_nic *rtl = netdev->priv;
+
+
+#warning "Hack alert"	
+	rtl_close ( netdev );
 
-};
+
+	unregister_netdev ( netdev );
+	rtl_reset ( rtl );
+	free_netdev ( netdev );
+}
 
 static struct pci_device_id rtl8139_nics[] = {
 PCI_ROM(0x10ec, 0x8129, "rtl8129",       "Realtek 8129"),
@@ -545,7 +599,9 @@ PCI_ROM(0x14ea, 0xab07, "fnw3800tx",     "Planex FNW-3800-TX"),
 PCI_ROM(0xffff, 0x8139, "clone-rtl8139", "Cloned 8139"),
 };
 
-PCI_DRIVER ( rtl8139_driver, rtl8139_nics, PCI_NO_CLASS );
-
-DRIVER ( "RTL8139", nic_driver, pci_driver, rtl8139_driver,
-	 rtl8139_probe, rtl_disable );
+struct pci_driver rtl8139_driver __pci_driver = {
+	.ids = rtl8139_nics,
+	.id_count = ( sizeof ( rtl8139_nics ) / sizeof ( rtl8139_nics[0] ) ),
+	.probe = rtl_probe,
+	.remove = rtl_remove,
+};