ref: d916a4c3823f55227ffae35738c2497256e307b5
dir: /os/cerf405/etheremac.c/
/*
* ethernet
*/
#include "u.h"
#include "lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#include "../port/error.h"
#include "../port/netif.h"
#include "ethermii.h"
#include "etherif.h"
#include "ureg.h"
/*
* TO DO:
* - test EMAC1
*/
#define DBG if(0)iprint
#define MIIDBG if(0)iprint
enum {
Nrdre = 64, /* receive descriptor ring entries */
Ntdre = 32, /* transmit descriptor ring entries */
Nrxchan = 2,
Ntxchan = 2, /* there are actually 4 but we only use 2 now */
Rbsize = ETHERMAXTU, /* ring buffer size */
Bufsize = (Rbsize+CACHELINESZ-1)&~(CACHELINESZ-1), /* aligned */
};
enum {
/* emac-specific Rx BD bits */
RxOverrun= 1<<9, /* not enough empty space in FIFO */
RxPause= 1<<8, /* control pause packet */
RxBad= 1<<7, /* packet error */
RxRunt= 1<<6,
RxShort= 1<<5,
RxAlign= 1<<4,
RxFCS= 1<<3,
RxLong= 1<<2,
RxRange= 1<<1, /* out of range error */
RxInRange= 1<<0, /* in range error */
RxError= (0x3FF & ~RxPause), /* error flags */
/* emac-specific Tx BD bits */
/* write access */
TxFCS= 1<<9, /* generate FCS */
TxPad= 1<<8, /* pad short frames */
TxInsSA= 1<<7, /* insert source address */
TxRepSA= 1<<6, /* replace source address */
TxInsVLAN= 1<<5, /* insert VLAN tag */
TxRepVLAN= 1<<4, /* replace VLAN tag */
/* read access (status) */
TxBadFCS= 1<<9,
TxBadPrev= 1<<8, /* bad previous packet in dependent mode */
TxLostCarrier= 1<<7,
TxEDef= 1<<6, /* excessive deferral */
TxECol= 1<<5, /* excessive collisions */
TxLateCol= 1<<4, /* late collision (half-duplex only) */
TxManyCol= 1<<3, /* more than 1 but less than 16 collisions */
TxCollision= 1<<2, /* single collision */
TxUnderrun= 1<<1, /* didn't fill FIFO in time */
TxSQE= 1<<0, /* signal quality test failed (10mbit half-duplex only) */
TxError= 0x3FF, /* error flags */
};
typedef struct Emac Emac;
struct Emac {
ulong mr0; /* mode register 0 [see 19-48] */
ulong mr1; /* mode register 1 [Reset] */
ulong tmr0; /* transmit mode register 0 [see 19-28] */
ulong tmr1; /* transmit mode register 1 [see 19-28] */
ulong rmr; /* receive mode register [Reset] */
ulong isr; /* interrupt status register [Always] */
ulong iser; /* interrupt status enable register [Reset] */
ulong iahr; /* individual address high [Reset, R, T]*/
ulong ialr; /* individual address low [Reset, R, T] */
ulong vtpid; /* VLAN Tag Protocol Identifier [Reset, R, T] */
ulong vtci; /* VLAN Tag Control Information [Reset, R, T] */
ulong ptr; /* pause timer [Reset, T] */
ulong iaht[4]; /* individual address hash table [Reset, R] */
ulong gaht[4]; /* group address hash table [Reset, R] */
ulong lsah; /* last source address high */
ulong lsal; /* last source address low */
ulong ipgvr; /* inter-packet gap value [Reset, T] */
ulong stacr; /* STA control register [see 19-41] */
ulong trtr; /* transmit request threshold register [see 19-42] */
ulong rwmr; /* receive low/high water mark [Reset] */
ulong octx; /* bytes transmitted */
ulong ocrx; /* bytes received */
};
enum {
/* mode register 0 */
Mr0Rxi= 1<<31, /* receive MAC idle */
Mr0Txi= 1<<30, /* transmit MAC idle */
Mr0Srst= 1<<29, /* soft reset; soft reset in progress */
Mr0Txe= 1<<28, /* tx MAC enable */
Mr0Rxe= 1<<27, /* rx MAC enable */
Mr0Wke= 1<<26, /* enable wake-up packets */
/* mode register 1 */
Mr1Fde= 1<<31, /* full-duplex enable */
Mr1Ile= 1<<30, /* internal loop-back enable */
Mr1Vle= 1<<29, /* VLAN enable */
Mr1Eifc= 1<<28, /* enable integrated flow control */
Mr1App= 1<<27, /* allow pause packets */
Mr1Ist= 1<<24, /* ignore sqe test (all but half-duplex 10m/bit) */
Mr1Mf10= 0<<22, /* medium [MII] frequency is 10 mbps */
Mr1Mf100= 1<<22, /* medium frequency is 100 mbps */
Mr1Rfs512= 0<<20, /* RX FIFO size (512 bytes) */
Mr1Rfs1024= 1<<20,
Mr1Rfs2048= 2<<20,
Mr1Rfs4096= 3<<20,
Mr1Tfs1024= 1<<18, /* TX FIFO size (1024 bytes) */
Mr1Tfs2048= 2<<18,
Mr1Tr0sp= 0<<15, /* transmit request 0: single packet */
Mr1Tr0mp= 1<<15, /* multiple packets */
Mr1Tr0dm= 2<<15, /* dependent mode */
Mr1Tr1sp= 0<<13, /* transmit request 1: single packet */
Mr1Tr1mp= 1<<13, /* multiple packets */
Mr1Tr1dm= 2<<13, /* dependent mode */
/* transmit mode register 0 */
Tmr0Gnp0= 1<<31, /* get new packet channel 0 */
Tmr0Gnp1= 1<<30, /* get new packet channel 1 */
Tmr0Gnpd= 1<<29, /* get new packet dependent mode */
Tmr0Fc= 1<<28, /* first channel (dependent mode) */
/* transmit mode register 1 */
Tmr1Trl_s= 27, /* transmit low request (shift) */
Tmr1Tur_s= 16, /* transmit urgent request (shift) */
/* receive mode register */
RmrSp= 1<<31, /* strip pad/FCS bytes */
RmrSfcs= 1<<30, /* strip FCS */
RmrRrp= 1<<29, /* receive runt packets */
RmrRfp= 1<<28, /* receive packets with FCS error */
RmrRop= 1<<27, /* receive oversize packets */
RmrRpir= 1<<26, /* receive packets with in range error */
RmrPpp= 1<<25, /* propagate pause packet */
RmrPme= 1<<24, /* promiscuous mode enable */
RmrPmme= 1<<23, /* promiscuous mode multicast enable */
RmrIae= 1<<22, /* individual address enable */
RmrMiae= 1<<21, /* multiple individual address enable */
RmrBae= 1<<20, /* broadcast address enable */
RmrMae= 1<<19, /* multicast address enable */
/* interrupt status register */
IsrOvr= 1<<25, /* overrun error */
IsrPp= 1<<24, /* pause packet */
IsrBp= 1<<23, /* bad packet */
IsrRp= 1<<22, /* runt packet */
IsrSe= 1<<21, /* short event */
IsrAle= 1<<20, /* alignment error */
IsrBfcs= 1<<19, /* bad FCS */
IsrPtle= 1<<18, /* packet too long error */
IsrOre= 1<<17, /* out of range error */
IsrIre= 1<<16, /* in range error */
IsrDbdm= 1<<9, /* dead bit dependent mode */
IsrDb0= 1<<8, /* dead bit 0 */
IsrSe0= 1<<7, /* sqe 0 */
IsrTe0= 1<<6, /* tx error 0 */
IsrDb1= 1<<5, /* dead bit 1 */
IsrSe1= 1<<4, /* sqe 1 */
IsrTe1= 1<<3, /* tx error 1 */
IsrMos= 1<<1, /* MMA operation succeeded */
IsrMof= 1<<0, /* MMA operation failed */
/* STA control register */
StaOc= 1<<15, /* operation complete */
StaPhye= 1<<14, /* PHY error */
StaRead= 1<<12, /* STA read */
StaWrite= 2<<12, /* STA write */
StaOpb50= 0<<10, /* OPB frequency */
StaOpb66= 1<<10,
StaOpb83= 2<<10,
StaOpb100= 3<<10,
/* transmit request threshold */
TrtrTrt_s= 27, /* threshold (shift) -- and the value is (threshold/64)-1 */
/* receive low/high water mark register */
RwmrRlwm_s= 23, /* low water mark (shift) */
RwmrRhwm_s= 7, /* high water mark (shift) */
};
typedef struct {
Lock;
int port;
int init;
int active;
Emac *regs;
Emac *miiregs;
Mal* rx;
Mal* tx;
Mii *mii;
Ring;
ulong interrupts; /* statistics */
ulong deferred;
ulong heartbeat;
ulong latecoll;
ulong retrylim;
ulong underrun;
ulong overrun;
ulong carrierlost;
ulong retrycount;
} Ctlr;
static void dumpemac(Emac*);
static void
attach(Ether *ether)
{
Ctlr *ctlr;
ctlr = ether->ctlr;
ilock(ctlr);
if(!ctlr->active){
malrxenable(ctlr->rx);
maltxenable(ctlr->tx);
eieio();
ctlr->regs->mr0 = Mr0Txe | Mr0Rxe;
eieio();
ctlr->active = 1;
}
iunlock(ctlr);
}
static void
closed(Ether *ether)
{
Ctlr *ctlr;
ctlr = ether->ctlr;
if(ctlr->active){
ilock(ctlr);
iprint("ether closed\n");
ctlr->regs->mr0 &= ~(Mr0Txe | Mr0Rxe); /* reset enable bits */
/* TO DO: reset ring */
/* TO DO: could wait */
ctlr->active = 0;
iunlock(ctlr);
}
}
static void
promiscuous(void* arg, int on)
{
Ether *ether;
Ctlr *ctlr;
ether = (Ether*)arg;
ctlr = ether->ctlr;
ilock(ctlr);
if(on || ether->nmaddr)
ctlr->regs->rmr |= RmrPme | RmrPmme;
else
ctlr->regs->rmr &= ~(RmrPme | RmrPmme);
iunlock(ctlr);
}
static void
multicast(void* arg, uchar *addr, int on)
{
Ether *ether;
Ctlr *ctlr;
USED(addr, on); /* if on, could SetGroupAddress; if !on, it's hard */
ether = (Ether*)arg;
ctlr = ether->ctlr;
ilock(ctlr);
if(ether->prom || ether->nmaddr)
ctlr->regs->rmr |= RmrPmme;
else
ctlr->regs->rmr &= ~RmrPmme;
iunlock(ctlr);
}
static void
txstart(Ether *ether)
{
int len;
Ctlr *ctlr;
Block *b;
BD *dre;
ctlr = ether->ctlr;
while(ctlr->ntq < ctlr->ntdre-1){
b = qget(ether->oq);
if(b == 0)
break;
dre = &ctlr->tdr[ctlr->tdrh];
if(dre->status & BDReady)
panic("ether: txstart");
/*
* Give ownership of the descriptor to the chip, increment the
* software ring descriptor pointer and tell the chip to poll.
*/
len = BLEN(b);
if(ctlr->txb[ctlr->tdrh] != nil)
panic("etheremac: txstart");
ctlr->txb[ctlr->tdrh] = b;
dre->addr = PADDR(b->rp);
dre->length = len;
dcflush(b->rp, len);
eieio();
dre->status = (dre->status & BDWrap) | BDReady|BDInt|BDLast|TxFCS|TxPad;
eieio();
ctlr->regs->tmr0 = Tmr0Gnp0; /* TO DO: several channels */
eieio();
ctlr->ntq++;
ctlr->tdrh = NEXT(ctlr->tdrh, ctlr->ntdre);
}
}
static void
transmit(Ether* ether)
{
Ctlr *ctlr;
ctlr = ether->ctlr;
ilock(ctlr);
txstart(ether);
iunlock(ctlr);
}
/*
* allocate receive buffer space on cache-line boundaries
*/
static Block*
clallocb(void)
{
Block *b;
b = iallocb(Bufsize+CACHELINESZ-1);
if(b == nil)
return b;
dcflush(b->base, BALLOC(b));
b->wp = b->rp = (uchar*)(((ulong)b->base + CACHELINESZ - 1) & ~(CACHELINESZ-1));
return b;
}
static void
rxring(Ureg*, void *arg)
{
Ether *ether;
ulong status;
Ctlr *ctlr;
BD *dre;
Block *b, *rb;
ether = arg;
ctlr = ether->ctlr;
ctlr->interrupts++;
/*
* Receiver interrupt: run round the descriptor ring logging
* errors and passing valid receive data up to the higher levels
* until we encounter a descriptor still owned by the chip.
* We rely on the descriptor accesses being uncached.
*/
dre = &ctlr->rdr[ctlr->rdrx];
while(((status = dre->status) & BDEmpty) == 0){
if(status & RxError || (status & (BDFirst|BDLast)) != (BDFirst|BDLast)){
if(status & (RxShort|RxLong))
ether->buffs++;
if(status & (RxBad|RxAlign|RxRange|RxInRange))
ether->frames++;
if(status & RxFCS)
ether->crcs++;
if(status & RxOverrun)
ether->overflows++;
iprint("eth rx: %lux\n", status);
}else if((status & RxPause) == 0){
/*
* We have a packet. Read it in.
*/
b = clallocb();
if(b != nil){
rb = ctlr->rxb[ctlr->rdrx];
rb->wp += dre->length;
ctlr->rxb[ctlr->rdrx] = b;
ctlr->rdr[ctlr->rdrx].addr = PADDR(b->wp);
etheriq(ether, rb, 1);
}else
ether->soverflows++;
}
/*
* Finished with this descriptor, reinitialise it,
* give it back to the chip, then on to the next...
*/
dre->status = (status & BDWrap) | BDEmpty | BDInt;
eieio();
ctlr->rdrx = NEXT(ctlr->rdrx, ctlr->nrdre);
dre = &ctlr->rdr[ctlr->rdrx];
}
}
static void
txring(Ureg*, void *arg)
{
Ether *ether;
ulong status;
Ctlr *ctlr;
BD *dre;
Block *b;
ether = arg;
ctlr = ether->ctlr;
ctlr->interrupts++;
/*
* Transmitter interrupt: handle anything queued for a free descriptor.
*/
lock(ctlr);
while(ctlr->ntq){
dre = &ctlr->tdr[ctlr->tdri];
status = dre->status;
if(status & BDReady)
break;
if(status & TxEDef)
ctlr->deferred++;
if(status & TxLateCol)
ctlr->latecoll++;
if(status & TxECol)
ctlr->retrylim++;
if(status & TxUnderrun)
ctlr->underrun++;
if(status & (TxManyCol|TxCollision))
ctlr->retrycount++;
b = ctlr->txb[ctlr->tdri];
if(b == nil)
panic("etheremac: bufp");
ctlr->txb[ctlr->tdri] = nil;
freeb(b);
ctlr->ntq--;
ctlr->tdri = NEXT(ctlr->tdri, ctlr->ntdre);
}
txstart(ether);
unlock(ctlr);
}
static void
interrupt(Ureg*, void *arg)
{
Ether *ether;
ulong events;
Ctlr *ctlr;
ether = arg;
ctlr = ether->ctlr;
events = ctlr->regs->isr;
eieio();
ctlr->regs->isr = events;
eieio();
ctlr->interrupts++;
//iprint("eth: %8.8lux\n", events);
if(!ctlr->active || events == 0)
return;
if(events & IsrOvr)
ctlr->overrun++;
if(events & (IsrTe0|IsrTe1))
ether->oerrs++;
rxring(nil, arg);
txring(nil, arg);
ctlr->interrupts -= 2;
/* TO DO: restart tx/rx on error */
}
static long
ifstat(Ether* ether, void* a, long n, ulong offset)
{
char *p;
int len;
Ctlr *ctlr;
if(n == 0)
return 0;
ctlr = ether->ctlr;
p = malloc(READSTR);
len = snprint(p, READSTR, "interrupts: %lud\n", ctlr->interrupts);
len += snprint(p+len, READSTR-len, "carrierlost: %lud\n", ctlr->carrierlost);
len += snprint(p+len, READSTR-len, "heartbeat: %lud\n", ctlr->heartbeat);
len += snprint(p+len, READSTR-len, "retrylimit: %lud\n", ctlr->retrylim);
len += snprint(p+len, READSTR-len, "retrycount: %lud\n", ctlr->retrycount);
len += snprint(p+len, READSTR-len, "latecollisions: %lud\n", ctlr->latecoll);
len += snprint(p+len, READSTR-len, "rxoverruns: %lud\n", ctlr->overrun);
len += snprint(p+len, READSTR-len, "txunderruns: %lud\n", ctlr->underrun);
snprint(p+len, READSTR-len, "framesdeferred: %lud\n", ctlr->deferred);
n = readstr(offset, a, n, p);
free(p);
return n;
}
static QLock miilock; /* the PHY are both on EMAC0's MII bus */
static int
miird(Mii *mii, int pa, int ra)
{
Ctlr *ctlr;
Emac *em;
ulong r;
int i;
if(up)
qlock(&miilock);
ctlr = mii->ctlr;
em = ctlr->miiregs;
MIIDBG("r: %x.%x:", pa, ra);
if((em->stacr & StaOc) == 0)
iprint("mii-not oc\n");
em->stacr = StaRead | StaOpb66 | (pa<<5) | ra;
for(i=0; i<100 && (em->stacr & StaOc) == 0; i++)
microdelay(1);
r = em->stacr;
if(up)
qunlock(&miilock);
if((r & StaOc) == 0)
iprint("mii'-not oc\n");
if(r & StaPhye)
return -1;
MIIDBG(" %8.8lux\n", r);
return r >> 16;
}
static int
miiwr(Mii *mii, int pa, int ra, int v)
{
Ctlr *ctlr;
Emac *em;
ulong r;
int i;
if(up)
qlock(&miilock);
ctlr = mii->ctlr;
em = ctlr->miiregs;
if((em->stacr & StaOc) == 0)
iprint("miiw-not oc\n");
em->stacr = (v<<16) | StaWrite | StaOpb66 | (pa<<5) | ra;
for(i=0; i<100 && (em->stacr & StaOc) == 0; i++)
microdelay(1);
r = em->stacr;
if(up)
qunlock(&miilock);
if((r & StaOc) == 0)
iprint("miiw'-not oc\n");
if(r & StaPhye)
return -1;
MIIDBG("w: %x.%x: %8.8lux\n", pa, ra, r);
return 0;
}
static int
emacmii(Ctlr *ctlr)
{
MiiPhy *phy;
int i;
MIIDBG("mii\n");
if((ctlr->mii = malloc(sizeof(Mii))) == nil)
return -1;
ctlr->mii->ctlr = ctlr;
ctlr->mii->mir = miird;
ctlr->mii->miw = miiwr;
if(mii(ctlr->mii, 1<<(ctlr->port+1)) == 0 || (phy = ctlr->mii->curphy) == nil){
free(ctlr->mii);
ctlr->mii = nil;
return -1;
}
iprint("oui %X phyno %d\n", phy->oui, phy->phyno);
if(miistatus(ctlr->mii) < 0){
miireset(ctlr->mii);
MIIDBG("miireset\n");
if(miiane(ctlr->mii, ~0, 0, ~0) < 0){
iprint("miiane failed\n");
return -1;
}
MIIDBG("miistatus...\n");
miistatus(ctlr->mii);
if(miird(ctlr->mii, phy->phyno, Bmsr) & BmsrLs){
for(i=0;; i++){
if(i > 600){
iprint("emac%d: autonegotiation failed\n", ctlr->port);
break;
}
if(miird(ctlr->mii, phy->phyno, Bmsr) & BmsrAnc)
break;
delay(10);
}
if(miistatus(ctlr->mii) < 0)
iprint("miistatus failed\n");
}else{
iprint("emac%d: no link\n", ctlr->port);
phy->speed = 10; /* simple default */
}
}
iprint("emac%d mii: fd=%d speed=%d tfc=%d rfc=%d\n", ctlr->port, phy->fd, phy->speed, phy->tfc, phy->rfc);
MIIDBG("mii done\n");
return 0;
}
static void
emacsetup(Ctlr *ctlr, Ether *ether)
{
int i;
Emac *em;
ulong mode;
MiiPhy *phy;
/* apparently don't need to set any Alt1 in GPIO */
em = ctlr->regs;
/* errata emac_8 */
if(em->mr0 & Mr0Rxe){ /* probably never happens in our config */
em->mr0 &= ~Mr0Rxe;
eieio();
for(i=0; (em->mr0 & Mr0Rxi) == 0; i++){
if(i > 100){
iprint("ethermac: Rxe->Rxi timed out\n");
break; /* we'll try soft reset anyway */
}
microdelay(100);
}
}
/* soft reset */
em->mr0 = Mr0Srst;
eieio();
for(i=0; em->mr0 & Mr0Srst; i++){
if(i > 20){
iprint("ethermac: reset (PHY clocks not running?)");
i=0;
}
microdelay(100);
}
iprint("%d: rx=%8.8lux tx=%8.8lux\n", ctlr->port, PADDR(ctlr->rdr), PADDR(ctlr->tdr));
//if(ctlr->port)return;
malrxinit(ctlr->rx, ctlr, Bufsize/16);
maltxinit(ctlr->tx, ctlr);
malrxreset(ctlr->rx);
maltxreset(ctlr->tx);
em->mr0 = 0;
mode = Mr1Rfs4096 | Mr1Tfs2048 | Mr1Tr0mp;
if(ctlr->mii != nil && (phy = ctlr->mii->curphy) != nil){
if(phy->speed == 10){
mode |= Mr1Mf10;
if(phy->fd)
mode |= Mr1Ist;
}else
mode |= Mr1Mf100 | Mr1Ist;
if(phy->fd)
mode |= Mr1Fde;
/* errata emac_9 suggests not using integrated flow control (it's broken); so don't negotiate it */
if(0 && (phy->rfc || phy->tfc))
mode |= Mr1App | Mr1Eifc;
ether->mbps = phy->speed;
ether->fullduplex = phy->fd;
}else{
iprint("mii: didn't work: default 100FD\n");
mode |= Mr1Mf100 | Mr1Ist | Mr1Fde;
ether->mbps = 100;
ether->fullduplex = 1;
}
em->mr1 = mode;
em->tmr1 = (9<<Tmr1Trl_s) | (256<<Tmr1Tur_s); /* TO DO: validate these sizes */
em->rmr = RmrSp | RmrSfcs | RmrIae | RmrBae;
em->iahr = (ether->ea[0]<<8) | ether->ea[1];
em->ialr = (ether->ea[2]<<24) | (ether->ea[3]<<16) | (ether->ea[4]<<8) | ether->ea[5];
em->vtpid = 0;
em->vtci = 0;
em->ptr = 1; /* pause timer [Reset, T] */
for(i=0; i<4; i++){
em->iaht[i] = 0; /* individual address hash table */
em->gaht[i] = 0; /* group address hash table */
}
em->ipgvr = (96/8)/3; /* minimise bit times between packets */
em->trtr = ((256/64)-1)<<TrtrTrt_s; /* transmission threshold (probably could be smaller) */
em->rwmr = (32<<RwmrRlwm_s) | (128<<RwmrRhwm_s); /* receive low/high water mark (TO DO: check) */
/* 0x0f002000? */
//dumpemac(em);
//dumpmal();
eieio();
em->isr = em->isr; /* clear all events */
eieio();
em->iser = IsrOvr | IsrBp | IsrSe | IsrSe0 | IsrTe0 | IsrSe1 | IsrTe1; /* enable various error interrupts */
/* packet tx/rx interrupts come from MAL */
eieio();
/* tx/rx enable is deferred until attach */
}
static int
reset(Ether* ether)
{
uchar ea[Eaddrlen];
Ctlr *ctlr;
int i;
ioringreserve(Nrxchan, Nrdre, Ntxchan, Ntdre);
/*
* Insist that the platform-specific code provide the Ethernet address
*/
memset(ea, 0, Eaddrlen);
if(memcmp(ea, ether->ea, Eaddrlen) == 0){
print("no ether address");
return -1;
}
ctlr = malloc(sizeof(*ctlr));
ctlr->port = ether->port;
switch(ether->port){
case 0:
ctlr->regs = KADDR(PHYSEMAC0);
ctlr->miiregs = ctlr->regs;
ctlr->rx = malchannel(0, 0, rxring, ether);
ctlr->tx = malchannel(0, 1, txring, ether);
ether->irq = VectorEMAC0;
break;
case 1:
ctlr->regs = KADDR(PHYSEMAC1);
ctlr->miiregs = KADDR(PHYSEMAC0); /* p. 19-41: ``only the MDIO interface for EMAC0 is pinned out'' */
ctlr->rx = malchannel(1, 0, rxring, ether);
ctlr->tx = malchannel(2, 1, txring, ether);
ether->irq = VectorEMAC1;
break;
default:
print("%s ether: no port %lud\n", ether->type, ether->port);
free(ctlr);
return -1;
}
if(emacmii(ctlr) < 0){
free(ctlr);
return -1;
}
ether->ctlr = ctlr;
if(ioringinit(ctlr, Nrdre, Ntdre) < 0) /* TO DO: there are two transmit rings*/
panic("etheremac initring");
for(i = 0; i < ctlr->nrdre; i++){
ctlr->rxb[i] = clallocb();
ctlr->rdr[i].addr = PADDR(ctlr->rxb[i]->wp);
}
emacsetup(ctlr, ether);
ether->attach = attach;
ether->closed = closed;
ether->transmit = transmit;
ether->interrupt = interrupt; /* oddly, it's only error interrupts; see malchannel call above for tx/rx */
ether->ifstat = ifstat;
ether->arg = ether;
ether->promiscuous = promiscuous;
ether->multicast = multicast;
return 0;
}
void
etheremaclink(void)
{
addethercard("EMAC", reset);
}
static void
dumpemac(Emac *r)
{
iprint("mr0=%8.8lux\n", r->mr0); /* mode register 0 [see 19-48] */
iprint("mr1=%8.8lux\n", r->mr1); /* mode register 1 [Reset] */
iprint("tmr0=%8.8lux\n", r->tmr0); /* transmit mode register 0 [see 19-28] */
iprint("tmr1=%8.8lux\n", r->tmr1); /* transmit mode register 1 [see 19-28] */
iprint("rmr=%8.8lux\n", r->rmr); /* receive mode register [Reset] */
iprint("isr=%8.8lux\n", r->isr); /* interrupt status register [Always] */
iprint("iser=%8.8lux\n", r->iser); /* interrupt status enable register [Reset] */
iprint("iahr=%8.8lux\n", r->iahr); /* individual address high [Reset, R, T]*/
iprint("ialr=%8.8lux\n", r->ialr); /* individual address low [Reset, R, T] */
iprint("vtpid=%8.8lux\n", r->vtpid); /* VLAN Tag Protocol Identifier [Reset, R, T] */
iprint("vtci=%8.8lux\n", r->vtci); /* VLAN Tag Control Information [Reset, R, T] */
iprint("ptr=%8.8lux\n", r->ptr); /* pause timer [Reset, T] */
iprint("lsah=%8.8lux\n", r->lsah); /* last source address high */
iprint("lsal=%8.8lux\n", r->lsal); /* last source address low */
iprint("ipgvr=%8.8lux\n", r->ipgvr); /* inter-packet gap value [Reset, T] */
iprint("stacr=%8.8lux\n", r->stacr); /* STA control register [see 19-41] */
iprint("trtr=%8.8lux\n", r->trtr); /* transmit request threshold register [see 19-42] */
iprint("rwmr=%8.8lux\n", r->rwmr); /* receive low/high water mark [Reset] */
iprint("octx=%8.8lux\n", r->octx); /* bytes transmitted */
iprint("ocrx=%8.8lux\n", r->ocrx); /* bytes received */
}