Newbusify ed driver.

Partly submitted by:	alex

1 files changed, 458 insertions, 315 deletions

diff --git a/sys/dev/ed/if_ed.c b/sys/dev/ed/if_ed.c
index e1bab28..e099480 100644
--- a/sys/dev/ed/if_ed.c
+++ b/sys/dev/ed/if_ed.c
@@ -75,13 +75,13 @@ static void	ed_start	__P((struct ifnet *));
 static void	ed_reset	__P((struct ifnet *));
 static void	ed_watchdog	__P((struct ifnet *));
 
-static void	ds_getmcaf	__P((struct ed_softc *, u_long *));
+static void	ds_getmcaf	__P((struct ed_softc *, u_int32_t *));
 
-static void	ed_get_packet	__P((struct ed_softc *, char *, /* u_short */ int));
+static void	ed_get_packet	__P((struct ed_softc *, int, /* u_short */ int));
 
 static __inline void	ed_rint	__P((struct ed_softc *));
 static __inline void	ed_xmit	__P((struct ed_softc *));
-static __inline char *	ed_ring_copy __P((struct ed_softc *, char *, char *,
+static __inline int	ed_ring_copy __P((struct ed_softc *, int, char *,
 					  /* u_short */ int));
 static void	ed_hpp_set_physical_link __P((struct ed_softc *));
 static void	ed_hpp_readmem	__P((struct ed_softc *, int, unsigned char *,
@@ -96,9 +96,16 @@ static void	ed_pio_writemem	__P((struct ed_softc *, char *,
 static u_short	ed_pio_write_mbufs __P((struct ed_softc *, struct mbuf *,
 					int));
 
+static u_char	ed_readb	__P((struct ed_softc *, int));
+static void	ed_writew	__P((struct ed_softc *, int, u_int16_t));
+static u_int16_t ed_readw	__P((struct ed_softc *, int));
+static void	ed_writesw	__P((struct ed_softc *, int, const u_int16_t *,
+				     size_t));
+static void	ed_bcopy_from	__P((struct ed_softc *, caddr_t, int, size_t));
+
 static void	ed_setrcr	__P((struct ed_softc *));
 
-static u_long	ds_crc		__P((u_char *ep));
+static u_int32_t ds_crc		__P((u_char *ep));
 
 /*
  * Interrupt conversion table for WD/SMC ASIC/83C584
@@ -152,6 +159,62 @@ static unsigned short ed_hpp_intr_val[] = {
 };
 
 /*
+ * Write one byte to device 
+ */
+static void
+ed_writeb(struct ed_softc *sc, int regno, u_char data)
+{
+	bus_space_write_1(sc->bst, sc->bsh, regno, data);
+}
+
+/*
+ * Read one byte from device
+ */
+static u_char
+ed_readb(struct ed_softc *sc, int regno)
+{
+	return bus_space_read_1(sc->bst, sc->bsh, regno);
+}
+
+/*
+ * Write one word to device 
+ */
+static void
+ed_writew(struct ed_softc *sc, int regno, u_int16_t data)
+{
+	bus_space_write_2(sc->bst, sc->bsh, regno, data);
+}
+
+/*
+ * Read one word from device
+ */
+static u_int16_t
+ed_readw(struct ed_softc *sc, int regno)
+{
+	return bus_space_read_2(sc->bst, sc->bsh, regno);
+}
+
+/*
+ * Write a whole vector of words to device
+ */
+static void
+ed_writesw(struct ed_softc *sc, int regno, const u_int16_t *addr, size_t cnt)
+{
+	bus_space_write_multi_2(sc->bst, sc->bsh, regno,
+	    addr, cnt);
+}
+
+/*
+ * bcopy memory from card to buffer
+ */
+static void
+ed_bcopy_from(struct ed_softc *sc, caddr_t dst, int regno, size_t cnt)
+{
+	bus_space_read_multi_1(sc->bst, sc->bsh, regno,
+	    dst, cnt);
+}
+
+/*
  * Generic probe routine for testing for the existance of a DS8390.
  *	Must be called after the NIC has just been reset. This routine
  *	works by looking at certain register values that are guaranteed
@@ -178,11 +241,11 @@ int
 ed_probe_generic8390(sc)
 	struct ed_softc *sc;
 {
-	if ((inb(sc->nic_addr + ED_P0_CR) &
+	if ((ed_readb(sc, sc->nic_addr + ED_P0_CR) &
 	     (ED_CR_RD2 | ED_CR_TXP | ED_CR_STA | ED_CR_STP)) !=
 	    (ED_CR_RD2 | ED_CR_STP))
 		return (0);
-	if ((inb(sc->nic_addr + ED_P0_ISR) & ED_ISR_RST) != ED_ISR_RST)
+	if ((ed_readb(sc, sc->nic_addr + ED_P0_ISR) & ED_ISR_RST) != ED_ISR_RST)
 		return (0);
 
 	return (1);
@@ -213,12 +276,11 @@ ed_probe_WD80x3(dev)
 
 	if (ED_FLAGS_GETTYPE(flags) == ED_FLAGS_TOSH_ETHER) {
 		totalsum = ED_WD_ROM_CHECKSUM_TOTAL_TOSH_ETHER;
-		outb(sc->asic_addr + ED_WD_MSR, ED_WD_MSR_POW);
+		ed_writeb(sc, sc->asic_addr + ED_WD_MSR, ED_WD_MSR_POW);
 		DELAY(10000);
 	}
 	else
 		totalsum = ED_WD_ROM_CHECKSUM_TOTAL;
-	
 
 	/*
 	 * Attempt to do a checksum over the station address PROM. If it
@@ -227,7 +289,7 @@ ed_probe_WD80x3(dev)
 	 * Danpex boards for one.
 	 */
 	for (sum = 0, i = 0; i < 8; ++i)
-		sum += inb(sc->asic_addr + ED_WD_PROM + i);
+		sum += ed_readb(sc, sc->asic_addr + ED_WD_PROM + i);
 
 	if (sum != totalsum) {
 
@@ -236,23 +298,23 @@ ed_probe_WD80x3(dev)
 		 * clones.  In this case, the checksum byte (the eighth byte)
 		 * seems to always be zero.
 		 */
-		if (inb(sc->asic_addr + ED_WD_CARD_ID) != ED_TYPE_WD8003E ||
-		    inb(sc->asic_addr + ED_WD_PROM + 7) != 0)
+		if (ed_readb(sc, sc->asic_addr + ED_WD_CARD_ID) != ED_TYPE_WD8003E ||
+		    ed_readb(sc, sc->asic_addr + ED_WD_PROM + 7) != 0)
 			return (ENXIO);
 	}
 	/* reset card to force it into a known state. */
 	if (ED_FLAGS_GETTYPE(flags) == ED_FLAGS_TOSH_ETHER)
-		outb(sc->asic_addr + ED_WD_MSR, ED_WD_MSR_RST | ED_WD_MSR_POW);
+		ed_writeb(sc, sc->asic_addr + ED_WD_MSR, ED_WD_MSR_RST | ED_WD_MSR_POW);
 	else
-		outb(sc->asic_addr + ED_WD_MSR, ED_WD_MSR_RST);
+		ed_writeb(sc, sc->asic_addr + ED_WD_MSR, ED_WD_MSR_RST);
 
 	DELAY(100);
-	outb(sc->asic_addr + ED_WD_MSR, inb(sc->asic_addr + ED_WD_MSR) & ~ED_WD_MSR_RST);
+	ed_writeb(sc, sc->asic_addr + ED_WD_MSR, ed_readb(sc, sc->asic_addr + ED_WD_MSR) & ~ED_WD_MSR_RST);
 	/* wait in the case this card is reading its EEROM */
 	DELAY(5000);
 
 	sc->vendor = ED_VENDOR_WD_SMC;
-	sc->type = inb(sc->asic_addr + ED_WD_CARD_ID);
+	sc->type = ed_readb(sc, sc->asic_addr + ED_WD_CARD_ID);
 
 	/*
 	 * Set initial values for width/size.
@@ -283,7 +345,7 @@ ed_probe_WD80x3(dev)
 		isa16bit = 1;
 		break;
 	case ED_TYPE_WD8013EP:	/* also WD8003EP */
-		if (inb(sc->asic_addr + ED_WD_ICR)
+		if (ed_readb(sc, sc->asic_addr + ED_WD_ICR)
 		    & ED_WD_ICR_16BIT) {
 			isa16bit = 1;
 			memsize = 16384;
@@ -315,9 +377,9 @@ ed_probe_WD80x3(dev)
 			sc->type_str = "SMC8216T";
 		}
 
-		outb(sc->asic_addr + ED_WD790_HWR,
-		    inb(sc->asic_addr + ED_WD790_HWR) | ED_WD790_HWR_SWH);
-		switch (inb(sc->asic_addr + ED_WD790_RAR) & ED_WD790_RAR_SZ64) {
+		ed_writeb(sc, sc->asic_addr + ED_WD790_HWR,
+		    ed_readb(sc, sc->asic_addr + ED_WD790_HWR) | ED_WD790_HWR_SWH);
+		switch (ed_readb(sc, sc->asic_addr + ED_WD790_RAR) & ED_WD790_RAR_SZ64) {
 		case ED_WD790_RAR_SZ64:
 			memsize = 65536;
 			break;
@@ -337,8 +399,8 @@ ed_probe_WD80x3(dev)
 			memsize = 8192;
 			break;
 		}
-		outb(sc->asic_addr + ED_WD790_HWR,
-		    inb(sc->asic_addr + ED_WD790_HWR) & ~ED_WD790_HWR_SWH);
+		ed_writeb(sc, sc->asic_addr + ED_WD790_HWR,
+		    ed_readb(sc, sc->asic_addr + ED_WD790_HWR) & ~ED_WD790_HWR_SWH);
 
 		isa16bit = 1;
 		sc->chip_type = ED_CHIP_TYPE_WD790;
@@ -364,7 +426,7 @@ ed_probe_WD80x3(dev)
 	 */
 	if (isa16bit && (sc->type != ED_TYPE_WD8013EBT)
 	  && (sc->type != ED_TYPE_TOSHIBA1) && (sc->type != ED_TYPE_TOSHIBA4)
-	    && ((inb(sc->asic_addr + ED_WD_ICR) & ED_WD_ICR_16BIT) == 0)) {
+	    && ((ed_readb(sc, sc->asic_addr + ED_WD_ICR) & ED_WD_ICR_16BIT) == 0)) {
 		isa16bit = 0;
 		memsize = 8192;
 	}
@@ -378,7 +440,7 @@ ed_probe_WD80x3(dev)
 	printf("type = %x type_str=%s isa16bit=%d memsize=%d id_msize=%d\n",
 	       sc->type, sc->type_str, isa16bit, memsize, conf_msize);
 	for (i = 0; i < 8; i++)
-		printf("%x -> %x\n", i, inb(sc->asic_addr + i));
+		printf("%x -> %x\n", i, ed_readb(sc, sc->asic_addr + i));
 #endif
 
 	/*
@@ -412,8 +474,8 @@ ed_probe_WD80x3(dev)
 		/*
 		 * Assemble together the encoded interrupt number.
 		 */
-		iptr = (inb(sc->asic_addr + ED_WD_ICR) & ED_WD_ICR_IR2) |
-		    ((inb(sc->asic_addr + ED_WD_IRR) &
+		iptr = (ed_readb(sc, sc->asic_addr + ED_WD_ICR) & ED_WD_ICR_IR2) |
+		    ((ed_readb(sc, sc->asic_addr + ED_WD_IRR) &
 		      (ED_WD_IRR_IR0 | ED_WD_IRR_IR1)) >> 5);
 
 		/*
@@ -429,17 +491,17 @@ ed_probe_WD80x3(dev)
 		/*
 		 * Enable the interrupt.
 		 */
-		outb(sc->asic_addr + ED_WD_IRR,
-		     inb(sc->asic_addr + ED_WD_IRR) | ED_WD_IRR_IEN);
+		ed_writeb(sc, sc->asic_addr + ED_WD_IRR,
+		     ed_readb(sc, sc->asic_addr + ED_WD_IRR) | ED_WD_IRR_IEN);
 	}
 	if (sc->chip_type == ED_CHIP_TYPE_WD790) {
-		outb(sc->asic_addr + ED_WD790_HWR,
-		  inb(sc->asic_addr + ED_WD790_HWR) | ED_WD790_HWR_SWH);
-		iptr = (((inb(sc->asic_addr + ED_WD790_GCR) & ED_WD790_GCR_IR2) >> 4) |
-			(inb(sc->asic_addr + ED_WD790_GCR) &
+		ed_writeb(sc, sc->asic_addr + ED_WD790_HWR,
+		  ed_readb(sc, sc->asic_addr + ED_WD790_HWR) | ED_WD790_HWR_SWH);
+		iptr = (((ed_readb(sc, sc->asic_addr + ED_WD790_GCR) & ED_WD790_GCR_IR2) >> 4) |
+			(ed_readb(sc, sc->asic_addr + ED_WD790_GCR) &
 			 (ED_WD790_GCR_IR1 | ED_WD790_GCR_IR0)) >> 2);
-		outb(sc->asic_addr + ED_WD790_HWR,
-		 inb(sc->asic_addr + ED_WD790_HWR) & ~ED_WD790_HWR_SWH);
+		ed_writeb(sc, sc->asic_addr + ED_WD790_HWR,
+		 ed_readb(sc, sc->asic_addr + ED_WD790_HWR) & ~ED_WD790_HWR_SWH);
 
 		/*
 		 * If no interrupt specified (or "?"), use what the board tells us.
@@ -454,8 +516,8 @@ ed_probe_WD80x3(dev)
 		/*
 		 * Enable interrupts.
 		 */
-		outb(sc->asic_addr + ED_WD790_ICR,
-		  inb(sc->asic_addr + ED_WD790_ICR) | ED_WD790_ICR_EIL);
+		ed_writeb(sc, sc->asic_addr + ED_WD790_ICR,
+		  ed_readb(sc, sc->asic_addr + ED_WD790_ICR) | ED_WD790_ICR_EIL);
 	}
 	error = bus_get_resource(dev, SYS_RES_IRQ, 0,
 				 &irq, &junk);
@@ -472,7 +534,7 @@ ed_probe_WD80x3(dev)
 		printf("*** ed_alloc_memory() failed! (%d)\n", error);
 		return (error);
 	}
-	sc->mem_start = (caddr_t) rman_get_virtual(sc->mem_res);
+	sc->mem_start = rman_get_start(sc->mem_res);
 
 	/*
 	 * allocate one xmit buffer if < 16k, two buffers otherwise
@@ -494,30 +556,31 @@ ed_probe_WD80x3(dev)
 	 * Get station address from on-board ROM
 	 */
 	for (i = 0; i < ETHER_ADDR_LEN; ++i)
-		sc->arpcom.ac_enaddr[i] = inb(sc->asic_addr + ED_WD_PROM + i);
+		sc->arpcom.ac_enaddr[i] = ed_readb(sc, sc->asic_addr + ED_WD_PROM + i);
 
 	/*
 	 * Set upper address bits and 8/16 bit access to shared memory.
 	 */
 	if (isa16bit) {
 		if (sc->chip_type == ED_CHIP_TYPE_WD790) {
-			sc->wd_laar_proto = inb(sc->asic_addr + ED_WD_LAAR);
+			sc->wd_laar_proto = ed_readb(sc,
+			    sc->asic_addr + ED_WD_LAAR);
 		} else {
 			sc->wd_laar_proto = ED_WD_LAAR_L16EN |
-			    ((kvtop(sc->mem_start) >> 19) & ED_WD_LAAR_ADDRHI);
+			    ((sc->mem_start >> 19) & ED_WD_LAAR_ADDRHI);
 		}
 		/*
 		 * Enable 16bit access
 		 */
-		outb(sc->asic_addr + ED_WD_LAAR, sc->wd_laar_proto |
+		ed_writeb(sc, sc->asic_addr + ED_WD_LAAR, sc->wd_laar_proto |
 		    ED_WD_LAAR_M16EN);
 	} else {
 		if (((sc->type & ED_WD_SOFTCONFIG) ||
 		    (sc->type == ED_TYPE_TOSHIBA1) || (sc->type == ED_TYPE_TOSHIBA4) ||
 		    (sc->type == ED_TYPE_WD8013EBT)) && (sc->chip_type != ED_CHIP_TYPE_WD790)) {
-			sc->wd_laar_proto = (kvtop(sc->mem_start) >> 19) &
+			sc->wd_laar_proto = (sc->mem_start >> 19) &
 			    ED_WD_LAAR_ADDRHI;
-			outb(sc->asic_addr + ED_WD_LAAR, sc->wd_laar_proto);
+			ed_writeb(sc, sc->asic_addr + ED_WD_LAAR, sc->wd_laar_proto);
 		}
 	}
 
@@ -526,26 +589,24 @@ ed_probe_WD80x3(dev)
 	 */
 	if (sc->chip_type != ED_CHIP_TYPE_WD790) {
 		if (ED_FLAGS_GETTYPE(flags) == ED_FLAGS_TOSH_ETHER) {
-			outb(sc->asic_addr + ED_WD_MSR + 1,
-			     ((kvtop(sc->mem_start) >> 8) & 0xe0) | 4);
-			outb(sc->asic_addr + ED_WD_MSR + 2,
-			     ((kvtop(sc->mem_start) >> 16) & 0x0f));
-			outb(sc->asic_addr + ED_WD_MSR,
-			     ED_WD_MSR_MENB | ED_WD_MSR_POW);
-		}
-		else {
-			outb(sc->asic_addr + ED_WD_MSR,
-			     ((kvtop(sc->mem_start) >> 13) & 
-			      ED_WD_MSR_ADDR) | ED_WD_MSR_MENB);
+			ed_writeb(sc, sc->asic_addr + ED_WD_MSR + 1,
+			    ((sc->mem_start >> 8) & 0xe0) | 4);
+			ed_writeb(sc, sc->asic_addr + ED_WD_MSR + 2,
+			    ((sc->mem_start >> 16) & 0x0f));
+			ed_writeb(sc, sc->asic_addr + ED_WD_MSR,
+			    ED_WD_MSR_MENB | ED_WD_MSR_POW);
+		} else {
+			ed_writeb(sc, sc->asic_addr + ED_WD_MSR,
+			    ((sc->mem_start >> 13) & 
+			    ED_WD_MSR_ADDR) | ED_WD_MSR_MENB);
 		}
-		sc->cr_proto = ED_CR_RD2;
 	} else {
-		outb(sc->asic_addr + ED_WD_MSR, ED_WD_MSR_MENB);
-		outb(sc->asic_addr + ED_WD790_HWR, (inb(sc->asic_addr + ED_WD790_HWR) | ED_WD790_HWR_SWH));
-		outb(sc->asic_addr + ED_WD790_RAR, ((kvtop(sc->mem_start) >> 13) & 0x0f) |
-		     ((kvtop(sc->mem_start) >> 11) & 0x40) |
-		     (inb(sc->asic_addr + ED_WD790_RAR) & 0xb0));
-		outb(sc->asic_addr + ED_WD790_HWR, (inb(sc->asic_addr + ED_WD790_HWR) & ~ED_WD790_HWR_SWH));
+		ed_writeb(sc, sc->asic_addr + ED_WD_MSR, ED_WD_MSR_MENB);
+		ed_writeb(sc, sc->asic_addr + ED_WD790_HWR, (ed_readb(sc, sc->asic_addr + ED_WD790_HWR) | ED_WD790_HWR_SWH));
+		ed_writeb(sc, sc->asic_addr + ED_WD790_RAR, ((sc->mem_start >> 13) & 0x0f) |
+		     ((sc->mem_start >> 11) & 0x40) |
+		     (ed_readb(sc, sc->asic_addr + ED_WD790_RAR) & 0xb0));
+		ed_writeb(sc, sc->asic_addr + ED_WD790_HWR, (ed_readb(sc, sc->asic_addr + ED_WD790_HWR) & ~ED_WD790_HWR_SWH));
 		sc->cr_proto = 0;
 	}
 
@@ -553,28 +614,30 @@ ed_probe_WD80x3(dev)
 	printf("starting memory performance test at 0x%x, size %d...\n",
 		sc->mem_start, memsize*16384);
 	for (i = 0; i < 16384; i++)
-		bzero(sc->mem_start, memsize);
+		bus_space_set_multi_1(sc->bst, sc->bsh, sc->mem_start,
+		    0x0, memsize);
 	printf("***DONE***\n");
 #endif
 
 	/*
 	 * Now zero memory and verify that it is clear
 	 */
-	bzero(sc->mem_start, memsize);
+	bus_space_set_multi_1(sc->bst, sc->bsh, sc->mem_start,
+	    0x0, memsize);
 
 	for (i = 0; i < memsize; ++i) {
-		if (sc->mem_start[i]) {
+		if (ed_readb(sc, sc->mem_start + i) != 0) {
 			device_printf(dev, "failed to clear shared memory at %lx - check configuration\n",
-				      kvtop(sc->mem_start + i));
+				      sc->mem_start + i);
 
 			/*
 			 * Disable 16 bit access to shared memory
 			 */
 			if (isa16bit) {
 				if (sc->chip_type == ED_CHIP_TYPE_WD790) {
-					outb(sc->asic_addr + ED_WD_MSR, 0x00);
+					ed_writeb(sc, sc->asic_addr + ED_WD_MSR, 0x00);
 				}
-				outb(sc->asic_addr + ED_WD_LAAR, sc->wd_laar_proto &
+				ed_writeb(sc, sc->asic_addr + ED_WD_LAAR, sc->wd_laar_proto &
 				    ~ED_WD_LAAR_M16EN);
 			}
 			return (ENXIO);
@@ -591,9 +654,9 @@ ed_probe_WD80x3(dev)
 	 */
 	if (isa16bit) {
 		if (sc->chip_type == ED_CHIP_TYPE_WD790) {
-			outb(sc->asic_addr + ED_WD_MSR, 0x00);
+			ed_writeb(sc, sc->asic_addr + ED_WD_MSR, 0x00);
 		}
-		outb(sc->asic_addr + ED_WD_LAAR, sc->wd_laar_proto &
+		ed_writeb(sc, sc->asic_addr + ED_WD_LAAR, sc->wd_laar_proto &
 		    ~ED_WD_LAAR_M16EN);
 	}
 	return (0);
@@ -625,7 +688,7 @@ ed_probe_3Com(dev)
 	 * Verify that the kernel configured I/O address matches the board
 	 * configured address
 	 */
-	switch (inb(sc->asic_addr + ED_3COM_BCFR)) {
+	switch (ed_readb(sc, sc->asic_addr + ED_3COM_BCFR)) {
 	case ED_3COM_BCFR_300:
 		if (rman_get_start(sc->port_res) != 0x300)
 			return (ENXIO);
@@ -671,7 +734,7 @@ ed_probe_3Com(dev)
 	 * Verify that the kernel shared memory address matches the board
 	 * configured address.
 	 */
-	switch (inb(sc->asic_addr + ED_3COM_PCFR)) {
+	switch (ed_readb(sc, sc->asic_addr + ED_3COM_PCFR)) {
 	case ED_3COM_PCFR_DC000:
 		if (conf_maddr != 0xdc000)
 			return (ENXIO);
@@ -698,7 +761,7 @@ ed_probe_3Com(dev)
 	 * sequence because it'll lock up if the cable isn't connected if we
 	 * don't.
 	 */
-	outb(sc->asic_addr + ED_3COM_CR, ED_3COM_CR_RST | ED_3COM_CR_XSEL);
+	ed_writeb(sc, sc->asic_addr + ED_3COM_CR, ED_3COM_CR_RST | ED_3COM_CR_XSEL);
 
 	/*
 	 * Wait for a while, then un-reset it
@@ -707,10 +770,10 @@ ed_probe_3Com(dev)
 
 	/*
 	 * The 3Com ASIC defaults to rather strange settings for the CR after
-	 * a reset - it's important to set it again after the following outb
-	 * (this is done when we map the PROM below).
+	 * a reset - it's important to set it again after the following 
+	 * ed_writeb (this is done when we map the PROM below).
 	 */
-	outb(sc->asic_addr + ED_3COM_CR, ED_3COM_CR_XSEL);
+	ed_writeb(sc, sc->asic_addr + ED_3COM_CR, ED_3COM_CR_XSEL);
 
 	/*
 	 * Wait a bit for the NIC to recover from the reset
@@ -736,17 +799,17 @@ ed_probe_3Com(dev)
 	 * First, map ethernet address PROM over the top of where the NIC
 	 * registers normally appear.
 	 */
-	outb(sc->asic_addr + ED_3COM_CR, ED_3COM_CR_EALO | ED_3COM_CR_XSEL);
+	ed_writeb(sc, sc->asic_addr + ED_3COM_CR, ED_3COM_CR_EALO | ED_3COM_CR_XSEL);
 
 	for (i = 0; i < ETHER_ADDR_LEN; ++i)
-		sc->arpcom.ac_enaddr[i] = inb(sc->nic_addr + i);
+		sc->arpcom.ac_enaddr[i] = ed_readb(sc, sc->nic_addr + i);
 
 	/*
 	 * Unmap PROM - select NIC registers. The proper setting of the
 	 * tranceiver is set in ed_init so that the attach code is given a
 	 * chance to set the default based on a compile-time config option
 	 */
-	outb(sc->asic_addr + ED_3COM_CR, ED_3COM_CR_XSEL);
+	ed_writeb(sc, sc->asic_addr + ED_3COM_CR, ED_3COM_CR_XSEL);
 
 	/*
 	 * Determine if this is an 8bit or 16bit board
@@ -755,23 +818,23 @@ ed_probe_3Com(dev)
 	/*
 	 * select page 0 registers
 	 */
-	outb(sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STP);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STP);
 
 	/*
 	 * Attempt to clear WTS bit. If it doesn't clear, then this is a 16bit
 	 * board.
 	 */
-	outb(sc->nic_addr + ED_P0_DCR, 0);
+	ed_writeb(sc, sc->nic_addr + ED_P0_DCR, 0);
 
 	/*
 	 * select page 2 registers
 	 */
-	outb(sc->nic_addr + ED_P0_CR, ED_CR_PAGE_2 | ED_CR_RD2 | ED_CR_STP);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, ED_CR_PAGE_2 | ED_CR_RD2 | ED_CR_STP);
 
 	/*
 	 * The 3c503 forces the WTS bit to a one if this is a 16bit board
 	 */
-	if (inb(sc->nic_addr + ED_P2_DCR) & ED_DCR_WTS)
+	if (ed_readb(sc, sc->nic_addr + ED_P2_DCR) & ED_DCR_WTS)
 		isa16bit = 1;
 	else
 		isa16bit = 0;
@@ -779,13 +842,13 @@ ed_probe_3Com(dev)
 	/*
 	 * select page 0 registers
 	 */
-	outb(sc->nic_addr + ED_P2_CR, ED_CR_RD2 | ED_CR_STP);
+	ed_writeb(sc, sc->nic_addr + ED_P2_CR, ED_CR_RD2 | ED_CR_STP);
 
 	error = ed_alloc_memory(dev, 0, memsize);
 	if (error)
 		return (error);
 
-	sc->mem_start = (caddr_t) rman_get_virtual(sc->mem_res);
+	sc->mem_start = rman_get_start(sc->mem_res);
 	sc->mem_size = memsize;
 	sc->mem_end = sc->mem_start + memsize;
 
@@ -824,8 +887,8 @@ ed_probe_3Com(dev)
 	 * Initialize GA page start/stop registers. Probably only needed if
 	 * doing DMA, but what the hell.
 	 */
-	outb(sc->asic_addr + ED_3COM_PSTR, sc->rec_page_start);
-	outb(sc->asic_addr + ED_3COM_PSPR, sc->rec_page_stop);
+	ed_writeb(sc, sc->asic_addr + ED_3COM_PSTR, sc->rec_page_start);
+	ed_writeb(sc, sc->asic_addr + ED_3COM_PSPR, sc->rec_page_stop);
 
 	/*
 	 * Set IRQ. 3c503 only allows a choice of irq 2-5.
@@ -838,16 +901,16 @@ ed_probe_3Com(dev)
 	switch (irq) {
 	case 2:
 	case 9:
-		outb(sc->asic_addr + ED_3COM_IDCFR, ED_3COM_IDCFR_IRQ2);
+		ed_writeb(sc, sc->asic_addr + ED_3COM_IDCFR, ED_3COM_IDCFR_IRQ2);
 		break;
 	case 3:
-		outb(sc->asic_addr + ED_3COM_IDCFR, ED_3COM_IDCFR_IRQ3);
+		ed_writeb(sc, sc->asic_addr + ED_3COM_IDCFR, ED_3COM_IDCFR_IRQ3);
 		break;
 	case 4:
-		outb(sc->asic_addr + ED_3COM_IDCFR, ED_3COM_IDCFR_IRQ4);
+		ed_writeb(sc, sc->asic_addr + ED_3COM_IDCFR, ED_3COM_IDCFR_IRQ4);
 		break;
 	case 5:
-		outb(sc->asic_addr + ED_3COM_IDCFR, ED_3COM_IDCFR_IRQ5);
+		ed_writeb(sc, sc->asic_addr + ED_3COM_IDCFR, ED_3COM_IDCFR_IRQ5);
 		break;
 	default:
 		device_printf(dev, "Invalid irq configuration (%ld) must be 3-5,9 for 3c503\n",
@@ -859,7 +922,7 @@ ed_probe_3Com(dev)
 	 * Initialize GA configuration register. Set bank and enable shared
 	 * mem.
 	 */
-	outb(sc->asic_addr + ED_3COM_GACFR, ED_3COM_GACFR_RSEL |
+	ed_writeb(sc, sc->asic_addr + ED_3COM_GACFR, ED_3COM_GACFR_RSEL |
 	     ED_3COM_GACFR_MBS0);
 
 	/*
@@ -868,19 +931,19 @@ ed_probe_3Com(dev)
 	 * shared memory is disabled. We set them to 0xffff0...allegedly the
 	 * reset vector.
 	 */
-	outb(sc->asic_addr + ED_3COM_VPTR2, 0xff);
-	outb(sc->asic_addr + ED_3COM_VPTR1, 0xff);
-	outb(sc->asic_addr + ED_3COM_VPTR0, 0x00);
+	ed_writeb(sc, sc->asic_addr + ED_3COM_VPTR2, 0xff);
+	ed_writeb(sc, sc->asic_addr + ED_3COM_VPTR1, 0xff);
+	ed_writeb(sc, sc->asic_addr + ED_3COM_VPTR0, 0x00);
 
 	/*
 	 * Zero memory and verify that it is clear
 	 */
-	bzero(sc->mem_start, memsize);
+	bus_space_set_multi_1(sc->bst, sc->bsh, sc->mem_start, 0x0, memsize);
 
 	for (i = 0; i < memsize; ++i)
-		if (sc->mem_start[i]) {
+		if (ed_readb(sc, sc->mem_start + i) != 0) {
 			device_printf(dev, "failed to clear shared memory at %lx - check configuration\n",
-				      kvtop(sc->mem_start + i));
+				      sc->mem_start + i);
 			return (ENXIO);
 		}
 	return (0);
@@ -909,14 +972,14 @@ ed_get_Linksys(sc)
 	 * 0x0B      : Check Sum Register (SR)
 	 */
 	for (sum = 0, i = 0x04; i < 0x0c; i++)
-		sum += inb(sc->asic_addr + i);
+		sum += ed_readb(sc, sc->asic_addr + i);
 	if (sum != 0xff)
 		return (0);		/* invalid DL10019C */
 	for (i = 0; i < ETHER_ADDR_LEN; i++) {
-		sc->arpcom.ac_enaddr[i] = inb(sc->asic_addr + 0x04 + i);
+		sc->arpcom.ac_enaddr[i] = ed_readb(sc, sc->asic_addr + 0x04 + i);
 	}
 
-	outb(sc->nic_addr + ED_P0_DCR, ED_DCR_WTS | ED_DCR_FT1 | ED_DCR_LS);
+	ed_writeb(sc, sc->nic_addr + ED_P0_DCR, ED_DCR_WTS | ED_DCR_FT1 | ED_DCR_LS);
 	sc->isa16bit = 1;
 	sc->type = ED_TYPE_NE2000;
 	sc->type_str = "Linksys";
@@ -950,20 +1013,20 @@ ed_probe_Novell_generic(dev, port_rid, flags)
 
 	/* Reset the board */
 	if (ED_FLAGS_GETTYPE(flags) == ED_FLAGS_GWETHER) {
-		outb(sc->asic_addr + ED_NOVELL_RESET, 0);
+		ed_writeb(sc, sc->asic_addr + ED_NOVELL_RESET, 0);
 		DELAY(200);
 	}
-	tmp = inb(sc->asic_addr + ED_NOVELL_RESET);
+	tmp = ed_readb(sc, sc->asic_addr + ED_NOVELL_RESET);
 
 	/*
 	 * I don't know if this is necessary; probably cruft leftover from
 	 * Clarkson packet driver code. Doesn't do a thing on the boards I've
-	 * tested. -DG [note that a outb(0x84, 0) seems to work here, and is
+	 * tested. -DG [note that a ed_writeb(sc, 0x84, 0) seems to work here, and is
 	 * non-invasive...but some boards don't seem to reset and I don't have
 	 * complete documentation on what the 'right' thing to do is...so we
 	 * do the invasive thing for now. Yuck.]
 	 */
-	outb(sc->asic_addr + ED_NOVELL_RESET, tmp);
+	ed_writeb(sc, sc->asic_addr + ED_NOVELL_RESET, tmp);
 	DELAY(5000);
 
 	/*
@@ -972,7 +1035,7 @@ ed_probe_Novell_generic(dev, port_rid, flags)
 	 * - this makes the probe invasive! ...Done against my better
 	 * judgement. -DLG
 	 */
-	outb(sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STP);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STP);
 
 	DELAY(5000);
 
@@ -993,13 +1056,13 @@ ed_probe_Novell_generic(dev, port_rid, flags)
 	 * This prevents packets from being stored in the NIC memory when the
 	 * readmem routine turns on the start bit in the CR.
 	 */
-	outb(sc->nic_addr + ED_P0_RCR, ED_RCR_MON);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RCR, ED_RCR_MON);
 
 	/* Temporarily initialize DCR for byte operations */
-	outb(sc->nic_addr + ED_P0_DCR, ED_DCR_FT1 | ED_DCR_LS);
+	ed_writeb(sc, sc->nic_addr + ED_P0_DCR, ED_DCR_FT1 | ED_DCR_LS);
 
-	outb(sc->nic_addr + ED_P0_PSTART, 8192 / ED_PAGE_SIZE);
-	outb(sc->nic_addr + ED_P0_PSTOP, 16384 / ED_PAGE_SIZE);
+	ed_writeb(sc, sc->nic_addr + ED_P0_PSTART, 8192 / ED_PAGE_SIZE);
+	ed_writeb(sc, sc->nic_addr + ED_P0_PSTOP, 16384 / ED_PAGE_SIZE);
 
 	sc->isa16bit = 0;
 
@@ -1017,9 +1080,9 @@ ed_probe_Novell_generic(dev, port_rid, flags)
 	} else {
 
 		/* neither an NE1000 nor a Linksys - try NE2000 */
-		outb(sc->nic_addr + ED_P0_DCR, ED_DCR_WTS | ED_DCR_FT1 | ED_DCR_LS);
-		outb(sc->nic_addr + ED_P0_PSTART, 16384 / ED_PAGE_SIZE);
-		outb(sc->nic_addr + ED_P0_PSTOP, 32768 / ED_PAGE_SIZE);
+		ed_writeb(sc, sc->nic_addr + ED_P0_DCR, ED_DCR_WTS | ED_DCR_FT1 | ED_DCR_LS);
+		ed_writeb(sc, sc->nic_addr + ED_P0_PSTART, 16384 / ED_PAGE_SIZE);
+		ed_writeb(sc, sc->nic_addr + ED_P0_PSTOP, 32768 / ED_PAGE_SIZE);
 
 		sc->isa16bit = 1;
 
@@ -1051,7 +1114,7 @@ ed_probe_Novell_generic(dev, port_rid, flags)
 
 	/* NIC memory doesn't start at zero on an NE board */
 	/* The start address is tied to the bus width */
-	sc->mem_start = (char *) 8192 + sc->isa16bit * 8192;
+	sc->mem_start = (u_long) ((char *) 8192 + sc->isa16bit * 8192);
 	sc->mem_end = sc->mem_start + memsize;
 	sc->tx_page_start = memsize / ED_PAGE_SIZE;
 
@@ -1112,8 +1175,8 @@ ed_probe_Novell_generic(dev, port_rid, flags)
 		device_printf(dev, "RAM start at %d, size : %d.\n", mstart, msize);
 
 		sc->mem_size = msize;
-		sc->mem_start = (char *) mstart;
-		sc->mem_end = (char *) (msize + mstart);
+		sc->mem_start = (u_long) mstart;
+		sc->mem_end = (u_long) (msize + mstart);
 		sc->tx_page_start = mstart / ED_PAGE_SIZE;
 	}
 
@@ -1141,7 +1204,7 @@ ed_probe_Novell_generic(dev, port_rid, flags)
 	}
 
 	/* clear any pending interrupts that might have occurred above */
-	outb(sc->nic_addr + ED_P0_ISR, 0xff);
+	ed_writeb(sc, sc->nic_addr + ED_P0_ISR, 0xff);
 
 	return (0);
 }
@@ -1205,22 +1268,22 @@ ed_probe_HP_pclanp(dev)
 	 * Look for the HP PCLAN+ signature: "0x50,0x48,0x00,0x53" 
 	 */
 	
-	if ((inb(sc->asic_addr + ED_HPP_ID) != 0x50) || 
-	    (inb(sc->asic_addr + ED_HPP_ID + 1) != 0x48) ||
-	    ((inb(sc->asic_addr + ED_HPP_ID + 2) & 0xF0) != 0) ||
-	    (inb(sc->asic_addr + ED_HPP_ID + 3) != 0x53))
+	if ((ed_readb(sc, sc->asic_addr + ED_HPP_ID) != 0x50) || 
+	    (ed_readb(sc, sc->asic_addr + ED_HPP_ID + 1) != 0x48) ||
+	    ((ed_readb(sc, sc->asic_addr + ED_HPP_ID + 2) & 0xF0) != 0) ||
+	    (ed_readb(sc, sc->asic_addr + ED_HPP_ID + 3) != 0x53))
 		return ENXIO;
 
 	/* 
 	 * Read the MAC address and verify checksum on the address.
 	 */
 
-	outw(sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_MAC);
+	ed_writew(sc, sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_MAC);
 	for (n  = 0, checksum = 0; n < ETHER_ADDR_LEN; n++)
 		checksum += (sc->arpcom.ac_enaddr[n] = 
-			inb(sc->asic_addr + ED_HPP_MAC_ADDR + n));
+			ed_readb(sc, sc->asic_addr + ED_HPP_MAC_ADDR + n));
 	
-	checksum += inb(sc->asic_addr + ED_HPP_MAC_ADDR + ETHER_ADDR_LEN);
+	checksum += ed_readb(sc, sc->asic_addr + ED_HPP_MAC_ADDR + ETHER_ADDR_LEN);
 
 	if (checksum != 0xFF)
 		return ENXIO;
@@ -1229,8 +1292,8 @@ ed_probe_HP_pclanp(dev)
 	 * Verify that the software model number is 0.
 	 */
 	
-	outw(sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_ID);
-	if (((sc->hpp_id = inw(sc->asic_addr + ED_HPP_PAGE_4)) & 
+	ed_writew(sc, sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_ID);
+	if (((sc->hpp_id = ed_readw(sc, sc->asic_addr + ED_HPP_PAGE_4)) & 
 		ED_HPP_ID_SOFT_MODEL_MASK) != 0x0000)
 		return ENXIO;
 
@@ -1238,7 +1301,7 @@ ed_probe_HP_pclanp(dev)
 	 * Read in and save the current options configured on card.
 	 */
 
-	sc->hpp_options = inw(sc->asic_addr + ED_HPP_OPTION);
+	sc->hpp_options = ed_readw(sc, sc->asic_addr + ED_HPP_OPTION);
 
 	sc->hpp_options |= (ED_HPP_OPTION_NIC_RESET | 
                         	ED_HPP_OPTION_CHIP_RESET |
@@ -1249,29 +1312,29 @@ ed_probe_HP_pclanp(dev)
 	 * so take care to preserve the other bits.
 	 */
 
-	outw(sc->asic_addr + ED_HPP_OPTION, 
+	ed_writew(sc, sc->asic_addr + ED_HPP_OPTION, 
 		(sc->hpp_options & ~(ED_HPP_OPTION_NIC_RESET | 
 			ED_HPP_OPTION_CHIP_RESET)));
 
 	DELAY(5000);	/* wait for chip reset to complete */
 
-	outw(sc->asic_addr + ED_HPP_OPTION,
+	ed_writew(sc, sc->asic_addr + ED_HPP_OPTION,
 		(sc->hpp_options | (ED_HPP_OPTION_NIC_RESET |
 			ED_HPP_OPTION_CHIP_RESET |
 			ED_HPP_OPTION_ENABLE_IRQ)));
 
 	DELAY(5000);
 
-	if (!(inb(sc->nic_addr + ED_P0_ISR) & ED_ISR_RST))
+	if (!(ed_readb(sc, sc->nic_addr + ED_P0_ISR) & ED_ISR_RST))
 		return ENXIO;	/* reset did not complete */
 
 	/*
 	 * Read out configuration information.
 	 */
 
-	outw(sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_HW);
+	ed_writew(sc, sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_HW);
 
-	irq = inb(sc->asic_addr + ED_HPP_HW_IRQ);
+	irq = ed_readb(sc, sc->asic_addr + ED_HPP_HW_IRQ);
 
 	/*
  	 * Check for impossible IRQ.
@@ -1327,8 +1390,8 @@ ed_probe_HP_pclanp(dev)
 		 * determine the memory address from the board.
 		 */
 		
-		outw(sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_HW);
-		mem_addr = (inw(sc->asic_addr + ED_HPP_HW_MEM_MAP) << 8);
+		ed_writew(sc, sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_HW);
+		mem_addr = (ed_readw(sc, sc->asic_addr + ED_HPP_HW_MEM_MAP) << 8);
 
 		/*
 		 * Check that the kernel specified start of memory and
@@ -1346,7 +1409,7 @@ ed_probe_HP_pclanp(dev)
 		if (error)
 			return (error);
 
-		sc->hpp_mem_start = rman_get_virtual(sc->mem_res);
+		sc->hpp_mem_start = rman_get_start(sc->mem_res);
 	}
 
 	/*
@@ -1389,8 +1452,8 @@ ed_probe_HP_pclanp(dev)
 	 * Set the wrap registers for string I/O reads.
 	 */
 
-	outw(sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_HW);
-	outw(sc->asic_addr + ED_HPP_HW_WRAP,
+	ed_writew(sc, sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_HW);
+	ed_writew(sc, sc->asic_addr + ED_HPP_HW_WRAP,
 		((sc->rec_page_start / ED_PAGE_SIZE) |
 		 (((sc->rec_page_stop / ED_PAGE_SIZE) - 1) << 8)));
 
@@ -1398,7 +1461,7 @@ ed_probe_HP_pclanp(dev)
 	 * Reset the register page to normal operation.
 	 */
 
-	outw(sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_PERF);
+	ed_writew(sc, sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_PERF);
 
 	/*
 	 * Verify that we can read/write from adapter memory.
@@ -1445,8 +1508,8 @@ ed_hpp_set_physical_link(struct ed_softc *sc)
 	struct ifnet *ifp = &sc->arpcom.ac_if;
 	int lan_page;
 
-	outw(sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_LAN);
-	lan_page = inw(sc->asic_addr + ED_HPP_PAGE_0);
+	ed_writew(sc, sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_LAN);
+	lan_page = ed_readw(sc, sc->asic_addr + ED_HPP_PAGE_0);
 
 	if (ifp->if_flags & IFF_ALTPHYS) {
 
@@ -1456,8 +1519,8 @@ ed_hpp_set_physical_link(struct ed_softc *sc)
 
 		lan_page |= ED_HPP_LAN_AUI;
 
-		outw(sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_LAN);
-		outw(sc->asic_addr + ED_HPP_PAGE_0, lan_page);
+		ed_writew(sc, sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_LAN);
+		ed_writew(sc, sc->asic_addr + ED_HPP_PAGE_0, lan_page);
 
 
 	} else {
@@ -1468,8 +1531,8 @@ ed_hpp_set_physical_link(struct ed_softc *sc)
 
 		lan_page &= ~ED_HPP_LAN_AUI;
 
-		outw(sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_LAN);
-		outw(sc->asic_addr + ED_HPP_PAGE_0, lan_page);
+		ed_writew(sc, sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_LAN);
+		ed_writew(sc, sc->asic_addr + ED_HPP_PAGE_0, lan_page);
 
 	}
 
@@ -1483,7 +1546,7 @@ ed_hpp_set_physical_link(struct ed_softc *sc)
 	 * Restore normal pages.
 	 */
 
-	outw(sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_PERF);
+	ed_writew(sc, sc->asic_addr + ED_HPP_PAGING, ED_HPP_PAGE_PERF);
 
 }
 
@@ -1708,7 +1771,7 @@ ed_stop(sc)
 	/*
 	 * Stop everything on the interface, and select page 0 registers.
 	 */
-	outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STP);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STP);
 
 	/*
 	 * Wait for interface to enter stopped state, but limit # of checks to
@@ -1716,7 +1779,7 @@ ed_stop(sc)
 	 * just in case it's an old one.
 	 */
 	if (sc->chip_type != ED_CHIP_TYPE_AX88190)
-		while (((inb(sc->nic_addr + ED_P0_ISR) & ED_ISR_RST) == 0) && --n);
+		while (((ed_readb(sc, sc->nic_addr + ED_P0_ISR) & ED_ISR_RST) == 0) && --n);
 }
 
 /*
@@ -1776,7 +1839,7 @@ ed_init(xsc)
 	/*
 	 * Set interface for page 0, Remote DMA complete, Stopped
 	 */
-	outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STP);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STP);
 
 	if (sc->isa16bit) {
 
@@ -1784,51 +1847,51 @@ ed_init(xsc)
 		 * Set FIFO threshold to 8, No auto-init Remote DMA, byte
 		 * order=80x86, word-wide DMA xfers,
 		 */
-		outb(sc->nic_addr + ED_P0_DCR, ED_DCR_FT1 | ED_DCR_WTS | ED_DCR_LS);
+		ed_writeb(sc, sc->nic_addr + ED_P0_DCR, ED_DCR_FT1 | ED_DCR_WTS | ED_DCR_LS);
 	} else {
 
 		/*
 		 * Same as above, but byte-wide DMA xfers
 		 */
-		outb(sc->nic_addr + ED_P0_DCR, ED_DCR_FT1 | ED_DCR_LS);
+		ed_writeb(sc, sc->nic_addr + ED_P0_DCR, ED_DCR_FT1 | ED_DCR_LS);
 	}
 
 	/*
 	 * Clear Remote Byte Count Registers
 	 */
-	outb(sc->nic_addr + ED_P0_RBCR0, 0);
-	outb(sc->nic_addr + ED_P0_RBCR1, 0);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RBCR0, 0);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RBCR1, 0);
 
 	/*
 	 * For the moment, don't store incoming packets in memory.
 	 */
-	outb(sc->nic_addr + ED_P0_RCR, ED_RCR_MON);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RCR, ED_RCR_MON);
 
 	/*
 	 * Place NIC in internal loopback mode
 	 */
-	outb(sc->nic_addr + ED_P0_TCR, ED_TCR_LB0);
+	ed_writeb(sc, sc->nic_addr + ED_P0_TCR, ED_TCR_LB0);
 
 	/*
 	 * Initialize transmit/receive (ring-buffer) Page Start
 	 */
-	outb(sc->nic_addr + ED_P0_TPSR, sc->tx_page_start);
-	outb(sc->nic_addr + ED_P0_PSTART, sc->rec_page_start);
+	ed_writeb(sc, sc->nic_addr + ED_P0_TPSR, sc->tx_page_start);
+	ed_writeb(sc, sc->nic_addr + ED_P0_PSTART, sc->rec_page_start);
 	/* Set lower bits of byte addressable framing to 0 */
 	if (sc->chip_type == ED_CHIP_TYPE_WD790)
-		outb(sc->nic_addr + 0x09, 0);
+		ed_writeb(sc, sc->nic_addr + 0x09, 0);
 
 	/*
 	 * Initialize Receiver (ring-buffer) Page Stop and Boundry
 	 */
-	outb(sc->nic_addr + ED_P0_PSTOP, sc->rec_page_stop);
-	outb(sc->nic_addr + ED_P0_BNRY, sc->rec_page_start);
+	ed_writeb(sc, sc->nic_addr + ED_P0_PSTOP, sc->rec_page_stop);
+	ed_writeb(sc, sc->nic_addr + ED_P0_BNRY, sc->rec_page_start);
 
 	/*
 	 * Clear all interrupts. A '1' in each bit position clears the
 	 * corresponding flag.
 	 */
-	outb(sc->nic_addr + ED_P0_ISR, 0xff);
+	ed_writeb(sc, sc->nic_addr + ED_P0_ISR, 0xff);
 
 	/*
 	 * Enable the following interrupts: receive/transmit complete,
@@ -1836,24 +1899,24 @@ ed_init(xsc)
 	 *
 	 * Counter overflow and Remote DMA complete are *not* enabled.
 	 */
-	outb(sc->nic_addr + ED_P0_IMR,
+	ed_writeb(sc, sc->nic_addr + ED_P0_IMR,
 	ED_IMR_PRXE | ED_IMR_PTXE | ED_IMR_RXEE | ED_IMR_TXEE | ED_IMR_OVWE);
 
 	/*
 	 * Program Command Register for page 1
 	 */
-	outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_PAGE_1 | ED_CR_STP);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_PAGE_1 | ED_CR_STP);
 
 	/*
 	 * Copy out our station address
 	 */
 	for (i = 0; i < ETHER_ADDR_LEN; ++i)
-		outb(sc->nic_addr + ED_P1_PAR(i), sc->arpcom.ac_enaddr[i]);
+		ed_writeb(sc, sc->nic_addr + ED_P1_PAR(i), sc->arpcom.ac_enaddr[i]);
 
 	/*
 	 * Set Current Page pointer to next_packet (initialized above)
 	 */
-	outb(sc->nic_addr + ED_P1_CURR, sc->next_packet);
+	ed_writeb(sc, sc->nic_addr + ED_P1_CURR, sc->next_packet);
 
 	/*
 	 * Program Receiver Configuration Register and multicast filter. CR is
@@ -1864,7 +1927,7 @@ ed_init(xsc)
 	/*
 	 * Take interface out of loopback
 	 */
-	outb(sc->nic_addr + ED_P0_TCR, 0);
+	ed_writeb(sc, sc->nic_addr + ED_P0_TCR, 0);
 
 	/*
 	 * If this is a 3Com board, the tranceiver must be software enabled
@@ -1872,9 +1935,9 @@ ed_init(xsc)
 	 */
 	if (sc->vendor == ED_VENDOR_3COM) {
 		if (ifp->if_flags & IFF_ALTPHYS) {
-			outb(sc->asic_addr + ED_3COM_CR, 0);
+			ed_writeb(sc, sc->asic_addr + ED_3COM_CR, 0);
 		} else {
-			outb(sc->asic_addr + ED_3COM_CR, ED_3COM_CR_XSEL);
+			ed_writeb(sc, sc->asic_addr + ED_3COM_CR, ED_3COM_CR_XSEL);
 		}
 	}
 
@@ -1909,24 +1972,24 @@ ed_xmit(sc)
 	/*
 	 * Set NIC for page 0 register access
 	 */
-	outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
 
 	/*
 	 * Set TX buffer start page
 	 */
-	outb(sc->nic_addr + ED_P0_TPSR, sc->tx_page_start +
+	ed_writeb(sc, sc->nic_addr + ED_P0_TPSR, sc->tx_page_start +
 	     sc->txb_next_tx * ED_TXBUF_SIZE);
 
 	/*
 	 * Set TX length
 	 */
-	outb(sc->nic_addr + ED_P0_TBCR0, len);
-	outb(sc->nic_addr + ED_P0_TBCR1, len >> 8);
+	ed_writeb(sc, sc->nic_addr + ED_P0_TBCR0, len);
+	ed_writeb(sc, sc->nic_addr + ED_P0_TBCR1, len >> 8);
 
 	/*
 	 * Set page 0, Remote DMA complete, Transmit Packet, and *Start*
 	 */
-	outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_TXP | ED_CR_STA);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_TXP | ED_CR_STA);
 	sc->xmit_busy = 1;
 
 	/*
@@ -1957,7 +2020,7 @@ ed_start(ifp)
 {
 	struct ed_softc *sc = ifp->if_softc;
 	struct mbuf *m0, *m;
-	caddr_t buffer;
+	u_long buffer;
 	int     len;
 
 	if (sc->gone) {
@@ -2024,7 +2087,7 @@ outloop:
 				 * change pages.
 				 */
 			case ED_VENDOR_3COM:
-				outb(sc->asic_addr + ED_3COM_GACFR,
+				ed_writeb(sc, sc->asic_addr + ED_3COM_GACFR,
 				     ED_3COM_GACFR_RSEL);
 				break;
 
@@ -2032,19 +2095,22 @@ outloop:
 				 * Enable 16bit access to shared memory on
 				 * WD/SMC boards.
 				 */
-			case ED_VENDOR_WD_SMC:{
-				outb(sc->asic_addr + ED_WD_LAAR,
-				     sc->wd_laar_proto | ED_WD_LAAR_M16EN);
-				if (sc->chip_type == ED_CHIP_TYPE_WD790) {
-					outb(sc->asic_addr + ED_WD_MSR, 
-					     ED_WD_MSR_MENB);
-				}
-					break;
-				}
+			case ED_VENDOR_WD_SMC:
+				do {
+					ed_writeb(sc,
+					    sc->asic_addr + ED_WD_LAAR,
+					    sc->wd_laar_proto | ED_WD_LAAR_M16EN);
+					if (sc->chip_type == ED_CHIP_TYPE_WD790) {
+						ed_writeb(sc,
+						    sc->asic_addr + ED_WD_MSR, 
+						    ED_WD_MSR_MENB);
+					}
+                                        break;
+				} while(0);
 			}
 		}
 		for (len = 0; m != 0; m = m->m_next) {
-			bcopy(mtod(m, caddr_t), buffer, m->m_len);
+			ed_bcopy_from(sc, mtod(m, caddr_t), buffer, m->m_len);
 			buffer += m->m_len;
 			len += m->m_len;
 		}
@@ -2055,17 +2121,20 @@ outloop:
 		if (sc->isa16bit) {
 			switch (sc->vendor) {
 			case ED_VENDOR_3COM:
-				outb(sc->asic_addr + ED_3COM_GACFR,
+				ed_writeb(sc, sc->asic_addr + ED_3COM_GACFR,
 				     ED_3COM_GACFR_RSEL | ED_3COM_GACFR_MBS0);
 				break;
-			case ED_VENDOR_WD_SMC:{
-				if (sc->chip_type == ED_CHIP_TYPE_WD790) {
-					outb(sc->asic_addr + ED_WD_MSR, 0x00);
-				}
-				outb(sc->asic_addr + ED_WD_LAAR,
-				    sc->wd_laar_proto & ~ED_WD_LAAR_M16EN);
-				break;
-				}
+			case ED_VENDOR_WD_SMC:
+				do {
+					if (sc->chip_type == ED_CHIP_TYPE_WD790) {
+						ed_writeb(sc,
+						    sc->asic_addr + ED_WD_MSR,
+						    0x00);
+					}
+					ed_writeb(sc, sc->asic_addr + ED_WD_LAAR,
+					    sc->wd_laar_proto & ~ED_WD_LAAR_M16EN);
+					break;
+				} while(0);
 			}
 		}
 	} else {
@@ -2122,7 +2191,7 @@ ed_rint(sc)
 	/*
 	 * Set NIC to page 1 registers to get 'current' pointer
 	 */
-	outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_PAGE_1 | ED_CR_STA);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_PAGE_1 | ED_CR_STA);
 
 	/*
 	 * 'sc->next_packet' is the logical beginning of the ring-buffer -
@@ -2132,10 +2201,10 @@ ed_rint(sc)
 	 * here until the logical beginning equals the logical end (or in
 	 * other words, until the ring-buffer is empty).
 	 */
-	while (sc->next_packet != inb(sc->nic_addr + ED_P1_CURR)) {
+	while (sc->next_packet != ed_readb(sc, sc->nic_addr + ED_P1_CURR)) {
 
 		/* get pointer to this buffer's header structure */
-		packet_ptr = sc->mem_ring +
+		packet_ptr = (char *)sc->mem_ring +
 		    (sc->next_packet - sc->rec_page_start) * ED_PAGE_SIZE;
 
 		/*
@@ -2193,7 +2262,7 @@ ed_rint(sc)
 			/*
 			 * Go get packet.
 			 */
-			ed_get_packet(sc, packet_ptr + sizeof(struct ed_ring),
+			ed_get_packet(sc, (int)(packet_ptr + sizeof(struct ed_ring)),
 				      len - sizeof(struct ed_ring));
 			ifp->if_ipackets++;
 		} else {
@@ -2224,15 +2293,15 @@ ed_rint(sc)
 		/*
 		 * Set NIC to page 0 registers to update boundry register
 		 */
-		outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
+		ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
 
-		outb(sc->nic_addr + ED_P0_BNRY, boundry);
+		ed_writeb(sc, sc->nic_addr + ED_P0_BNRY, boundry);
 
 		/*
 		 * Set NIC to page 1 registers before looping to top (prepare
 		 * to get 'CURR' current pointer)
 		 */
-		outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_PAGE_1 | ED_CR_STA);
+		ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_PAGE_1 | ED_CR_STA);
 	}
 }
 
@@ -2252,25 +2321,25 @@ edintr(arg)
 	/*
 	 * Set NIC to page 0 registers
 	 */
-	outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
 
 	/*
 	 * loop until there are no more new interrupts
 	 */
-	while ((isr = inb(sc->nic_addr + ED_P0_ISR)) != 0) {
+	while ((isr = ed_readb(sc, sc->nic_addr + ED_P0_ISR)) != 0) {
 
 		/*
 		 * reset all the bits that we are 'acknowledging' by writing a
 		 * '1' to each bit position that was set (writing a '1'
 		 * *clears* the bit)
 		 */
-		outb(sc->nic_addr + ED_P0_ISR, isr);
+		ed_writeb(sc, sc->nic_addr + ED_P0_ISR, isr);
 
 		/* XXX workaround for AX88190 */
 		if (sc->chip_type == ED_CHIP_TYPE_AX88190) {
-			while(inb(sc->nic_addr + ED_P0_ISR) & isr) {
-				outb(sc->nic_addr + ED_P0_ISR,0);
-				outb(sc->nic_addr + ED_P0_ISR,isr);
+			while(ed_readb(sc, sc->nic_addr + ED_P0_ISR) & isr) {
+				ed_writeb(sc, sc->nic_addr + ED_P0_ISR,0);
+				ed_writeb(sc, sc->nic_addr + ED_P0_ISR,isr);
 			}
 		}
 
@@ -2279,7 +2348,7 @@ edintr(arg)
 		 * the receiver will reset the board under some conditions.
 		 */
 		if (isr & (ED_ISR_PTX | ED_ISR_TXE)) {
-			u_char  collisions = inb(sc->nic_addr + ED_P0_NCR) & 0x0f;
+			u_char  collisions = ed_readb(sc, sc->nic_addr + ED_P0_NCR) & 0x0f;
 
 			/*
 			 * Check for transmit error. If a TX completed with an
@@ -2290,14 +2359,14 @@ edintr(arg)
 			 * flow. Of course, with UDP we're screwed, but this
 			 * is expected when a network is heavily loaded.
 			 */
-			(void) inb(sc->nic_addr + ED_P0_TSR);
+			(void) ed_readb(sc, sc->nic_addr + ED_P0_TSR);
 			if (isr & ED_ISR_TXE) {
 				u_char tsr;
 
 				/*
 				 * Excessive collisions (16)
 				 */
-				tsr = inb(sc->nic_addr + ED_P0_TSR);
+				tsr = ed_readb(sc, sc->nic_addr + ED_P0_TSR);
 				if ((tsr & ED_TSR_ABT)	
 				    && (collisions == 0)) {
 
@@ -2410,7 +2479,7 @@ edintr(arg)
 				 */
 				if (isr & ED_ISR_RXE) {
 					u_char rsr;
-					rsr = inb(sc->nic_addr + ED_P0_RSR);
+					rsr = ed_readb(sc, sc->nic_addr + ED_P0_RSR);
 					if (rsr & ED_RSR_CRC)
 						sc->mibdata.dot3StatsFCSErrors++;
 					if (rsr & ED_RSR_FAE)
@@ -2420,7 +2489,7 @@ edintr(arg)
 					ifp->if_ierrors++;
 #ifdef ED_DEBUG
 					printf("ed%d: receive error %x\n", ifp->if_unit,
-					       inb(sc->nic_addr + ED_P0_RSR));
+					       ed_readb(sc, sc->nic_addr + ED_P0_RSR));
 #endif
 				}
 
@@ -2439,10 +2508,10 @@ edintr(arg)
 				if (sc->isa16bit &&
 				    (sc->vendor == ED_VENDOR_WD_SMC)) {
 
-					outb(sc->asic_addr + ED_WD_LAAR,
+					ed_writeb(sc, sc->asic_addr + ED_WD_LAAR,
 					     sc->wd_laar_proto | ED_WD_LAAR_M16EN);
 					if (sc->chip_type == ED_CHIP_TYPE_WD790) {
-						outb(sc->asic_addr + ED_WD_MSR,
+						ed_writeb(sc, sc->asic_addr + ED_WD_MSR,
 						     ED_WD_MSR_MENB);
 					}
 				}
@@ -2453,9 +2522,9 @@ edintr(arg)
 				    (sc->vendor == ED_VENDOR_WD_SMC)) {
 
 					if (sc->chip_type == ED_CHIP_TYPE_WD790) {
-						outb(sc->asic_addr + ED_WD_MSR, 0x00);
+						ed_writeb(sc, sc->asic_addr + ED_WD_MSR, 0x00);
 					}
-					outb(sc->asic_addr + ED_WD_LAAR,
+					ed_writeb(sc, sc->asic_addr + ED_WD_LAAR,
 					     sc->wd_laar_proto & ~ED_WD_LAAR_M16EN);
 				}
 			}
@@ -2475,7 +2544,7 @@ edintr(arg)
 		 * set in the transmit routine, is *okay* - it is 'edge'
 		 * triggered from low to high)
 		 */
-		outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
+		ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
 
 		/*
 		 * If the Network Talley Counters overflow, read them to reset
@@ -2483,9 +2552,9 @@ edintr(arg)
 		 * otherwise - resulting in an infinite loop.
 		 */
 		if (isr & ED_ISR_CNT) {
-			(void) inb(sc->nic_addr + ED_P0_CNTR0);
-			(void) inb(sc->nic_addr + ED_P0_CNTR1);
-			(void) inb(sc->nic_addr + ED_P0_CNTR2);
+			(void) ed_readb(sc, sc->nic_addr + ED_P0_CNTR0);
+			(void) ed_readb(sc, sc->nic_addr + ED_P0_CNTR1);
+			(void) ed_readb(sc, sc->nic_addr + ED_P0_CNTR2);
 		}
 	}
 }
@@ -2545,9 +2614,9 @@ ed_ioctl(ifp, command, data)
 		 */
 		if (sc->vendor == ED_VENDOR_3COM) {
 			if (ifp->if_flags & IFF_ALTPHYS) {
-				outb(sc->asic_addr + ED_3COM_CR, 0);
+				ed_writeb(sc, sc->asic_addr + ED_3COM_CR, 0);
 			} else {
-				outb(sc->asic_addr + ED_3COM_CR, ED_3COM_CR_XSEL);
+				ed_writeb(sc, sc->asic_addr + ED_3COM_CR, ED_3COM_CR_XSEL);
 			}
 		} else if (sc->vendor == ED_VENDOR_HP) 
 			ed_hpp_set_physical_link(sc);
@@ -2575,10 +2644,10 @@ ed_ioctl(ifp, command, data)
  *	the ring buffer into a linear destination buffer. Takes into account
  *	ring-wrap.
  */
-static __inline char *
+static __inline int
 ed_ring_copy(sc, src, dst, amount)
 	struct ed_softc *sc;
-	char   *src;
+	int    src;
 	char   *dst;
 	u_short amount;
 {
@@ -2590,16 +2659,16 @@ ed_ring_copy(sc, src, dst, amount)
 
 		/* copy amount up to end of NIC memory */
 		if (sc->mem_shared)
-			bcopy(src, dst, tmp_amount);
+			ed_bcopy_from(sc, dst, src, tmp_amount);
 		else
-			ed_pio_readmem(sc, (int)src, dst, tmp_amount);
+			ed_pio_readmem(sc, src, dst, tmp_amount);
 
 		amount -= tmp_amount;
 		src = sc->mem_ring;
 		dst += tmp_amount;
 	}
 	if (sc->mem_shared)
-		bcopy(src, dst, amount);
+		ed_bcopy_from(sc, dst, src, amount);
 	else
 		ed_pio_readmem(sc, (int)src, dst, amount);
 
@@ -2612,8 +2681,8 @@ ed_ring_copy(sc, src, dst, amount)
  */
 static void
 ed_get_packet(sc, buf, len)
-	struct ed_softc *sc;
-	char   *buf;
+	struct  ed_softc *sc;
+	int     buf;
 	u_short len;
 {
 	struct ether_header *eh;
@@ -2706,26 +2775,31 @@ ed_pio_readmem(sc, src, dst, amount)
 		
 	/* Regular Novell cards */
 	/* select page 0 registers */
-	outb(sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STA);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STA);
+
 
 	/* round up to a word */
 	if (amount & 1)
 		++amount;
 
 	/* set up DMA byte count */
-	outb(sc->nic_addr + ED_P0_RBCR0, amount);
-	outb(sc->nic_addr + ED_P0_RBCR1, amount >> 8);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RBCR0, amount);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RBCR1, amount >> 8);
 
 	/* set up source address in NIC mem */
-	outb(sc->nic_addr + ED_P0_RSAR0, src);
-	outb(sc->nic_addr + ED_P0_RSAR1, src >> 8);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RSAR0, src);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RSAR1, src >> 8);
 
-	outb(sc->nic_addr + ED_P0_CR, ED_CR_RD0 | ED_CR_STA);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, ED_CR_RD0 | ED_CR_STA);
 
-	if (sc->isa16bit) {
-		insw(sc->asic_addr + ED_NOVELL_DATA, dst, amount / 2);
-	} else
-		insb(sc->asic_addr + ED_NOVELL_DATA, dst, amount);
+	if (sc->isa16bit)
+		bus_space_read_multi_2(sc->bst, sc->bsh,
+		    sc->asic_addr + ED_NOVELL_DATA,
+		    (u_int16_t *) dst, amount / 2);
+	else
+		bus_space_read_multi_1(sc->bst, sc->bsh,
+		    sc->asic_addr + ED_NOVELL_DATA,
+		    (u_int8_t *) dst, amount);
 
 }
 
@@ -2746,26 +2820,29 @@ ed_pio_writemem(sc, src, dst, len)
 	if (sc->vendor == ED_VENDOR_NOVELL) {
 
 		/* select page 0 registers */
-		outb(sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STA);
+		ed_writeb(sc, sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STA);
 
 		/* reset remote DMA complete flag */
-		outb(sc->nic_addr + ED_P0_ISR, ED_ISR_RDC);
+		ed_writeb(sc, sc->nic_addr + ED_P0_ISR, ED_ISR_RDC);
 
 		/* set up DMA byte count */
-		outb(sc->nic_addr + ED_P0_RBCR0, len);
-		outb(sc->nic_addr + ED_P0_RBCR1, len >> 8);
+		ed_writeb(sc, sc->nic_addr + ED_P0_RBCR0, len);
+		ed_writeb(sc, sc->nic_addr + ED_P0_RBCR1, len >> 8);
 
 		/* set up destination address in NIC mem */
-		outb(sc->nic_addr + ED_P0_RSAR0, dst);
-		outb(sc->nic_addr + ED_P0_RSAR1, dst >> 8);
+		ed_writeb(sc, sc->nic_addr + ED_P0_RSAR0, dst);
+		ed_writeb(sc, sc->nic_addr + ED_P0_RSAR1, dst >> 8);
 
 		/* set remote DMA write */
-		outb(sc->nic_addr + ED_P0_CR, ED_CR_RD1 | ED_CR_STA);
+		ed_writeb(sc, sc->nic_addr + ED_P0_CR, ED_CR_RD1 | ED_CR_STA);
 
 		if (sc->isa16bit)
-			outsw(sc->asic_addr + ED_NOVELL_DATA, src, len / 2);
+			ed_writesw(sc, sc->asic_addr + ED_NOVELL_DATA,
+			    (u_int16_t *) src, len / 2);
 		else
-			outsb(sc->asic_addr + ED_NOVELL_DATA, src, len);
+			bus_space_write_multi_1(sc->bst, sc->bsh,
+			    sc->asic_addr + ED_NOVELL_DATA,
+			    src, len);
 
 		/*
 		 * Wait for remote DMA complete. This is necessary because on the
@@ -2774,7 +2851,7 @@ ed_pio_writemem(sc, src, dst, len)
 		 * waiting causes really bad things to happen - like the NIC
 		 * irrecoverably jamming the ISA bus.
 		 */
-		while (((inb(sc->nic_addr + ED_P0_ISR) & ED_ISR_RDC) != ED_ISR_RDC) && --maxwait);
+		while (((ed_readb(sc, sc->nic_addr + ED_P0_ISR) & ED_ISR_RDC) != ED_ISR_RDC) && --maxwait);
 
 	} else if ((sc->vendor == ED_VENDOR_HP) && 
 		   (sc->type == ED_TYPE_HP_PCLANPLUS)) { 
@@ -2782,10 +2859,10 @@ ed_pio_writemem(sc, src, dst, len)
 		/* HP PCLAN+ */
 
 		/* reset remote DMA complete flag */
-		outb(sc->nic_addr + ED_P0_ISR, ED_ISR_RDC);
+		ed_writeb(sc, sc->nic_addr + ED_P0_ISR, ED_ISR_RDC);
 
 		/* program the write address in RAM */
-		outw(sc->asic_addr + ED_HPP_PAGE_0, dst);
+		ed_writew(sc, sc->asic_addr + ED_HPP_PAGE_0, dst);
 
 		if (sc->hpp_mem_start) {
 			u_short *s = (u_short *) src;
@@ -2796,7 +2873,7 @@ ed_pio_writemem(sc, src, dst, len)
 			 * Enable memory mapped access.
 			 */
 
-			outw(sc->asic_addr + ED_HPP_OPTION, 
+			ed_writew(sc, sc->asic_addr + ED_HPP_OPTION, 
 			     sc->hpp_options & 
 				~(ED_HPP_OPTION_MEM_DISABLE | 
 				  ED_HPP_OPTION_BOOT_ROM_ENB));
@@ -2812,12 +2889,13 @@ ed_pio_writemem(sc, src, dst, len)
 			 * Restore Boot ROM access.
 			 */
 
-			outw(sc->asic_addr + ED_HPP_OPTION,
+			ed_writew(sc, sc->asic_addr + ED_HPP_OPTION,
 			     sc->hpp_options);
 
 		} else {
 			/* write data using I/O writes */
-			outsw(sc->asic_addr + ED_HPP_PAGE_4, src, len / 2);
+			ed_writesw(sc, sc->asic_addr + ED_HPP_PAGE_4,
+			    (u_int16_t *) src, len / 2);
 		}
 
 	}
@@ -2853,21 +2931,21 @@ ed_pio_write_mbufs(sc, m, dst)
 		dma_len++;
 
 	/* select page 0 registers */
-	outb(sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STA);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STA);
 
 	/* reset remote DMA complete flag */
-	outb(sc->nic_addr + ED_P0_ISR, ED_ISR_RDC);
+	ed_writeb(sc, sc->nic_addr + ED_P0_ISR, ED_ISR_RDC);
 
 	/* set up DMA byte count */
-	outb(sc->nic_addr + ED_P0_RBCR0, dma_len);
-	outb(sc->nic_addr + ED_P0_RBCR1, dma_len >> 8);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RBCR0, dma_len);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RBCR1, dma_len >> 8);
 
 	/* set up destination address in NIC mem */
