![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxif|
Return to if_ex.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxif |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)if_ex.c 7.2 (Berkeley) 10/13/86 ! 7: */ ! 8: ! 9: ! 10: #include "ex.h" ! 11: #if NEX > 0 ! 12: ! 13: /* ! 14: * Excelan EXOS 204 Interface ! 15: * ! 16: * George Powers ! 17: * Excelan Inc. ! 18: */ ! 19: ! 20: #include "../machine/pte.h" ! 21: ! 22: #include "param.h" ! 23: #include "systm.h" ! 24: #include "mbuf.h" ! 25: #include "buf.h" ! 26: #include "protosw.h" ! 27: #include "socket.h" ! 28: #include "vmmac.h" ! 29: #include "ioctl.h" ! 30: #include "syslog.h" ! 31: #include "errno.h" ! 32: ! 33: #include "../net/if.h" ! 34: #include "../net/netisr.h" ! 35: #include "../net/route.h" ! 36: ! 37: #ifdef INET ! 38: #include "../netinet/in.h" ! 39: #include "../netinet/in_systm.h" ! 40: #include "../netinet/in_var.h" ! 41: #include "../netinet/ip.h" ! 42: #include "../netinet/if_ether.h" ! 43: #endif ! 44: ! 45: #ifdef NS ! 46: #include "../netns/ns.h" ! 47: #include "../netns/ns_if.h" ! 48: #endif ! 49: ! 50: #include "../vax/cpu.h" ! 51: #include "../vax/mtpr.h" ! 52: #include "if_exreg.h" ! 53: #include "if_uba.h" ! 54: #include "../vaxuba/ubareg.h" ! 55: #include "../vaxuba/ubavar.h" ! 56: ! 57: #define DEBUG /* check for "impossible" events */ ! 58: ! 59: #define NH2X 4 /* a sufficient number is critical */ ! 60: #define NX2H 4 /* this is pretty arbitrary */ ! 61: #define EXWATCHINTVL 10 /* call exwatch() every 10 seconds */ ! 62: ! 63: int exprobe(), exattach(), excdint(); ! 64: struct uba_device *exinfo[NEX]; ! 65: u_short exstd[] = { 0 }; ! 66: struct uba_driver exdriver = ! 67: { exprobe, 0, exattach, 0, exstd, "ex", exinfo }; ! 68: int exinit(),exoutput(),exioctl(),exreset(),exwatch(); ! 69: struct ex_msg *exgetcbuf(); ! 70: ! 71: /* ! 72: * Ethernet software status per interface. ! 73: * ! 74: * Each interface is referenced by a network interface structure, ! 75: * xs_if, which the routing code uses to locate the interface. ! 76: * This structure contains the output queue for the interface, its address, ... ! 77: * We also have, for each interface, a UBA interface structure, which ! 78: * contains information about the UNIBUS resources held by the interface: ! 79: * map registers, buffered data paths, etc. Information is cached in this ! 80: * structure for use by the if_uba.c routines in running the interface ! 81: * efficiently. ! 82: */ ! 83: struct ex_softc { ! 84: struct arpcom xs_ac; /* Ethernet common part */ ! 85: #define xs_if xs_ac.ac_if /* network-visible interface */ ! 86: #define xs_addr xs_ac.ac_enaddr /* hardware Ethernet address */ ! 87: #ifdef DEBUG ! 88: int xs_wait; ! 89: #endif ! 90: struct ifuba xs_ifuba; /* UNIBUS resources */ ! 91: int xs_flags; /* private flags */ ! 92: #define EX_XPENDING 1 /* xmit rqst pending on EXOS */ ! 93: #define EX_STATPENDING (1<<1) /* stats rqst pending on EXOS */ ! 94: #define EX_RUNNING (1<<2) /* board is running */ ! 95: #define EX_SETADDR (1<<3) /* physaddr has been changed */ ! 96: struct ex_msg *xs_h2xnext; /* host pointer to request queue */ ! 97: struct ex_msg *xs_x2hnext; /* host pointer to reply queue */ ! 98: int xs_ubaddr; /* map info for structs below */ ! 99: #define UNIADDR(x) ((u_long)(x)&0x3FFFF) ! 100: #define P_UNIADDR(x) ((u_long)(x)&0x3FFF0) ! 101: /* the following structures are always mapped in */ ! 102: u_short xs_h2xhdr; /* EXOS's request queue header */ ! 103: u_short xs_x2hhdr; /* EXOS's reply queue header */ ! 104: struct ex_msg xs_h2xent[NH2X]; /* request msg buffers */ ! 105: struct ex_msg xs_x2hent[NX2H]; /* reply msg buffers */ ! 106: struct confmsg xs_cm; /* configuration message */ ! 107: struct stat_array xs_xsa; /* EXOS writes stats here */ ! 108: /* end mapped area */ ! 109: #define INCORE_BASE(p) ((caddr_t)((u_long)(&(p)->xs_h2xhdr) & 0xFFFFFFF0)) ! 110: #define RVAL_OFF(unit, n) \ ! 111: ((caddr_t)(&(ex_softc[unit].n)) - INCORE_BASE(&ex_softc[unit])) ! 112: #define LVAL_OFF(unit, n) \ ! 113: ((caddr_t)(ex_softc[unit].n) - INCORE_BASE(&ex_softc[unit])) ! 114: #define H2XHDR_OFFSET(unit) RVAL_OFF(unit, xs_h2xhdr) ! 115: #define X2HHDR_OFFSET(unit) RVAL_OFF(unit, xs_x2hhdr) ! 116: #define H2XENT_OFFSET(unit) LVAL_OFF(unit, xs_h2xent) ! 117: #define X2HENT_OFFSET(unit) LVAL_OFF(unit, xs_x2hent) ! 118: #define CM_OFFSET(unit) RVAL_OFF(unit, xs_cm) ! 119: #define SA_OFFSET(unit) RVAL_OFF(unit, xs_xsa) ! 120: #define INCORE_SIZE(unit) RVAL_OFF(unit, xs_end) ! 121: int xs_end; /* place holder */ ! 122: } ex_softc[NEX]; ! 123: ! 124: /* ! 125: * The following structure is a kludge to store a cvec value ! 126: * between the time exprobe is called, and exconfig. ! 127: */ ! 128: struct ex_cvecs { ! 129: struct exdevice *xc_csraddr; ! 130: int xc_cvec; ! 131: }ex_cvecs[NEX]; ! 132: ! 133: int ex_ncall = 0; /* counts calls to exprobe */ ! 134: ! 135: exprobe(reg) ! 136: caddr_t reg; ! 137: { ! 138: register int br, cvec; /* r11, r10 value-result */ ! 139: register struct exdevice *addr = (struct exdevice *)reg; ! 140: register i; ! 141: ! 142: /* ! 143: * We program the EXOS interrupt vector, like dmf device. ! 144: */ ! 145: br = 0x15; ! 146: cvec = (uba_hd[numuba].uh_lastiv -= 4); ! 147: ex_cvecs[ex_ncall].xc_csraddr = addr; ! 148: ex_cvecs[ex_ncall].xc_cvec = cvec; ! 149: /* ! 150: * Reset EXOS and run self-test (guaranteed to ! 151: * complete within 2 seconds). ! 152: */ ! 153: addr->xd_porta = EX_RESET; ! 154: i = 2000; ! 155: while (((addr->xd_portb & EX_TESTOK) == 0) && --i) ! 156: DELAY(1000); ! 157: if ((addr->xd_portb & EX_TESTOK) == 0) { ! 158: printf("ex: self-test failed\n"); ! 159: return 0; ! 160: } ! 161: #ifdef lint ! 162: br = br; ! 163: excdint(0); ! 164: #endif ! 165: ex_ncall++; ! 166: return (sizeof(struct exdevice)); ! 167: } ! 168: ! 169: /* ! 170: * Interface exists: make available by filling in network interface ! 171: * record. System will initialize the interface when it is ready ! 172: * to accept packets. Board is temporarily configured and issues ! 173: * a NET_ADDRS command, only to get the Ethernet address. ! 174: */ ! 175: exattach(ui) ! 176: struct uba_device *ui; ! 177: { ! 178: register struct ex_softc *xs = &ex_softc[ui->ui_unit]; ! 179: register struct ifnet *ifp = &xs->xs_if; ! 180: register struct exdevice *addr = (struct exdevice *)ui->ui_addr; ! 181: register struct ex_msg *bp; ! 182: int unit = ui->ui_unit; ! 183: ifp->if_unit = ui->ui_unit; ! 184: ifp->if_name = "ex"; ! 185: ifp->if_mtu = ETHERMTU; ! 186: ! 187: /* ! 188: * Temporarily map queues in order to configure EXOS ! 189: */ ! 190: xs->xs_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(xs), ! 191: INCORE_SIZE(unit), 0); ! 192: exconfig(ui, 0); /* without interrupts */ ! 193: if (xs->xs_cm.cm_cc) goto badconf; ! 194: ! 195: bp = exgetcbuf(xs); ! 196: bp->mb_rqst = LLNET_ADDRS; ! 197: bp->mb_na.na_mask = READ_OBJ; ! 198: bp->mb_na.na_slot = PHYSSLOT; ! 199: bp->mb_status |= MH_EXOS; ! 200: addr->xd_portb = EX_NTRUPT; ! 201: bp = xs->xs_x2hnext; ! 202: while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */ ! 203: ; ! 204: printf("ex%d: HW %c.%c, NX %c.%c, hardware address %s\n", ! 205: ui->ui_unit, xs->xs_cm.cm_vc[2], xs->xs_cm.cm_vc[3], ! 206: xs->xs_cm.cm_vc[0], xs->xs_cm.cm_vc[1], ! 207: ether_sprintf(bp->mb_na.na_addrs)); ! 208: bcopy((caddr_t)bp->mb_na.na_addrs, (caddr_t)xs->xs_addr, ! 209: sizeof (xs->xs_addr)); ! 210: ! 211: ifp->if_init = exinit; ! 212: ifp->if_output = exoutput; ! 213: ifp->if_ioctl = exioctl; ! 214: ifp->if_reset = exreset; ! 215: ifp->if_flags = IFF_BROADCAST; ! 216: xs->xs_ifuba.ifu_flags = UBA_CANTWAIT; ! 217: if_attach(ifp); ! 218: badconf: ! 219: ubarelse(ui->ui_ubanum, &xs->xs_ubaddr); ! 220: } ! 221: ! 222: /* ! 223: * Reset of interface after UNIBUS reset. ! 224: * If interface is on specified uba, reset its state. ! 225: */ ! 226: exreset(unit, uban) ! 227: int unit, uban; ! 228: { ! 229: register struct uba_device *ui; ! 230: ! 231: if (unit >= NEX || (ui = exinfo[unit]) == 0 || ui->ui_alive == 0 || ! 232: ui->ui_ubanum != uban) ! 233: return; ! 234: printf(" ex%d", unit); ! 235: ex_softc[unit].xs_if.if_flags &= ~IFF_RUNNING; ! 236: ex_softc[unit].xs_flags &= ~EX_RUNNING; ! 237: exinit(unit); ! 238: } ! 239: ! 240: /* ! 241: * Initialization of interface; clear recorded pending ! 242: * operations, and reinitialize UNIBUS usage. ! 243: * Called at boot time (with interrupts disabled?), ! 244: * and at ifconfig time via exioctl, with interrupts disabled. ! 245: */ ! 246: exinit(unit) ! 247: int unit; ! 248: { ! 249: register struct ex_softc *xs = &ex_softc[unit]; ! 250: register struct uba_device *ui = exinfo[unit]; ! 251: register struct exdevice *addr = (struct exdevice *)ui->ui_addr; ! 252: register struct ifnet *ifp = &xs->xs_if; ! 253: register struct ex_msg *bp; ! 254: int s; ! 255: ! 256: /* not yet, if address still unknown */ ! 257: if (ifp->if_addrlist == (struct ifaddr *)0) ! 258: return; ! 259: if (xs->xs_flags & EX_RUNNING) ! 260: return; ! 261: ! 262: if ((ifp->if_flags & IFF_RUNNING) == 0) { ! 263: if (if_ubainit(&xs->xs_ifuba, ui->ui_ubanum, ! 264: sizeof (struct ether_header), ! 265: (int)btoc(EXMAXRBUF-sizeof(struct ether_header))) == 0) { ! 266: printf("ex%d: can't initialize\n", unit); ! 267: xs->xs_if.if_flags &= ~IFF_UP; ! 268: return; ! 269: } ! 270: xs->xs_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(xs), ! 271: INCORE_SIZE(unit), 0); ! 272: } ! 273: exconfig(ui, 4); /* with vectored interrupts*/ ! 274: /* ! 275: * Put EXOS on the Ethernet, using NET_MODE command ! 276: */ ! 277: bp = exgetcbuf(xs); ! 278: bp->mb_rqst = LLNET_MODE; ! 279: bp->mb_nm.nm_mask = WRITE_OBJ; ! 280: bp->mb_nm.nm_optn = 0; ! 281: bp->mb_nm.nm_mode = MODE_PERF; ! 282: bp->mb_status |= MH_EXOS; ! 283: addr->xd_portb = EX_NTRUPT; ! 284: bp = xs->xs_x2hnext; ! 285: while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */ ! 286: ; ! 287: bp->mb_length = MBDATALEN; ! 288: bp->mb_status |= MH_EXOS; /* free up buffer */ ! 289: addr->xd_portb = EX_NTRUPT; /* tell EXOS about it */ ! 290: xs->xs_x2hnext = xs->xs_x2hnext->mb_next; ! 291: ! 292: ifp->if_watchdog = exwatch; ! 293: ifp->if_timer = EXWATCHINTVL; ! 294: s = splimp(); /* are interrupts always disabled here, anyway? */ ! 295: exhangrcv(unit); /* hang receive request */ ! 296: xs->xs_if.if_flags |= IFF_RUNNING; ! 297: xs->xs_flags |= EX_RUNNING; ! 298: if (xs->xs_flags & EX_SETADDR) ! 299: ex_setaddr((u_char *)0, unit); ! 300: exstart(unit); /* start transmits */ ! 301: splx(s); ! 302: } ! 303: ! 304: /* ! 305: * Reset, test, and configure EXOS. This routine assumes ! 306: * that message queues, etc. have already been mapped into ! 307: * the UBA. It is called by exinit, and should also be ! 308: * callable by exattach. ! 309: */ ! 310: exconfig(ui, itype) ! 311: struct uba_device *ui; ! 312: int itype; ! 313: { ! 314: register int unit = ui->ui_unit; ! 315: register struct ex_softc *xs = &ex_softc[unit]; ! 316: register struct exdevice *addr = (struct exdevice *) ui->ui_addr; ! 317: register struct confmsg *cm = &xs->xs_cm; ! 318: register struct ex_msg *bp; ! 319: int i; ! 320: u_long shiftreg; ! 321: ! 322: xs->xs_flags = 0; ! 323: /* ! 324: * Reset EXOS, wait for self-test to complete ! 325: */ ! 326: addr->xd_porta = EX_RESET; ! 327: while ((addr->xd_portb & EX_TESTOK) == 0) ! 328: ; ! 329: /* ! 330: * Set up configuration message. ! 331: */ ! 332: cm->cm_1rsrv = 1; ! 333: cm->cm_cc = 0xFF; ! 334: cm->cm_opmode = 0; /* link-level controller mode */ ! 335: cm->cm_dfo = 0x0101; /* enable host data order conversion */ ! 336: cm->cm_dcn1 = 1; ! 337: cm->cm_2rsrv[0] = ! 338: cm->cm_2rsrv[1] = 0; ! 339: cm->cm_ham = 3; /* absolute address mode */ ! 340: cm->cm_3rsrv = 0; ! 341: cm->cm_mapsiz = 0; ! 342: cm->cm_byteptrn[0] = 0x01; /* EXOS deduces data order of host */ ! 343: cm->cm_byteptrn[1] = 0x03; /* by looking at this pattern */ ! 344: cm->cm_byteptrn[2] = 0x07; ! 345: cm->cm_byteptrn[3] = 0x0F; ! 346: cm->cm_wordptrn[0] = 0x0103; ! 347: cm->cm_wordptrn[1] = 0x070F; ! 348: cm->cm_lwordptrn = 0x0103070F; ! 349: for (i=0; i<20; i++) cm->cm_rsrvd[i] = 0; ! 350: cm->cm_mba = 0xFFFFFFFF; ! 351: cm->cm_nproc = 0xFF; ! 352: cm->cm_nmbox = 0xFF; ! 353: cm->cm_nmcast = 0xFF; ! 354: cm->cm_nhost = 1; ! 355: cm->cm_h2xba = P_UNIADDR(xs->xs_ubaddr); ! 356: cm->cm_h2xhdr = H2XHDR_OFFSET(unit); ! 357: cm->cm_h2xtyp = 0; /* should never wait for rqst buffer */ ! 358: cm->cm_x2hba = cm->cm_h2xba; ! 359: cm->cm_x2hhdr = X2HHDR_OFFSET(unit); ! 360: cm->cm_x2htyp = itype; /* 0 for none, 4 for vectored */ ! 361: for (i=0; (addr != ex_cvecs[i].xc_csraddr); i++) ! 362: #ifdef DEBUG ! 363: if (i >= NEX) ! 364: panic("ex: matching csr address not found"); ! 365: #endif ! 366: ; ! 367: cm->cm_x2haddr = ex_cvecs[i].xc_cvec; /* stashed here by exprobe */ ! 368: /* ! 369: * Set up message queues and headers. ! 370: * First the request queue. ! 371: */ ! 372: for (bp = &xs->xs_h2xent[0]; bp < &xs->xs_h2xent[NH2X]; bp++) { ! 373: bp->mb_link = (u_short)((char *)(bp+1)-INCORE_BASE(xs)); ! 374: bp->mb_rsrv = 0; ! 375: bp->mb_length = MBDATALEN; ! 376: bp->mb_status = MH_HOST; ! 377: bp->mb_next = bp+1; ! 378: } ! 379: xs->xs_h2xhdr = ! 380: xs->xs_h2xent[NH2X-1].mb_link = ! 381: (u_short)H2XENT_OFFSET(unit); ! 382: xs->xs_h2xnext = ! 383: xs->xs_h2xent[NH2X-1].mb_next = ! 384: xs->xs_h2xent; ! 385: ! 386: /* Now the reply queue. */ ! 387: for (bp = &xs->xs_x2hent[0]; bp < &xs->xs_x2hent[NX2H]; bp++) { ! 388: bp->mb_link = (u_short)((char *)(bp+1)-INCORE_BASE(xs)); ! 389: bp->mb_rsrv = 0; ! 390: bp->mb_length = MBDATALEN; ! 391: bp->mb_status = MH_EXOS; ! 392: bp->mb_next = bp+1; ! 393: } ! 394: xs->xs_x2hhdr = ! 395: xs->xs_x2hent[NX2H-1].mb_link = ! 396: (u_short)X2HENT_OFFSET(unit); ! 397: xs->xs_x2hnext = ! 398: xs->xs_x2hent[NX2H-1].mb_next = ! 399: xs->xs_x2hent; ! 400: ! 401: /* ! 402: * Write config msg address to EXOS and wait for ! 403: * configuration to complete (guaranteed response ! 404: * within 2 seconds). ! 405: */ ! 406: shiftreg = (u_long)0x0000FFFF; ! 407: for (i = 0; i < 8; i++) { ! 408: if (i == 4) ! 409: shiftreg = P_UNIADDR(xs->xs_ubaddr) + CM_OFFSET(unit); ! 410: while (addr->xd_portb & EX_UNREADY) ! 411: ; ! 412: addr->xd_portb = (u_char)(shiftreg & 0xFF); ! 413: shiftreg >>= 8; ! 414: } ! 415: for (i = 1000000; (cm->cm_cc == 0xFF) && i; --i); ! 416: if (cm->cm_cc) ! 417: printf("ex%d: configuration failed; cc = %x\n", ! 418: unit, cm->cm_cc); ! 419: } ! 420: ! 421: /* ! 422: * Start or re-start output on interface. ! 423: * Get another datagram to send off of the interface queue, ! 424: * and map it to the interface before starting the output. ! 425: * This routine is called by exinit(), exoutput(), and excdint(). ! 426: * In all cases, interrupts by EXOS are disabled. ! 427: */ ! 428: exstart(unit) ! 429: int unit; ! 430: { ! 431: struct uba_device *ui = exinfo[unit]; ! 432: register struct ex_softc *xs = &ex_softc[unit]; ! 433: register struct exdevice *addr = (struct exdevice *)ui->ui_addr; ! 434: register struct ex_msg *bp; ! 435: struct mbuf *m; ! 436: int len; ! 437: ! 438: #ifdef DEBUG ! 439: if (xs->xs_flags & EX_XPENDING) ! 440: panic("exstart(): xmit still pending"); ! 441: #endif ! 442: IF_DEQUEUE(&xs->xs_if.if_snd, m); ! 443: if (m == 0) ! 444: return; ! 445: len = if_wubaput(&xs->xs_ifuba, m); ! 446: if (len - sizeof(struct ether_header) < ETHERMIN) ! 447: len = ETHERMIN + sizeof(struct ether_header); ! 448: /* ! 449: * Place a transmit request. ! 450: */ ! 451: bp = exgetcbuf(xs); ! 452: bp->mb_rqst = LLRTRANSMIT; ! 453: bp->mb_et.et_nblock = 1; ! 454: bp->mb_et.et_blks[0].bb_len = (u_short)len; ! 455: *(u_long *)bp->mb_et.et_blks[0].bb_addr = ! 456: UNIADDR(xs->xs_ifuba.ifu_w.ifrw_info); ! 457: xs->xs_flags |= EX_XPENDING; ! 458: bp->mb_status |= MH_EXOS; ! 459: addr->xd_portb = EX_NTRUPT; ! 460: } ! 461: ! 462: /* ! 463: * Command done interrupt. ! 464: */ ! 465: excdint(unit) ! 466: int unit; ! 467: { ! 468: register struct ex_softc *xs = &ex_softc[unit]; ! 469: register struct ex_msg *bp = xs->xs_x2hnext; ! 470: struct uba_device *ui = exinfo[unit]; ! 471: struct exdevice *addr = (struct exdevice *)ui->ui_addr; ! 472: ! 473: while ((bp->mb_status & MH_OWNER) == MH_HOST) { ! 474: switch (bp->mb_rqst) { ! 475: case LLRECEIVE: ! 476: exrecv(unit, bp); ! 477: exhangrcv(unit); ! 478: break; ! 479: case LLRTRANSMIT: ! 480: #ifdef DEBUG ! 481: if ((xs->xs_flags & EX_XPENDING) == 0) ! 482: panic("exxmit: no xmit pending"); ! 483: #endif ! 484: xs->xs_flags &= ~EX_XPENDING; ! 485: xs->xs_if.if_opackets++; ! 486: if (bp->mb_rply == LL_OK) { ! 487: ; ! 488: } else if (bp->mb_rply & LLXM_1RTRY) { ! 489: xs->xs_if.if_collisions++; ! 490: } else if (bp->mb_rply & LLXM_RTRYS) { ! 491: xs->xs_if.if_collisions += 2; /* guess */ ! 492: } else if (bp->mb_rply & LLXM_ERROR) { ! 493: xs->xs_if.if_oerrors++; ! 494: log(LOG_ERR, "ex%d: transmit error=%b\n", ! 495: unit, bp->mb_rply, XMIT_BITS); ! 496: } ! 497: if (xs->xs_ifuba.ifu_xtofree) { ! 498: m_freem(xs->xs_ifuba.ifu_xtofree); ! 499: xs->xs_ifuba.ifu_xtofree = 0; ! 500: } ! 501: exstart(unit); ! 502: break; ! 503: case LLNET_STSTCS: ! 504: xs->xs_if.if_ierrors = xs->xs_xsa.sa_crc; ! 505: xs->xs_flags &= ~EX_STATPENDING; ! 506: break; ! 507: case LLNET_ADDRS: ! 508: case LLNET_RECV: ! 509: break; ! 510: #ifdef DEBUG ! 511: default: ! 512: panic("ex%d: unknown reply"); ! 513: #endif ! 514: } /* end of switch */ ! 515: bp->mb_length = MBDATALEN; ! 516: bp->mb_status |= MH_EXOS; /* free up buffer */ ! 517: addr->xd_portb = EX_NTRUPT; /* tell EXOS about it */ ! 518: bp = xs->xs_x2hnext = xs->xs_x2hnext->mb_next; ! 519: } ! 520: } ! 521: ! 522: /* ! 523: * Get a request buffer, fill in standard values, advance pointer. ! 524: */ ! 525: struct ex_msg * ! 526: exgetcbuf(xs) ! 527: struct ex_softc *xs; ! 528: { ! 529: register struct ex_msg *bp = xs->xs_h2xnext; ! 530: ! 531: #ifdef DEBUG ! 532: if ((bp->mb_status & MH_OWNER) == MH_EXOS) ! 533: panic("exgetcbuf(): EXOS owns message buffer"); ! 534: #endif ! 535: bp->mb_1rsrv = 0; ! 536: bp->mb_length = MBDATALEN; ! 537: xs->xs_h2xnext = xs->xs_h2xnext->mb_next; ! 538: return bp; ! 539: } ! 540: ! 541: /* ! 542: * Process Ethernet receive completion: ! 543: * If input error just drop packet. ! 544: * Otherwise purge input buffered data path and examine ! 545: * packet to determine type. If can't determine length ! 546: * from type, then have to drop packet. Otherwise decapsulate ! 547: * packet based on type and pass to type-specific higher-level ! 548: * input routine. ! 549: */ ! 550: exrecv(unit, bp) ! 551: int unit; ! 552: register struct ex_msg *bp; ! 553: { ! 554: register struct ex_softc *xs = &ex_softc[unit]; ! 555: register struct ether_header *eh; ! 556: struct mbuf *m; ! 557: register int len, off, resid; ! 558: register struct ifqueue *inq; ! 559: int s; ! 560: ! 561: xs->xs_if.if_ipackets++; ! 562: len = bp->mb_er.er_blks[0].bb_len - sizeof(struct ether_header) - 4; ! 563: if (bp->mb_rply != LL_OK) { ! 564: xs->xs_if.if_ierrors++; ! 565: log(LOG_ERR, "ex%d: receive error=%b\n", ! 566: unit, bp->mb_rply, RECV_BITS); ! 567: return; ! 568: } ! 569: eh = (struct ether_header *)(xs->xs_ifuba.ifu_r.ifrw_addr); ! 570: ! 571: /* ! 572: * Deal with trailer protocol: if type is trailer ! 573: * get true type from first 16-bit word past data. ! 574: * Remember that type was trailer by setting off. ! 575: */ ! 576: eh->ether_type = ntohs((u_short)eh->ether_type); ! 577: #define exdataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off)))) ! 578: if (eh->ether_type >= ETHERTYPE_TRAIL && ! 579: eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) { ! 580: off = (eh->ether_type - ETHERTYPE_TRAIL) * 512; ! 581: if (off >= ETHERMTU) ! 582: return; /* sanity */ ! 583: eh->ether_type = ntohs(*exdataaddr(eh, off, u_short *)); ! 584: resid = ntohs(*(exdataaddr(eh, off+2, u_short *))); ! 585: if (off + resid > len) ! 586: return; /* sanity */ ! 587: len = off + resid; ! 588: } else ! 589: off = 0; ! 590: if (len == 0) ! 591: return; ! 592: ! 593: /* ! 594: * Pull packet off interface. Off is nonzero if packet ! 595: * has trailing header; if_rubaget will then force this header ! 596: * information to be at the front, but we still have to drop ! 597: * the type and length which are at the front of any trailer data. ! 598: */ ! 599: m = if_rubaget(&xs->xs_ifuba, len, off, &xs->xs_if); ! 600: if (m == 0) ! 601: return; ! 602: if (off) { ! 603: struct ifnet *ifp; ! 604: ! 605: ifp = *(mtod(m, struct ifnet **)); ! 606: m->m_off += 2 * sizeof (u_short); ! 607: m->m_len -= 2 * sizeof (u_short); ! 608: *(mtod(m, struct ifnet **)) = ifp; ! 609: } ! 610: switch (eh->ether_type) { ! 611: ! 612: #ifdef INET ! 613: case ETHERTYPE_IP: ! 614: schednetisr(NETISR_IP); /* is this necessary */ ! 615: inq = &ipintrq; ! 616: break; ! 617: ! 618: case ETHERTYPE_ARP: ! 619: arpinput(&xs->xs_ac, m); ! 620: return; ! 621: #endif ! 622: #ifdef NS ! 623: case ETHERTYPE_NS: ! 624: schednetisr(NETISR_NS); ! 625: inq = &nsintrq; ! 626: break; ! 627: ! 628: #endif ! 629: default: ! 630: m_freem(m); ! 631: return; ! 632: } ! 633: ! 634: s = splimp(); ! 635: if (IF_QFULL(inq)) { ! 636: IF_DROP(inq); ! 637: m_freem(m); ! 638: } else ! 639: IF_ENQUEUE(inq, m); ! 640: splx(s); ! 641: } ! 642: ! 643: /* ! 644: * Send receive request to EXOS. ! 645: * This routine is called by exinit and excdint, ! 646: * with interrupts disabled in both cases. ! 647: */ ! 648: exhangrcv(unit) ! 649: int unit; ! 650: { ! 651: register struct ex_softc *xs = &ex_softc[unit]; ! 652: register struct ex_msg *bp = exgetcbuf(xs); ! 653: struct exdevice *addr = (struct exdevice *)exinfo[unit]->ui_addr; ! 654: ! 655: bp->mb_rqst = LLRECEIVE; ! 656: bp->mb_er.er_nblock = 1; ! 657: bp->mb_er.er_blks[0].bb_len = EXMAXRBUF; ! 658: *(u_long *)bp->mb_er.er_blks[0].bb_addr = ! 659: UNIADDR(xs->xs_ifuba.ifu_r.ifrw_info); ! 660: bp->mb_status |= MH_EXOS; ! 661: addr->xd_portb = EX_NTRUPT; ! 662: } ! 663: ! 664: /* ! 665: * Ethernet output routine. ! 666: * Encapsulate a packet of type family for the local net. ! 667: * Use trailer local net encapsulation if enough data in first ! 668: * packet leaves a multiple of 512 bytes of data in remainder. ! 669: */ ! 670: exoutput(ifp, m0, dst) ! 671: register struct ifnet *ifp; ! 672: register struct mbuf *m0; ! 673: struct sockaddr *dst; ! 674: { ! 675: int type, s, error; ! 676: u_char edst[6]; ! 677: struct in_addr idst; ! 678: register struct ex_softc *xs = &ex_softc[ifp->if_unit]; ! 679: register struct mbuf *m = m0; ! 680: register struct ether_header *eh; ! 681: register int off; ! 682: int usetrailers; ! 683: ! 684: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) { ! 685: error = ENETDOWN; ! 686: goto bad; ! 687: } ! 688: switch (dst->sa_family) { ! 689: ! 690: #ifdef INET ! 691: case AF_INET: ! 692: idst = ((struct sockaddr_in *)dst)->sin_addr; ! 693: if (!arpresolve(&xs->xs_ac, m, &idst, edst, &usetrailers)) ! 694: return (0); /* if not yet resolved */ ! 695: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len; ! 696: if (usetrailers && off > 0 && (off & 0x1ff) == 0 && ! 697: m->m_off >= MMINOFF + 2 * sizeof (u_short)) { ! 698: type = ETHERTYPE_TRAIL + (off>>9); ! 699: m->m_off -= 2 * sizeof (u_short); ! 700: m->m_len += 2 * sizeof (u_short); ! 701: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP); ! 702: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len); ! 703: goto gottrailertype; ! 704: } ! 705: type = ETHERTYPE_IP; ! 706: off = 0; ! 707: goto gottype; ! 708: #endif ! 709: #ifdef NS ! 710: case AF_NS: ! 711: type = ETHERTYPE_NS; ! 712: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host), ! 713: (caddr_t)edst, sizeof (edst)); ! 714: off = 0; ! 715: goto gottype; ! 716: #endif ! 717: ! 718: case AF_UNSPEC: ! 719: eh = (struct ether_header *)dst->sa_data; ! 720: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst)); ! 721: type = eh->ether_type; ! 722: goto gottype; ! 723: ! 724: default: ! 725: printf("ex%d: can't handle af%d\n", ifp->if_unit, ! 726: dst->sa_family); ! 727: error = EAFNOSUPPORT; ! 728: goto bad; ! 729: } ! 730: ! 731: gottrailertype: ! 732: /* ! 733: * Packet to be sent as trailer: move first packet ! 734: * (control information) to end of chain. ! 735: */ ! 736: while (m->m_next) ! 737: m = m->m_next; ! 738: m->m_next = m0; ! 739: m = m0->m_next; ! 740: m0->m_next = 0; ! 741: m0 = m; ! 742: ! 743: gottype: ! 744: /* ! 745: * Add local net header. If no space in first mbuf, ! 746: * allocate another. ! 747: */ ! 748: if (m->m_off > MMAXOFF || ! 749: MMINOFF + sizeof (struct ether_header) > m->m_off) { ! 750: m = m_get(M_DONTWAIT, MT_HEADER); ! 751: if (m == 0) { ! 752: error = ENOBUFS; ! 753: goto bad; ! 754: } ! 755: m->m_next = m0; ! 756: m->m_off = MMINOFF; ! 757: m->m_len = sizeof (struct ether_header); ! 758: } else { ! 759: m->m_off -= sizeof (struct ether_header); ! 760: m->m_len += sizeof (struct ether_header); ! 761: } ! 762: eh = mtod(m, struct ether_header *); ! 763: eh->ether_type = htons((u_short)type); ! 764: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst)); ! 765: bcopy((caddr_t)xs->xs_addr, (caddr_t)eh->ether_shost, 6); ! 766: ! 767: /* ! 768: * Queue message on interface, and start output if interface ! 769: * not yet active. ! 770: */ ! 771: s = splimp(); ! 772: if (IF_QFULL(&ifp->if_snd)) { ! 773: IF_DROP(&ifp->if_snd); ! 774: splx(s); ! 775: m_freem(m); ! 776: return (ENOBUFS); ! 777: } ! 778: IF_ENQUEUE(&ifp->if_snd, m); ! 779: /* ! 780: * If transmit request not already pending, then ! 781: * kick the back end. ! 782: */ ! 783: if ((xs->xs_flags & EX_XPENDING) == 0) { ! 784: exstart(ifp->if_unit); ! 785: } ! 786: #ifdef DEBUG ! 787: else { ! 788: xs->xs_wait++; ! 789: } ! 790: #endif ! 791: splx(s); ! 792: return (0); ! 793: ! 794: bad: ! 795: m_freem(m0); ! 796: return (error); ! 797: } ! 798: ! 799: /* ! 800: * Watchdog routine - place stats request to EXOS ! 801: * (This could be dispensed with, if you don't care ! 802: * about the if_ierrors count, or are willing to receive ! 803: * bad packets in order to derive it.) ! 804: */ ! 805: exwatch(unit) ! 806: int unit; ! 807: { ! 808: struct uba_device *ui = exinfo[unit]; ! 809: struct exdevice *addr = (struct exdevice *)ui->ui_addr; ! 810: register struct ex_softc *xs = &ex_softc[unit]; ! 811: register struct ex_msg *bp; ! 812: int s = splimp(); ! 813: ! 814: if (xs->xs_flags & EX_STATPENDING) goto exspnd; ! 815: bp = exgetcbuf(xs); ! 816: xs->xs_flags |= EX_STATPENDING; ! 817: bp->mb_rqst = LLNET_STSTCS; ! 818: bp->mb_ns.ns_mask = READ_OBJ; ! 819: bp->mb_ns.ns_rsrv = 0; ! 820: bp->mb_ns.ns_nobj = 8; /* read all 8 stats objects */ ! 821: bp->mb_ns.ns_xobj = 0; /* starting with the 1st one */ ! 822: bp->mb_ns.ns_bufp = P_UNIADDR(xs->xs_ubaddr) + SA_OFFSET(unit); ! 823: bp->mb_status |= MH_EXOS; ! 824: addr->xd_portb = EX_NTRUPT; ! 825: exspnd: ! 826: splx(s); ! 827: xs->xs_if.if_timer = EXWATCHINTVL; ! 828: } ! 829: ! 830: /* ! 831: * Process an ioctl request. ! 832: */ ! 833: exioctl(ifp, cmd, data) ! 834: register struct ifnet *ifp; ! 835: int cmd; ! 836: caddr_t data; ! 837: { ! 838: register struct ifaddr *ifa = (struct ifaddr *)data; ! 839: register struct ex_softc *xs = &ex_softc[ifp->if_unit]; ! 840: int s = splimp(), error = 0; ! 841: ! 842: switch (cmd) { ! 843: ! 844: case SIOCSIFADDR: ! 845: ifp->if_flags |= IFF_UP; ! 846: exinit(ifp->if_unit); ! 847: ! 848: switch (ifa->ifa_addr.sa_family) { ! 849: #ifdef INET ! 850: case AF_INET: ! 851: ((struct arpcom *)ifp)->ac_ipaddr = ! 852: IA_SIN(ifa)->sin_addr; ! 853: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr); ! 854: break; ! 855: #endif ! 856: #ifdef NS ! 857: case AF_NS: ! 858: { ! 859: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr); ! 860: ! 861: if (ns_nullhost(*ina)) ! 862: ina->x_host = *(union ns_host *)(xs->xs_addr); ! 863: else ! 864: ex_setaddr(ina->x_host.c_host,ifp->if_unit); ! 865: break; ! 866: } ! 867: #endif ! 868: } ! 869: break; ! 870: ! 871: case SIOCSIFFLAGS: ! 872: if ((ifp->if_flags & IFF_UP) == 0 && ! 873: xs->xs_flags & EX_RUNNING) { ! 874: ((struct exdevice *) ! 875: (exinfo[ifp->if_unit]->ui_addr))->xd_porta = EX_RESET; ! 876: xs->xs_flags &= ~EX_RUNNING; ! 877: } else if (ifp->if_flags & IFF_UP && ! 878: (xs->xs_flags & EX_RUNNING) == 0) ! 879: exinit(ifp->if_unit); ! 880: break; ! 881: ! 882: default: ! 883: error = EINVAL; ! 884: } ! 885: splx(s); ! 886: return (error); ! 887: } ! 888: ! 889: /* ! 890: * set ethernet address for unit ! 891: */ ! 892: ex_setaddr(physaddr, unit) ! 893: u_char *physaddr; ! 894: int unit; ! 895: { ! 896: register struct ex_softc *xs = &ex_softc[unit]; ! 897: struct uba_device *ui = exinfo[unit]; ! 898: register struct exdevice *addr= (struct exdevice *)ui->ui_addr; ! 899: register struct ex_msg *bp; ! 900: ! 901: if (physaddr) { ! 902: xs->xs_flags |= EX_SETADDR; ! 903: bcopy((caddr_t)physaddr, (caddr_t)xs->xs_addr, 6); ! 904: } ! 905: if (! (xs->xs_flags & EX_RUNNING)) ! 906: return; ! 907: bp = exgetcbuf(xs); ! 908: bp->mb_rqst = LLNET_ADDRS; ! 909: bp->mb_na.na_mask = READ_OBJ|WRITE_OBJ; ! 910: bp->mb_na.na_slot = PHYSSLOT; ! 911: bcopy((caddr_t)xs->xs_addr, (caddr_t)bp->mb_na.na_addrs, 6); ! 912: bp->mb_status |= MH_EXOS; ! 913: addr->xd_portb = EX_NTRUPT; ! 914: bp = xs->xs_x2hnext; ! 915: while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */ ! 916: ; ! 917: #ifdef DEBUG ! 918: log(LOG_DEBUG, "ex%d: reset addr %s\n", ui->ui_unit, ! 919: ether_sprintf(bp->mb_na.na_addrs)); ! 920: #endif ! 921: /* ! 922: * Now, re-enable reception on phys slot. ! 923: */ ! 924: bp = exgetcbuf(xs); ! 925: bp->mb_rqst = LLNET_RECV; ! 926: bp->mb_nr.nr_mask = ENABLE_RCV|READ_OBJ|WRITE_OBJ; ! 927: bp->mb_nr.nr_slot = PHYSSLOT; ! 928: bp->mb_status |= MH_EXOS; ! 929: addr->xd_portb = EX_NTRUPT; ! 930: bp = xs->xs_x2hnext; ! 931: while ((bp->mb_status & MH_OWNER) == MH_EXOS) /* poll for reply */ ! 932: ; ! 933: } ! 934: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.