![[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] / 43BSDReno / sys / vaxif|
Return to if_de.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxif |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1989 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution is only permitted until one year after the first shipment ! 6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 7: * binary forms are permitted provided that: (1) source distributions retain ! 8: * this entire copyright notice and comment, and (2) distributions including ! 9: * binaries display the following acknowledgement: This product includes ! 10: * software developed by the University of California, Berkeley and its ! 11: * contributors'' in the documentation or other materials provided with the ! 12: * distribution and in all advertising materials mentioning features or use ! 13: * of this software. Neither the name of the University nor the names of ! 14: * its contributors may be used to endorse or promote products derived from ! 15: * this software without specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: * ! 20: * @(#)if_de.c 7.11 (Berkeley) 6/28/90 ! 21: */ ! 22: ! 23: #include "de.h" ! 24: #if NDE > 0 ! 25: ! 26: /* ! 27: * DEC DEUNA interface ! 28: * ! 29: * Lou Salkind ! 30: * New York University ! 31: * ! 32: * TODO: ! 33: * timeout routine (get statistics) ! 34: */ ! 35: #include "machine/pte.h" ! 36: ! 37: #include "param.h" ! 38: #include "systm.h" ! 39: #include "mbuf.h" ! 40: #include "buf.h" ! 41: #include "protosw.h" ! 42: #include "socket.h" ! 43: #include "vmmac.h" ! 44: #include "ioctl.h" ! 45: #include "errno.h" ! 46: #include "syslog.h" ! 47: ! 48: #include "../net/if.h" ! 49: #include "../net/netisr.h" ! 50: #include "../net/route.h" ! 51: ! 52: #ifdef INET ! 53: #include "../netinet/in.h" ! 54: #include "../netinet/in_systm.h" ! 55: #include "../netinet/in_var.h" ! 56: #include "../netinet/ip.h" ! 57: #include "../netinet/if_ether.h" ! 58: #endif ! 59: ! 60: #ifdef NS ! 61: #include "../netns/ns.h" ! 62: #include "../netns/ns_if.h" ! 63: #endif ! 64: ! 65: #ifdef ISO ! 66: #include "../netiso/iso.h" ! 67: #include "../netiso/iso_var.h" ! 68: extern char all_es_snpa[], all_is_snpa[]; ! 69: #endif ! 70: ! 71: #include "../vax/cpu.h" ! 72: #include "../vax/mtpr.h" ! 73: #include "if_dereg.h" ! 74: #include "if_uba.h" ! 75: #include "../vaxuba/ubareg.h" ! 76: #include "../vaxuba/ubavar.h" ! 77: ! 78: #define NXMT 3 /* number of transmit buffers */ ! 79: #define NRCV 7 /* number of receive buffers (must be > 1) */ ! 80: ! 81: int dedebug = 0; ! 82: ! 83: int deprobe(), deattach(), deintr(); ! 84: struct uba_device *deinfo[NDE]; ! 85: u_short destd[] = { 0 }; ! 86: struct uba_driver dedriver = ! 87: { deprobe, 0, deattach, 0, destd, "de", deinfo }; ! 88: int deinit(),ether_output(),deioctl(),dereset(),destart(); ! 89: ! 90: ! 91: /* ! 92: * Ethernet software status per interface. ! 93: * ! 94: * Each interface is referenced by a network interface structure, ! 95: * ds_if, which the routing code uses to locate the interface. ! 96: * This structure contains the output queue for the interface, its address, ... ! 97: * We also have, for each interface, a UBA interface structure, which ! 98: * contains information about the UNIBUS resources held by the interface: ! 99: * map registers, buffered data paths, etc. Information is cached in this ! 100: * structure for use by the if_uba.c routines in running the interface ! 101: * efficiently. ! 102: */ ! 103: struct de_softc { ! 104: struct arpcom ds_ac; /* Ethernet common part */ ! 105: #define ds_if ds_ac.ac_if /* network-visible interface */ ! 106: #define ds_addr ds_ac.ac_enaddr /* hardware Ethernet address */ ! 107: int ds_flags; ! 108: #define DSF_RUNNING 2 /* board is enabled */ ! 109: #define DSF_SETADDR 4 /* physical address is changed */ ! 110: int ds_ubaddr; /* map info for incore structs */ ! 111: struct ifubinfo ds_deuba; /* unibus resource structure */ ! 112: struct ifrw ds_ifr[NRCV]; /* unibus receive maps */ ! 113: struct ifxmt ds_ifw[NXMT]; /* unibus xmt maps */ ! 114: /* the following structures are always mapped in */ ! 115: struct de_pcbb ds_pcbb; /* port control block */ ! 116: struct de_ring ds_xrent[NXMT]; /* transmit ring entrys */ ! 117: struct de_ring ds_rrent[NRCV]; /* receive ring entrys */ ! 118: struct de_udbbuf ds_udbbuf; /* UNIBUS data buffer */ ! 119: /* end mapped area */ ! 120: #define INCORE_BASE(p) ((char *)&(p)->ds_pcbb) ! 121: #define RVAL_OFF(n) ((char *)&de_softc[0].n - INCORE_BASE(&de_softc[0])) ! 122: #define LVAL_OFF(n) ((char *)de_softc[0].n - INCORE_BASE(&de_softc[0])) ! 123: #define PCBB_OFFSET RVAL_OFF(ds_pcbb) ! 124: #define XRENT_OFFSET LVAL_OFF(ds_xrent) ! 125: #define RRENT_OFFSET LVAL_OFF(ds_rrent) ! 126: #define UDBBUF_OFFSET RVAL_OFF(ds_udbbuf) ! 127: #define INCORE_SIZE RVAL_OFF(ds_xindex) ! 128: int ds_xindex; /* UNA index into transmit chain */ ! 129: int ds_rindex; /* UNA index into receive chain */ ! 130: int ds_xfree; /* index for next transmit buffer */ ! 131: int ds_nxmit; /* # of transmits in progress */ ! 132: } de_softc[NDE]; ! 133: ! 134: deprobe(reg) ! 135: caddr_t reg; ! 136: { ! 137: register int br, cvec; /* r11, r10 value-result */ ! 138: register struct dedevice *addr = (struct dedevice *)reg; ! 139: register i; ! 140: ! 141: #ifdef lint ! 142: br = 0; cvec = br; br = cvec; ! 143: i = 0; derint(i); deintr(i); ! 144: #endif ! 145: ! 146: /* ! 147: * Make sure self-test is finished before we screw with the board. ! 148: * Self-test on a DELUA can take 15 seconds (argh). ! 149: */ ! 150: for (i = 0; ! 151: i < 160 && ! 152: (addr->pcsr0 & PCSR0_FATI) == 0 && ! 153: (addr->pcsr1 & PCSR1_STMASK) == STAT_RESET; ! 154: ++i) ! 155: DELAY(100000); ! 156: if ((addr->pcsr0 & PCSR0_FATI) != 0 || ! 157: (addr->pcsr1 & PCSR1_STMASK) != STAT_READY) ! 158: return(0); ! 159: ! 160: addr->pcsr0 = 0; ! 161: DELAY(100); ! 162: addr->pcsr0 = PCSR0_RSET; ! 163: while ((addr->pcsr0 & PCSR0_INTR) == 0) ! 164: ; ! 165: /* make board interrupt by executing a GETPCBB command */ ! 166: addr->pcsr0 = PCSR0_INTE; ! 167: addr->pcsr2 = 0; ! 168: addr->pcsr3 = 0; ! 169: addr->pcsr0 = PCSR0_INTE|CMD_GETPCBB; ! 170: DELAY(100000); ! 171: return(1); ! 172: } ! 173: ! 174: /* ! 175: * Interface exists: make available by filling in network interface ! 176: * record. System will initialize the interface when it is ready ! 177: * to accept packets. We get the ethernet address here. ! 178: */ ! 179: deattach(ui) ! 180: struct uba_device *ui; ! 181: { ! 182: register struct de_softc *ds = &de_softc[ui->ui_unit]; ! 183: register struct ifnet *ifp = &ds->ds_if; ! 184: register struct dedevice *addr = (struct dedevice *)ui->ui_addr; ! 185: int csr1; ! 186: ! 187: ifp->if_unit = ui->ui_unit; ! 188: ifp->if_name = "de"; ! 189: ifp->if_mtu = ETHERMTU; ! 190: ifp->if_flags = IFF_BROADCAST; ! 191: ! 192: /* ! 193: * What kind of a board is this? ! 194: * The error bits 4-6 in pcsr1 are a device id as long as ! 195: * the high byte is zero. ! 196: */ ! 197: csr1 = addr->pcsr1; ! 198: if (csr1 & 0xff60) ! 199: printf("de%d: broken\n", ui->ui_unit); ! 200: else if (csr1 & 0x10) ! 201: printf("de%d: delua\n", ui->ui_unit); ! 202: else ! 203: printf("de%d: deuna\n", ui->ui_unit); ! 204: ! 205: /* ! 206: * Reset the board and temporarily map ! 207: * the pcbb buffer onto the Unibus. ! 208: */ ! 209: addr->pcsr0 = 0; /* reset INTE */ ! 210: DELAY(100); ! 211: addr->pcsr0 = PCSR0_RSET; ! 212: (void)dewait(ui, "reset"); ! 213: ! 214: ds->ds_ubaddr = uballoc(ui->ui_ubanum, (char *)&ds->ds_pcbb, ! 215: sizeof (struct de_pcbb), 0); ! 216: addr->pcsr2 = ds->ds_ubaddr & 0xffff; ! 217: addr->pcsr3 = (ds->ds_ubaddr >> 16) & 0x3; ! 218: addr->pclow = CMD_GETPCBB; ! 219: (void)dewait(ui, "pcbb"); ! 220: ! 221: ds->ds_pcbb.pcbb0 = FC_RDPHYAD; ! 222: addr->pclow = CMD_GETCMD; ! 223: (void)dewait(ui, "read addr "); ! 224: ! 225: ubarelse(ui->ui_ubanum, &ds->ds_ubaddr); ! 226: bcopy((caddr_t)&ds->ds_pcbb.pcbb2, (caddr_t)ds->ds_addr, ! 227: sizeof (ds->ds_addr)); ! 228: printf("de%d: hardware address %s\n", ui->ui_unit, ! 229: ether_sprintf(ds->ds_addr)); ! 230: ifp->if_init = deinit; ! 231: ifp->if_output = ether_output; ! 232: ifp->if_ioctl = deioctl; ! 233: ifp->if_reset = dereset; ! 234: ifp->if_start = destart; ! 235: ds->ds_deuba.iff_flags = UBA_CANTWAIT; ! 236: #ifdef notdef ! 237: /* CAN WE USE BDP's ??? */ ! 238: ds->ds_deuba.iff_flags |= UBA_NEEDBDP; ! 239: #endif ! 240: if_attach(ifp); ! 241: } ! 242: ! 243: /* ! 244: * Reset of interface after UNIBUS reset. ! 245: * If interface is on specified uba, reset its state. ! 246: */ ! 247: dereset(unit, uban) ! 248: int unit, uban; ! 249: { ! 250: register struct uba_device *ui; ! 251: ! 252: if (unit >= NDE || (ui = deinfo[unit]) == 0 || ui->ui_alive == 0 || ! 253: ui->ui_ubanum != uban) ! 254: return; ! 255: printf(" de%d", unit); ! 256: de_softc[unit].ds_if.if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); ! 257: de_softc[unit].ds_flags &= ~DSF_RUNNING; ! 258: ((struct dedevice *)ui->ui_addr)->pcsr0 = PCSR0_RSET; ! 259: (void)dewait(ui, "reset"); ! 260: deinit(unit); ! 261: } ! 262: ! 263: /* ! 264: * Initialization of interface; clear recorded pending ! 265: * operations, and reinitialize UNIBUS usage. ! 266: */ ! 267: deinit(unit) ! 268: int unit; ! 269: { ! 270: register struct de_softc *ds = &de_softc[unit]; ! 271: register struct uba_device *ui = deinfo[unit]; ! 272: register struct dedevice *addr; ! 273: register struct ifrw *ifrw; ! 274: register struct ifxmt *ifxp; ! 275: struct ifnet *ifp = &ds->ds_if; ! 276: int s; ! 277: struct de_ring *rp; ! 278: int incaddr; ! 279: ! 280: /* not yet, if address still unknown */ ! 281: if (ifp->if_addrlist == (struct ifaddr *)0) ! 282: return; ! 283: ! 284: if (ds->ds_flags & DSF_RUNNING) ! 285: return; ! 286: if ((ifp->if_flags & IFF_RUNNING) == 0) { ! 287: if (if_ubaminit(&ds->ds_deuba, ui->ui_ubanum, ! 288: sizeof (struct ether_header), (int)btoc(ETHERMTU), ! 289: ds->ds_ifr, NRCV, ds->ds_ifw, NXMT) == 0) { ! 290: printf("de%d: can't initialize\n", unit); ! 291: ds->ds_if.if_flags &= ~IFF_UP; ! 292: return; ! 293: } ! 294: ds->ds_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(ds), ! 295: INCORE_SIZE, 0); ! 296: } ! 297: addr = (struct dedevice *)ui->ui_addr; ! 298: ! 299: /* set the pcbb block address */ ! 300: incaddr = ds->ds_ubaddr + PCBB_OFFSET; ! 301: addr->pcsr2 = incaddr & 0xffff; ! 302: addr->pcsr3 = (incaddr >> 16) & 0x3; ! 303: addr->pclow = 0; /* reset INTE */ ! 304: DELAY(100); ! 305: addr->pclow = CMD_GETPCBB; ! 306: (void)dewait(ui, "pcbb"); ! 307: ! 308: /* set the transmit and receive ring header addresses */ ! 309: incaddr = ds->ds_ubaddr + UDBBUF_OFFSET; ! 310: ds->ds_pcbb.pcbb0 = FC_WTRING; ! 311: ds->ds_pcbb.pcbb2 = incaddr & 0xffff; ! 312: ds->ds_pcbb.pcbb4 = (incaddr >> 16) & 0x3; ! 313: ! 314: incaddr = ds->ds_ubaddr + XRENT_OFFSET; ! 315: ds->ds_udbbuf.b_tdrbl = incaddr & 0xffff; ! 316: ds->ds_udbbuf.b_tdrbh = (incaddr >> 16) & 0x3; ! 317: ds->ds_udbbuf.b_telen = sizeof (struct de_ring) / sizeof (short); ! 318: ds->ds_udbbuf.b_trlen = NXMT; ! 319: incaddr = ds->ds_ubaddr + RRENT_OFFSET; ! 320: ds->ds_udbbuf.b_rdrbl = incaddr & 0xffff; ! 321: ds->ds_udbbuf.b_rdrbh = (incaddr >> 16) & 0x3; ! 322: ds->ds_udbbuf.b_relen = sizeof (struct de_ring) / sizeof (short); ! 323: ds->ds_udbbuf.b_rrlen = NRCV; ! 324: ! 325: addr->pclow = CMD_GETCMD; ! 326: (void)dewait(ui, "wtring"); ! 327: ! 328: /* initialize the mode - enable hardware padding */ ! 329: ds->ds_pcbb.pcbb0 = FC_WTMODE; ! 330: /* let hardware do padding - set MTCH bit on broadcast */ ! 331: ds->ds_pcbb.pcbb2 = MOD_TPAD|MOD_HDX; ! 332: addr->pclow = CMD_GETCMD; ! 333: (void)dewait(ui, "wtmode"); ! 334: ! 335: /* set up the receive and transmit ring entries */ ! 336: ifxp = &ds->ds_ifw[0]; ! 337: for (rp = &ds->ds_xrent[0]; rp < &ds->ds_xrent[NXMT]; rp++) { ! 338: rp->r_segbl = ifxp->ifw_info & 0xffff; ! 339: rp->r_segbh = (ifxp->ifw_info >> 16) & 0x3; ! 340: rp->r_flags = 0; ! 341: ifxp++; ! 342: } ! 343: ifrw = &ds->ds_ifr[0]; ! 344: for (rp = &ds->ds_rrent[0]; rp < &ds->ds_rrent[NRCV]; rp++) { ! 345: rp->r_slen = sizeof (struct de_buf); ! 346: rp->r_segbl = ifrw->ifrw_info & 0xffff; ! 347: rp->r_segbh = (ifrw->ifrw_info >> 16) & 0x3; ! 348: rp->r_flags = RFLG_OWN; /* hang receive */ ! 349: ifrw++; ! 350: } ! 351: ! 352: /* start up the board (rah rah) */ ! 353: s = splimp(); ! 354: ds->ds_rindex = ds->ds_xindex = ds->ds_xfree = ds->ds_nxmit = 0; ! 355: ds->ds_if.if_flags |= IFF_RUNNING; ! 356: addr->pclow = PCSR0_INTE; /* avoid interlock */ ! 357: destart(&ds->ds_if); /* queue output packets */ ! 358: ds->ds_flags |= DSF_RUNNING; /* need before de_setaddr */ ! 359: if (ds->ds_flags & DSF_SETADDR) ! 360: de_setaddr(ds->ds_addr, unit); ! 361: addr->pclow = CMD_START | PCSR0_INTE; ! 362: splx(s); ! 363: } ! 364: ! 365: /* ! 366: * Setup output on interface. ! 367: * Get another datagram to send off of the interface queue, ! 368: * and map it to the interface before starting the output. ! 369: * Must be called from ipl >= our interrupt level. ! 370: */ ! 371: destart(ifp) ! 372: struct ifnet *ifp; ! 373: { ! 374: int len; ! 375: int unit = ifp->if_unit; ! 376: struct uba_device *ui = deinfo[unit]; ! 377: struct dedevice *addr = (struct dedevice *)ui->ui_addr; ! 378: register struct de_softc *ds = &de_softc[unit]; ! 379: register struct de_ring *rp; ! 380: struct mbuf *m; ! 381: register int nxmit; ! 382: ! 383: /* ! 384: * the following test is necessary, since ! 385: * the code is not reentrant and we have ! 386: * multiple transmission buffers. ! 387: */ ! 388: if (ds->ds_if.if_flags & IFF_OACTIVE) ! 389: return; ! 390: for (nxmit = ds->ds_nxmit; nxmit < NXMT; nxmit++) { ! 391: IF_DEQUEUE(&ds->ds_if.if_snd, m); ! 392: if (m == 0) ! 393: break; ! 394: rp = &ds->ds_xrent[ds->ds_xfree]; ! 395: if (rp->r_flags & XFLG_OWN) ! 396: panic("deuna xmit in progress"); ! 397: len = if_ubaput(&ds->ds_deuba, &ds->ds_ifw[ds->ds_xfree], m); ! 398: if (ds->ds_deuba.iff_flags & UBA_NEEDBDP) ! 399: UBAPURGE(ds->ds_deuba.iff_uba, ! 400: ds->ds_ifw[ds->ds_xfree].ifw_bdp); ! 401: rp->r_slen = len; ! 402: rp->r_tdrerr = 0; ! 403: rp->r_flags = XFLG_STP|XFLG_ENP|XFLG_OWN; ! 404: ! 405: ds->ds_xfree++; ! 406: if (ds->ds_xfree == NXMT) ! 407: ds->ds_xfree = 0; ! 408: } ! 409: if (ds->ds_nxmit != nxmit) { ! 410: ds->ds_nxmit = nxmit; ! 411: if (ds->ds_flags & DSF_RUNNING) ! 412: addr->pclow = PCSR0_INTE|CMD_PDMD; ! 413: } ! 414: } ! 415: ! 416: /* ! 417: * Command done interrupt. ! 418: */ ! 419: deintr(unit) ! 420: int unit; ! 421: { ! 422: struct uba_device *ui = deinfo[unit]; ! 423: register struct dedevice *addr = (struct dedevice *)ui->ui_addr; ! 424: register struct de_softc *ds = &de_softc[unit]; ! 425: register struct de_ring *rp; ! 426: register struct ifxmt *ifxp; ! 427: short csr0; ! 428: ! 429: /* save flags right away - clear out interrupt bits */ ! 430: csr0 = addr->pcsr0; ! 431: addr->pchigh = csr0 >> 8; ! 432: ! 433: ! 434: ds->ds_if.if_flags |= IFF_OACTIVE; /* prevent entering destart */ ! 435: /* ! 436: * if receive, put receive buffer on mbuf ! 437: * and hang the request again ! 438: */ ! 439: derecv(unit); ! 440: ! 441: /* ! 442: * Poll transmit ring and check status. ! 443: * Be careful about loopback requests. ! 444: * Then free buffer space and check for ! 445: * more transmit requests. ! 446: */ ! 447: for ( ; ds->ds_nxmit > 0; ds->ds_nxmit--) { ! 448: rp = &ds->ds_xrent[ds->ds_xindex]; ! 449: if (rp->r_flags & XFLG_OWN) ! 450: break; ! 451: ds->ds_if.if_opackets++; ! 452: ifxp = &ds->ds_ifw[ds->ds_xindex]; ! 453: /* check for unusual conditions */ ! 454: if (rp->r_flags & (XFLG_ERRS|XFLG_MTCH|XFLG_ONE|XFLG_MORE)) { ! 455: if (rp->r_flags & XFLG_ERRS) { ! 456: /* output error */ ! 457: ds->ds_if.if_oerrors++; ! 458: if (dedebug) ! 459: printf("de%d: oerror, flags=%b tdrerr=%b (len=%d)\n", ! 460: unit, rp->r_flags, XFLG_BITS, ! 461: rp->r_tdrerr, XERR_BITS, rp->r_slen); ! 462: } else if (rp->r_flags & XFLG_ONE) { ! 463: /* one collision */ ! 464: ds->ds_if.if_collisions++; ! 465: } else if (rp->r_flags & XFLG_MORE) { ! 466: /* more than one collision */ ! 467: ds->ds_if.if_collisions += 2; /* guess */ ! 468: } else if (rp->r_flags & XFLG_MTCH) { ! 469: /* received our own packet */ ! 470: ds->ds_if.if_ipackets++; ! 471: deread(ds, &ifxp->ifrw, ! 472: rp->r_slen - sizeof (struct ether_header)); ! 473: } ! 474: } ! 475: if (ifxp->ifw_xtofree) { ! 476: m_freem(ifxp->ifw_xtofree); ! 477: ifxp->ifw_xtofree = 0; ! 478: } ! 479: /* check if next transmit buffer also finished */ ! 480: ds->ds_xindex++; ! 481: if (ds->ds_xindex == NXMT) ! 482: ds->ds_xindex = 0; ! 483: } ! 484: ds->ds_if.if_flags &= ~IFF_OACTIVE; ! 485: destart(&ds->ds_if); ! 486: ! 487: if (csr0 & PCSR0_RCBI) { ! 488: if (dedebug) ! 489: log(LOG_WARNING, "de%d: buffer unavailable\n", unit); ! 490: addr->pclow = PCSR0_INTE|CMD_PDMD; ! 491: } ! 492: } ! 493: ! 494: /* ! 495: * Ethernet interface receiver interface. ! 496: * If input error just drop packet. ! 497: * Otherwise purge input buffered data path and examine ! 498: * packet to determine type. If can't determine length ! 499: * from type, then have to drop packet. Othewise decapsulate ! 500: * packet based on type and pass to type specific higher-level ! 501: * input routine. ! 502: */ ! 503: derecv(unit) ! 504: int unit; ! 505: { ! 506: register struct de_softc *ds = &de_softc[unit]; ! 507: register struct de_ring *rp; ! 508: int len; ! 509: ! 510: rp = &ds->ds_rrent[ds->ds_rindex]; ! 511: while ((rp->r_flags & RFLG_OWN) == 0) { ! 512: ds->ds_if.if_ipackets++; ! 513: if (ds->ds_deuba.iff_flags & UBA_NEEDBDP) ! 514: UBAPURGE(ds->ds_deuba.iff_uba, ! 515: ds->ds_ifr[ds->ds_rindex].ifrw_bdp); ! 516: len = (rp->r_lenerr&RERR_MLEN) - sizeof (struct ether_header) ! 517: - 4; /* don't forget checksum! */ ! 518: /* check for errors */ ! 519: if ((rp->r_flags & (RFLG_ERRS|RFLG_FRAM|RFLG_OFLO|RFLG_CRC)) || ! 520: (rp->r_flags&(RFLG_STP|RFLG_ENP)) != (RFLG_STP|RFLG_ENP) || ! 521: (rp->r_lenerr & (RERR_BUFL|RERR_UBTO|RERR_NCHN)) || ! 522: len < ETHERMIN || len > ETHERMTU) { ! 523: ds->ds_if.if_ierrors++; ! 524: if (dedebug) ! 525: printf("de%d: ierror, flags=%b lenerr=%b (len=%d)\n", ! 526: unit, rp->r_flags, RFLG_BITS, rp->r_lenerr, ! 527: RERR_BITS, len); ! 528: } else ! 529: deread(ds, &ds->ds_ifr[ds->ds_rindex], len); ! 530: ! 531: /* hang the receive buffer again */ ! 532: rp->r_lenerr = 0; ! 533: rp->r_flags = RFLG_OWN; ! 534: ! 535: /* check next receive buffer */ ! 536: ds->ds_rindex++; ! 537: if (ds->ds_rindex == NRCV) ! 538: ds->ds_rindex = 0; ! 539: rp = &ds->ds_rrent[ds->ds_rindex]; ! 540: } ! 541: } ! 542: ! 543: /* ! 544: * Pass a packet to the higher levels. ! 545: * We deal with the trailer protocol here. ! 546: */ ! 547: deread(ds, ifrw, len) ! 548: register struct de_softc *ds; ! 549: struct ifrw *ifrw; ! 550: int len; ! 551: { ! 552: struct ether_header *eh; ! 553: struct mbuf *m; ! 554: int off, resid; ! 555: int s; ! 556: register struct ifqueue *inq; ! 557: ! 558: /* ! 559: * Deal with trailer protocol: if type is trailer type ! 560: * get true type from first 16-bit word past data. ! 561: * Remember that type was trailer by setting off. ! 562: */ ! 563: eh = (struct ether_header *)ifrw->ifrw_addr; ! 564: eh->ether_type = ntohs((u_short)eh->ether_type); ! 565: #define dedataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off)))) ! 566: if (eh->ether_type >= ETHERTYPE_TRAIL && ! 567: eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) { ! 568: off = (eh->ether_type - ETHERTYPE_TRAIL) * 512; ! 569: if (off >= ETHERMTU) ! 570: return; /* sanity */ ! 571: eh->ether_type = ntohs(*dedataaddr(eh, off, u_short *)); ! 572: resid = ntohs(*(dedataaddr(eh, off+2, u_short *))); ! 573: if (off + resid > len) ! 574: return; /* sanity */ ! 575: len = off + resid; ! 576: } else ! 577: off = 0; ! 578: if (len == 0) ! 579: return; ! 580: ! 581: /* ! 582: * Pull packet off interface. Off is nonzero if packet ! 583: * has trailing header; if_ubaget will then force this header ! 584: * information to be at the front. ! 585: */ ! 586: m = if_ubaget(&ds->ds_deuba, ifrw, len, off, &ds->ds_if); ! 587: if (m) ! 588: ether_input(&ds->ds_if, eh, m); ! 589: } ! 590: /* ! 591: * Process an ioctl request. ! 592: */ ! 593: deioctl(ifp, cmd, data) ! 594: register struct ifnet *ifp; ! 595: int cmd; ! 596: caddr_t data; ! 597: { ! 598: register struct ifaddr *ifa = (struct ifaddr *)data; ! 599: register struct de_softc *ds = &de_softc[ifp->if_unit]; ! 600: int s = splimp(), error = 0; ! 601: ! 602: switch (cmd) { ! 603: ! 604: case SIOCSIFADDR: ! 605: ifp->if_flags |= IFF_UP; ! 606: deinit(ifp->if_unit); ! 607: ! 608: switch (ifa->ifa_addr->sa_family) { ! 609: #ifdef INET ! 610: case AF_INET: ! 611: ((struct arpcom *)ifp)->ac_ipaddr = ! 612: IA_SIN(ifa)->sin_addr; ! 613: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr); ! 614: break; ! 615: #endif ! 616: #ifdef NS ! 617: case AF_NS: ! 618: { ! 619: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr); ! 620: ! 621: if (ns_nullhost(*ina)) ! 622: ina->x_host = *(union ns_host *)(ds->ds_addr); ! 623: else ! 624: de_setaddr(ina->x_host.c_host,ifp->if_unit); ! 625: break; ! 626: } ! 627: #endif ! 628: } ! 629: break; ! 630: ! 631: case SIOCSIFFLAGS: ! 632: if ((ifp->if_flags & IFF_UP) == 0 && ! 633: ds->ds_flags & DSF_RUNNING) { ! 634: ((struct dedevice *) ! 635: (deinfo[ifp->if_unit]->ui_addr))->pclow = 0; ! 636: DELAY(100); ! 637: ((struct dedevice *) ! 638: (deinfo[ifp->if_unit]->ui_addr))->pclow = PCSR0_RSET; ! 639: ds->ds_flags &= ~DSF_RUNNING; ! 640: ds->ds_if.if_flags &= ~IFF_OACTIVE; ! 641: } else if (ifp->if_flags & IFF_UP && ! 642: (ds->ds_flags & DSF_RUNNING) == 0) ! 643: deinit(ifp->if_unit); ! 644: break; ! 645: ! 646: default: ! 647: error = EINVAL; ! 648: } ! 649: splx(s); ! 650: return (error); ! 651: } ! 652: ! 653: /* ! 654: * set ethernet address for unit ! 655: */ ! 656: de_setaddr(physaddr, unit) ! 657: u_char *physaddr; ! 658: int unit; ! 659: { ! 660: register struct de_softc *ds = &de_softc[unit]; ! 661: struct uba_device *ui = deinfo[unit]; ! 662: register struct dedevice *addr= (struct dedevice *)ui->ui_addr; ! 663: ! 664: if (! (ds->ds_flags & DSF_RUNNING)) ! 665: return; ! 666: ! 667: bcopy((caddr_t) physaddr, (caddr_t) &ds->ds_pcbb.pcbb2, 6); ! 668: ds->ds_pcbb.pcbb0 = FC_WTPHYAD; ! 669: addr->pclow = PCSR0_INTE|CMD_GETCMD; ! 670: if (dewait(ui, "address change") == 0) { ! 671: ds->ds_flags |= DSF_SETADDR; ! 672: bcopy((caddr_t) physaddr, (caddr_t) ds->ds_addr, 6); ! 673: } ! 674: } ! 675: ! 676: /* ! 677: * Await completion of the named function ! 678: * and check for errors. ! 679: */ ! 680: dewait(ui, fn) ! 681: register struct uba_device *ui; ! 682: char *fn; ! 683: { ! 684: register struct dedevice *addr = (struct dedevice *)ui->ui_addr; ! 685: register csr0; ! 686: ! 687: while ((addr->pcsr0 & PCSR0_INTR) == 0) ! 688: ; ! 689: csr0 = addr->pcsr0; ! 690: addr->pchigh = csr0 >> 8; ! 691: if (csr0 & PCSR0_PCEI) ! 692: printf("de%d: %s failed, csr0=%b csr1=%b\n", ! 693: ui->ui_unit, fn, csr0, PCSR0_BITS, ! 694: addr->pcsr1, PCSR1_BITS); ! 695: return (csr0 & PCSR0_PCEI); ! 696: } ! 697: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.