-	outb(sc->nic_addr + ED_P0_RSAR0, dst);
-	outb(sc->nic_addr + ED_P0_RSAR1, dst >> 8);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RSAR0, dst);
+	ed_writeb(sc, sc->nic_addr + ED_P0_RSAR1, dst >> 8);
 
 	/* set remote DMA write */
-	outb(sc->nic_addr + ED_P0_CR, ED_CR_RD1 | ED_CR_STA);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, ED_CR_RD1 | ED_CR_STA);
 
   /*
    * Transfer the mbuf chain to the NIC memory.
@@ -2878,10 +2956,10 @@ ed_pio_write_mbufs(sc, m, dst)
 	if (!sc->isa16bit) {
 		/* NE1000s are easy */
 		while (m) {
-			if (m->m_len) {
-				outsb(sc->asic_addr + ED_NOVELL_DATA,
-				      m->m_data, m->m_len);
-			}
+			if (m->m_len)
+				bus_space_write_multi_1(sc->bst, sc->bsh,
+				    sc->asic_addr + ED_NOVELL_DATA,
+				    m->m_data, m->m_len);
 			m = m->m_next;
 		}
 	} else {
@@ -2899,15 +2977,16 @@ ed_pio_write_mbufs(sc, m, dst)
 				/* finish the last word */
 				if (wantbyte) {
 					savebyte[1] = *data;
-					outw(sc->asic_addr + ED_NOVELL_DATA, *(u_short *)savebyte);
+					ed_writew(sc, sc->asic_addr + ED_NOVELL_DATA, *(u_short *)savebyte);
 					data++;
 					len--;
 					wantbyte = 0;
 				}
 				/* output contiguous words */
 				if (len > 1) {
-					outsw(sc->asic_addr + ED_NOVELL_DATA,
-					      data, len >> 1);
+					ed_writesw(sc,
+					    sc->asic_addr + ED_NOVELL_DATA,
+					    (u_int16_t *) data, len >> 1);
 					data += len & ~1;
 					len &= 1;
 				}
@@ -2921,7 +3000,7 @@ ed_pio_write_mbufs(sc, m, dst)
 		}
 		/* spit last byte */
 		if (wantbyte) {
-			outw(sc->asic_addr + ED_NOVELL_DATA, *(u_short *)savebyte);
+			ed_writew(sc, sc->asic_addr + ED_NOVELL_DATA, *(u_short *)savebyte);
 		}
 	}
 
