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