Annotation of sys/arch/mvme68k/dev/if_ie.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_ie.c,v 1.35 2006/04/16 00:46:32 pascoe Exp $ */
! 2:
! 3: /*-
! 4: * Copyright (c) 1999 Steve Murphree, Jr.
! 5: * Copyright (c) 1995 Theo de Raadt
! 6: * Copyright (c) 1993, 1994, 1995 Charles Hannum.
! 7: * Copyright (c) 1992, 1993, University of Vermont and State
! 8: * Agricultural College.
! 9: * Copyright (c) 1992, 1993, Garrett A. Wollman.
! 10: *
! 11: * Portions:
! 12: * Copyright (c) 1994, 1995, Rafal K. Boni
! 13: * Copyright (c) 1990, 1991, William F. Jolitz
! 14: * Copyright (c) 1990, The Regents of the University of California
! 15: *
! 16: * All rights reserved.
! 17: *
! 18: * Redistribution and use in source and binary forms, with or without
! 19: * modification, are permitted provided that the following conditions
! 20: * are met:
! 21: * 1. Redistributions of source code must retain the above copyright
! 22: * notice, this list of conditions and the following disclaimer.
! 23: * 2. Redistributions in binary form must reproduce the above copyright
! 24: * notice, this list of conditions and the following disclaimer in the
! 25: * documentation and/or other materials provided with the distribution.
! 26: * 3. All advertising materials mentioning features or use of this software
! 27: * must display the following acknowledgement:
! 28: * This product includes software developed by Charles Hannum, by the
! 29: * University of Vermont and State Agricultural College and Garrett A.
! 30: * Wollman, by William F. Jolitz, and by the University of California,
! 31: * Berkeley, Lawrence Berkeley Laboratory, and its contributors.
! 32: * 4. Neither the names of the Universities nor the names of the authors
! 33: * may be used to endorse or promote products derived from this software
! 34: * without specific prior written permission.
! 35: *
! 36: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 37: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 38: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 39: * ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR AUTHORS BE LIABLE
! 40: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 41: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 42: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 43: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 44: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 45: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 46: * SUCH DAMAGE.
! 47: */
! 48:
! 49: /*
! 50: * Intel 82596 Ethernet chip
! 51: * Register, bit, and structure definitions.
! 52: *
! 53: * Original StarLAN driver written by Garrett Wollman with reference to the
! 54: * Clarkson Packet Driver code for this chip written by Russ Nelson and others.
! 55: *
! 56: * BPF support code taken from hpdev/if_le.c, supplied with tcpdump.
! 57: *
! 58: * 3C507 support is loosely based on code donated to NetBSD by Rafal Boni.
! 59: *
! 60: * Majorly cleaned up and 3C507 code merged by Charles Hannum.
! 61: *
! 62: * Converted to SUN ie driver by Charles D. Cranor,
! 63: * October 1994, January 1995.
! 64: * This sun version based on i386 version 1.30.
! 65: */
! 66:
! 67: extern void *etherbuf;
! 68: extern int etherlen;
! 69:
! 70: /*
! 71: Mode of operation:
! 72:
! 73: We run the 82596 in a standard Ethernet mode. We keep NFRAMES
! 74: received frame descriptors around for the receiver to use, and
! 75: NRXBUF associated receive buffer descriptors, both in a circular
! 76: list. Whenever a frame is received, we rotate both lists as
! 77: necessary. (The 596 treats both lists as a simple queue.) We also
! 78: keep a transmit command around so that packets can be sent off
! 79: quickly.
! 80:
! 81: We configure the adapter in AL-LOC = 1 mode, which means that the
! 82: Ethernet/802.3 MAC header is placed at the beginning of the receive
! 83: buffer rather than being split off into various fields in the RFD.
! 84: This also means that we must include this header in the transmit
! 85: buffer as well.
! 86:
! 87: By convention, all transmit commands, and only transmit commands,
! 88: shall have the I (IE_CMD_INTR) bit set in the command. This way,
! 89: when an interrupt arrives at ieintr(), it is immediately possible
! 90: to tell what precisely caused it. ANY OTHER command-sending
! 91: routines should run at splnet(), and should post an acknowledgement
! 92: to every interrupt they generate.
! 93:
! 94: */
! 95:
! 96: #include "bpfilter.h"
! 97:
! 98: #include <sys/param.h>
! 99: #include <sys/systm.h>
! 100: #include <sys/mbuf.h>
! 101: #include <sys/buf.h>
! 102: #include <sys/protosw.h>
! 103: #include <sys/socket.h>
! 104: #include <sys/ioctl.h>
! 105: #include <sys/errno.h>
! 106: #include <sys/syslog.h>
! 107: #include <sys/device.h>
! 108:
! 109: #include <net/if.h>
! 110: #include <net/if_types.h>
! 111: #include <net/if_dl.h>
! 112: #include <net/netisr.h>
! 113: #include <net/route.h>
! 114:
! 115: #if NBPFILTER > 0
! 116: #include <net/bpf.h>
! 117: #include <net/bpfdesc.h>
! 118: #endif
! 119:
! 120: #ifdef INET
! 121: #include <netinet/in.h>
! 122: #include <netinet/in_systm.h>
! 123: #include <netinet/in_var.h>
! 124: #include <netinet/ip.h>
! 125: #include <netinet/if_ether.h>
! 126: #endif
! 127:
! 128: #include <uvm/uvm_extern.h>
! 129:
! 130: #include <machine/autoconf.h>
! 131: #include <machine/cpu.h>
! 132: #include <machine/pmap.h>
! 133:
! 134: #include "mc.h"
! 135: #include "pcctwo.h"
! 136:
! 137: #if NMC > 0
! 138: #include <mvme68k/dev/mcreg.h>
! 139: #endif
! 140: #if NPCCTWO > 0
! 141: #include <mvme68k/dev/pcctworeg.h>
! 142: #endif
! 143:
! 144: #include <mvme68k/dev/if_ie.h>
! 145: #include <mvme68k/dev/i82596.h>
! 146:
! 147: static struct mbuf *last_not_for_us;
! 148: struct vm_map *ie_map; /* for obio */
! 149:
! 150: #define IED_RINT 0x01
! 151: #define IED_TINT 0x02
! 152: #define IED_RNR 0x04
! 153: #define IED_CNA 0x08
! 154: #define IED_READFRAME 0x10
! 155: #define IED_ALL 0x1f
! 156:
! 157: #define ETHER_MIN_LEN 64
! 158: #define ETHER_MAX_LEN 1518
! 159: #define ETHER_ADDR_LEN 6
! 160:
! 161: #define B_PER_F 3 /* recv buffers per frame */
! 162: #define MXFRAMES 300 /* max number of recv frames */
! 163: #define MXRXBUF (MXFRAMES*B_PER_F) /* number of buffers to allocate */
! 164: #define IE_RBUF_SIZE 256 /* size of each receive buffer;
! 165: MUST BE POWER OF TWO */
! 166: #define NTXBUF 2 /* number of transmit commands */
! 167: #define IE_TBUF_SIZE ETHER_MAX_LEN /* length of transmit buffer */
! 168:
! 169: struct ie_softc {
! 170: struct device sc_dev; /* device structure */
! 171: struct intrhand sc_ih, sc_failih; /* interrupt info */
! 172: char sc_failintrname[16 + 4];
! 173:
! 174: caddr_t sc_iobase; /* KVA of base of 24 bit addr space */
! 175: caddr_t sc_maddr; /* KVA of base of chip's RAM (16bit addr sp.)*/
! 176: u_int sc_msize; /* how much RAM we have/use */
! 177: vaddr_t sc_reg; /* KVA of car's register */
! 178: int sc_bustype;
! 179:
! 180: struct arpcom sc_arpcom;/* system arpcom structure */
! 181:
! 182: void (*reset_596)(void *); /* card dependent reset function */
! 183: void (*chan_attn)(void *); /* card dependent attn function */
! 184: void (*run_596)(void *); /* card dependent "go on-line" func */
! 185: void (*memcopy)(const void *, void *, size_t);
! 186: /* card dependent memory copy function */
! 187: void (*memzero)(void *, size_t);
! 188: /* card dependent memory zero function */
! 189: int want_mcsetup; /* mcsetup flag */
! 190: int promisc; /* are we in promisc mode? */
! 191:
! 192: /*
! 193: * pointers to the 3 major control structures
! 194: */
! 195:
! 196: volatile struct ie_sys_conf_ptr *scp;
! 197: volatile struct ie_int_sys_conf_ptr *iscp;
! 198: volatile struct ie_sys_ctl_block *scb;
! 199:
! 200: /*
! 201: * pointer and size of a block of KVA where the buffers
! 202: * are to be allocated from
! 203: */
! 204:
! 205: caddr_t buf_area;
! 206: int buf_area_sz;
! 207:
! 208: /*
! 209: * the actual buffers (recv and xmit)
! 210: */
! 211:
! 212: volatile struct ie_recv_frame_desc *rframes[MXFRAMES];
! 213: volatile struct ie_recv_buf_desc *rbuffs[MXRXBUF];
! 214: volatile char *cbuffs[MXRXBUF];
! 215: int rfhead, rftail, rbhead, rbtail;
! 216:
! 217: volatile struct ie_xmit_cmd *xmit_cmds[NTXBUF];
! 218: volatile struct ie_xmit_buf *xmit_buffs[NTXBUF];
! 219: u_char *xmit_cbuffs[NTXBUF];
! 220: int xmit_busy;
! 221: int xmit_free;
! 222: int xchead, xctail;
! 223:
! 224: struct ie_en_addr mcast_addrs[MAXMCAST + 1];
! 225: int mcast_count;
! 226:
! 227: int nframes; /* number of frames in use */
! 228: int nrxbuf; /* number of recv buffs in use */
! 229:
! 230: #ifdef IEDEBUG
! 231: int sc_debug;
! 232: #endif
! 233: };
! 234:
! 235: void ie_obreset(void *);
! 236: void ie_obattend(void *);
! 237: void ie_obrun(void *);
! 238:
! 239: void iewatchdog(struct ifnet *);
! 240: int ieintr(void *);
! 241: int iefailintr(void *);
! 242: int ieinit(struct ie_softc *);
! 243: int ieioctl(struct ifnet *, u_long, caddr_t);
! 244: void iestart(struct ifnet *);
! 245: void iereset(struct ie_softc *);
! 246: void ie_readframe(struct ie_softc *, int);
! 247: void ie_drop_packet_buffer(struct ie_softc *);
! 248: int command_and_wait(struct ie_softc *, int,
! 249: void volatile *, int);
! 250: void ierint(struct ie_softc *);
! 251: void ietint(struct ie_softc *);
! 252: void setup_bufs(struct ie_softc *);
! 253: int mc_setup(struct ie_softc *, void *);
! 254: void mc_reset(struct ie_softc *);
! 255:
! 256: void ie_setup_config(volatile struct ie_config_cmd *, int, int);
! 257: void ie_ack(struct ie_softc *, u_int);
! 258: int ether_equal(u_char *, u_char *);
! 259: int check_eh(struct ie_softc *, struct ether_header *, int *);
! 260: int ie_buflen(struct ie_softc *, int);
! 261: int ie_packet_len(struct ie_softc *);
! 262: void iexmit(struct ie_softc *);
! 263: int ieget(struct ie_softc *, struct mbuf **, struct ether_header *, int *);
! 264: int ie_setupram(struct ie_softc *);
! 265: void run_tdr(struct ie_softc *, struct ie_tdr_cmd *);
! 266: void iestop(struct ie_softc *);
! 267:
! 268: #ifdef IEDEBUG
! 269: void print_rbd(volatile struct ie_recv_buf_desc *);
! 270:
! 271: int in_ierint = 0;
! 272: int in_ietint = 0;
! 273: #endif
! 274:
! 275: int iematch(struct device *, void *, void *);
! 276: void ieattach(struct device *, struct device *, void *);
! 277:
! 278: struct cfattach ie_ca = {
! 279: sizeof(struct ie_softc), iematch, ieattach
! 280: };
! 281:
! 282: struct cfdriver ie_cd = {
! 283: NULL, "ie", DV_IFNET
! 284: };
! 285:
! 286: /*
! 287: * address generation macros
! 288: */
! 289: /* Make 32 bit value from swapped data (err counters access) */
! 290: #define MK_32(ptr) ((((u_int)(ptr) >> 16) & 0xffff) | ((u_int)(ptr) << 16))
! 291:
! 292: #define MKADR_32(ptr) \
! 293: ((caddr_t)((((u_int)(ptr) >> 16) & 0xffff) | \
! 294: (((u_int)(ptr) << 16)) + UNCACHED_MEMORY_ADDR))
! 295:
! 296: /* *NOTE* The next macros also converts to physical address! */
! 297: #define ASWAP(ptr) ((((u_int)(ptr) >> 16) & 0x1fff) | ((u_int)(ptr) << 16))
! 298:
! 299: #define SWT_32(to, from) { \
! 300: u_int *t = (u_int *)&to; \
! 301: *t = ((((u_int)from >> 16) & 0x1fff) | ((u_int)from << 16)); \
! 302: }
! 303: /*
! 304: * Here are a few useful functions. We could have done these as macros, but
! 305: * since we have the inline facility, it makes sense to use that instead.
! 306: */
! 307: void
! 308: ie_setup_config(cmd, promiscuous, manchester)
! 309: volatile struct ie_config_cmd *cmd;
! 310: int promiscuous, manchester;
! 311: {
! 312:
! 313: cmd->ie_config_count = 0x0e;
! 314: cmd->ie_fifo = 0xc8;
! 315: cmd->ie_save_bad = 0x40;
! 316: cmd->ie_addr_len = 0x2e;
! 317: cmd->ie_priority = 0;
! 318: cmd->ie_ifs = 0x60;
! 319: cmd->ie_slot_low = 0;
! 320: cmd->ie_slot_high = 0xf2;
! 321: cmd->ie_promisc = !!promiscuous | manchester << 2;
! 322: cmd->ie_crs_cdt = 0;
! 323: cmd->ie_min_len = 64;
! 324: cmd->ie_junk = 0xff;
! 325: cmd->ie_dplx = 0x00;
! 326: cmd->ie_miabf = 0x3f;
! 327: }
! 328:
! 329: void
! 330: ie_ack(sc, mask)
! 331: struct ie_softc *sc;
! 332: u_int mask;
! 333: {
! 334: volatile struct ie_sys_ctl_block *scb = sc->scb;
! 335:
! 336: command_and_wait(sc, scb->ie_status & mask, 0, 0);
! 337: }
! 338:
! 339: int
! 340: iematch(parent, vcf, args)
! 341: struct device *parent;
! 342: void *vcf, *args;
! 343: {
! 344: struct confargs *ca = args;
! 345:
! 346: return (!badvaddr((vaddr_t)ca->ca_vaddr, 4));
! 347: }
! 348:
! 349: /*
! 350: * Deep Magic: reset it, then set SCP address again. Pray.
! 351: */
! 352: void
! 353: ie_obreset(arg)
! 354: void *arg;
! 355: {
! 356: struct ie_softc *sc = (struct ie_softc *)arg;
! 357: volatile struct ieob *ieo = (struct ieob *)sc->sc_reg;
! 358: volatile int t;
! 359: u_long a;
! 360:
! 361: a = IE_PORT_RESET;
! 362: ieo->porthigh = a & 0xffff;
! 363: t = 0; t = 1;
! 364: ieo->portlow = a >> 16;
! 365: delay(1000);
! 366:
! 367: pmap_extract(pmap_kernel(), (vaddr_t)sc->scp, &a);
! 368: a |= IE_PORT_NEWSCPADDR;
! 369: ieo->porthigh = a & 0xffff;
! 370: t = 0; t = 1;
! 371: ieo->portlow = a >> 16;
! 372: delay(1000);
! 373: }
! 374:
! 375: void
! 376: ie_obattend(arg)
! 377: void *arg;
! 378: {
! 379: struct ie_softc *sc = (struct ie_softc *)arg;
! 380: volatile struct ieob *ieo = (struct ieob *)sc->sc_reg;
! 381:
! 382: ieo->attn = 1;
! 383: }
! 384:
! 385: /* ARGSUSED */
! 386: void
! 387: ie_obrun(arg)
! 388: void *arg;
! 389: {
! 390: }
! 391:
! 392: /*
! 393: * Taken almost exactly from Bill's if_is.c, then modified beyond recognition.
! 394: */
! 395: void
! 396: ieattach(parent, self, aux)
! 397: struct device *parent, *self;
! 398: void *aux;
! 399: {
! 400: struct ie_softc *sc = (void *) self;
! 401: struct confargs *ca = aux;
! 402: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
! 403: extern void myetheraddr(u_char *); /* should be elsewhere */
! 404: int pri = ca->ca_ipl;
! 405: volatile struct ieob *ieo;
! 406: paddr_t pa;
! 407:
! 408: sc->reset_596 = ie_obreset;
! 409: sc->chan_attn = ie_obattend;
! 410: sc->run_596 = ie_obrun;
! 411: sc->memcopy = bcopy;
! 412: sc->memzero = bzero;
! 413: sc->sc_msize = etherlen;
! 414: sc->sc_reg = ca->ca_vaddr;
! 415: ieo = (volatile struct ieob *)sc->sc_reg;
! 416:
! 417: /* get the first available etherbuf */
! 418: sc->sc_maddr = etherbuf; /* maddr = vaddr */
! 419: if (sc->sc_maddr == NULL) panic("ie: too many ethernet boards");
! 420: if (pmap_extract(pmap_kernel(), (vaddr_t)sc->sc_maddr, &pa) == FALSE)
! 421: panic("ie: pmap_extract");
! 422: sc->sc_iobase = (caddr_t)pa; /* iobase = paddr (24 bit) */
! 423:
! 424: /*printf("maddrP %x iobaseV %x\n", sc->sc_maddr, sc->sc_iobase);*/
! 425:
! 426: (sc->memzero)(sc->sc_maddr, sc->sc_msize);
! 427: sc->iscp = (volatile struct ie_int_sys_conf_ptr *)
! 428: sc->sc_maddr; /* @@ location zero */
! 429: sc->scb = (volatile struct ie_sys_ctl_block *)
! 430: roundup((int)sc->iscp + sizeof(struct ie_int_sys_conf_ptr), 16);
! 431: sc->scp = (struct ie_sys_conf_ptr *)
! 432: roundup((int)sc->scb + sizeof(struct ie_sys_ctl_block), 16);
! 433: /*printf("scpV %x iscpV %x scbV %x\n", sc->scp, sc->iscp, sc->scb);*/
! 434:
! 435: sc->scp->ie_bus_use = 0x44;
! 436: pmap_extract(pmap_kernel(), (vaddr_t)sc->iscp, &pa);
! 437: SWT_32(sc->scp->ie_iscp_ptr, pa);
! 438: /*
! 439: * rest of first page is unused (wasted!), rest of ram
! 440: * for buffers
! 441: */
! 442: sc->buf_area = sc->sc_maddr + NBPG;
! 443: sc->buf_area_sz = sc->sc_msize - NBPG;
! 444: myetheraddr(sc->sc_arpcom.ac_enaddr);
! 445:
! 446: if (ie_setupram(sc) == 0) {
! 447: printf(": RAM CONFIG FAILED!\n");
! 448: /* XXX should reclaim resources? */
! 449: return;
! 450: }
! 451: bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
! 452: ifp->if_softc = sc;
! 453: ifp->if_start = iestart;
! 454: ifp->if_ioctl = ieioctl;
! 455: ifp->if_watchdog = iewatchdog;
! 456: ifp->if_flags =
! 457: IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS | IFF_MULTICAST;
! 458:
! 459: /* Attach the interface. */
! 460: if_attach(ifp);
! 461: ether_ifattach(ifp);
! 462:
! 463: printf(": address %s\n", ether_sprintf(sc->sc_arpcom.ac_enaddr));
! 464:
! 465: sc->sc_bustype = ca->ca_bustype;
! 466:
! 467: sc->sc_ih.ih_fn = ieintr;
! 468: sc->sc_ih.ih_arg = sc;
! 469: sc->sc_ih.ih_ipl = pri;
! 470: sc->sc_failih.ih_fn = iefailintr;
! 471: sc->sc_failih.ih_arg = sc;
! 472: sc->sc_failih.ih_ipl = pri;
! 473:
! 474: snprintf(sc->sc_failintrname, sizeof sc->sc_failintrname, "%s_err", self->dv_xname);
! 475:
! 476: switch (sc->sc_bustype) {
! 477: #if NMC > 0
! 478: case BUS_MC:
! 479: mcintr_establish(MCV_IE, &sc->sc_ih, self->dv_xname);
! 480: sys_mc->mc_ieirq = pri | MC_SC_SNOOP | MC_IRQ_IEN |
! 481: MC_IRQ_ICLR;
! 482: mcintr_establish(MCV_IEFAIL, &sc->sc_failih,
! 483: sc->sc_failintrname);
! 484: sys_mc->mc_iefailirq = pri | MC_IRQ_IEN | MC_IRQ_ICLR;
! 485: break;
! 486: #endif
! 487: #if NPCCTWO > 0
! 488: case BUS_PCCTWO:
! 489: pcctwointr_establish(PCC2V_IE, &sc->sc_ih, self->dv_xname);
! 490: switch (cputyp) {
! 491: #ifdef MVME172
! 492: case CPU_172:
! 493: #endif
! 494: #ifdef MVME177
! 495: case CPU_177:
! 496: #endif
! 497: #if defined(MVME172) || defined(MVME177)
! 498: /* no snooping on 68060 */
! 499: sys_pcc2->pcc2_ieirq = pri | PCC2_SC_INHIBIT |
! 500: PCC2_IRQ_IEN | PCC2_IRQ_ICLR;
! 501: break;
! 502: #endif
! 503: default:
! 504: sys_pcc2->pcc2_ieirq = pri | PCC2_SC_SNOOP |
! 505: PCC2_IRQ_IEN | PCC2_IRQ_ICLR;
! 506: }
! 507: pcctwointr_establish(PCC2V_IEFAIL, &sc->sc_failih,
! 508: sc->sc_failintrname);
! 509: sys_pcc2->pcc2_iefailirq = pri | PCC2_IRQ_IEN |
! 510: PCC2_IRQ_ICLR;
! 511: break;
! 512: #endif
! 513: }
! 514: }
! 515:
! 516: /*
! 517: * Device timeout/watchdog routine. Entered if the device neglects to generate
! 518: * an interrupt after a transmit has been started on it.
! 519: */
! 520: void
! 521: iewatchdog(ifp)
! 522: struct ifnet *ifp;
! 523: {
! 524: struct ie_softc *sc = ifp->if_softc;
! 525:
! 526: log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
! 527: ++sc->sc_arpcom.ac_if.if_oerrors;
! 528:
! 529: iereset(sc);
! 530: }
! 531:
! 532: int
! 533: iefailintr(v)
! 534: void *v;
! 535: {
! 536: struct ie_softc *sc = v;
! 537:
! 538: switch (sc->sc_bustype) {
! 539: #if NMC > 0
! 540: case BUS_MC:
! 541: sys_mc->mc_ieirq |= MC_IRQ_ICLR; /* safe: clear irq */
! 542: sys_mc->mc_iefailirq |= MC_IRQ_ICLR; /* clear failure */
! 543: sys_mc->mc_ieerr = MC_IEERR_SCLR; /* reset error */
! 544: break;
! 545: #endif
! 546: #if NPCCTWO > 0
! 547: case BUS_PCCTWO:
! 548: sys_pcc2->pcc2_ieirq |= PCC2_IRQ_ICLR; /* safe: clear irq */
! 549: sys_pcc2->pcc2_iefailirq |= PCC2_IRQ_ICLR; /* clear failure */
! 550: sys_pcc2->pcc2_ieerr = PCC2_IEERR_SCLR; /* reset error */
! 551: break;
! 552: #endif
! 553: }
! 554:
! 555: iereset(sc);
! 556: return (1);
! 557: }
! 558:
! 559: /*
! 560: * What to do upon receipt of an interrupt.
! 561: */
! 562: int
! 563: ieintr(v)
! 564: void *v;
! 565: {
! 566: struct ie_softc *sc = v;
! 567: register u_short status;
! 568:
! 569: status = sc->scb->ie_status;
! 570: /*printf("I");*/
! 571:
! 572: loop:
! 573: /* Ack interrupts FIRST in case we receive more during the ISR. */
! 574: ie_ack(sc, IE_ST_WHENCE & status);
! 575: switch (sc->sc_bustype) {
! 576: #if NMC > 0
! 577: case BUS_MC:
! 578: sys_mc->mc_ieirq |= MC_IRQ_ICLR; /* clear irq */
! 579: break;
! 580: #endif
! 581: #if NPCCTWO > 0
! 582: case BUS_PCCTWO:
! 583: sys_pcc2->pcc2_ieirq |= PCC2_IRQ_ICLR; /* clear irq */
! 584: break;
! 585: #endif
! 586: }
! 587:
! 588: if (status & (IE_ST_RECV | IE_ST_RNR)) {
! 589: #ifdef IEDEBUG
! 590: in_ierint++;
! 591: if (sc->sc_debug & IED_RINT)
! 592: printf("%s: rint\n", sc->sc_dev.dv_xname);
! 593: #endif
! 594: ierint(sc);
! 595: #ifdef IEDEBUG
! 596: in_ierint--;
! 597: #endif
! 598: }
! 599:
! 600: if (status & IE_ST_DONE) {
! 601: #ifdef IEDEBUG
! 602: in_ietint++;
! 603: if (sc->sc_debug & IED_TINT)
! 604: printf("%s: tint\n", sc->sc_dev.dv_xname);
! 605: #endif
! 606: ietint(sc);
! 607: #ifdef IEDEBUG
! 608: in_ietint--;
! 609: #endif
! 610: }
! 611:
! 612: if (status & IE_ST_RNR) {
! 613: printf("%s: receiver not ready\n", sc->sc_dev.dv_xname);
! 614: sc->sc_arpcom.ac_if.if_ierrors++;
! 615: iereset(sc);
! 616: }
! 617:
! 618: #ifdef IEDEBUG
! 619: if ((status & IE_ST_ALLDONE) && (sc->sc_debug & IED_CNA))
! 620: printf("%s: cna\n", sc->sc_dev.dv_xname);
! 621: #endif
! 622:
! 623: if ((status = sc->scb->ie_status) & IE_ST_WHENCE)
! 624: goto loop;
! 625:
! 626: return 1;
! 627: }
! 628:
! 629: /*
! 630: * Process a received-frame interrupt.
! 631: */
! 632: void
! 633: ierint(sc)
! 634: struct ie_softc *sc;
! 635: {
! 636: volatile struct ie_sys_ctl_block *scb = sc->scb;
! 637: int i, status;
! 638: static int timesthru = 1024;
! 639:
! 640: i = sc->rfhead;
! 641: for (;;) {
! 642: status = sc->rframes[i]->ie_fd_status;
! 643:
! 644: if ((status & IE_FD_COMPLETE) && (status & IE_FD_OK)) {
! 645: sc->sc_arpcom.ac_if.if_ipackets++;
! 646: if (!--timesthru) {
! 647: sc->sc_arpcom.ac_if.if_ierrors +=
! 648: MK_32(scb->ie_err_crc) +
! 649: MK_32(scb->ie_err_align) +
! 650: MK_32(scb->ie_err_resource) +
! 651: MK_32(scb->ie_err_overrun) +
! 652: MK_32(scb->ie_err_coll) +
! 653: MK_32(scb->ie_err_short);
! 654: scb->ie_err_crc = 0;
! 655: scb->ie_err_align = 0;
! 656: scb->ie_err_resource = 0;
! 657: scb->ie_err_overrun = 0;
! 658: scb->ie_err_coll = 0;
! 659: scb->ie_err_short = 0;
! 660: timesthru = 1024;
! 661: }
! 662: ie_readframe(sc, i);
! 663: } else {
! 664: if ((status & IE_FD_RNR) != 0 &&
! 665: (scb->ie_status & IE_RU_READY) == 0) {
! 666: sc->rframes[0]->ie_fd_buf_desc = ASWAP(sc->rbuffs[0]);
! 667: scb->ie_recv_list = ASWAP(sc->rframes[0]);
! 668: command_and_wait(sc, IE_RU_START, 0, 0);
! 669: }
! 670: break;
! 671: }
! 672: i = (i + 1) % sc->nframes;
! 673: }
! 674: }
! 675:
! 676: /*
! 677: * Process a command-complete interrupt. These are only generated by the
! 678: * transmission of frames. This routine is deceptively simple, since most of
! 679: * the real work is done by iestart().
! 680: */
! 681: void
! 682: ietint(sc)
! 683: struct ie_softc *sc;
! 684: {
! 685: int status;
! 686:
! 687: sc->sc_arpcom.ac_if.if_timer = 0;
! 688: sc->sc_arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
! 689:
! 690: status = sc->xmit_cmds[sc->xctail]->ie_xmit_status;
! 691:
! 692: if (!(status & IE_STAT_COMPL) || (status & IE_STAT_BUSY))
! 693: printf("ietint: command still busy!\n");
! 694:
! 695: if (status & IE_STAT_OK) {
! 696: sc->sc_arpcom.ac_if.if_opackets++;
! 697: sc->sc_arpcom.ac_if.if_collisions += status & IE_XS_MAXCOLL;
! 698: } else if (status & IE_STAT_ABORT) {
! 699: printf("%s: send aborted\n", sc->sc_dev.dv_xname);
! 700: sc->sc_arpcom.ac_if.if_oerrors++;
! 701: } else if (status & IE_XS_NOCARRIER) {
! 702: printf("%s: no carrier\n", sc->sc_dev.dv_xname);
! 703: sc->sc_arpcom.ac_if.if_oerrors++;
! 704: } else if (status & IE_XS_LOSTCTS) {
! 705: printf("%s: lost CTS\n", sc->sc_dev.dv_xname);
! 706: sc->sc_arpcom.ac_if.if_oerrors++;
! 707: } else if (status & IE_XS_UNDERRUN) {
! 708: printf("%s: DMA underrun\n", sc->sc_dev.dv_xname);
! 709: sc->sc_arpcom.ac_if.if_oerrors++;
! 710: } else if (status & IE_XS_EXCMAX) {
! 711: printf("%s: too many collisions\n", sc->sc_dev.dv_xname);
! 712: sc->sc_arpcom.ac_if.if_collisions += 16;
! 713: sc->sc_arpcom.ac_if.if_oerrors++;
! 714: }
! 715:
! 716: /*
! 717: * If multicast addresses were added or deleted while transmitting,
! 718: * mc_reset() set the want_mcsetup flag indicating that we should do
! 719: * it.
! 720: */
! 721: if (sc->want_mcsetup) {
! 722: mc_setup(sc, (caddr_t)sc->xmit_cbuffs[sc->xctail]);
! 723: sc->want_mcsetup = 0;
! 724: }
! 725:
! 726: /* Done with the buffer. */
! 727: sc->xmit_free++;
! 728: sc->xmit_busy = 0;
! 729: sc->xctail = (sc->xctail + 1) % NTXBUF;
! 730:
! 731: iestart(&sc->sc_arpcom.ac_if);
! 732: }
! 733:
! 734: /*
! 735: * Compare two Ether/802 addresses for equality, inlined and unrolled for
! 736: * speed. I'd love to have an inline assembler version of this...
! 737: */
! 738: int
! 739: ether_equal(one, two)
! 740: u_char *one, *two;
! 741: {
! 742:
! 743: if (one[0] != two[0] || one[1] != two[1] || one[2] != two[2] ||
! 744: one[3] != two[3] || one[4] != two[4] || one[5] != two[5])
! 745: return 0;
! 746: return 1;
! 747: }
! 748:
! 749: /*
! 750: * Check for a valid address. to_bpf is filled in with one of the following:
! 751: * 0 -> BPF doesn't get this packet
! 752: * 1 -> BPF does get this packet
! 753: * 2 -> BPF does get this packet, but we don't
! 754: * Return value is true if the packet is for us, and false otherwise.
! 755: *
! 756: * This routine is a mess, but it's also critical that it be as fast
! 757: * as possible. It could be made cleaner if we can assume that the
! 758: * only client which will fiddle with IFF_PROMISC is BPF. This is
! 759: * probably a good assumption, but we do not make it here. (Yet.)
! 760: */
! 761: int
! 762: check_eh(sc, eh, to_bpf)
! 763: struct ie_softc *sc;
! 764: struct ether_header *eh;
! 765: int *to_bpf;
! 766: {
! 767: int i;
! 768:
! 769: switch(sc->promisc) {
! 770: case IFF_ALLMULTI:
! 771: /*
! 772: * Receiving all multicasts, but no unicasts except those
! 773: * destined for us.
! 774: */
! 775: #if NBPFILTER > 0
! 776: *to_bpf = (sc->sc_arpcom.ac_if.if_bpf != 0); /* BPF gets this packet if anybody cares */
! 777: #endif
! 778: if (eh->ether_dhost[0] & 1)
! 779: return 1;
! 780: if (ether_equal(eh->ether_dhost, sc->sc_arpcom.ac_enaddr)) return 1;
! 781: return 0;
! 782:
! 783: case IFF_PROMISC:
! 784: /*
! 785: * Receiving all packets. These need to be passed on to BPF.
! 786: */
! 787: #if NBPFILTER > 0
! 788: *to_bpf = (sc->sc_arpcom.ac_if.if_bpf != 0) ||
! 789: (sc->sc_arpcom.ac_if.if_bridge != NULL);
! 790: #else
! 791: *to_bpf = (sc->sc_arpcom.ac_if.if_bridge != NULL);
! 792: #endif
! 793: /* If for us, accept and hand up to BPF */
! 794: if (ether_equal(eh->ether_dhost, sc->sc_arpcom.ac_enaddr)) return 1;
! 795:
! 796: #if NBPFILTER > 0
! 797: if (*to_bpf && sc->sc_arpcom.ac_if.if_bridge == NULL)
! 798: *to_bpf = 2; /* we don't need to see it */
! 799: #endif
! 800:
! 801: /*
! 802: * Not a multicast, so BPF wants to see it but we don't.
! 803: */
! 804: if (!(eh->ether_dhost[0] & 1))
! 805: return 1;
! 806:
! 807: /*
! 808: * If it's one of our multicast groups, accept it and pass it
! 809: * up.
! 810: */
! 811: for (i = 0; i < sc->mcast_count; i++) {
! 812: if (ether_equal(eh->ether_dhost, (u_char *)&sc->mcast_addrs[i])) {
! 813: #if NBPFILTER > 0
! 814: if (*to_bpf)
! 815: *to_bpf = 1;
! 816: #endif
! 817: return 1;
! 818: }
! 819: }
! 820: return 1;
! 821:
! 822: case IFF_ALLMULTI | IFF_PROMISC:
! 823: /*
! 824: * Acting as a multicast router, and BPF running at the same
! 825: * time. Whew! (Hope this is a fast machine...)
! 826: */
! 827: #if NBPFILTER > 0
! 828: *to_bpf = (sc->sc_arpcom.ac_if.if_bpf != 0) ||
! 829: (sc->sc_arpcom.ac_if.if_bridge != NULL);
! 830: #else
! 831: *to_bpf = (sc->sc_arpcom.ac_if.if_bridge != NULL);
! 832: #endif
! 833: /* We want to see multicasts. */
! 834: if (eh->ether_dhost[0] & 1)
! 835: return 1;
! 836:
! 837: /* We want to see our own packets */
! 838: if (ether_equal(eh->ether_dhost, sc->sc_arpcom.ac_enaddr))
! 839: return 1;
! 840:
! 841: /* Anything else goes to BPF but nothing else. */
! 842: #if NBPFILTER > 0
! 843: if (*to_bpf && sc->sc_arpcom.ac_if.if_bridge == NULL)
! 844: *to_bpf = 2;
! 845: #endif
! 846: return 1;
! 847:
! 848: default:
! 849: /*
! 850: * Only accept unicast packets destined for us, or multicasts
! 851: * for groups that we belong to. For now, we assume that the
! 852: * '596 will only return packets that we asked it for. This
! 853: * isn't strictly true (it uses hashing for the multicast
! 854: * filter), but it will do in this case, and we want to get out
! 855: * of here as quickly as possible.
! 856: */
! 857: #if NBPFILTER > 0
! 858: *to_bpf = (sc->sc_arpcom.ac_if.if_bpf != 0);
! 859: #endif
! 860: return 1;
! 861: }
! 862: return 0;
! 863: }
! 864:
! 865: /*
! 866: * We want to isolate the bits that have meaning... This assumes that
! 867: * IE_RBUF_SIZE is an even power of two. If somehow the act_len exceeds
! 868: * the size of the buffer, then we are screwed anyway.
! 869: */
! 870: int
! 871: ie_buflen(sc, head)
! 872: struct ie_softc *sc;
! 873: int head;
! 874: {
! 875:
! 876: return (sc->rbuffs[head]->ie_rbd_actual & (IE_RBUF_SIZE | (IE_RBUF_SIZE - 1)));
! 877: }
! 878:
! 879: int
! 880: ie_packet_len(sc)
! 881: struct ie_softc *sc;
! 882: {
! 883: int i;
! 884: int head = sc->rbhead;
! 885: int acc = 0;
! 886:
! 887: do {
! 888: if (!(sc->rbuffs[sc->rbhead]->ie_rbd_actual & IE_RBD_USED)) {
! 889: #ifdef IEDEBUG
! 890: print_rbd(sc->rbuffs[sc->rbhead]);
! 891: #endif
! 892: log(LOG_ERR, "%s: receive descriptors out of sync at %d\n",
! 893: sc->sc_dev.dv_xname, sc->rbhead);
! 894: iereset(sc);
! 895: return -1;
! 896: }
! 897:
! 898: i = sc->rbuffs[head]->ie_rbd_actual & IE_RBD_LAST;
! 899:
! 900: acc += ie_buflen(sc, head);
! 901: head = (head + 1) % sc->nrxbuf;
! 902: } while (!i);
! 903:
! 904: return acc;
! 905: }
! 906:
! 907: /*
! 908: * Setup all necessary artifacts for an XMIT command, and then pass the XMIT
! 909: * command to the chip to be executed. On the way, if we have a BPF listener
! 910: * also give him a copy.
! 911: */
! 912: void
! 913: iexmit(sc)
! 914: struct ie_softc *sc;
! 915: {
! 916:
! 917: #if NBPFILTER > 0
! 918: /*
! 919: * If BPF is listening on this interface, let it see the packet before
! 920: * we push it on the wire.
! 921: */
! 922: if (sc->sc_arpcom.ac_if.if_bpf)
! 923: bpf_tap(sc->sc_arpcom.ac_if.if_bpf,
! 924: sc->xmit_cbuffs[sc->xctail],
! 925: sc->xmit_buffs[sc->xctail]->ie_xmit_flags,
! 926: BPF_DIRECTION_OUT);
! 927: #endif
! 928:
! 929: #if 0
! 930: printf("iexmit base %x cmd %x bfd %x to %x\n",
! 931: sc->sc_maddr,
! 932: sc->xmit_cmds[sc->xctail],
! 933: sc->xmit_buffs[sc->xctail],
! 934: sc->xmit_cbuffs[sc->xctail]);
! 935: #endif
! 936: sc->xmit_buffs[sc->xctail]->ie_xmit_flags |= IE_XMIT_LAST;
! 937: sc->xmit_buffs[sc->xctail]->ie_xmit_next = 0xffffffff;
! 938: SWT_32(sc->xmit_buffs[sc->xctail]->ie_xmit_buf,
! 939: sc->xmit_cbuffs[sc->xctail]);
! 940:
! 941: sc->xmit_cmds[sc->xctail]->com.ie_cmd_link = 0xffffffff;
! 942: sc->xmit_cmds[sc->xctail]->com.ie_cmd_cmd =
! 943: IE_CMD_XMIT | IE_CMD_INTR | IE_CMD_LAST | IE_CMD_FLEX;
! 944:
! 945: sc->xmit_cmds[sc->xctail]->ie_xmit_status = 0;
! 946: sc->xmit_cmds[sc->xctail]->ie_xmit_desc =
! 947: ASWAP(sc->xmit_buffs[sc->xctail]);
! 948: sc->xmit_cmds[sc->xctail]->ie_xmit_count = 0;
! 949:
! 950: sc->scb->ie_command_list =
! 951: ASWAP(sc->xmit_cmds[sc->xctail]);
! 952: command_and_wait(sc, IE_CU_START, 0, 0);
! 953:
! 954: sc->xmit_busy = 1;
! 955: sc->sc_arpcom.ac_if.if_timer = 5;
! 956: }
! 957:
! 958: /*
! 959: * Read data off the interface, and turn it into an mbuf chain.
! 960: *
! 961: * This code is DRAMATICALLY different from the previous version; this
! 962: * version tries to allocate the entire mbuf chain up front, given the
! 963: * length of the data available. This enables us to allocate mbuf
! 964: * clusters in many situations where before we would have had a long
! 965: * chain of partially-full mbufs. This should help to speed up the
! 966: * operation considerably. (Provided that it works, of course.)
! 967: */
! 968: int
! 969: ieget(sc, mp, ehp, to_bpf)
! 970: struct ie_softc *sc;
! 971: struct mbuf **mp;
! 972: struct ether_header *ehp;
! 973: int *to_bpf;
! 974: {
! 975: struct mbuf *m, *top, **mymp;
! 976: int i;
! 977: int offset = 0;
! 978: int totlen, resid;
! 979: int thismboff;
! 980: int head;
! 981:
! 982: totlen = ie_packet_len(sc);
! 983: if (totlen <= 0)
! 984: return -1;
! 985:
! 986: i = sc->rbhead;
! 987:
! 988: /*
! 989: * Snarf the Ethernet header.
! 990: */
! 991: (sc->memcopy)((caddr_t)sc->cbuffs[i], (caddr_t)ehp, sizeof *ehp);
! 992:
! 993: /*
! 994: * As quickly as possible, check if this packet is for us.
! 995: * If not, don't waste a single cycle copying the rest of the
! 996: * packet in.
! 997: * This is only a consideration when FILTER is defined; i.e., when
! 998: * we are either running BPF or doing multicasting.
! 999: */
! 1000: if (!check_eh(sc, ehp, to_bpf)) {
! 1001: ie_drop_packet_buffer(sc);
! 1002: sc->sc_arpcom.ac_if.if_ierrors--; /* just this case, it's not an error */
! 1003: return -1;
! 1004: }
! 1005:
! 1006: MGETHDR(*mp, M_DONTWAIT, MT_DATA);
! 1007: if (!*mp) {
! 1008: ie_drop_packet_buffer(sc);
! 1009: return -1;
! 1010: }
! 1011:
! 1012: m = *mp;
! 1013: m->m_pkthdr.rcvif = &sc->sc_arpcom.ac_if;
! 1014: m->m_len = MHLEN;
! 1015: resid = m->m_pkthdr.len = totlen;
! 1016: top = 0;
! 1017: mymp = ⊤
! 1018:
! 1019: /*
! 1020: * This loop goes through and allocates mbufs for all the data we will
! 1021: * be copying in. It does not actually do the copying yet.
! 1022: */
! 1023: do { /* while (resid > 0) */
! 1024: /*
! 1025: * Try to allocate an mbuf to hold the data that we have. If
! 1026: * we already allocated one, just get another one and stick it
! 1027: * on the end (eventually). If we don't already have one, try
! 1028: * to allocate an mbuf cluster big enough to hold the whole
! 1029: * packet, if we think it's reasonable, or a single mbuf which
! 1030: * may or may not be big enough.
! 1031: * Got that?
! 1032: */
! 1033: if (top) {
! 1034: MGET(m, M_DONTWAIT, MT_DATA);
! 1035: if (!m) {
! 1036: m_freem(top);
! 1037: ie_drop_packet_buffer(sc);
! 1038: return -1;
! 1039: }
! 1040: m->m_len = MLEN;
! 1041: }
! 1042:
! 1043: if (resid >= MINCLSIZE) {
! 1044: MCLGET(m, M_DONTWAIT);
! 1045: if (m->m_flags & M_EXT)
! 1046: m->m_len = min(resid, MCLBYTES);
! 1047: } else {
! 1048: if (resid < m->m_len) {
! 1049: if (!top && resid + max_linkhdr <= m->m_len)
! 1050: m->m_data += max_linkhdr;
! 1051: m->m_len = resid;
! 1052: }
! 1053: }
! 1054: resid -= m->m_len;
! 1055: *mymp = m;
! 1056: mymp = &m->m_next;
! 1057: } while (resid > 0);
! 1058:
! 1059: resid = totlen;
! 1060: m = top;
! 1061: thismboff = 0;
! 1062: head = sc->rbhead;
! 1063:
! 1064: /*
! 1065: * Now we take the mbuf chain (hopefully only one mbuf most of the
! 1066: * time) and stuff the data into it. There are no possible failures at
! 1067: * or after this point.
! 1068: */
! 1069: while (resid > 0) { /* while there's stuff left */
! 1070: int thislen = ie_buflen(sc, head) - offset;
! 1071:
! 1072: /*
! 1073: * If too much data for the current mbuf, then fill the current
! 1074: * one up, go to the next one, and try again.
! 1075: */
! 1076: if (thislen > m->m_len - thismboff) {
! 1077: int newlen = m->m_len - thismboff;
! 1078: (sc->memcopy)((caddr_t)(sc->cbuffs[head] + offset),
! 1079: mtod(m, caddr_t) + thismboff, (u_int)newlen);
! 1080: m = m->m_next;
! 1081: thismboff = 0; /* new mbuf, so no offset */
! 1082: offset += newlen; /* we are now this far
! 1083: into the packet */
! 1084: resid -= newlen; /* so there is this much
! 1085: left to get */
! 1086: continue;
! 1087: }
! 1088:
! 1089: /*
! 1090: * If there is more than enough space in the mbuf to hold the
! 1091: * contents of this buffer, copy everything in, advance
! 1092: * pointers and so on.
! 1093: */
! 1094: if (thislen < m->m_len - thismboff) {
! 1095: (sc->memcopy)((caddr_t)(sc->cbuffs[head] + offset),
! 1096: mtod(m, caddr_t) + thismboff, (u_int)thislen);
! 1097: thismboff += thislen; /* we are this far into the mbuf */
! 1098: resid -= thislen; /* and this much is left */
! 1099: goto nextbuf;
! 1100: }
! 1101:
! 1102: /*
! 1103: * Otherwise, there is exactly enough space to put this
! 1104: * buffer's contents into the current mbuf. Do the combination
! 1105: * of the above actions.
! 1106: */
! 1107: (sc->memcopy)((caddr_t)(sc->cbuffs[head] + offset),
! 1108: mtod(m, caddr_t) + thismboff, (u_int)thislen);
! 1109: m = m->m_next;
! 1110: thismboff = 0; /* new mbuf, start at the beginning */
! 1111: resid -= thislen; /* and we are this far through */
! 1112:
! 1113: /*
! 1114: * Advance all the pointers. We can get here from either of
! 1115: * the last two cases, but never the first.
! 1116: */
! 1117: nextbuf:
! 1118: offset = 0;
! 1119: sc->rbuffs[head]->ie_rbd_actual = 0;
! 1120: sc->rbuffs[head]->ie_rbd_length |= IE_RBD_LAST;
! 1121: sc->rbhead = head = (head + 1) % sc->nrxbuf;
! 1122: sc->rbuffs[sc->rbtail]->ie_rbd_length &= ~IE_RBD_LAST;
! 1123: sc->rbtail = (sc->rbtail + 1) % sc->nrxbuf;
! 1124: }
! 1125:
! 1126: /*
! 1127: * Unless something changed strangely while we were doing the copy, we
! 1128: * have now copied everything in from the shared memory.
! 1129: * This means that we are done.
! 1130: */
! 1131: return 0;
! 1132: }
! 1133:
! 1134: /*
! 1135: * Read frame NUM from unit UNIT (pre-cached as IE).
! 1136: *
! 1137: * This routine reads the RFD at NUM, and copies in the buffers from the list
! 1138: * of RBD, then rotates the RBD and RFD lists so that the receiver doesn't
! 1139: * start complaining. Trailers are DROPPED---there's no point in wasting time
! 1140: * on confusing code to deal with them. Hopefully, this machine will never ARP
! 1141: * for trailers anyway.
! 1142: */
! 1143: void
! 1144: ie_readframe(sc, num)
! 1145: struct ie_softc *sc;
! 1146: int num; /* frame number to read */
! 1147: {
! 1148: int status;
! 1149: struct mbuf *m = 0;
! 1150: struct ether_header eh;
! 1151: #if NBPFILTER > 0
! 1152: int bpf_gets_it = 0;
! 1153: #endif
! 1154:
! 1155: status = sc->rframes[num]->ie_fd_status;
! 1156:
! 1157: /* Immediately advance the RFD list, since we have copied ours now. */
! 1158: sc->rframes[num]->ie_fd_status = 0;
! 1159: sc->rframes[num]->ie_fd_actual = 0;
! 1160: sc->rframes[num]->ie_fd_last |= IE_FD_LAST;
! 1161: sc->rframes[sc->rftail]->ie_fd_last &= ~IE_FD_LAST;
! 1162: sc->rftail = (sc->rftail + 1) % sc->nframes;
! 1163: sc->rfhead = (sc->rfhead + 1) % sc->nframes;
! 1164:
! 1165: if (status & IE_FD_OK) {
! 1166: #if NBPFILTER > 0
! 1167: if (ieget(sc, &m, &eh, &bpf_gets_it)) {
! 1168: #else
! 1169: if (ieget(sc, &m, &eh, 0)) {
! 1170: #endif
! 1171: sc->sc_arpcom.ac_if.if_ierrors++;
! 1172: return;
! 1173: }
! 1174: }
! 1175:
! 1176: #ifdef IEDEBUG
! 1177: if (sc->sc_debug & IED_READFRAME)
! 1178: printf("%s: frame from ether %s type %x\n", sc->sc_dev.dv_xname,
! 1179: ether_sprintf(eh.ether_shost), (u_int)eh.ether_type);
! 1180: #endif
! 1181:
! 1182: if (!m)
! 1183: return;
! 1184:
! 1185: if (last_not_for_us) {
! 1186: m_freem(last_not_for_us);
! 1187: last_not_for_us = 0;
! 1188: }
! 1189:
! 1190: #if NBPFILTER > 0
! 1191: /* Check for a BPF filter; if so, hand it up. */
! 1192: if (bpf_gets_it)
! 1193: bpf_mtap(sc->sc_arpcom.ac_if.if_bpf, m, BPF_DIRECTION_IN);
! 1194:
! 1195: /*
! 1196: * A signal passed up from the filtering code indicating that the
! 1197: * packet is intended for BPF but not for the protocol machinery.
! 1198: * We can save a few cycles by not handing it off to them.
! 1199: */
! 1200: if (bpf_gets_it == 2) {
! 1201: last_not_for_us = m;
! 1202: return;
! 1203: }
! 1204: #endif /* NBPFILTER > 0 */
! 1205:
! 1206: /*
! 1207: * In here there used to be code to check destination addresses upon
! 1208: * receipt of a packet. We have deleted that code, and replaced it
! 1209: * with code to check the address much earlier in the cycle, before
! 1210: * copying the data in; this saves us valuable cycles when operating
! 1211: * as a multicast router or when using BPF.
! 1212: */
! 1213:
! 1214: /*
! 1215: * Finally pass this packet up to higher layers.
! 1216: */
! 1217: ether_input_mbuf(&sc->sc_arpcom.ac_if, m);
! 1218: }
! 1219:
! 1220: void
! 1221: ie_drop_packet_buffer(sc)
! 1222: struct ie_softc *sc;
! 1223: {
! 1224: int i;
! 1225:
! 1226: do {
! 1227: /*
! 1228: * This means we are somehow out of sync. So, we reset the
! 1229: * adapter.
! 1230: */
! 1231: if (!(sc->rbuffs[sc->rbhead]->ie_rbd_actual & IE_RBD_USED)) {
! 1232: #ifdef IEDEBUG
! 1233: print_rbd(sc->rbuffs[sc->rbhead]);
! 1234: #endif
! 1235: log(LOG_ERR, "%s: receive descriptors out of sync at %d\n",
! 1236: sc->sc_dev.dv_xname, sc->rbhead);
! 1237: iereset(sc);
! 1238: return;
! 1239: }
! 1240:
! 1241: i = sc->rbuffs[sc->rbhead]->ie_rbd_actual & IE_RBD_LAST;
! 1242:
! 1243: sc->rbuffs[sc->rbhead]->ie_rbd_length |= IE_RBD_LAST;
! 1244: sc->rbuffs[sc->rbhead]->ie_rbd_actual = 0;
! 1245: sc->rbhead = (sc->rbhead + 1) % sc->nrxbuf;
! 1246: sc->rbuffs[sc->rbtail]->ie_rbd_length &= ~IE_RBD_LAST;
! 1247: sc->rbtail = (sc->rbtail + 1) % sc->nrxbuf;
! 1248: } while (!i);
! 1249: }
! 1250:
! 1251:
! 1252: /*
! 1253: * Start transmission on an interface.
! 1254: */
! 1255: void
! 1256: iestart(ifp)
! 1257: struct ifnet *ifp;
! 1258: {
! 1259: struct ie_softc *sc = ifp->if_softc;
! 1260: struct mbuf *m0, *m;
! 1261: u_char *buffer;
! 1262: u_short len;
! 1263:
! 1264: /*printf("iestart\n");*/
! 1265: if ((ifp->if_flags & IFF_RUNNING) == 0)
! 1266: return;
! 1267:
! 1268: if (sc->xmit_free == 0) {
! 1269: ifp->if_flags |= IFF_OACTIVE;
! 1270: if (!sc->xmit_busy)
! 1271: iexmit(sc);
! 1272: return;
! 1273: }
! 1274:
! 1275: do {
! 1276: IF_DEQUEUE(&sc->sc_arpcom.ac_if.if_snd, m);
! 1277: if (!m)
! 1278: break;
! 1279:
! 1280: len = 0;
! 1281: buffer = sc->xmit_cbuffs[sc->xchead];
! 1282:
! 1283: for (m0 = m; m && (len +m->m_len) < IE_TBUF_SIZE;
! 1284: m = m->m_next) {
! 1285: bcopy(mtod(m, caddr_t), buffer, m->m_len);
! 1286: buffer += m->m_len;
! 1287: len += m->m_len;
! 1288: }
! 1289: if (m)
! 1290: printf("%s: tbuf overflow\n", sc->sc_dev.dv_xname);
! 1291:
! 1292: m_freem(m0);
! 1293:
! 1294: if (len < ETHER_MIN_LEN - ETHER_CRC_LEN) {
! 1295: bzero(buffer, ETHER_MIN_LEN - ETHER_CRC_LEN - len);
! 1296: len = ETHER_MIN_LEN - ETHER_CRC_LEN;
! 1297: buffer += ETHER_MIN_LEN - ETHER_CRC_LEN;
! 1298: }
! 1299:
! 1300: sc->xmit_buffs[sc->xchead]->ie_xmit_flags = len;
! 1301:
! 1302: sc->xmit_free--;
! 1303: sc->xchead = (sc->xchead + 1) % NTXBUF;
! 1304: } while (sc->xmit_free > 0);
! 1305:
! 1306: /* If we stuffed any packets into the card's memory, send now. */
! 1307: if ((sc->xmit_free < NTXBUF) && (!sc->xmit_busy))
! 1308: iexmit(sc);
! 1309:
! 1310: return;
! 1311: }
! 1312:
! 1313: /*
! 1314: * set up IE's ram space
! 1315: */
! 1316: int
! 1317: ie_setupram(sc)
! 1318: struct ie_softc *sc;
! 1319: {
! 1320: volatile struct ie_int_sys_conf_ptr *iscp;
! 1321: volatile struct ie_sys_ctl_block *scb;
! 1322: int s;
! 1323:
! 1324: s = splnet();
! 1325:
! 1326: iscp = sc->iscp;
! 1327: (sc->memzero)((char *) iscp, sizeof *iscp);
! 1328:
! 1329: scb = sc->scb;
! 1330: (sc->memzero)((char *) scb, sizeof *scb);
! 1331: scb->ie_off_timer = 10;
! 1332: scb->ie_on_timer = 10000;
! 1333:
! 1334: iscp->ie_busy = 1; /* ie_busy == char */
! 1335: SWT_32(iscp->ie_base, sc->scb);
! 1336:
! 1337: (sc->reset_596) (sc);
! 1338: (sc->chan_attn) (sc);
! 1339:
! 1340: delay(100); /* wait a while... */
! 1341:
! 1342: if (iscp->ie_busy) {
! 1343: splx(s);
! 1344: return 0;
! 1345: }
! 1346: /*
! 1347: * Acknowledge any interrupts we may have caused...
! 1348: */
! 1349: ie_ack(sc, IE_ST_WHENCE);
! 1350: splx(s);
! 1351:
! 1352: return 1;
! 1353: }
! 1354:
! 1355: void
! 1356: iereset(sc)
! 1357: struct ie_softc *sc;
! 1358: {
! 1359: int s = splnet();
! 1360:
! 1361: printf("%s: reset\n", sc->sc_dev.dv_xname);
! 1362:
! 1363: /* Clear OACTIVE in case we're called from watchdog (frozen xmit). */
! 1364: sc->sc_arpcom.ac_if.if_flags &= ~(IFF_UP | IFF_OACTIVE);
! 1365: ieioctl(&sc->sc_arpcom.ac_if, SIOCSIFFLAGS, 0);
! 1366:
! 1367: /*
! 1368: * Stop i82596 dead in its tracks.
! 1369: */
! 1370: if (command_and_wait(sc, IE_RU_ABORT | IE_CU_ABORT, 0, 0))
! 1371: printf("%s: abort commands timed out\n", sc->sc_dev.dv_xname);
! 1372:
! 1373: if (command_and_wait(sc, IE_RU_DISABLE | IE_CU_STOP, 0, 0))
! 1374: printf("%s: disable commands timed out\n", sc->sc_dev.dv_xname);
! 1375:
! 1376: #ifdef notdef
! 1377: if (!check_ie_present(sc, sc->sc_maddr, sc->sc_msize))
! 1378: panic("ie disappeared!");
! 1379: #endif
! 1380:
! 1381: sc->sc_arpcom.ac_if.if_flags |= IFF_UP;
! 1382: ieioctl(&sc->sc_arpcom.ac_if, SIOCSIFFLAGS, 0);
! 1383:
! 1384: splx(s);
! 1385: }
! 1386:
! 1387: #if 0
! 1388: /*
! 1389: * This is called if we time out.
! 1390: */
! 1391: void
! 1392: chan_attn_timeout(rock)
! 1393: caddr_t rock;
! 1394: {
! 1395:
! 1396: *(int *)rock = 1;
! 1397: }
! 1398: #endif
! 1399:
! 1400: /*
! 1401: * Send a command to the controller and wait for it to either complete
! 1402: * or be accepted, depending on the command. If the command pointer
! 1403: * is null, then pretend that the command is not an action command.
! 1404: * If the command pointer is not null, and the command is an action
! 1405: * command, wait for
! 1406: * ((volatile struct ie_cmd_common *)pcmd)->ie_cmd_status & MASK
! 1407: * to become true.
! 1408: */
! 1409: int
! 1410: command_and_wait(sc, cmd, pcmd, mask)
! 1411: struct ie_softc *sc;
! 1412: int cmd;
! 1413: volatile void *pcmd;
! 1414: int mask;
! 1415: {
! 1416: volatile struct ie_cmd_common *cc = pcmd;
! 1417: volatile struct ie_sys_ctl_block *scb = sc->scb;
! 1418: volatile int timedout = 0;
! 1419: #if 0
! 1420: struct timeout chan_tmo;
! 1421: extern int hz;
! 1422: #endif
! 1423:
! 1424: scb->ie_command = (u_short)cmd;
! 1425:
! 1426: if (IE_ACTION_COMMAND(cmd) && pcmd) {
! 1427: (sc->chan_attn)(sc);
! 1428:
! 1429: #if 0
! 1430: /*
! 1431: * XXX
! 1432: * I don't think this timeout works on suns.
! 1433: * we are at splnet() in the loop, and the timeout
! 1434: * stuff runs at software spl (so it is masked off?).
! 1435: */
! 1436:
! 1437: /*
! 1438: * According to the packet driver, the minimum timeout should
! 1439: * be .369 seconds, which we round up to .4.
! 1440: */
! 1441: timeout_set(&chan_tmo, chan_attn_timeout, (caddr_t)&timedout);
! 1442: timeout_add(&chan_tmo, 2 * hz / 5);
! 1443: #endif
! 1444:
! 1445: /*
! 1446: * Now spin-lock waiting for status. This is not a very nice
! 1447: * thing to do, but I haven't figured out how, or indeed if, we
! 1448: * can put the process waiting for action to sleep. (We may
! 1449: * be getting called through some other timeout running in the
! 1450: * kernel.)
! 1451: */
! 1452: for (;;)
! 1453: if ((cc->ie_cmd_status & mask) || timedout)
! 1454: break;
! 1455: #if 0
! 1456: timeout_del(&chan_tmo);
! 1457: #endif
! 1458:
! 1459: return timedout;
! 1460: } else {
! 1461: /*
! 1462: * Otherwise, just wait for the command to be accepted.
! 1463: */
! 1464: (sc->chan_attn)(sc);
! 1465:
! 1466: while (scb->ie_command)
! 1467: ; /* XXX spin lock */
! 1468:
! 1469: return 0;
! 1470: }
! 1471: }
! 1472:
! 1473: /*
! 1474: * Run the time-domain reflectometer.
! 1475: */
! 1476: void
! 1477: run_tdr(sc, cmd)
! 1478: struct ie_softc *sc;
! 1479: struct ie_tdr_cmd *cmd;
! 1480: {
! 1481: int result;
! 1482:
! 1483: cmd->com.ie_cmd_status = 0;
! 1484: cmd->com.ie_cmd_cmd = IE_CMD_TDR | IE_CMD_LAST;
! 1485: cmd->com.ie_cmd_link = 0xffffffff;
! 1486:
! 1487: sc->scb->ie_command_list = ASWAP(cmd);
! 1488: cmd->ie_tdr_time = 0;
! 1489:
! 1490: if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL) ||
! 1491: !(cmd->com.ie_cmd_status & IE_STAT_OK))
! 1492: result = 0x10000; /* XXX */
! 1493: else
! 1494: result = cmd->ie_tdr_time;
! 1495:
! 1496: ie_ack(sc, IE_ST_WHENCE);
! 1497:
! 1498: if (result & IE_TDR_SUCCESS)
! 1499: return;
! 1500:
! 1501: if (result & 0x10000)
! 1502: printf("%s: TDR command failed\n", sc->sc_dev.dv_xname);
! 1503: else if (result & IE_TDR_XCVR)
! 1504: printf("%s: transceiver problem\n", sc->sc_dev.dv_xname);
! 1505: else if (result & IE_TDR_OPEN)
! 1506: printf("%s: TDR detected an open %d clocks away\n",
! 1507: sc->sc_dev.dv_xname, result & IE_TDR_TIME);
! 1508: else if (result & IE_TDR_SHORT)
! 1509: printf("%s: TDR detected a short %d clocks away\n",
! 1510: sc->sc_dev.dv_xname, result & IE_TDR_TIME);
! 1511: else
! 1512: printf("%s: TDR returned unknown status %x\n",
! 1513: sc->sc_dev.dv_xname, result);
! 1514: }
! 1515:
! 1516: #ifdef notdef
! 1517: /* ALIGN works on 8 byte boundaries.... but 4 byte boundaries are ok for sun */
! 1518: #define _ALLOC(p, n) (bzero(p, n), p += n, p - n)
! 1519: #define ALLOC(p, n) _ALLOC(p, ALIGN(n)) /* XXX convert to this? */
! 1520: #endif
! 1521:
! 1522: #define Align(ptr) ((caddr_t)(((u_long)(ptr) + 3) & ~3L))
! 1523:
! 1524: /*
! 1525: * setup_bufs: set up the buffers
! 1526: *
! 1527: * we have a block of KVA at sc->buf_area which is of size sc->buf_area_sz.
! 1528: * this is to be used for the buffers. the chip indexs its control data
! 1529: * structures with 16 bit offsets, and it indexes actual buffers with
! 1530: * 24 bit addresses. so we should allocate control buffers first so that
! 1531: * we don't overflow the 16 bit offset field. The number of transmit
! 1532: * buffers is fixed at compile time.
! 1533: *
! 1534: * note: this function was written to be easy to understand, rather than
! 1535: * highly efficient (it isn't in the critical path).
! 1536: */
! 1537: void
! 1538: setup_bufs(sc)
! 1539: struct ie_softc *sc;
! 1540: {
! 1541: caddr_t ptr = sc->buf_area; /* memory pool */
! 1542: int n, r;
! 1543:
! 1544: /*
! 1545: * step 0: zero memory and figure out how many recv buffers and
! 1546: * frames we can have. XXX CURRENTLY HARDWIRED AT MAX
! 1547: */
! 1548: (sc->memzero)(ptr, sc->buf_area_sz);
! 1549: ptr = Align(ptr); /* set alignment and stick with it */
! 1550:
! 1551: n = (int)Align(sizeof(struct ie_xmit_cmd)) +
! 1552: (int)Align(sizeof(struct ie_xmit_buf)) + IE_TBUF_SIZE;
! 1553: n *= NTXBUF; /* n = total size of xmit area */
! 1554:
! 1555: n = sc->buf_area_sz - n;/* n = free space for recv stuff */
! 1556:
! 1557: r = (int)Align(sizeof(struct ie_recv_frame_desc)) +
! 1558: (((int)Align(sizeof(struct ie_recv_buf_desc)) + IE_RBUF_SIZE) * B_PER_F);
! 1559:
! 1560: /* r = size of one R frame */
! 1561:
! 1562: sc->nframes = n / r;
! 1563: if (sc->nframes <= 0)
! 1564: panic("ie: bogus buffer calc");
! 1565: if (sc->nframes > MXFRAMES)
! 1566: sc->nframes = MXFRAMES;
! 1567:
! 1568: sc->nrxbuf = sc->nframes * B_PER_F;
! 1569:
! 1570: #ifdef IEDEBUG
! 1571: printf("IEDEBUG: %d frames %d bufs\n", sc->nframes, sc->nrxbuf);
! 1572: #endif
! 1573:
! 1574: /*
! 1575: * step 1a: lay out and zero frame data structures for transmit and recv
! 1576: */
! 1577: for (n = 0; n < NTXBUF; n++) {
! 1578: sc->xmit_cmds[n] = (volatile struct ie_xmit_cmd *) ptr;
! 1579: ptr = Align(ptr + sizeof(struct ie_xmit_cmd));
! 1580: }
! 1581:
! 1582: for (n = 0; n < sc->nframes; n++) {
! 1583: sc->rframes[n] = (volatile struct ie_recv_frame_desc *) ptr;
! 1584: ptr = Align(ptr + sizeof(struct ie_recv_frame_desc));
! 1585: }
! 1586:
! 1587: /*
! 1588: * step 1b: link together the recv frames and set EOL on last one
! 1589: */
! 1590: for (n = 0; n < sc->nframes; n++) {
! 1591: sc->rframes[n]->ie_fd_last = IE_FD_FLEX;
! 1592: sc->rframes[n]->ie_fd_size = 0;
! 1593: sc->rframes[n]->ie_fd_next =
! 1594: ASWAP(sc->rframes[(n + 1) % sc->nframes]);
! 1595: }
! 1596: sc->rframes[sc->nframes - 1]->ie_fd_last |= IE_FD_LAST;
! 1597:
! 1598: /*
! 1599: * step 2a: lay out and zero frame buffer structures for xmit and recv
! 1600: */
! 1601: for (n = 0; n < NTXBUF; n++) {
! 1602: sc->xmit_buffs[n] = (volatile struct ie_xmit_buf *) ptr;
! 1603: ptr = Align(ptr + sizeof(struct ie_xmit_buf));
! 1604: }
! 1605:
! 1606: for (n = 0; n < sc->nrxbuf; n++) {
! 1607: sc->rbuffs[n] = (volatile struct ie_recv_buf_desc *) ptr;
! 1608: ptr = Align(ptr + sizeof(struct ie_recv_buf_desc));
! 1609: }
! 1610:
! 1611: /*
! 1612: * step 2b: link together recv bufs and set EOL on last one
! 1613: */
! 1614: for (n = 0; n < sc->nrxbuf; n++) {
! 1615: sc->rbuffs[n]->ie_rbd_next =
! 1616: ASWAP(sc->rbuffs[(n + 1) % sc->nrxbuf]);
! 1617: }
! 1618: sc->rbuffs[sc->nrxbuf - 1]->ie_rbd_length |= IE_RBD_LAST;
! 1619:
! 1620: /*
! 1621: * step 3: allocate the actual data buffers for xmit and recv
! 1622: * recv buffer gets linked into recv_buf_desc list here
! 1623: */
! 1624: for (n = 0; n < NTXBUF; n++) {
! 1625: sc->xmit_cbuffs[n] = (u_char *) ptr;
! 1626: ptr = Align(ptr + IE_TBUF_SIZE);
! 1627: }
! 1628:
! 1629: /* Pointers to last packet sent and next available transmit buffer. */
! 1630: sc->xchead = sc->xctail = 0;
! 1631:
! 1632: /* Clear transmit-busy flag and set number of free transmit buffers. */
! 1633: sc->xmit_busy = 0;
! 1634: sc->xmit_free = NTXBUF;
! 1635:
! 1636: for (n = 0; n < sc->nrxbuf; n++) {
! 1637: sc->cbuffs[n] = (char *) ptr; /* XXX why char vs uchar? */
! 1638: sc->rbuffs[n]->ie_rbd_length = IE_RBUF_SIZE;
! 1639: SWT_32(sc->rbuffs[n]->ie_rbd_buffer, ptr);
! 1640: ptr = Align(ptr + IE_RBUF_SIZE);
! 1641: }
! 1642:
! 1643: /*
! 1644: * step 4: set the head and tail pointers on receive to keep track of
! 1645: * the order in which RFDs and RBDs are used. link in recv frames
! 1646: * and buffer into the scb.
! 1647: */
! 1648:
! 1649: sc->rfhead = 0;
! 1650: sc->rftail = sc->nframes - 1;
! 1651: sc->rbhead = 0;
! 1652: sc->rbtail = sc->nrxbuf - 1;
! 1653:
! 1654: sc->scb->ie_recv_list = ASWAP(sc->rframes[0]);
! 1655: sc->rframes[0]->ie_fd_buf_desc = ASWAP(sc->rbuffs[0]);
! 1656:
! 1657: #ifdef IEDEBUG
! 1658: printf("IE_DEBUG: reserved %d bytes\n", ptr - sc->buf_area);
! 1659: #endif
! 1660: }
! 1661:
! 1662: /*
! 1663: * Run the multicast setup command.
! 1664: * Called at splnet().
! 1665: */
! 1666: int
! 1667: mc_setup(sc, ptr)
! 1668: struct ie_softc *sc;
! 1669: void *ptr;
! 1670: {
! 1671: volatile struct ie_mcast_cmd *cmd = ptr;
! 1672:
! 1673: cmd->com.ie_cmd_status = 0;
! 1674: cmd->com.ie_cmd_cmd = IE_CMD_MCAST | IE_CMD_LAST;
! 1675: cmd->com.ie_cmd_link = 0xffffffff;
! 1676:
! 1677: (sc->memcopy)((caddr_t)sc->mcast_addrs, (caddr_t)cmd->ie_mcast_addrs,
! 1678: sc->mcast_count * sizeof *sc->mcast_addrs);
! 1679:
! 1680: cmd->ie_mcast_bytes = sc->mcast_count * ETHER_ADDR_LEN; /* grrr... */
! 1681:
! 1682: sc->scb->ie_command_list = ASWAP(cmd);
! 1683: if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL) ||
! 1684: !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
! 1685: printf("%s: multicast address setup command failed\n",
! 1686: sc->sc_dev.dv_xname);
! 1687: return 0;
! 1688: }
! 1689: return 1;
! 1690: }
! 1691:
! 1692: /*
! 1693: * This routine takes the environment generated by check_ie_present() and adds
! 1694: * to it all the other structures we need to operate the adapter. This
! 1695: * includes executing the CONFIGURE, IA-SETUP, and MC-SETUP commands, starting
! 1696: * the receiver unit, and clearing interrupts.
! 1697: *
! 1698: * THIS ROUTINE MUST BE CALLED AT splnet() OR HIGHER.
! 1699: */
! 1700: int
! 1701: ieinit(sc)
! 1702: struct ie_softc *sc;
! 1703: {
! 1704: volatile struct ie_sys_ctl_block *scb = sc->scb;
! 1705: void *ptr;
! 1706:
! 1707: ptr = sc->buf_area;
! 1708:
! 1709: /*
! 1710: * Set up bus throttles.
! 1711: */
! 1712:
! 1713: {
! 1714: if (command_and_wait(sc, IE_CU_THROTTLE, 0, 0)) {
! 1715: printf("%s: throttle set command failed\n",
! 1716: sc->sc_dev.dv_xname);
! 1717: return 0;
! 1718: }
! 1719: }
! 1720:
! 1721: /*
! 1722: * Send the configure command first.
! 1723: */
! 1724:
! 1725: {
! 1726: volatile struct ie_config_cmd *cmd = ptr;
! 1727:
! 1728: scb->ie_command_list = ASWAP(cmd);
! 1729: cmd->com.ie_cmd_status = 0;
! 1730: cmd->com.ie_cmd_cmd = IE_CMD_CONFIG | IE_CMD_LAST;
! 1731: cmd->com.ie_cmd_link = 0xffffffff;
! 1732:
! 1733: ie_setup_config(cmd, sc->promisc, 0);
! 1734:
! 1735: if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL) ||
! 1736: !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
! 1737: printf("%s: configure command failed\n",
! 1738: sc->sc_dev.dv_xname);
! 1739: return 0;
! 1740: }
! 1741: }
! 1742:
! 1743: /*
! 1744: * Now send the Individual Address Setup command.
! 1745: */
! 1746: {
! 1747: volatile struct ie_iasetup_cmd *cmd = ptr;
! 1748:
! 1749: scb->ie_command_list = ASWAP(cmd);
! 1750: cmd->com.ie_cmd_status = 0;
! 1751: cmd->com.ie_cmd_cmd = IE_CMD_IASETUP | IE_CMD_LAST;
! 1752: cmd->com.ie_cmd_link = 0xffffffff;
! 1753:
! 1754: (sc->memcopy)(sc->sc_arpcom.ac_enaddr,
! 1755: (caddr_t)&cmd->ie_address, sizeof cmd->ie_address);
! 1756:
! 1757: if (command_and_wait(sc, IE_CU_START, cmd, IE_STAT_COMPL) ||
! 1758: !(cmd->com.ie_cmd_status & IE_STAT_OK)) {
! 1759: printf("%s: individual address setup command failed\n",
! 1760: sc->sc_dev.dv_xname);
! 1761: return 0;
! 1762: }
! 1763: }
! 1764:
! 1765: /*
! 1766: * Now run the time-domain reflectometer.
! 1767: */
! 1768: run_tdr(sc, ptr);
! 1769:
! 1770: /*
! 1771: * Acknowledge any interrupts we have generated thus far.
! 1772: */
! 1773: ie_ack(sc, IE_ST_WHENCE);
! 1774:
! 1775: /*
! 1776: * Set up the transmit and recv buffers.
! 1777: */
! 1778: setup_bufs(sc);
! 1779:
! 1780: sc->sc_arpcom.ac_if.if_flags |= IFF_RUNNING; /* tell higher levels that we are here */
! 1781:
! 1782: sc->scb->ie_recv_list = ASWAP(sc->rframes[0]);
! 1783: command_and_wait(sc, IE_RU_START, 0, 0);
! 1784:
! 1785: ie_ack(sc, IE_ST_WHENCE);
! 1786:
! 1787: if (sc->run_596)
! 1788: (sc->run_596)(sc);
! 1789:
! 1790: return 0;
! 1791: }
! 1792:
! 1793: void
! 1794: iestop(sc)
! 1795: struct ie_softc *sc;
! 1796: {
! 1797:
! 1798: command_and_wait(sc, IE_RU_DISABLE, 0, 0);
! 1799: }
! 1800:
! 1801: int
! 1802: ieioctl(ifp, cmd, data)
! 1803: register struct ifnet *ifp;
! 1804: u_long cmd;
! 1805: caddr_t data;
! 1806: {
! 1807: struct ie_softc *sc = ifp->if_softc;
! 1808: struct ifaddr *ifa = (struct ifaddr *)data;
! 1809: struct ifreq *ifr = (struct ifreq *)data;
! 1810: int s, error = 0;
! 1811:
! 1812: s = splnet();
! 1813:
! 1814: if ((error = ether_ioctl(ifp, &sc->sc_arpcom, cmd, data)) > 0) {
! 1815: splx(s);
! 1816: return error;
! 1817: }
! 1818:
! 1819: switch(cmd) {
! 1820:
! 1821: case SIOCSIFADDR:
! 1822: ifp->if_flags |= IFF_UP;
! 1823:
! 1824: switch(ifa->ifa_addr->sa_family) {
! 1825: #ifdef INET
! 1826: case AF_INET:
! 1827: ieinit(sc);
! 1828: arp_ifinit(&sc->sc_arpcom, ifa);
! 1829: break;
! 1830: #endif
! 1831: default:
! 1832: ieinit(sc);
! 1833: break;
! 1834: }
! 1835: break;
! 1836:
! 1837: case SIOCSIFFLAGS:
! 1838: sc->promisc = ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI);
! 1839: if ((ifp->if_flags & IFF_UP) == 0 &&
! 1840: (ifp->if_flags & IFF_RUNNING) != 0) {
! 1841: /*
! 1842: * If interface is marked down and it is running, then
! 1843: * stop it.
! 1844: */
! 1845: iestop(sc);
! 1846: ifp->if_flags &= ~IFF_RUNNING;
! 1847: } else if ((ifp->if_flags & IFF_UP) != 0 &&
! 1848: (ifp->if_flags & IFF_RUNNING) == 0) {
! 1849: /*
! 1850: * If interface is marked up and it is stopped, then
! 1851: * start it.
! 1852: */
! 1853: ieinit(sc);
! 1854: } else {
! 1855: /*
! 1856: * Reset the interface to pick up changes in any other
! 1857: * flags that affect hardware registers.
! 1858: */
! 1859: iestop(sc);
! 1860: ieinit(sc);
! 1861: }
! 1862: #ifdef IEDEBUG
! 1863: if (ifp->if_flags & IFF_DEBUG)
! 1864: sc->sc_debug = IED_ALL;
! 1865: else
! 1866: sc->sc_debug = 0;
! 1867: #endif
! 1868: break;
! 1869:
! 1870: case SIOCADDMULTI:
! 1871: case SIOCDELMULTI:
! 1872: error = (cmd == SIOCADDMULTI) ?
! 1873: ether_addmulti(ifr, &sc->sc_arpcom):
! 1874: ether_delmulti(ifr, &sc->sc_arpcom);
! 1875:
! 1876: if (error == ENETRESET) {
! 1877: /*
! 1878: * Multicast list has changed; set the hardware filter
! 1879: * accordingly.
! 1880: */
! 1881: if (ifp->if_flags & IFF_RUNNING)
! 1882: mc_reset(sc);
! 1883: error = 0;
! 1884: }
! 1885: break;
! 1886:
! 1887: default:
! 1888: error = EINVAL;
! 1889: }
! 1890: splx(s);
! 1891: return error;
! 1892: }
! 1893:
! 1894: void
! 1895: mc_reset(sc)
! 1896: struct ie_softc *sc;
! 1897: {
! 1898: struct ether_multi *enm;
! 1899: struct ether_multistep step;
! 1900:
! 1901: /*
! 1902: * Step through the list of addresses.
! 1903: */
! 1904: sc->mcast_count = 0;
! 1905: ETHER_FIRST_MULTI(step, &sc->sc_arpcom, enm);
! 1906: while (enm) {
! 1907: if (sc->mcast_count >= MAXMCAST ||
! 1908: bcmp(enm->enm_addrlo, enm->enm_addrhi, 6) != 0) {
! 1909: sc->sc_arpcom.ac_if.if_flags |= IFF_ALLMULTI;
! 1910: ieioctl(&sc->sc_arpcom.ac_if, SIOCSIFFLAGS, (void *)0);
! 1911: goto setflag;
! 1912: }
! 1913:
! 1914: bcopy(enm->enm_addrlo, &sc->mcast_addrs[sc->mcast_count], 6);
! 1915: sc->mcast_count++;
! 1916: ETHER_NEXT_MULTI(step, enm);
! 1917: }
! 1918: setflag:
! 1919: sc->want_mcsetup = 1;
! 1920: }
! 1921:
! 1922: #ifdef IEDEBUG
! 1923: void
! 1924: print_rbd(rbd)
! 1925: volatile struct ie_recv_buf_desc *rbd;
! 1926: {
! 1927:
! 1928: printf("RBD at %08lx:\nactual %04x, next %04x, buffer %08x\n"
! 1929: "length %04x, mbz %04x\n", (u_long)rbd, rbd->ie_rbd_actual,
! 1930: rbd->ie_rbd_next, rbd->ie_rbd_buffer, rbd->ie_rbd_length,
! 1931: rbd->mbz);
! 1932: }
! 1933: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_ie.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mvme68k / dev