## diffname port/devlance.c 1990/0227
## diff -e /dev/null /n/bootesdump/1990/0227/sys/src/9/mips/devlance.c
0a
#include	"u.h"
#include	"lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"io.h"
#include	"errno.h"
#include	"devtab.h"
/*
 *  configuration parameters
 */
enum {
	Ntypes=		8,		/* max number of ethernet packet types */
	LogNrrb=	7,		/* log of number of receive buffers */
	Nrrb=		(1<<LogNrrb),	/* number of recieve buffers */
	LogNtrb=	7,		/* log of number of transmit buffers */
	Ntrb=		(1<<LogNtrb),	/* number of transmit buffers */
	Ndpkt=		30,		/* number of debug packets */
};
#define RSUCC(x) (((x)+1)%Nrrb)
#define TSUCC(x) (((x)+1)%Ntrb)

/*
 *  Communication with the lance is via a transmit and receive ring of
 *  message descriptors.  The Initblock contains pointers to and sizes of
 *  these rings.  The rings must be in RAM addressible by the lance
 */
typedef struct {
	ushort	laddr;		/* low order piece of address */
	ushort	flags;		/* flags and high order piece of address */
	short	size;		/* size of buffer */
	ushort	cntflags;	/* (rcv)count of bytes in buffer; (xmt) more flags */
} Msg;

/*
 *  Ethernet packet buffers.  These must also be in lance addressible RAM.
 */
typedef struct {
	uchar d[6];
	uchar s[6];
	uchar type[2];
	uchar data[1500];
	uchar crc[4];
} Pkt;

/*
 *  lance memory map
 */
typedef
struct
{
	/*
	 *  initialization block
	 */
	struct initblock {	
		ushort	mode;		/* chip control (see below) */
		ushort	etheraddr[3];	/* the ethernet physical address */
		ushort	multi[4];	/* multicast addresses, 1 bit for each of 64 */
		ushort	rdralow;	/* receive buffer ring */
		ushort	rdrahigh;	/* (top three bits define size of ring) */
		ushort	tdralow;	/* transmit buffer ring */
		ushort	tdrahigh;	/* (top three bits define size of ring) */
	};
	
	/*
	 * ring buffers
	 * first receive, then transmit
	 */
	Msg	rmr[Nrrb];		/* recieve message ring */
	Msg	tmr[Ntrb];		/* transmit message ring */

	/*
	 * actual packets
	 */
	Pkt	p[1];
} Lancemem;
#define LANCEMEM ((Lancemem *)LANCERAM)

/*
 *  Some macros for dealing with lance memory addresses.  The lance splits
 *  its 24 bit addresses across two 16 bit registers.
 */
#define HADDR(a) ((((ulong)(a))>>16)&0xF)
#define LADDR(a) (((ulong)a)&0xFFFF)

/*
 *  one per ethernet packet type
 */
typedef struct {
	QLock;
	int	type;		/* ethernet type */
	Queue	*q;
} Ethertype;

/*
 *  circular debug queue (first 44 bytes of the last Ndpkt packets)
 */
typedef struct {
	uchar d[6];
	uchar s[6];
	uchar type[2];
	uchar data[40];
} Dpkt;
typedef struct {
	Lock;
	int	next;
	char	*tag[Ndpkt];
	int	len[Ndpkt];
	Dpkt	p[Ndpkt];
} Debqueue;

/*
 *  lance state
 */
typedef struct {
	QLock;

	int	inited;
	uchar	ea[6];		/* our ether addr */
	uchar	*lmp;		/* location of parity test */
	ushort	*rap;		/* lance address register */
	ushort	*rdp;		/* lance data register */

	Rendez	rr;		/* rendezvous for an input buffer */
	ushort	rl;		/* first rcv Message belonging to Lance */	
	ushort	rc;		/* first rcv Message belonging to CPU */
	Pkt	*rp[Nrrb];	/* receive buffers */
	int	inpackets;

	Rendez	tr;		/* rendezvous for an output buffer */
	QLock	tlock;		/* semaphore on tc */
	ushort	tl;		/* first xmt Message belonging to Lance */	
	ushort	tc;		/* first xmt Message belonging to CPU */	
	Pkt	*tp[Ntrb];	/* transmit buffers */
	int	outpackets;

	Ethertype e[Ntypes];
	int	debug;
	int	prdebug;
	int	kstarted;
	Debqueue dq;
} Lance;
static Lance l;

/*
 *  mode bits in the lance initialization block
 */
#define PROM	0x8000
#define INTL	0x40
#define DRTY	0x20
#define COLL	0x10
#define DTCR	0x8
#define LOOP	0x4
#define DTX	0x2
#define DRX	0x1

/*
 *  LANCE CSR0, this is the register we play with most often.  We leave
 *  this register pointed to by l.rap in normal operation.
 */
#define ERR0	0x8000
#define BABL	0x4000
#define CERR	0x2000
#define MISS	0x1000
#define MERR	0x800
#define RINT	0x400
#define TINT	0x200
#define IDON	0x100
#define INTR	0x80
#define INEA	0x40
#define RXON	0x20
#define TXON	0x10
#define TDMD	0x8
#define STOP	0x4
#define STRT	0x2
#define INIT	0x1

/*
 *  LANCE CSR3
 */
#define BSWP	0x4
#define ACON	0x2
#define BCON	0x1

/*
 *  flag bits from a buffer descriptor in the rcv/xmt rings
 */
#define OWN	0x8000	/* 1 means that the buffer can be used by the chip */
#define ERR	0x4000	/* error summary, the OR of all error bits */
#define FRAM	0x2000	/* CRC error and incoming packet not a multiple of 8 bits */
#define OFLO	0x1000	/* (receive) lost some of the packet */
#define MORE	0x1000	/* (transmit) more than 1 retry to send the packet */
#define CRC	0x800	/* (receive) crc error reading packet */
#define ONE	0x800	/* (transmit) one retry to transmit the packet */
#define BUF	0x400	/* (receive) out of buffers while reading a packet */
#define DEF	0x400	/* (transmit) deffered while transmitting packet */
#define STP	0x200	/* start of packet */
#define ENP	0x100	/* end of packet */

/*
 *  cntflags bits from a buffer descriptor in the rcv/xmt rings
 */
#define BUFF	0x8000	/* buffer error (host screwed up?) */
#define UFLO	0x4000	/* underflow from memory */
#define LCOL	0x1000	/* late collision (ether too long?) */
#define LCAR	0x800	/* loss of carrier (ether broken?) */
#define RTRY	0x400	/* couldn't transmit (bad station on ether?) */
#define TTDR	0x3FF	/* time domain reflectometer */

/*
 *  predeclared
 */
void lancekproc(void *);

/*
 *  print a packet preceded by a message
 */
printpacket(char *tag, Pkt *p, int len)
{
  print("%s: %d d(%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux)s(%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux)t(%ux %ux)d(%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux)\n",
	tag, len,
	p->d[0], p->d[1], p->d[2], p->d[3], p->d[4], p->d[5],
	p->s[0], p->s[1], p->s[2], p->s[3], p->s[4], p->s[5], p->type[0], p->type[1],
	p->data[0], p->data[1], p->data[2], p->data[3], p->data[4], p->data[5],
	p->data[6], p->data[7], p->data[8], p->data[9], p->data[10], p->data[11]);
}

/*
 *  save a message in a circular queue for later debugging
 */
void
lancedebq(char *tag, Pkt *p, int len)
{
	lock(&l.dq);
	l.dq.tag[l.dq.next] = tag;
	l.dq.len[l.dq.next] = len;
	memcpy(&l.dq.p[l.dq.next], p, sizeof(Dpkt));
	l.dq.next = (l.dq.next+1) % Ndpkt;
	unlock(&l.dq);
}

/*
 *  copy to/from lance memory till we get it right
 */
void
slowcpy(uchar *to, uchar *from, int n)
{
	memcpy(to, from, n);
	while(memcmp(to, from, n)!=0){
		print("lance compare error\n");
		memcpy(to, from, n);
	}
}

/*
 *  lance stream module definition
 */
static void lanceoput(Queue*, Block*);
static void lancestopen(Queue*, Stream*);
static void lancestclose(Queue*);
static void stagerbuf(void);
Qinfo lanceinfo = { nullput, lanceoput, lancestopen, lancestclose, "lance" };

/*
 *  open a lance line discipline
 *
 *  the lock is to synchronize changing the ethertype with
 *  sending packets up the stream on interrupts.
 */
void
lancestopen(Queue *q, Stream *s)
{
	Ethertype *et;

	et = &l.e[s->id];
	qlock(et);
	RD(q)->ptr = WR(q)->ptr = et;
	et->type = 0;
	et->q = RD(q);
	qunlock(et);
}

/*
 *  close lance line discipline
 *
 *  the lock is to synchronize changing the ethertype with
 *  sending packets up the stream on interrupts.
 */
static void
lancestclose(Queue *q)
{
	Ethertype *et;

	qlock(et);
	et = (Ethertype *)(q->ptr);
	et->type = 0;
	et->q = 0;
	qunlock(et);
}

/*
 *  assume the q is locked external to this routine
 *
 *  the ``connect'' control message specifyies the type
 */
Proc *lanceout;
static int
isobuf(void *x)
{
	return TSUCC(l.tc) != l.tl;
}
static void
lanceoput(Queue *q, Block *bp )
{
	int n, len;
	Pkt *p;
	Msg *m;

	if(bp->type == M_CTL){
		if(streamparse("connect", bp)){
			((Ethertype *)q->ptr)->type = strtoul((char *)bp->rptr, 0, 0);
		}
		freeb(bp);
		return;
	}

	/*
	 *  save up to a delim
	 */
	if(!putq(q, bp))
		return;

	/*
	 *  only one transmitter at a time
	 */
	qlock(&l.tlock);

	/*
	 *  Wait till we get an output buffer
	 */
	if(TSUCC(l.tc) == l.tl){
		print("lance obuf sleep");
		sleep(&l.tr, isobuf, (void *)0);
		print("done");
	}
	p = l.tp[l.tc];

	/*
	 *  copy message into lance RAM
	 */
	len = 0;
	while(bp = getq(q)){
		if(sizeof(Pkt) - len >= (n = bp->wptr - bp->rptr)){
			slowcpy(((uchar *)p)+len, bp->rptr, n);
			len += n;
		} else
			print("no room damn it\n");
		if(bp->flags & S_DELIM){
			freeb(bp);
			break;
		} else
			freeb(bp);
	}

	/*
	 *  give packet a local address
	 */
	memcpy(p->s, l.ea, sizeof(l.ea));

	/*
	 *  pad the packet
	 */
	if(len < 60)
		len = 60;

	lancedebq("out", p, len);

	/*
	 *  set up the ring descriptor and hand to lance
	 */
	m = &(LANCEMEM->tmr[l.tc]);
	m->size = -len;
	m->cntflags = 0;
	m->laddr = LADDR(l.tp[l.tc]);
	m->flags = OWN|STP|ENP|HADDR(l.tp[l.tc]);
	l.tc = TSUCC(l.tc);
	*l.rdp = INEA|TDMD; /**/
	qunlock(&l.tlock);
}

/*
 *  lance directory
 */
enum {
	Lchanqid = 1
};
Dirtab lancedir[Ntypes];


/*
 *  stop the lance, disable all ring buffers, and free all staged rcv buffers
 */
void
lancereset(void)
{
	Lancemem *lm=LANCEMEM;
	int i;

	/*
	 *  toggle lance's reset line
	 */
	MODEREG->promenet &= ~1;
	MODEREG->promenet |= 1;

	/*
	 *  disable all ring entries
	 */
	l.tl = l.tc = 0;
	for(i = 0; i < Ntrb; i++)
		lm->tmr[i].flags = 0;
	l.rl = l.rc = 0;
	for(i = 0; i < Ntrb; i++)
		lm->rmr[i].flags = 0;

	/*
	 *  run through all lance memory to set parity
	 */
	for(l.lmp=LANCERAM; l.lmp<=LANCEEND; l.lmp++)
		*l.lmp = 55;
}

/*
 *  Initialize and start the lance.  This routine can be called at any time.
 *  It may be used to restart a dead lance.
 */
