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