plan 9 kernel history: overview | file list | diff list |
1990/0227/port/devlance.c (diff list | history)
port/devlance.c on 1990/0227 | ||
1990/0227 | #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); } |