![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_il.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_il.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_il.c 7.1 (Berkeley) 6/5/86 ! 7: */ ! 8: ! 9: #include "il.h" ! 10: #include "enetfilter.h" ! 11: #if NIL > 0 ! 12: ! 13: /* ! 14: * Interlan Ethernet Communications Controller interface ! 15: */ ! 16: #include "../machine/pte.h" ! 17: ! 18: #include "param.h" ! 19: #include "systm.h" ! 20: #include "mbuf.h" ! 21: #include "buf.h" ! 22: #include "protosw.h" ! 23: #include "socket.h" ! 24: #include "vmmac.h" ! 25: #include "ioctl.h" ! 26: #include "errno.h" ! 27: ! 28: #include "../net/if.h" ! 29: #include "../net/netisr.h" ! 30: #include "../net/route.h" ! 31: ! 32: #ifdef INET ! 33: #include "../netinet/in.h" ! 34: #include "../netinet/in_systm.h" ! 35: #include "../netinet/in_var.h" ! 36: #include "../netinet/ip.h" ! 37: #include "../netinet/if_ether.h" ! 38: #endif ! 39: ! 40: #ifdef NS ! 41: #include "../netns/ns.h" ! 42: #include "../netns/ns_if.h" ! 43: #endif ! 44: ! 45: #include "../vax/cpu.h" ! 46: #include "../vax/mtpr.h" ! 47: #include "if_il.h" ! 48: #include "if_ilreg.h" ! 49: #include "if_uba.h" ! 50: #if NENETFILTER > 0 ! 51: #include "../net/enet.h" ! 52: #endif NENETFILTER > 0 ! 53: #include "../vaxuba/ubareg.h" ! 54: #include "../vaxuba/ubavar.h" ! 55: ! 56: int ilprobe(), ilattach(), ilrint(), ilcint(); ! 57: struct uba_device *ilinfo[NIL]; ! 58: u_short ilstd[] = { 0 }; ! 59: struct uba_driver ildriver = ! 60: { ilprobe, 0, ilattach, 0, ilstd, "il", ilinfo }; ! 61: #define ILUNIT(x) minor(x) ! 62: int ilinit(),iloutput(),ilioctl(),ilreset(),ilwatch(); ! 63: int ildebug = 0; ! 64: ! 65: /* ! 66: * Ethernet software status per interface. ! 67: * ! 68: * Each interface is referenced by a network interface structure, ! 69: * is_if, which the routing code uses to locate the interface. ! 70: * This structure contains the output queue for the interface, its address, ... ! 71: * We also have, for each interface, a UBA interface structure, which ! 72: * contains information about the UNIBUS resources held by the interface: ! 73: * map registers, buffered data paths, etc. Information is cached in this ! 74: * structure for use by the if_uba.c routines in running the interface ! 75: * efficiently. ! 76: */ ! 77: struct il_softc { ! 78: struct arpcom is_ac; /* Ethernet common part */ ! 79: #define is_if is_ac.ac_if /* network-visible interface */ ! 80: #define is_addr is_ac.ac_enaddr /* hardware Ethernet address */ ! 81: struct ifuba is_ifuba; /* UNIBUS resources */ ! 82: int is_flags; ! 83: #define ILF_OACTIVE 0x1 /* output is active */ ! 84: #define ILF_RCVPENDING 0x2 /* start rcv in ilcint */ ! 85: #define ILF_STATPENDING 0x4 /* stat cmd pending */ ! 86: #define ILF_RUNNING 0x8 /* board is running */ ! 87: #define ILF_SETADDR 0x10 /* physical address is changed */ ! 88: short is_lastcmd; /* can't read csr, so must save it */ ! 89: short is_scaninterval; /* interval of stat collection */ ! 90: #define ILWATCHINTERVAL 60 /* once every 60 seconds */ ! 91: struct il_stats is_stats; /* holds on-board statistics */ ! 92: struct il_stats is_sum; /* summation over time */ ! 93: int is_ubaddr; /* mapping registers of is_stats */ ! 94: #if NENETFILTER > 0 ! 95: short is_enetunit; /* unit number for enet filtering */ ! 96: #endif NENETFILTER ! 97: } il_softc[NIL]; ! 98: ! 99: ilprobe(reg) ! 100: caddr_t reg; ! 101: { ! 102: register int br, cvec; /* r11, r10 value-result */ ! 103: register struct ildevice *addr = (struct ildevice *)reg; ! 104: register i; ! 105: ! 106: #ifdef lint ! 107: br = 0; cvec = br; br = cvec; ! 108: i = 0; ilrint(i); ilcint(i); ilwatch(i); ! 109: #endif ! 110: ! 111: addr->il_csr = ILC_OFFLINE|IL_CIE; ! 112: DELAY(100000); ! 113: i = addr->il_csr; /* clear CDONE */ ! 114: if (cvec > 0 && cvec != 0x200) ! 115: cvec -= 4; ! 116: return (1); ! 117: } ! 118: ! 119: /* ! 120: * Interface exists: make available by filling in network interface ! 121: * record. System will initialize the interface when it is ready ! 122: * to accept packets. A STATUS command is done to get the ethernet ! 123: * address and other interesting data. ! 124: */ ! 125: ilattach(ui) ! 126: struct uba_device *ui; ! 127: { ! 128: register struct il_softc *is = &il_softc[ui->ui_unit]; ! 129: register struct ifnet *ifp = &is->is_if; ! 130: register struct ildevice *addr = (struct ildevice *)ui->ui_addr; ! 131: ! 132: ifp->if_unit = ui->ui_unit; ! 133: ifp->if_name = "il"; ! 134: ifp->if_mtu = ETHERMTU; ! 135: ifp->if_flags = IFF_BROADCAST; ! 136: ! 137: /* ! 138: * Reset the board and map the statistics ! 139: * buffer onto the Unibus. ! 140: */ ! 141: addr->il_csr = ILC_RESET; ! 142: (void)ilwait(ui, "reset"); ! 143: ! 144: is->is_ubaddr = uballoc(ui->ui_ubanum, (caddr_t)&is->is_stats, ! 145: sizeof (struct il_stats), 0); ! 146: addr->il_bar = is->is_ubaddr & 0xffff; ! 147: addr->il_bcr = sizeof (struct il_stats); ! 148: addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT; ! 149: (void)ilwait(ui, "status"); ! 150: ubarelse(ui->ui_ubanum, &is->is_ubaddr); ! 151: if (ildebug) ! 152: printf("il%d: module=%s firmware=%s\n", ui->ui_unit, ! 153: is->is_stats.ils_module, is->is_stats.ils_firmware); ! 154: bcopy((caddr_t)is->is_stats.ils_addr, (caddr_t)is->is_addr, ! 155: sizeof (is->is_addr)); ! 156: printf("il%d: hardware address %s\n", ui->ui_unit, ! 157: ether_sprintf(is->is_addr)); ! 158: ifp->if_init = ilinit; ! 159: ifp->if_output = iloutput; ! 160: ifp->if_ioctl = ilioctl; ! 161: ifp->if_reset = ilreset; ! 162: is->is_ifuba.ifu_flags = UBA_CANTWAIT; ! 163: #if NENETFILTER > 0 ! 164: { ! 165: struct endevp enp; ! 166: ! 167: enp.end_dev_type = ENDT_10MB; ! 168: enp.end_addr_len = sizeof(is->is_addr); ! 169: enp.end_hdr_len = sizeof(struct ether_header); ! 170: enp.end_MTU = ETHERMTU; ! 171: bcopy((caddr_t)is->is_addr, ! 172: (caddr_t)(enp.end_addr), sizeof(is->is_addr)); ! 173: bcopy((caddr_t)etherbroadcastaddr, ! 174: (caddr_t)(enp.end_broadaddr), sizeof(is->is_addr)); ! 175: ! 176: is->is_enetunit = enetattach(&is->is_if, &enp); ! 177: } ! 178: #endif NENETFILTER > 0 ! 179: if_attach(ifp); ! 180: } ! 181: ! 182: ilwait(ui, op) ! 183: struct uba_device *ui; ! 184: char *op; ! 185: { ! 186: register struct ildevice *addr = (struct ildevice *)ui->ui_addr; ! 187: ! 188: while ((addr->il_csr&IL_CDONE) == 0) ! 189: ; ! 190: if (addr->il_csr&IL_STATUS) { ! 191: printf("il%d: %s failed, csr=%b\n", ui->ui_unit, op, ! 192: addr->il_csr, IL_BITS); ! 193: return (-1); ! 194: } ! 195: return (0); ! 196: } ! 197: ! 198: /* ! 199: * Reset of interface after UNIBUS reset. ! 200: * If interface is on specified uba, reset its state. ! 201: */ ! 202: ilreset(unit, uban) ! 203: int unit, uban; ! 204: { ! 205: register struct uba_device *ui; ! 206: ! 207: if (unit >= NIL || (ui = ilinfo[unit]) == 0 || ui->ui_alive == 0 || ! 208: ui->ui_ubanum != uban) ! 209: return; ! 210: printf(" il%d", unit); ! 211: il_softc[unit].is_if.if_flags &= ~IFF_RUNNING; ! 212: il_softc[unit].is_flags &= ~ILF_RUNNING; ! 213: ilinit(unit); ! 214: } ! 215: ! 216: /* ! 217: * Initialization of interface; clear recorded pending ! 218: * operations, and reinitialize UNIBUS usage. ! 219: */ ! 220: ilinit(unit) ! 221: int unit; ! 222: { ! 223: register struct il_softc *is = &il_softc[unit]; ! 224: register struct uba_device *ui = ilinfo[unit]; ! 225: register struct ildevice *addr; ! 226: register struct ifnet *ifp = &is->is_if; ! 227: int s; ! 228: ! 229: /* not yet, if address still unknown */ ! 230: if (ifp->if_addrlist == (struct ifaddr *)0) ! 231: return; ! 232: if (is->is_flags & ILF_RUNNING) ! 233: return; ! 234: ! 235: if ((ifp->if_flags & IFF_RUNNING) == 0) { ! 236: if (if_ubainit(&is->is_ifuba, ui->ui_ubanum, ! 237: sizeof (struct il_rheader), (int)btoc(ETHERMTU)) == 0) { ! 238: printf("il%d: can't initialize\n", unit); ! 239: is->is_if.if_flags &= ~IFF_UP; ! 240: return; ! 241: } ! 242: is->is_ubaddr = uballoc(ui->ui_ubanum, (caddr_t)&is->is_stats, ! 243: sizeof (struct il_stats), 0); ! 244: } ! 245: ifp->if_watchdog = ilwatch; ! 246: is->is_scaninterval = ILWATCHINTERVAL; ! 247: ifp->if_timer = is->is_scaninterval; ! 248: addr = (struct ildevice *)ui->ui_addr; ! 249: ! 250: /* ! 251: * Turn off source address insertion (it's faster this way), ! 252: * and set board online. Former doesn't work if board is ! 253: * already online (happens on ubareset), so we put it offline ! 254: * first. ! 255: */ ! 256: s = splimp(); ! 257: addr->il_csr = ILC_RESET; ! 258: if (ilwait(ui, "hardware diag")) { ! 259: is->is_if.if_flags &= ~IFF_UP; ! 260: splx(s); ! 261: return; ! 262: } ! 263: addr->il_csr = ILC_CISA; ! 264: while ((addr->il_csr & IL_CDONE) == 0) ! 265: ; ! 266: /* ! 267: * If we must reprogram this board's physical ethernet ! 268: * address (as for secondary XNS interfaces), we do so ! 269: * before putting it on line, and starting receive requests. ! 270: * If you try this on an older 1010 board, it will total ! 271: * wedge the board. ! 272: */ ! 273: if (is->is_flags & ILF_SETADDR) { ! 274: bcopy((caddr_t)is->is_addr, (caddr_t)&is->is_stats, ! 275: sizeof is->is_addr); ! 276: addr->il_bar = is->is_ubaddr & 0xffff; ! 277: addr->il_bcr = sizeof is->is_addr; ! 278: addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_LDPA; ! 279: if (ilwait(ui, "setaddr")) ! 280: return; ! 281: addr->il_bar = is->is_ubaddr & 0xffff; ! 282: addr->il_bcr = sizeof (struct il_stats); ! 283: addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT; ! 284: if (ilwait(ui, "verifying setaddr")) ! 285: return; ! 286: if (bcmp((caddr_t)is->is_stats.ils_addr, (caddr_t)is->is_addr, ! 287: sizeof (is->is_addr)) != 0) { ! 288: printf("il%d: setaddr didn't work\n", ui->ui_unit); ! 289: return; ! 290: } ! 291: } ! 292: /* ! 293: * Set board online. ! 294: * Hang receive buffer and start any pending ! 295: * writes by faking a transmit complete. ! 296: * Receive bcr is not a multiple of 8 so buffer ! 297: * chaining can't happen. ! 298: */ ! 299: addr->il_csr = ILC_ONLINE; ! 300: while ((addr->il_csr & IL_CDONE) == 0) ! 301: ; ! 302: addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff; ! 303: addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6; ! 304: addr->il_csr = ! 305: ((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE; ! 306: while ((addr->il_csr & IL_CDONE) == 0) ! 307: ; ! 308: is->is_flags = ILF_OACTIVE; ! 309: is->is_if.if_flags |= IFF_RUNNING; ! 310: is->is_flags |= ILF_RUNNING; ! 311: is->is_lastcmd = 0; ! 312: ilcint(unit); ! 313: splx(s); ! 314: } ! 315: ! 316: /* ! 317: * Start output on interface. ! 318: * Get another datagram to send off of the interface queue, ! 319: * and map it to the interface before starting the output. ! 320: */ ! 321: ilstart(dev) ! 322: dev_t dev; ! 323: { ! 324: int unit = ILUNIT(dev), len; ! 325: struct uba_device *ui = ilinfo[unit]; ! 326: register struct il_softc *is = &il_softc[unit]; ! 327: register struct ildevice *addr; ! 328: struct mbuf *m; ! 329: short csr; ! 330: ! 331: IF_DEQUEUE(&is->is_if.if_snd, m); ! 332: addr = (struct ildevice *)ui->ui_addr; ! 333: if (m == 0) { ! 334: if ((is->is_flags & ILF_STATPENDING) == 0) ! 335: return; ! 336: addr->il_bar = is->is_ubaddr & 0xffff; ! 337: addr->il_bcr = sizeof (struct il_stats); ! 338: csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT|IL_RIE|IL_CIE; ! 339: is->is_flags &= ~ILF_STATPENDING; ! 340: goto startcmd; ! 341: } ! 342: len = if_wubaput(&is->is_ifuba, m); ! 343: /* ! 344: * Ensure minimum packet length. ! 345: * This makes the safe assumtion that there are no virtual holes ! 346: * after the data. ! 347: * For security, it might be wise to zero out the added bytes, ! 348: * but we're mainly interested in speed at the moment. ! 349: */ ! 350: if (len - sizeof(struct ether_header) < ETHERMIN) ! 351: len = ETHERMIN + sizeof(struct ether_header); ! 352: if (is->is_ifuba.ifu_flags & UBA_NEEDBDP) ! 353: UBAPURGE(is->is_ifuba.ifu_uba, is->is_ifuba.ifu_w.ifrw_bdp); ! 354: addr->il_bar = is->is_ifuba.ifu_w.ifrw_info & 0xffff; ! 355: addr->il_bcr = len; ! 356: csr = ! 357: ((is->is_ifuba.ifu_w.ifrw_info >> 2) & IL_EUA)|ILC_XMIT|IL_CIE|IL_RIE; ! 358: ! 359: startcmd: ! 360: is->is_lastcmd = csr & IL_CMD; ! 361: addr->il_csr = csr; ! 362: is->is_flags |= ILF_OACTIVE; ! 363: } ! 364: ! 365: /* ! 366: * Command done interrupt. ! 367: */ ! 368: ilcint(unit) ! 369: int unit; ! 370: { ! 371: register struct il_softc *is = &il_softc[unit]; ! 372: struct uba_device *ui = ilinfo[unit]; ! 373: register struct ildevice *addr = (struct ildevice *)ui->ui_addr; ! 374: short csr; ! 375: ! 376: if ((is->is_flags & ILF_OACTIVE) == 0) { ! 377: printf("il%d: stray xmit interrupt, csr=%b\n", unit, ! 378: addr->il_csr, IL_BITS); ! 379: return; ! 380: } ! 381: ! 382: csr = addr->il_csr; ! 383: /* ! 384: * Hang receive buffer if it couldn't ! 385: * be done earlier (in ilrint). ! 386: */ ! 387: if (is->is_flags & ILF_RCVPENDING) { ! 388: int s; ! 389: ! 390: addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff; ! 391: addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6; ! 392: addr->il_csr = ! 393: ((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE; ! 394: s = splhigh(); ! 395: while ((addr->il_csr & IL_CDONE) == 0) ! 396: ; ! 397: splx(s); ! 398: is->is_flags &= ~ILF_RCVPENDING; ! 399: } ! 400: is->is_flags &= ~ILF_OACTIVE; ! 401: csr &= IL_STATUS; ! 402: switch (is->is_lastcmd) { ! 403: ! 404: case ILC_XMIT: ! 405: is->is_if.if_opackets++; ! 406: if (csr > ILERR_RETRIES) ! 407: is->is_if.if_oerrors++; ! 408: break; ! 409: ! 410: case ILC_STAT: ! 411: if (csr == ILERR_SUCCESS) ! 412: iltotal(is); ! 413: break; ! 414: } ! 415: if (is->is_ifuba.ifu_xtofree) { ! 416: m_freem(is->is_ifuba.ifu_xtofree); ! 417: is->is_ifuba.ifu_xtofree = 0; ! 418: } ! 419: ilstart(unit); ! 420: } ! 421: ! 422: /* ! 423: * Ethernet interface receiver interrupt. ! 424: * If input error just drop packet. ! 425: * Otherwise purge input buffered data path and examine ! 426: * packet to determine type. If can't determine length ! 427: * from type, then have to drop packet. Othewise decapsulate ! 428: * packet based on type and pass to type specific higher-level ! 429: * input routine. ! 430: */ ! 431: ilrint(unit) ! 432: int unit; ! 433: { ! 434: register struct il_softc *is = &il_softc[unit]; ! 435: struct ildevice *addr = (struct ildevice *)ilinfo[unit]->ui_addr; ! 436: register struct il_rheader *il; ! 437: struct mbuf *m; ! 438: int len, off, resid, s; ! 439: register struct ifqueue *inq; ! 440: ! 441: is->is_if.if_ipackets++; ! 442: if (is->is_ifuba.ifu_flags & UBA_NEEDBDP) ! 443: UBAPURGE(is->is_ifuba.ifu_uba, is->is_ifuba.ifu_r.ifrw_bdp); ! 444: il = (struct il_rheader *)(is->is_ifuba.ifu_r.ifrw_addr); ! 445: len = il->ilr_length - sizeof(struct il_rheader); ! 446: if ((il->ilr_status&(ILFSTAT_A|ILFSTAT_C)) || len < 46 || ! 447: len > ETHERMTU) { ! 448: is->is_if.if_ierrors++; ! 449: #ifdef notdef ! 450: if (is->is_if.if_ierrors % 100 == 0) ! 451: printf("il%d: += 100 input errors\n", unit); ! 452: #endif ! 453: goto setup; ! 454: } ! 455: ! 456: /* ! 457: * Deal with trailer protocol: if type is trailer type ! 458: * get true type from first 16-bit word past data. ! 459: * Remember that type was trailer by setting off. ! 460: */ ! 461: il->ilr_type = ntohs((u_short)il->ilr_type); ! 462: #define ildataaddr(il, off, type) ((type)(((caddr_t)((il)+1)+(off)))) ! 463: if (il->ilr_type >= ETHERTYPE_TRAIL && ! 464: il->ilr_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) { ! 465: off = (il->ilr_type - ETHERTYPE_TRAIL) * 512; ! 466: if (off >= ETHERMTU) ! 467: goto setup; /* sanity */ ! 468: il->ilr_type = ntohs(*ildataaddr(il, off, u_short *)); ! 469: resid = ntohs(*(ildataaddr(il, off+2, u_short *))); ! 470: if (off + resid > len) ! 471: goto setup; /* sanity */ ! 472: len = off + resid; ! 473: } else ! 474: off = 0; ! 475: if (len == 0) ! 476: goto setup; ! 477: ! 478: /* ! 479: * Pull packet off interface. Off is nonzero if packet ! 480: * has trailing header; ilget will then force this header ! 481: * information to be at the front, but we still have to drop ! 482: * the type and length which are at the front of any trailer data. ! 483: */ ! 484: m = if_rubaget(&is->is_ifuba, len, off, &is->is_if); ! 485: if (m == 0) ! 486: goto setup; ! 487: if (off) { ! 488: struct ifnet *ifp; ! 489: ! 490: ifp = *(mtod(m, struct ifnet **)); ! 491: m->m_off += 2 * sizeof (u_short); ! 492: m->m_len -= 2 * sizeof (u_short); ! 493: *(mtod(m, struct ifnet **)) = ifp; ! 494: } ! 495: switch (il->ilr_type) { ! 496: ! 497: #ifdef INET ! 498: case ETHERTYPE_IP: ! 499: schednetisr(NETISR_IP); ! 500: inq = &ipintrq; ! 501: break; ! 502: ! 503: case ETHERTYPE_ARP: ! 504: arpinput(&is->is_ac, m); ! 505: goto setup; ! 506: #endif ! 507: #ifdef NS ! 508: case ETHERTYPE_NS: ! 509: schednetisr(NETISR_NS); ! 510: inq = &nsintrq; ! 511: break; ! 512: ! 513: #endif ! 514: #if NENETFILTER > 0 ! 515: default: ! 516: { ! 517: register struct mbuf *mtop; ! 518: /* ! 519: * We need the local net header after all. Oh well, ! 520: * this could be improved. ! 521: */ ! 522: MGET(mtop, M_DONTWAIT, MT_DATA); ! 523: if (mtop == 0) { /* no more mbufs? */ ! 524: m_freem(m); /* wasted effort */ ! 525: goto setup; ! 526: } ! 527: il->ilr_type = htons((u_short)il->ilr_type); ! 528: /* undo the swap done earlier */ ! 529: ! 530: /* ! 531: * the struct il_rheader pointed to by "il" ! 532: * contains the received ether header, but ! 533: * the definitions should be more obvious. ! 534: */ ! 535: bcopy(il->ilr_dhost, mtod(mtop, struct ether_header *), ! 536: sizeof(struct ether_header)); ! 537: mtop->m_len = sizeof(struct ether_header); ! 538: IF_ADJ(m); ! 539: mtop->m_next = m; ! 540: enetFilter(is->is_enetunit, mtop, ! 541: (len + sizeof(struct ether_header)) ); ! 542: goto setup; ! 543: } ! 544: #else ! 545: default: ! 546: m_freem(m); ! 547: goto setup; ! 548: #endif NENETFILTER > 0 ! 549: } ! 550: ! 551: s = splimp(); ! 552: if (IF_QFULL(inq)) { ! 553: IF_DROP(inq); ! 554: m_freem(m); ! 555: } else ! 556: IF_ENQUEUE(inq, m); ! 557: splx(s); ! 558: ! 559: setup: ! 560: /* ! 561: * Reset for next packet if possible. ! 562: * If waiting for transmit command completion, set flag ! 563: * and wait until command completes. ! 564: */ ! 565: if (is->is_flags & ILF_OACTIVE) { ! 566: is->is_flags |= ILF_RCVPENDING; ! 567: return; ! 568: } ! 569: addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff; ! 570: addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6; ! 571: addr->il_csr = ! 572: ((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE; ! 573: s = splhigh(); ! 574: while ((addr->il_csr & IL_CDONE) == 0) ! 575: ; ! 576: splx(s); ! 577: } ! 578: ! 579: /* ! 580: * Ethernet output routine. ! 581: * Encapsulate a packet of type family for the local net. ! 582: * Use trailer local net encapsulation if enough data in first ! 583: * packet leaves a multiple of 512 bytes of data in remainder. ! 584: */ ! 585: iloutput(ifp, m0, dst) ! 586: struct ifnet *ifp; ! 587: struct mbuf *m0; ! 588: struct sockaddr *dst; ! 589: { ! 590: int type, s, error; ! 591: u_char edst[6]; ! 592: struct in_addr idst; ! 593: register struct il_softc *is = &il_softc[ifp->if_unit]; ! 594: register struct mbuf *m = m0; ! 595: register struct ether_header *il; ! 596: register int off; ! 597: int usetrailers; ! 598: ! 599: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) { ! 600: error = ENETDOWN; ! 601: goto bad; ! 602: } ! 603: switch (dst->sa_family) { ! 604: ! 605: #ifdef INET ! 606: case AF_INET: ! 607: idst = ((struct sockaddr_in *)dst)->sin_addr; ! 608: if (!arpresolve(&is->is_ac, m, &idst, edst, &usetrailers)) ! 609: return (0); /* if not yet resolved */ ! 610: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len; ! 611: if (usetrailers && off > 0 && (off & 0x1ff) == 0 && ! 612: m->m_off >= MMINOFF + 2 * sizeof (u_short)) { ! 613: type = ETHERTYPE_TRAIL + (off>>9); ! 614: m->m_off -= 2 * sizeof (u_short); ! 615: m->m_len += 2 * sizeof (u_short); ! 616: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP); ! 617: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len); ! 618: goto gottrailertype; ! 619: } ! 620: type = ETHERTYPE_IP; ! 621: off = 0; ! 622: goto gottype; ! 623: #endif ! 624: #ifdef NS ! 625: case AF_NS: ! 626: type = ETHERTYPE_NS; ! 627: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host), ! 628: (caddr_t)edst, sizeof (edst)); ! 629: off = 0; ! 630: goto gottype; ! 631: #endif ! 632: #if NENETFILTER > 0 ! 633: case AF_IMPLINK: ! 634: il = mtod(m, struct ether_header *); ! 635: goto gotheader; ! 636: #endif NENETFILTER ! 637: ! 638: case AF_UNSPEC: ! 639: il = (struct ether_header *)dst->sa_data; ! 640: bcopy((caddr_t)il->ether_dhost, (caddr_t)edst, sizeof (edst)); ! 641: type = il->ether_type; ! 642: goto gottype; ! 643: ! 644: default: ! 645: printf("il%d: can't handle af%d\n", ifp->if_unit, ! 646: dst->sa_family); ! 647: error = EAFNOSUPPORT; ! 648: goto bad; ! 649: } ! 650: ! 651: gottrailertype: ! 652: /* ! 653: * Packet to be sent as trailer: move first packet ! 654: * (control information) to end of chain. ! 655: */ ! 656: while (m->m_next) ! 657: m = m->m_next; ! 658: m->m_next = m0; ! 659: m = m0->m_next; ! 660: m0->m_next = 0; ! 661: m0 = m; ! 662: ! 663: gottype: ! 664: /* ! 665: * Add local net header. If no space in first mbuf, ! 666: * allocate another. ! 667: */ ! 668: if (m->m_off > MMAXOFF || ! 669: MMINOFF + sizeof (struct ether_header) > m->m_off) { ! 670: m = m_get(M_DONTWAIT, MT_HEADER); ! 671: if (m == 0) { ! 672: error = ENOBUFS; ! 673: goto bad; ! 674: } ! 675: m->m_next = m0; ! 676: m->m_off = MMINOFF; ! 677: m->m_len = sizeof (struct ether_header); ! 678: } else { ! 679: m->m_off -= sizeof (struct ether_header); ! 680: m->m_len += sizeof (struct ether_header); ! 681: } ! 682: il = mtod(m, struct ether_header *); ! 683: il->ether_type = htons((u_short)type); ! 684: bcopy((caddr_t)edst, (caddr_t)il->ether_dhost, sizeof (edst)); ! 685: #if NENETFILTER > 0 ! 686: gotheader: ! 687: #endif NENETFILTER ! 688: bcopy((caddr_t)is->is_addr, (caddr_t)il->ether_shost, ! 689: sizeof(il->ether_shost)); ! 690: ! 691: /* ! 692: * Queue message on interface, and start output if interface ! 693: * not yet active. ! 694: */ ! 695: s = splimp(); ! 696: if (IF_QFULL(&ifp->if_snd)) { ! 697: IF_DROP(&ifp->if_snd); ! 698: splx(s); ! 699: m_freem(m); ! 700: return (ENOBUFS); ! 701: } ! 702: IF_ENQUEUE(&ifp->if_snd, m); ! 703: if ((is->is_flags & ILF_OACTIVE) == 0) ! 704: ilstart(ifp->if_unit); ! 705: splx(s); ! 706: return (0); ! 707: ! 708: bad: ! 709: m_freem(m0); ! 710: return (error); ! 711: } ! 712: ! 713: /* ! 714: * Watchdog routine, request statistics from board. ! 715: */ ! 716: ilwatch(unit) ! 717: int unit; ! 718: { ! 719: register struct il_softc *is = &il_softc[unit]; ! 720: register struct ifnet *ifp = &is->is_if; ! 721: int s; ! 722: ! 723: if (is->is_flags & ILF_STATPENDING) { ! 724: ifp->if_timer = is->is_scaninterval; ! 725: return; ! 726: } ! 727: s = splimp(); ! 728: is->is_flags |= ILF_STATPENDING; ! 729: if ((is->is_flags & ILF_OACTIVE) == 0) ! 730: ilstart(ifp->if_unit); ! 731: splx(s); ! 732: ifp->if_timer = is->is_scaninterval; ! 733: } ! 734: ! 735: /* ! 736: * Total up the on-board statistics. ! 737: */ ! 738: iltotal(is) ! 739: register struct il_softc *is; ! 740: { ! 741: register u_short *interval, *sum, *end; ! 742: ! 743: interval = &is->is_stats.ils_frames; ! 744: sum = &is->is_sum.ils_frames; ! 745: end = is->is_sum.ils_fill2; ! 746: while (sum < end) ! 747: *sum++ += *interval++; ! 748: is->is_if.if_collisions = is->is_sum.ils_collis; ! 749: } ! 750: ! 751: /* ! 752: * Process an ioctl request. ! 753: */ ! 754: ilioctl(ifp, cmd, data) ! 755: register struct ifnet *ifp; ! 756: int cmd; ! 757: caddr_t data; ! 758: { ! 759: register struct ifaddr *ifa = (struct ifaddr *)data; ! 760: register struct il_softc *is = &il_softc[ifp->if_unit]; ! 761: int s = splimp(), error = 0; ! 762: ! 763: switch (cmd) { ! 764: ! 765: case SIOCSIFADDR: ! 766: ifp->if_flags |= IFF_UP; ! 767: ilinit(ifp->if_unit); ! 768: ! 769: switch (ifa->ifa_addr.sa_family) { ! 770: #ifdef INET ! 771: case AF_INET: ! 772: ((struct arpcom *)ifp)->ac_ipaddr = ! 773: IA_SIN(ifa)->sin_addr; ! 774: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr); ! 775: break; ! 776: #endif ! 777: #ifdef NS ! 778: case AF_NS: ! 779: { ! 780: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr); ! 781: ! 782: if (ns_nullhost(*ina)) { ! 783: ina->x_host = * (union ns_host *) ! 784: (il_softc[ifp->if_unit].is_addr); ! 785: } else { ! 786: il_setaddr(ina->x_host.c_host, ifp->if_unit); ! 787: return (0); ! 788: } ! 789: break; ! 790: } ! 791: #endif ! 792: } ! 793: break; ! 794: ! 795: case SIOCSIFFLAGS: ! 796: if ((ifp->if_flags & IFF_UP) == 0 && ! 797: is->is_flags & ILF_RUNNING) { ! 798: ((struct ildevice *) ! 799: (ilinfo[ifp->if_unit]->ui_addr))->il_csr = ILC_RESET; ! 800: is->is_flags &= ~ILF_RUNNING; ! 801: } else if (ifp->if_flags & IFF_UP && ! 802: (is->is_flags & ILF_RUNNING) == 0) ! 803: ilinit(ifp->if_unit); ! 804: break; ! 805: ! 806: default: ! 807: error = EINVAL; ! 808: } ! 809: splx(s); ! 810: return (error); ! 811: } ! 812: ! 813: /* ! 814: * set ethernet address for unit ! 815: */ ! 816: il_setaddr(physaddr, unit) ! 817: u_char *physaddr; ! 818: int unit; ! 819: { ! 820: register struct il_softc *is = &il_softc[unit]; ! 821: ! 822: if (! (is->is_flags & ILF_RUNNING)) ! 823: return; ! 824: ! 825: bcopy((caddr_t)physaddr, (caddr_t)is->is_addr, sizeof is->is_addr); ! 826: is->is_flags &= ~ILF_RUNNING; ! 827: is->is_flags |= ILF_SETADDR; ! 828: ilinit(unit); ! 829: } ! 830: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.