Subversion Repositories planix.SVN

#include "u.h"

#include "../port/lib.h"

#include "mem.h"

#include "dat.h"

#include "fns.h"

#include "io.h"

#include "../port/error.h"

#include "../port/netif.h"

#include "etherif.h"

#include "ether8390.h"

/*

 * Driver written for the 'Notebook Computer Ethernet LAN Adapter',

 * a plug-in to the bus-slot on the rear of the Gateway NOMAD 425DXL

 * laptop. The manual says NE2000 compatible.

 * The interface appears to be pretty well described in the National

 * Semiconductor Local Area Network Databook (1992) as one of the

 * AT evaluation cards.

 *

 * The NE2000 is really just a DP8390[12] plus a data port

 * and a reset port.

 */

enum {

	Data		= 0x10,		/* offset from I/O base of data port */

	Reset		= 0x1F,		/* offset from I/O base of reset port */

};

typedef struct Ctlr Ctlr;

typedef struct Ctlr {

	Pcidev*	pcidev;

	Ctlr*	next;

	int	active;

} Ctlr;

static Ctlr* ctlrhead;

static Ctlr* ctlrtail;

static struct {

	char*	name;

	int	id;

} ne2000pci[] = {

	{ "Realtek 8029",	(0x8029<<16)|0x10EC, },

	{ "Winbond 89C940",	(0x0940<<16)|0x1050, },

	{ nil },

};

static Ctlr*

ne2000match(Ether* edev, int id)

{

	int port;

	Pcidev *p;

	Ctlr *ctlr;

	/*

	 * Any adapter matches if no edev->port is supplied,

	 * otherwise the ports must match.

	 */

	for(ctlr = ctlrhead; ctlr != nil; ctlr = ctlr->next){

		if(ctlr->active)

			continue;

		p = ctlr->pcidev;

		if(((p->did<<16)|p->vid) != id)

			continue;

		port = p->mem[0].bar & ~0x01;

		if(edev->port != 0 && edev->port != port)

			continue;

		/*

		 * It suffices to fill these in,

		 * the rest is gleaned from the card.

		 */

		edev->port = port;

		edev->irq = p->intl;

		ctlr->active = 1;

		return ctlr;

	}

	return nil;

}

static void

ne2000pnp(Ether* edev)

{

	int i, id;

	Pcidev *p;

	Ctlr *ctlr;

	/*

	 * Make a list of all ethernet controllers

	 * if not already done.

	 */

	if(ctlrhead == nil){

		p = nil;

		while(p = pcimatch(p, 0, 0)){

			if(p->ccrb != 0x02 || p->ccru != 0)

				continue;

			ctlr = malloc(sizeof(Ctlr));

			if(ctlr == nil)

				error(Enomem);

			ctlr->pcidev = p;

			if(ctlrhead != nil)

				ctlrtail->next = ctlr;

			else

				ctlrhead = ctlr;

			ctlrtail = ctlr;

		}

	}

	/*

	 * Is it a card with an unrecognised vid+did?

	 * Normally a search is made through all the found controllers

	 * for one which matches any of the known vid+did pairs.

	 * If a vid+did pair is specified a search is made for that

	 * specific controller only.

	 */

	id = 0;

	for(i = 0; i < edev->nopt; i++){

		if(cistrncmp(edev->opt[i], "id=", 3) == 0)

			id = strtol(&edev->opt[i][3], nil, 0);

	}

	if(id != 0)

		ne2000match(edev, id);

	else for(i = 0; ne2000pci[i].name; i++){

		if(ne2000match(edev, ne2000pci[i].id) != nil)

			break;

	}

}

static int

ne2000reset(Ether* edev)

{

	ushort buf[16];

	ulong port;

	Dp8390 *dp8390;

	int i;

	uchar ea[Eaddrlen];

	if(edev->port == 0)

		ne2000pnp(edev);

	/*

	 * Set up the software configuration.

	 * Use defaults for irq, mem and size

	 * if not specified.

	 * Must have a port, no more default.

	 */

	if(edev->port == 0)

		return -1;

	if(edev->irq == 0)

		edev->irq = 2;

	if(edev->mem == 0)

		edev->mem = 0x4000;

	if(edev->size == 0)

		edev->size = 16*1024;

	port = edev->port;

	if(ioalloc(edev->port, 0x20, 0, "ne2000") < 0)

		return -1;

	edev->ctlr = malloc(sizeof(Dp8390));

	dp8390 = edev->ctlr;

	if(dp8390 == nil)

		error(Enomem);

	dp8390->width = 2;

	dp8390->ram = 0;

	dp8390->port = port;

	dp8390->data = port+Data;

	dp8390->tstart = HOWMANY(edev->mem, Dp8390BufSz);

	dp8390->pstart = dp8390->tstart + HOWMANY(sizeof(Etherpkt), Dp8390BufSz);

	dp8390->pstop = dp8390->tstart + HOWMANY(edev->size, Dp8390BufSz);

	dp8390->dummyrr = 1;

	for(i = 0; i < edev->nopt; i++){

		if(strcmp(edev->opt[i], "nodummyrr"))

			continue;

		dp8390->dummyrr = 0;

		break;

	}

	/*

	 * Reset the board. This is done by doing a read

	 * followed by a write to the Reset address.

	 */

	buf[0] = inb(port+Reset);

	delay(2);

	outb(port+Reset, buf[0]);

	delay(2);

	/*

	 * Init the (possible) chip, then use the (possible)

	 * chip to read the (possible) PROM for ethernet address

	 * and a marker byte.

	 * Could just look at the DP8390 command register after

	 * initialisation has been tried, but that wouldn't be

	 * enough, there are other ethernet boards which could

	 * match.

	 * Parallels has buf[0x0E] == 0x00 whereas real hardware

	 * usually has 0x57.

	 */

	dp8390reset(edev);

	memset(buf, 0, sizeof(buf));

	dp8390read(dp8390, buf, 0, sizeof(buf));

	i = buf[0x0E] & 0xFF;

	if((i != 0x00 && i != 0x57) || (buf[0x0F] & 0xFF) != 0x57){

		iofree(edev->port);

		free(edev->ctlr);

		return -1;

	}

	/*

	 * Stupid machine. Shorts were asked for,

	 * shorts were delivered, although the PROM is a byte array.

	 * Set the ethernet address.

	 */

	memset(ea, 0, Eaddrlen);

	if(memcmp(ea, edev->ea, Eaddrlen) == 0){

		for(i = 0; i < sizeof(edev->ea); i++)

			edev->ea[i] = buf[i];

	}

	dp8390setea(edev);

	return 0;

}

void

ether2000link(void)

{

	addethercard("NE2000", ne2000reset);

}