ether/etherpci/etherpci.c

/*
 * Copyright (c) 1998, 1999, Be Incorporated.  All Rights Reserved.
 * This file may be used under the terms of the Be Sample Code License.
 */

/*! Ethernet driver: handles PCI NE2000 cards */

#include "etherpci_private.h"
#include <ether_driver.h>

#include <OS.h>
#include <KernelExport.h>
#include <Drivers.h>
#include <PCI.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>

#define kDevName "etherpci"
#define kDevDir "net/" kDevName "/"
#define DEVNAME_LENGTH		64
#define MAX_CARDS 			 4			/* maximum number of driver instances */

int32 api_version = B_CUR_DRIVER_API_VERSION;

/* debug flags */
#define ERR       0x0001
#define INFO      0x0002
#define RX        0x0004		/* dump received frames */
#define TX        0x0008		/* dump transmitted frames */
#define INTERRUPT 0x0010		/* interrupt calls */
#define FUNCTION  0x0020		/* function calls */
#define PCI_IO    0x0040		/* pci reads and writes */
#define SEQ		  0x0080		/* trasnmit & receive TCP/IP sequence sequence numbers */
#define WARN	  0x0100		/* Warnings - off on final release */

/* diagnostic debug flags - compile in here or set while running with debugger "AcmeRoadRunner" command */
#define DEFAULT_DEBUG_FLAGS ( ERR | INFO | WARN | FUNCTION )

