![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ne.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / isa|
Return to if_ne.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1990, 1991 William F. Jolitz. ! 3: * Copyright (c) 1990 The Regents of the University of California. ! 4: * All rights reserved. ! 5: * ! 6: * Redistribution and use in source and binary forms, with or without ! 7: * modification, are permitted provided that the following conditions ! 8: * are met: ! 9: * 1. Redistributions of source code must retain the above copyright ! 10: * notice, this list of conditions and the following disclaimer. ! 11: * 2. Redistributions in binary form must reproduce the above copyright ! 12: * notice, this list of conditions and the following disclaimer in the ! 13: * documentation and/or other materials provided with the distribution. ! 14: * 3. All advertising materials mentioning features or use of this software ! 15: * must display the following acknowledgement: ! 16: * This product includes software developed by the University of ! 17: * California, Berkeley and its contributors. ! 18: * 4. Neither the name of the University nor the names of its contributors ! 19: * may be used to endorse or promote products derived from this software ! 20: * without specific prior written permission. ! 21: * ! 22: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 32: * SUCH DAMAGE. ! 33: * ! 34: * @(#)if_ne.c 7.4 (Berkeley) 5/21/91 ! 35: */ ! 36: ! 37: /* ! 38: * NE2000 Ethernet driver ! 39: * ! 40: * Parts inspired from Tim Tucker's if_wd driver for the wd8003, ! 41: * insight on the ne2000 gained from Robert Clements PC/FTP driver. ! 42: */ ! 43: ! 44: #include "ne.h" ! 45: #if NNE > 0 ! 46: ! 47: #include "param.h" ! 48: #include "systm.h" ! 49: #include "mbuf.h" ! 50: #include "buf.h" ! 51: #include "protosw.h" ! 52: #include "socket.h" ! 53: #include "ioctl.h" ! 54: #include "errno.h" ! 55: #include "syslog.h" ! 56: ! 57: #include "net/if.h" ! 58: #include "net/netisr.h" ! 59: #include "net/route.h" ! 60: ! 61: #ifdef INET ! 62: #include "netinet/in.h" ! 63: #include "netinet/in_systm.h" ! 64: #include "netinet/in_var.h" ! 65: #include "netinet/ip.h" ! 66: #include "netinet/if_ether.h" ! 67: #endif ! 68: ! 69: #ifdef NS ! 70: #include "netns/ns.h" ! 71: #include "netns/ns_if.h" ! 72: #endif ! 73: ! 74: #include "i386/isa/isa_device.h" ! 75: #include "i386/isa/if_nereg.h" ! 76: #include "i386/isa/icu.h" ! 77: ! 78: int neprobe(), neattach(), neintr(); ! 79: int nestart(),neinit(), ether_output(), neioctl(); ! 80: ! 81: struct isa_driver nedriver = { ! 82: neprobe, neattach, "ne", ! 83: }; ! 84: ! 85: struct mbuf *neget(); ! 86: ! 87: #define ETHER_MIN_LEN 64 ! 88: #define ETHER_MAX_LEN 1536 ! 89: ! 90: /* ! 91: * Ethernet software status per interface. ! 92: * ! 93: * Each interface is referenced by a network interface structure, ! 94: * ns_if, which the routing code uses to locate the interface. ! 95: * This structure contains the output queue for the interface, its address, ... ! 96: */ ! 97: struct ne_softc { ! 98: struct arpcom ns_ac; /* Ethernet common part */ ! 99: #define ns_if ns_ac.ac_if /* network-visible interface */ ! 100: #define ns_addr ns_ac.ac_enaddr /* hardware Ethernet address */ ! 101: int ns_flags; ! 102: #define DSF_LOCK 1 /* block re-entering enstart */ ! 103: int ns_oactive ; ! 104: int ns_mask ; ! 105: int ns_ba; /* byte addr in buffer ram of inc pkt */ ! 106: int ns_cur; /* current page being filled */ ! 107: struct prhdr ns_ph; /* hardware header of incoming packet*/ ! 108: struct ether_header ns_eh; /* header of incoming packet */ ! 109: u_char ns_pb[2048 /*ETHERMTU+sizeof(long)*/]; ! 110: } ne_softc[NNE] ; ! 111: #define ENBUFSIZE (sizeof(struct ether_header) + ETHERMTU + 2 + ETHER_MIN_LEN) ! 112: ! 113: int nec; ! 114: ! 115: u_short boarddata[16]; ! 116: ! 117: neprobe(dvp) ! 118: struct isa_device *dvp; ! 119: { ! 120: int val,i,s; ! 121: register struct ne_softc *ns = &ne_softc[0]; ! 122: ! 123: #ifdef lint ! 124: neintr(0); ! 125: #endif ! 126: ! 127: nec = dvp->id_iobase; ! 128: s = splimp(); ! 129: ! 130: /* Reset the bastard */ ! 131: val = inb(nec+ne_reset); ! 132: DELAY(2000000); ! 133: outb(nec+ne_reset,val); ! 134: ! 135: outb(nec+ds_cmd, DSCM_STOP|DSCM_NODMA); ! 136: ! 137: i = 1000000; ! 138: while ((inb(nec+ds0_isr)&DSIS_RESET) == 0 && i-- > 0); ! 139: if (i < 0) return (0); ! 140: ! 141: outb(nec+ds0_isr, 0xff); ! 142: ! 143: /* Word Transfers, Burst Mode Select, Fifo at 8 bytes */ ! 144: outb(nec+ds0_dcr, DSDC_WTS|DSDC_BMS|DSDC_FT1); ! 145: ! 146: outb(nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP); ! 147: DELAY(10000); ! 148: ! 149: /* Check cmd reg and fail if not right */ ! 150: if ((i=inb(nec+ds_cmd)) != (DSCM_NODMA|DSCM_PG0|DSCM_STOP)) ! 151: return(0); ! 152: ! 153: outb(nec+ds0_tcr, 0); ! 154: outb(nec+ds0_rcr, DSRC_MON); ! 155: outb(nec+ds0_pstart, RBUF/DS_PGSIZE); ! 156: outb(nec+ds0_pstop, RBUFEND/DS_PGSIZE); ! 157: outb(nec+ds0_bnry, RBUFEND/DS_PGSIZE); ! 158: outb(nec+ds0_imr, 0); ! 159: outb(nec+ds0_isr, 0); ! 160: outb(nec+ds_cmd, DSCM_NODMA|DSCM_PG1|DSCM_STOP); ! 161: outb(nec+ds1_curr, RBUF/DS_PGSIZE); ! 162: outb(nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP); ! 163: ! 164: #ifdef NEDEBUG ! 165: #define PAT(n) (0xa55a + 37*(n)) ! 166: #define RCON 37 ! 167: { int i, rom, pat; ! 168: ! 169: rom=1; ! 170: printf("ne ram "); ! 171: ! 172: for (i = 0; i < 0xfff0; i+=4) { ! 173: pat = PAT(i); ! 174: neput(&pat,i,4); ! 175: nefetch(&pat,i,4); ! 176: if (pat == PAT(i)) { ! 177: if (rom) { ! 178: rom=0; ! 179: printf(" %x", i); ! 180: } ! 181: } else { ! 182: if (!rom) { ! 183: rom=1; ! 184: printf("..%x ", i); ! 185: } ! 186: } ! 187: pat=0; ! 188: neput(&pat,i,4); ! 189: } ! 190: printf("\n"); ! 191: } ! 192: #endif ! 193: ! 194: /* Extract board address */ ! 195: nefetch ((caddr_t)boarddata, 0, sizeof(boarddata)); ! 196: for(i=0; i < 6; i++) ns->ns_addr[i] = boarddata[i]; ! 197: splx(s); ! 198: return (1); ! 199: } ! 200: ! 201: /* ! 202: * Fetch from onboard ROM/RAM ! 203: */ ! 204: nefetch (up, ad, len) caddr_t up; { ! 205: u_char cmd; ! 206: ! 207: cmd = inb(nec+ds_cmd); ! 208: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_START); ! 209: ! 210: /* Setup remote dma */ ! 211: outb (nec+ds0_isr, DSIS_RDC); ! 212: outb (nec+ds0_rbcr0, len); ! 213: outb (nec+ds0_rbcr1, len>>8); ! 214: outb (nec+ds0_rsar0, ad); ! 215: outb (nec+ds0_rsar1, ad>>8); ! 216: ! 217: /* Execute & extract from card */ ! 218: outb (nec+ds_cmd, DSCM_RREAD|DSCM_PG0|DSCM_START); ! 219: insw (nec+ne_data, up, len/2); ! 220: ! 221: /* Wait till done, then shutdown feature */ ! 222: while ((inb (nec+ds0_isr) & DSIS_RDC) == 0) ; ! 223: outb (nec+ds0_isr, DSIS_RDC); ! 224: outb (nec+ds_cmd, cmd); ! 225: } ! 226: ! 227: /* ! 228: * Put to onboard RAM ! 229: */ ! 230: neput (up, ad, len) caddr_t up; { ! 231: u_char cmd; ! 232: ! 233: cmd = inb(nec+ds_cmd); ! 234: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_START); ! 235: ! 236: /* Setup for remote dma */ ! 237: outb (nec+ds0_isr, DSIS_RDC); ! 238: if(len&1) len++; /* roundup to words */ ! 239: outb (nec+ds0_rbcr0, len); ! 240: outb (nec+ds0_rbcr1, len>>8); ! 241: outb (nec+ds0_rsar0, ad); ! 242: outb (nec+ds0_rsar1, ad>>8); ! 243: ! 244: /* Execute & stuff to card */ ! 245: outb (nec+ds_cmd, DSCM_RWRITE|DSCM_PG0|DSCM_START); ! 246: outsw (nec+ne_data, up, len/2); ! 247: ! 248: /* Wait till done, then shutdown feature */ ! 249: while ((inb (nec+ds0_isr) & DSIS_RDC) == 0) ; ! 250: outb (nec+ds0_isr, DSIS_RDC); ! 251: outb (nec+ds_cmd, cmd); ! 252: } ! 253: ! 254: /* ! 255: * Reset of interface. ! 256: */ ! 257: nereset(unit, uban) ! 258: int unit, uban; ! 259: { ! 260: if (unit >= NNE) ! 261: return; ! 262: printf("ne%d: reset\n", unit); ! 263: ne_softc[unit].ns_flags &= ~DSF_LOCK; ! 264: neinit(unit); ! 265: } ! 266: ! 267: /* ! 268: * Interface exists: make available by filling in network interface ! 269: * record. System will initialize the interface when it is ready ! 270: * to accept packets. We get the ethernet address here. ! 271: */ ! 272: neattach(dvp) ! 273: struct isa_device *dvp; ! 274: { ! 275: int unit = dvp->id_unit; ! 276: register struct ne_softc *ns = &ne_softc[unit]; ! 277: register struct ifnet *ifp = &ns->ns_if; ! 278: ! 279: ifp->if_unit = unit; ! 280: ifp->if_name = nedriver.name ; ! 281: ifp->if_mtu = ETHERMTU; ! 282: printf (" ethernet address %s", ether_sprintf(ns->ns_addr)) ; ! 283: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS; ! 284: ifp->if_init = neinit; ! 285: ifp->if_output = ether_output; ! 286: ifp->if_start = nestart; ! 287: ifp->if_ioctl = neioctl; ! 288: ifp->if_reset = nereset; ! 289: ifp->if_watchdog = 0; ! 290: if_attach(ifp); ! 291: } ! 292: ! 293: /* ! 294: * Initialization of interface; set up initialization block ! 295: * and transmit/receive descriptor rings. ! 296: */ ! 297: neinit(unit) ! 298: int unit; ! 299: { ! 300: register struct ne_softc *ns = &ne_softc[unit]; ! 301: struct ifnet *ifp = &ns->ns_if; ! 302: int s; ! 303: register i; char *cp; ! 304: ! 305: if (ifp->if_addrlist == (struct ifaddr *)0) return; ! 306: if (ifp->if_flags & IFF_RUNNING) return; ! 307: ! 308: s = splimp(); ! 309: ! 310: /* set physical address on ethernet */ ! 311: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG1|DSCM_STOP); ! 312: for (i=0 ; i < 6 ; i++) outb(nec+ds1_par0+i,ns->ns_addr[i]); ! 313: ! 314: /* clr logical address hash filter for now */ ! 315: for (i=0 ; i < 8 ; i++) outb(nec+ds1_mar0+i,0xff); ! 316: ! 317: /* init regs */ ! 318: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP); ! 319: outb (nec+ds0_rbcr0, 0); ! 320: outb (nec+ds0_rbcr1, 0); ! 321: outb (nec+ds0_imr, 0); ! 322: outb (nec+ds0_isr, 0xff); ! 323: ! 324: /* Word Transfers, Burst Mode Select, Fifo at 8 bytes */ ! 325: outb(nec+ds0_dcr, DSDC_WTS|DSDC_BMS|DSDC_FT1); ! 326: outb(nec+ds0_tcr, 0); ! 327: outb (nec+ds0_rcr, DSRC_MON); ! 328: outb (nec+ds0_tpsr, 0); ! 329: outb(nec+ds0_pstart, RBUF/DS_PGSIZE); ! 330: outb(nec+ds0_pstop, RBUFEND/DS_PGSIZE); ! 331: outb(nec+ds0_bnry, RBUF/DS_PGSIZE); ! 332: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG1|DSCM_STOP); ! 333: outb(nec+ds1_curr, RBUF/DS_PGSIZE); ! 334: ns->ns_cur = RBUF/DS_PGSIZE; ! 335: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_START); ! 336: outb (nec+ds0_rcr, DSRC_AB); ! 337: outb(nec+ds0_dcr, DSDC_WTS|DSDC_BMS|DSDC_FT1); ! 338: outb (nec+ds0_imr, 0xff); ! 339: ! 340: ns->ns_if.if_flags |= IFF_RUNNING; ! 341: ns->ns_oactive = 0; ns->ns_mask = ~0; ! 342: nestart(ifp); ! 343: splx(s); ! 344: } ! 345: ! 346: /* ! 347: * Setup output on interface. ! 348: * Get another datagram to send off of the interface queue, ! 349: * and map it to the interface before starting the output. ! 350: * called only at splimp or interrupt level. ! 351: */ ! 352: nestart(ifp) ! 353: struct ifnet *ifp; ! 354: { ! 355: register struct ne_softc *ns = &ne_softc[ifp->if_unit]; ! 356: struct mbuf *m0, *m; ! 357: int buffer; ! 358: int len = 0, i, total,t; ! 359: ! 360: /* ! 361: * The DS8390 has only one transmit buffer, if it is busy we ! 362: * must wait until the transmit interrupt completes. ! 363: */ ! 364: outb(nec+ds_cmd,DSCM_NODMA|DSCM_START); ! 365: ! 366: if (ns->ns_flags & DSF_LOCK) ! 367: return; ! 368: ! 369: if (inb(nec+ds_cmd) & DSCM_TRANS) ! 370: return; ! 371: ! 372: if ((ns->ns_if.if_flags & IFF_RUNNING) == 0) ! 373: return; ! 374: ! 375: IF_DEQUEUE(&ns->ns_if.if_snd, m); ! 376: ! 377: if (m == 0) ! 378: return; ! 379: ! 380: /* ! 381: * Copy the mbuf chain into the transmit buffer ! 382: */ ! 383: ! 384: ns->ns_flags |= DSF_LOCK; /* prevent entering nestart */ ! 385: buffer = TBUF; len = i = 0; ! 386: t = 0; ! 387: for (m0 = m; m != 0; m = m->m_next) ! 388: t += m->m_len; ! 389: ! 390: m = m0; ! 391: total = t; ! 392: for (m0 = m; m != 0; ) { ! 393: ! 394: if (m->m_len&1 && t > m->m_len) { ! 395: neput(mtod(m, caddr_t), buffer, m->m_len - 1); ! 396: t -= m->m_len - 1; ! 397: buffer += m->m_len - 1; ! 398: m->m_data += m->m_len - 1; ! 399: m->m_len = 1; ! 400: m = m_pullup(m, 2); ! 401: } else { ! 402: neput(mtod(m, caddr_t), buffer, m->m_len); ! 403: buffer += m->m_len; ! 404: t -= m->m_len; ! 405: MFREE(m, m0); ! 406: m = m0; ! 407: } ! 408: } ! 409: ! 410: /* ! 411: * Init transmit length registers, and set transmit start flag. ! 412: */ ! 413: ! 414: len = total; ! 415: if (len < ETHER_MIN_LEN) len = ETHER_MIN_LEN; ! 416: outb(nec+ds0_tbcr0,len&0xff); ! 417: outb(nec+ds0_tbcr1,(len>>8)&0xff); ! 418: outb(nec+ds0_tpsr, TBUF/DS_PGSIZE); ! 419: outb(nec+ds_cmd, DSCM_TRANS|DSCM_NODMA|DSCM_START); ! 420: } ! 421: ! 422: /* buffer successor/predecessor in ring? */ ! 423: #define succ(n) (((n)+1 >= RBUFEND/DS_PGSIZE) ? RBUF/DS_PGSIZE : (n)+1) ! 424: #define pred(n) (((n)-1 < RBUF/DS_PGSIZE) ? RBUFEND/DS_PGSIZE-1 : (n)-1) ! 425: ! 426: /* ! 427: * Controller interrupt. ! 428: */ ! 429: neintr(unit) ! 430: { ! 431: register struct ne_softc *ns = &ne_softc[unit]; ! 432: u_char cmd,isr; ! 433: ! 434: /* Save cmd, clear interrupt */ ! 435: cmd = inb (nec+ds_cmd); ! 436: loop: ! 437: isr = inb (nec+ds0_isr); ! 438: outb(nec+ds_cmd,DSCM_NODMA|DSCM_START); ! 439: outb(nec+ds0_isr, isr); ! 440: ! 441: /* Receiver error */ ! 442: if (isr & DSIS_RXE) { ! 443: /* need to read these registers to clear status */ ! 444: (void) inb(nec+ ds0_rsr); ! 445: (void) inb(nec+ 0xD); ! 446: (void) inb(nec + 0xE); ! 447: (void) inb(nec + 0xF); ! 448: ns->ns_if.if_ierrors++; ! 449: } ! 450: ! 451: /* We received something; rummage thru tiny ring buffer */ ! 452: if (isr & (DSIS_RX|DSIS_RXE|DSIS_ROVRN)) { ! 453: u_char pend,lastfree; ! 454: ! 455: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG1); ! 456: pend = inb(nec+ds1_curr); ! 457: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG0); ! 458: lastfree = inb(nec+ds0_bnry); ! 459: ! 460: /* Have we wrapped? */ ! 461: if (lastfree >= RBUFEND/DS_PGSIZE) ! 462: lastfree = RBUF/DS_PGSIZE; ! 463: if (pend < lastfree && ns->ns_cur < pend) ! 464: lastfree = ns->ns_cur; ! 465: else if (ns->ns_cur > lastfree) ! 466: lastfree = ns->ns_cur; ! 467: ! 468: /* Something in the buffer? */ ! 469: while (pend != lastfree) { ! 470: u_char nxt; ! 471: ! 472: /* Extract header from microcephalic board */ ! 473: nefetch(&ns->ns_ph,lastfree*DS_PGSIZE, ! 474: sizeof(ns->ns_ph)); ! 475: ns->ns_ba = lastfree*DS_PGSIZE+sizeof(ns->ns_ph); ! 476: ! 477: /* Incipient paranoia */ ! 478: if (ns->ns_ph.pr_status == DSRS_RPC || ! 479: /* for dequna's */ ! 480: ns->ns_ph.pr_status == 0x21) ! 481: nerecv (ns); ! 482: #ifdef NEDEBUG ! 483: else { ! 484: printf("cur %x pnd %x lfr %x ", ! 485: ns->ns_cur, pend, lastfree); ! 486: printf("nxt %x len %x ", ns->ns_ph.pr_nxtpg, ! 487: (ns->ns_ph.pr_sz1<<8)+ ns->ns_ph.pr_sz0); ! 488: printf("Bogus Sts %x\n", ns->ns_ph.pr_status); ! 489: } ! 490: #endif ! 491: ! 492: nxt = ns->ns_ph.pr_nxtpg ; ! 493: ! 494: /* Sanity check */ ! 495: if ( nxt >= RBUF/DS_PGSIZE && nxt <= RBUFEND/DS_PGSIZE ! 496: && nxt <= pend) ! 497: ns->ns_cur = nxt; ! 498: else ns->ns_cur = nxt = pend; ! 499: ! 500: /* Set the boundaries */ ! 501: lastfree = nxt; ! 502: outb(nec+ds0_bnry, pred(nxt)); ! 503: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG1); ! 504: pend = inb(nec+ds1_curr); ! 505: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG0); ! 506: } ! 507: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA); ! 508: } ! 509: ! 510: /* Transmit error */ ! 511: if (isr & DSIS_TXE) { ! 512: ns->ns_flags &= ~DSF_LOCK; ! 513: /* Need to read these registers to clear status */ ! 514: ns->ns_if.if_collisions += inb(nec+ds0_tbcr0); ! 515: ns->ns_if.if_oerrors++; ! 516: } ! 517: ! 518: /* Packet Transmitted */ ! 519: if (isr & DSIS_TX) { ! 520: ns->ns_flags &= ~DSF_LOCK; ! 521: ++ns->ns_if.if_opackets; ! 522: ns->ns_if.if_collisions += inb(nec+ds0_tbcr0); ! 523: } ! 524: ! 525: /* Receiver ovverun? */ ! 526: if (isr & DSIS_ROVRN) { ! 527: log(LOG_ERR, "ne%d: error: isr %x\n", ns-ne_softc, isr ! 528: /*, DSIS_BITS*/); ! 529: outb(nec+ds0_rbcr0, 0); ! 530: outb(nec+ds0_rbcr1, 0); ! 531: outb(nec+ds0_tcr, DSTC_LB0); ! 532: outb(nec+ds0_rcr, DSRC_MON); ! 533: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA); ! 534: outb(nec+ds0_rcr, DSRC_AB); ! 535: outb(nec+ds0_tcr, 0); ! 536: } ! 537: ! 538: /* Any more to send? */ ! 539: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_START); ! 540: nestart(&ns->ns_if); ! 541: outb (nec+ds_cmd, cmd); ! 542: outb (nec+ds0_imr, 0xff); ! 543: ! 544: /* Still more to do? */ ! 545: isr = inb (nec+ds0_isr); ! 546: if(isr) goto loop; ! 547: } ! 548: ! 549: /* ! 550: * Ethernet interface receiver interface. ! 551: * If input error just drop packet. ! 552: * Otherwise examine packet to determine type. If can't determine length ! 553: * from type, then have to drop packet. Othewise decapsulate ! 554: * packet based on type and pass to type specific higher-level ! 555: * input routine. ! 556: */ ! 557: nerecv(ns) ! 558: register struct ne_softc *ns; ! 559: { ! 560: int len,i; ! 561: ! 562: ns->ns_if.if_ipackets++; ! 563: len = ns->ns_ph.pr_sz0 + (ns->ns_ph.pr_sz1<<8); ! 564: if(len < ETHER_MIN_LEN || len > ETHER_MAX_LEN) ! 565: return; ! 566: ! 567: /* this need not be so torturous - one/two bcopys at most into mbufs */ ! 568: nefetch(ns->ns_pb, ns->ns_ba, min(len,DS_PGSIZE-sizeof(ns->ns_ph))); ! 569: if (len > DS_PGSIZE-sizeof(ns->ns_ph)) { ! 570: int l = len - (DS_PGSIZE-sizeof(ns->ns_ph)), b ; ! 571: u_char *p = ns->ns_pb + (DS_PGSIZE-sizeof(ns->ns_ph)); ! 572: ! 573: if(++ns->ns_cur > 0x7f) ns->ns_cur = 0x46; ! 574: b = ns->ns_cur*DS_PGSIZE; ! 575: ! 576: while (l >= DS_PGSIZE) { ! 577: nefetch(p, b, DS_PGSIZE); ! 578: p += DS_PGSIZE; l -= DS_PGSIZE; ! 579: if(++ns->ns_cur > 0x7f) ns->ns_cur = 0x46; ! 580: b = ns->ns_cur*DS_PGSIZE; ! 581: } ! 582: if (l > 0) ! 583: nefetch(p, b, l); ! 584: } ! 585: /* don't forget checksum! */ ! 586: len -= sizeof(struct ether_header) + sizeof(long); ! 587: ! 588: neread(ns,(caddr_t)(ns->ns_pb), len); ! 589: } ! 590: ! 591: /* ! 592: * Pass a packet to the higher levels. ! 593: * We deal with the trailer protocol here. ! 594: */ ! 595: neread(ns, buf, len) ! 596: register struct ne_softc *ns; ! 597: char *buf; ! 598: int len; ! 599: { ! 600: register struct ether_header *eh; ! 601: struct mbuf *m; ! 602: int off, resid; ! 603: register struct ifqueue *inq; ! 604: ! 605: /* ! 606: * Deal with trailer protocol: if type is trailer type ! 607: * get true type from first 16-bit word past data. ! 608: * Remember that type was trailer by setting off. ! 609: */ ! 610: eh = (struct ether_header *)buf; ! 611: eh->ether_type = ntohs((u_short)eh->ether_type); ! 612: #define nedataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off)))) ! 613: if (eh->ether_type >= ETHERTYPE_TRAIL && ! 614: eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) { ! 615: off = (eh->ether_type - ETHERTYPE_TRAIL) * 512; ! 616: if (off >= ETHERMTU) return; /* sanity */ ! 617: eh->ether_type = ntohs(*nedataaddr(eh, off, u_short *)); ! 618: resid = ntohs(*(nedataaddr(eh, off+2, u_short *))); ! 619: if (off + resid > len) return; /* sanity */ ! 620: len = off + resid; ! 621: } else off = 0; ! 622: ! 623: if (len == 0) return; ! 624: ! 625: /* ! 626: * Pull packet off interface. Off is nonzero if packet ! 627: * has trailing header; neget will then force this header ! 628: * information to be at the front, but we still have to drop ! 629: * the type and length which are at the front of any trailer data. ! 630: */ ! 631: m = neget(buf, len, off, &ns->ns_if); ! 632: if (m == 0) return; ! 633: ! 634: ether_input(&ns->ns_if, eh, m); ! 635: } ! 636: ! 637: /* ! 638: * Supporting routines ! 639: */ ! 640: ! 641: /* ! 642: * Pull read data off a interface. ! 643: * Len is length of data, with local net header stripped. ! 644: * Off is non-zero if a trailer protocol was used, and ! 645: * gives the offset of the trailer information. ! 646: * We copy the trailer information and then all the normal ! 647: * data into mbufs. When full cluster sized units are present ! 648: * we copy into clusters. ! 649: */ ! 650: struct mbuf * ! 651: neget(buf, totlen, off0, ifp) ! 652: caddr_t buf; ! 653: int totlen, off0; ! 654: struct ifnet *ifp; ! 655: { ! 656: struct mbuf *top, **mp, *m, *p; ! 657: int off = off0, len; ! 658: register caddr_t cp = buf; ! 659: char *epkt; ! 660: ! 661: buf += sizeof(struct ether_header); ! 662: cp = buf; ! 663: epkt = cp + totlen; ! 664: ! 665: ! 666: if (off) { ! 667: cp += off + 2 * sizeof(u_short); ! 668: totlen -= 2 * sizeof(u_short); ! 669: } ! 670: ! 671: MGETHDR(m, M_DONTWAIT, MT_DATA); ! 672: if (m == 0) ! 673: return (0); ! 674: m->m_pkthdr.rcvif = ifp; ! 675: m->m_pkthdr.len = totlen; ! 676: m->m_len = MHLEN; ! 677: ! 678: top = 0; ! 679: mp = ⊤ ! 680: while (totlen > 0) { ! 681: if (top) { ! 682: MGET(m, M_DONTWAIT, MT_DATA); ! 683: if (m == 0) { ! 684: m_freem(top); ! 685: return (0); ! 686: } ! 687: m->m_len = MLEN; ! 688: } ! 689: len = min(totlen, epkt - cp); ! 690: if (len >= MINCLSIZE) { ! 691: MCLGET(m, M_DONTWAIT); ! 692: if (m->m_flags & M_EXT) ! 693: m->m_len = len = min(len, MCLBYTES); ! 694: else ! 695: len = m->m_len; ! 696: } else { ! 697: /* ! 698: * Place initial small packet/header at end of mbuf. ! 699: */ ! 700: if (len < m->m_len) { ! 701: if (top == 0 && len + max_linkhdr <= m->m_len) ! 702: m->m_data += max_linkhdr; ! 703: m->m_len = len; ! 704: } else ! 705: len = m->m_len; ! 706: } ! 707: bcopy(cp, mtod(m, caddr_t), (unsigned)len); ! 708: cp += len; ! 709: *mp = m; ! 710: mp = &m->m_next; ! 711: totlen -= len; ! 712: if (cp == epkt) ! 713: cp = buf; ! 714: } ! 715: return (top); ! 716: } ! 717: ! 718: /* ! 719: * Process an ioctl request. ! 720: */ ! 721: neioctl(ifp, cmd, data) ! 722: register struct ifnet *ifp; ! 723: int cmd; ! 724: caddr_t data; ! 725: { ! 726: register struct ifaddr *ifa = (struct ifaddr *)data; ! 727: struct ne_softc *ns = &ne_softc[ifp->if_unit]; ! 728: struct ifreq *ifr = (struct ifreq *)data; ! 729: int s = splimp(), error = 0; ! 730: ! 731: ! 732: switch (cmd) { ! 733: ! 734: case SIOCSIFADDR: ! 735: ifp->if_flags |= IFF_UP; ! 736: ! 737: switch (ifa->ifa_addr->sa_family) { ! 738: #ifdef INET ! 739: case AF_INET: ! 740: neinit(ifp->if_unit); /* before arpwhohas */ ! 741: ((struct arpcom *)ifp)->ac_ipaddr = ! 742: IA_SIN(ifa)->sin_addr; ! 743: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr); ! 744: break; ! 745: #endif ! 746: #ifdef NS ! 747: case AF_NS: ! 748: { ! 749: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr); ! 750: ! 751: if (ns_nullhost(*ina)) ! 752: ina->x_host = *(union ns_host *)(ns->ns_addr); ! 753: else { ! 754: /* ! 755: * The manual says we can't change the address ! 756: * while the receiver is armed, ! 757: * so reset everything ! 758: */ ! 759: ifp->if_flags &= ~IFF_RUNNING; ! 760: bcopy((caddr_t)ina->x_host.c_host, ! 761: (caddr_t)ns->ns_addr, sizeof(ns->ns_addr)); ! 762: } ! 763: neinit(ifp->if_unit); /* does ne_setaddr() */ ! 764: break; ! 765: } ! 766: #endif ! 767: default: ! 768: neinit(ifp->if_unit); ! 769: break; ! 770: } ! 771: break; ! 772: ! 773: case SIOCSIFFLAGS: ! 774: if ((ifp->if_flags & IFF_UP) == 0 && ! 775: ifp->if_flags & IFF_RUNNING) { ! 776: ifp->if_flags &= ~IFF_RUNNING; ! 777: outb(nec+ds_cmd,DSCM_STOP|DSCM_NODMA); ! 778: } else if (ifp->if_flags & IFF_UP && ! 779: (ifp->if_flags & IFF_RUNNING) == 0) ! 780: neinit(ifp->if_unit); ! 781: break; ! 782: ! 783: #ifdef notdef ! 784: case SIOCGHWADDR: ! 785: bcopy((caddr_t)ns->ns_addr, (caddr_t) &ifr->ifr_data, ! 786: sizeof(ns->ns_addr)); ! 787: break; ! 788: #endif ! 789: ! 790: default: ! 791: error = EINVAL; ! 792: } ! 793: splx(s); ! 794: return (error); ! 795: } ! 796: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.