![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_de.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_de.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_de.c 7.4 (Berkeley) 5/26/88 ! 7: */ ! 8: #include "de.h" ! 9: #if NDE > 0 ! 10: ! 11: /* ! 12: * DEC DEUNA interface ! 13: * ! 14: * Lou Salkind ! 15: * New York University ! 16: * ! 17: * TODO: ! 18: * timeout routine (get statistics) ! 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 "errno.h" ! 31: #include "syslog.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_dereg.h" ! 53: #include "if_uba.h" ! 54: #include "../vaxuba/ubareg.h" ! 55: #include "../vaxuba/ubavar.h" ! 56: ! 57: #define NXMT 3 /* number of transmit buffers */ ! 58: #define NRCV 7 /* number of receive buffers (must be > 1) */ ! 59: ! 60: int dedebug = 0; ! 61: ! 62: int deprobe(), deattach(), deintr(); ! 63: struct uba_device *deinfo[NDE]; ! 64: u_short destd[] = { 0 }; ! 65: struct uba_driver dedriver = ! 66: { deprobe, 0, deattach, 0, destd, "de", deinfo }; ! 67: int deinit(),deoutput(),deioctl(),dereset(); ! 68: ! 69: ! 70: /* ! 71: * Ethernet software status per interface. ! 72: * ! 73: * Each interface is referenced by a network interface structure, ! 74: * ds_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 de_softc { ! 83: struct arpcom ds_ac; /* Ethernet common part */ ! 84: #define ds_if ds_ac.ac_if /* network-visible interface */ ! 85: #define ds_addr ds_ac.ac_enaddr /* hardware Ethernet address */ ! 86: int ds_flags; ! 87: #define DSF_LOCK 1 /* lock out destart */ ! 88: #define DSF_RUNNING 2 /* board is enabled */ ! 89: #define DSF_SETADDR 4 /* physical address is changed */ ! 90: int ds_ubaddr; /* map info for incore structs */ ! 91: struct ifubinfo ds_deuba; /* unibus resource structure */ ! 92: struct ifrw ds_ifr[NRCV]; /* unibus receive maps */ ! 93: struct ifxmt ds_ifw[NXMT]; /* unibus xmt maps */ ! 94: /* the following structures are always mapped in */ ! 95: struct de_pcbb ds_pcbb; /* port control block */ ! 96: struct de_ring ds_xrent[NXMT]; /* transmit ring entrys */ ! 97: struct de_ring ds_rrent[NRCV]; /* receive ring entrys */ ! 98: struct de_udbbuf ds_udbbuf; /* UNIBUS data buffer */ ! 99: /* end mapped area */ ! 100: #define INCORE_BASE(p) ((char *)&(p)->ds_pcbb) ! 101: #define RVAL_OFF(n) ((char *)&de_softc[0].n - INCORE_BASE(&de_softc[0])) ! 102: #define LVAL_OFF(n) ((char *)de_softc[0].n - INCORE_BASE(&de_softc[0])) ! 103: #define PCBB_OFFSET RVAL_OFF(ds_pcbb) ! 104: #define XRENT_OFFSET LVAL_OFF(ds_xrent) ! 105: #define RRENT_OFFSET LVAL_OFF(ds_rrent) ! 106: #define UDBBUF_OFFSET RVAL_OFF(ds_udbbuf) ! 107: #define INCORE_SIZE RVAL_OFF(ds_xindex) ! 108: int ds_xindex; /* UNA index into transmit chain */ ! 109: int ds_rindex; /* UNA index into receive chain */ ! 110: int ds_xfree; /* index for next transmit buffer */ ! 111: int ds_nxmit; /* # of transmits in progress */ ! 112: } de_softc[NDE]; ! 113: ! 114: deprobe(reg) ! 115: caddr_t reg; ! 116: { ! 117: register int br, cvec; /* r11, r10 value-result */ ! 118: register struct dedevice *addr = (struct dedevice *)reg; ! 119: register i; ! 120: ! 121: #ifdef lint ! 122: br = 0; cvec = br; br = cvec; ! 123: i = 0; derint(i); deintr(i); ! 124: #endif ! 125: ! 126: /* ! 127: * Make sure self-test is finished before we screw with the board. ! 128: * Self-test on a DELUA can take 15 seconds (argh). ! 129: */ ! 130: for (i = 0; ! 131: i < 160 && ! 132: (addr->pcsr0 & PCSR0_FATI) == 0 && ! 133: (addr->pcsr1 & PCSR1_STMASK) == STAT_RESET; ! 134: ++i) ! 135: DELAY(100000); ! 136: if ((addr->pcsr0 & PCSR0_FATI) != 0 || ! 137: (addr->pcsr1 & PCSR1_STMASK) != STAT_READY) ! 138: return(0); ! 139: ! 140: addr->pcsr0 = 0; ! 141: DELAY(100); ! 142: addr->pcsr0 = PCSR0_RSET; ! 143: while ((addr->pcsr0 & PCSR0_INTR) == 0) ! 144: ; ! 145: /* make board interrupt by executing a GETPCBB command */ ! 146: addr->pcsr0 = PCSR0_INTE; ! 147: addr->pcsr2 = 0; ! 148: addr->pcsr3 = 0; ! 149: addr->pcsr0 = PCSR0_INTE|CMD_GETPCBB; ! 150: DELAY(100000); ! 151: return(1); ! 152: } ! 153: ! 154: /* ! 155: * Interface exists: make available by filling in network interface ! 156: * record. System will initialize the interface when it is ready ! 157: * to accept packets. We get the ethernet address here. ! 158: */ ! 159: deattach(ui) ! 160: struct uba_device *ui; ! 161: { ! 162: register struct de_softc *ds = &de_softc[ui->ui_unit]; ! 163: register struct ifnet *ifp = &ds->ds_if; ! 164: register struct dedevice *addr = (struct dedevice *)ui->ui_addr; ! 165: int csr1; ! 166: ! 167: ifp->if_unit = ui->ui_unit; ! 168: ifp->if_name = "de"; ! 169: ifp->if_mtu = ETHERMTU; ! 170: ifp->if_flags = IFF_BROADCAST; ! 171: ! 172: /* ! 173: * What kind of a board is this? ! 174: * The error bits 4-6 in pcsr1 are a device id as long as ! 175: * the high byte is zero. ! 176: */ ! 177: csr1 = addr->pcsr1; ! 178: if (csr1 & 0xff60) ! 179: printf("de%d: broken\n", ui->ui_unit); ! 180: else if (csr1 & 0x10) ! 181: printf("de%d: delua\n", ui->ui_unit); ! 182: else ! 183: printf("de%d: deuna\n", ui->ui_unit); ! 184: ! 185: /* ! 186: * Reset the board and temporarily map ! 187: * the pcbb buffer onto the Unibus. ! 188: */ ! 189: addr->pcsr0 = 0; /* reset INTE */ ! 190: DELAY(100); ! 191: addr->pcsr0 = PCSR0_RSET; ! 192: (void)dewait(ui, "reset"); ! 193: ! 194: ds->ds_ubaddr = uballoc(ui->ui_ubanum, (char *)&ds->ds_pcbb, ! 195: sizeof (struct de_pcbb), 0); ! 196: addr->pcsr2 = ds->ds_ubaddr & 0xffff; ! 197: addr->pcsr3 = (ds->ds_ubaddr >> 16) & 0x3; ! 198: addr->pclow = CMD_GETPCBB; ! 199: (void)dewait(ui, "pcbb"); ! 200: ! 201: ds->ds_pcbb.pcbb0 = FC_RDPHYAD; ! 202: addr->pclow = CMD_GETCMD; ! 203: (void)dewait(ui, "read addr "); ! 204: ! 205: ubarelse(ui->ui_ubanum, &ds->ds_ubaddr); ! 206: bcopy((caddr_t)&ds->ds_pcbb.pcbb2, (caddr_t)ds->ds_addr, ! 207: sizeof (ds->ds_addr)); ! 208: printf("de%d: hardware address %s\n", ui->ui_unit, ! 209: ether_sprintf(ds->ds_addr)); ! 210: ifp->if_init = deinit; ! 211: ifp->if_output = deoutput; ! 212: ifp->if_ioctl = deioctl; ! 213: ifp->if_reset = dereset; ! 214: ds->ds_deuba.iff_flags = UBA_CANTWAIT; ! 215: #ifdef notdef ! 216: /* CAN WE USE BDP's ??? */ ! 217: ds->ds_deuba.iff_flags |= UBA_NEEDBDP; ! 218: #endif ! 219: if_attach(ifp); ! 220: } ! 221: ! 222: /* ! 223: * Reset of interface after UNIBUS reset. ! 224: * If interface is on specified uba, reset its state. ! 225: */ ! 226: dereset(unit, uban) ! 227: int unit, uban; ! 228: { ! 229: register struct uba_device *ui; ! 230: ! 231: if (unit >= NDE || (ui = deinfo[unit]) == 0 || ui->ui_alive == 0 || ! 232: ui->ui_ubanum != uban) ! 233: return; ! 234: printf(" de%d", unit); ! 235: de_softc[unit].ds_if.if_flags &= ~IFF_RUNNING; ! 236: de_softc[unit].ds_flags &= ~(DSF_LOCK | DSF_RUNNING); ! 237: ((struct dedevice *)ui->ui_addr)->pcsr0 = PCSR0_RSET; ! 238: (void)dewait(ui, "reset"); ! 239: deinit(unit); ! 240: } ! 241: ! 242: /* ! 243: * Initialization of interface; clear recorded pending ! 244: * operations, and reinitialize UNIBUS usage. ! 245: */ ! 246: deinit(unit) ! 247: int unit; ! 248: { ! 249: register struct de_softc *ds = &de_softc[unit]; ! 250: register struct uba_device *ui = deinfo[unit]; ! 251: register struct dedevice *addr; ! 252: register struct ifrw *ifrw; ! 253: register struct ifxmt *ifxp; ! 254: struct ifnet *ifp = &ds->ds_if; ! 255: int s; ! 256: struct de_ring *rp; ! 257: int incaddr; ! 258: ! 259: /* not yet, if address still unknown */ ! 260: if (ifp->if_addrlist == (struct ifaddr *)0) ! 261: return; ! 262: ! 263: if (ds->ds_flags & DSF_RUNNING) ! 264: return; ! 265: if ((ifp->if_flags & IFF_RUNNING) == 0) { ! 266: if (if_ubaminit(&ds->ds_deuba, ui->ui_ubanum, ! 267: sizeof (struct ether_header), (int)btoc(ETHERMTU), ! 268: ds->ds_ifr, NRCV, ds->ds_ifw, NXMT) == 0) { ! 269: printf("de%d: can't initialize\n", unit); ! 270: ds->ds_if.if_flags &= ~IFF_UP; ! 271: return; ! 272: } ! 273: ds->ds_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(ds), ! 274: INCORE_SIZE, 0); ! 275: } ! 276: addr = (struct dedevice *)ui->ui_addr; ! 277: ! 278: /* set the pcbb block address */ ! 279: incaddr = ds->ds_ubaddr + PCBB_OFFSET; ! 280: addr->pcsr2 = incaddr & 0xffff; ! 281: addr->pcsr3 = (incaddr >> 16) & 0x3; ! 282: addr->pclow = 0; /* reset INTE */ ! 283: DELAY(100); ! 284: addr->pclow = CMD_GETPCBB; ! 285: (void)dewait(ui, "pcbb"); ! 286: ! 287: /* set the transmit and receive ring header addresses */ ! 288: incaddr = ds->ds_ubaddr + UDBBUF_OFFSET; ! 289: ds->ds_pcbb.pcbb0 = FC_WTRING; ! 290: ds->ds_pcbb.pcbb2 = incaddr & 0xffff; ! 291: ds->ds_pcbb.pcbb4 = (incaddr >> 16) & 0x3; ! 292: ! 293: incaddr = ds->ds_ubaddr + XRENT_OFFSET; ! 294: ds->ds_udbbuf.b_tdrbl = incaddr & 0xffff; ! 295: ds->ds_udbbuf.b_tdrbh = (incaddr >> 16) & 0x3; ! 296: ds->ds_udbbuf.b_telen = sizeof (struct de_ring) / sizeof (short); ! 297: ds->ds_udbbuf.b_trlen = NXMT; ! 298: incaddr = ds->ds_ubaddr + RRENT_OFFSET; ! 299: ds->ds_udbbuf.b_rdrbl = incaddr & 0xffff; ! 300: ds->ds_udbbuf.b_rdrbh = (incaddr >> 16) & 0x3; ! 301: ds->ds_udbbuf.b_relen = sizeof (struct de_ring) / sizeof (short); ! 302: ds->ds_udbbuf.b_rrlen = NRCV; ! 303: ! 304: addr->pclow = CMD_GETCMD; ! 305: (void)dewait(ui, "wtring"); ! 306: ! 307: /* initialize the mode - enable hardware padding */ ! 308: ds->ds_pcbb.pcbb0 = FC_WTMODE; ! 309: /* let hardware do padding - set MTCH bit on broadcast */ ! 310: ds->ds_pcbb.pcbb2 = MOD_TPAD|MOD_HDX; ! 311: addr->pclow = CMD_GETCMD; ! 312: (void)dewait(ui, "wtmode"); ! 313: ! 314: /* set up the receive and transmit ring entries */ ! 315: ifxp = &ds->ds_ifw[0]; ! 316: for (rp = &ds->ds_xrent[0]; rp < &ds->ds_xrent[NXMT]; rp++) { ! 317: rp->r_segbl = ifxp->ifw_info & 0xffff; ! 318: rp->r_segbh = (ifxp->ifw_info >> 16) & 0x3; ! 319: rp->r_flags = 0; ! 320: ifxp++; ! 321: } ! 322: ifrw = &ds->ds_ifr[0]; ! 323: for (rp = &ds->ds_rrent[0]; rp < &ds->ds_rrent[NRCV]; rp++) { ! 324: rp->r_slen = sizeof (struct de_buf); ! 325: rp->r_segbl = ifrw->ifrw_info & 0xffff; ! 326: rp->r_segbh = (ifrw->ifrw_info >> 16) & 0x3; ! 327: rp->r_flags = RFLG_OWN; /* hang receive */ ! 328: ifrw++; ! 329: } ! 330: ! 331: /* start up the board (rah rah) */ ! 332: s = splimp(); ! 333: ds->ds_rindex = ds->ds_xindex = ds->ds_xfree = ds->ds_nxmit = 0; ! 334: ds->ds_if.if_flags |= IFF_RUNNING; ! 335: addr->pclow = PCSR0_INTE; /* avoid interlock */ ! 336: destart(unit); /* queue output packets */ ! 337: ds->ds_flags |= DSF_RUNNING; /* need before de_setaddr */ ! 338: if (ds->ds_flags & DSF_SETADDR) ! 339: de_setaddr(ds->ds_addr, unit); ! 340: addr->pclow = CMD_START | PCSR0_INTE; ! 341: splx(s); ! 342: } ! 343: ! 344: /* ! 345: * Setup output on interface. ! 346: * Get another datagram to send off of the interface queue, ! 347: * and map it to the interface before starting the output. ! 348: */ ! 349: destart(unit) ! 350: int unit; ! 351: { ! 352: int len; ! 353: struct uba_device *ui = deinfo[unit]; ! 354: struct dedevice *addr = (struct dedevice *)ui->ui_addr; ! 355: register struct de_softc *ds = &de_softc[unit]; ! 356: register struct de_ring *rp; ! 357: struct mbuf *m; ! 358: register int nxmit; ! 359: ! 360: /* ! 361: * the following test is necessary, since ! 362: * the code is not reentrant and we have ! 363: * multiple transmission buffers. ! 364: */ ! 365: if (ds->ds_flags & DSF_LOCK) ! 366: return; ! 367: for (nxmit = ds->ds_nxmit; nxmit < NXMT; nxmit++) { ! 368: IF_DEQUEUE(&ds->ds_if.if_snd, m); ! 369: if (m == 0) ! 370: break; ! 371: rp = &ds->ds_xrent[ds->ds_xfree]; ! 372: if (rp->r_flags & XFLG_OWN) ! 373: panic("deuna xmit in progress"); ! 374: len = if_ubaput(&ds->ds_deuba, &ds->ds_ifw[ds->ds_xfree], m); ! 375: if (ds->ds_deuba.iff_flags & UBA_NEEDBDP) ! 376: UBAPURGE(ds->ds_deuba.iff_uba, ! 377: ds->ds_ifw[ds->ds_xfree].ifw_bdp); ! 378: rp->r_slen = len; ! 379: rp->r_tdrerr = 0; ! 380: rp->r_flags = XFLG_STP|XFLG_ENP|XFLG_OWN; ! 381: ! 382: ds->ds_xfree++; ! 383: if (ds->ds_xfree == NXMT) ! 384: ds->ds_xfree = 0; ! 385: } ! 386: if (ds->ds_nxmit != nxmit) { ! 387: ds->ds_nxmit = nxmit; ! 388: if (ds->ds_flags & DSF_RUNNING) ! 389: addr->pclow = PCSR0_INTE|CMD_PDMD; ! 390: } ! 391: } ! 392: ! 393: /* ! 394: * Command done interrupt. ! 395: */ ! 396: deintr(unit) ! 397: int unit; ! 398: { ! 399: struct uba_device *ui = deinfo[unit]; ! 400: register struct dedevice *addr = (struct dedevice *)ui->ui_addr; ! 401: register struct de_softc *ds = &de_softc[unit]; ! 402: register struct de_ring *rp; ! 403: register struct ifxmt *ifxp; ! 404: short csr0; ! 405: ! 406: /* save flags right away - clear out interrupt bits */ ! 407: csr0 = addr->pcsr0; ! 408: addr->pchigh = csr0 >> 8; ! 409: ! 410: ! 411: ds->ds_flags |= DSF_LOCK; /* prevent entering destart */ ! 412: /* ! 413: * if receive, put receive buffer on mbuf ! 414: * and hang the request again ! 415: */ ! 416: derecv(unit); ! 417: ! 418: /* ! 419: * Poll transmit ring and check status. ! 420: * Be careful about loopback requests. ! 421: * Then free buffer space and check for ! 422: * more transmit requests. ! 423: */ ! 424: for ( ; ds->ds_nxmit > 0; ds->ds_nxmit--) { ! 425: rp = &ds->ds_xrent[ds->ds_xindex]; ! 426: if (rp->r_flags & XFLG_OWN) ! 427: break; ! 428: ds->ds_if.if_opackets++; ! 429: ifxp = &ds->ds_ifw[ds->ds_xindex]; ! 430: /* check for unusual conditions */ ! 431: if (rp->r_flags & (XFLG_ERRS|XFLG_MTCH|XFLG_ONE|XFLG_MORE)) { ! 432: if (rp->r_flags & XFLG_ERRS) { ! 433: /* output error */ ! 434: ds->ds_if.if_oerrors++; ! 435: if (dedebug) ! 436: printf("de%d: oerror, flags=%b tdrerr=%b (len=%d)\n", ! 437: unit, rp->r_flags, XFLG_BITS, ! 438: rp->r_tdrerr, XERR_BITS, rp->r_slen); ! 439: } else if (rp->r_flags & XFLG_ONE) { ! 440: /* one collision */ ! 441: ds->ds_if.if_collisions++; ! 442: } else if (rp->r_flags & XFLG_MORE) { ! 443: /* more than one collision */ ! 444: ds->ds_if.if_collisions += 2; /* guess */ ! 445: } else if (rp->r_flags & XFLG_MTCH) { ! 446: /* received our own packet */ ! 447: ds->ds_if.if_ipackets++; ! 448: deread(ds, &ifxp->ifrw, ! 449: rp->r_slen - sizeof (struct ether_header)); ! 450: } ! 451: } ! 452: if (ifxp->ifw_xtofree) { ! 453: m_freem(ifxp->ifw_xtofree); ! 454: ifxp->ifw_xtofree = 0; ! 455: } ! 456: /* check if next transmit buffer also finished */ ! 457: ds->ds_xindex++; ! 458: if (ds->ds_xindex == NXMT) ! 459: ds->ds_xindex = 0; ! 460: } ! 461: ds->ds_flags &= ~DSF_LOCK; ! 462: destart(unit); ! 463: ! 464: if (csr0 & PCSR0_RCBI) { ! 465: if (dedebug) ! 466: log(LOG_WARNING, "de%d: buffer unavailable\n", unit); ! 467: addr->pclow = PCSR0_INTE|CMD_PDMD; ! 468: } ! 469: } ! 470: ! 471: /* ! 472: * Ethernet interface receiver interface. ! 473: * If input error just drop packet. ! 474: * Otherwise purge input buffered data path and examine ! 475: * packet to determine type. If can't determine length ! 476: * from type, then have to drop packet. Othewise decapsulate ! 477: * packet based on type and pass to type specific higher-level ! 478: * input routine. ! 479: */ ! 480: derecv(unit) ! 481: int unit; ! 482: { ! 483: register struct de_softc *ds = &de_softc[unit]; ! 484: register struct de_ring *rp; ! 485: int len; ! 486: ! 487: rp = &ds->ds_rrent[ds->ds_rindex]; ! 488: while ((rp->r_flags & RFLG_OWN) == 0) { ! 489: ds->ds_if.if_ipackets++; ! 490: if (ds->ds_deuba.iff_flags & UBA_NEEDBDP) ! 491: UBAPURGE(ds->ds_deuba.iff_uba, ! 492: ds->ds_ifr[ds->ds_rindex].ifrw_bdp); ! 493: len = (rp->r_lenerr&RERR_MLEN) - sizeof (struct ether_header) ! 494: - 4; /* don't forget checksum! */ ! 495: /* check for errors */ ! 496: if ((rp->r_flags & (RFLG_ERRS|RFLG_FRAM|RFLG_OFLO|RFLG_CRC)) || ! 497: (rp->r_flags&(RFLG_STP|RFLG_ENP)) != (RFLG_STP|RFLG_ENP) || ! 498: (rp->r_lenerr & (RERR_BUFL|RERR_UBTO|RERR_NCHN)) || ! 499: len < ETHERMIN || len > ETHERMTU) { ! 500: ds->ds_if.if_ierrors++; ! 501: if (dedebug) ! 502: printf("de%d: ierror, flags=%b lenerr=%b (len=%d)\n", ! 503: unit, rp->r_flags, RFLG_BITS, rp->r_lenerr, ! 504: RERR_BITS, len); ! 505: } else ! 506: deread(ds, &ds->ds_ifr[ds->ds_rindex], len); ! 507: ! 508: /* hang the receive buffer again */ ! 509: rp->r_lenerr = 0; ! 510: rp->r_flags = RFLG_OWN; ! 511: ! 512: /* check next receive buffer */ ! 513: ds->ds_rindex++; ! 514: if (ds->ds_rindex == NRCV) ! 515: ds->ds_rindex = 0; ! 516: rp = &ds->ds_rrent[ds->ds_rindex]; ! 517: } ! 518: } ! 519: ! 520: /* ! 521: * Pass a packet to the higher levels. ! 522: * We deal with the trailer protocol here. ! 523: */ ! 524: deread(ds, ifrw, len) ! 525: register struct de_softc *ds; ! 526: struct ifrw *ifrw; ! 527: int len; ! 528: { ! 529: struct ether_header *eh; ! 530: struct mbuf *m; ! 531: int off, resid; ! 532: int s; ! 533: register struct ifqueue *inq; ! 534: ! 535: /* ! 536: * Deal with trailer protocol: if type is trailer type ! 537: * get true type from first 16-bit word past data. ! 538: * Remember that type was trailer by setting off. ! 539: */ ! 540: eh = (struct ether_header *)ifrw->ifrw_addr; ! 541: eh->ether_type = ntohs((u_short)eh->ether_type); ! 542: #define dedataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off)))) ! 543: if (eh->ether_type >= ETHERTYPE_TRAIL && ! 544: eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) { ! 545: off = (eh->ether_type - ETHERTYPE_TRAIL) * 512; ! 546: if (off >= ETHERMTU) ! 547: return; /* sanity */ ! 548: eh->ether_type = ntohs(*dedataaddr(eh, off, u_short *)); ! 549: resid = ntohs(*(dedataaddr(eh, off+2, u_short *))); ! 550: if (off + resid > len) ! 551: return; /* sanity */ ! 552: len = off + resid; ! 553: } else ! 554: off = 0; ! 555: if (len == 0) ! 556: return; ! 557: ! 558: /* ! 559: * Pull packet off interface. Off is nonzero if packet ! 560: * has trailing header; if_ubaget will then force this header ! 561: * information to be at the front, but we still have to drop ! 562: * the type and length which are at the front of any trailer data. ! 563: */ ! 564: m = if_ubaget(&ds->ds_deuba, ifrw, len, off, &ds->ds_if); ! 565: if (m == 0) ! 566: return; ! 567: if (off) { ! 568: struct ifnet *ifp; ! 569: ! 570: ifp = *(mtod(m, struct ifnet **)); ! 571: m->m_off += 2 * sizeof (u_short); ! 572: m->m_len -= 2 * sizeof (u_short); ! 573: *(mtod(m, struct ifnet **)) = ifp; ! 574: } ! 575: switch (eh->ether_type) { ! 576: ! 577: #ifdef INET ! 578: case ETHERTYPE_IP: ! 579: schednetisr(NETISR_IP); ! 580: inq = &ipintrq; ! 581: break; ! 582: ! 583: case ETHERTYPE_ARP: ! 584: arpinput(&ds->ds_ac, m); ! 585: return; ! 586: #endif ! 587: #ifdef NS ! 588: case ETHERTYPE_NS: ! 589: schednetisr(NETISR_NS); ! 590: inq = &nsintrq; ! 591: break; ! 592: ! 593: #endif ! 594: default: ! 595: m_freem(m); ! 596: return; ! 597: } ! 598: ! 599: s = splimp(); ! 600: if (IF_QFULL(inq)) { ! 601: IF_DROP(inq); ! 602: splx(s); ! 603: m_freem(m); ! 604: return; ! 605: } ! 606: IF_ENQUEUE(inq, m); ! 607: splx(s); ! 608: } ! 609: ! 610: /* ! 611: * Ethernet output routine. ! 612: * Encapsulate a packet of type family for the local net. ! 613: * Use trailer local net encapsulation if enough data in first ! 614: * packet leaves a multiple of 512 bytes of data in remainder. ! 615: */ ! 616: deoutput(ifp, m0, dst) ! 617: struct ifnet *ifp; ! 618: struct mbuf *m0; ! 619: struct sockaddr *dst; ! 620: { ! 621: int type, s, error; ! 622: u_char edst[6]; ! 623: struct in_addr idst; ! 624: register struct de_softc *ds = &de_softc[ifp->if_unit]; ! 625: register struct mbuf *m = m0; ! 626: register struct ether_header *eh; ! 627: register int off; ! 628: int usetrailers; ! 629: ! 630: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) { ! 631: error = ENETDOWN; ! 632: goto bad; ! 633: } ! 634: switch (dst->sa_family) { ! 635: ! 636: #ifdef INET ! 637: case AF_INET: ! 638: idst = ((struct sockaddr_in *)dst)->sin_addr; ! 639: if (!arpresolve(&ds->ds_ac, m, &idst, edst, &usetrailers)) ! 640: return (0); /* if not yet resolved */ ! 641: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len; ! 642: if (usetrailers && off > 0 && (off & 0x1ff) == 0 && ! 643: m->m_off >= MMINOFF + 2 * sizeof (u_short)) { ! 644: type = ETHERTYPE_TRAIL + (off>>9); ! 645: m->m_off -= 2 * sizeof (u_short); ! 646: m->m_len += 2 * sizeof (u_short); ! 647: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP); ! 648: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len); ! 649: goto gottrailertype; ! 650: } ! 651: type = ETHERTYPE_IP; ! 652: off = 0; ! 653: goto gottype; ! 654: #endif ! 655: #ifdef NS ! 656: case AF_NS: ! 657: type = ETHERTYPE_NS; ! 658: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host), ! 659: (caddr_t)edst, sizeof (edst)); ! 660: off = 0; ! 661: goto gottype; ! 662: #endif ! 663: ! 664: case AF_UNSPEC: ! 665: eh = (struct ether_header *)dst->sa_data; ! 666: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst)); ! 667: type = eh->ether_type; ! 668: goto gottype; ! 669: ! 670: default: ! 671: printf("de%d: can't handle af%d\n", ifp->if_unit, ! 672: dst->sa_family); ! 673: error = EAFNOSUPPORT; ! 674: goto bad; ! 675: } ! 676: ! 677: gottrailertype: ! 678: /* ! 679: * Packet to be sent as trailer: move first packet ! 680: * (control information) to end of chain. ! 681: */ ! 682: while (m->m_next) ! 683: m = m->m_next; ! 684: m->m_next = m0; ! 685: m = m0->m_next; ! 686: m0->m_next = 0; ! 687: m0 = m; ! 688: ! 689: gottype: ! 690: /* ! 691: * Add local net header. If no space in first mbuf, ! 692: * allocate another. ! 693: */ ! 694: if (m->m_off > MMAXOFF || ! 695: MMINOFF + sizeof (struct ether_header) > m->m_off) { ! 696: m = m_get(M_DONTWAIT, MT_HEADER); ! 697: if (m == 0) { ! 698: error = ENOBUFS; ! 699: goto bad; ! 700: } ! 701: m->m_next = m0; ! 702: m->m_off = MMINOFF; ! 703: m->m_len = sizeof (struct ether_header); ! 704: } else { ! 705: m->m_off -= sizeof (struct ether_header); ! 706: m->m_len += sizeof (struct ether_header); ! 707: } ! 708: eh = mtod(m, struct ether_header *); ! 709: eh->ether_type = htons((u_short)type); ! 710: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst)); ! 711: /* DEUNA fills in source address */ ! 712: ! 713: /* ! 714: * Queue message on interface, and start output if interface ! 715: * not yet active. ! 716: */ ! 717: s = splimp(); ! 718: if (IF_QFULL(&ifp->if_snd)) { ! 719: IF_DROP(&ifp->if_snd); ! 720: splx(s); ! 721: m_freem(m); ! 722: return (ENOBUFS); ! 723: } ! 724: IF_ENQUEUE(&ifp->if_snd, m); ! 725: destart(ifp->if_unit); ! 726: splx(s); ! 727: return (0); ! 728: ! 729: bad: ! 730: m_freem(m0); ! 731: return (error); ! 732: } ! 733: ! 734: /* ! 735: * Process an ioctl request. ! 736: */ ! 737: deioctl(ifp, cmd, data) ! 738: register struct ifnet *ifp; ! 739: int cmd; ! 740: caddr_t data; ! 741: { ! 742: register struct ifaddr *ifa = (struct ifaddr *)data; ! 743: register struct de_softc *ds = &de_softc[ifp->if_unit]; ! 744: int s = splimp(), error = 0; ! 745: ! 746: switch (cmd) { ! 747: ! 748: case SIOCSIFADDR: ! 749: ifp->if_flags |= IFF_UP; ! 750: deinit(ifp->if_unit); ! 751: ! 752: switch (ifa->ifa_addr.sa_family) { ! 753: #ifdef INET ! 754: case AF_INET: ! 755: ((struct arpcom *)ifp)->ac_ipaddr = ! 756: IA_SIN(ifa)->sin_addr; ! 757: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr); ! 758: break; ! 759: #endif ! 760: #ifdef NS ! 761: case AF_NS: ! 762: { ! 763: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr); ! 764: ! 765: if (ns_nullhost(*ina)) ! 766: ina->x_host = *(union ns_host *)(ds->ds_addr); ! 767: else ! 768: de_setaddr(ina->x_host.c_host,ifp->if_unit); ! 769: break; ! 770: } ! 771: #endif ! 772: } ! 773: break; ! 774: ! 775: case SIOCSIFFLAGS: ! 776: if ((ifp->if_flags & IFF_UP) == 0 && ! 777: ds->ds_flags & DSF_RUNNING) { ! 778: ((struct dedevice *) ! 779: (deinfo[ifp->if_unit]->ui_addr))->pclow = 0; ! 780: DELAY(100); ! 781: ((struct dedevice *) ! 782: (deinfo[ifp->if_unit]->ui_addr))->pclow = PCSR0_RSET; ! 783: ds->ds_flags &= ~(DSF_LOCK | DSF_RUNNING); ! 784: } else if (ifp->if_flags & IFF_UP && ! 785: (ds->ds_flags & DSF_RUNNING) == 0) ! 786: deinit(ifp->if_unit); ! 787: break; ! 788: ! 789: default: ! 790: error = EINVAL; ! 791: } ! 792: splx(s); ! 793: return (error); ! 794: } ! 795: ! 796: /* ! 797: * set ethernet address for unit ! 798: */ ! 799: de_setaddr(physaddr, unit) ! 800: u_char *physaddr; ! 801: int unit; ! 802: { ! 803: register struct de_softc *ds = &de_softc[unit]; ! 804: struct uba_device *ui = deinfo[unit]; ! 805: register struct dedevice *addr= (struct dedevice *)ui->ui_addr; ! 806: ! 807: if (! (ds->ds_flags & DSF_RUNNING)) ! 808: return; ! 809: ! 810: bcopy((caddr_t) physaddr, (caddr_t) &ds->ds_pcbb.pcbb2, 6); ! 811: ds->ds_pcbb.pcbb0 = FC_WTPHYAD; ! 812: addr->pclow = PCSR0_INTE|CMD_GETCMD; ! 813: if (dewait(ui, "address change") == 0) { ! 814: ds->ds_flags |= DSF_SETADDR; ! 815: bcopy((caddr_t) physaddr, (caddr_t) ds->ds_addr, 6); ! 816: } ! 817: } ! 818: ! 819: /* ! 820: * Await completion of the named function ! 821: * and check for errors. ! 822: */ ! 823: dewait(ui, fn) ! 824: register struct uba_device *ui; ! 825: char *fn; ! 826: { ! 827: register struct dedevice *addr = (struct dedevice *)ui->ui_addr; ! 828: register csr0; ! 829: ! 830: while ((addr->pcsr0 & PCSR0_INTR) == 0) ! 831: ; ! 832: csr0 = addr->pcsr0; ! 833: addr->pchigh = csr0 >> 8; ! 834: if (csr0 & PCSR0_PCEI) ! 835: printf("de%d: %s failed, csr0=%b csr1=%b\n", ! 836: ui->ui_unit, fn, csr0, PCSR0_BITS, ! 837: addr->pcsr1, PCSR1_BITS); ! 838: return (csr0 & PCSR0_PCEI); ! 839: } ! 840: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.