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