2001/0727/alphapc/devether.c (diff list | history)

2001/0727/sys/src/9/alphapc/devether.c:1,451 – 2001/1204/sys/src/9/alphapc/devether.c:1,446 (short | long | prev | next)
1999/0415		#include "u.h" #include "../port/lib.h" #include "mem.h" #include "dat.h" #include "fns.h" #include "io.h" #include "ureg.h" #include "../port/error.h" #include "../port/netif.h" #include "etherif.h" static Ether *etherxx[MaxEther]; Chan* etherattach(char* spec) { ulong ctlrno; char *p; Chan *chan; ctlrno = 0; if(spec && *spec){ ctlrno = strtoul(spec, &p, 0); if((ctlrno == 0 && p == spec) || *p || (ctlrno >= MaxEther)) error(Ebadarg); } if(etherxx[ctlrno] == 0) error(Enodev); chan = devattach('l', spec); chan->dev = ctlrno; if(etherxx[ctlrno]->attach) etherxx[ctlrno]->attach(etherxx[ctlrno]); return chan; }
2001/0727		static Walkqid* etherwalk(Chan* chan, Chan* nchan, char** name, int nname)
1999/0415		{
2001/0727		return netifwalk(etherxx[chan->dev], chan, nchan, name, nname);
1999/0415		}
2001/0727		static int etherstat(Chan* chan, uchar* dp, int n)
1999/0415		{
2001/0727		return netifstat(etherxx[chan->dev], chan, dp, n);
1999/0415		} static Chan* etheropen(Chan* chan, int omode) { return netifopen(etherxx[chan->dev], chan, omode); } static void ethercreate(Chan*, char*, int, ulong) { } static void etherclose(Chan* chan) { netifclose(etherxx[chan->dev], chan); } static long etherread(Chan* chan, void* buf, long n, vlong off) { Ether *ether; ulong offset = off; ether = etherxx[chan->dev];
2001/0727		if((chan->qid.type & QTDIR) == 0 && ether->ifstat){
1999/0415		/* * With some controllers it is necessary to reach * into the chip to extract statistics. */ if(NETTYPE(chan->qid.path) == Nifstatqid) return ether->ifstat(ether, buf, n, offset); else if(NETTYPE(chan->qid.path) == Nstatqid) ether->ifstat(ether, buf, 0, offset); } return netifread(ether, chan, buf, n, offset); } static Block* etherbread(Chan* chan, long n, ulong offset) { return netifbread(etherxx[chan->dev], chan, n, offset); } static void etherremove(Chan*) { }
2001/0727		static int etherwstat(Chan* chan, uchar* dp, int n)
1999/0415		{
2001/0727		return netifwstat(etherxx[chan->dev], chan, dp, n);
1999/0415		} static void etherrtrace(Netfile* f, Etherpkt* pkt, int len) { int i, n; Block *bp; if(qwindow(f->in) <= 0) return;
2000/0713		if(len > 58) n = 58;
1999/0415		else n = len;
2000/0713		bp = iallocb(64); if(bp == nil)
1999/0415		return; memmove(bp->wp, pkt->d, n); i = TK2MS(MACHP(0)->ticks); bp->wp[58] = len>>8; bp->wp[59] = len; bp->wp[60] = i>>24; bp->wp[61] = i>>16; bp->wp[62] = i>>8; bp->wp[63] = i; bp->wp += 64; qpass(f->in, bp); } Block*
2000/0401		etheriq(Ether* ether, Block* bp, int fromwire)
1999/0415		{ Etherpkt *pkt; ushort type;
2000/0401		int len, multi, tome, fromme;
1999/0415		Netfile **ep, *f, **fp, *fx; Block *xbp; ether->inpackets++; pkt = (Etherpkt*)bp->rp; len = BLEN(bp); type = (pkt->type[0]<<8)|pkt->type[1]; fx = 0; ep = ðer->f[Ntypes];
2000/0401		multi = pkt->d[0] & 1;
1999/0415		/* check for valid multcast addresses */
2000/0401		if(multi && memcmp(pkt->d, ether->bcast, sizeof(pkt->d)) && ether->prom == 0){
1999/0415		if(!activemulti(ether, pkt->d, sizeof(pkt->d))){
2000/0401		if(fromwire){
1999/0415		freeb(bp); bp = 0; } return bp; } }
2000/0401		/* is it for me? */ tome = memcmp(pkt->d, ether->ea, sizeof(pkt->d)) == 0; fromme = memcmp(pkt->s, ether->ea, sizeof(pkt->s)) == 0;
1999/0415		/* * Multiplex the packet to all the connections which want it.
2000/0401		* If the packet is not to be used subsequently (fromwire != 0),
1999/0415		* attempt to simply pass it into one of the connections, thereby * saving a copy of the data (usual case hopefully). */ for(fp = ether->f; fp < ep; fp++){
2000/0401		if(f = *fp) if(f->type == type || f->type < 0) if(tome || multi || f->prom){ /* Don't want to hear bridged packets */ if(f->bridge && !fromwire && !fromme) continue; if(!f->headersonly){ if(fromwire && fx == 0)
1999/0415		fx = f; else if(xbp = iallocb(len)){ memmove(xbp->wp, pkt, len); xbp->wp += len; qpass(f->in, xbp); } else ether->soverflows++; } else etherrtrace(f, pkt, len); } } if(fx){
2000/0401		if(qpass(fx->in, bp) < 0) ether->soverflows++;
1999/0415		return 0; }
2000/0401		if(fromwire){
1999/0415		freeb(bp); return 0; } return bp; } static int etheroq(Ether* ether, Block* bp) { int len, loopback, s; Etherpkt *pkt; ether->outpackets++; /* * Check if the packet has to be placed back onto the input queue, * i.e. if it's a loopback or broadcast packet or the interface is * in promiscuous mode. * If it's a loopback packet indicate to etheriq that the data isn't * needed and return, etheriq will pass-on or free the block.
2000/0401		* To enable bridging to work, only packets that were originated * by this interface are fed back.
1999/0415		*/ pkt = (Etherpkt*)bp->rp; len = BLEN(bp);
2000/0401		loopback = memcmp(pkt->d, ether->ea, sizeof(pkt->d)) == 0;
1999/0415		if(loopback || memcmp(pkt->d, ether->bcast, sizeof(pkt->d)) == 0 || ether->prom){ s = splhi();
2000/0401		etheriq(ether, bp, 0);
1999/0415		splx(s); } if(!loopback){ qbwrite(ether->oq, bp); ether->transmit(ether);
2000/0401		} else freeb(bp);
1999/0415		return len; } static long etherwrite(Chan* chan, void* buf, long n, vlong) { Ether *ether; Block *bp; ether = etherxx[chan->dev]; if(NETTYPE(chan->qid.path) != Ndataqid) return netifwrite(ether, chan, buf, n); if(n > ETHERMAXTU) error(Etoobig); if(n < ETHERMINTU) error(Etoosmall); bp = allocb(n); if(waserror()){ freeb(bp); nexterror(); } memmove(bp->rp, buf, n); memmove(bp->rp+Eaddrlen, ether->ea, Eaddrlen); poperror(); bp->wp += n; return etheroq(ether, bp); } static long etherbwrite(Chan* chan, Block* bp, ulong) { Ether *ether; long n; n = BLEN(bp); ether = etherxx[chan->dev]; if(NETTYPE(chan->qid.path) != Ndataqid){ n = netifwrite(ether, chan, bp->rp, n); freeb(bp); return n; } if(n > ETHERMAXTU){ freeb(bp); error(Ebadarg); } if(n < ETHERMINTU){ freeb(bp); error(Etoosmall); } return etheroq(ether, bp); } static struct { char* type; int (*reset)(Ether*); } cards[MaxEther+1]; void addethercard(char* t, int (*r)(Ether*)) { static int ncard; if(ncard == MaxEther) panic("too many ether cards"); cards[ncard].type = t; cards[ncard].reset = r; ncard++; } 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; } static void etherreset(void) { Ether *ether; int i, n, ctlrno;
2001/0727		char name[32], buf[128];
1999/0415		for(ether = 0, ctlrno = 0; ctlrno < MaxEther; ctlrno++){ if(ether == 0) ether = malloc(sizeof(Ether)); memset(ether, 0, sizeof(Ether)); ether->ctlrno = ctlrno; ether->tbdf = BUSUNKNOWN; ether->mbps = 10;
2001/0727		ether->minmtu = ETHERMINTU; ether->maxmtu = ETHERMAXTU;
1999/0415		if(isaconfig("ether", ctlrno, ether) == 0) continue; for(n = 0; cards[n].type; n++){ if(cistrcmp(cards[n].type, ether->type)) continue; for(i = 0; i < ether->nopt; i++){ if(strncmp(ether->opt[i], "ea=", 3)) continue; if(parseether(ether->ea, ðer->opt[i][3]) == -1) memset(ether->ea, 0, Eaddrlen); } if(cards[n].reset(ether)) break; /* * IRQ2 doesn't really exist, it's used to gang the interrupt * controllers together. A device set to IRQ2 will appear on * the second interrupt controller as IRQ9. */
2001/0228		if(ether->irq == 2 && BUSTYPE(ether->tbdf) != BusPCI)
1999/0415		ether->irq = 9;
2000/0401		snprint(name, sizeof(name), "ether%d", ctlrno); intrenable(ether->irq, ether->interrupt, ether, ether->tbdf, name);
1999/0415
2000/0401		i = sprint(buf, "#l%d: %s: %dMbps port 0x%luX irq %lud",
1999/0415		ctlrno, ether->type, ether->mbps, ether->port, ether->irq); if(ether->mem) i += sprint(buf+i, " addr 0x%luX", PADDR(ether->mem)); if(ether->size) i += sprint(buf+i, " size 0x%luX", ether->size); i += sprint(buf+i, ": %2.2uX%2.2uX%2.2uX%2.2uX%2.2uX%2.2uX", ether->ea[0], ether->ea[1], ether->ea[2], ether->ea[3], ether->ea[4], ether->ea[5]); sprint(buf+i, "\n"); print(buf); if(ether->mbps == 100){ netifinit(ether, name, Ntypes, 256*1024); if(ether->oq == 0) ether->oq = qopen(256*1024, 1, 0, 0); } else{ netifinit(ether, name, Ntypes, 65*1024); if(ether->oq == 0) ether->oq = qopen(65*1024, 1, 0, 0); } if(ether->oq == 0) panic("etherreset %s", name); ether->alen = Eaddrlen; memmove(ether->addr, ether->ea, Eaddrlen); memset(ether->bcast, 0xFF, Eaddrlen); etherxx[ctlrno] = ether; ether = 0; break; } } if(ether) free(ether); } #define POLY 0xedb88320 /* really slow 32 bit crc for ethers */ ulong ethercrc(uchar *p, int len) { int i, j; ulong crc, b; crc = 0xffffffff; for(i = 0; i < len; i++){ b = *p++; for(j = 0; j < 8; j++){ crc = (crc>>1) ^ (((crc^b) & 1) ? POLY : 0); b >>= 1; } } return crc; } Dev etherdevtab = { 'l', "ether", etherreset, devinit, etherattach, etherwalk, etherstat, etheropen, ethercreate, etherclose, etherread, etherbread, etherwrite, etherbwrite, etherremove,
2001/1204		devremove,
1999/0415		etherwstat, };