![[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] / 43BSDReno / sys / vaxif|
Return to if_il.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxif |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution is only permitted until one year after the first shipment ! 6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 7: * binary forms are permitted provided that: (1) source distributions retain ! 8: * this entire copyright notice and comment, and (2) distributions including ! 9: * binaries display the following acknowledgement: This product includes ! 10: * software developed by the University of California, Berkeley and its ! 11: * contributors'' in the documentation or other materials provided with the ! 12: * distribution and in all advertising materials mentioning features or use ! 13: * of this software. Neither the name of the University nor the names of ! 14: * its contributors may be used to endorse or promote products derived from ! 15: * this software without specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: * ! 20: * @(#)if_il.c 7.7 (Berkeley) 6/28/90 ! 21: */ ! 22: ! 23: #include "il.h" ! 24: #if NIL > 0 ! 25: ! 26: /* ! 27: * Interlan Ethernet Communications Controller interface ! 28: */ ! 29: #include "machine/pte.h" ! 30: ! 31: #include "param.h" ! 32: #include "systm.h" ! 33: #include "mbuf.h" ! 34: #include "buf.h" ! 35: #include "protosw.h" ! 36: #include "socket.h" ! 37: #include "vmmac.h" ! 38: #include "ioctl.h" ! 39: #include "errno.h" ! 40: #include "syslog.h" ! 41: ! 42: #include "../net/if.h" ! 43: #include "../net/netisr.h" ! 44: #include "../net/route.h" ! 45: ! 46: #ifdef INET ! 47: #include "../netinet/in.h" ! 48: #include "../netinet/in_systm.h" ! 49: #include "../netinet/in_var.h" ! 50: #include "../netinet/ip.h" ! 51: #include "../netinet/if_ether.h" ! 52: #endif ! 53: ! 54: #ifdef NS ! 55: #include "../netns/ns.h" ! 56: #include "../netns/ns_if.h" ! 57: #endif ! 58: ! 59: #include "../vax/cpu.h" ! 60: #include "../vax/mtpr.h" ! 61: #include "if_il.h" ! 62: #include "if_ilreg.h" ! 63: #include "if_uba.h" ! 64: #include "../vaxuba/ubareg.h" ! 65: #include "../vaxuba/ubavar.h" ! 66: ! 67: int ilprobe(), ilattach(), ilrint(), ilcint(); ! 68: struct uba_device *ilinfo[NIL]; ! 69: u_short ilstd[] = { 0 }; ! 70: struct uba_driver ildriver = ! 71: { ilprobe, 0, ilattach, 0, ilstd, "il", ilinfo }; ! 72: #define ILUNIT(x) minor(x) ! 73: int ilinit(),iloutput(),ilioctl(),ilreset(),ilwatch(),ilstart(); ! 74: int ildebug = 0; ! 75: ! 76: /* ! 77: * Ethernet software status per interface. ! 78: * ! 79: * Each interface is referenced by a network interface structure, ! 80: * is_if, which the routing code uses to locate the interface. ! 81: * This structure contains the output queue for the interface, its address, ... ! 82: * We also have, for each interface, a UBA interface structure, which ! 83: * contains information about the UNIBUS resources held by the interface: ! 84: * map registers, buffered data paths, etc. Information is cached in this ! 85: * structure for use by the if_uba.c routines in running the interface ! 86: * efficiently. ! 87: */ ! 88: ! 89: struct ether_addr { ! 90: u_char addr[6]; ! 91: }; ! 92: struct il_softc { ! 93: struct arpcom is_ac; /* Ethernet common part */ ! 94: #define is_if is_ac.ac_if /* network-visible interface */ ! 95: #define is_addr is_ac.ac_enaddr /* hardware Ethernet address */ ! 96: struct ifuba is_ifuba; /* UNIBUS resources */ ! 97: int is_flags; ! 98: #define ILF_RCVPENDING 0x2 /* start rcv in ilcint */ ! 99: #define ILF_STATPENDING 0x4 /* stat cmd pending */ ! 100: #define ILF_RUNNING 0x8 /* board is running */ ! 101: #define ILF_SETADDR 0x10 /* physical address is changed */ ! 102: short is_lastcmd; /* can't read csr, so must save it */ ! 103: short is_scaninterval; /* interval of stat collection */ ! 104: #define ILWATCHINTERVAL 60 /* once every 60 seconds */ ! 105: union { ! 106: struct il_stats isu_stats; /* holds on-board statistics */ ! 107: struct ether_addr isu_maddrs[63]; /* multicast addrs */ ! 108: } is_isu; ! 109: #define is_stats is_isu.isu_stats ! 110: #define is_maddrs is_isu.isu_maddrs ! 111: struct il_stats is_sum; /* summation over time */ ! 112: int is_ubaddr; /* mapping registers of is_stats */ ! 113: } il_softc[NIL]; ! 114: ! 115: ilprobe(reg) ! 116: caddr_t reg; ! 117: { ! 118: register int br, cvec; /* r11, r10 value-result */ ! 119: register struct ildevice *addr = (struct ildevice *)reg; ! 120: register i; ! 121: ! 122: #ifdef lint ! 123: br = 0; cvec = br; br = cvec; ! 124: i = 0; ilrint(i); ilcint(i); ilwatch(i); ! 125: #endif ! 126: ! 127: addr->il_csr = ILC_OFFLINE|IL_CIE; ! 128: DELAY(100000); ! 129: i = addr->il_csr; /* clear CDONE */ ! 130: if (cvec > 0 && cvec != 0x200) ! 131: cvec -= 4; ! 132: return (1); ! 133: } ! 134: ! 135: /* ! 136: * Interface exists: make available by filling in network interface ! 137: * record. System will initialize the interface when it is ready ! 138: * to accept packets. A STATUS command is done to get the ethernet ! 139: * address and other interesting data. ! 140: */ ! 141: ilattach(ui) ! 142: struct uba_device *ui; ! 143: { ! 144: register struct il_softc *is = &il_softc[ui->ui_unit]; ! 145: register struct ifnet *ifp = &is->is_if; ! 146: register struct ildevice *addr = (struct ildevice *)ui->ui_addr; ! 147: ! 148: ifp->if_unit = ui->ui_unit; ! 149: ifp->if_name = "il"; ! 150: ifp->if_mtu = ETHERMTU; ! 151: ifp->if_flags = IFF_BROADCAST; ! 152: ! 153: /* ! 154: * Reset the board and map the statistics ! 155: * buffer onto the Unibus. ! 156: */ ! 157: addr->il_csr = ILC_RESET; ! 158: (void)ilwait(ui, "reset"); ! 159: ! 160: is->is_ubaddr = uballoc(ui->ui_ubanum, (caddr_t)&is->is_stats, ! 161: sizeof (struct il_stats), 0); ! 162: addr->il_bar = is->is_ubaddr & 0xffff; ! 163: addr->il_bcr = sizeof (struct il_stats); ! 164: addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT; ! 165: (void)ilwait(ui, "status"); ! 166: ubarelse(ui->ui_ubanum, &is->is_ubaddr); ! 167: if (ildebug) ! 168: printf("il%d: module=%s firmware=%s\n", ui->ui_unit, ! 169: is->is_stats.ils_module, is->is_stats.ils_firmware); ! 170: bcopy((caddr_t)is->is_stats.ils_addr, (caddr_t)is->is_addr, ! 171: sizeof (is->is_addr)); ! 172: printf("il%d: hardware address %s\n", ui->ui_unit, ! 173: ether_sprintf(is->is_addr)); ! 174: ifp->if_init = ilinit; ! 175: ifp->if_output = ether_output; ! 176: ifp->if_ioctl = ilioctl; ! 177: ifp->if_reset = ilreset; ! 178: ifp->if_start = ilstart; ! 179: is->is_ifuba.ifu_flags = UBA_CANTWAIT; ! 180: if_attach(ifp); ! 181: } ! 182: ! 183: ilwait(ui, op) ! 184: struct uba_device *ui; ! 185: char *op; ! 186: { ! 187: register struct ildevice *addr = (struct ildevice *)ui->ui_addr; ! 188: ! 189: while ((addr->il_csr&IL_CDONE) == 0) ! 190: ; ! 191: if (addr->il_csr&IL_STATUS) { ! 192: printf("il%d: %s failed, csr=%b\n", ui->ui_unit, op, ! 193: addr->il_csr, IL_BITS); ! 194: return (-1); ! 195: } ! 196: return (0); ! 197: } ! 198: ! 199: /* ! 200: * Reset of interface after UNIBUS reset. ! 201: * If interface is on specified uba, reset its state. ! 202: */ ! 203: ilreset(unit, uban) ! 204: int unit, uban; ! 205: { ! 206: register struct uba_device *ui; ! 207: ! 208: if (unit >= NIL || (ui = ilinfo[unit]) == 0 || ui->ui_alive == 0 || ! 209: ui->ui_ubanum != uban) ! 210: return; ! 211: printf(" il%d", unit); ! 212: il_softc[unit].is_if.if_flags &= ~IFF_RUNNING; ! 213: il_softc[unit].is_flags &= ~ILF_RUNNING; ! 214: ilinit(unit); ! 215: } ! 216: ! 217: /* ! 218: * Initialization of interface; clear recorded pending ! 219: * operations, and reinitialize UNIBUS usage. ! 220: */ ! 221: ilinit(unit) ! 222: int unit; ! 223: { ! 224: register struct il_softc *is = &il_softc[unit]; ! 225: register struct uba_device *ui = ilinfo[unit]; ! 226: register struct ildevice *addr; ! 227: register struct ifnet *ifp = &is->is_if; ! 228: int s; ! 229: ! 230: /* not yet, if address still unknown */ ! 231: if (ifp->if_addrlist == (struct ifaddr *)0) ! 232: return; ! 233: if (is->is_flags & ILF_RUNNING) ! 234: return; ! 235: ! 236: if ((ifp->if_flags & IFF_RUNNING) == 0) { ! 237: if (if_ubainit(&is->is_ifuba, ui->ui_ubanum, ! 238: sizeof (struct il_rheader), (int)btoc(ETHERMTU)) == 0) { ! 239: printf("il%d: can't initialize\n", unit); ! 240: is->is_if.if_flags &= ~IFF_UP; ! 241: return; ! 242: } ! 243: is->is_ubaddr = uballoc(ui->ui_ubanum, (caddr_t)&is->is_isu, ! 244: sizeof (is->is_isu), 0); ! 245: } ! 246: ifp->if_watchdog = ilwatch; ! 247: is->is_scaninterval = ILWATCHINTERVAL; ! 248: ifp->if_timer = is->is_scaninterval; ! 249: addr = (struct ildevice *)ui->ui_addr; ! 250: ! 251: /* ! 252: * Turn off source address insertion (it's faster this way), ! 253: * and set board online. Former doesn't work if board is ! 254: * already online (happens on ubareset), so we put it offline ! 255: * first. ! 256: */ ! 257: s = splimp(); ! 258: addr->il_csr = ILC_RESET; ! 259: if (ilwait(ui, "hardware diag")) { ! 260: is->is_if.if_flags &= ~IFF_UP; ! 261: splx(s); ! 262: return; ! 263: } ! 264: addr->il_csr = ILC_CISA; ! 265: while ((addr->il_csr & IL_CDONE) == 0) ! 266: ; ! 267: /* ! 268: * If we must reprogram this board's physical ethernet ! 269: * address (as for secondary XNS interfaces), we do so ! 270: * before putting it on line, and starting receive requests. ! 271: * If you try this on an older 1010 board, it will total ! 272: * wedge the board. ! 273: */ ! 274: if (is->is_flags & ILF_SETADDR) { ! 275: bcopy((caddr_t)is->is_addr, (caddr_t)&is->is_isu, ! 276: sizeof is->is_addr); ! 277: addr->il_bar = is->is_ubaddr & 0xffff; ! 278: addr->il_bcr = sizeof is->is_addr; ! 279: addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_LDPA; ! 280: if (ilwait(ui, "setaddr")) ! 281: return; ! 282: addr->il_bar = is->is_ubaddr & 0xffff; ! 283: addr->il_bcr = sizeof (struct il_stats); ! 284: addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT; ! 285: if (ilwait(ui, "verifying setaddr")) ! 286: return; ! 287: if (bcmp((caddr_t)is->is_stats.ils_addr, (caddr_t)is->is_addr, ! 288: sizeof (is->is_addr)) != 0) { ! 289: printf("il%d: setaddr didn't work\n", ui->ui_unit); ! 290: return; ! 291: } ! 292: } ! 293: #ifdef MULTICAST ! 294: if (is->is_if.if_flags & IFF_PROMISC) { ! 295: addr->il_csr = ILC_PRMSC; ! 296: if (ilwait(ui, "all multi")) ! 297: return; ! 298: } else if (is->is_if.if_flags & IFF_ALLMULTI) { ! 299: too_many_multis: ! 300: addr->il_csr = ILC_ALLMC; ! 301: if (ilwait(ui, "all multi")) ! 302: return; ! 303: else { ! 304: int i; ! 305: register struct ether_addr *ep = is->is_maddrs; ! 306: struct ether_multi *enm; ! 307: struct ether_multistep step; ! 308: /* ! 309: * Step through our list of multicast addresses. If we have ! 310: * too many multicast addresses, or if we have to listen to ! 311: * a range of multicast addresses, turn on reception of all ! 312: * multicasts. ! 313: */ ! 314: i = 0; ! 315: ETHER_FIRST_MULTI(step, &is->is_ac, enm); ! 316: while (enm != NULL) { ! 317: if (++i > 63 && k != 0) { ! 318: break; ! 319: } ! 320: *ep++ = *(struct ether_addr *)enm->enm_addrlo; ! 321: ETHER_NEXT_MULTI(step, enm); ! 322: } ! 323: if (i = 0) { ! 324: /* no multicasts! */ ! 325: } else if (i <= 63) { ! 326: addr->il_bar = is->is_ubaddr & 0xffff; ! 327: addr->il_bcr = i * sizeof (struct ether_addr); ! 328: addr->il_csr = ((is->is_ubaddr >> 2) & IL_EUA)| ! 329: LC_LDGRPS; ! 330: if (ilwait(ui, "load multi")) ! 331: return; ! 332: } else { ! 333: is->is_if.if_flags |= IFF_ALLMULTI; ! 334: goto too_many_multis; ! 335: } ! 336: } ! 337: #endif MULTI ! 338: /* ! 339: * Set board online. ! 340: * Hang receive buffer and start any pending ! 341: * writes by faking a transmit complete. ! 342: * Receive bcr is not a multiple of 8 so buffer ! 343: * chaining can't happen. ! 344: */ ! 345: addr->il_csr = ILC_ONLINE; ! 346: while ((addr->il_csr & IL_CDONE) == 0) ! 347: ; ! 348: addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff; ! 349: addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6; ! 350: addr->il_csr = ! 351: ((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE; ! 352: while ((addr->il_csr & IL_CDONE) == 0) ! 353: ; ! 354: is->is_if.if_flags |= IFF_RUNNING | IFF_OACTIVE; ! 355: is->is_flags |= ILF_RUNNING; ! 356: is->is_lastcmd = 0; ! 357: ilcint(unit); ! 358: splx(s); ! 359: } ! 360: ! 361: /* ! 362: * Start output on interface. ! 363: * Get another datagram to send off of the interface queue, ! 364: * and map it to the interface before starting the output. ! 365: */ ! 366: ilstart(ifp) ! 367: register struct ifnet *ifp; ! 368: { ! 369: int unit = ifp->if_unit, len; ! 370: struct uba_device *ui = ilinfo[unit]; ! 371: register struct il_softc *is = &il_softc[unit]; ! 372: register struct ildevice *addr; ! 373: struct mbuf *m; ! 374: short csr; ! 375: ! 376: IF_DEQUEUE(&is->is_if.if_snd, m); ! 377: addr = (struct ildevice *)ui->ui_addr; ! 378: if (m == 0) { ! 379: if ((is->is_flags & ILF_STATPENDING) == 0) ! 380: return (0); ! 381: addr->il_bar = is->is_ubaddr & 0xffff; ! 382: addr->il_bcr = sizeof (struct il_stats); ! 383: csr = ((is->is_ubaddr >> 2) & IL_EUA)|ILC_STAT|IL_RIE|IL_CIE; ! 384: is->is_flags &= ~ILF_STATPENDING; ! 385: goto startcmd; ! 386: } ! 387: len = if_wubaput(&is->is_ifuba, m); ! 388: /* ! 389: * Ensure minimum packet length. ! 390: * This makes the safe assumtion that there are no virtual holes ! 391: * after the data. ! 392: * For security, it might be wise to zero out the added bytes, ! 393: * but we're mainly interested in speed at the moment. ! 394: */ ! 395: if (len - sizeof(struct ether_header) < ETHERMIN) ! 396: len = ETHERMIN + sizeof(struct ether_header); ! 397: if (is->is_ifuba.ifu_flags & UBA_NEEDBDP) ! 398: UBAPURGE(is->is_ifuba.ifu_uba, is->is_ifuba.ifu_w.ifrw_bdp); ! 399: addr->il_bar = is->is_ifuba.ifu_w.ifrw_info & 0xffff; ! 400: addr->il_bcr = len; ! 401: csr = ! 402: ((is->is_ifuba.ifu_w.ifrw_info >> 2) & IL_EUA)|ILC_XMIT|IL_CIE|IL_RIE; ! 403: ! 404: startcmd: ! 405: is->is_lastcmd = csr & IL_CMD; ! 406: addr->il_csr = csr; ! 407: is->is_if.if_flags |= IFF_OACTIVE; ! 408: return (0); ! 409: } ! 410: ! 411: /* ! 412: * Command done interrupt. ! 413: */ ! 414: ilcint(unit) ! 415: int unit; ! 416: { ! 417: register struct il_softc *is = &il_softc[unit]; ! 418: struct uba_device *ui = ilinfo[unit]; ! 419: register struct ildevice *addr = (struct ildevice *)ui->ui_addr; ! 420: short csr; ! 421: ! 422: if ((is->is_if.if_flags & IFF_OACTIVE) == 0) { ! 423: printf("il%d: stray xmit interrupt, csr=%b\n", unit, ! 424: addr->il_csr, IL_BITS); ! 425: return; ! 426: } ! 427: ! 428: csr = addr->il_csr; ! 429: /* ! 430: * Hang receive buffer if it couldn't ! 431: * be done earlier (in ilrint). ! 432: */ ! 433: if (is->is_flags & ILF_RCVPENDING) { ! 434: int s; ! 435: ! 436: addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff; ! 437: addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6; ! 438: addr->il_csr = ! 439: ((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE; ! 440: s = splhigh(); ! 441: while ((addr->il_csr & IL_CDONE) == 0) ! 442: ; ! 443: splx(s); ! 444: is->is_flags &= ~ILF_RCVPENDING; ! 445: } ! 446: is->is_if.if_flags &= ~IFF_OACTIVE; ! 447: csr &= IL_STATUS; ! 448: switch (is->is_lastcmd) { ! 449: ! 450: case ILC_XMIT: ! 451: is->is_if.if_opackets++; ! 452: if (csr > ILERR_RETRIES) ! 453: is->is_if.if_oerrors++; ! 454: break; ! 455: ! 456: case ILC_STAT: ! 457: if (csr == ILERR_SUCCESS) ! 458: iltotal(is); ! 459: break; ! 460: } ! 461: if (is->is_ifuba.ifu_xtofree) { ! 462: m_freem(is->is_ifuba.ifu_xtofree); ! 463: is->is_ifuba.ifu_xtofree = 0; ! 464: } ! 465: (void) ilstart(&is->is_if); ! 466: } ! 467: ! 468: /* ! 469: * Ethernet interface receiver interrupt. ! 470: * If input error just drop packet. ! 471: * Otherwise purge input buffered data path and examine ! 472: * packet to determine type. If can't determine length ! 473: * from type, then have to drop packet. Othewise decapsulate ! 474: * packet based on type and pass to type specific higher-level ! 475: * input routine. ! 476: */ ! 477: ilrint(unit) ! 478: int unit; ! 479: { ! 480: register struct il_softc *is = &il_softc[unit]; ! 481: struct ildevice *addr = (struct ildevice *)ilinfo[unit]->ui_addr; ! 482: register struct il_rheader *il; ! 483: struct mbuf *m; ! 484: int len, off, resid, s; ! 485: register struct ifqueue *inq; ! 486: ! 487: is->is_if.if_ipackets++; ! 488: if (is->is_ifuba.ifu_flags & UBA_NEEDBDP) ! 489: UBAPURGE(is->is_ifuba.ifu_uba, is->is_ifuba.ifu_r.ifrw_bdp); ! 490: il = (struct il_rheader *)(is->is_ifuba.ifu_r.ifrw_addr); ! 491: len = il->ilr_length - sizeof(struct il_rheader); ! 492: if ((il->ilr_status&(ILFSTAT_A|ILFSTAT_C)) || len < 46 || ! 493: len > ETHERMTU) { ! 494: is->is_if.if_ierrors++; ! 495: #ifdef notdef ! 496: if (is->is_if.if_ierrors % 100 == 0) ! 497: printf("il%d: += 100 input errors\n", unit); ! 498: #endif ! 499: goto setup; ! 500: } ! 501: ! 502: /* ! 503: * Deal with trailer protocol: if type is trailer type ! 504: * get true type from first 16-bit word past data. ! 505: * Remember that type was trailer by setting off. ! 506: */ ! 507: il->ilr_type = ntohs((u_short)il->ilr_type); ! 508: #define ildataaddr(il, off, type) ((type)(((caddr_t)((il)+1)+(off)))) ! 509: if (il->ilr_type >= ETHERTYPE_TRAIL && ! 510: il->ilr_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) { ! 511: off = (il->ilr_type - ETHERTYPE_TRAIL) * 512; ! 512: if (off >= ETHERMTU) ! 513: goto setup; /* sanity */ ! 514: il->ilr_type = ntohs(*ildataaddr(il, off, u_short *)); ! 515: resid = ntohs(*(ildataaddr(il, off+2, u_short *))); ! 516: if (off + resid > len) ! 517: goto setup; /* sanity */ ! 518: len = off + resid; ! 519: } else ! 520: off = 0; ! 521: if (len == 0) ! 522: goto setup; ! 523: ! 524: /* ! 525: * Pull packet off interface. Off is nonzero if packet ! 526: * has trailing header; ilget will then force this header ! 527: * information to be at the front, but we still have to drop ! 528: * the type and length which are at the front of any trailer data. ! 529: */ ! 530: m = if_rubaget(&is->is_ifuba, len, off, &is->is_if); ! 531: if (m) ! 532: ether_input(&is->is_if, (struct ether_header *)il->ilr_dhost, m); ! 533: setup: ! 534: /* ! 535: * Reset for next packet if possible. ! 536: * If waiting for transmit command completion, set flag ! 537: * and wait until command completes. ! 538: */ ! 539: if (is->is_if.if_flags & IFF_OACTIVE) { ! 540: is->is_flags |= ILF_RCVPENDING; ! 541: return; ! 542: } ! 543: addr->il_bar = is->is_ifuba.ifu_r.ifrw_info & 0xffff; ! 544: addr->il_bcr = sizeof(struct il_rheader) + ETHERMTU + 6; ! 545: addr->il_csr = ! 546: ((is->is_ifuba.ifu_r.ifrw_info >> 2) & IL_EUA)|ILC_RCV|IL_RIE; ! 547: s = splhigh(); ! 548: while ((addr->il_csr & IL_CDONE) == 0) ! 549: ; ! 550: splx(s); ! 551: } ! 552: /* ! 553: * Watchdog routine, request statistics from board. ! 554: */ ! 555: ilwatch(unit) ! 556: int unit; ! 557: { ! 558: register struct il_softc *is = &il_softc[unit]; ! 559: register struct ifnet *ifp = &is->is_if; ! 560: int s; ! 561: ! 562: if (is->is_flags & ILF_STATPENDING) { ! 563: ifp->if_timer = is->is_scaninterval; ! 564: return; ! 565: } ! 566: s = splimp(); ! 567: is->is_flags |= ILF_STATPENDING; ! 568: if ((is->is_if.if_flags & IFF_OACTIVE) == 0) ! 569: (void) ilstart(ifp); ! 570: splx(s); ! 571: ifp->if_timer = is->is_scaninterval; ! 572: } ! 573: ! 574: /* ! 575: * Total up the on-board statistics. ! 576: */ ! 577: iltotal(is) ! 578: register struct il_softc *is; ! 579: { ! 580: register u_short *interval, *sum, *end; ! 581: ! 582: interval = &is->is_stats.ils_frames; ! 583: sum = &is->is_sum.ils_frames; ! 584: end = is->is_sum.ils_fill2; ! 585: while (sum < end) ! 586: *sum++ += *interval++; ! 587: is->is_if.if_collisions = is->is_sum.ils_collis; ! 588: if ((is->is_flags & ILF_SETADDR) && ! 589: (bcmp((caddr_t)is->is_stats.ils_addr, (caddr_t)is->is_addr, ! 590: sizeof (is->is_addr)) != 0)) { ! 591: log(LOG_ERR, "il%d: physaddr reverted\n", is->is_if.if_unit); ! 592: is->is_flags &= ~ILF_RUNNING; ! 593: ilinit(is->is_if.if_unit); ! 594: } ! 595: } ! 596: ! 597: /* ! 598: * Process an ioctl request. ! 599: */ ! 600: ilioctl(ifp, cmd, data) ! 601: register struct ifnet *ifp; ! 602: int cmd; ! 603: caddr_t data; ! 604: { ! 605: register struct ifaddr *ifa = (struct ifaddr *)data; ! 606: register struct il_softc *is = &il_softc[ifp->if_unit]; ! 607: int s = splimp(), error = 0; ! 608: ! 609: switch (cmd) { ! 610: ! 611: case SIOCSIFADDR: ! 612: ifp->if_flags |= IFF_UP; ! 613: ilinit(ifp->if_unit); ! 614: ! 615: switch (ifa->ifa_addr->sa_family) { ! 616: #ifdef INET ! 617: case AF_INET: ! 618: ((struct arpcom *)ifp)->ac_ipaddr = ! 619: IA_SIN(ifa)->sin_addr; ! 620: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr); ! 621: break; ! 622: #endif ! 623: #ifdef NS ! 624: case AF_NS: ! 625: { ! 626: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr); ! 627: ! 628: if (ns_nullhost(*ina)) { ! 629: ina->x_host = * (union ns_host *) ! 630: (il_softc[ifp->if_unit].is_addr); ! 631: } else { ! 632: il_setaddr(ina->x_host.c_host, ifp->if_unit); ! 633: return (0); ! 634: } ! 635: break; ! 636: } ! 637: #endif ! 638: } ! 639: break; ! 640: ! 641: case SIOCSIFFLAGS: ! 642: if ((ifp->if_flags & IFF_UP) == 0 && ! 643: is->is_flags & ILF_RUNNING) { ! 644: ((struct ildevice *) ! 645: (ilinfo[ifp->if_unit]->ui_addr))->il_csr = ILC_RESET; ! 646: is->is_flags &= ~ILF_RUNNING; ! 647: } else if (ifp->if_flags & IFF_UP && ! 648: (is->is_flags & ILF_RUNNING) == 0) ! 649: ilinit(ifp->if_unit); ! 650: break; ! 651: ! 652: default: ! 653: error = EINVAL; ! 654: } ! 655: splx(s); ! 656: return (error); ! 657: } ! 658: ! 659: /* ! 660: * set ethernet address for unit ! 661: */ ! 662: il_setaddr(physaddr, unit) ! 663: u_char *physaddr; ! 664: int unit; ! 665: { ! 666: register struct il_softc *is = &il_softc[unit]; ! 667: ! 668: if (! (is->is_flags & ILF_RUNNING)) ! 669: return; ! 670: ! 671: bcopy((caddr_t)physaddr, (caddr_t)is->is_addr, sizeof is->is_addr); ! 672: is->is_flags &= ~ILF_RUNNING; ! 673: is->is_flags |= ILF_SETADDR; ! 674: ilinit(unit); ! 675: } ! 676: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.