![[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 [GnuMach] / Gnu-Mach / i386 / i386at|
Return to if_ne.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at |
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: ! 46: ! 47: #if NNE > 0 ! 48: #ifdef MACH_KERNEL ! 49: ! 50: #include <kern/time_out.h> ! 51: #include <device/device_types.h> ! 52: #include <device/errno.h> ! 53: #include <device/io_req.h> ! 54: #include <device/if_hdr.h> ! 55: #include <device/if_ether.h> ! 56: #include <device/net_status.h> ! 57: #include <device/net_io.h> ! 58: #include <i386at/ds8390.h> ! 59: #include <i386at/if_nereg.h> ! 60: #include <i386/ipl.h> ! 61: #include <chips/busses.h> ! 62: #ifdef FIPC ! 63: #include <ipc/fipc.h> ! 64: #endif /* FIPC */ ! 65: ! 66: #else MACH_KERNEL ! 67: ! 68: #include <sys/param.h> ! 69: #include <mach/vm_param.h> ! 70: #include <sys/systm.h> ! 71: #include <sys/mbuf.h> ! 72: #include <sys/table.h> ! 73: #include <sys/buf.h> ! 74: #include <sys/protosw.h> ! 75: #include <sys/socket.h> ! 76: #include <sys/vmmac.h> ! 77: #include <sys/ioctl.h> ! 78: #include <sys/errno.h> ! 79: #include <sys/syslog.h> ! 80: #include <vm/vm_kern.h> ! 81: ! 82: #include <net/if.h> ! 83: #include <net/if_types.h> ! 84: #include <net/route.h> ! 85: ! 86: #include <netinet/in.h> ! 87: #include <netinet/in_systm.h> ! 88: #include <netinet/in_var.h> ! 89: #include <netinet/ip.h> ! 90: #include <netinet/if_ether.h> ! 91: ! 92: #include <netns/ns.h> ! 93: #include <netns/ns_if.h> ! 94: ! 95: ! 96: #include <i386/ipl.h> ! 97: #include <i386at/atbus.h> ! 98: #include <i386at/ds8390.h> ! 99: #include <i386at/if_nereg.h> ! 100: #include <i386/handler.h> ! 101: #include <i386/dispatcher.h> ! 102: int ether_output(); ! 103: int neioctl(); ! 104: ! 105: #endif ! 106: ! 107: ! 108: int neprobe(); ! 109: void neattach(); ! 110: int neintr(); ! 111: int nestart(); ! 112: int neinit(); ! 113: ! 114: static vm_offset_t ne_std[NNE] = {0}; ! 115: static struct bus_device *ne_info[NNE]; ! 116: struct bus_driver nedriver = ! 117: { neprobe, 0, neattach, 0, ne_std, "ne", ne_info, 0, 0, 0 }; ! 118: ! 119: #define ETHER_MIN_LEN 64 ! 120: #define ETHER_MAX_LEN 1536 ! 121: #define SPLNET spl6 ! 122: /* ! 123: * Ethernet software status per interface. ! 124: * ! 125: * Each interface is referenced by a network interface structure, ! 126: * ns_if, which the routing code uses to locate the interface. ! 127: * This structure contains the output queue for the interface, its address, ... ! 128: */ ! 129: typedef struct { ! 130: ! 131: #ifdef MACH_KERNEL ! 132: struct ifnet ds_if; ! 133: u_char ds_addr[6]; ! 134: #else MACH_KERNEL ! 135: struct arpcom ns_ac; /* Ethernet common part */ ! 136: #define ds_if ns_ac.ac_if /* network-visible interface */ ! 137: #define ds_addr ns_ac.ac_enaddr /* hardware Ethernet address */ ! 138: #endif MACH_KERNEL ! 139: ! 140: int ns_flags; ! 141: #define DSF_LOCK 1 /* block re-entering enstart */ ! 142: #define DSF_RUNNING 2 ! 143: int ns_oactive ; ! 144: int ns_mask ; ! 145: int ns_ba; /* byte addr in buffer ram of inc pkt */ ! 146: int ns_cur; /* current page being filled */ ! 147: struct prhdr ns_ph; /* hardware header of incoming packet*/ ! 148: struct ether_header ns_eh; /* header of incoming packet */ ! 149: u_char ns_pb[2048 /*ETHERMTU+sizeof(long)*/]; ! 150: short ns_txstart; /* transmitter buffer start */ ! 151: short ns_rxend; /* recevier buffer end */ ! 152: short ns_rxbndry; /* recevier buffer boundary */ ! 153: caddr_t ns_port; /* i/o port base */ ! 154: short ns_mode; /* word/byte mode */ ! 155: int mode; ! 156: short card_present; ! 157: #ifndef MACH_KERNEL ! 158: ihandler_t handler; ! 159: ihandler_id_t *handler_id; ! 160: #endif MACH_KERNEL ! 161: ! 162: } ne_softc_t; ! 163: ne_softc_t ne_softc[NNE]; ! 164: ! 165: #define PAT(n) (0xa55a + 37*(n)) ! 166: ! 167: u_short boarddata[16]; ! 168: ! 169: /* ! 170: * Fetch from onboard ROM/RAM ! 171: */ ! 172: nefetch (ns, up, ad, len) ne_softc_t *ns; caddr_t up; { ! 173: u_char cmd; ! 174: caddr_t nec = ns->ns_port; ! 175: int counter = 10000; ! 176: int t_len; ! 177: unsigned char last_word[2]; ! 178: char odd; ! 179: ! 180: cmd = inb (nec + ds_cmd); ! 181: outb (nec + ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_START); ! 182: ! 183: /* Setup remote dma */ ! 184: outb (nec + ds0_isr, DSIS_RDC); ! 185: ! 186: t_len = len; ! 187: if ((ns->ns_mode & DSDC_WTS) && len&1) { ! 188: odd=1; ! 189: t_len++; /* roundup to words */ ! 190: } else odd=0; ! 191: ! 192: outb (nec+ds0_rbcr0, t_len); ! 193: outb (nec+ds0_rbcr1, t_len>>8); ! 194: outb (nec+ds0_rsar0, ad); ! 195: outb (nec+ds0_rsar1, ad>>8); ! 196: ! 197: /* Execute & extract from card */ ! 198: outb (nec+ds_cmd, DSCM_RREAD|DSCM_PG0|DSCM_START); ! 199: ! 200: if (ns->ns_mode & DSDC_WTS) ! 201: if (odd) { ! 202: linw (nec+ne_data, up, len/2); ! 203: *(last_word) = inw(nec+ne_data); /* get last word */ ! 204: *(up+len-1) = last_word[0]; /* last byte */ ! 205: } else { ! 206: linw (nec+ne_data, up, len/2); ! 207: } ! 208: else ! 209: linb (nec+ne_data, up, len); ! 210: ! 211: ! 212: /* Wait till done, then shutdown feature */ ! 213: while ((inb (nec+ds0_isr) & DSIS_RDC) == 0 && counter-- > 0) ! 214: ; ! 215: ! 216: outb (nec+ds0_isr, DSIS_RDC); ! 217: outb (nec+ds_cmd, cmd); ! 218: } ! 219: ! 220: /* ! 221: * Put to onboard RAM ! 222: */ ! 223: neput (ns, up, ad, len) ne_softc_t *ns; caddr_t up; { ! 224: u_char cmd; ! 225: caddr_t nec = ns->ns_port; ! 226: int counter = 10000; ! 227: int t_len; ! 228: int odd; ! 229: unsigned char last_word[2]; ! 230: ! 231: cmd = inb(nec+ds_cmd); ! 232: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_START); ! 233: ! 234: /* Setup for remote dma */ ! 235: outb (nec+ds0_isr, DSIS_RDC); ! 236: ! 237: t_len = len; ! 238: if ((ns->ns_mode & DSDC_WTS) && len&1) { ! 239: odd = 1; ! 240: t_len++; /* roundup to words */ ! 241: } else odd = 0; ! 242: ! 243: outb (nec+ds0_rbcr0, t_len); ! 244: outb (nec+ds0_rbcr1, t_len>>8); ! 245: outb (nec+ds0_rsar0, ad); ! 246: outb (nec+ds0_rsar1, ad>>8); ! 247: ! 248: /* Execute & stuff to card */ ! 249: outb (nec+ds_cmd, DSCM_RWRITE|DSCM_PG0|DSCM_START); ! 250: if (ns->ns_mode & DSDC_WTS) { ! 251: if (odd) { ! 252: loutw (nec+ne_data, up, len/2); ! 253: last_word[0] = *(up+len-1); ! 254: outw (nec+ne_data, (unsigned short) *(last_word)); ! 255: } ! 256: else { ! 257: loutw (nec+ne_data, up, len/2); ! 258: } ! 259: } ! 260: else ! 261: loutb (nec+ne_data, up, len); ! 262: ! 263: ! 264: /* Wait till done, then shutdown feature */ ! 265: while ((inb (nec+ds0_isr) & DSIS_RDC) == 0 && counter-- > 0) ! 266: ; ! 267: ! 268: outb (nec+ds0_isr, DSIS_RDC); ! 269: outb (nec+ds_cmd, cmd); ! 270: } ! 271: ! 272: int ! 273: neprobe(port, dev) ! 274: struct bus_device *dev; ! 275: { ! 276: int val, i, sum, bytemode = 1, pat; ! 277: int unit = dev->unit; ! 278: ne_softc_t *ns = &ne_softc[unit]; ! 279: caddr_t nec; ! 280: ! 281: if ((unsigned) unit >= NNE) ! 282: return(0); ! 283: ! 284: nec = (caddr_t) ns->ns_port = dev->address; ! 285: ! 286: if (ns->card_present) { ! 287: printf("ne%s : card already present in port %x\n", ! 288: unit, nec); ! 289: return(0); ! 290: } ! 291: ! 292: if (bytemode) { ! 293: /* Byte Transfers, Burst Mode Select, Fifo at 8 bytes */ ! 294: ns->ns_mode = DSDC_BMS|DSDC_FT1; ! 295: ns->ns_txstart = TBUF8; ! 296: ns->ns_rxend = RBUFEND8; ! 297: } else { ! 298: word: ! 299: /* Word Transfers, Burst Mode Select, Fifo at 8 bytes */ ! 300: ns->ns_mode = DSDC_WTS|DSDC_BMS|DSDC_FT1; ! 301: ns->ns_txstart = TBUF16; ! 302: ns->ns_rxend = RBUFEND16; ! 303: bytemode = 0; ! 304: } ! 305: ! 306: /* Reset the bastard */ ! 307: val = inb(nec + ne_reset); ! 308: delay(200); ! 309: outb(nec + ne_reset, val); ! 310: delay(200); ! 311: ! 312: outb(nec + ds_cmd, DSCM_STOP|DSCM_NODMA); ! 313: ! 314: i = 10000; ! 315: while ((inb(nec + ds0_isr) & DSIS_RESET) == 0 && i-- > 0); ! 316: if (i < 0) return (0); ! 317: ! 318: outb(nec + ds0_isr, 0xff); ! 319: outb(nec + ds0_dcr, ns->ns_mode); ! 320: outb(nec + ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP); ! 321: delay(1000); ! 322: ! 323: /* Check cmd reg and fail if not right */ ! 324: if ((i = inb(nec + ds_cmd)) != (DSCM_NODMA|DSCM_PG0|DSCM_STOP)) ! 325: return(0); ! 326: ! 327: outb(nec + ds0_tcr, DSTC_LB0); ! 328: outb(nec + ds0_rcr, DSRC_MON); ! 329: outb(nec + ds0_pstart, ns->ns_txstart+PKTSZ); ! 330: outb(nec + ds0_pstop, ns->ns_rxend); ! 331: outb(nec + ds0_bnry, ns->ns_rxend); ! 332: outb(nec + ds0_imr, 0); ! 333: outb(nec + ds0_isr, 0); ! 334: outb(nec + ds_cmd, DSCM_NODMA|DSCM_PG1|DSCM_STOP); ! 335: outb(nec + ds1_curr, ns->ns_txstart+PKTSZ); ! 336: outb(nec + ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP); ! 337: ! 338: #ifdef NEDEBUG ! 339: #define RCON 37 ! 340: { int i, rom; ! 341: ! 342: rom=1; ! 343: printf("ne ram "); ! 344: ! 345: for (i = 0; i < 0xfff0; i+=4) { ! 346: pat = PAT(i); ! 347: neput(ns, &pat,i,4); ! 348: nefetch(ns, &pat,i,4); ! 349: if (pat == PAT(i)) { ! 350: if (rom) { ! 351: rom=0; ! 352: printf(" %x", i); ! 353: } ! 354: } else { ! 355: if (!rom) { ! 356: rom=1; ! 357: printf("..%x ", i); ! 358: } ! 359: } ! 360: pat=0; ! 361: neput(ns, &pat,i,4); ! 362: } ! 363: printf("\n"); ! 364: } ! 365: #endif ! 366: ! 367: /* ! 368: * <groan> detect difference between units ! 369: * solely by where the RAM is decoded. ! 370: */ ! 371: pat = PAT(0); ! 372: neput (ns, &pat, ns->ns_txstart*DS_PGSIZE, 4); ! 373: nefetch(ns, &pat, ns->ns_txstart*DS_PGSIZE, 4); ! 374: if (pat != PAT(0)) { ! 375: if (bytemode) ! 376: goto word; ! 377: else return (0); ! 378: } ! 379: ! 380: ! 381: /* Extract board address */ ! 382: nefetch (ns, (caddr_t)boarddata, 0, sizeof(boarddata)); ! 383: ! 384: for(i=0; i < 6; i++) ! 385: ns->ds_addr[i] = boarddata[i]; ! 386: ns->card_present = 1; ! 387: return (1); ! 388: } ! 389: ! 390: /* ! 391: * Interface exists: make available by filling in network interface ! 392: * record. System will initialize the interface when it is ready ! 393: * to accept packets. We get the ethernet address here. ! 394: */ ! 395: void ! 396: neattach(dev) ! 397: struct bus_device *dev; ! 398: { ! 399: short unit = dev->unit; ! 400: ne_softc_t *ns = &ne_softc[unit]; ! 401: register struct ifnet *ifp = &(ns->ds_if); ! 402: ! 403: if ((unsigned) unit >= NNE) ! 404: return; ! 405: ! 406: #ifdef MACH_KERNEL ! 407: take_dev_irq(dev); ! 408: #else MACH_KERNEL ! 409: /* setup intr handler */ ! 410: ns->handler.ih_level = dev->dev_pic; ! 411: ns->handler.ih_handler = dev->dev_intr[0]; ! 412: ns->handler.ih_resolver = i386_resolver; ! 413: ns->handler.ih_rdev = dev; ! 414: ns->handler.ih_stats.intr_type = INTR_DEVICE; ! 415: ns->handler.ih_stats.intr_cnt = 0; ! 416: ns->handler.ih_hparam[0].intparam = unit; ! 417: if ((ns->handler_id = handler_add(&ns->handler)) != NULL) ! 418: handler_enable(ns->handler_id); ! 419: else ! 420: panic("Unable to add NEx000 interrupt handler"); ! 421: #endif MACH_KERNEL ! 422: printf (", port = %x, spl = %d, pic = %d, [%s].", ! 423: dev->address, dev->sysdep, dev->sysdep1, ! 424: ether_sprintf(ns->ds_addr)); ! 425: #ifndef MACH_KERNEL ! 426: ns->ns_ac.ac_bcastaddr = (u_char *)etherbroadcastaddr; ! 427: ns->ns_ac.ac_arphrd = ARPHRD_ETHER; ! 428: #endif MACH_KERNEL ! 429: ns->ns_flags = 0; ! 430: ns->mode = 0; ! 431: ifp->if_unit = unit; ! 432: ifp->if_mtu = ETHERMTU; ! 433: ifp->if_flags = IFF_BROADCAST; ! 434: #ifdef MACH_KERNEL ! 435: ifp->if_header_size = sizeof(struct ether_header); ! 436: ifp->if_header_format = HDR_ETHERNET; ! 437: ifp->if_address_size = 6; ! 438: ifp->if_address = (char *)&ns->ds_addr[0]; ! 439: if_init_queues(ifp); ! 440: #else MACH_KERNEL ! 441: ifp->if_name = nedriver.driver_dname; ! 442: ifp->if_init = neinit; ! 443: ifp->if_output = ether_output; ! 444: ifp->if_start = nestart; ! 445: ifp->if_ioctl = neioctl; ! 446: ifp->if_reset = nereset; ! 447: ifp->if_watchdog= 0; ! 448: if_attach(ifp); ! 449: #endif MACH_KERNEL ! 450: } ! 451: ! 452: /* ! 453: * Initialization of interface; set up initialization block ! 454: * and transmit/receive descriptor rings. ! 455: */ ! 456: neinit(unit) ! 457: int unit; ! 458: { ! 459: ne_softc_t *ns = &ne_softc[unit]; ! 460: struct ifnet *ifp = &ns->ds_if; ! 461: int i; char *cp; ! 462: int oldpri; ! 463: caddr_t nec = ns->ns_port; ! 464: ! 465: #ifndef MACH_KERNEL ! 466: if (ifp->if_addrlist == (struct ifaddr *)0) return; ! 467: #endif MACH_KERNEL ! 468: ! 469: oldpri = SPLNET(); ! 470: ! 471: outb(nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP); ! 472: ! 473: /* Word Transfer select, Burst Mode Select, Fifo at 8 bytes */ ! 474: outb(nec+ds0_dcr, ns->ns_mode); ! 475: ! 476: /* clear remote byte count resigters */ ! 477: outb (nec+ds0_rbcr0, 0); ! 478: outb (nec+ds0_rbcr1, 0); ! 479: ! 480: /* don't store incoming packets into memory for now */ ! 481: outb (nec+ds0_rcr, DSRC_MON); ! 482: ! 483: /* place NIC in internal loopback mode */ ! 484: outb(nec+ds0_tcr, DSTC_LB0); ! 485: ! 486: /* initialize transmit/recieve (ring-buffer) Page Start */ ! 487: outb (nec+ds0_tpsr, 0); ! 488: outb (nec+ds0_pstart, ns->ns_txstart+PKTSZ); ! 489: ! 490: /* initialize reciever (ring-buffer) Page Stop and Boundary */ ! 491: outb (nec+ds0_pstop, ns->ns_rxend); ! 492: outb (nec+ds0_bnry, ns->ns_txstart+PKTSZ); ! 493: ! 494: /* clear all interrupts */ ! 495: outb (nec+ds0_isr, 0xff); ! 496: ! 497: /* enable the interrupts that we care about */ ! 498: outb (nec+ds0_imr, IMR_ENABLE); ! 499: ! 500: /* set physical address on ethernet */ ! 501: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG1|DSCM_STOP); ! 502: for (i=0 ; i < 6 ; i++) outb(nec+ds1_par0+i,ns->ds_addr[i]); ! 503: ! 504: ns->ns_cur = ns->ns_txstart+PKTSZ + 1; ! 505: outb (nec+ds1_curr, ns->ns_cur); ! 506: ! 507: /* XXX deal with Reciever Configuration Register */ ! 508: /* clr logical address hash filter for now */ ! 509: for (i=0 ; i < 8 ; i++) outb(nec+ds1_mar0+i,0xff); ! 510: ! 511: /* set page 0 registers */ ! 512: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP); ! 513: outb (nec+ds0_rcr, DSRC_AB); ! 514: ! 515: /* take unit out of loopback mode */ ! 516: outb (nec+ds0_tcr, 0); ! 517: ! 518: ns->ds_if.if_flags |= IFF_RUNNING; ! 519: ns->ns_flags &= ~(DSF_LOCK|DSF_RUNNING); ! 520: ns->ns_oactive = 0; ns->ns_mask = ~0; ! 521: splx(oldpri); ! 522: nestart(unit); ! 523: return(1); ! 524: } ! 525: ! 526: /* ! 527: * Setup output on interface. ! 528: * Get another datagram to send off of the interface queue, ! 529: * and map it to the interface before starting the output. ! 530: * called only at splimp or interrupt level. ! 531: */ ! 532: nestart(unit) ! 533: int unit; ! 534: { ! 535: ne_softc_t *ns = &ne_softc[unit]; ! 536: struct ifnet *ifp = &ns->ds_if; ! 537: int buffer; ! 538: int len, i, total,t; ! 539: caddr_t nec = ns->ns_port; ! 540: #ifdef MACH_KERNEL ! 541: io_req_t m; ! 542: ! 543: #else MACH_KERNEL ! 544: struct mbuf *m0, *m; ! 545: #endif MACH_KERNEL ! 546: ! 547: /* ! 548: * The DS8390 has only one transmit buffer, if it is busy we ! 549: * must wait until the transmit interrupt completes. ! 550: */ ! 551: outb(nec+ds_cmd,DSCM_NODMA|DSCM_START); ! 552: ! 553: if (ns->ns_flags & DSF_LOCK) ! 554: goto done; ! 555: ! 556: if (inb(nec+ds_cmd) & DSCM_TRANS) ! 557: goto done; ! 558: ! 559: if ((ns->ds_if.if_flags & IFF_RUNNING) == 0) ! 560: goto done; ! 561: ! 562: IF_DEQUEUE(&ns->ds_if.if_snd, m); ! 563: if (m == 0) ! 564: goto done; ! 565: ! 566: /* ! 567: * Copy the mbuf chain into the transmit buffer ! 568: */ ! 569: ! 570: ns->ns_flags |= DSF_LOCK; /* prevent entering nestart */ ! 571: buffer = ns->ns_txstart*DS_PGSIZE; ! 572: #ifdef MACH_KERNEL ! 573: total = m->io_count; ! 574: neput(ns, m->io_data, buffer, total); ! 575: #else MACH_KERNEL ! 576: t = 0; len = i = 0; ! 577: for (m0 = m; m != 0; m = m->m_next) ! 578: t += m->m_len; ! 579: ! 580: m = m0; ! 581: total = t; ! 582: for (m0 = m; m != 0; ) { ! 583: ! 584: if (m->m_len&1 && t > m->m_len) { ! 585: neput(ns, mtod(m, caddr_t), buffer, m->m_len - 1); ! 586: t -= m->m_len - 1; ! 587: buffer += m->m_len - 1; ! 588: m->m_data += m->m_len - 1; ! 589: m->m_len = 1; ! 590: m = m_pullup(m, 2); ! 591: } else { ! 592: neput(ns, mtod(m, caddr_t), buffer, m->m_len); ! 593: buffer += m->m_len; ! 594: t -= m->m_len; ! 595: MFREE(m, m0); ! 596: m = m0; ! 597: } ! 598: } ! 599: #endif MACH_KERNEL ! 600: /* ! 601: * Init transmit length registers, and set transmit start flag. ! 602: */ ! 603: ! 604: len = total; ! 605: if (len < ETHER_MIN_LEN) len = ETHER_MIN_LEN; ! 606: outb(nec+ds0_tbcr0,len&0xff); ! 607: outb(nec+ds0_tbcr1,(len>>8)&0xff); ! 608: outb(nec+ds0_tpsr, ns->ns_txstart); ! 609: outb(nec+ds_cmd, DSCM_TRANS|DSCM_NODMA|DSCM_START); ! 610: ! 611: #ifdef MACH_KERNEL ! 612: iodone(m); ! 613: m = 0; ! 614: done: ! 615: #endif MACH_KERNEL ! 616: } ! 617: ! 618: /* buffer successor/predecessor in ring? */ ! 619: #define succ(n) (((n)+1 >= ns->ns_rxend) ? (ns->ns_txstart+PKTSZ) : (n)+1) ! 620: #define pred(n) (((n)-1 < (ns->ns_txstart+PKTSZ)) ? ns->ns_rxend-1 : (n)-1) ! 621: ! 622: /* ! 623: * Controller interrupt. ! 624: */ ! 625: neintr(unit) ! 626: { ! 627: ne_softc_t *ns = &ne_softc[unit]; ! 628: u_char cmd,isr; ! 629: caddr_t nec = ns->ns_port; ! 630: ! 631: /* Save cmd, clear interrupt */ ! 632: cmd = inb (nec+ds_cmd); ! 633: isr = inb (nec+ds0_isr); ! 634: loop: ! 635: outb(nec+ds_cmd,DSCM_NODMA|DSCM_START); ! 636: outb(nec+ds0_isr, isr); ! 637: ! 638: /* Receiver error */ ! 639: if (isr & DSIS_RXE) { ! 640: (void) inb(nec+ds0_rsr); ! 641: /* need to read these registers to clear status */ ! 642: ns->ds_if.if_ierrors++; ! 643: } ! 644: ! 645: /* Counters overflowed, reading the registers resets them */ ! 646: if (isr & DSIS_CTRS) { ! 647: (void) inb(nec+ds0_cntr0); ! 648: (void) inb(nec+ds0_cntr1); ! 649: (void) inb(nec+ds0_cntr2); ! 650: } ! 651: ! 652: ! 653: /* We received something; rummage thru tiny ring buffer */ ! 654: if (isr & (DSIS_RX|DSIS_RXE|DSIS_ROVRN)) { ! 655: u_char pend,lastfree; ! 656: ! 657: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG1); ! 658: pend = inb(nec+ds1_curr); ! 659: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG0); ! 660: ! 661: /* Something in the buffer? */ ! 662: while (pend != ns->ns_cur) { ! 663: /* Extract header from microcephalic board */ ! 664: nefetch(ns, &ns->ns_ph,ns->ns_cur*DS_PGSIZE, ! 665: sizeof(ns->ns_ph)); ! 666: ns->ns_ba = ns->ns_cur*DS_PGSIZE+sizeof(ns->ns_ph); ! 667: ! 668: /* Incipient paranoia */ ! 669: if (ns->ns_ph.pr_status == DSRS_RPC || ! 670: /* for dequna's */ ! 671: ns->ns_ph.pr_status == 0x21) { ! 672: if (nerecv(ns)) ! 673: ns->ns_cur = ns->ns_ph.pr_nxtpg ; ! 674: else { ! 675: outb(nec+ds0_bnry, pred(ns->ns_cur)); ! 676: goto short_load; ! 677: } ! 678: } ! 679: #ifdef NEDEBUG ! 680: else { ! 681: printf("cur %x pnd %x lfr %x ", ! 682: ns->ns_cur, pend, lastfree); ! 683: printf("nxt %x len %x ", ns->ns_ph.pr_nxtpg, ! 684: (ns->ns_ph.pr_sz1<<8)+ ns->ns_ph.pr_sz0); ! 685: printf("Bogus Sts %x\n", ns->ns_ph.pr_status); ! 686: ns->ns_cur = pend; ! 687: } ! 688: #endif ! 689: outb(nec+ds0_bnry, pred(ns->ns_cur)); ! 690: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG1); ! 691: pend = inb(nec+ds1_curr); ! 692: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG0); ! 693: } ! 694: short_load: ! 695: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA); ! 696: } ! 697: ! 698: /* Transmit error */ ! 699: if (isr & DSIS_TXE) { ! 700: ns->ns_flags &= ~DSF_LOCK; ! 701: /* Need to read these registers to clear status */ ! 702: ns->ds_if.if_collisions += inb(nec+ds0_tbcr0); ! 703: ns->ds_if.if_oerrors++; ! 704: } ! 705: ! 706: /* Packet Transmitted */ ! 707: if (isr & DSIS_TX) { ! 708: ns->ns_flags &= ~DSF_LOCK; ! 709: ++ns->ds_if.if_opackets; ! 710: ns->ds_if.if_collisions += inb(nec+ds0_tbcr0); ! 711: } ! 712: ! 713: /* Receiver ovverun? */ ! 714: if (isr & DSIS_ROVRN) { ! 715: outb(nec+ds0_rbcr0, 0); ! 716: outb(nec+ds0_rbcr1, 0); ! 717: outb(nec+ds0_tcr, DSTC_LB0); ! 718: outb(nec+ds0_rcr, DSRC_MON); ! 719: outb(nec+ds_cmd, DSCM_START|DSCM_NODMA); ! 720: outb(nec+ds0_rcr, DSRC_AB); ! 721: outb(nec+ds0_tcr, 0); ! 722: } ! 723: ! 724: /* Any more to send? */ ! 725: outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_START); ! 726: nestart(unit); ! 727: outb (nec+ds_cmd, cmd); ! 728: outb (nec+ds0_imr, IMR_ENABLE); ! 729: ! 730: /* Still more to do? */ ! 731: isr = inb (nec+ds0_isr); ! 732: if(isr) goto loop; ! 733: ! 734: return 0; ! 735: } ! 736: ! 737: /* ! 738: * Ethernet interface receiver interface. ! 739: * If input error just drop packet. ! 740: * Otherwise examine packet to determine type. If can't determine length ! 741: * from type, then have to drop packet. Othewise decapsulate ! 742: * packet based on type and pass to type specific higher-level ! 743: * input routine. ! 744: */ ! 745: nerecv(ns) ! 746: ne_softc_t *ns; ! 747: { ! 748: #ifdef MACH_KERNEL ! 749: ipc_kmsg_t new_kmsg; ! 750: struct ether_header *ehp; ! 751: struct packet_header *pkt; ! 752: register struct ifnet *ifp = &ns->ds_if; ! 753: #ifdef FIPC ! 754: char *fipc_buf; ! 755: #endif ! 756: #else MACH_KERNEL ! 757: struct mbuf *top, **mp, *m, *p; ! 758: #endif MACH_KERNEL ! 759: int len, l; ! 760: int epkt; ! 761: ! 762: ns->ds_if.if_ipackets++; ! 763: len = ns->ns_ph.pr_sz0 + (ns->ns_ph.pr_sz1<<8); ! 764: if(len < ETHER_MIN_LEN || len > ETHER_MAX_LEN) ! 765: return 0; ! 766: ! 767: nefetch(ns, &ns->ns_eh, ns->ns_ba, sizeof(struct ether_header)); ! 768: ! 769: #ifndef MACH_KERNEL ! 770: ns->ns_eh.ether_type = ntohs((u_short)ns->ns_eh.ether_type); ! 771: #endif MACH_KERNEL ! 772: ns->ns_ba += sizeof(struct ether_header); ! 773: ! 774: /* don't forget checksum! */ ! 775: len -= (sizeof(struct ether_header) + sizeof(long)); ! 776: #ifdef MACH_KERNEL ! 777: #ifdef FIPC ! 778: if (ns->ns_eh.ether_type == FIPC_MSG_TYPE) /* fipc packet */ ! 779: { ! 780: /* We need to hand the whole packet to the handler. */ ! 781: ! 782: fipc_recvs++; ! 783: ! 784: fipc_buf = get_fipc_buffer (len, TRUE, TRUE); ! 785: ! 786: if (fipc_buf == NULL) ! 787: { ! 788: ns->ds_if.if_rcvdrops++; ! 789: return(0); ! 790: } ! 791: nefetch (ns, fipc_buf, ns->ns_ba, len); ! 792: ! 793: fipc_packet (fipc_buf, ns->ns_eh); ! 794: } ! 795: else /* net_kmsg */ ! 796: { ! 797: #endif /* FIPC */ ! 798: new_kmsg = net_kmsg_get(); ! 799: ! 800: if (new_kmsg == IKM_NULL) { ! 801: ns->ds_if.if_rcvdrops++; ! 802: return(0); ! 803: } ! 804: ! 805: ehp = (struct ether_header *) (&net_kmsg(new_kmsg)->header[0]); ! 806: pkt = (struct packet_header *)(&net_kmsg(new_kmsg)->packet[0]); ! 807: *ehp = ns->ns_eh; ! 808: ! 809: nefetch(ns, (char *) (pkt + 1), ns->ns_ba, len); ! 810: ! 811: pkt->type = ehp->ether_type; ! 812: ! 813: pkt->length = len + sizeof(struct packet_header); ! 814: net_packet(ifp, new_kmsg, pkt->length, ethernet_priority(new_kmsg)); ! 815: #ifdef FIPC ! 816: } ! 817: #endif ! 818: ! 819: #else MACH_KERNEL ! 820: /**/ ! 821: epkt = ns->ns_ba + len; ! 822: ! 823: MGETHDR(m, M_DONTWAIT, MT_DATA); ! 824: if (m == 0) ! 825: return (0); ! 826: ! 827: m->m_pkthdr.rcvif = &ns->ds_if; ! 828: m->m_pkthdr.len = len; ! 829: m->m_len = MHLEN; ! 830: ! 831: top = 0; ! 832: mp = ⊤ ! 833: while (len > 0) { ! 834: if (top) { ! 835: MGET(m, M_DONTWAIT, MT_DATA); ! 836: if (m == 0) { ! 837: m_freem(top); ! 838: return (0); ! 839: } ! 840: m->m_len = MLEN; ! 841: } ! 842: l = min(len, epkt - ns->ns_ba); ! 843: if (l >= MINCLSIZE) { ! 844: MCLGET(m, M_DONTWAIT); ! 845: if (m->m_flags & M_EXT) ! 846: m->m_len = l = min(len, MCLBYTES); ! 847: else ! 848: l = m->m_len; ! 849: } else { ! 850: /* ! 851: * Place initial small packet/header at end of mbuf. ! 852: */ ! 853: if (l < m->m_len) { ! 854: if (top == 0 && len + max_linkhdr <= m->m_len) ! 855: m->m_data += max_linkhdr; ! 856: m->m_len = l; ! 857: } else ! 858: l = m->m_len; ! 859: } ! 860: nefetch(ns, mtod(m, caddr_t), ns->ns_ba, l); ! 861: ns->ns_ba += l; ! 862: *mp = m; ! 863: mp = &m->m_next; ! 864: len -= l; ! 865: } ! 866: /**/ ! 867: if (top == 0) return 0; /* NEED MODIFY HERE !!! */ ! 868: ! 869: ether_input(&ns->ds_if, &ns->ns_eh, top); ! 870: #endif MACH_KERNEL ! 871: return 1; ! 872: } ! 873: ! 874: #ifdef MACH_KERNEL ! 875: neopen(dev, flag) ! 876: dev_t dev; ! 877: int flag; ! 878: { ! 879: register int unit = minor(dev); ! 880: ! 881: if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE) ! 882: return (ENXIO); ! 883: ! 884: ne_softc[unit].ds_if.if_flags |= IFF_UP; ! 885: neinit(unit); ! 886: return(0); ! 887: } ! 888: ! 889: #ifdef FIPC ! 890: nefoutput(dev, ior) ! 891: dev_t dev; ! 892: io_req_t ior; ! 893: { ! 894: register int unit = minor(dev); ! 895: ! 896: if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE) ! 897: return (ENXIO); ! 898: ! 899: return (net_fwrite(&ne_softc[unit].ds_if, nestart, ior)); ! 900: } ! 901: #endif ! 902: ! 903: neoutput(dev, ior) ! 904: dev_t dev; ! 905: io_req_t ior; ! 906: { ! 907: register int unit = minor(dev); ! 908: ! 909: if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE) ! 910: return (ENXIO); ! 911: ! 912: return (net_write(&ne_softc[unit].ds_if, nestart, ior)); ! 913: } ! 914: ! 915: nesetinput(dev, receive_port, priority, filter, filter_count) ! 916: dev_t dev; ! 917: mach_port_t receive_port; ! 918: int priority; ! 919: filter_t filter[]; ! 920: unsigned int filter_count; ! 921: { ! 922: register int unit = minor(dev); ! 923: ! 924: if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE) ! 925: return (ENXIO); ! 926: ! 927: return (net_set_filter(&ne_softc[unit].ds_if, ! 928: receive_port, priority, ! 929: filter, filter_count)); ! 930: } ! 931: ! 932: negetstat(dev, flavor, status, count) ! 933: dev_t dev; ! 934: int flavor; ! 935: dev_status_t status; ! 936: unsigned int *count; ! 937: { ! 938: register int unit = minor(dev); ! 939: ! 940: if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE) ! 941: return (ENXIO); ! 942: ! 943: return (net_getstat(&ne_softc[unit].ds_if, ! 944: flavor, ! 945: status, ! 946: count)); ! 947: } ! 948: ! 949: nesetstat(dev, flavor, status, count) ! 950: dev_t dev; ! 951: int flavor; ! 952: dev_status_t status; ! 953: unsigned int count; ! 954: { ! 955: register int unit = minor(dev); ! 956: register ne_softc_t *ns; ! 957: ! 958: if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE) ! 959: return (ENXIO); ! 960: ! 961: ns = &ne_softc[unit]; ! 962: ! 963: switch(flavor) { ! 964: case NET_STATUS: { ! 965: register struct net_status *s = (struct net_status *)status; ! 966: int mode = 0; ! 967: if (count < NET_STATUS_COUNT) ! 968: return(D_INVALID_SIZE); ! 969: #define MOD_ENAL 1 ! 970: #define MOD_PROM 2 ! 971: if (s->flags & IFF_ALLMULTI) ! 972: mode |= MOD_ENAL; ! 973: if (s->flags & IFF_PROMISC) ! 974: mode |= MOD_PROM; ! 975: ! 976: if (ns->mode != mode) { ! 977: ns->mode = mode; ! 978: if (ns->ns_flags & DSF_RUNNING) { ! 979: ns->ns_flags &= ~(DSF_LOCK | DSF_RUNNING); ! 980: neinit(unit); ! 981: } ! 982: } ! 983: break; ! 984: } ! 985: default : ! 986: return (D_INVALID_OPERATION); ! 987: } ! 988: return (D_SUCCESS); ! 989: } ! 990: ! 991: #else MACH_KERNEL ! 992: ! 993: /* ! 994: * Process an ioctl request. ! 995: */ ! 996: neioctl(ifp, cmd, data) ! 997: register struct ifnet *ifp; ! 998: int cmd; ! 999: caddr_t data; ! 1000: { ! 1001: register struct ifaddr *ifa = (struct ifaddr *)data; ! 1002: ne_softc_t *ns = &ne_softc[ifp->if_unit]; ! 1003: struct ifreq *ifr = (struct ifreq *)data; ! 1004: int s = splimp(), error = 0; ! 1005: ! 1006: ! 1007: switch (cmd) { ! 1008: ! 1009: case SIOCSIFADDR: ! 1010: ifp->if_flags |= IFF_UP; ! 1011: ! 1012: switch (ifa->ifa_addr->sa_family) { ! 1013: case AF_INET: ! 1014: neinit(ifp->if_unit); /* before arpwhohas */ ! 1015: ((struct arpcom *)ifp)->ac_ipaddr = ! 1016: IA_SIN(ifa)->sin_addr; ! 1017: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr); ! 1018: break; ! 1019: case AF_NS: ! 1020: { ! 1021: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr); ! 1022: ! 1023: if (ns_nullhost(*ina)) ! 1024: ina->x_host = *(union ns_host *)(ns->ds_addr); ! 1025: else { ! 1026: /* ! 1027: * The manual says we can't change the address ! 1028: * while the receiver is armed, ! 1029: * so reset everything ! 1030: */ ! 1031: ifp->if_flags &= ~IFF_RUNNING; ! 1032: bcopy((caddr_t)ina->x_host.c_host, ! 1033: (caddr_t)ns->ds_addr, sizeof(ns->ds_addr)); ! 1034: } ! 1035: neinit(ifp->if_unit); /* does ne_setaddr() */ ! 1036: break; ! 1037: } ! 1038: default: ! 1039: neinit(ifp->if_unit); ! 1040: break; ! 1041: } ! 1042: break; ! 1043: ! 1044: case SIOCSIFFLAGS: ! 1045: if ((ifp->if_flags & IFF_UP) == 0 && ! 1046: ifp->if_flags & IFF_RUNNING) { ! 1047: ifp->if_flags &= ~IFF_RUNNING; ! 1048: outb(ns->ns_port + ds_cmd, DSCM_STOP|DSCM_NODMA); ! 1049: } else if (ifp->if_flags & IFF_UP && ! 1050: (ifp->if_flags & IFF_RUNNING) == 0) ! 1051: neinit(ifp->if_unit); ! 1052: break; ! 1053: ! 1054: #ifdef notdef ! 1055: case SIOCGHWADDR: ! 1056: bcopy((caddr_t)ns->ds_addr, (caddr_t) &ifr->ifr_data, ! 1057: sizeof(ns->ds_addr)); ! 1058: break; ! 1059: #endif ! 1060: ! 1061: default: ! 1062: error = EINVAL; ! 1063: } ! 1064: splx(s); ! 1065: return (error); ! 1066: } ! 1067: ! 1068: /* ! 1069: * Reset of interface. ! 1070: */ ! 1071: nereset(unit, uban) ! 1072: int unit, uban; ! 1073: { ! 1074: if (unit >= NNE) ! 1075: return; ! 1076: printf("ne%d: reset\n", unit); ! 1077: ne_softc[unit].ns_flags &= ~DSF_LOCK; ! 1078: neinit(unit); ! 1079: } ! 1080: #endif MACH_KERNEL ! 1081: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.