//#define TRACE_ETHERPCI
#ifdef TRACE_ETHERPCI
#	define ETHER_DEBUG(mask, enabled, format, args...) \
		do { if (mask & enabled) \
			dprintf(format , ##args); } while (0)
#else
#	define ETHER_DEBUG(mask, enabled, format, args...) ;
#endif


static pci_module_info		*gPCIModInfo;
static char 				*gDevNameList[MAX_CARDS+1];
static pci_info 			*gDevList[MAX_CARDS+1];
static int32 				gOpenMask = 0;


/* Driver Entry Points */
status_t init_hardware(void);
status_t init_driver(void);
void uninit_driver(void);
const char** publish_devices(void);
device_hooks *find_device(const char *name);


/*
 * Define STAY_ON_PAGE_0 if you want the driver to stay on page 0 all the
 * time.  This is faster than if it has to switch to page 1 to get the
 * current register to see if there are any more packets.  Reason: the
 * interrupt handler does not have to do any locking if it knows it is
 * always on page 0.  I'm not sure why the speed difference is so dramatic,
 * so perhaps there is actually a bug in page-changing version.
 *
 * STAY_ON_PAGE_0 uses a rather dubious technique to avoid changing the
 * register page and it may not be 100% reliable.  The technique used is to
 * make sure all ring headers are zeroed out before packets are received
 * into them.  Then, if you detect a non-zero ring header, you can be pretty
 * sure that it is another packet.
 *
 * We never read the "might-be-a-packet" immediately.  Instead, we just
 * release a semaphore so that the next read will occur later on enough
 * so that the ring header information should be completely filled in.
 *
 */
#define STAY_ON_PAGE_0	0


/*
 * We only care about these interrupts in our driver
 */
#define INTS_WE_CARE_ABOUT (ISR_RECEIVE | ISR_RECEIVE_ERROR |\
							ISR_TRANSMIT | ISR_TRANSMIT_ERROR | ISR_COUNTER)

typedef struct etherpci_private {
	int32			devID; 		/* device identifier: 0-n */
	pci_info		*pciInfo;
	uint16			irq;		/* IRQ line */
	uint32			reg_base;	/* hardware register base address */
	area_id			ioarea; 	/* Area used for MMIO of hostRegs */
	int boundary;			/* boundary register value (mirrored) */
	ether_address_t myaddr;	/* my ethernet address */
	unsigned nmulti;		/* number of multicast addresses */
	ether_address_t multi[MAX_MULTI];	/* multicast addresses */
	sem_id iolock;			/* ethercard io, except interrupt handler */
	int nonblocking;		/* non-blocking mode */
#if !STAY_ON_PAGE_0
	spinlock intrlock;		/* ethercard io, including interrupt handler */
#endif /* !STAY_ON_PAGE_0 */
	volatile int interrupted;   /* interrupted system call */
	sem_id inrw;			/* in read or write function */
	sem_id ilock;			/* waiting for input */
	sem_id olock;	 		/* waiting to output */

	/*
	 * Various statistics
	 */
	volatile int ints;	/* total number of interrupts */
	volatile int rints;	/* read interrupts */
	volatile int wints;	/* write interrupts */
	volatile int reads;	/* reads */
	volatile int writes;	/* writes */
	volatile int resets;	/* resets */
	volatile int rerrs;	/* read errors */
	volatile int werrs;	/* write errors */
	volatile int interrs;/* unknown interrupts */
	volatile int frame_errs;	/* frame alignment errors */
	volatile int crc_errs;	/* crc errors */
	volatile int frames_lost;/* frames lost due to buffer problems */

	/*
	 * Most recent values of the error statistics to detect any changes in them
	 */
	int rerrs_last;
	int werrs_last;
	int interrs_last;
	int frame_errs_last;
	int crc_errs_last;
	int frames_lost_last;

	/* stats from the hardware */
	int chip_rx_frame_errors;
	int chip_rx_crc_errors;
	int chip_rx_missed_errors;
	/*
	 * These values are set once and never looked at again.  They are
	 * almost as good as constants, but they differ for the various
	 * cards, so we can't set them now.
	 */
	int ETHER_BUF_START;
	int ETHER_BUF_SIZE;
	int EC_VMEM_PAGE;
	int EC_VMEM_NPAGES;
	int EC_RXBUF_START_PAGE;
	int EC_RXBUF_END_PAGE;
	int EC_RINGSTART;
	int EC_RINGSIZE;

	uint32 debug;

} etherpci_private_t;


#if __POWERPC__

#define ether_inb(device, offset)  			(*((volatile uint8*)(device->reg_base + (offset)))); __eieio()
#define ether_inw(device, offset)  			(*((volatile uint16*)(device->reg_base + (offset)))); __eieio()
#define ether_outb(device, offset, value)  	(*((volatile uint8 *)(device->reg_base + (offset))) = (value)); __eieio()
#define ether_outw(device, offset, value) 	(*((volatile uint16*)(device->reg_base + (offset))) = (value)); __eieio()

#else /* !PPC */

#define ether_outb(device, offset, value)	(*gPCIModInfo->write_io_8)((device->reg_base + (offset)), (value))
#define ether_outw(device, offset, value)	(*gPCIModInfo->write_io_16)((device->reg_base + (offset)), (value))
#define ether_inb(device, offset)			((*gPCIModInfo->read_io_8)(device->reg_base + (offset)))
#define ether_inw(device, offset)			((*gPCIModInfo->read_io_16)(device->reg_base + (offset)))

#endif

#if 0
#if __i386__

uint8  ether_inb(etherpci_private_t *device, uint32 offset) {
  	uint8 result;
	result = ((*gPCIModInfo->read_io_8)(device->reg_base + (offset)));
	ETHER_DEBUG(PCI_IO, device->debug, " inb(%x) %x \n", offset, result);
	return result;
};
uint16  ether_inw(etherpci_private_t *device, uint32 offset) {
  	uint16 result;
	result = ((*gPCIModInfo->read_io_16)(device->reg_base + (offset)));
	ETHER_DEBUG(PCI_IO, device->debug, " inw(%x) %x \n", offset, result);
	return result;
};
void  ether_outb(etherpci_private_t *device, uint32 offset, uint8 value) {
	(*gPCIModInfo->write_io_8)((device->reg_base + (offset)), (value));
	ETHER_DEBUG(PCI_IO, device->debug, " outb(%x) %x \n", offset, value);
};
void  ether_outw(etherpci_private_t *device, uint32 offset, uint16 value) {
	(*gPCIModInfo->write_io_16)((device->reg_base + (offset)), (value));
	ETHER_DEBUG(PCI_IO, device->debug, " outb(%x) %x \n", offset, value);
};


#else /* PPC */

uint8  ether_inb(etherpci_private_t *device, uint32 offset) {
  	uint8 result;
	result = (*((volatile uint8*) (device->reg_base + (offset)))); __eieio();
	ETHER_DEBUG(PCI_IO, device->debug, " inb(%x) %x \n", offset, result);
	return result;
};

uint16  ether_inw(etherpci_private_t *device, uint32 offset) {
  	uint16 result;
	result = (*((volatile uint16*) (device->reg_base + (offset)))); __eieio();
	ETHER_DEBUG(PCI_IO, device->debug, " inw(%x) %x \n", offset, result);
	return result;
};

void  ether_outb(etherpci_private_t *device, uint32 offset, uint8 value) {
	(*((volatile uint8 *)(device->reg_base + (offset))) = (value)); __eieio();
	ETHER_DEBUG(PCI_IO, device->debug, " outb(%x) %x \n", offset, value);
};
void  ether_outw(etherpci_private_t *device, uint32 offset, uint16 value) {
	(*((volatile uint16 *)(device->reg_base + (offset))) = (value)); __eieio();
	ETHER_DEBUG(PCI_IO, device->debug, " outb(%x) %x \n", offset, value);
};

#endif
#endif


/* for serial debug command*/
#define DEBUGGER_COMMAND true
#if DEBUGGER_COMMAND
etherpci_private_t * gdev;
static int etherpci(int argc, char **argv);
	/* serial debug command */
#endif

/*
 * io_lock gets you exclusive access to the card, except that
 * the interrupt handler can still run.
 * There is probably no need to io_lock() a 3com card, so look into
 * removing it for that case.
 */
#define io_lock(data)	acquire_sem(data->iolock)
#define io_unlock(data)	release_sem_etc(data->iolock, 1, B_DO_NOT_RESCHEDULE)

/*
 * output_wait wakes up when the card is ready to transmit another packet
 */
#define output_wait(data, t) acquire_sem_etc(data->olock, 1, B_TIMEOUT, t)
#define output_unwait(data, c)	release_sem_etc(data->olock, c, B_DO_NOT_RESCHEDULE)

/*
 * input_wait wakes up when the card has at least one packet on it
 */
#define input_wait(data)		acquire_sem_etc(data->ilock ,1, B_CAN_INTERRUPT, 0)
#define input_unwait(data, c)	release_sem_etc(data->ilock, c, B_DO_NOT_RESCHEDULE)


/* prototypes */
static status_t open_hook(const char *name, uint32 flags, void **cookie);
static status_t close_hook(void *);
static status_t free_hook(void *);
static status_t control_hook(void * cookie,uint32 msg,void *buf,size_t len);
static status_t read_hook(void *data, off_t pos, void *buf, size_t *len);
static status_t write_hook(void *data, off_t pos, const void *buf, size_t *len);
//static int32    etherpci_interrupt(void *data);                	   /* interrupt handler */
//static int32    get_pci_list(pci_info *info[], int32 maxEntries);  /* Get pci_info for each device */
//static status_t free_pci_list(pci_info *info[]);                   /* Free storage used by pci_info list */
//static void 	dump_packet(const char * msg, unsigned char * buf, uint16 size); /* diagnostic packet trace */
//static status_t enable_addressing(etherpci_private_t  *data);             /* enable pci io address space for device */
//static int domulti(etherpci_private_t *data,char *addr);

static device_hooks gDeviceHooks =  {
	open_hook, 			/* -> open entry point */
	close_hook,         /* -> close entry point */
	free_hook,          /* -> free entry point */
	control_hook,       /* -> control entry point */
	read_hook,          /* -> read entry point */
	write_hook,         /* -> write entry point */
	NULL,               /* -> select entry point */
	NULL,                /* -> deselect entry point */
	NULL,               /* -> readv */
	NULL                /* -> writev */
};


static int32
get_pci_list(pci_info *info[], int32 maxEntries)
{
	int32 i, entries;
	pci_info *item;

	item = (pci_info *)malloc(sizeof(pci_info));
	if (item == NULL)
		return 0;

	for (i = 0, entries = 0; entries < maxEntries; i++) {
		if (gPCIModInfo->get_nth_pci_info(i, item) != B_OK)
			break;

		if ((item->vendor_id == 0x10ec && item->device_id == 0x8029)		// RealTek 8029
			|| (item->vendor_id == 0x1106 && item->device_id == 0x0926)		// VIA
			|| (item->vendor_id == 0x4a14 && item->device_id == 0x5000)		// NetVin 5000
			|| (item->vendor_id == 0x1050 && item->device_id == 0x0940)		// ProLAN
			|| (item->vendor_id == 0x11f6 && item->device_id == 0x1401)		// Compex
			|| (item->vendor_id == 0x8e2e && item->device_id == 0x3000)) {	// KTI
			/* check if the device really has an IRQ */
			if (item->u.h0.interrupt_line == 0 || item->u.h0.interrupt_line == 0xFF) {
				dprintf(kDevName " found with invalid IRQ - check IRQ assignement");
				continue;
			}

			dprintf(kDevName " found at IRQ %x ", item->u.h0.interrupt_line);
			info[entries++] = item;
			item = (pci_info *)malloc(sizeof(pci_info));
			if (item == NULL)
				break;
		}
	}
	info[entries] = NULL;
	free(item);
	return entries;
}


static status_t
free_pci_list(pci_info *info[])
{
	pci_info *item;
	int32 i;

	for (i = 0; (item = info[i]) != NULL; i++) {
		free(item);
	}
	return B_OK;
}


#if 0
/*! How many waiting for io? */
static long
io_count(etherpci_private_t *data)
{
	long count;

	get_sem_count(data->iolock, &count);
	return (count);
}


/*! How many waiting for output? */
static long
output_count(etherpci_private_t *data)
{
	long count;

	get_sem_count(data->olock, &count);
	return (count);
}
#endif

/*
 * How many waiting for input?
 */
static int32
input_count(etherpci_private_t *data)
{
	int32 count;

	get_sem_count(data->ilock, &count);
	return (count);
}

#if STAY_ON_PAGE_0

#define INTR_LOCK(data, expression) (expression)

#else /* STAY_ON_PAGE_0 */

/*
 * Spinlock for negotiating access to card with interrupt handler
 */
#define intr_lock(data)			acquire_spinlock(&data->intrlock)
#define intr_unlock(data)		release_spinlock(&data->intrlock)

/*
 * The interrupt handler must lock all calls to the card
 * This macro is useful for that purpose.
 */
#define INTR_LOCK(data, expression) (intr_lock(data), (expression), intr_unlock(data))

#endif /* STAY_ON_PAGE_0 */


/*
 * Calculate various constants
 * These must be done at runtime, since 3com and ne2000 cards have different
 * values.
 */
static void
calc_constants(etherpci_private_t *data)
{
	data->EC_VMEM_PAGE = (data->ETHER_BUF_START >> EC_PAGE_SHIFT);
	data->EC_VMEM_NPAGES = (data->ETHER_BUF_SIZE >> EC_PAGE_SHIFT);

	data->EC_RXBUF_START_PAGE = (data->EC_VMEM_PAGE + 6);
	data->EC_RXBUF_END_PAGE = (data->EC_VMEM_PAGE + data->EC_VMEM_NPAGES);

	data->EC_RINGSTART = (data->EC_RXBUF_START_PAGE << EC_PAGE_SHIFT);
	data->EC_RINGSIZE = ((data->EC_VMEM_NPAGES - 6) << EC_PAGE_SHIFT);
}


/*! Print an ethernet address */
static void
print_address(ether_address_t *addr)
{
	int i;
	char buf[3 * 6 + 1];

	for (i = 0; i < 5; i++) {
		sprintf(&buf[3*i], "%02x:", addr->ebyte[i]);
	}
	sprintf(&buf[3*5], "%02x", addr->ebyte[5]);
	dprintf("%s\n", buf);
}


/*! Get the isr register */
static unsigned char
getisr(etherpci_private_t *data)
{
	return ether_inb(data, EN0_ISR);
}


/*! Set the isr register */
static void
setisr(etherpci_private_t *data, unsigned char isr)
{
	ether_outb(data, EN0_ISR, isr);
}


/*! Wait for the DMA to complete */
static int
wait_for_dma_complete(etherpci_private_t *data, unsigned short addr,
	unsigned short size)
{
	unsigned short hi, low;
	unsigned short where;
	int bogus;

#define MAXBOGUS 20

	/*
	 * This is the expected way to wait for DMA completion, which
	 * is in fact incorrect. I think ISR_DMADONE gets set too early.
	 */
	bogus = 0;
	while (!(getisr(data) & ISR_DMADONE) && ++bogus < MAXBOGUS) {
		/* keep waiting */
	}
	if (bogus >= MAXBOGUS)
		dprintf("Bogus alert: waiting for ISR\n");

	/*
	 * This is the workaround
	 */
	bogus = 0;
	do {
		hi = ether_inb(data, EN0_RADDRHI);
		low = ether_inb(data, EN0_RADDRLO);
		where = (hi << 8) | low;
	} while (where < addr + size && ++bogus < MAXBOGUS);

	if (bogus >= MAXBOGUS * 2) {
		/*
		 * On some cards, the counters will never clear.
		 * So only print this message when debugging.
		 */
		dprintf("Bogus alert: waiting for counters to zero\n");
		return -1;
	}

	setisr(data, ISR_DMADONE);
	ether_outb(data, EN_CCMD, ENC_NODMA);
	return 0;
}


/*! Check the status of the last packet transmitted */
static void
check_transmit_status(etherpci_private_t *data)
{
	unsigned char status;

	status = ether_inb(data, EN0_TPSR);
	if (status & (TSR_ABORTED | TSR_UNDERRUN)) {
		dprintf("transmit error: %02x\n", status);
	}
#if 0
	if (data->wints + data->werrs != data->writes) {
		dprintf("Write interrupts %d, errors %d, transmits %d\n",
				data->wints, data->werrs, data->writes);
	}
#endif
}


static long
inrw(etherpci_private_t *data)
{
	return data->inrw;
}


static status_t
create_sems(etherpci_private_t *data)
{
	data->iolock = create_sem(1, "ethercard io");
	if (data->iolock < B_OK)
		return data->iolock;

	data->olock = create_sem(1, "ethercard output");
	if (data->olock < B_OK) {
		delete_sem(data->iolock);
		return data->olock;
	}

	data->ilock = create_sem(0, "ethercard input");
	if (data->ilock < B_OK) {
		delete_sem(data->iolock);
		delete_sem(data->olock);
		return data->ilock;
	}

	return B_OK;
}


/*! Get data from the ne2000 card */
static void
etherpci_min(etherpci_private_t *data, unsigned char *dst,
	unsigned src, unsigned len)
{
	unsigned int i;

	if (len & 1)
		len++;

	ether_outb(data, EN0_RCNTLO, len & 0xff);
	ether_outb(data, EN0_RCNTHI, len >> 8);
	ether_outb(data, EN0_RADDRLO, src & 0xff);
	ether_outb(data, EN0_RADDRHI, src >> 8);
	ether_outb(data, EN_CCMD, ENC_DMAREAD);

	for (i = 0; i < len; i += 2) {
		unsigned short word;

		word = ether_inw(data, NE_DATA);
#if __i386__
		dst[i + 1] = word >> 8;
		dst[i + 0] = word & 0xff;
#else
		dst[i] = word >> 8;
		dst[i + 1] = word & 0xff;
#endif
	}
	wait_for_dma_complete(data, src, len);
}


/*! Put data on the ne2000 card */
static void
etherpci_mout(etherpci_private_t *data, unsigned dst,
	const unsigned char *src, unsigned len)
{
	unsigned int i;
	int tries = 1;

	// This loop is for a bug that showed up with the old ISA 3com cards
	// that were in the original BeBox.  Sometimes the dma status would just
	// stop on some part of the buffer, never finishing.
	// If we notice this error, we redo the dma transfer.
again:
#define MAXTRIES 2
	if (tries > MAXTRIES) {
		dprintf("ether_mout : tried %d times, stopping\n", tries);
		return;
	}

	if (len & 1)
		len++;

	ether_outb(data, EN0_RCNTHI, len >> 8);
	ether_outb(data, EN0_RADDRLO, dst & 0xff);
	ether_outb(data, EN0_RADDRHI, dst >> 8);

	/*
	 * The 8390 hardware has documented bugs in it related to DMA write.
	 * So, we follow the documentation on how to work around them.
	 */

	/*
	 * Step 1: You must put a non-zero value in this register. We use 2.
	 */
	if ((len & 0xff) == 0) {
		ether_outb(data, EN0_RCNTLO, 2);
	} else {
		ether_outb(data, EN0_RCNTLO, len & 0xff);
	}

#if you_want_to_follow_step2_even_though_it_hangs
	ether_outb(data, EN_CCMD, ENC_DMAREAD);				/* Step 2 */
#endif

	ether_outb(data, EN_CCMD, ENC_DMAWRITE);

	for (i = 0; i < len; i += 2) {
		unsigned short word;

#if __i386__
		word = (src[i + 1] << 8) | src[i + 0];
#else
		word = (src[i] << 8) | src[i + 1];
#endif
		ether_outw(data, NE_DATA, word);
	}

	if ((len & 0xff) == 0) {
		/*
		 * Write out the two extra bytes
		 */
		ether_outw(data, NE_DATA, 0);
		len += 2;
	}
	if (wait_for_dma_complete(data, dst, len) != 0) {
		tries++;
		goto again;
	}
	//if (tries != 1) { dprintf("wait_for_dma worked after %d tries\n", tries); }
}


#if STAY_ON_PAGE_0
/*! Zero out the headers in the ring buffer */
static void
ringzero(etherpci_private_t *data, unsigned boundary,
	unsigned next_boundary)
{
	ring_header ring;
	int i;
	int pages;
	unsigned offset;

	ring.count = 0;
	ring.next_packet = 0;
	ring.status = 0;

	if (data->boundary < next_boundary) {
		pages = next_boundary - data->boundary;
	} else {
		pages = (data->EC_RINGSIZE >> EC_PAGE_SHIFT) - (data->boundary - next_boundary);
	}

	for (i = 0; i < pages; i++) {
		offset = data->boundary << EC_PAGE_SHIFT;
		etherpci_mout(data, offset, (unsigned char *)&ring, sizeof(ring));
		data->boundary++;
		if (data->boundary >= data->EC_RXBUF_END_PAGE) {
			data->boundary = data->EC_RXBUF_START_PAGE;
		}
	}
}
#endif /* STAY_ON_PAGE_0 */


/*! Determine if we have an ne2000 PCI card */
static int
probe(etherpci_private_t *data)
{
	unsigned int i;
	int reg;
	unsigned char test[EC_PAGE_SIZE];
	short waddr[ETHER_ADDR_LEN];
	uint8 reg_val;

	data->ETHER_BUF_START = ETHER_BUF_START_NE2000;
	data->ETHER_BUF_SIZE = ETHER_BUF_SIZE_NE2000;
	calc_constants(data);

	reg = ether_inb(data, NE_RESET);
	snooze(2000);
	ether_outb(data, NE_RESET, reg);
	snooze(2000);
	ether_outb(data, EN_CCMD, ENC_NODMA | ENC_STOP | ENC_PAGE0);

	i = 10000;
	while ( i-- > 0) {
		reg_val = ether_inb(data, EN0_ISR);
		if (reg_val & ISR_RESET) break;
	}
	if (i < 0)
		dprintf("reset failed -- ignoring\n");

	ether_outb(data, EN0_ISR, 0xff);
	ether_outb(data, EN0_DCFG, DCFG_BM16);
	ether_outb(data, EN_CCMD, ENC_NODMA | ENC_STOP | ENC_PAGE0);

	snooze(2000);

	reg = ether_inb(data, EN_CCMD);
	if (reg != (ENC_NODMA|ENC_STOP|ENC_PAGE0)) {
		dprintf("command register failed: %02x != %02x\n", reg, ENC_NODMA|ENC_STOP);
		return 0;
	}

	ether_outb(data, EN0_TXCR, 0);
	ether_outb(data, EN0_RXCR, ENRXCR_MON);
	ether_outb(data, EN0_STARTPG, data->EC_RXBUF_START_PAGE);
	ether_outb(data, EN0_STOPPG, data->EC_RXBUF_END_PAGE);
	ether_outb(data, EN0_BOUNDARY, data->EC_RXBUF_END_PAGE);
	ether_outb(data, EN0_IMR, 0);
	ether_outb(data, EN0_ISR, 0);
	ether_outb(data, EN_CCMD, ENC_NODMA | ENC_PAGE1 | ENC_STOP);
	ether_outb(data, EN1_CURPAG, data->EC_RXBUF_START_PAGE);
	ether_outb(data, EN_CCMD, ENC_NODMA | ENC_PAGE0 | ENC_STOP);

	/* stop chip */
	ether_outb(data, EN_CCMD, ENC_NODMA | ENC_PAGE0);
	ether_outb(data, EN_CCMD, ENC_NODMA | ENC_STOP);

	memset(&waddr[0], 0, sizeof(waddr));
	etherpci_min(data, (unsigned char *)&waddr[0], 0, sizeof(waddr));

	for (i = 0; i < ETHER_ADDR_LEN; i++) {
		data->myaddr.ebyte[i] = ((unsigned char *)&waddr[0])[2*i];
	}

	/* test memory */
	for (i = 0; i < sizeof(test); i++) {
		test[i] = i;
	}

	etherpci_mout(data, data->ETHER_BUF_START, (unsigned char *)&test[0], sizeof(test));
	memset(&test, 0, sizeof(test));
	etherpci_min(data, (unsigned char *)&test[0], data->ETHER_BUF_START, sizeof(test));

	for (i = 0; i < sizeof(test); i++) {
		if (test[i] != i) {
			dprintf("memory test failed: %02x %02x\n", i, test[i]);
			return 0;
		}
	}

	dprintf("ne2000 pci ethernet card found - ");
	print_address(&data->myaddr);
	return 1;
}


/*! Initialize the ethernet card */
static void
init(etherpci_private_t *data)
{
	int i;

#if STAY_ON_PAGE_0
	/*
	 * Set all the ring headers to zero
	 */
	ringzero(data, data->EC_RXBUF_START_PAGE, data->EC_RXBUF_END_PAGE);
#endif /* STAY_ON_PAGE_0 */

	/* initialize data configuration register */
	ether_outb(data, EN0_DCFG, DCFG_BM16);

	/* clear remote byte count registers */
	ether_outb(data, EN0_RCNTLO, 0x0);
	ether_outb(data, EN0_RCNTHI, 0x0);

	/* initialize receive configuration register */
	ether_outb(data, EN0_RXCR, ENRXCR_BCST);

	/* get into loopback mode */
	ether_outb(data, EN0_TXCR, TXCR_LOOPBACK);

	/* set boundary, page start and page stop */
	ether_outb(data, EN0_BOUNDARY, data->EC_RXBUF_END_PAGE);
	data->boundary = data->EC_RXBUF_START_PAGE;
	ether_outb(data, EN0_STARTPG, data->EC_RXBUF_START_PAGE);
	ether_outb(data, EN0_STOPPG, data->EC_RXBUF_END_PAGE);

	/* set transmit page start register */
	ether_outb(data, EN0_TPSR, data->EC_VMEM_PAGE);

	/* clear interrupt status register */
	ether_outb(data, EN0_ISR, 0xff);

	/* initialize interrupt mask register */
	ether_outb(data, EN0_IMR, INTS_WE_CARE_ABOUT);

	/* set page 1 */
	ether_outb(data, EN_CCMD, ENC_NODMA | ENC_PAGE1);

	/* set physical address */
	for (i = 0; i < 6; i++) {
		ether_outb(data, EN1_PHYS + i, data->myaddr.ebyte[i]);
	}

	/* set multicast address */
	for (i = 0; i < 8; i++) {
		ether_outb(data, EN1_MULT+i, 0xff);
	}
	data->nmulti = 0;

	/* set current pointer */
	ether_outb(data, EN1_CURPAG, data->EC_RXBUF_START_PAGE);

	/* start chip */
	ether_outb(data, EN_CCMD, ENC_START | ENC_PAGE0 | ENC_NODMA);

	/* initialize transmit configuration register */
	ether_outb(data, EN0_TXCR, 0x00);
}


/*! Copy data from the card's ring buffer */
static void
ringcopy(etherpci_private_t *data, unsigned char *ether_buf,
	int offset, int len)
{
	int roffset;
	int rem;

	roffset = offset - data->EC_RINGSTART;
	rem = data->EC_RINGSIZE - roffset;
	if (len > rem) {
		etherpci_min(data, &ether_buf[0], offset, rem);
		etherpci_min(data, &ether_buf[rem], data->EC_RINGSTART, len - rem);
	} else {
		etherpci_min(data, &ether_buf[0], offset, len);
	}
}


/*!
	Set the boundary register, both on the card and internally
	NOTE: you cannot make the boundary = current register on the card,
	so we actually set it one behind.
*/
static void
setboundary(etherpci_private_t *data, unsigned char nextboundary)
{
	if (nextboundary != data->EC_RXBUF_START_PAGE) {
		ether_outb(data, EN0_BOUNDARY, nextboundary - 1);
	} else {
		/* since it's a ring buffer */
		ether_outb(data, EN0_BOUNDARY, data->EC_RXBUF_END_PAGE - 1);
	}
	data->boundary = nextboundary;
}


/*! Start resetting the chip, because of ring overflow */
static int
reset(etherpci_private_t *data)
{
	unsigned char cmd;
	int resend = false;

	cmd = ether_inb(data, EN_CCMD);
	ether_outb(data, EN_CCMD, ENC_STOP | ENC_NODMA);
	snooze(10 * 1000);
	ether_outb(data, EN0_RCNTLO, 0x0);
	ether_outb(data, EN0_RCNTHI, 0x0);
	if (cmd & ENC_TRANS) {
		if(!(getisr(data) & (ISR_TRANSMIT | ISR_TRANSMIT_ERROR)))
			resend = true;  // xmit command issued but ISR shows its not completed
	}
	/* get into loopback mode */
	ether_outb(data, EN0_TXCR, TXCR_LOOPBACK);
	ether_outb(data, EN_CCMD, ENC_START | ENC_PAGE0 | ENC_NODMA);
	return (resend);
}


/*! finish the reset */
static void
finish_reset(etherpci_private_t *data, int resend)
{
	setisr(data, ISR_OVERWRITE);
	ether_outb(data, EN0_TXCR, 0x00);

	if (resend) {
//		dprintf("Xmit CMD resent\n");
		ether_outb(data, EN_CCMD, ENC_START | ENC_PAGE0 | ENC_NODMA | ENC_TRANS);
	}
}


/*! Handle ethernet interrupts */
static int32
etherpci_interrupt(void *_data)
{
	etherpci_private_t *data = (etherpci_private_t *) _data;
	unsigned char isr;
	int wakeup_reader = 0;
	int wakeup_writer = 0;
	int32 handled = B_UNHANDLED_INTERRUPT;
	data->ints++;

	ETHER_DEBUG(INTERRUPT, data->debug, "ENTR isr=%x & %x?\n",getisr(data), INTS_WE_CARE_ABOUT);
	for (INTR_LOCK(data, isr = getisr(data));
			isr & INTS_WE_CARE_ABOUT;
			INTR_LOCK(data, isr = getisr(data))) {
		if (isr & ISR_RECEIVE) {
			data->rints++;
			wakeup_reader++;
			INTR_LOCK(data, setisr(data, ISR_RECEIVE));
			handled = B_HANDLED_INTERRUPT;
			continue;
		}
		if (isr & ISR_TRANSMIT_ERROR) {
			data->werrs++;
			INTR_LOCK(data, setisr(data, ISR_TRANSMIT_ERROR));
			wakeup_writer++;
			handled = B_HANDLED_INTERRUPT;
			continue;
		}
		if (isr & ISR_TRANSMIT) {
			data->wints++;
			INTR_LOCK(data, setisr(data, ISR_TRANSMIT));
			wakeup_writer++;
			handled = B_HANDLED_INTERRUPT;
			continue;
		}
		if (isr & ISR_RECEIVE_ERROR) {
			uint32 err_count;
			err_count = ether_inb(data, EN0_CNTR0);  data->frame_errs += err_count;
			err_count = ether_inb(data, EN0_CNTR1);  data->crc_errs += err_count;
			err_count = ether_inb(data, EN0_CNTR2);  data->frames_lost += err_count;

			isr &= ~ISR_RECEIVE_ERROR;
			INTR_LOCK(data, setisr(data, ISR_RECEIVE_ERROR));
			handled = B_HANDLED_INTERRUPT;
		}
		if (isr & ISR_DMADONE) {
			isr &= ~ISR_DMADONE;	/* handled elsewhere */
			handled = B_HANDLED_INTERRUPT;
		}
		if (isr & ISR_OVERWRITE) {
			isr &= ~ISR_OVERWRITE; /* handled elsewhere */
			handled = B_HANDLED_INTERRUPT;
		}

		if (isr & ISR_COUNTER) {
			isr &= ~ISR_COUNTER; /* handled here */
//			dprintf("Clearing Stats Cntr\n");
			INTR_LOCK(data, setisr(data, ISR_COUNTER));
			handled = B_HANDLED_INTERRUPT;
		}

		if (isr) {
			/*
			 * If any other interrupts, just clear them (hmmm....)
			 * ??? This doesn't seem right - HB
			 */
//			ddprintf("ISR=%x rdr=%x wtr=%x io=%x inrw=%x nonblk=%x\n",
//				isr,input_count(data), output_count(data),io_count(data),
//				data->inrw,data->nonblocking);
			INTR_LOCK(data, setisr(data, isr));
			data->interrs++;
		}
	}
	if (wakeup_reader) {
		input_unwait(data, 1);
	}
	if (wakeup_writer) {
		output_unwait(data, 1);
	}

	return handled;
}


/*! Check to see if there are any new errors */
static void
check_errors(etherpci_private_t *data)
{
#define DOIT(stat, message) \
	if (stat > stat##_last) { \
		stat##_last = stat; \
		dprintf(message, stat##_last); \
	}

	DOIT(data->rerrs, "Receive errors now %d\n");
	DOIT(data->werrs, "Transmit errors now %d\n");
	DOIT(data->interrs, "Interrupt errors now %d\n");
	DOIT(data->frames_lost, "Frames lost now %d\n");
#undef DOIT
#if 0
	/*
	 * these are normal errors because collisions are normal
	 * so don't make a big deal about them.
	 */
	DOIT(data->frame_errs, "Frame alignment errors now %d\n");
	DOIT(data->crc_errs, "CRC errors now %d\n");
#endif
}


/*! Find out if there are any more packets on the card */
static int
more_packets(etherpci_private_t *data, int didreset)
{
#if STAY_ON_PAGE_0
	unsigned offset;
	ring_header ring;

	offset = data->boundary << EC_PAGE_SHIFT;
	etherpci_min(data, (unsigned char *)&ring, offset, sizeof(ring));
	return ring.status && ring.next_packet && ring.count;

#else /* STAY_ON_PAGE_0 */

	cpu_status ps;
	unsigned char cur;

	/*
	 * First, get the current registe
	 */
	ps = disable_interrupts();
	intr_lock(data);
	ether_outb(data, EN_CCMD, ENC_PAGE1);
	cur = ether_inb(data, EN1_CURPAG);
	ether_outb(data, EN_CCMD, ENC_PAGE0);
	intr_unlock(data);
	restore_interrupts(ps);

	/*
	 * Then return the result
	 * Must use didreset since cur == boundary in
	 * an overflow situation.
	 */
	return didreset || cur != data->boundary;
#endif	/* STAY_ON_PAGE_0 */
}


/*! Copy a packet from the ethernet card */
static int
copy_packet(etherpci_private_t *data, unsigned char *ether_buf,
	int buflen)
{
	ring_header ring;
	unsigned offset;
	int len;
	int rlen;
	int ether_len = 0;
	int didreset = 0;
	int resend = 0;

	io_lock(data);
	check_errors(data);

	/*
	 * Check for overwrite error first
	 */
	if (getisr(data) & ISR_OVERWRITE) {
//		dprintf("starting ether reset!\n");
		data->resets++;
		resend = reset(data);
		didreset++;
	}

	if (more_packets(data, didreset)) do {
		/*
		 * Read packet ring header
		 */
		offset = data->boundary << EC_PAGE_SHIFT;
		etherpci_min(data, (unsigned char *)&ring, offset, sizeof(ring));

		len = swapshort(ring.count);

		if (!(ring.status & RSR_INTACT)) {
			dprintf("packet not intact! (%02x,%u,%02x) (%d)\n",
				ring.status, ring.next_packet, ring.count, data->boundary);

			/* discard bad packet */
			ether_len = 0; setboundary(data, ring.next_packet);
			break;
		}

		if (ring.next_packet < data->EC_RXBUF_START_PAGE
			|| ring.next_packet >= data->EC_RXBUF_END_PAGE) {
			dprintf("etherpci_read: bad next packet! (%02x,%u,%02x) (%d)\n",
				ring.status, ring.next_packet, ring.count, data->boundary);

			data->rerrs++;
			/* discard bad packet */
			ether_len = 0; setboundary(data, ring.next_packet);
			break;
		}

		len = swapshort(ring.count);
		rlen = len - 4;
		if (rlen < ETHER_MIN_SIZE || rlen > ETHER_MAX_SIZE) {
			dprintf("etherpci_read: bad length! (%02x,%u,%02x) (%d)\n",
				ring.status, ring.next_packet, ring.count, data->boundary);

			data->rerrs++;
			/* discard bad packet */
			ether_len = 0; setboundary(data, ring.next_packet);
			break;
		}

		if (rlen > buflen)
			rlen = buflen;

		ringcopy(data, ether_buf, offset + 4, rlen);

#if STAY_ON_PAGE_0
		ringzero(data, data->boundary, ring.next_packet);
#endif /* STAY_ON_PAGE_0 */

		ether_len = rlen;
		setboundary(data, ring.next_packet);
		data->reads++;
	} while (0);

	if (didreset) {
		dprintf("finishing reset!\n");
		finish_reset(data, resend);
	}

	if (input_count(data) <= 0 && more_packets(data, didreset)) {
		/*
		 * Looks like there is another packet
		 * So, make sure they get woken up
		 */
		input_unwait(data, 1);
	}

	io_unlock(data);
	return ether_len;
}


/*! Checks if the received packet is really for us */
static int
my_packet(etherpci_private_t *data, char *addr)
{
	unsigned int i;
	const char broadcast[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

	if (memcmp(addr, &data->myaddr, sizeof(data->myaddr)) == 0
		|| memcmp(addr, broadcast, sizeof(broadcast)) == 0)
		return 1;

	for (i = 0; i < data->nmulti; i++) {
		if (memcmp(addr, &data->multi[i], sizeof(data->multi[i])) == 0)
			return 1;
	}

	return 0;
}


static status_t
enable_addressing(etherpci_private_t *data)
{
	unsigned char cmd;

#if __i386__
	data->reg_base = data->pciInfo->u.h0.base_registers[0];
#else
	uint32 base, size, offset;
	base = data->pciInfo->u.h0.base_registers[0];
	size = data->pciInfo->u.h0.base_register_sizes[0];

	/* Round down to nearest page boundary */
	base = base & ~(B_PAGE_SIZE-1);

	/* Adjust the size */
	offset = data->pciInfo->u.h0.base_registers[0] - base;
	size += offset;
	size = (size +(B_PAGE_SIZE-1)) & ~(B_PAGE_SIZE-1);

	dprintf(kDevName ": PCI base=%x size=%x offset=%x\n", base, size, offset);

	if ((data->ioarea = map_physical_memory(kDevName "_regs", base, size,
			B_ANY_KERNEL_ADDRESS, B_READ_AREA | B_WRITE_AREA,
			(void **)&data->reg_base)) < 0) {
		return B_ERROR;
	}

	data->reg_base = data->reg_base + offset;

#endif
	dprintf(kDevName ": reg_base=%" B_PRIx32 "\n", data->reg_base);

	/* enable pci address access */
	cmd = (gPCIModInfo->read_pci_config)(data->pciInfo->bus, data->pciInfo->device, data->pciInfo->function, PCI_command, 2);
	(gPCIModInfo->write_pci_config)(data->pciInfo->bus, data->pciInfo->device, data->pciInfo->function, PCI_command, 2, cmd | PCI_command_io);

	return B_OK;
}


static int
domulti(etherpci_private_t *data, char *addr)
{
	int i;
	int nmulti = data->nmulti;

	if (nmulti == MAX_MULTI)
		return B_ERROR;

	for (i = 0; i < nmulti; i++) {
		if (memcmp(&data->multi[i], addr, sizeof(data->multi[i])) == 0) {
			break;
		}
	}

	if (i == nmulti) {
		/*
		 * Only copy if it isn't there already
		 */
		memcpy(&data->multi[i], addr, sizeof(data->multi[i]));
		data->nmulti++;
	}
	if (data->nmulti == 1) {
		dprintf("Enabling multicast\n");
		ether_outb(data, EN0_RXCR, ENRXCR_BCST | ENRXCR_MCST);
	}

	return B_NO_ERROR;
}


/*!
	Serial Debugger command
	Connect a terminal emulator to the serial port at 19.2 8-1-None
	Press the keys ( alt-sysreq on Intel) or (Clover-leaf Power on Mac ) to enter the debugger
	At the kdebug> prompt enter "etherpci arg...",
	for example "etherpci R" to enable a received packet trace.
*/
#if DEBUGGER_COMMAND
static int
etherpci(int argc, char **argv) {
	uint16 i,j;
	const char * usage = "usage: etherpci { Function_calls | PCI_IO | Stats | Rx_trace | Tx_trace }\n";


	if (argc < 2) {
		kprintf("%s",usage);	return 0;
	}

	for (i= argc, j= 1; i > 1; i--, j++) {
		switch (*argv[j]) {
		case 'F':
		case 'f':
			gdev->debug ^= FUNCTION;
			if (gdev->debug & FUNCTION)
				kprintf("Function() call trace Enabled\n");
			else
				kprintf("Function() call trace Disabled\n");
			break;
		case 'N':
		case 'n':
			gdev->debug ^= SEQ;
			if (gdev->debug & SEQ)
				kprintf("Sequence numbers packet trace Enabled\n");
			else
				kprintf("Sequence numbers packet trace Disabled\n");
			break;
		case 'R':
		case 'r':
			gdev->debug ^= RX;
			if (gdev->debug & RX)
				kprintf("Receive packet trace Enabled\n");
			else
				kprintf("Receive packet trace Disabled\n");
			break;
		case 'T':
		case 't':
			gdev->debug ^= TX;
			if (gdev->debug & TX)
				kprintf("Transmit packet trace Enabled\n");
			else
				kprintf("Transmit packet trace Disabled\n");
			break;
		case 'S':
		case 's':
			kprintf(kDevName " statistics\n");
			kprintf("rx_ints %d,  tx_ints %d\n", gdev->rints, gdev->wints);
			kprintf("resets %d \n", gdev->resets);
			kprintf("crc_errs %d, frame_errs %d, frames_lost %d\n", gdev->crc_errs, gdev->frame_errs, gdev->frames_lost);
			break;
		case 'P':
		case 'p':
			gdev->debug ^= PCI_IO;
			if (gdev->debug & PCI_IO)
				kprintf("PCI IO trace Enabled\n");
			else
				kprintf("PCI IO trace Disabled\n");
			break;
		default:
			kprintf("%s",usage);
			return 0;
		}
	}

	return 0;
}
#endif /* DEBUGGER_COMMAND */


static void
dump_packet(const char * msg, unsigned char * buf, uint16 size)
{
	uint16 j;

	dprintf("%s dumping %p size %u \n", msg, buf, size);
	for (j = 0; j < size; j++) {
		if ((j & 0xF) == 0)
			dprintf("\n");
		dprintf("%2.2x ", buf[j]);
	}
}


//	#pragma mark - Driver Entry Points


status_t
init_hardware(void)
{
	return B_NO_ERROR;
}


status_t
init_driver(void)
{
	status_t status;
	int32 entries;
	char devName[64];
	int32 i;

	dprintf(kDevName ": init_driver ");

	if ((status = get_module( B_PCI_MODULE_NAME, (module_info **)&gPCIModInfo )) != B_OK) {
		dprintf(kDevName " Get module failed! %s\n", strerror(status ));
		return status;
	}

	/* Find Lan cards*/
	if ((entries = get_pci_list(gDevList, MAX_CARDS )) == 0) {
		dprintf("init_driver: " kDevName " not found\n");
		free_pci_list(gDevList);
		put_module(B_PCI_MODULE_NAME );
		return B_ERROR;
	}
	dprintf("\n");

	/* Create device name list*/
	for (i=0; i<entries; i++ )
	{
		sprintf(devName, "%s%" B_PRId32, kDevDir, i );
		gDevNameList[i] = (char *)malloc(strlen(devName)+1);
		strcpy(gDevNameList[i], devName);
	}
	gDevNameList[i] = NULL;

	return B_OK;
}


void
uninit_driver(void)
{
	void *item;
	int32 i;

	/*Free device name list*/
	for (i = 0; (item = gDevNameList[i]) != NULL; i++) {
		free(item);
	}

	/*Free device list*/
	free_pci_list(gDevList);
	put_module(B_PCI_MODULE_NAME);
}


device_hooks *
find_device(const char *name)
{
	int32 i;
	char *item;

	/* Find device name */
	for (i = 0; (item = gDevNameList[i]) != NULL; i++) {
		if (!strcmp(name, item))
			return &gDeviceHooks;
	}

	return NULL;
}


const char**
publish_devices(void)
{
	dprintf(kDevName ": publish_devices()\n");
	return (const char **)gDevNameList;
}


//	#pragma mark Device Hooks


/*! Implements the read() system call to the ethernet driver */
static status_t
read_hook(void *_data, off_t pos, void *buf, size_t *len)
{
	etherpci_private_t *data = (etherpci_private_t *) _data;
	ulong buflen;
	int packet_len;

	buflen = *len;
	atomic_add(&data->inrw, 1);
	if (data->interrupted) {
		atomic_add(&data->inrw, -1);
		return B_INTERRUPTED;
	}

	do {
		if (!data->nonblocking) {
			input_wait(data);
		}
		if (data->interrupted) {
			atomic_add(&data->inrw, -1);
			return B_INTERRUPTED;
		}
		packet_len = copy_packet(data, (unsigned char *)buf, buflen);
		if ((packet_len) && (data->debug & RX)) {
			dump_packet("RX:" ,buf, packet_len);
		}
	} while (!data->nonblocking && packet_len == 0 && !my_packet(data, buf));

	atomic_add(&data->inrw, -1);
	*len = packet_len;
	return 0;
}


static status_t
open_hook(const char *name, uint32 flags, void **cookie)
{
	int32 devID;
	int32 mask;
	status_t status;
	char *devName;
	etherpci_private_t *data;

	/*	Find device name*/
	for (devID = 0; (devName = gDevNameList[devID]); devID++) {
		if (strcmp(name, devName) == 0)
			break;
	}
	if (!devName)
		return EINVAL;

	/* Check if the device is busy and set in-use flag if not */
	mask = 1 << devID;
	if (atomic_or(&gOpenMask, mask) &mask)
		return B_BUSY;

	/*	Allocate storage for the cookie*/
	if (!(*cookie = data = (etherpci_private_t *)malloc(sizeof(etherpci_private_t)))) {
		status = B_NO_MEMORY;
		goto err0;
	}
	memset(data, 0, sizeof(etherpci_private_t));

	/* Setup the cookie */
	data->pciInfo = gDevList[devID];
	data->devID = devID;
	data->interrupted = 0;
	data->inrw = 0;
	data->nonblocking = 0;

	data->debug = DEFAULT_DEBUG_FLAGS;
	ETHER_DEBUG(FUNCTION, data->debug, kDevName ": open %s dev=%p\n", name, data);

#if DEBUGGER_COMMAND
	gdev = data;
	add_debugger_command (kDevName, etherpci, "Ethernet driver Info");
#endif

	/* enable access to the cards address space */
	if ((status = enable_addressing(data)) != B_OK)
		goto err1;

	if (!probe(data)) {
		dprintf(kDevName ": probe failed\n");
		goto err1;
	}

	if (create_sems(data) != B_OK)
		goto err2;

	/* Setup interrupts */
	install_io_interrupt_handler( data->pciInfo->u.h0.interrupt_line, etherpci_interrupt, *cookie, 0 );

	dprintf("Interrupts installed at %x\n", data->pciInfo->u.h0.interrupt_line);
	/* Init Device */
	init(data);

	return B_NO_ERROR;

err2:
#if !__i386__
	delete_area(data->ioarea);
#endif
err1:
#if DEBUGGER_COMMAND
	remove_debugger_command (kDevName, etherpci);
#endif
	free(data);

err0:
	atomic_and(&gOpenMask, ~mask);
	dprintf(kDevName ": open failed!\n");
	return B_ERROR;
}


static status_t
close_hook(void *_data)
{
	etherpci_private_t *data = (etherpci_private_t *)_data;
	ETHER_DEBUG(FUNCTION, data->debug, kDevName ": close dev=%p\n", data);

	/*
	 * Force pending reads and writes to terminate
	 */
	io_lock(data);
	data->interrupted = 1;
	input_unwait(data, 1);
	output_unwait(data, 1);
	io_unlock(data);
	while (inrw(data)) {
		snooze(1000000);
		dprintf("ether: still waiting for read/write to finish\n");
	}

	/*
	 * Stop the chip
	 */
	ether_outb(data, EN_CCMD, ENC_STOP);
	snooze(2000);

	/*
	 * And clean up
	 */
	remove_io_interrupt_handler(data->pciInfo->u.h0.interrupt_line, etherpci_interrupt, data);
	delete_sem(data->iolock);
	delete_sem(data->ilock);
	delete_sem(data->olock);

	/*
	 * Reset all the statistics
	 */
	data->ints = 0;
	data->rints = 0;
	data->rerrs = 0;
	data->wints = 0;
	data->werrs = 0;
	data->reads = 0;
	data->writes = 0;
	data->interrs = 0;
	data->resets = 0;
	data->frame_errs = 0;
	data->crc_errs = 0;
	data->frames_lost = 0;

	data->rerrs_last = 0;
	data->werrs_last = 0;
	data->interrs_last = 0;
	data->frame_errs_last = 0;
	data->crc_errs_last = 0;
	data->frames_lost_last = 0;

	data->chip_rx_frame_errors = 0;
	data->chip_rx_crc_errors = 0;
	data->chip_rx_missed_errors = 0;

#if DEBUGGER_COMMAND
	remove_debugger_command (kDevName, etherpci);
#endif

	return B_OK;
}


static status_t
free_hook(void *_data)
{
	etherpci_private_t *data = (etherpci_private_t *)_data;
	int32 mask;

	ETHER_DEBUG(FUNCTION, data->debug, kDevName ": free dev=%p\n", data);

#if !__i386__
	delete_area(data->ioarea);
#endif

	// make sure the device can be reopened again
	mask = 1L << data->devID;
	atomic_and(&gOpenMask, ~mask);

	free(data);
	return B_OK;
}


static status_t
write_hook(void *_data, off_t pos, const void *buf, size_t *len)
{
	etherpci_private_t *data = (etherpci_private_t *) _data;
	ulong buflen;
	int status;

	buflen = *len;
	atomic_add(&data->inrw, 1);
	if (data->interrupted) {
		atomic_add(&data->inrw, -1);
		return B_INTERRUPTED;
	}
	/*
	 * Wait for somebody else (if any) to finish transmitting
	 */
	status = output_wait(data, ETHER_TRANSMIT_TIMEOUT);
	if (status < B_NO_ERROR || data->interrupted) {
		atomic_add(&data->inrw, -1);
		return status;
	}

	io_lock(data);
	check_errors(data);

	if (data->writes > 0)
		check_transmit_status(data);

	etherpci_mout(data, data->ETHER_BUF_START, (const unsigned char *)buf, buflen);
	if (buflen < ETHER_MIN_SIZE) {
		/*
		 * Round up to ETHER_MIN_SIZE
		 */
		buflen = ETHER_MIN_SIZE;
	}
	ether_outb(data, EN0_TCNTLO, (char)(buflen & 0xff));
	ether_outb(data, EN0_TCNTHI, (char)(buflen >> 8));
	ether_outb(data, EN_CCMD, ENC_NODMA | ENC_TRANS);
	data->writes++;
	io_unlock(data);
	atomic_add(&data->inrw, -1);
	*len = buflen;

	if (data->debug & TX)
		dump_packet("TX:",(unsigned char *) buf, buflen);

	return 0;
}


/*! Standard driver control function */
static status_t
control_hook(void *_data, uint32 msg, void *buf, size_t len)
{
	etherpci_private_t *data = (etherpci_private_t *) _data;

	switch (msg) {
		case ETHER_INIT:
			ETHER_DEBUG(FUNCTION, data->debug, kDevName ": control: ETHER_INIT \n");
			return B_OK;

		case ETHER_GETADDR:
			if (data == NULL)
				return B_ERROR;

			ETHER_DEBUG(FUNCTION, data->debug, kDevName ": control: GET_ADDR \n");
			memcpy(buf, &data->myaddr, sizeof(data->myaddr));
			return B_OK;

		case ETHER_NONBLOCK:
			if (data == NULL)
				return B_ERROR;

			memcpy(&data->nonblocking, buf, sizeof(data->nonblocking));
			ETHER_DEBUG(FUNCTION, data->debug, kDevName ": control: NON_BLOCK %x\n", data->nonblocking);
			return B_OK;

		case ETHER_ADDMULTI:
			ETHER_DEBUG(FUNCTION, data->debug, kDevName ": control: DO_MULTI\n");
			return domulti(data, (char *)buf);
	}

	return B_ERROR;
}