@@ -2932,7 +3011,7 @@ ed_pio_write_mbufs(sc, m, dst)
 	 * waiting causes really bad things to happen - like the NIC
 	 * irrecoverably jamming the ISA bus.
 	 */
-	while (((inb(sc->nic_addr + ED_P0_ISR) & ED_ISR_RDC) != ED_ISR_RDC) && --maxwait);
+	while (((ed_readb(sc, sc->nic_addr + ED_P0_ISR) & ED_ISR_RDC) != ED_ISR_RDC) && --maxwait);
 
 	if (!maxwait) {
 		log(LOG_WARNING, "ed%d: remote transmit DMA failed to complete\n",
@@ -2964,7 +3043,7 @@ ed_hpp_readmem(sc, src, dst, amount)
 
 
 	/* Program the source address in RAM */
-	outw(sc->asic_addr + ED_HPP_PAGE_2, src);
+	ed_writew(sc, sc->asic_addr + ED_HPP_PAGE_2, src);
 
 	/*
 	 * The HP PC Lan+ card supports word reads as well as
@@ -2975,16 +3054,16 @@ ed_hpp_readmem(sc, src, dst, amount)
 	if (sc->hpp_mem_start) {
 
 		/* Enable memory mapped access.  */
-		outw(sc->asic_addr + ED_HPP_OPTION, 
+		ed_writew(sc, sc->asic_addr + ED_HPP_OPTION, 
 		     sc->hpp_options & 
 			~(ED_HPP_OPTION_MEM_DISABLE | 
 			  ED_HPP_OPTION_BOOT_ROM_ENB));
 
 		if (use_32bit_access && (amount > 3)) {
-			u_long *dl = (u_long *) dst;	
-			volatile u_long *const sl = 
-				(u_long *) sc->hpp_mem_start;
-			u_long *const fence = dl + (amount >> 2);
+			u_int32_t *dl = (u_int32_t *) dst;	
+			volatile u_int32_t *const sl = 
+				(u_int32_t *) sc->hpp_mem_start;
+			u_int32_t *const fence = dl + (amount >> 2);
 			
 			/* Copy out NIC data.  We could probably write this
 			   as a `movsl'. The currently generated code is lousy.
@@ -3029,31 +3108,35 @@ ed_hpp_readmem(sc, src, dst, amount)
 
 		/* Restore Boot ROM access.  */
 
-		outw(sc->asic_addr + ED_HPP_OPTION,
+		ed_writew(sc, sc->asic_addr + ED_HPP_OPTION,
 		     sc->hpp_options);
 
 
 	} else { 
 		/* Read in data using the I/O port */
 		if (use_32bit_access && (amount > 3)) {
-			insl(sc->asic_addr + ED_HPP_PAGE_4, dst, amount >> 2);
+			bus_space_read_multi_4(sc->bst, sc->bsh,
+			    sc->asic_addr + ED_HPP_PAGE_4,
+			    (u_int32_t *) dst, amount >> 2);
 			dst += (amount & ~3);
 			amount &= 3;
 		}
 		if (amount > 1) {
-			insw(sc->asic_addr + ED_HPP_PAGE_4, dst, amount >> 1);
+			bus_space_read_multi_2(sc->bst, sc->bsh,
+			    sc->asic_addr + ED_HPP_PAGE_4,
+			    (u_int16_t *) dst, amount >> 1);
 			dst += (amount & ~1);
 			amount &= 1;
 		}
 		if (amount == 1) { /* read in a short and keep the LSB */
-			*dst = inw(sc->asic_addr + ED_HPP_PAGE_4) & 0xFF;
+			*dst = ed_readw(sc, sc->asic_addr + ED_HPP_PAGE_4) & 0xFF;
 		}
 	}
 }
 
 /*
- * Write to HP PC Lan+ NIC memory.  Access to the NIC can be by using 
- * outsw() or via the memory mapped interface to the same register.
+ * Write to HP PC Lan+ NIC memory.  Access to the NIC can be by using
+ * ed_writesw() or via the memory mapped interface to the same register.
  * Writes have to be in word units; byte accesses won't work and may cause
  * the NIC to behave wierdly. Long word accesses are permitted if the ASIC
  * allows it.
@@ -3070,16 +3153,16 @@ ed_hpp_write_mbufs(struct ed_softc *sc, struct mbuf *m, int dst)
 	int use_32bit_accesses = !(sc->hpp_id & ED_HPP_ID_16_BIT_ACCESS);
 
 	/* select page 0 registers */
-	outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
 
 	/* reset remote DMA complete flag */
-	outb(sc->nic_addr + ED_P0_ISR, ED_ISR_RDC);
+	ed_writeb(sc, sc->nic_addr + ED_P0_ISR, ED_ISR_RDC);
 
 	/* program the write address in RAM */
-	outw(sc->asic_addr + ED_HPP_PAGE_0, dst);
+	ed_writew(sc, sc->asic_addr + ED_HPP_PAGE_0, dst);
 
 	if (sc->hpp_mem_start) 	/* enable memory mapped I/O */
-		outw(sc->asic_addr + ED_HPP_OPTION, sc->hpp_options & 
+		ed_writew(sc, sc->asic_addr + ED_HPP_OPTION, sc->hpp_options & 
 			~(ED_HPP_OPTION_MEM_DISABLE |
 			ED_HPP_OPTION_BOOT_ROM_ENB));
 
@@ -3099,10 +3182,10 @@ ed_hpp_write_mbufs(struct ed_softc *sc, struct mbuf *m, int dst)
 				}
 				/* output contiguous words */
 				if ((len > 3) && (use_32bit_accesses)) {
-					volatile u_long *const dl = 
-						(volatile u_long *) d;
-					u_long *sl = (u_long *) data;
-					u_long *fence = sl + (len >> 2);
+					volatile u_int32_t *const dl = 
+						(volatile u_int32_t *) d;
+					u_int32_t *sl = (u_int32_t *) data;
+					u_int32_t *fence = sl + (len >> 2);
 
 					while (sl < fence)
 						*dl = *sl++;
@@ -3138,7 +3221,7 @@ ed_hpp_write_mbufs(struct ed_softc *sc, struct mbuf *m, int dst)
 				/* finish the last word of the previous mbuf */
 				if (wantbyte) {
 					savebyte[1] = *data;
-					outw(sc->asic_addr + ED_HPP_PAGE_4, 
+					ed_writew(sc, sc->asic_addr + ED_HPP_PAGE_4, 
 					     *((u_short *)savebyte));
 					data++; 
 					len--; 
@@ -3146,15 +3229,18 @@ ed_hpp_write_mbufs(struct ed_softc *sc, struct mbuf *m, int dst)
 				}
 				/* output contiguous words */
 				if ((len > 3) && use_32bit_accesses) {
-					outsl(sc->asic_addr + ED_HPP_PAGE_4,
-						data, len >> 2);
+					bus_space_write_multi_4(sc->bst,
+					    sc->bsh,
+					    sc->asic_addr + ED_HPP_PAGE_4,
+					    (u_int32_t *) data, len);
 					data += (len & ~3);
 					len &= 3;
 				}
 				/* finish off remaining 16 bit accesses */
 				if (len > 1) {
-					outsw(sc->asic_addr + ED_HPP_PAGE_4,
-					      data, len >> 1);
+					ed_writesw(sc,
+					    sc->asic_addr + ED_HPP_PAGE_4,
+					    (u_int16_t *) data, len >> 1);
 					data += (len & ~1);
 					len &= 1;
 				}
@@ -3165,13 +3251,13 @@ ed_hpp_write_mbufs(struct ed_softc *sc, struct mbuf *m, int dst)
 			m = m->m_next;
 		}
 		if (wantbyte) /* spit last byte */
-			outw(sc->asic_addr + ED_HPP_PAGE_4, 
+			ed_writew(sc, sc->asic_addr + ED_HPP_PAGE_4, 
 				*(u_short *)savebyte);
 
 	}
 
 	if (sc->hpp_mem_start)	/* turn off memory mapped i/o */
-		outw(sc->asic_addr + ED_HPP_OPTION,
+		ed_writew(sc, sc->asic_addr + ED_HPP_OPTION,
 		     sc->hpp_options);
 
 	return (total_len);
@@ -3183,7 +3269,7 @@ ed_setrcr(sc)
 {
 	struct ifnet *ifp = (struct ifnet *)sc;
 	int     i;
-	u_char reg1;
+	u_char	reg1;
 
 	/* Bit 6 in AX88190 RCR register must be set. */
 	if (sc->chip_type == ED_CHIP_TYPE_AX88190)
@@ -3191,9 +3277,8 @@ ed_setrcr(sc)
 	else
 		reg1 = 0x00;
 
-
 	/* set page 1 registers */
-	outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_PAGE_1 | ED_CR_STP);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_PAGE_1 | ED_CR_STP);
 
 	if (ifp->if_flags & IFF_PROMISC) {
 
@@ -3201,21 +3286,21 @@ ed_setrcr(sc)
 		 * Reconfigure the multicast filter.
 		 */
 		for (i = 0; i < 8; i++)
-			outb(sc->nic_addr + ED_P1_MAR(i), 0xff);
+			ed_writeb(sc, sc->nic_addr + ED_P1_MAR(i), 0xff);
 
 		/*
 		 * And turn on promiscuous mode. Also enable reception of
 		 * runts and packets with CRC & alignment errors.
 		 */
 		/* Set page 0 registers */
-		outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STP);
+		ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STP);
 
-		outb(sc->nic_addr + ED_P0_RCR, ED_RCR_PRO | ED_RCR_AM |
+		ed_writeb(sc, sc->nic_addr + ED_P0_RCR, ED_RCR_PRO | ED_RCR_AM |
 		     ED_RCR_AB | ED_RCR_AR | ED_RCR_SEP | reg1);
 	} else {
 		/* set up multicast addresses and filter modes */
 		if (ifp->if_flags & IFF_MULTICAST) {
-			u_long  mcaf[2];
+			u_int32_t  mcaf[2];
 
 			if (ifp->if_flags & IFF_ALLMULTI) {
 				mcaf[0] = 0xffffffff;
@@ -3227,12 +3312,12 @@ ed_setrcr(sc)
 			 * Set multicast filter on chip.
 			 */
 			for (i = 0; i < 8; i++)
-				outb(sc->nic_addr + ED_P1_MAR(i), ((u_char *) mcaf)[i]);
+				ed_writeb(sc, sc->nic_addr + ED_P1_MAR(i), ((u_char *) mcaf)[i]);
 
 			/* Set page 0 registers */
-			outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STP);
+			ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STP);
 
-			outb(sc->nic_addr + ED_P0_RCR, ED_RCR_AM | ED_RCR_AB | reg1);
+			ed_writeb(sc, sc->nic_addr + ED_P0_RCR, ED_RCR_AM | ED_RCR_AB | reg1);
 		} else {
 
 			/*
@@ -3240,44 +3325,102 @@ ed_setrcr(sc)
 			 * not accept multicasts.
 			 */
 			for (i = 0; i < 8; ++i)
-				outb(sc->nic_addr + ED_P1_MAR(i), 0x00);
+				ed_writeb(sc, sc->nic_addr + ED_P1_MAR(i), 0x00);
 
 			/* Set page 0 registers */
-			outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STP);
+			ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STP);
 
-			outb(sc->nic_addr + ED_P0_RCR, ED_RCR_AB | reg1);
+			ed_writeb(sc, sc->nic_addr + ED_P0_RCR, ED_RCR_AB | reg1);
 		}
 	}
 
 	/*
 	 * Start interface.
 	 */