static void
lancestart(void)
{
	Lancemem *lm=LANCEMEM;
	int i;
	Pkt *p;

	lancereset();

	/*
	 *  create the initialization block
	 */
	lm->mode = 0;

	/*
	 *  set ether addr from the value in the id prom.
	 *  the id prom has them in reverse order, the init
	 *  structure wants them in byte swapped order
	 */
	lm->etheraddr[0] = (LANCEID[16]&0xff00)|((LANCEID[20]>>8)&0xff);
	lm->etheraddr[1] = (LANCEID[8]&0xff00)|((LANCEID[12]>>8)&0xff);
	lm->etheraddr[2] = (LANCEID[0]&0xff00)|((LANCEID[4]>>8)&0xff);
	l.ea[0] = LANCEID[20]>>8;
	l.ea[1] = LANCEID[16]>>8;
	l.ea[2] = LANCEID[12]>>8;
	l.ea[3] = LANCEID[8]>>8;
	l.ea[4] = LANCEID[4]>>8;
	l.ea[5] = LANCEID[0]>>8;

	/*
	 *  ignore multicast addresses
	 */
	for(i=0; i<4; i++)
		lm->multi[i] = 0;

	/*
	 *  set up rcv message ring
	 */
	p = lm->p;
	for(i = 0; i < Nrrb; i++){
		l.rp[i] = p++;
		lm->rmr[i].size = -sizeof(Pkt);
		lm->rmr[i].cntflags = 0;
		lm->rmr[i].laddr = LADDR(l.rp[i]);
		lm->rmr[i].flags = HADDR(l.rp[i]);
	}
	lm->rdralow = LADDR(lm->rmr);
	lm->rdrahigh = (LogNrrb<<13)|HADDR(lm->rmr);

	/*
	 *  give the lance all the rcv buffers except one (as a sentinel)
	 */
	l.rc = Nrrb - 1;
	for(i = 0; i < l.rc; i++)
		lm->rmr[i].flags |= OWN;

	/*
	 *  set up xmit message ring
	 */
	for(i = 0; i < Ntrb; i++){
		l.tp[i] = p++;
		lm->tmr[i].size = 0;
		lm->tmr[i].cntflags = 0;
		lm->tmr[i].laddr = LADDR(l.tp[i]);
		lm->tmr[i].flags = HADDR(l.tp[i]);
	}
	lm->tdralow = LADDR(lm->tmr);
	lm->tdrahigh = (LogNtrb<<13)|HADDR(lm->tmr);

	/*
	 *  so that we don't have to indirect through constants
	 */
	l.rap = LANCERAP;
	l.rdp = LANCERDP;

	/*
	 *  point lance to the initialization block
	 */
	*l.rap = 1;
	*l.rdp = LADDR(lm);
	wbflush();
	*l.rap = 2;
	*l.rdp = HADDR(lm);

	/*
	 *  The lance byte swaps the ethernet packet unless we tell it not to
	 */
	wbflush();
	*l.rap = 3;
	*l.rdp = BSWP;

	/*
	 *  initialize lance, turn on interrupts, turn on transmit and rcv.
	 */
	*l.rap = 0;
	*l.rdp = INEA|INIT|STRT; /**/
}

/*
 *  set up the free list and lance directory.
 *  start the lance.
 */
void
lanceinit(void)
{
	int i;

	/*
	 *  staticly set up types for now
	 */
	for(i=0; i<Ntypes; i++) {
		sprint(lancedir[i].name, "%d", i);
		lancedir[i].qid = CHDIR|STREAMQID(i, Lchanqid);
		lancedir[i].length = 0;
		lancedir[i].perm = 0600;
	}
}

Chan*
lanceattach(char *spec)
{
	Chan *c;

	if(l.kstarted == 0){
		kproc("**lancekproc**", lancekproc, 0);
		l.kstarted = 1;
		lancestart();
	}
	c = devattach('l', spec);
	c->dev = 0;
	return c;
}

Chan*
lanceclone(Chan *c, Chan *nc)
{
	return devclone(c, nc);
}

/*
 *  if the name doesn't exist, the name is numeric, and room exists
 *  in lancedir, create a new entry.
 */
int	 
lancewalk(Chan *c, char *name)
{
	if(c->qid == CHDIR)
		return devwalk(c, name, lancedir, Ntypes, devgen);
	else
		return devwalk(c, name, 0, 0, streamgen);
}

void	 
lancestat(Chan *c, char *dp)
{
	if(c->qid == CHDIR)
		devstat(c, dp, lancedir, Ntypes, devgen);
	else
		devstat(c, dp, 0, 0, streamgen);
}

/*
 *  Pass open's of anything except the directory to streamopen
 */
Chan*
lanceopen(Chan *c, int omode)
{
	extern Qinfo nonetinfo;

	if(c->qid == CHDIR){
		if(omode != OREAD)
			error(0, Eperm);
	}else
		streamopen(c, &lanceinfo);
	c->mode = openmode(omode);
	c->flag |= COPEN;
	c->offset = 0;
	return c;
}

void	 
lancecreate(Chan *c, char *name, int omode, ulong perm)
{
	error(0, Eperm);
}

void	 
lanceclose(Chan *c)
{
	/* real closing happens in lancestclose */
	if(c->qid != CHDIR)
		streamclose(c);
}

long	 
lanceread(Chan *c, void *a, long n)
{
	if(c->qid == CHDIR)
		return devdirread(c, a, n, lancedir, Ntypes, devgen);
	else
		return streamread(c, a, n);
}

long	 
lancewrite(Chan *c, void *a, long n)
{
	return streamwrite(c, a, n);
}

void	 
lanceremove(Chan *c)
{
	error(0, Eperm);
}

void	 
lancewstat(Chan *c, char *dp)
{
	error(0, Eperm);
}

void	 
lanceerrstr(Error *e, char *buf)
{
	rooterrstr(e, buf);
}

void	 
lanceuserstr(Error *e, char *buf)
{
	consuserstr(e, buf);
}

/*
 *  We will:
 *	(1) Clear interrupt cause in the lance
 *	(2) service all current events
 */
void
lanceintr(void)
{
	ushort csr;
	Lancemem *lm;

	lm = LANCEMEM;

	csr = *l.rdp;

	/*
	 *  turn off the interrupt and any error indicators
	 */
	*l.rdp = IDON|INEA|TINT|RINT|BABL|CERR|MISS|MERR;

	/*
	 *  see if an error occurred
	 */
	if(csr & (BABL|MISS|MERR))
		print("lance err %ux\n", csr);

	if(csr & IDON)
		l.inited = 1;

	/*
	 *  look for rcv'd packets, just wakeup the input process
	 */
	if(l.rl!=l.rc && (lm->rmr[l.rl].flags & OWN)==0)
		wakeup(&l.rr);

	/*
	 *  look for xmitt'd packets, wake any process waiting for a
	 *  transmit buffer
	 */
	while(l.tl != l.tc && (lm->tmr[l.tl].flags & OWN) == 0){
		if(lm->tmr[l.tl].flags & ERR)
			print("xmt error %ux %ux\n", lm->tmr[l.tl].flags,
				lm->tmr[l.tl].cntflags);
		l.tl = TSUCC(l.tl);
		wakeup(&l.tr);
	}
}

/*
 *  input process, awakened on each interrupt with rcv buffers filled
 */
static int
isinput(void *arg)
{
	return l.rl!=l.rc && (LANCEMEM->rmr[l.rl].flags & OWN)==0;
}
void
lancekproc(void *arg)
{
	Block *bp;
	Lancemem *lm;
	Pkt *p;
	Ethertype *e;
	int t;
	Msg *m;
	int len;
	int i, last;

	lm = LANCEMEM;

	for(;;){
		for(; l.rl!=l.rc && (lm->rmr[l.rl].flags & OWN)==0 ; l.rl=RSUCC(l.rl)){
			l.inpackets++;
			m = &(lm->rmr[l.rl]);
			if(m->flags & ERR){
				print("rcv error %ux\n",
					m->flags&(FRAM|OFLO|CRC|BUFF));
				goto stage;
			}
	
			/*
			 *  See if a queue exists for this packet type.
			 */
			p = l.rp[l.rl];
			t = (p->type[1]<<8) | p->type[0];
			len = m->cntflags - 4;
			lancedebq("in", p, len);
			for(e = &l.e[0]; e < &l.e[Ntypes]; e++){
				if(!canqlock(e))
					continue;
				if(e->q && t == e->type)
					break;
				qunlock(e);
			}
	
			/*
			 *  If no match, see if any stream has type -1.
			 *  It matches all packets.
			 */
			if(e == &l.e[Ntypes]){
				for(e = &l.e[0]; e < &l.e[Ntypes]; e++){
					if(!canqlock(e))
						continue;
					if(e->q && e->type == -1)
						break;
					qunlock(e);
				}
			}
			if(e != &l.e[Ntypes] && e->q->next->len <= Streamhi){
				/*
				 *  The lock on e makes sure the queue is still there.
				 */
				bp = allocb(len);
				slowcpy(bp->rptr, (uchar *)p, len);
				bp->wptr += len;
				bp->flags |= S_DELIM;
				PUTNEXT(e->q, bp);
				qunlock(e);
			}
	
stage:
			/*
			 *  stage the next input buffer
			 */
			m = &(lm->rmr[l.rc]);
			m->size = -sizeof(Pkt);
			m->cntflags = 0;
			m->laddr = LADDR(l.rp[l.rc]);
			m->flags = OWN|HADDR(l.rp[l.rc]);
			l.rc = RSUCC(l.rc);
		}
		if(l.prdebug){
			lock(&l.dq);
			i = l.dq.next;
			do {
				if(l.dq.tag[i])
					printpacket(l.dq.tag[i], (Pkt *)&l.dq.p[i],
						l.dq.len[i]);
				i = (i+1) % Ndpkt;
			} while(i != l.dq.next);
			unlock(&l.dq);
			l.prdebug = 0;
		}
		sleep(&l.rr, isinput, 0);
	}
}

void
lanceparity(void)
{
	print("lance DRAM parity error lmp=%ux\n", l.lmp);
	MODEREG->promenet &= ~4;
	MODEREG->promenet |= 4;
}

void
LANCEDEBUG()
{
	l.debug ^= 1;
}

/*
 *  print the debug queue
 */
void
LANCEPRDEBQ()
{
	l.prdebug = 1;
	wakeup(&l.rr);
}
.
## diffname port/devlance.c 1990/03011
## diff -e /n/bootesdump/1990/0227/sys/src/9/mips/devlance.c /n/bootesdump/1990/03011/sys/src/9/mips/devlance.c
753c
			t = (p->type[0]<<8) | p->type[1];
.
## diffname port/devlance.c 1990/03042
## diff -e /n/bootesdump/1990/03011/sys/src/9/mips/devlance.c /n/bootesdump/1990/03042/sys/src/9/mips/devlance.c
822,837d
800,811d
782c
				memcpy(bp->rptr, (uchar *)p, len);
.
755c
			lancedebq('i', p, len);
.
636a
	}
.
633,635c
	switch(c->qid){
	case CHDIR:
		return devdirread(c, a, n, lancedir, Ndir, devgen);
	case Ltraceqid:
		return lancetraceread(c, a, n);
	default:
.
629a
static long
lancetraceread(Chan *c, void *a, long n)
{
	char buf[512];
	long rv;
	int i;
	char *ca = a;
	int offset;
	Trace *t;
	int plen;

	rv = 0;
	sprintpacket(buf, l.dq.t);
	plen = strlen(buf);
	offset = c->offset % plen;
	for(t = &l.dq.t[c->offset/plen]; n && t < &l.dq.t[Ndpkt]; t++){
		if(t->tag == 0)
			break;
		lock(&l.dq);
		sprintpacket(buf, t);
		unlock(&l.dq);
		i = plen - offset;
		if(i > n)
			i = n;
		memcpy(ca, buf + offset, i);
		n -= i;
		ca += i;
		rv += i;
		offset = 0;
	}
	return rv;
}

.
627a
		break;
	}
.
626c
	switch(c->qid){
	case CHDIR:
	case Ltraceqid:
		break;
	default:
.
609a
		break;
	}
.
608c
		break;
	default:
