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