-	outb(sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, sc->cr_proto | ED_CR_STA);
+}
+
+void
+ed_ax88190_geteprom(struct ed_softc *sc)
+{
+	int prom[16],i;
+	u_char tmp;
+	struct {
+		unsigned char offset,value;
+	} pg_seq[]={
+		{ED_P0_CR ,ED_CR_RD2|ED_CR_STP}, /* Select Page0 */
+		{ED_P0_DCR,0x01},
+		{ED_P0_RBCR0, 0x00}, /* Clear the count regs. */
+		{ED_P0_RBCR1, 0x00},
+		{ED_P0_IMR, 0x00},   /* Mask completion irq. */
+		{ED_P0_ISR, 0xff},
+		{ED_P0_RCR, ED_RCR_MON|ED_RCR_INTT}, /* Set To Monitor */
+		{ED_P0_TCR, ED_TCR_LB0},             /* loopback mode. */
+		{ED_P0_RBCR0,32},
+		{ED_P0_RBCR1,0x00},
+		{ED_P0_RSAR0,0x00},
+		{ED_P0_RSAR1,0x04},
+		{ED_P0_CR ,ED_CR_RD0|ED_CR_STA},
+	};
+
+	/* Default Set */
+	sc->asic_addr = rman_get_start(sc->port_res) + ED_NOVELL_ASIC_OFFSET;
+	sc->nic_addr = rman_get_start(sc->port_res) + ED_NOVELL_NIC_OFFSET;
+	/* Reset Card */
+	tmp = ed_readb(sc, sc->asic_addr + ED_NOVELL_RESET);
+	ed_writeb(sc, sc->asic_addr + ED_NOVELL_RESET, tmp);
+	DELAY(5000);
+	ed_writeb(sc, sc->nic_addr + ED_P0_CR, ED_CR_RD2 | ED_CR_STP);
+	DELAY(5000);
+
+	/* Card Settings */
+	for(i=0;i<sizeof(pg_seq)/sizeof(pg_seq[0]);i++) {
+		ed_writeb(sc, sc->nic_addr + pg_seq[i].offset , pg_seq[i].value);
+	}
+
+	/* Get Data */
+	for(i=0;i<16;i++) {
+		prom[i] = ed_readw(sc, sc->asic_addr);
+	}
+/*
+	for(i=0;i<16;i++) {
+		printf("ax88190 eprom [%02d] %02x %02x\n",
+			i,prom[i] & 0xff,prom[i] >> 8);
+	}
+*/
+	sc->arpcom.ac_enaddr[0] = prom[0] & 0xff;
+	sc->arpcom.ac_enaddr[1] = prom[0] >> 8;
+	sc->arpcom.ac_enaddr[2] = prom[1] & 0xff;
+	sc->arpcom.ac_enaddr[3] = prom[1] >> 8;
+	sc->arpcom.ac_enaddr[4] = prom[2] & 0xff;
+	sc->arpcom.ac_enaddr[5] = prom[2] >> 8;
+
+	return;
 }
 
 /*
  * Compute crc for ethernet address
  */
-static u_long
+static u_int32_t
 ds_crc(ep)
 	u_char *ep;
 {
 #define POLYNOMIAL 0x04c11db6
-	register u_long crc = 0xffffffffL;
+	register u_int32_t crc = 0xffffffff;
 	register int carry, i, j;
 	register u_char b;
 
 	for (i = 6; --i >= 0;) {
 		b = *ep++;
 		for (j = 8; --j >= 0;) {
-			carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
+			carry = ((crc & 0x80000000) ? 1 : 0) ^ (b & 0x01);
 			crc <<= 1;
 			b >>= 1;
 			if (carry)
-				crc = ((crc ^ POLYNOMIAL) | carry);
+				crc = (crc ^ POLYNOMIAL) | carry;
 		}
 	}
-	return crc;
+	return (crc & 0xffffffff);
 #undef POLYNOMIAL
 }
 
@@ -3288,9 +3431,9 @@ ds_crc(ep)
 static void
 ds_getmcaf(sc, mcaf)
 	struct ed_softc *sc;
-	u_long *mcaf;
+	u_int32_t *mcaf;
 {
-	register u_int index;
+	register u_int32_t index;
 	register u_char *af = (u_char *) mcaf;
 	struct ifmultiaddr *ifma;