.
605c
	switch(c->qid){
	case CHDIR:
	case Ltraceqid:
.
592c
		devstat(c, dp, lancedir, Ndir, devgen);
.
583c
		return devwalk(c, name, lancedir, Ndir, devgen);
.
551a
	strcpy(lancedir[Ntypes].name, "trace");
	lancedir[Ntypes].qid = Ltraceqid;
	lancedir[Ntypes].length = 0;
	lancedir[Ntypes].perm = 0600;
.
397c
Dirtab lancedir[Ndir];
.
395c
	Lchanqid = 1,
	Ltraceqid = 2,
.
376c
	lancedebq('o', p, len);
.
354c
			memcpy(((uchar *)p)+len, bp->rptr, n);
.
235,237c
	t = &l.dq.t[l.dq.next];
	t->ticks = NOW;
	t->tag = tag;
	t->len = len;
	memcpy(&(t->p), p, sizeof(Dpkt));
.
233a
	Trace *t;

.
232c
lancedebq(char tag, Pkt *p, int len)
.
220,225c
	Dpkt *p = &t->p;

	sprint(buf, "%c: %.8ud %.4d d(%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux)s(%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux)t(%.2ux %.2ux)d(%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux)\n",
	    t->tag, t->ticks, t->len,
	    p->d[0], p->d[1], p->d[2], p->d[3], p->d[4], p->d[5],
	    p->s[0], p->s[1], p->s[2], p->s[3], p->s[4], p->s[5], p->type[0],p->type[1],
	    p->data[0], p->data[1], p->data[2], p->data[3], p->data[4], p->data[5],
	    p->data[6], p->data[7], p->data[8], p->data[9], p->data[10], p->data[11]);
.
218c
sprintpacket(char *buf, Trace *t)
.
139d
107,109c
	Trace	t[Ndpkt];
.
104a
	ulong	ticks;
	char	tag;
	int	len;
	Dpkt	p;
} Trace;
typedef struct {
.
22a
#define NOW (MACHP(0)->ticks)

.
18c
	Ndpkt=		1000,		/* number of debug packets */
.
13a
	Ndir=		Ntypes+1,	/* entries in top level directory */
.
## diffname port/devlance.c 1990/0312
## diff -e /n/bootesdump/1990/03042/sys/src/9/mips/devlance.c /n/bootesdump/1990/0312/sys/src/9/mips/devlance.c
707c
	return streamwrite(c, a, n, 0);
.
365c
		if(sizeof(Pkt) - len >= (n = BLEN(bp))){
.
## diffname port/devlance.c 1990/0319
## diff -e /n/bootesdump/1990/0312/sys/src/9/mips/devlance.c /n/bootesdump/1990/0319/sys/src/9/mips/devlance.c
608c
	if(c->qid==CHDIR || c->qid==Ltraceqid)
.
## diffname port/devlance.c 1990/0409
## diff -e /n/bootesdump/1990/0319/sys/src/9/mips/devlance.c /n/bootesdump/1990/0409/sys/src/9/mips/devlance.c
228,233c
	sprint(buf, "%c: %.8ud %.4d d(%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux)s(%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux)t(%.2ux %.2ux)d(",
		t->tag, t->ticks, t->len,
		p->d[0], p->d[1], p->d[2], p->d[3], p->d[4], p->d[5],
		p->s[0], p->s[1], p->s[2], p->s[3], p->s[4], p->s[5],
		p->type[0], p->type[1]);
	for(i=0; i<41; i++)
		sprint(buf+strlen(buf), "%.2ux", p->data[i]);
	sprint(buf+strlen(buf), ")\n");
.
226a
	int i;
.
105c
	uchar data[60];
.
19c
	Ndpkt=		200,		/* number of debug packets */
.
## diffname port/devlance.c 1990/0419
## diff -e /n/bootesdump/1990/0409/sys/src/9/mips/devlance.c /n/bootesdump/1990/0419/sys/src/9/mips/devlance.c
479a
/*
	print("lance addr = %.4ux %.4ux %.4ux\n", lm->etheraddr[0], lm->etheraddr[1],
		lm->etheraddr[2]);
/**/
.
## diffname port/devlance.c 1990/0427
## diff -e /n/bootesdump/1990/0419/sys/src/9/mips/devlance.c /n/bootesdump/1990/0427/sys/src/9/mips/devlance.c
254a
/*	{
		char buf[1024];
		if(p->d[0] != 0xff){
			sprintpacket(buf, t);
			print("%s\n", buf);
		}
	} /**/
.
## diffname port/devlance.c 1990/0707
## diff -e /n/bootesdump/1990/0427/sys/src/9/mips/devlance.c /n/bootesdump/1990/0707/sys/src/9/mips/devlance.c
582a

.
24c
#define NOW (MACHP(0)->ticks*MS2HZ)
.
## diffname port/devlance.c 1990/0721
## diff -e /n/bootesdump/1990/0707/sys/src/9/mips/devlance.c /n/bootesdump/1990/0721/sys/src/9/mips/devlance.c
317a
	qlock(et);
.
316d
## diffname port/devlance.c 1990/0722
## diff -e /n/bootesdump/1990/0721/sys/src/9/mips/devlance.c /n/bootesdump/1990/0722/sys/src/9/mips/devlance.c
592c
		kproc("lancekproc", lancekproc, 0);
.
## diffname port/devlance.c 1990/0826
## diff -e /n/bootesdump/1990/0722/sys/src/9/mips/devlance.c /n/bootesdump/1990/0826/sys/src/9/mips/devlance.c
890a

void
lance3intr(void)
{
	panic("lance3 interrupt\n");
}
.
## diffname port/devlance.c 1990/0911
## diff -e /n/bootesdump/1990/0826/sys/src/9/mips/devlance.c /n/bootesdump/1990/0911/sys/src/9/mips/devlance.c
890,895d
874,877c
			MPs(m->size) = -sizeof(Pkt);
			MPus(m->cntflags) = 0;
			MPus(m->laddr) = LADDR(l.rpa[l.rc]);
			MPus(m->flags) = OWN|HADDR(l.rpa[l.rc]);
.
857c
			if(e!=&l.e[Ntypes] && e->q->next->len<=Streamhi){
.
834,835c
			len = MPus(m->cntflags) - 4;
			lancedebq('i', p, len);/**/
.
832c
			p = &l.rp[l.rl];
.
823,825c
			if(MPus(m->flags) & ERR){
				t = MPus(m->flags);
				if(t & FRAM)
					l.frames++;
				if(t & OFLO)
					l.overflows++;
				if(t & CRC)
					l.crcs++;
				if(t & BUFF)
					l.buffs++;
.
820c
		for(; l.rl!=l.rc && (MPus(lm->rmr[l.rl].flags) & OWN)==0 ; l.rl=RSUCC(l.rl)){
.
817,818d
815a
	Lancemem *lm = LANCEMEM;
	Msg *m;
.
813d
809d
803c
	Lancemem *lm = LANCEMEM;
	return l.rl!=l.rc && (MPus(lm->rmr[l.rl].flags) & OWN)==0;
.
788,791c
	while(l.tl!=l.tc && (MPus(lm->tmr[l.tl].flags) & OWN)==0){
		if(MPus(lm->tmr[l.tl].flags) & ERR)
			l.oerrs++;
.
781c
	if(l.rl!=l.rc && (MPus(lm->rmr[l.rl].flags) & OWN)==0)
.
760,761d
758c
	Lancemem *lm = LANCEMEM;
.
756a
	int i;
.
711a
	case Lstatsqid:
		sprint(buf, "in: %d\nout: %d\ncrc errs %d\noverflows: %d\nframe errs %d\nbuff errs: %d\noerrs %d\n",
			l.inpackets, l.outpackets, l.crcs, l.overflows, l.frames,
			l.buffs, l.oerrs);
		return stringread(c, a, n, buf);
.
708a
	char buf[256];

.
665a
	case Lstatsqid:
.
639a
	case Lstatsqid:
.
623c
	if(c->qid==CHDIR || c->qid==Ltraceqid || c->qid==Lstatsqid)
.
592c
		kproc("lancekproc", lancekproc, 0);/**/
.
583c
	strcpy(lancedir[Ntypes+1].name, "stats");
	lancedir[Ntypes+1].qid = Lstatsqid;
	lancedir[Ntypes+1].length = 0;
	lancedir[Ntypes+1].perm = 0600;
.
545c
	*l.rdp = HADDR(l.lm);
.
542c
	*l.rdp = LADDR(l.lm);
.
533,538d
529,530c
	MPus(lm->tdralow) = LADDR(l.lm->tmr);
	MPus(lm->tdrahigh) = (LogNtrb<<13)|HADDR(l.lm->tmr);
.
522,527c
	m = lm->tmr;
	for(i = 0; i < Ntrb; i++, m++){
		MPs(m->size) = 0;
		MPus(m->cntflags) = 0;
		MPus(m->laddr) = LADDR(l.tpa[i]);
		MPus(m->flags) = HADDR(l.tpa[i]);
.
516,517c
	m = lm->rmr;
	for(i = 0; i < l.rc; i++, m++)
		MPus(m->flags) |= OWN;
.
511a

.
509,510c
	MPus(lm->rdralow) = LADDR(l.lm->rmr);
	MPus(lm->rdrahigh) = (LogNrrb<<13)|HADDR(l.lm->rmr);
.
501,507c
	m = lm->rmr;
	for(i = 0; i < Nrrb; i++, m++){
		MPs(m->size) = -sizeof(Pkt);
		MPus(m->cntflags) = 0;
		MPus(m->laddr) = LADDR(l.rpa[i]);
		MPus(m->flags) = HADDR(l.rpa[i]);
.
495,496c
	MPus(lm->multi[0]) = 0;
	MPus(lm->multi[1]) = 0;
	MPus(lm->multi[2]) = 0;
	MPus(lm->multi[3]) = 0;
.
487,490d
478,480c
	MPus(lm->etheraddr[0]) = (LANCEID[16]&0xff00)|((LANCEID[20]>>8)&0xff);
	MPus(lm->etheraddr[1]) = (LANCEID[8]&0xff00)|((LANCEID[12]>>8)&0xff);
	MPus(lm->etheraddr[2]) = (LANCEID[0]&0xff00)|((LANCEID[4]>>8)&0xff);
.
471c
	MPus(lm->mode) = 0;
.
464a
	Lancemem *lm = LANCEMEM;
	Msg *m;
.
462d
451,452c
	for(sp = l.lanceram; sp < l.lanceend; sp += l.sep)
		*sp = 0;

.
447a
			l.lanceram = LANCERAM;
			l.lanceend = LANCEEND;
			l.lm = (Lancemem *)0;
			l.sep = 1;

			/*
			 *  allocate packet buffers in lance memory
			 */
			for(i = 0; i < Nrrb; i++)
				l.rpa[i] = (uchar *)&l.lm->rp[i];
			for(i = 0; i < Ntrb; i++)
				l.tpa[i] = (uchar *)&l.lm->tp[i];
		} else {
			/*
			 *  toggle lance's reset line
			 */
			MODEREG->promenet |= 1;
			MODEREG->promenet &= ~1;

			l.lanceram = LANCE3RAM;
			l.lanceend = LANCE3END;
			l.lm = (Lancemem *)0x800000;
			l.sep = 4;

			/*
			 *  allocate packet buffers in MP bus memory
			 *  and map it into lance space
			 */
			l.rp = (Pkt *)ialloc((Nrrb + Ntrb)*sizeof(Pkt), 1);
			l.tp = l.rp + Nrrb;
			index = 0x1E00;
			for(i = 0; i < Nrrb; i++){
				x = (ulong)&l.rp[i];
				*WRITEMAP = (index<<16) | (x>>12)&0xFFFF;
				l.rpa[i] = (uchar *)((i<<12) | (x & 0xFFF));
				index++;
			}
			for(i = 0; i < Ntrb; i++){
				x = (ulong)&l.tp[i];
				*WRITEMAP = (index<<16) | (x>>12)&0xFFFF;
				l.tpa[i] = (uchar *)(((i+Nrrb)<<12) | (x & 0xFFF));
				index++;
			}
		}
	}

.
441,446c
	if(already == 0){
		already = 1;
		if(ioid < IO3R1){
			/*
			 *  toggle lance's reset line
			 */
			MODEREG->promenet &= ~1;
			MODEREG->promenet |= 1;
.
439c
	 *  allocate the send and receive buffers and map them into
	 *  the lance's address space.
.
435,436c
	l.rap = LANCERAP;
	l.rdp = LANCERDP;
.
433c
	 *  so that we don't have to indirect through constants
.
430a
	ushort *sp;
	ulong x;
	int index;
	static int already;
.
429d
422d
418a
	Lstatsqid = 3,
.
404,407c
	MPs(m->size) = -len;
	MPus(m->cntflags) = 0;
	MPus(m->laddr) = LADDR(l.tpa[l.tc]);
	MPus(m->flags) = OWN|STP|ENP|HADDR(l.tpa[l.tc]);
.
402a
	l.outpackets++;
.
398c
	lancedebq('o', p, len);/**/
.
368c
	p = &l.tp[l.tc];
.
265,277d
234c
	for(i=0; i<16; i++)
.
147a

	Pkt	*rp;		/* receive buffers */
	Pkt	*tp;		/* transmit buffers */
	uchar	*rpa[Nrrb];	/* receive buffer address in lance space */
	uchar	*tpa[Ntrb];	/* transmit buffer address in lance space */

	/* sadistics */

	int	inpackets;
	int	outpackets;
	int	crcs;		/* input crc errors */
	int	oerrs;		/* output erros */
	int	frames;		/* framing errors */
	int	overflows;	/* packet overflows */
	int	buffs;		/* buffering errors */
.
141,142d
134,135d
129a
	int	sep;		/* separaqtion between shorts in lance ram
				    as seen by host */
	ushort	*lanceram;	/* start of lance ram as seen by host */
	ushort	*lanceend;	/* end of lance ram as seen by host */
	Lancemem *lm;		/* start of lance memory as seen by lance */
.
87a
#define MPs(a) (*(short *)(l.lanceram + l.sep*((ushort*)&a - (ushort*)0)))
#define MPus(a) (*(ushort *)(l.lanceram + l.sep*((ushort*)&a - (ushort*)0)))
.
86c
#define HADDR(a) ((((ulong)(a))>>16)&0xFF)
.
80c
#define LANCEMEM ((Lancemem*)0)
.
78c
	Pkt	rp[Nrrb];
	Pkt	tp[Ntrb];
.
76c
	 *  packet buffers (for IO2 version)
.
69,70c
	 *  ring buffers
	 *  first receive, then transmit
.
58,66c
	ushort	mode;		/* chip control (see below) */
	ushort	etheraddr[3];	/* the ethernet physical address */
	ushort	multi[4];	/* multicast addresses, 1 bit for each of 64 */
	ushort	rdralow;	/* receive buffer ring */
	ushort	rdrahigh;	/* (top three bits define size of ring) */
	ushort	tdralow;	/* transmit buffer ring */
	ushort	tdrahigh;	/* (top three bits define size of ring) */
.
52,53c
typedef struct Lancemem
.
39,49d
26a
 *  Ethernet packet buffers.  These must also be in lance addressible RAM.
 */
typedef struct {
	uchar d[6];
	uchar s[6];
	uchar type[2];
	uchar data[1500];
	uchar crc[4];
} Pkt;

/*
.
14c
	Ndir=		Ntypes+2,	/* entries in top level directory */
.
## diffname port/devlance.c 1990/0912
## diff -e /n/bootesdump/1990/0911/sys/src/9/mips/devlance.c /n/bootesdump/1990/0912/sys/src/9/mips/devlance.c
469a

			l.rp = ((Lancemem *)LANCERAM)->rp;
			l.tp = ((Lancemem *)LANCERAM)->tp;
.
## diffname port/devlance.c 1990/11211
## diff -e /n/bootesdump/1990/0912/sys/src/9/mips/devlance.c /n/bootesdump/1990/11211/sys/src/9/mips/devlance.c
800,812c
	error(Eperm);
.
794c
	error(Eperm);
.
770c
	switch(c->qid.path){
.
721c
	switch(c->qid.path){
.
714c
	error(Eperm);
.
699c
			error(Eperm);
.
694c
	switch(c->qid.path){
.
680c
	if(c->qid.path==CHDIR || c->qid.path==Ltraceqid || c->qid.path==Lstatsqid)
.
671c
	if(c->qid.path == CHDIR)
.
638c
	lancedir[Ntypes+1].qid.path = Lstatsqid;
.
634c
	lancedir[Ntypes].qid.path = Ltraceqid;
.
629c
		lancedir[i].qid.path = CHDIR|STREAMQID(i, Lchanqid);
		lancedir[i].qid.vers = 0;
.
## diffname port/devlance.c 1990/1228
## diff -e /n/bootesdump/1990/11211/sys/src/9/mips/devlance.c /n/bootesdump/1990/1228/sys/src/9/mips/devlance.c
933c
			MPs(m->size) = -sizeof(Etherpkt);
.
863c
	Etherpkt *p;
.
562c
		MPs(m->size) = -sizeof(Etherpkt);
.
539,547c
	MPus(lm->etheraddr[0]) = (l.ea[1]<<8) | l.ea[0];
	MPus(lm->etheraddr[1]) = (l.ea[3]<<8) | l.ea[2];
	MPus(lm->etheraddr[2]) = (l.ea[5]<<8) | l.ea[4];
.
523c
	Etherpkt *p;
.
507,512d
489c
			l.rp = (Etherpkt *)ialloc((Nrrb + Ntrb)*sizeof(Etherpkt), 1);
.
475,485d
471,472c
			l.rp = ((Lancemem *)l.lanceram)->rp;
			l.tp = ((Lancemem *)l.lanceram)->tp;
.
453,463d
445,448d
442,443c
	*l.rap = 0;
	*l.rdp = STOP;
.
440c
	 *  stop the lance
.
434d
427a
 *  configure the lance
 */
void
lanceconfig(void *ramstart, void *ramend, void *rap, void *rdp, int sep,
	void *lancemem, uchar* ea)
{
	l.lanceram = ramstart;
	l.lanceend = ramend;
	l.rap = rap;
	l.rdp = rdp;
	l.sep = sep;
	l.lm = lancemem;	/* where lance sees its memory start */
	memcpy(l.ea, ea, 6);
}

/*
.
378c
		if(sizeof(Etherpkt) - len >= (n = BLEN(bp))){
.
341c
	Etherpkt *p;
.
259c
lancedebq(char tag, Etherpkt *p, int len)
.
150,151c
	Etherpkt	*rp;		/* receive buffers */
	Etherpkt	*tp;		/* transmit buffers */
.
85a

/*
 *  The following functions exist to sidestep a quirk in the SGI IO3 lance
 *  interface.  In all other processors, the lance's initialization block and
 *  descriptor rings look like normal memory.  In the SGI IO3, the CPU sees a
 *  6 byte pad twixt all lance memory shorts.  Therefore, we use the following
 *  macros to compute the address whenever accessing the lance memory to make
 *  the code portable.  Sic transit gloria.
 */
#define LANCEMEM ((Lancemem*)0)
.
78d
75,76c
	Etherpkt	rp[Nrrb];
	Etherpkt	tp[Ntrb];
.
73c
	 *  packet buffers (for SGI IO2 version only)
.
27,37d
## diffname port/devlance.c 1990/1229
## diff -e /n/bootesdump/1990/1229/sys/src/9/mips/devlance.c /n/bootesdump/1990/1229/sys/src/9/port/devlance.c
921,923c
	plance ^= 1;
.
918,919c
lancetoggle()
.
912a
			wbflush();
.
910,911c
			MPus(m->laddr) = LADDR(&l.lrp[l.rc]);
			MPus(m->flags) = OWN|HADDR(&l.lrp[l.rc]);
.
811a
	}
.
810c
	if(l.rl!=l.rc && (MPus(lm->rmr[l.rl].flags) & OWN)==0){
.
585a
	wbflush();
.
561,562c
		MPus(m->laddr) = LADDR(&l.ltp[i]);
		MPus(m->flags) = HADDR(&l.ltp[i]);
.
539,540c
		MPus(m->laddr) = LADDR(&l.lrp[i]);
		MPus(m->flags) = HADDR(&l.lrp[i]);
.
469,491c
		/*
		 *  lance ethernet address
		 */
		lanceeaddr(l.ea);

		/*
		 *  lance init block and descriptor rings
		 */
		lancectlmem(&hostaddr, &lanceaddr, &l.sep, sizeof(Lancemem));
		l.lanceram = hostaddr;
		l.lm = (Lancemem*)lanceaddr;

		/*
		 *  lance receive buffers
		 */
		lancepktmem(&hostaddr, &lanceaddr, Nrrb*sizeof(Etherpkt));
		l.rp = (Etherpkt*)hostaddr;
		l.lrp = (Etherpkt*)lanceaddr;

		/*
		 *  lance xmt buffers
		 */
		lancepktmem(&hostaddr, &lanceaddr, Ntrb*sizeof(Etherpkt));
		l.tp = (Etherpkt*)hostaddr;
		l.ltp = (Etherpkt*)lanceaddr;
.
460,467d
451a
	l.rap = LANCERAP;
	l.rdp = LANCERDP;

.
450a
	ushort *lanceaddr;
	ushort *hostaddr;
.
429,444d
426c
 *  stop the lance and allocate buffers
.
411a
	wbflush();
.
408,409c
	MPus(m->laddr) = LADDR(&l.ltp[l.tc]);
	MPus(m->flags) = OWN|STP|ENP|HADDR(&l.ltp[l.tc]);
.
269c
	if(plance){
.
148,151c
	Etherpkt	*rp;	/* receive buffers (host address) */
	Etherpkt	*tp;	/* transmit buffers (host address) */
	Etherpkt	*lrp;	/* receive buffers (lance address) */
	Etherpkt	*ltp;	/* transmit buffers (lance address) */
.
131d
60,65d
25a
int plance;

.
## diffname port/devlance.c 1990/1231
## diff -e /n/bootesdump/1990/1229/sys/src/9/port/devlance.c /n/bootesdump/1990/1231/sys/src/9/port/devlance.c
785a
	}
.
784c
	if(csr & IDON){
		print("lance inited\n");
.
567a
	print("lance started\n");
.
565a
	print("starting lance\n");
.
544c
	MPus(lm->tdrahigh) = (l.logntrb<<13)|HADDR(l.lm->tmr);
.
537c
	for(i = 0; i < l.ntrb; i++, m++){
.
528c
	l.rc = l.nrrb - 1;
.
522c
	MPus(lm->rdrahigh) = (l.lognrrb<<13)|HADDR(l.lm->rmr);
.
515c
	for(i = 0; i < l.nrrb; i++, m++){
.
442,472d
434,435c
	if(already == 0){
		already = 1;
		lancesetup(&l);
	}
.
157,158c
} SoftLance;
static SoftLance l;
.
143,147d
122,127d
120d
118a
	Lance;			/* host dependent lance params */

.
60,62c
	Msg	rmr[Maxrb];		/* recieve message ring */
	Msg	tmr[Maxrb];		/* transmit message ring */
};
.
43c
struct Lancemem
.
21,22c
#define RSUCC(x) (((x)+1)%l.nrrb)
#define TSUCC(x) (((x)+1)%l.ntrb)
.
19a
	Maxrb=		128,		/* max buffers in a ring */
.
15,18d
9,11c

.
## diffname port/devlance.c 1991/0108
## diff -e /n/bootesdump/1990/1231/sys/src/9/port/devlance.c /n/bootesdump/1991/0108/sys/src/9/port/devlance.c
740a
		print("aser %lux asevar %lux\n", getw2(0x60000008), getw2(0x6000000C));
	*l.rap = 0;
	*l.rdp = STOP;
delay(100);
	*l.rap = 0;
	print("csr0 %lux\n", *l.rdp);
	*l.rap = 1;
	print("csr1 %lux\n", *l.rdp);
	*l.rap = 2;
	print("csr2 %lux\n", *l.rdp);
	}
.
739c
	if(csr & (BABL|MISS|MERR)){
.
423a
	*l.rap = 0;
	print("csr0 %lux\n", *l.rdp);
	*l.rap = 1;
	print("csr1 %lux\n", *l.rdp);
	*l.rap = 2;
	print("csr2 %lux\n", *l.rdp);

.
418a

.
## diffname port/devlance.c 1991/0109
## diff -e /n/bootesdump/1991/0108/sys/src/9/port/devlance.c /n/bootesdump/1991/0109/sys/src/9/port/devlance.c
749,758d
533d
530d
524c
	*l.rdp = l.busctl;
.
425,431d
347d
345d
179,185d
## diffname port/devlance.c 1991/01151
## diff -e /n/bootesdump/1991/0109/sys/src/9/port/devlance.c /n/bootesdump/1991/01151/sys/src/9/port/devlance.c
851c
void
lancetoggle(void)
.
## diffname port/devlance.c 1991/0118
## diff -e /n/bootesdump/1991/01151/sys/src/9/port/devlance.c /n/bootesdump/1991/0118/sys/src/9/port/devlance.c
639c
	char buf[1024];
.
368a
	}
.
367c
	if(len < 60){
		memset(((char*)p)+len, 0, 60-len);
.
365c
	 *  pad the packet (zero the pad)
.
221c
	for(i=0; i<sizeof(p->data); i++)
.
## diffname port/devlance.c 1991/0313
## diff -e /n/bootesdump/1991/0118/sys/src/9/port/devlance.c /n/bootesdump/1991/0313/sys/src/9/port/devlance.c
829,833c
				if(!waserror()){
					bp = allocb(len);
					memcpy(bp->rptr, (uchar *)p, len);
					bp->wptr += len;
					bp->flags |= S_DELIM;
					PUTNEXT(e->q, bp);
					poperror();
				}
.
## diffname port/devlance.c 1991/0314
## diff -e /n/bootesdump/1991/0313/sys/src/9/port/devlance.c /n/bootesdump/1991/0314/sys/src/9/port/devlance.c
825,829c
			/*
			 *  The lock on e makes sure the queue is still there.
			 */
			if(e!=&l.e[Ntypes]){
				if(e->q->next->len<=Streamhi && !waserror()){
.
818c
					if(e->q==0 || e->type!=-1 || !canqlock(e))
.
805c
				if(e->q==0 || t!=e->type || !canqlock(e))
.
## diffname port/devlance.c 1991/0316
## diff -e /n/bootesdump/1991/0314/sys/src/9/port/devlance.c /n/bootesdump/1991/0316/sys/src/9/port/devlance.c
634,635d
626,632c
	if(c->stream)
.
598,599d
559,561c
	return devattach('l', spec);
.
552,553d
## diffname port/devlance.c 1991/0318
## diff -e /n/bootesdump/1991/0316/sys/src/9/port/devlance.c /n/bootesdump/1991/0318/sys/src/9/port/devlance.c
817c
					memmove(bp->rptr, (uchar *)p, len);
.
648c
		memmove(ca, buf + offset, i);
.
546a

.
362c
	memmove(p->s, l.ea, sizeof(l.ea));
.
348c
			memmove(((uchar *)p)+len, bp->rptr, n);
.
239c
	memmove(&(t->p), p, sizeof(Dpkt));
.
## diffname port/devlance.c 1991/0325
## diff -e /n/bootesdump/1991/0318/sys/src/9/port/devlance.c /n/bootesdump/1991/0325/sys/src/9/port/devlance.c
667,669c
		sprint(buf, "in: %d\nout: %d\ncrc errs %d\noverflows: %d\nframe errs %d\nbuff errs: %d\noerrs %d\naddr: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x\n",
		l.inpackets, l.outpackets, l.crcs,
		l.overflows, l.frames, l.buffs, l.oerrs,
		l.ea[0], l.ea[1], l.ea[2], l.ea[3], l.ea[4], l.ea[5]);
.
## diffname port/devlance.c 1991/0411
## diff -e /n/bootesdump/1991/0325/sys/src/9/port/devlance.c /n/bootesdump/1991/0411/sys/src/9/port/devlance.c
680c
lancewrite(Chan *c, void *a, long n, ulong offset)
.
673c
		return lancetraceread(c, a, n, offset);
.
671c
		return stringread(c, a, n, buf, offset);
.
659c
lanceread(Chan *c, void *a, long n, ulong offset)
.
653c
		off = 0;
.
649c
		memmove(ca, buf + off, i);
.
646c
		i = plen - off;
.
639,640c
	off = offset % plen;
	for(t = &l.dq.t[offset/plen]; n && t < &l.dq.t[Ndpkt]; t++){
.
632c
	int off;
.
626c
lancetraceread(Chan *c, void *a, long n, ulong offset)
.
## diffname port/devlance.c 1991/0413
## diff -e /n/bootesdump/1991/0411/sys/src/9/port/devlance.c /n/bootesdump/1991/0413/sys/src/9/port/devlance.c
317c
			n = strtoul((char *)bp->rptr, 0, 0);
			((Ethertype *)q->ptr)->type = n;
.
312a
	Ethertype *e;
.
## diffname port/devlance.c 1991/0419
## diff -e /n/bootesdump/1991/0413/sys/src/9/port/devlance.c /n/bootesdump/1991/0419/sys/src/9/port/devlance.c
581a
Chan*
lanceclwalk(Chan *c, char *name)
{
	return devclwalk(c, name);
}

.
## diffname port/devlance.c 1991/0423
## diff -e /n/bootesdump/1991/0419/sys/src/9/port/devlance.c /n/bootesdump/1991/0423/sys/src/9/port/devlance.c
645,646c
	plen = sprintpacket(buf, l.dq.t);
.
222,223c
		n += sprint(buf+n, "%.2ux", p->data[i]);
	n += sprint(buf+n, ")\n");
	return n;
.
216c
	n = sprint(buf, "%c: %.8ud %.4d d(%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux)s(%.2ux%.2ux%.2ux%.2ux%.2ux%.2ux)t(%.2ux %.2ux)d(",
.
214c
	int i, n;
.
210a
int
.
## diffname port/devlance.c 1991/0427
## diff -e /n/bootesdump/1991/0423/sys/src/9/port/devlance.c /n/bootesdump/1991/0427/sys/src/9/port/devlance.c
584,589d
## diffname port/devlance.c 1991/0510
## diff -e /n/bootesdump/1991/0427/sys/src/9/port/devlance.c /n/bootesdump/1991/0510/sys/src/9/port/devlance.c
802d
## diffname port/devlance.c 1991/0620
## diff -e /n/bootesdump/1991/0510/sys/src/9/port/devlance.c /n/bootesdump/1991/0620/sys/src/9/port/devlance.c
446c
	MPus(lm->mode) = lancemode;
.
208a
 *  mode used by restart
 */
int	lancemode;

/*
.
## diffname port/devlance.c 1991/0621
## diff -e /n/bootesdump/1991/0620/sys/src/9/port/devlance.c /n/bootesdump/1991/0621/sys/src/9/port/devlance.c
849,854d
846a
		qunlock(&l.rlock);
.
820,834c

.
801,816c
				if(e->q!=0 && (t==e->type||e->type==-1) && canqlock(e)){
					if(t==e->type||e->type==-1)
						lanceup(e, p, len);
.
799d
794c
			 *  stuff packet up each queue that wants it
.
776a
		qlock(&l.rlock);
.
772c
	int t;
.
770d
767d
764c
static void
.
755a
 *  send a packet upstream
 */
void
lanceup(Ethertype *e, Etherpkt *p, int len)
{
	Block *bp;

	/*
	 *  only a trace channel gets packets destined for other machines
	 */
	if(e->type != -1){
		if(!(p->d[0]&0x80) && memcmp(p->d, l.ea, sizeof(p->d))!=0)
			return;
	}
	if(e->q && e->q->next->len<=Streamhi && !waserror()){
		bp = allocb(len);
		memmove(bp->rptr, (uchar *)p, len);
		bp->wptr += len;
		bp->flags |= S_DELIM;
		PUTNEXT(e->q, bp);
		poperror();
	}
}

/*
.
733a
		qunlock(&l.rlock);
		qunlock(&l.tlock);
.
732d
680,681d
634,665d
606d
592c
	if(c->qid.path==CHDIR || c->qid.path==Lstatsqid)
.
565c
		lancestart(0);
.
552,555d
548,549c
	strcpy(lancedir[Ntypes].name, "stats");
	lancedir[Ntypes].qid.path = Lstatsqid;
.
530,531c
 *  set up lance directory.
.
451c
	MPus(lm->mode) = mode;
.
446a
	l.rl = 0;
	l.rc = 0;
	l.tl = 0;
	l.tc = 0;
.
445a
	/*
	 *   wait till both receiver and transmitter are
	 *   quiescent
	 */
	qlock(&l.tlock);
	qlock(&l.rlock);

.
439c
lancestart(int mode)
.
403,404c
	Lstatsqid = 2,
.
381,382d
325,326c
			e->type = strtol((char *)bp->rptr, 0, 0);
		} else if(streamparse("promiscuous", bp)) {
			e->prom = 1;
			qlock(&l);
			l.prom++;
			if(l.prom == 1)
				lancestart(PROM);
			qunlock(&l);
.
323a
		e = q->ptr;
.
300a
	et->prom = 0;
.
297a
	if(et->prom){
		qlock(&l);
		l.prom--;
		if(l.prom == 0)
			lancestart(0);
		qunlock(&l);
	}
.
209,258d
206,207c
static void lancekproc(void *);
static void lancestart(int);
.
131d
119a
	QLock	rlock;		/* semaphore on tc */
.
114a
	int	prom;		/* number of promiscuous channels */
.
87,106d
83a
	int	prom;		/* promiscuous mode */
.
21,22d
11,13c
	Ntypes=		9,		/* max number of ethernet packet types */
	Ndir=		Ntypes+1,	/* entries in top level directory */
.
## diffname port/devlance.c 1991/0828
## diff -e /n/bootesdump/1991/0621/sys/src/9/port/devlance.c /n/bootesdump/1991/0828/sys/src/9/port/devlance.c
758a
}

static void
lancedump(void)
{
	print("l.rl %d l.rc %d l.tl %d l.tc %d\n", l.rl, l.rc, l.tl, l.tc);
.
652a
		misses = 0;
.
640a
		if(csr & MISS)
			lancedump();
.
627a
	static int misses;
.
512c
		lancestart(0, 1);
.
391,392c
	if(dolock){
		qlock(&l.tlock);
		qlock(&l.rlock);
	}
.
380c
lancestart(int mode, int dolock)
.
337a
	poperror();
.
290,292c
	sleep(&l.tr, isobuf, (void *)0);
.
285a
	if(waserror()){
		qunlock(&l.tlock);
		nexterror();
	}
.
269c
				lancestart(PROM, 1);
.
231c
			lancestart(0, 1);
.
186c
static void lancestart(int, int);
static void lancedump(void);

.
## diffname port/devlance.c 1991/0925
## diff -e /n/bootesdump/1991/0828/sys/src/9/port/devlance.c /n/bootesdump/1991/0925/sys/src/9/port/devlance.c
340a
	freeb(bp);
.
312,313d
309,310c
		if(bp->flags & S_DELIM)
.
303,305c
	for(nbp = bp; nbp; nbp = nbp->next){
		if(sizeof(Etherpkt) - len >= (n = BLEN(nbp))){
			memmove(((uchar *)p)+len, nbp->rptr, n);
.
288a
		freeb(bp);
.
279,284d
260a
	Block *nbp;
.
## diffname port/devlance.c 1991/0926
## diff -e /n/bootesdump/1991/0925/sys/src/9/port/devlance.c /n/bootesdump/1991/0926/sys/src/9/port/devlance.c
685c
		if(p->d[0]!=0xff && memcmp(p->d, l.ea, sizeof(p->d))!=0)
.
## diffname port/devlance.c 1991/1002
## diff -e /n/bootesdump/1991/0926/sys/src/9/port/devlance.c /n/bootesdump/1991/1002/sys/src/9/port/devlance.c
244,245d
## diffname port/devlance.c 1991/1026
## diff -e /n/bootesdump/1991/1002/sys/src/9/port/devlance.c /n/bootesdump/1991/1026/sys/src/9/port/devlance.c
760a
print("!");
.
740a
if(p->type[0] == 0x80 || p->type[0] == 0x8) print("*");
.
693a
	poperror();
.
692d
682,686c
	if(e->type != -1 && p->d[0]!=0xff && memcmp(p->d, l.ea, sizeof(p->d))!=0)
		return;

	if(waserror())
		return;

	if(e->q && e->q->next->len<=Streamhi){
.
## diffname port/devlance.c 1991/1027
## diff -e /n/bootesdump/1991/1026/sys/src/9/port/devlance.c /n/bootesdump/1991/1027/sys/src/9/port/devlance.c
764d
743d
706a

.
687d
## diffname port/devlance.c 1991/1031
## diff -e /n/bootesdump/1991/1027/sys/src/9/port/devlance.c /n/bootesdump/1991/1031/sys/src/9/port/devlance.c
722,723c
			t = MPus(m->flags);
			if(t & ERR){
.
## diffname port/devlance.c 1991/1106
## diff -e /n/bootesdump/1991/1031/sys/src/9/port/devlance.c /n/bootesdump/1991/1106/sys/src/9/port/devlance.c
741,747c
			lanceup(p, len);
.
739d
718a
		while(bp = getq(&l.self)){
			lanceup((Etherpkt*)bp->rptr, BLEN(bp));
			freeb(bp);
		}
.
715a
	Block *bp;
.
704c
	return l.self.first || (l.rl!=l.rc && (MPus(lm->rmr[l.rl].flags) & OWN)==0);
.
694d
685,692c
		/*
		 *  only a trace channel gets packets destined for other machines
		 */
		if(e->type!=-1 && p->d[0]!=0xff && memcmp(p->d, l.ea, sizeof(p->d))!=0)
			continue;

		/*
		 *  check after locking to make sure things didn't
		 *  change under foot
		 */
		if(!canqlock(e))
			continue;
		if(e->q==0 || e->q->next->len>Streamhi || (t!=e->type && e->type!=-1)){
			qunlock(e);
			continue;
		}
		if(!waserror()){
			bp = allocb(len);
			memmove(bp->rptr, (uchar *)p, len);
			bp->wptr += len;
			bp->flags |= S_DELIM;
			PUTNEXT(e->q, bp);
		}
		poperror();
		qunlock(e);
.
679,683c
	t = (p->type[0]<<8) | p->type[1];
	for(e = &l.e[0]; e < &l.e[Ntypes]; e++){
		/*
		 *  check before locking just to save a lock
		 */
		if(e->q==0 || (t!=e->type && e->type!=-1))
			continue;
.
677a
	Ethertype *e;
	int t;
.
674,675c
static void
lanceup(Etherpkt *p, int len)
.
308,312d
277a
	 *  give packet a local address, return upstream if destined for
	 *  this machine.
	 */
	if(BLEN(bp) < ETHERHDRSIZE){
		bp = pullup(bp, ETHERHDRSIZE);
		if(bp == 0)
			return;
	}
	p = (Etherpkt *)bp->rptr;
	memmove(p->s, l.ea, sizeof(l.ea));
	if(memcmp(l.ea, p->d, sizeof(l.ea)) == 0){
		len = blen(bp);
		bp = expandb(bp, len >= 60 ? len : 60);
		if(bp){
			putq(&l.self, bp);
			wakeup(&l.rr);
		}
		return;
	}

	/*
.
243a
 *  expand a block list to be one byte, len bytes long
 */
static Block*
expandb(Block *bp, int len)
{
	Block *nbp, *new;
	int i;

	new = allocb(len);
	if(new == 0){
		freeb(bp);
		return 0;
	}

	/*
	 *  copy bytes into new block
	 */
	for(nbp = bp; len>0 && nbp; nbp = nbp->next){
		i = BLEN(bp);
		if(i > len) {
			memmove(new->wptr, nbp->rptr, len);
			new->wptr += len;
			break;
		} else {
			memmove(new->wptr, nbp->rptr, i);
			new->wptr += i;
			len -= i;
		}
	}
	if(len){
		memset(new->wptr, 0, len);
		new->wptr += len;
	}
	freeb(bp);
	return new;

}

/*
.
187a
static void lanceup(Etherpkt*, int);
.
111a
	Queue	self;	/* packets turned around at the interface */

.
## diffname port/devlance.c 1991/1107
## diff -e /n/bootesdump/1991/1106/sys/src/9/port/devlance.c /n/bootesdump/1991/1107/sys/src/9/port/devlance.c
840,845d
698,700c
		if(misses++ < 4)
			print("lance err %ux\n", csr);
.
373,375c
	if(len < ETHERMINTU){
		memset(((char*)p)+len, 0, ETHERMINTU-len);
		len = ETHERMINTU;
.
332c
		bp = expandb(bp, len >= ETHERMINTU ? len : ETHERMINTU);
.
247,285d
189d
## diffname port/devlance.c 1991/1112
## diff -e /n/bootesdump/1991/1107/sys/src/9/port/devlance.c /n/bootesdump/1991/1112/sys/src/9/port/devlance.c
519c
	lancedir[Ntypes].perm = 0666;
.
514c
		lancedir[i].perm = 0666;
.
## diffname port/devlance.c 1991/1113
## diff -e /n/bootesdump/1991/1112/sys/src/9/port/devlance.c /n/bootesdump/1991/1113/sys/src/9/port/devlance.c
19a
static int netlight;

.
## diffname port/devlance.c 1991/1114
## diff -e /n/bootesdump/1991/1113/sys/src/9/port/devlance.c /n/bootesdump/1991/1114/sys/src/9/port/devlance.c
633a
}

/*
 *  user level network interface routines
 */
static void
lancestatsfill(Chan *c, char* p, int n)
{
	char buf[256];

	sprint(buf, "in: %d\nout: %d\ncrc errs %d\noverflows: %d\nframe errs %d\nbuff errs: %d\noerrs %d\naddr: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x\n",
		l.inpackets, l.outpackets, l.crcs,
		l.overflows, l.frames, l.buffs, l.oerrs,
		l.ea[0], l.ea[1], l.ea[2], l.ea[3], l.ea[4], l.ea[5]);
	strncpy(p, buf, n);
}
static void
lancetypefill(Chan *c, char* p, int n)
{
	char buf[16];
	Ethertype *e;

	e = &l.e[STREAMID(c->qid.path)];
	sprint(buf, "%d", e->type);
	strncpy(p, buf, n);
}

static int
lanceclonecon(Chan *c)
{
	Ethertype *e;

	for(e = l.e; e < &l.e[Ntypes]; e++){
		qlock(e);
		if(e->inuse || e->q){
			qunlock(e);
			continue;
		}
		e->inuse = 1;
		qunlock(e);
		return e - l.e;
	}
	errors("no unused lance channels");
.
602,615c
	return netread(c, a, n, offset,  &l.net);
.
570,583c
	return netopen(c, omode, &l.net);
.
558,561c
	netstat(c, dp, &l.net);
.
549,552c
	return netwalk(c, name, &l.net);
.
542,545d
506,522d
382a

		l.net.name = "ether";
		l.net.nconv = Ntypes;
		l.net.devp = &lanceinfo;
		l.net.protop = 0;
		l.net.listen = 0;
		l.net.clone = lanceclonecon;
		l.net.ninfo = 2;
		l.net.info[0].name = "stats";
		l.net.info[0].fill = lancestatsfill;
		l.net.info[1].name = "type";
		l.net.info[1].fill = lancetypefill;
.
379d
376,377d
372,374d
358,366d
243a
	et->inuse = 0;
.
217a
	et->inuse = 1;
.
189,191c
static void	lancekproc(void *);
static void	lancestart(int, int);
static void	lanceup(Etherpkt*, int);
static int	lanceclonecon(Chan*);
static void	lancestatsfill(Chan*, char*, int);
static void	lancetypefill(Chan*, char*, int);
.
95a
	Network	net;
.
84a
	int	inuse;
.
12d
## diffname port/devlance.c 1991/1115
## diff -e /n/bootesdump/1991/1114/sys/src/9/port/devlance.c /n/bootesdump/1991/1115/sys/src/9/port/devlance.c
749a
	USED(arg);
.
735a

	USED(arg);
.
622a
		netown(&l.net, e - l.e, u->p->user, 0);
.
615a
	USED(c);
.
599a

.
593a
	USED(c);
.
583c
	netwstat(c, dp, &l.net);
.
576a
	USED(c);
.
551a
	USED(c, name, omode, perm);
.
381a
		l.net.prot = l.prot;
.
259a
	USED(x);
.
249a
	netdisown(&l.net, et - l.e);
.
96a
	Netprot	prot[Ntypes];
.
## diffname port/devlance.c 1991/1121
## diff -e /n/bootesdump/1991/1115/sys/src/9/port/devlance.c /n/bootesdump/1991/1121/sys/src/9/port/devlance.c
389a

		memset(l.bcast, 0xff, sizeof l.bcast);
.
309a
	if(memcmp(l.bcast, p->d, sizeof(l.bcast)) == 0){
		len = blen(bp);
		nbp = copyb(bp, len = len >= ETHERMINTU ? len : ETHERMINTU);
		if(nbp){
			nbp->wptr = nbp->rptr+len;
			putq(&l.self, nbp);
			wakeup(&l.rr);
		}
	}
.
114a
	uchar	bcast[6];
.
## diffname port/devlance.c 1991/1126
## diff -e /n/bootesdump/1991/1121/sys/src/9/port/devlance.c /n/bootesdump/1991/1126/sys/src/9/port/devlance.c
782a
			l.misses = 0;
.
691d
688,689c
	if(l.rl!=l.rc && (MPus(lm->rmr[l.rl].flags) & OWN)==0)
.
675c
		if(l.misses++ < 4)
.
662d
324a

.
320a
	/* restart the lance if'n it needs it */
	if(l.misses > 4){
		l.misses = 0;
		print("restarting lance\n");
		lancestart(0, 1);
	}

.
120a
	int	misses;
.
## diffname port/devlance.c 1991/1214
## diff -e /n/bootesdump/1991/1126/sys/src/9/port/devlance.c /n/bootesdump/1991/1214/sys/src/9/port/devlance.c
438,439c
	qlock(&l.rlock);
.
436c
	if(dolock)
.
343c
	tsleep(&l.tr, isobuf, (void *)0, 1000);
	if(isobuf(0) == 0 || l.misses > 4){
		l.misses = 0;
		print("lance wedged, restarting\n");
		lancestart(0, 0);
		freeb(bp);
		return;		/* the interrupt routine will qunlock(&l.tlock) */
	}
.
341c
	 *  Wait till we get an output buffer, reset the lance if input
	 *  or output seems wedged.
.
322,328d
## diffname port/devlance.c 1992/0111
## diff -e /n/bootesdump/1991/1214/sys/src/9/port/devlance.c /n/bootesdump/1992/0111/sys/src/9/port/devlance.c
7c
#include	"../port/error.h"
.
## diffname port/devlance.c 1992/0112
## diff -e /n/bootesdump/1992/0111/sys/src/9/port/devlance.c /n/bootesdump/1992/0112/sys/src/9/port/devlance.c
657c
	error(Enodev);
.
## diffname port/devlance.c 1992/0215
## diff -e /n/bootesdump/1992/0112/sys/src/9/port/devlance.c /n/bootesdump/1992/0215/sys/src/9/port/devlance.c
314c
		nbp = copyb(bp, len);
		nbp = expandb(nbp, len >= ETHERMINTU ? len : ETHERMINTU);
.
## diffname port/devlance.c 1992/0307
## diff -e /n/bootesdump/1992/0215/sys/src/9/port/devlance.c /n/bootesdump/1992/0307/sys/src/9/port/devlance.c
312c
	if(memcmp(l.bcast, p->d, sizeof(l.bcast)) == 0 || l.prom){
.
285c
/*				lancestart(PROM, 1);/**/
.
## diffname port/devlance.c 1992/0312
## diff -e /n/bootesdump/1992/0307/sys/src/9/port/devlance.c /n/bootesdump/1992/0312/sys/src/9/port/devlance.c
285c
				lancestart(PROM, 1);/**/
.
## diffname port/devlance.c 1992/0314
## diff -e /n/bootesdump/1992/0312/sys/src/9/port/devlance.c /n/bootesdump/1992/0314/sys/src/9/port/devlance.c
433a
if(mode == PROM)
	print("setting promiscuous mode\n");

.
## diffname port/devlance.c 1992/0315
## diff -e /n/bootesdump/1992/0314/sys/src/9/port/devlance.c /n/bootesdump/1992/0315/sys/src/9/port/devlance.c
312c
	if(memcmp(l.bcast, p->d, sizeof(l.bcast)) == 0 || l.prom || l.all){
.
279a
			if(e->type == -1){
				qlock(&l);
				l.all++;
				qunlock(&l);
			}
.
247a
	if(et->type == -1){
		qlock(&l);
		l.all--;
		qunlock(&l);
	}
.
95a
	int	all;		/* number of channels listening to all packets */
.
## diffname port/devlance.c 1992/0316
## diff -e /n/bootesdump/1992/0315/sys/src/9/port/devlance.c /n/bootesdump/1992/0316/sys/src/9/port/devlance.c
353a
		qunlock(&l.tlock);
.
298a
		qunlock(&l);
.
297d
293d
289,290d
286,287c
			if(e->type == -1)
.
284a
			if(e->type == -1)
				l.all--;
.
283a
		qlock(&l);
.
## diffname port/devlance.c 1992/0319
## diff -e /n/bootesdump/1992/0316/sys/src/9/port/devlance.c /n/bootesdump/1992/0319/sys/src/9/port/devlance.c
759a

.
755a

.
## diffname port/devlance.c 1992/0320
## diff -e /n/bootesdump/1992/0319/sys/src/9/port/devlance.c /n/bootesdump/1992/0320/sys/src/9/port/devlance.c
444,446d
288c
			e->type  = strtol((char *)bp->rptr, 0, 0);
.
## diffname port/devlance.c 1992/0321
## diff -e /n/bootesdump/1992/0320/sys/src/9/port/devlance.c /n/bootesdump/1992/0321/sys/src/9/port/devlance.c
2c
#include	"../port/lib.h"
.
## diffname port/devlance.c 1992/0322
## diff -e /n/bootesdump/1992/0321/sys/src/9/port/devlance.c /n/bootesdump/1992/0322/sys/src/9/port/devlance.c
554a
		print("lance ether: %.2x%.2x%.2x%.2x%.2x%.2x\n",
			l.ea[0], l.ea[1], l.ea[2], l.ea[3], l.ea[4], l.ea[5]);

.
## diffname port/devlance.c 1992/0328
## diff -e /n/bootesdump/1992/0322/sys/src/9/port/devlance.c /n/bootesdump/1992/0328/sys/src/9/port/devlance.c
354a
		poperror();
.
353d
351c
print("lance wedged, restarting\n");
.
## diffname port/devlance.c 1992/0506
## diff -e /n/bootesdump/1992/0328/sys/src/9/port/devlance.c /n/bootesdump/1992/0506/sys/src/9/port/devlance.c
394a
	freeb(bp);
.
393d
355c
		return;
.
350,352c
print("lance wedged\n");
		qunlock(&l.tlock);
.
340a
		freeb(bp);
.
339d
## diffname port/devlance.c 1992/0520
## diff -e /n/bootesdump/1992/0506/sys/src/9/port/devlance.c /n/bootesdump/1992/0520/sys/src/9/port/devlance.c
671a
	return -1;		/* never reached */
.
## diffname port/devlance.c 1992/0604
## diff -e /n/bootesdump/1992/0520/sys/src/9/port/devlance.c /n/bootesdump/1992/0604/sys/src/9/port/devlance.c
330a
	} else if(*p->d == *l.ea && memcmp(l.ea, p->d, sizeof(l.ea)) == 0){
		len = blen(bp);
		bp = expandb(bp, len >= ETHERMINTU ? len : ETHERMINTU);
		if(bp){
			putq(&l.self, bp);
			wakeup(&l.rr);
		}
		return;
.
315,323d
313c
	if(*p->d == 0xff || l.prom || l.all){
.
## diffname port/devlance.c 1992/0605
## diff -e /n/bootesdump/1992/0604/sys/src/9/port/devlance.c /n/bootesdump/1992/0605/sys/src/9/port/devlance.c
840c
		sleep(&l.rr, isinput, m);

		/*
		 *  if the lance is wedged, restart it
		 */
		if(l.wedged){
			print("lance wedged, restarting\n");
			l.wedged = 0;
			lancestart(0);
		}

		/*
		 *  close ethertypes requesting it
		 */
		if(l.closeline){
			lock(&l.closepin);
			for(e = l.closeline; e; e = e->closeline){
				e->q = 0;
				wakeup(&e->rc);
			}
			l.closeline = 0;
			unlock(&l.closepin);
		}
.
837a
			l.rl = RSUCC(l.rl);
			m = &(lm->rmr[l.rl]);
.
834,836c
			MPus(m->laddr) = LADDR(&l.lrp[l.rl]);
			MPus(m->flags) = LANCEOWNER|HADDR(&l.lrp[l.rl]);
.
831d
827d
819,825d
817c
			} else {
				/*
				 *  stuff packet up each queue that wants it
				 */
				p = &l.rp[l.rl];
				len = MPus(m->cntflags) - 4;
				lanceup(p, len);
.
805,806d
803c
		m = &(lm->rmr[l.rl]);
		while((MPus(m->flags) & LANCEOWNER)==0){
.
781,782c
	return l.self.first || ((MPus(m->flags) & LANCEOWNER)==0);
.
779c
	Msg *m = arg;
.
749,760d
746c
		if(e->type!=-1 && p->d[0]!=0xff
		&& (*p->d != *l.ea || memcmp(p->d, l.ea, sizeof(p->d))!=0))
.
740c
		if(e->q==0 || (t!=e->type && e->type!=-1) || e->q->next->len>Streamhi)
.
738c
		 *  check for open, the right type, and flow control
.
722d
717,720c
	if(csr & TINT)
.
714,715c
	 *  wake any process waiting for a transmit buffer
.
710c
	if((csr & (TXON|RXON)) != (TXON|RXON))
		l.wedged = 1;

	/*
	 *  wakeup the input process
	 */
	if(csr & RINT)
.
708c
	 *  the lance turns off if it gets strange output errors
.
702c
		l.wedged = 0;
.
684d
552c
		lancestart(0);
.
498,499c
	for(i = 0; i < l.nrrb; i++, m++)
		MPus(m->flags) |= LANCEOWNER;
.
496d
453,454d
447,448c
	qlock(&l.tlock);
.
436c
lancestart(int mode)
.
432c
 *  Initialize and start the lance.  This routine can be called only from a process.
.
387c
	MPus(m->flags) = LANCEOWNER|STP|ENP|HADDR(&l.ltp[l.tc]);
.
383d
355a
	if((MPus(m->flags)&LANCEOWNER) != 0)
		tsleep(&l.tr, isobuf, m, 128);
		if(isobuf(m) == 0){
			qunlock(&l.tlock);
			freeb(bp);
			poperror();
			print("lance wedged, dumping block & restarting\n");
			lancestart(0);
			return;
		}
.
347,354c
	m = &(LANCEMEM->tmr[l.tc]);
.
344c
	 *  Wait till we get an output buffer, complain if input
.
295c
				lancestart(PROM);/**/
.
288c
			e->type = strtol((char *)bp->rptr, 0, 0);
.
274c
lanceoput(Queue *q, Block *bp)
.
270,271c
	Msg *m;

	m = x;
	return (MPus(m->flags)&LANCEOWNER) == 0;
.
260d
254c

	/*
	 *  mark as closing and wait for kproc to close us
	 */
	lock(&l.closepin);
	et->closeline = l.closeline;
	l.closeline = et;
	unlock(&l.closepin);
	wakeup(&l.rr);
	sleep(&et->rc, isclosed, et);
	
.
246c
			lancestart(0);
.
235a
static int
isclosed(void *x)
{
	return ((Ethertype *)x)->q == 0;
}
.
227d
222d
212,214d
195c
static void	lancestart(int);
.
169c
#define LANCEOWNER	0x8000	/* 1 means that the buffer can be used by the chip */
.
112a
	Ethertype *closeline;	/* channels waiting to close */
	Lock	closepin;	/* lock for closeline */
.
110,111c
	ushort	tc;		/* next xmt Message CPU will try for */	
.
106d
96a
	int	wedged;		/* the lance is wedged */
.
81,85c
	int		type;		/* ethernet type */
	int		prom;		/* promiscuous mode */
	Queue		*q;
	int		inuse;
	Rendez		rc;		/* rendzvous for close */
	Ethertype	*closeline;	/* close list */
};
.
79c
typedef struct Ethertype	Ethertype;
struct Ethertype
{
.
## diffname port/devlance.c 1992/0621
## diff -e /n/bootesdump/1992/0605/sys/src/9/port/devlance.c /n/bootesdump/1992/0621/sys/src/9/port/devlance.c
646c
	char buf[512];
.
569d
564c
		kproc("lancekproc", lancekproc, 0);
.
552,554d
288a

.
240a

.
17,20d
## diffname port/devlance.c 1992/0623
## diff -e /n/bootesdump/1992/0621/sys/src/9/port/devlance.c /n/bootesdump/1992/0623/sys/src/9/port/devlance.c
674c
		netown(e, u->p->user, 0);
.
435a
		for(i = 0; i < Ntypes; i++)
			netadd(&l.net, &l.e[i], i);
.
431d
418a
	int i;
.
271c
	netdisown(et);
.
99d
78a
	Netprot;			/* stat info */
.
## diffname port/devlance.c 1992/0711
## diff -e /n/bootesdump/1992/0623/sys/src/9/port/devlance.c /n/bootesdump/1992/0711/sys/src/9/port/devlance.c
692d
619a
	USED(offset);
.
457d
## diffname port/devlance.c 1992/0714
## diff -e /n/bootesdump/1992/0711/sys/src/9/port/devlance.c /n/bootesdump/1992/0714/sys/src/9/port/devlance.c
743a
	if(len <= 0)
		return;

.
## diffname port/devlance.c 1992/0717
## diff -e /n/bootesdump/1992/0714/sys/src/9/port/devlance.c /n/bootesdump/1992/0717/sys/src/9/port/devlance.c
796a

	while(waserror())
		print("lancekproc err %s\n", u->error);

.
769d
767a
			poperror();
.
## diffname port/devlance.c 1992/0912
## diff -e /n/bootesdump/1992/0717/sys/src/9/port/devlance.c /n/bootesdump/1992/0912/sys/src/9/port/devlance.c
848a
			print("lance wedged, restarting\n");
.
847d
742d
739a
	int t;
.
706a
		else {
			l.wedged = 1;
			l.misses = 0;
			*l.rap = 0;
			*l.rdp = STOP;
			wakeup(&l.rr);
			wakeup(&l.tr);
			return;
		}
.
368a
			l.wedged = 0;
.
365c
		if(l.wedged || isobuf(m) == 0){
.
## diffname port/devlance.c 1992/0913
## diff -e /n/bootesdump/1992/0912/sys/src/9/port/devlance.c /n/bootesdump/1992/0913/sys/src/9/port/devlance.c
859a
			l.wedged = 0;
.
857d
792c
	return l.wedged || l.self.first || ((MPus(m->flags) & LANCEOWNER)==0);
.
711,712c
			lancereset();
.
708a
			print("lance stopped\n");
.
707c
			print("lance err #%ux\n", csr);
.
373a
	}
.
371a
			l.wedged = 0;
.
369d
363c
	while((MPus(m->flags)&LANCEOWNER) != 0) {
.
349a
	if(l.wedged) {
		qunlock(&l.tlock);
		freeb(bp);
		return;
	}
.
345a
	if(l.wedged) {
		freeb(bp);
		return;
	}

.
284c
	return l.wedged || (MPus(m->flags)&LANCEOWNER) == 0;
.
## diffname port/devlance.c 1992/0926
## diff -e /n/bootesdump/1992/0913/sys/src/9/port/devlance.c /n/bootesdump/1992/0926/sys/src/9/port/devlance.c
791d
## diffname port/devlance.c 1992/1017
## diff -e /n/bootesdump/1992/0926/sys/src/9/port/devlance.c /n/bootesdump/1992/1017/sys/src/9/port/devlance.c
802c
	return ((MPus(m->flags) & LANCEOWNER)==0) || l.wedged || l.self.first
		|| l.closeline;
.
## diffname port/devlance.c 1993/0501
## diff -e /n/bootesdump/1992/1017/sys/src/9/port/devlance.c /n/fornaxdump/1993/0501/sys/src/brazil/port/devlance.c
820c
		print("lancekproc err %s\n", up->error);
.
688c
		netown(e, up->user, 0);
.
## diffname port/devlance.c 1993/0806
## diff -e /n/fornaxdump/1993/0501/sys/src/brazil/port/devlance.c /n/fornaxdump/1993/0806/sys/src/brazil/port/devlance.c
885a
	qunlock(&l.tlock);
	return n;
}

void
lanceremove(Chan *c)
{
	USED(c);
}

void
lancestat(Chan *c, char *dp)
{
	netifstat(&l, c, dp);
}

void
lancewstat(Chan *c, char *dp)
{
	netifwstat(&l, c, dp);
.
884a
		memmove(p->s, l.ea, sizeof(l.ea));

		l.outpackets++;
		MPs(m->size) = -n;
		MPus(m->cntflags) = 0;
		MPus(m->laddr) = LADDR(&l.ltp[l.tc]);
		MPus(m->flags) = LANCEOWNER|STP|ENP|HADDR(&l.ltp[l.tc]);
		l.tc = TSUCC(l.tc);
		*l.rdp = INEA|TDMD; /**/
.
873,883c
	/* we handle data */
	qlock(&l.tlock);
	m = &(LANCEMEM->tmr[l.tc]);
	tsleep(&l.tr, isoutbuf, m, 10000);
	if(!isoutbuf(m) || l.wedged){
		print("lance transmitter jammed\n");
	}
	else {
		p = &l.tp[l.tc];
		memmove(p->d, buf, n);
		if(n < 60) {
			memset(p->d+n, 0, 60-n);
			n = 60;
.
864,871c
	/* etherif.c handles structure */
	if(NETTYPE(c->qid.path) != Ndataqid)
		return netifwrite(&l, c, buf, n);
.
850,862c
	if(n > ETHERMAXTU)
		error(Ebadarg);
.
822,848c
	USED(offset);
.
819,820c
long
lancewrite(Chan *c, void *buf, long n, ulong offset)
{
	Msg *m;
	Lancepkt *p;
.
817c
	m = x;
	return l.wedged || (MPus(m->flags)&LANCEOWNER) == 0;
}
.
815d
809,813c
	netifclose(&l, c);
}

long
lanceread(Chan *c, void *buf, long n, ulong offset)
{
	return netifread(&l, c, buf, n, offset);
}

static int
isoutbuf(void *x)
{
.
806,807c
void
lanceclose(Chan *c)
.
802,803c
void
lancecreate(Chan *c, char *name, int omode, ulong perm)
{
	USED(c, name, omode, perm);
.
800c
	return netifopen(&l, c, omode);
}
.
794,798c
Chan*
lanceopen(Chan *c, int omode)
.
783,791c
int
lancewalk(Chan *c, char *name)
{
	return netifwalk(&l, c, name);
.
776,781c
Chan*
lanceclone(Chan *c, Chan *nc)
{
	return devclone(c, nc);
}
.
768,774c
Chan*
lanceattach(char *spec)
{
	return devattach('l', spec);
}
.
765,766c
void
lanceinit(void)
{
	lancestart(0);
	print("lance ether: %.2x%.2x%.2x%.2x%.2x%.2x\n",
		l.ea[0], l.ea[1], l.ea[2], l.ea[3], l.ea[4], l.ea[5]);
}
.
761,763c
	USED(arg);
	if(on)
		lancestart(PROM);
	else
		lancestart(0);;
}
.
759c
promiscuous(void *arg, int on)
.
756c
 *  turn promiscuous mode on/off
.
747a
			/*
			 *  stage the next input buffer
			 */
			MPs(m->size) = -sizeof(Lancepkt);
			MPus(m->cntflags) = 0;
			MPus(m->laddr) = LADDR(&l.lrp[l.rl]);
			MPus(m->flags) = LANCEOWNER|HADDR(&l.lrp[l.rl]);
			wbflush();
			l.rl = RSUCC(l.rl);
			m = &(lm->rmr[l.rl]);
		}
	}

.
745,746c
	if(csr & RINT) {
		m = &(lm->rmr[l.rl]);
		while((MPus(m->flags) & LANCEOWNER)==0){
			l.inpackets++;
			t = MPus(m->flags);
			if(t & ERR){
				if(t & FRAM)
					l.frames++;
				if(t & OFLO)
					l.overflows++;
				if(t & CRC)
					l.crcs++;
				if(t & BUFF)
					l.buffs++;
			} else {
				/* stuff packet up each queue that wants it */
				p = &l.rp[l.rl];
				x = MPus(m->cntflags) - 4;
				t = (p->type[0]<<8) | p->type[1];
				for(fp = l.f; fp < &l.f[Ntypes]; fp++){
					f = *fp;
					if(f == 0)
						continue;
					if(f->type == t || f->type < 0)
						qproduce(f->in, p->d, x);
				}
			}
.
743c
	 *  process incoming frames
.
732d
724d
704c
	Msg *m;
	Lancepkt *p;
	Netfile *f, **fp;
	ushort csr, t, x;
	Lancemem *lm = LANCEMEM;
.
564,701d
510c
		MPs(m->size) = -sizeof(Lancepkt);
.
477d
462,463c
 * Initialize and start the lance. 
 * This routine can be called only from a process.
 * It may be used to restart a dead lance.
.
437,451c
		/* general network interface structure */
		netifinit(&l, "ether", Ntypes, 32*1024);
		l.alen = 6;
		memmove(l.addr, l.ea, 6);
		memmove(l.bcast, etherbcast, 6);
		l.promiscuous = promiscuous;
		l.arg = &l;
.
431d
215,427d
123,213d
121c
static void	promiscuous(void*, int);
.
119c
	Netif;
} l;
.
112,117c
	QLock	tlock;		/* lock for grabbing transmitter queue */
	Rendez	tr;		/* wait here for free xmit buffer */
.
107,109d
101,105d
99d
95,97d
89,93c
	uchar	ea[6];
	uchar	bcast[6];
.
87a
struct Softlance
{
	Lance;			/* host dependent lance params */
.
78,85c
	PROM	= 0x8000,
	INTL	= 0x40,
	DRTY	= 0x20,
	COLL	= 0x10,
	DTCR	= 0x8,
	LOOP	= 0x4,
	DTX	= 0x2,
	DRX	= 0x1,
	ERR0	= 0x8000,
	BABL	= 0x4000,
	CERR	= 0x2000,
	MISS	= 0x1000,
	MERR	= 0x800,
	RINT	= 0x400,
	TINT	= 0x200,
	IDON	= 0x100,
	INTR	= 0x80,
	INEA	= 0x40,
	RXON	= 0x20,
	TXON	= 0x10,
	TDMD	= 0x8,
	STOP	= 0x4,
	STRT	= 0x2,
	INIT	= 0x1,
	/* flag bits from a buffer descriptor in the rcv/xmt rings */
	LANCEOWNER= 0x8000,	/* 1 means buffer can be used by the chip */
	ERR	= 0x4000,	/* error summary, the OR of all error bits */
	FRAM	= 0x2000,	/* CRC error */
	OFLO	= 0x1000,	/* (receive) lost some of the packet */
	MORE	= 0x1000,	/* (transmit) more than 1 retry to tx pkt */
	CRC	= 0x800,	/* (rcv) crc error reading packet */
	ONE	= 0x800,	/* (tx) one retry to transmit the packet */
	BUF	= 0x400,	/* (rcv) out of buffers */
	DEF	= 0x400,	/* (tx) deffered while transmitting packet */
	STP	= 0x200,	/* start of packet */
	ENP	= 0x100,	/* end of packet */
	/* cntflags bits from a buffer descriptor in the rcv/xmt rings */
	BUFF	= 0x8000,	/* buffer error (host screwed up?) */
	UFLO	= 0x4000,	/* underflow from memory */
	LCOL	= 0x1000,	/* late collision (ether too long?) */
	LCAR	= 0x800,	/* loss of carrier (ether broken?) */
	RTRY	= 0x400,	/* couldn't transmit (ether jammed?) */
	TTDR	= 0x3FF,	/* time domain reflectometer */
.
72,76c
enum
.
26c
	ushort	cntflags;	/* (rcv)count of buffer; (xmt) more flags */
.
11,12c
	Ntypes=		9,	/* max number of ethernet packet types */
	Maxrb=		128,	/* max buffers in a ring */
.
8c
#include	"../port/netif.h"
.
## diffname port/devlance.c 1993/0807
## diff -e /n/fornaxdump/1993/0806/sys/src/brazil/port/devlance.c /n/fornaxdump/1993/0807/sys/src/brazil/port/devlance.c
469c
		*l.rdp = INEA|TDMD;
.
453d
451c
	if(!isoutbuf(m) || l.wedged)
.
330a

.
174a
	Lancemem *lm = LANCEMEM;
.
173d
152a

.
144,145c
	if(inited == 0){
		inited = 1;
.
142c
	static int inited;
.
123d
## diffname port/devlance.c 1993/1008
## diff -e /n/fornaxdump/1993/0807/sys/src/brazil/port/devlance.c /n/fornaxdump/1993/1008/sys/src/brazil/port/devlance.c
454a
		etherloop(buf, n);
.
432a
static void
etherloop(Etherpkt *p, long n)
{
	int s;
	ushort t;
	Netfile *f, **fp;

	if(memcmp(p->d, p->s, sizeof(p->d)) && memcmp(p->d, l.bcast, sizeof(p->d)))
		return;

	s = splhi();
	t = (p->type[0]<<8) | p->type[1];
	for(fp = l.f; fp < &l.f[Ntypes]; fp++) {
		f = *fp;
		if(f == 0)
			continue;
		if(f->type == t || f->type < 0)
			qproduce(f->in, p->d, n);
	}
	splx(s);
}

.
## diffname port/devlance.c 1993/1009
## diff -e /n/fornaxdump/1993/1008/sys/src/brazil/port/devlance.c /n/fornaxdump/1993/1009/sys/src/brazil/port/devlance.c
477d
470a
	if(etherloop(buf, n))
		return n;

.
452a
	return !different;
.
440,441c
	different = memcmp(p->d, p->s, sizeof(p->d));
	if(different && memcmp(p->d, l.bcast, sizeof(p->d)))
		return 0;
.
436c
	int s, different;
.
433c
static int
.
## diffname port/devlance.c 1993/1202
## diff -e /n/fornaxdump/1993/1009/sys/src/brazil/port/devlance.c /n/fornaxdump/1993/1202/sys/src/brazil/port/devlance.c
498a
	poperror();
.
476a
	if(waserror()) {
		qunlock(&ctlr->tlock);
		nexterror();
	}

.
## diffname port/devlance.c 1993/1216
## diff -e /n/fornaxdump/1993/1202/sys/src/brazil/port/devlance.c /n/fornaxdump/1993/1216/sys/src/brazil/port/devlance.c
478c
		qunlock(&l.tlock);
.
## diffname port/devlance.c 1994/0624
## diff -e /n/fornaxdump/1993/1216/sys/src/brazil/port/devlance.c /n/fornaxdump/1994/0624/sys/src/brazil/port/devlance.c
6d
## diffname port/devlance.c 1994/0728
## diff -e /n/fornaxdump/1994/0624/sys/src/brazil/port/devlance.c /n/fornaxdump/1994/0728/sys/src/brazil/port/devlance.c
299,300d
297c
	if(csr & IDON)
.
262a

	for(i = 0; i < 1000; i++)
		if(l.wedged == 0)
			break;

	qunlock(&l.tlock);
.
160a
	l.wedged = 1;
.
## diffname port/devlance.c 1995/0108
## diff -e /n/fornaxdump/1994/0728/sys/src/brazil/port/devlance.c /n/fornaxdump/1995/0108/sys/src/brazil/port/devlance.c
509a
}

long
lancebwrite(Chan *c, Block *bp, ulong offset)
{
	return devbwrite(c, bp, offset);
.
427a
Block*
lancebread(Chan *c, long n, ulong offset)
{
	return devbread(c, n, offset);
}

.
## diffname port/devlance.c 1995/0804
## diff -e /n/fornaxdump/1995/0108/sys/src/brazil/port/devlance.c /n/fornaxdump/1995/0804/sys/src/brazil/port/devlance.c
527d
525c
lanceremove(Chan*)
.
473,474d
468c
lancewrite(Chan *c, void *buf, long n, ulong)
.
413d
411c
lancecreate(Chan*, char*, int, ulong)
.
371d
369c
promiscuous(void*, int on)
.
## diffname port/devlance.c 1997/0327
## diff -e /n/fornaxdump/1995/0804/sys/src/brazil/port/devlance.c /n/emeliedump/1997/0327/sys/src/brazil/port/devlance.c
535a

int
parseether(uchar *to, char *from)
{
	char nip[4];
	char *p;
	int i;

	p = from;
	for(i = 0; i < 6; i++){
		if(*p == 0)
			return -1;
		nip[0] = *p++;
		if(*p == 0)
			return -1;
		nip[1] = *p++;
		nip[2] = 0;
		to[i] = strtoul(nip, 0, 16);
		if(*p == ':')
			p++;
	}
	return 0;
}

Dev lancedevtab = {
	lancereset,
	lanceinit,
	lanceattach,
	devclone,
	lancewalk,
	lancestat,
	lanceopen,
	lancecreate,
	lanceclose,
	lanceread,
	devbread,
	lancewrite,
	devbwrite,
	lanceremove,
	lancewstat,
};
.
531c
static void
.
525c
static void
.
514,520c
static void
.
465c
static long
.
426,431d
420c
static long
.
414c
static void
.
409c
static void
.
403c
static Chan*
.
391,397c
static int
.
387a
	char *s;

	s = spec;
	if(s && *s && (*s != '0' || *(s+1)))
		error(Enodev);

.
385c
static Chan*
.
377c
static void
.
149,150c
		memmove(l.addr, l.ea, Eaddrlen);
		memset(l.bcast, 0xFF, Eaddrlen);
.
147c
		netifinit(&l, "ether0", Ntypes, 32*1024);
.
137c
static void
.
## diffname port/devlance.c 1997/0408
## diff -e /n/emeliedump/1997/0327/sys/src/brazil/port/devlance.c /n/emeliedump/1997/0408/sys/src/brazil/port/devlance.c
548a
	'l',
	"lance",

.
## diffname port/devlance.c 1997/1101 # deleted
## diff -e /n/emeliedump/1997/0408/sys/src/brazil/port/devlance.c /n/emeliedump/1997/1101/sys/src/brazil/port/devlance.c
1,567d