123292Smckusick /* 229363Smckusick * Copyright (c) 1982, 1986 Regents of the University of California. 335320Sbostic * All rights reserved. 423292Smckusick * 535320Sbostic * This code is derived from software contributed to Berkeley by 635320Sbostic * Excelan Inc. 735320Sbostic * 835320Sbostic * Redistribution and use in source and binary forms are permitted 935320Sbostic * provided that the above copyright notice and this paragraph are 1035320Sbostic * duplicated in all such forms and that any documentation, 1135320Sbostic * advertising materials, and other materials related to such 1235320Sbostic * distribution and use acknowledge that the software was developed 1335320Sbostic * by the University of California, Berkeley. The name of the 1435320Sbostic * University may not be used to endorse or promote products derived 1535320Sbostic * from this software without specific prior written permission. 1635320Sbostic * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 1735320Sbostic * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 1835320Sbostic * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. 1935320Sbostic * 20*40681Skarels * @(#)if_ex.c 7.6 (Berkeley) 04/03/90 2123292Smckusick */ 2219880Skarels 2319880Skarels #include "ex.h" 2425273Sbloom #if NEX > 0 2519880Skarels 2619880Skarels /* 2719880Skarels * Excelan EXOS 204 Interface 2819880Skarels * 2919880Skarels * George Powers 3019880Skarels * Excelan Inc. 3119880Skarels */ 3219880Skarels 3321777Skarels #include "param.h" 3421777Skarels #include "systm.h" 3521777Skarels #include "mbuf.h" 3621777Skarels #include "buf.h" 3721777Skarels #include "protosw.h" 3821777Skarels #include "socket.h" 3921777Skarels #include "vmmac.h" 4021777Skarels #include "ioctl.h" 4129849Skarels #include "syslog.h" 4221777Skarels #include "errno.h" 4319880Skarels 4419880Skarels #include "../net/if.h" 4519880Skarels #include "../net/netisr.h" 4619880Skarels #include "../net/route.h" 4724539Skarels 4824539Skarels #ifdef INET 4919880Skarels #include "../netinet/in.h" 5019880Skarels #include "../netinet/in_systm.h" 5121777Skarels #include "../netinet/in_var.h" 5219880Skarels #include "../netinet/ip.h" 5319880Skarels #include "../netinet/if_ether.h" 5424539Skarels #endif 5524539Skarels 5624556Ssklower #ifdef NS 5724556Ssklower #include "../netns/ns.h" 5824556Ssklower #include "../netns/ns_if.h" 5924556Ssklower #endif 6024556Ssklower 6137476Ssklower #ifdef ISO 6237476Ssklower #include "../netiso/iso.h" 6337476Ssklower #include "../netiso/iso_var.h" 6437476Ssklower #include "../netiso/iso_snpac.h" 6537476Ssklower extern struct snpa_cache all_es, all_is; 6637476Ssklower #endif 6737476Ssklower 6834531Skarels #include "../vax/pte.h" 6919880Skarels #include "../vax/cpu.h" 7019880Skarels #include "../vax/mtpr.h" 7121777Skarels #include "if_exreg.h" 7221777Skarels #include "if_uba.h" 7319880Skarels #include "../vaxuba/ubareg.h" 7419880Skarels #include "../vaxuba/ubavar.h" 7519880Skarels 7634531Skarels /* #define DEBUG /* check for "impossible" events */ 7719880Skarels 7819880Skarels #define NH2X 4 /* a sufficient number is critical */ 7919880Skarels #define NX2H 4 /* this is pretty arbitrary */ 8019880Skarels #define EXWATCHINTVL 10 /* call exwatch() every 10 seconds */ 8119880Skarels 8219880Skarels int exprobe(), exattach(), excdint(); 8319880Skarels struct uba_device *exinfo[NEX]; 8419880Skarels u_short exstd[] = { 0 }; 8519880Skarels struct uba_driver exdriver = 8619880Skarels { exprobe, 0, exattach, 0, exstd, "ex", exinfo }; 87*40681Skarels int exinit(),exstart(),ether_output(),exioctl(),exreset(),exwatch(); 8819880Skarels struct ex_msg *exgetcbuf(); 8919880Skarels 9019880Skarels /* 9119880Skarels * Ethernet software status per interface. 9219880Skarels * 9319880Skarels * Each interface is referenced by a network interface structure, 9419880Skarels * xs_if, which the routing code uses to locate the interface. 9519880Skarels * This structure contains the output queue for the interface, its address, ... 9619880Skarels * We also have, for each interface, a UBA interface structure, which 9719880Skarels * contains information about the UNIBUS resources held by the interface: 9819880Skarels * map registers, buffered data paths, etc. Information is cached in this 9919880Skarels * structure for use by the if_uba.c routines in running the interface 10019880Skarels * efficiently. 10119880Skarels */ 10219880Skarels struct ex_softc { 10321777Skarels struct arpcom xs_ac; /* Ethernet common part */ 10421777Skarels #define xs_if xs_ac.ac_if /* network-visible interface */ 10521777Skarels #define xs_addr xs_ac.ac_enaddr /* hardware Ethernet address */ 10619880Skarels #ifdef DEBUG 10719880Skarels int xs_wait; 10819880Skarels #endif 10919880Skarels struct ifuba xs_ifuba; /* UNIBUS resources */ 11019880Skarels int xs_flags; /* private flags */ 11119880Skarels #define EX_XPENDING 1 /* xmit rqst pending on EXOS */ 11219880Skarels #define EX_STATPENDING (1<<1) /* stats rqst pending on EXOS */ 11325447Skarels #define EX_RUNNING (1<<2) /* board is running */ 11425621Ssklower #define EX_SETADDR (1<<3) /* physaddr has been changed */ 11519880Skarels struct ex_msg *xs_h2xnext; /* host pointer to request queue */ 11619880Skarels struct ex_msg *xs_x2hnext; /* host pointer to reply queue */ 11726391Skarels int xs_ubaddr; /* map info for structs below */ 11819880Skarels #define UNIADDR(x) ((u_long)(x)&0x3FFFF) 11919880Skarels #define P_UNIADDR(x) ((u_long)(x)&0x3FFF0) 12019880Skarels /* the following structures are always mapped in */ 12119880Skarels u_short xs_h2xhdr; /* EXOS's request queue header */ 12219880Skarels u_short xs_x2hhdr; /* EXOS's reply queue header */ 12319880Skarels struct ex_msg xs_h2xent[NH2X]; /* request msg buffers */ 12419880Skarels struct ex_msg xs_x2hent[NX2H]; /* reply msg buffers */ 12519880Skarels struct confmsg xs_cm; /* configuration message */ 12619880Skarels struct stat_array xs_xsa; /* EXOS writes stats here */ 12719880Skarels /* end mapped area */ 12826391Skarels #define INCORE_BASE(p) ((caddr_t)((u_long)(&(p)->xs_h2xhdr) & 0xFFFFFFF0)) 12925728Smckusick #define RVAL_OFF(unit, n) \ 13026391Skarels ((caddr_t)(&(ex_softc[unit].n)) - INCORE_BASE(&ex_softc[unit])) 13125728Smckusick #define LVAL_OFF(unit, n) \ 13226391Skarels ((caddr_t)(ex_softc[unit].n) - INCORE_BASE(&ex_softc[unit])) 13325728Smckusick #define H2XHDR_OFFSET(unit) RVAL_OFF(unit, xs_h2xhdr) 13425728Smckusick #define X2HHDR_OFFSET(unit) RVAL_OFF(unit, xs_x2hhdr) 13525728Smckusick #define H2XENT_OFFSET(unit) LVAL_OFF(unit, xs_h2xent) 13625728Smckusick #define X2HENT_OFFSET(unit) LVAL_OFF(unit, xs_x2hent) 13725728Smckusick #define CM_OFFSET(unit) RVAL_OFF(unit, xs_cm) 13825728Smckusick #define SA_OFFSET(unit) RVAL_OFF(unit, xs_xsa) 13925728Smckusick #define INCORE_SIZE(unit) RVAL_OFF(unit, xs_end) 14019880Skarels int xs_end; /* place holder */ 14119880Skarels } ex_softc[NEX]; 14219880Skarels 14319880Skarels /* 14419880Skarels * The following structure is a kludge to store a cvec value 14519880Skarels * between the time exprobe is called, and exconfig. 14619880Skarels */ 14719880Skarels struct ex_cvecs { 14819880Skarels struct exdevice *xc_csraddr; 14919880Skarels int xc_cvec; 15019880Skarels }ex_cvecs[NEX]; 15119880Skarels 15219880Skarels int ex_ncall = 0; /* counts calls to exprobe */ 15319880Skarels 15419880Skarels exprobe(reg) 15519880Skarels caddr_t reg; 15619880Skarels { 15719880Skarels register int br, cvec; /* r11, r10 value-result */ 15819880Skarels register struct exdevice *addr = (struct exdevice *)reg; 15919880Skarels register i; 16019880Skarels 16119880Skarels /* 16219880Skarels * We program the EXOS interrupt vector, like dmf device. 16319880Skarels */ 16419880Skarels br = 0x15; 16519880Skarels cvec = (uba_hd[numuba].uh_lastiv -= 4); 16619880Skarels ex_cvecs[ex_ncall].xc_csraddr = addr; 16726013Skarels ex_cvecs[ex_ncall].xc_cvec = cvec; 16819880Skarels /* 16919880Skarels * Reset EXOS and run self-test (guaranteed to 17019880Skarels * complete within 2 seconds). 17119880Skarels */ 17219880Skarels addr->xd_porta = EX_RESET; 17326013Skarels i = 2000; 17419880Skarels while (((addr->xd_portb & EX_TESTOK) == 0) && --i) 17526013Skarels DELAY(1000); 17619880Skarels if ((addr->xd_portb & EX_TESTOK) == 0) { 17719880Skarels printf("ex: self-test failed\n"); 17819880Skarels return 0; 17919880Skarels } 18024539Skarels #ifdef lint 18124539Skarels br = br; 18226391Skarels excdint(0); 18324539Skarels #endif 18426013Skarels ex_ncall++; 18519880Skarels return (sizeof(struct exdevice)); 18619880Skarels } 18719880Skarels 18819880Skarels /* 18919880Skarels * Interface exists: make available by filling in network interface 19019880Skarels * record. System will initialize the interface when it is ready 19119880Skarels * to accept packets. Board is temporarily configured and issues 19219880Skarels * a NET_ADDRS command, only to get the Ethernet address. 19319880Skarels */ 19419880Skarels exattach(ui) 19537476Ssklower register struct uba_device *ui; 19619880Skarels { 19719880Skarels register struct ex_softc *xs = &ex_softc[ui->ui_unit]; 19819880Skarels register struct ifnet *ifp = &xs->xs_if; 19919880Skarels register struct exdevice *addr = (struct exdevice *)ui->ui_addr; 20019880Skarels register struct ex_msg *bp; 20125728Smckusick int unit = ui->ui_unit; 20219880Skarels ifp->if_unit = ui->ui_unit; 20319880Skarels ifp->if_name = "ex"; 20419880Skarels ifp->if_mtu = ETHERMTU; 20519880Skarels 20619880Skarels /* 20719880Skarels * Temporarily map queues in order to configure EXOS 20819880Skarels */ 20925728Smckusick xs->xs_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(xs), 21025728Smckusick INCORE_SIZE(unit), 0); 21119880Skarels exconfig(ui, 0); /* without interrupts */ 21219880Skarels if (xs->xs_cm.cm_cc) goto badconf; 21319880Skarels 21419880Skarels bp = exgetcbuf(xs); 21519880Skarels bp->mb_rqst = LLNET_ADDRS; 21619880Skarels bp->mb_na.na_mask = READ_OBJ; 21719880Skarels bp->mb_na.na_slot = PHYSSLOT; 21819880Skarels bp->mb_status |= MH_EXOS; 21919880Skarels addr->xd_portb = EX_NTRUPT; 22019880Skarels bp = xs->xs_x2hnext; 22119880Skarels while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */ 22219880Skarels ; 22325975Skarels printf("ex%d: HW %c.%c, NX %c.%c, hardware address %s\n", 22426013Skarels ui->ui_unit, xs->xs_cm.cm_vc[2], xs->xs_cm.cm_vc[3], 22526013Skarels xs->xs_cm.cm_vc[0], xs->xs_cm.cm_vc[1], 22626013Skarels ether_sprintf(bp->mb_na.na_addrs)); 22719880Skarels bcopy((caddr_t)bp->mb_na.na_addrs, (caddr_t)xs->xs_addr, 22819880Skarels sizeof (xs->xs_addr)); 22919880Skarels 23019880Skarels ifp->if_init = exinit; 23137476Ssklower ifp->if_output = ether_output; 232*40681Skarels ifp->if_start = exstart; 23319880Skarels ifp->if_ioctl = exioctl; 23419880Skarels ifp->if_reset = exreset; 23521777Skarels ifp->if_flags = IFF_BROADCAST; 23619880Skarels xs->xs_ifuba.ifu_flags = UBA_CANTWAIT; 23719880Skarels if_attach(ifp); 23819880Skarels badconf: 23919880Skarels ubarelse(ui->ui_ubanum, &xs->xs_ubaddr); 24019880Skarels } 24119880Skarels 24219880Skarels /* 24319880Skarels * Reset of interface after UNIBUS reset. 24419880Skarels * If interface is on specified uba, reset its state. 24519880Skarels */ 24619880Skarels exreset(unit, uban) 24719880Skarels int unit, uban; 24819880Skarels { 24919880Skarels register struct uba_device *ui; 25019880Skarels 25119880Skarels if (unit >= NEX || (ui = exinfo[unit]) == 0 || ui->ui_alive == 0 || 25219880Skarels ui->ui_ubanum != uban) 25319880Skarels return; 25419880Skarels printf(" ex%d", unit); 25521777Skarels ex_softc[unit].xs_if.if_flags &= ~IFF_RUNNING; 25625447Skarels ex_softc[unit].xs_flags &= ~EX_RUNNING; 25719880Skarels exinit(unit); 25819880Skarels } 25919880Skarels 26019880Skarels /* 26119880Skarels * Initialization of interface; clear recorded pending 26219880Skarels * operations, and reinitialize UNIBUS usage. 26319880Skarels * Called at boot time (with interrupts disabled?), 26419880Skarels * and at ifconfig time via exioctl, with interrupts disabled. 26519880Skarels */ 26619880Skarels exinit(unit) 26719880Skarels int unit; 26819880Skarels { 26919880Skarels register struct ex_softc *xs = &ex_softc[unit]; 27019880Skarels register struct uba_device *ui = exinfo[unit]; 27119880Skarels register struct exdevice *addr = (struct exdevice *)ui->ui_addr; 27219880Skarels register struct ifnet *ifp = &xs->xs_if; 27319880Skarels register struct ex_msg *bp; 27419880Skarels int s; 27519880Skarels 27621777Skarels /* not yet, if address still unknown */ 27721777Skarels if (ifp->if_addrlist == (struct ifaddr *)0) 27819880Skarels return; 27925447Skarels if (xs->xs_flags & EX_RUNNING) 28025447Skarels return; 28119880Skarels 28225447Skarels if ((ifp->if_flags & IFF_RUNNING) == 0) { 28325447Skarels if (if_ubainit(&xs->xs_ifuba, ui->ui_ubanum, 28425447Skarels sizeof (struct ether_header), 28525447Skarels (int)btoc(EXMAXRBUF-sizeof(struct ether_header))) == 0) { 28625447Skarels printf("ex%d: can't initialize\n", unit); 28725447Skarels xs->xs_if.if_flags &= ~IFF_UP; 28825447Skarels return; 28925447Skarels } 29025447Skarels xs->xs_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(xs), 29125728Smckusick INCORE_SIZE(unit), 0); 29219880Skarels } 29319880Skarels exconfig(ui, 4); /* with vectored interrupts*/ 29419880Skarels /* 29519880Skarels * Put EXOS on the Ethernet, using NET_MODE command 29619880Skarels */ 29719880Skarels bp = exgetcbuf(xs); 29819880Skarels bp->mb_rqst = LLNET_MODE; 29919880Skarels bp->mb_nm.nm_mask = WRITE_OBJ; 30019880Skarels bp->mb_nm.nm_optn = 0; 30119880Skarels bp->mb_nm.nm_mode = MODE_PERF; 30219880Skarels bp->mb_status |= MH_EXOS; 30319880Skarels addr->xd_portb = EX_NTRUPT; 30419880Skarels bp = xs->xs_x2hnext; 30519880Skarels while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */ 30619880Skarels ; 30719880Skarels bp->mb_length = MBDATALEN; 30819880Skarels bp->mb_status |= MH_EXOS; /* free up buffer */ 30919880Skarels addr->xd_portb = EX_NTRUPT; /* tell EXOS about it */ 31019880Skarels xs->xs_x2hnext = xs->xs_x2hnext->mb_next; 31119880Skarels 31219880Skarels ifp->if_watchdog = exwatch; 31319880Skarels ifp->if_timer = EXWATCHINTVL; 31419880Skarels s = splimp(); /* are interrupts always disabled here, anyway? */ 31519880Skarels exhangrcv(unit); /* hang receive request */ 31621777Skarels xs->xs_if.if_flags |= IFF_RUNNING; 31725447Skarels xs->xs_flags |= EX_RUNNING; 31825621Ssklower if (xs->xs_flags & EX_SETADDR) 31926391Skarels ex_setaddr((u_char *)0, unit); 32037476Ssklower #ifdef ISO 32137476Ssklower ex_setmulti(all_es.sc_snpa, unit, 1); 32237476Ssklower ex_setmulti(all_is.sc_snpa, unit, 2); 32337476Ssklower #endif 32437476Ssklower (void) exstart(&xs->xs_if); /* start transmits */ 32519880Skarels splx(s); 32619880Skarels } 32719880Skarels 32819880Skarels /* 32919880Skarels * Reset, test, and configure EXOS. This routine assumes 33019880Skarels * that message queues, etc. have already been mapped into 33119880Skarels * the UBA. It is called by exinit, and should also be 33219880Skarels * callable by exattach. 33319880Skarels */ 33419880Skarels exconfig(ui, itype) 33519880Skarels struct uba_device *ui; 33619880Skarels int itype; 33719880Skarels { 33819880Skarels register int unit = ui->ui_unit; 33919880Skarels register struct ex_softc *xs = &ex_softc[unit]; 34019880Skarels register struct exdevice *addr = (struct exdevice *) ui->ui_addr; 34119880Skarels register struct confmsg *cm = &xs->xs_cm; 34219880Skarels register struct ex_msg *bp; 34319880Skarels int i; 34419880Skarels u_long shiftreg; 34519880Skarels 34619880Skarels xs->xs_flags = 0; 34719880Skarels /* 34819880Skarels * Reset EXOS, wait for self-test to complete 34919880Skarels */ 35019880Skarels addr->xd_porta = EX_RESET; 35119880Skarels while ((addr->xd_portb & EX_TESTOK) == 0) 35219880Skarels ; 35319880Skarels /* 35419880Skarels * Set up configuration message. 35519880Skarels */ 35619880Skarels cm->cm_1rsrv = 1; 35719880Skarels cm->cm_cc = 0xFF; 35819880Skarels cm->cm_opmode = 0; /* link-level controller mode */ 35919880Skarels cm->cm_dfo = 0x0101; /* enable host data order conversion */ 36019880Skarels cm->cm_dcn1 = 1; 36137476Ssklower cm->cm_2rsrv[0] = cm->cm_2rsrv[1] = 0; 36219880Skarels cm->cm_ham = 3; /* absolute address mode */ 36319880Skarels cm->cm_3rsrv = 0; 36419880Skarels cm->cm_mapsiz = 0; 36519880Skarels cm->cm_byteptrn[0] = 0x01; /* EXOS deduces data order of host */ 36619880Skarels cm->cm_byteptrn[1] = 0x03; /* by looking at this pattern */ 36719880Skarels cm->cm_byteptrn[2] = 0x07; 36819880Skarels cm->cm_byteptrn[3] = 0x0F; 36919880Skarels cm->cm_wordptrn[0] = 0x0103; 37019880Skarels cm->cm_wordptrn[1] = 0x070F; 37119880Skarels cm->cm_lwordptrn = 0x0103070F; 37219880Skarels for (i=0; i<20; i++) cm->cm_rsrvd[i] = 0; 37319880Skarels cm->cm_mba = 0xFFFFFFFF; 37419880Skarels cm->cm_nproc = 0xFF; 37519880Skarels cm->cm_nmbox = 0xFF; 37619880Skarels cm->cm_nmcast = 0xFF; 37719880Skarels cm->cm_nhost = 1; 37819880Skarels cm->cm_h2xba = P_UNIADDR(xs->xs_ubaddr); 37925728Smckusick cm->cm_h2xhdr = H2XHDR_OFFSET(unit); 38019880Skarels cm->cm_h2xtyp = 0; /* should never wait for rqst buffer */ 38119880Skarels cm->cm_x2hba = cm->cm_h2xba; 38225728Smckusick cm->cm_x2hhdr = X2HHDR_OFFSET(unit); 38319880Skarels cm->cm_x2htyp = itype; /* 0 for none, 4 for vectored */ 38419880Skarels for (i=0; (addr != ex_cvecs[i].xc_csraddr); i++) 38519880Skarels #ifdef DEBUG 38619880Skarels if (i >= NEX) 38719880Skarels panic("ex: matching csr address not found"); 38819880Skarels #endif 38919880Skarels ; 39019880Skarels cm->cm_x2haddr = ex_cvecs[i].xc_cvec; /* stashed here by exprobe */ 39119880Skarels /* 39219880Skarels * Set up message queues and headers. 39319880Skarels * First the request queue. 39419880Skarels */ 39519880Skarels for (bp = &xs->xs_h2xent[0]; bp < &xs->xs_h2xent[NH2X]; bp++) { 39619880Skarels bp->mb_link = (u_short)((char *)(bp+1)-INCORE_BASE(xs)); 39719880Skarels bp->mb_rsrv = 0; 39819880Skarels bp->mb_length = MBDATALEN; 39919880Skarels bp->mb_status = MH_HOST; 40019880Skarels bp->mb_next = bp+1; 40119880Skarels } 40219880Skarels xs->xs_h2xhdr = 40337476Ssklower xs->xs_h2xent[NH2X-1].mb_link = (u_short)H2XENT_OFFSET(unit); 40437476Ssklower xs->xs_h2xnext = xs->xs_h2xent[NH2X-1].mb_next = xs->xs_h2xent; 40519880Skarels 40619880Skarels /* Now the reply queue. */ 40719880Skarels for (bp = &xs->xs_x2hent[0]; bp < &xs->xs_x2hent[NX2H]; bp++) { 40819880Skarels bp->mb_link = (u_short)((char *)(bp+1)-INCORE_BASE(xs)); 40919880Skarels bp->mb_rsrv = 0; 41019880Skarels bp->mb_length = MBDATALEN; 41119880Skarels bp->mb_status = MH_EXOS; 41219880Skarels bp->mb_next = bp+1; 41319880Skarels } 41419880Skarels xs->xs_x2hhdr = 41537476Ssklower xs->xs_x2hent[NX2H-1].mb_link = (u_short)X2HENT_OFFSET(unit); 41637476Ssklower xs->xs_x2hnext = xs->xs_x2hent[NX2H-1].mb_next = xs->xs_x2hent; 41719880Skarels 41819880Skarels /* 41919880Skarels * Write config msg address to EXOS and wait for 42019880Skarels * configuration to complete (guaranteed response 42119880Skarels * within 2 seconds). 42219880Skarels */ 42319880Skarels shiftreg = (u_long)0x0000FFFF; 42419880Skarels for (i = 0; i < 8; i++) { 42519880Skarels if (i == 4) 42625728Smckusick shiftreg = P_UNIADDR(xs->xs_ubaddr) + CM_OFFSET(unit); 42719880Skarels while (addr->xd_portb & EX_UNREADY) 42819880Skarels ; 42919880Skarels addr->xd_portb = (u_char)(shiftreg & 0xFF); 43019880Skarels shiftreg >>= 8; 43119880Skarels } 43219880Skarels for (i = 1000000; (cm->cm_cc == 0xFF) && i; --i); 43319880Skarels if (cm->cm_cc) 43419880Skarels printf("ex%d: configuration failed; cc = %x\n", 43519880Skarels unit, cm->cm_cc); 43619880Skarels } 43719880Skarels 43819880Skarels /* 43919880Skarels * Start or re-start output on interface. 44019880Skarels * Get another datagram to send off of the interface queue, 44119880Skarels * and map it to the interface before starting the output. 44237476Ssklower * This routine is called by exinit(), ether_output(), and excdint(). 44319880Skarels * In all cases, interrupts by EXOS are disabled. 44419880Skarels */ 44537476Ssklower exstart(ifp) 44637476Ssklower struct ifnet *ifp; 44719880Skarels { 44837476Ssklower int unit = ifp->if_unit; 44919880Skarels struct uba_device *ui = exinfo[unit]; 45019880Skarels register struct ex_softc *xs = &ex_softc[unit]; 45119880Skarels register struct exdevice *addr = (struct exdevice *)ui->ui_addr; 45219880Skarels register struct ex_msg *bp; 45319880Skarels struct mbuf *m; 45419880Skarels int len; 45519880Skarels 45619880Skarels #ifdef DEBUG 45737476Ssklower if (xs->xs_if.if_flags & IFF_OACTIVE) 45819880Skarels panic("exstart(): xmit still pending"); 45919880Skarels #endif 46019880Skarels IF_DEQUEUE(&xs->xs_if.if_snd, m); 46119880Skarels if (m == 0) 46237476Ssklower return (0); 46319880Skarels len = if_wubaput(&xs->xs_ifuba, m); 46419880Skarels if (len - sizeof(struct ether_header) < ETHERMIN) 46519880Skarels len = ETHERMIN + sizeof(struct ether_header); 46619880Skarels /* 46719880Skarels * Place a transmit request. 46819880Skarels */ 46919880Skarels bp = exgetcbuf(xs); 47019880Skarels bp->mb_rqst = LLRTRANSMIT; 47119880Skarels bp->mb_et.et_nblock = 1; 47219880Skarels bp->mb_et.et_blks[0].bb_len = (u_short)len; 47319880Skarels *(u_long *)bp->mb_et.et_blks[0].bb_addr = 47419880Skarels UNIADDR(xs->xs_ifuba.ifu_w.ifrw_info); 47537476Ssklower xs->xs_if.if_flags |= IFF_OACTIVE; 47619880Skarels bp->mb_status |= MH_EXOS; 47719880Skarels addr->xd_portb = EX_NTRUPT; 47837476Ssklower return (0); 47919880Skarels } 48019880Skarels 48119880Skarels /* 48219880Skarels * Command done interrupt. 48319880Skarels */ 48419880Skarels excdint(unit) 48519880Skarels int unit; 48619880Skarels { 48719880Skarels register struct ex_softc *xs = &ex_softc[unit]; 48819880Skarels register struct ex_msg *bp = xs->xs_x2hnext; 48919880Skarels struct uba_device *ui = exinfo[unit]; 49019880Skarels struct exdevice *addr = (struct exdevice *)ui->ui_addr; 49119880Skarels 49219880Skarels while ((bp->mb_status & MH_OWNER) == MH_HOST) { 49319880Skarels switch (bp->mb_rqst) { 49419880Skarels case LLRECEIVE: 49519880Skarels exrecv(unit, bp); 49619880Skarels exhangrcv(unit); 49719880Skarels break; 49819880Skarels case LLRTRANSMIT: 49919880Skarels #ifdef DEBUG 50037476Ssklower if ((xs->xs_if.if_flags & IFF_OACTIVE) == 0) 50119880Skarels panic("exxmit: no xmit pending"); 50219880Skarels #endif 50337476Ssklower xs->xs_if.if_flags &= ~IFF_OACTIVE; 50419880Skarels xs->xs_if.if_opackets++; 50519880Skarels if (bp->mb_rply == LL_OK) { 50619880Skarels ; 50719880Skarels } else if (bp->mb_rply & LLXM_1RTRY) { 50819880Skarels xs->xs_if.if_collisions++; 50919880Skarels } else if (bp->mb_rply & LLXM_RTRYS) { 51019880Skarels xs->xs_if.if_collisions += 2; /* guess */ 51119880Skarels } else if (bp->mb_rply & LLXM_ERROR) { 51219880Skarels xs->xs_if.if_oerrors++; 51329849Skarels log(LOG_ERR, "ex%d: transmit error=%b\n", 51419880Skarels unit, bp->mb_rply, XMIT_BITS); 51519880Skarels } 51619880Skarels if (xs->xs_ifuba.ifu_xtofree) { 51719880Skarels m_freem(xs->xs_ifuba.ifu_xtofree); 51819880Skarels xs->xs_ifuba.ifu_xtofree = 0; 51919880Skarels } 52037476Ssklower (void) exstart(&xs->xs_if); 52119880Skarels break; 52219880Skarels case LLNET_STSTCS: 52319880Skarels xs->xs_if.if_ierrors = xs->xs_xsa.sa_crc; 52419880Skarels xs->xs_flags &= ~EX_STATPENDING; 52519880Skarels break; 52625621Ssklower case LLNET_ADDRS: 52725621Ssklower case LLNET_RECV: 52825621Ssklower break; 52919880Skarels #ifdef DEBUG 53019880Skarels default: 53119880Skarels panic("ex%d: unknown reply"); 53219880Skarels #endif 53319880Skarels } /* end of switch */ 53419880Skarels bp->mb_length = MBDATALEN; 53519880Skarels bp->mb_status |= MH_EXOS; /* free up buffer */ 53619880Skarels addr->xd_portb = EX_NTRUPT; /* tell EXOS about it */ 53719880Skarels bp = xs->xs_x2hnext = xs->xs_x2hnext->mb_next; 53819880Skarels } 53919880Skarels } 54019880Skarels 54119880Skarels /* 54219880Skarels * Get a request buffer, fill in standard values, advance pointer. 54319880Skarels */ 54419880Skarels struct ex_msg * 54519880Skarels exgetcbuf(xs) 54619880Skarels struct ex_softc *xs; 54719880Skarels { 54819880Skarels register struct ex_msg *bp = xs->xs_h2xnext; 54919880Skarels 55019880Skarels #ifdef DEBUG 55119880Skarels if ((bp->mb_status & MH_OWNER) == MH_EXOS) 55219880Skarels panic("exgetcbuf(): EXOS owns message buffer"); 55319880Skarels #endif 55419880Skarels bp->mb_1rsrv = 0; 55519880Skarels bp->mb_length = MBDATALEN; 55619880Skarels xs->xs_h2xnext = xs->xs_h2xnext->mb_next; 55719880Skarels return bp; 55819880Skarels } 55919880Skarels 56019880Skarels /* 56119880Skarels * Process Ethernet receive completion: 56219880Skarels * If input error just drop packet. 56319880Skarels * Otherwise purge input buffered data path and examine 56419880Skarels * packet to determine type. If can't determine length 56519880Skarels * from type, then have to drop packet. Otherwise decapsulate 56619880Skarels * packet based on type and pass to type-specific higher-level 56719880Skarels * input routine. 56819880Skarels */ 56919880Skarels exrecv(unit, bp) 57019880Skarels int unit; 57119880Skarels register struct ex_msg *bp; 57219880Skarels { 57319880Skarels register struct ex_softc *xs = &ex_softc[unit]; 57419880Skarels register struct ether_header *eh; 57519880Skarels struct mbuf *m; 57619880Skarels register int len, off, resid; 57719880Skarels register struct ifqueue *inq; 57829849Skarels int s; 57919880Skarels 58019880Skarels xs->xs_if.if_ipackets++; 58119880Skarels len = bp->mb_er.er_blks[0].bb_len - sizeof(struct ether_header) - 4; 58219880Skarels if (bp->mb_rply != LL_OK) { 58319880Skarels xs->xs_if.if_ierrors++; 58429849Skarels log(LOG_ERR, "ex%d: receive error=%b\n", 58519880Skarels unit, bp->mb_rply, RECV_BITS); 58619880Skarels return; 58719880Skarels } 58819880Skarels eh = (struct ether_header *)(xs->xs_ifuba.ifu_r.ifrw_addr); 58919880Skarels 59019880Skarels /* 59121777Skarels * Deal with trailer protocol: if type is trailer 59219880Skarels * get true type from first 16-bit word past data. 59319880Skarels * Remember that type was trailer by setting off. 59419880Skarels */ 59519880Skarels eh->ether_type = ntohs((u_short)eh->ether_type); 59619880Skarels #define exdataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off)))) 59721777Skarels if (eh->ether_type >= ETHERTYPE_TRAIL && 59821777Skarels eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) { 59921777Skarels off = (eh->ether_type - ETHERTYPE_TRAIL) * 512; 60019880Skarels if (off >= ETHERMTU) 60119880Skarels return; /* sanity */ 60219880Skarels eh->ether_type = ntohs(*exdataaddr(eh, off, u_short *)); 60319880Skarels resid = ntohs(*(exdataaddr(eh, off+2, u_short *))); 60419880Skarels if (off + resid > len) 60519880Skarels return; /* sanity */ 60619880Skarels len = off + resid; 60719880Skarels } else 60819880Skarels off = 0; 60919880Skarels if (len == 0) 61019880Skarels return; 61119880Skarels 61219880Skarels /* 61319880Skarels * Pull packet off interface. Off is nonzero if packet 61419880Skarels * has trailing header; if_rubaget will then force this header 61519880Skarels * information to be at the front, but we still have to drop 61619880Skarels * the type and length which are at the front of any trailer data. 61719880Skarels */ 61824539Skarels m = if_rubaget(&xs->xs_ifuba, len, off, &xs->xs_if); 61919880Skarels if (m == 0) 62019880Skarels return; 62137476Ssklower ether_input(&xs->xs_if, eh, m); 62219880Skarels } 62319880Skarels 62419880Skarels /* 62519880Skarels * Send receive request to EXOS. 62619880Skarels * This routine is called by exinit and excdint, 62719880Skarels * with interrupts disabled in both cases. 62819880Skarels */ 62919880Skarels exhangrcv(unit) 63019880Skarels int unit; 63119880Skarels { 63219880Skarels register struct ex_softc *xs = &ex_softc[unit]; 63319880Skarels register struct ex_msg *bp = exgetcbuf(xs); 63419880Skarels struct exdevice *addr = (struct exdevice *)exinfo[unit]->ui_addr; 63519880Skarels 63619880Skarels bp->mb_rqst = LLRECEIVE; 63719880Skarels bp->mb_er.er_nblock = 1; 63819880Skarels bp->mb_er.er_blks[0].bb_len = EXMAXRBUF; 63919880Skarels *(u_long *)bp->mb_er.er_blks[0].bb_addr = 64019880Skarels UNIADDR(xs->xs_ifuba.ifu_r.ifrw_info); 64119880Skarels bp->mb_status |= MH_EXOS; 64219880Skarels addr->xd_portb = EX_NTRUPT; 64319880Skarels } 64419880Skarels 64519880Skarels /* 64619880Skarels * Watchdog routine - place stats request to EXOS 64719880Skarels * (This could be dispensed with, if you don't care 64819880Skarels * about the if_ierrors count, or are willing to receive 64919880Skarels * bad packets in order to derive it.) 65019880Skarels */ 65119880Skarels exwatch(unit) 65219880Skarels int unit; 65319880Skarels { 65419880Skarels struct uba_device *ui = exinfo[unit]; 65519880Skarels struct exdevice *addr = (struct exdevice *)ui->ui_addr; 65619880Skarels register struct ex_softc *xs = &ex_softc[unit]; 65719880Skarels register struct ex_msg *bp; 65819880Skarels int s = splimp(); 65919880Skarels 66019880Skarels if (xs->xs_flags & EX_STATPENDING) goto exspnd; 66119880Skarels bp = exgetcbuf(xs); 66219880Skarels xs->xs_flags |= EX_STATPENDING; 66319880Skarels bp->mb_rqst = LLNET_STSTCS; 66419880Skarels bp->mb_ns.ns_mask = READ_OBJ; 66519880Skarels bp->mb_ns.ns_rsrv = 0; 66619880Skarels bp->mb_ns.ns_nobj = 8; /* read all 8 stats objects */ 66719880Skarels bp->mb_ns.ns_xobj = 0; /* starting with the 1st one */ 66825728Smckusick bp->mb_ns.ns_bufp = P_UNIADDR(xs->xs_ubaddr) + SA_OFFSET(unit); 66919880Skarels bp->mb_status |= MH_EXOS; 67019880Skarels addr->xd_portb = EX_NTRUPT; 67119880Skarels exspnd: 67219880Skarels splx(s); 67319880Skarels xs->xs_if.if_timer = EXWATCHINTVL; 67419880Skarels } 67519880Skarels 67619880Skarels /* 67719880Skarels * Process an ioctl request. 67819880Skarels */ 67919880Skarels exioctl(ifp, cmd, data) 68019880Skarels register struct ifnet *ifp; 68119880Skarels int cmd; 68219880Skarels caddr_t data; 68319880Skarels { 68421777Skarels register struct ifaddr *ifa = (struct ifaddr *)data; 68525447Skarels register struct ex_softc *xs = &ex_softc[ifp->if_unit]; 68619880Skarels int s = splimp(), error = 0; 68719880Skarels 68819880Skarels switch (cmd) { 68919880Skarels 69019880Skarels case SIOCSIFADDR: 69121777Skarels ifp->if_flags |= IFF_UP; 69224539Skarels exinit(ifp->if_unit); 69321777Skarels 69437476Ssklower switch (ifa->ifa_addr->sa_family) { 69524556Ssklower #ifdef INET 69621777Skarels case AF_INET: 69721777Skarels ((struct arpcom *)ifp)->ac_ipaddr = 69821777Skarels IA_SIN(ifa)->sin_addr; 69921777Skarels arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr); 70021777Skarels break; 70124556Ssklower #endif 70224556Ssklower #ifdef NS 70324556Ssklower case AF_NS: 70425621Ssklower { 70525621Ssklower register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr); 70625621Ssklower 70725621Ssklower if (ns_nullhost(*ina)) 70825621Ssklower ina->x_host = *(union ns_host *)(xs->xs_addr); 70925621Ssklower else 71025621Ssklower ex_setaddr(ina->x_host.c_host,ifp->if_unit); 71124556Ssklower break; 71225621Ssklower } 71324556Ssklower #endif 71421777Skarels } 71519880Skarels break; 71619880Skarels 71725447Skarels case SIOCSIFFLAGS: 71825447Skarels if ((ifp->if_flags & IFF_UP) == 0 && 71925447Skarels xs->xs_flags & EX_RUNNING) { 72025447Skarels ((struct exdevice *) 72125447Skarels (exinfo[ifp->if_unit]->ui_addr))->xd_porta = EX_RESET; 72225447Skarels xs->xs_flags &= ~EX_RUNNING; 72325447Skarels } else if (ifp->if_flags & IFF_UP && 72425447Skarels (xs->xs_flags & EX_RUNNING) == 0) 72525447Skarels exinit(ifp->if_unit); 72625447Skarels break; 72725447Skarels 72819880Skarels default: 72919880Skarels error = EINVAL; 73019880Skarels } 73119880Skarels splx(s); 73219880Skarels return (error); 73319880Skarels } 73425621Ssklower 73525621Ssklower /* 73625621Ssklower * set ethernet address for unit 73725621Ssklower */ 73825621Ssklower ex_setaddr(physaddr, unit) 73925621Ssklower u_char *physaddr; 74025621Ssklower int unit; 74125621Ssklower { 74225621Ssklower register struct ex_softc *xs = &ex_softc[unit]; 74325621Ssklower 74425621Ssklower if (physaddr) { 74525621Ssklower xs->xs_flags |= EX_SETADDR; 74625621Ssklower bcopy((caddr_t)physaddr, (caddr_t)xs->xs_addr, 6); 74725621Ssklower } 74837476Ssklower ex_setmulti((u_char *)xs->xs_addr, unit, PHYSSLOT); 74937476Ssklower } 75037476Ssklower /* 75137476Ssklower * enable multicast reception on a particular address. 75237476Ssklower */ 75337476Ssklower ex_setmulti(linkaddr, unit, slot) 75437476Ssklower u_char *linkaddr; 75537476Ssklower int unit; 75637476Ssklower { 75737476Ssklower register struct ex_softc *xs = &ex_softc[unit]; 75837476Ssklower struct uba_device *ui = exinfo[unit]; 75937476Ssklower register struct exdevice *addr= (struct exdevice *)ui->ui_addr; 76037476Ssklower register struct ex_msg *bp; 76137476Ssklower 76225621Ssklower if (! (xs->xs_flags & EX_RUNNING)) 76325621Ssklower return; 76425621Ssklower bp = exgetcbuf(xs); 76525621Ssklower bp->mb_rqst = LLNET_ADDRS; 76625621Ssklower bp->mb_na.na_mask = READ_OBJ|WRITE_OBJ; 76737476Ssklower bp->mb_na.na_slot = slot; 76837476Ssklower bcopy((caddr_t)linkaddr, (caddr_t)bp->mb_na.na_addrs, 6); 76925621Ssklower bp->mb_status |= MH_EXOS; 77025621Ssklower addr->xd_portb = EX_NTRUPT; 77125621Ssklower bp = xs->xs_x2hnext; 77225621Ssklower while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */ 77325621Ssklower ; 77425975Skarels #ifdef DEBUG 77537476Ssklower log(LOG_DEBUG, "ex%d: %s %s (slot %d)\n", unit, 77637476Ssklower (slot == PHYSSLOT ? "reset addr" : "add multicast" 77737476Ssklower ether_sprintf(bp->mb_na.na_addrs), slot); 77825975Skarels #endif 77925621Ssklower /* 78037476Ssklower * Now, re-enable reception on slot. 78125621Ssklower */ 78225621Ssklower bp = exgetcbuf(xs); 78325621Ssklower bp->mb_rqst = LLNET_RECV; 78425621Ssklower bp->mb_nr.nr_mask = ENABLE_RCV|READ_OBJ|WRITE_OBJ; 78537476Ssklower bp->mb_nr.nr_slot = slot; 78625621Ssklower bp->mb_status |= MH_EXOS; 78725621Ssklower addr->xd_portb = EX_NTRUPT; 78825621Ssklower bp = xs->xs_x2hnext; 78925621Ssklower while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */ 79025621Ssklower ; 79125621Ssklower } 79225273Sbloom #endif 793