Annotation of sys/dev/ic/i82596.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: i82596.c,v 1.26 2006/03/25 22:41:43 djm Exp $ */
! 2: /* $NetBSD: i82586.c,v 1.18 1998/08/15 04:42:42 mycroft Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1998 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Paul Kranenburg and Charles M. Hannum.
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. All advertising materials mentioning features or use of this software
! 20: * must display the following acknowledgement:
! 21: * This product includes software developed by the NetBSD
! 22: * Foundation, Inc. and its contributors.
! 23: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 24: * contributors may be used to endorse or promote products derived
! 25: * from this software without specific prior written permission.
! 26: *
! 27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 37: * POSSIBILITY OF SUCH DAMAGE.
! 38: */
! 39: /*-
! 40: * Copyright (c) 1997 Paul Kranenburg.
! 41: * Copyright (c) 1992, 1993, University of Vermont and State
! 42: * Agricultural College.
! 43: * Copyright (c) 1992, 1993, Garrett A. Wollman.
! 44: *
! 45: * Portions:
! 46: * Copyright (c) 1994, 1995, Rafal K. Boni
! 47: * Copyright (c) 1990, 1991, William F. Jolitz
! 48: * Copyright (c) 1990, The Regents of the University of California
! 49: *
! 50: * All rights reserved.
! 51: *
! 52: * Redistribution and use in source and binary forms, with or without
! 53: * modification, are permitted provided that the following conditions
! 54: * are met:
! 55: * 1. Redistributions of source code must retain the above copyright
! 56: * notice, this list of conditions and the following disclaimer.
! 57: * 2. Redistributions in binary form must reproduce the above copyright
! 58: * notice, this list of conditions and the following disclaimer in the
! 59: * documentation and/or other materials provided with the distribution.
! 60: * 3. All advertising materials mentioning features or use of this software
! 61: * must display the following acknowledgement:
! 62: * This product includes software developed by the University of Vermont
! 63: * and State Agricultural College and Garrett A. Wollman, by William F.
! 64: * Jolitz, and by the University of California, Berkeley, Lawrence
! 65: * Berkeley Laboratory, and its contributors.
! 66: * 4. Neither the names of the Universities nor the names of the authors
! 67: * may be used to endorse or promote products derived from this software
! 68: * without specific prior written permission.
! 69: *
! 70: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 71: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 72: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 73: * ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR AUTHORS BE LIABLE
! 74: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 75: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 76: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 77: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 78: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 79: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 80: * SUCH DAMAGE.
! 81: */
! 82: /*
! 83: * Intel 82586/82596 Ethernet chip
! 84: * Register, bit, and structure definitions.
! 85: *
! 86: * Original StarLAN driver written by Garrett Wollman with reference to the
! 87: * Clarkson Packet Driver code for this chip written by Russ Nelson and others.
! 88: *
! 89: * BPF support code taken from hpdev/if_le.c, supplied with tcpdump.
! 90: *
! 91: * 3C507 support is loosely based on code donated to NetBSD by Rafal Boni.
! 92: *
! 93: * Majorly cleaned up and 3C507 code merged by Charles Hannum.
! 94: *
! 95: * Converted to SUN ie driver by Charles D. Cranor,
! 96: * October 1994, January 1995.
! 97: * This sun version based on i386 version 1.30.
! 98: */
! 99: /*
! 100: * The i82596 is a very painful chip, found in sun3's, sun-4/100's
! 101: * sun-4/200's, and VME based suns. The byte order is all wrong for a
! 102: * SUN, making life difficult. Programming this chip is mostly the same,
! 103: * but certain details differ from system to system. This driver is
! 104: * written so that different "ie" interfaces can be controled by the same
! 105: * driver.
! 106: */
! 107:
! 108: /*
! 109: Mode of operation:
! 110:
! 111: We run the 82596 in a standard Ethernet mode. We keep NFRAMES
! 112: received frame descriptors around for the receiver to use, and
! 113: NRXBUF associated receive buffer descriptors, both in a circular
! 114: list. Whenever a frame is received, we rotate both lists as
! 115: necessary. (The 596 treats both lists as a simple queue.) We also
! 116: keep a transmit command around so that packets can be sent off
! 117: quickly.
! 118:
! 119: We configure the adapter in AL-LOC = 1 mode, which means that the
! 120: Ethernet/802.3 MAC header is placed at the beginning of the receive
! 121: buffer rather than being split off into various fields in the RFD.
! 122: This also means that we must include this header in the transmit
! 123: buffer as well.
! 124:
! 125: By convention, all transmit commands, and only transmit commands,
! 126: shall have the I (IE_CMD_INTR) bit set in the command. This way,
! 127: when an interrupt arrives at i82596_intr(), it is immediately possible
! 128: to tell what precisely caused it. ANY OTHER command-sending
! 129: routines should run at splnet(), and should post an acknowledgement
! 130: to every interrupt they generate.
! 131:
! 132: To save the expense of shipping a command to 82596 every time we
! 133: want to send a frame, we use a linked list of commands consisting
! 134: of alternate XMIT and NOP commands. The links of these elements
! 135: are manipulated (in i82596_xmit()) such that the NOP command loops back
! 136: to itself whenever the following XMIT command is not yet ready to
! 137: go. Whenever an XMIT is ready, the preceding NOP link is pointed
! 138: at it, while its own link field points to the following NOP command.
! 139: Thus, a single transmit command sets off an interlocked traversal
! 140: of the xmit command chain, with the host processor in control of
! 141: the synchronization.
! 142: */
! 143:
! 144: #include "bpfilter.h"
! 145:
! 146: #include <sys/param.h>
! 147: #include <sys/systm.h>
! 148: #include <sys/mbuf.h>
! 149: #include <sys/socket.h>
! 150: #include <sys/ioctl.h>
! 151: #include <sys/errno.h>
! 152: #include <sys/syslog.h>
! 153: #include <sys/device.h>
! 154:
! 155: #include <net/if.h>
! 156: #include <net/if_dl.h>
! 157: #include <net/if_types.h>
! 158: #include <net/if_media.h>
! 159:
! 160: #if NBPFILTER > 0
! 161: #include <net/bpf.h>
! 162: #endif
! 163:
! 164: #ifdef INET
! 165: #include <netinet/in.h>
! 166: #include <netinet/in_systm.h>
! 167: #include <netinet/in_var.h>
! 168: #include <netinet/ip.h>
! 169: #include <netinet/if_ether.h>
! 170: #endif
! 171:
! 172: #include <uvm/uvm_extern.h>
! 173:
! 174: #include <machine/bus.h>
! 175:
! 176: #include <dev/ic/i82596reg.h>
! 177: #include <dev/ic/i82596var.h>
! 178:
! 179: static char *padbuf;
! 180:
! 181: void i82596_reset(struct ie_softc *, int);
! 182: void i82596_watchdog(struct ifnet *);
! 183: int i82596_init(struct ie_softc *);
! 184: int i82596_ioctl(struct ifnet *, u_long, caddr_t);
! 185: void i82596_start(struct ifnet *);
! 186:
! 187: int i82596_rint(struct ie_softc *, int);
! 188: int i82596_tint(struct ie_softc *, int);
! 189:
! 190: int i82596_mediachange(struct ifnet *);
! 191: void i82596_mediastatus(struct ifnet *, struct ifmediareq *);
! 192:
! 193: int i82596_readframe(struct ie_softc *, int);
! 194: int i82596_get_rbd_list(struct ie_softc *,
! 195: u_int16_t *, u_int16_t *, int *);
! 196: void i82596_release_rbd_list(struct ie_softc *, u_int16_t, u_int16_t);
! 197: int i82596_drop_frames(struct ie_softc *);
! 198: int i82596_chk_rx_ring(struct ie_softc *);
! 199:
! 200: void i82596_start_transceiver(struct ie_softc *);
! 201: void i82596_stop(struct ie_softc *);
! 202: void i82596_xmit(struct ie_softc *);
! 203:
! 204: void i82596_setup_bufs(struct ie_softc *);
! 205: void i82596_simple_command(struct ie_softc *, int, int);
! 206: int ie_cfg_setup(struct ie_softc *, int, int, int);
! 207: int ie_ia_setup(struct ie_softc *, int);
! 208: void ie_run_tdr(struct ie_softc *, int);
! 209: int ie_mc_setup(struct ie_softc *, int);
! 210: void ie_mc_reset(struct ie_softc *);
! 211: int i82596_cmd_wait(struct ie_softc *);
! 212:
! 213: #ifdef I82596_DEBUG
! 214: void print_rbd(struct ie_softc *, int);
! 215: #endif
! 216:
! 217: struct cfdriver ie_cd = {
! 218: NULL, "ie", DV_IFNET
! 219: };
! 220:
! 221: /*
! 222: * generic i82596 probe routine
! 223: */
! 224: int
! 225: i82596_probe(sc)
! 226: struct ie_softc *sc;
! 227: {
! 228: int i;
! 229:
! 230: sc->scp = sc->sc_msize - IE_SCP_SZ;
! 231: sc->iscp = 0;
! 232: sc->scb = 32;
! 233:
! 234: (sc->ie_bus_write16)(sc, IE_ISCP_BUSY(sc->iscp), 1);
! 235: (sc->ie_bus_write16)(sc, IE_ISCP_SCB(sc->iscp), sc->scb);
! 236: (sc->ie_bus_write24)(sc, IE_ISCP_BASE(sc->iscp), sc->sc_maddr);
! 237: (sc->ie_bus_write24)(sc, IE_SCP_ISCP(sc->scp), sc->sc_maddr);
! 238: (sc->ie_bus_write16)(sc, IE_SCP_BUS_USE(sc->scp), sc->sysbus);
! 239:
! 240: (sc->hwreset)(sc, IE_CARD_RESET);
! 241:
! 242: if ((sc->ie_bus_read16)(sc, IE_ISCP_BUSY(sc->iscp))) {
! 243: #ifdef I82596_DEBUG
! 244: printf("%s: ISCP set failed\n", sc->sc_dev.dv_xname);
! 245: #endif
! 246: return 0;
! 247: }
! 248:
! 249: if (sc->port) {
! 250: (sc->ie_bus_write24)(sc, sc->scp, 0);
! 251: (sc->ie_bus_write24)(sc, IE_SCP_TEST(sc->scp), -1);
! 252: (sc->port)(sc, IE_PORT_TEST);
! 253: for (i = 9000; i-- &&
! 254: (sc->ie_bus_read16)(sc, IE_SCP_TEST(sc->scp));
! 255: DELAY(100))
! 256: ;
! 257: }
! 258:
! 259: return 1;
! 260: }
! 261:
! 262: /*
! 263: * Front-ends call this function to attach to the MI driver.
! 264: *
! 265: * The front-end has responsibility for managing the ICP and ISCP
! 266: * structures. Both of these are opaque to us. Also, the front-end
! 267: * chooses a location for the SCB which is expected to be addressable
! 268: * (through `sc->scb') as an offset against the shared-memory bus handle.
! 269: *
! 270: * The following MD interface function must be setup by the front-end
! 271: * before calling here:
! 272: *
! 273: * hwreset - board dependent reset
! 274: * hwinit - board dependent initialization
! 275: * chan_attn - channel attention
! 276: * intrhook - board dependent interrupt processing
! 277: * memcopyin - shared memory copy: board to KVA
! 278: * memcopyout - shared memory copy: KVA to board
! 279: * ie_bus_read16 - read a sixteen-bit i82596 pointer
! 280: * ie_bus_write16 - write a sixteen-bit i82596 pointer
! 281: * ie_bus_write24 - write a twenty-four-bit i82596 pointer
! 282: *
! 283: */
! 284: void
! 285: i82596_attach(sc, name, etheraddr, media, nmedia, defmedia)
! 286: struct ie_softc *sc;
! 287: const char *name;
! 288: u_int8_t *etheraddr;
! 289: int *media, nmedia, defmedia;
! 290: {
! 291: int i;
! 292: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
! 293:
! 294: /* Setup SCP+ISCP */
! 295: (sc->ie_bus_write16)(sc, IE_ISCP_BUSY(sc->iscp), 1);
! 296: (sc->ie_bus_write16)(sc, IE_ISCP_SCB(sc->iscp), sc->scb);
! 297: (sc->ie_bus_write24)(sc, IE_ISCP_BASE(sc->iscp), sc->sc_maddr);
! 298: (sc->ie_bus_write24)(sc, IE_SCP_ISCP(sc->scp), sc->sc_maddr +sc->iscp);
! 299: (sc->ie_bus_write16)(sc, IE_SCP_BUS_USE(sc->scp), sc->sysbus);
! 300: (sc->hwreset)(sc, IE_CARD_RESET);
! 301:
! 302: /* Setup Iface */
! 303: bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
! 304: ifp->if_softc = sc;
! 305: ifp->if_start = i82596_start;
! 306: ifp->if_ioctl = i82596_ioctl;
! 307: ifp->if_watchdog = i82596_watchdog;
! 308: ifp->if_flags =
! 309: #ifdef I82596_DEBUG
! 310: IFF_DEBUG |
! 311: #endif
! 312: IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS | IFF_MULTICAST;
! 313: IFQ_SET_READY(&ifp->if_snd);
! 314:
! 315: /* Initialize media goo. */
! 316: ifmedia_init(&sc->sc_media, 0, i82596_mediachange, i82596_mediastatus);
! 317: if (media != NULL) {
! 318: for (i = 0; i < nmedia; i++)
! 319: ifmedia_add(&sc->sc_media, media[i], 0, NULL);
! 320: ifmedia_set(&sc->sc_media, defmedia);
! 321: } else {
! 322: ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_MANUAL, 0, NULL);
! 323: ifmedia_set(&sc->sc_media, IFM_ETHER|IFM_MANUAL);
! 324: }
! 325:
! 326: if (padbuf == NULL) {
! 327: padbuf = malloc(ETHER_MIN_LEN - ETHER_CRC_LEN, M_DEVBUF,
! 328: M_NOWAIT);
! 329: if (padbuf == NULL) {
! 330: printf("%s: can't allocate pad buffer\n",
! 331: sc->sc_dev.dv_xname);
! 332: return;
! 333: }
! 334: bzero(padbuf, ETHER_MIN_LEN - ETHER_CRC_LEN);
! 335: }
! 336:
! 337: /* Attach the interface. */
! 338: if_attach(ifp);
! 339: ether_ifattach(ifp);
! 340:
! 341: printf(" %s v%d.%d, address %s\n", name, sc->sc_vers / 10,
! 342: sc->sc_vers % 10, ether_sprintf(etheraddr));
! 343: }
! 344:
! 345:
! 346: /*
! 347: * Device timeout/watchdog routine.
! 348: * Entered if the device neglects to generate an interrupt after a
! 349: * transmit has been started on it.
! 350: */
! 351: void
! 352: i82596_watchdog(ifp)
! 353: struct ifnet *ifp;
! 354: {
! 355: struct ie_softc *sc = ifp->if_softc;
! 356:
! 357: log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
! 358: ++ifp->if_oerrors;
! 359:
! 360: i82596_reset(sc, 1);
! 361: }
! 362:
! 363: int
! 364: i82596_cmd_wait(sc)
! 365: struct ie_softc *sc;
! 366: {
! 367: /* spin on i82596 command acknowledge; wait at most 0.9 (!) seconds */
! 368: int i, off;
! 369:
! 370: for (i = 180000; i--; DELAY(5)) {
! 371: /* Read the command word */
! 372: off = IE_SCB_CMD(sc->scb);
! 373: bus_space_barrier(sc->bt, sc->bh, off, 2,
! 374: BUS_SPACE_BARRIER_READ);
! 375: if ((sc->ie_bus_read16)(sc, off) == 0) {
! 376: #ifdef I82596_DEBUG
! 377: if (sc->sc_debug & IED_CMDS)
! 378: printf("%s: cmd_wait after %d usec\n",
! 379: sc->sc_dev.dv_xname, (180000 - i) * 5);
! 380: #endif
! 381: return (0);
! 382: }
! 383: }
! 384:
! 385: #ifdef I82596_DEBUG
! 386: if (sc->sc_debug & IED_CMDS)
! 387: printf("i82596_cmd_wait: timo(%ssync): scb status: %b\n",
! 388: sc->async_cmd_inprogress? "a" : "",
! 389: sc->ie_bus_read16(sc, IE_SCB_STATUS(sc->scb)),
! 390: IE_STAT_BITS);
! 391: #endif
! 392: return (1); /* Timeout */
! 393: }
! 394:
! 395: /*
! 396: * Send a command to the controller and wait for it to either complete
! 397: * or be accepted, depending on the command. If the command pointer
! 398: * is null, then pretend that the command is not an action command.
! 399: * If the command pointer is not null, and the command is an action
! 400: * command, wait for one of the MASK bits to turn on in the command's
! 401: * status field.
! 402: * If ASYNC is set, we just call the chip's attention and return.
! 403: * We may have to wait for the command's acceptance later though.
! 404: */
! 405: int
! 406: i82596_start_cmd(sc, cmd, iecmdbuf, mask, async)
! 407: struct ie_softc *sc;
! 408: int cmd;
! 409: int iecmdbuf;
! 410: int mask;
! 411: int async;
! 412: {
! 413: int i, off;
! 414:
! 415: #ifdef I82596_DEBUG
! 416: if (sc->sc_debug & IED_CMDS)
! 417: printf("start_cmd: %p, %x, %x, %b, %ssync\n",
! 418: sc, cmd, iecmdbuf, mask, IE_STAT_BITS, async?"a":"");
! 419: #endif
! 420: if (sc->async_cmd_inprogress != 0) {
! 421: /*
! 422: * If previous command was issued asynchronously, wait
! 423: * for it now.
! 424: */
! 425: if (i82596_cmd_wait(sc) != 0)
! 426: return (1);
! 427: sc->async_cmd_inprogress = 0;
! 428: }
! 429:
! 430: off = IE_SCB_CMD(sc->scb);
! 431: (sc->ie_bus_write16)(sc, off, cmd);
! 432: bus_space_barrier(sc->bt, sc->bh, off, 2, BUS_SPACE_BARRIER_WRITE);
! 433: (sc->chan_attn)(sc);
! 434:
! 435: if (async) {
! 436: sc->async_cmd_inprogress = 1;
! 437: return (0);
! 438: }
! 439:
! 440: if (IE_ACTION_COMMAND(cmd) && iecmdbuf) {
! 441: int status;
! 442: /*
! 443: * Now spin-lock waiting for status. This is not a very nice
! 444: * thing to do, and can kill performance pretty well...
! 445: * According to the packet driver, the minimum timeout
! 446: * should be .369 seconds.
! 447: */
! 448: for (i = 73800; i--; DELAY(5)) {
! 449: /* Read the command status */
! 450: off = IE_CMD_COMMON_STATUS(iecmdbuf);
! 451: bus_space_barrier(sc->bt, sc->bh, off, 2,
! 452: BUS_SPACE_BARRIER_READ);
! 453: status = (sc->ie_bus_read16)(sc, off);
! 454: if (status & mask) {
! 455: #ifdef I82596_DEBUG
! 456: if (sc->sc_debug & IED_CMDS)
! 457: printf("%s: cmd status %b\n",
! 458: sc->sc_dev.dv_xname,
! 459: status, IE_STAT_BITS);
! 460: #endif
! 461: return (0);
! 462: }
! 463: }
! 464:
! 465: } else {
! 466: /*
! 467: * Otherwise, just wait for the command to be accepted.
! 468: */
! 469: return (i82596_cmd_wait(sc));
! 470: }
! 471:
! 472: /* Timeout */
! 473: return (1);
! 474: }
! 475:
! 476: /*
! 477: * Transfer accumulated chip error counters to IF.
! 478: */
! 479: static __inline void
! 480: i82596_count_errors(struct ie_softc *sc)
! 481: {
! 482: int scb = sc->scb;
! 483:
! 484: sc->sc_arpcom.ac_if.if_ierrors +=
! 485: sc->ie_bus_read16(sc, IE_SCB_ERRCRC(scb)) +
! 486: sc->ie_bus_read16(sc, IE_SCB_ERRALN(scb)) +
! 487: sc->ie_bus_read16(sc, IE_SCB_ERRRES(scb)) +
! 488: sc->ie_bus_read16(sc, IE_SCB_ERROVR(scb));
! 489:
! 490: /* Clear error counters */
! 491: sc->ie_bus_write16(sc, IE_SCB_ERRCRC(scb), 0);
! 492: sc->ie_bus_write16(sc, IE_SCB_ERRALN(scb), 0);
! 493: sc->ie_bus_write16(sc, IE_SCB_ERRRES(scb), 0);
! 494: sc->ie_bus_write16(sc, IE_SCB_ERROVR(scb), 0);
! 495: }
! 496:
! 497: static __inline void
! 498: i82596_rx_errors(struct ie_softc *sc, int fn, int status)
! 499: {
! 500: log(LOG_ERR, "%s: rx error (frame# %d): %b\n", sc->sc_dev.dv_xname, fn,
! 501: status, IE_FD_STATUSBITS);
! 502: }
! 503:
! 504: /*
! 505: * i82596 interrupt entry point.
! 506: */
! 507: int
! 508: i82596_intr(v)
! 509: void *v;
! 510: {
! 511: register struct ie_softc *sc = v;
! 512: register u_int status;
! 513: register int off;
! 514:
! 515: off = IE_SCB_STATUS(sc->scb);
! 516: bus_space_barrier(sc->bt, sc->bh, off, 2, BUS_SPACE_BARRIER_READ);
! 517: status = sc->ie_bus_read16(sc, off) /* & IE_ST_WHENCE */;
! 518:
! 519: if ((status & IE_ST_WHENCE) == 0) {
! 520: if (sc->intrhook)
! 521: (sc->intrhook)(sc, IE_INTR_EXIT);
! 522:
! 523: return (0);
! 524: }
! 525:
! 526: loop:
! 527: /* Ack interrupts FIRST in case we receive more during the ISR. */
! 528: i82596_start_cmd(sc, status & IE_ST_WHENCE, 0, 0, 1);
! 529:
! 530: if (status & (IE_ST_FR | IE_ST_RNR)) {
! 531: if (sc->intrhook)
! 532: (sc->intrhook)(sc, IE_INTR_ENRCV);
! 533:
! 534: if (i82596_rint(sc, status) != 0)
! 535: goto reset;
! 536: }
! 537:
! 538: if (status & IE_ST_CX) {
! 539: if (sc->intrhook)
! 540: (sc->intrhook)(sc, IE_INTR_ENSND);
! 541:
! 542: if (i82596_tint(sc, status) != 0)
! 543: goto reset;
! 544: }
! 545:
! 546: #ifdef I82596_DEBUG
! 547: if ((status & IE_ST_CNA) && (sc->sc_debug & IED_CNA))
! 548: printf("%s: cna; status=%b\n", sc->sc_dev.dv_xname,
! 549: status, IE_ST_BITS);
! 550: #endif
! 551: if (sc->intrhook)
! 552: (sc->intrhook)(sc, IE_INTR_LOOP);
! 553:
! 554: /*
! 555: * Interrupt ACK was posted asynchronously; wait for
! 556: * completion here before reading SCB status again.
! 557: *
! 558: * If ACK fails, try to reset the chip, in hopes that
! 559: * it helps.
! 560: */
! 561: if (i82596_cmd_wait(sc))
! 562: goto reset;
! 563:
! 564: bus_space_barrier(sc->bt, sc->bh, off, 2, BUS_SPACE_BARRIER_READ);
! 565: status = sc->ie_bus_read16(sc, off);
! 566: if ((status & IE_ST_WHENCE) != 0)
! 567: goto loop;
! 568:
! 569: out:
! 570: if (sc->intrhook)
! 571: (sc->intrhook)(sc, IE_INTR_EXIT);
! 572: return (1);
! 573:
! 574: reset:
! 575: i82596_cmd_wait(sc);
! 576: i82596_reset(sc, 1);
! 577: goto out;
! 578: }
! 579:
! 580: /*
! 581: * Process a received-frame interrupt.
! 582: */
! 583: int
! 584: i82596_rint(sc, scbstatus)
! 585: struct ie_softc *sc;
! 586: int scbstatus;
! 587: {
! 588: static int timesthru = 1024;
! 589: register int i, status, off;
! 590:
! 591: #ifdef I82596_DEBUG
! 592: if (sc->sc_debug & IED_RINT)
! 593: printf("%s: rint: status %b\n",
! 594: sc->sc_dev.dv_xname, scbstatus, IE_ST_BITS);
! 595: #endif
! 596:
! 597: for (;;) {
! 598: register int drop = 0;
! 599:
! 600: i = sc->rfhead;
! 601: off = IE_RFRAME_STATUS(sc->rframes, i);
! 602: bus_space_barrier(sc->bt, sc->bh, off, 2,
! 603: BUS_SPACE_BARRIER_READ);
! 604: status = sc->ie_bus_read16(sc, off);
! 605:
! 606: #ifdef I82596_DEBUG
! 607: if (sc->sc_debug & IED_RINT)
! 608: printf("%s: rint: frame(%d) status %b\n",
! 609: sc->sc_dev.dv_xname, i, status, IE_ST_BITS);
! 610: #endif
! 611: if ((status & IE_FD_COMPLETE) == 0) {
! 612: if ((status & IE_FD_OK) != 0) {
! 613: printf("%s: rint: weird: ",
! 614: sc->sc_dev.dv_xname);
! 615: i82596_rx_errors(sc, i, status);
! 616: break;
! 617: }
! 618: if (--timesthru == 0) {
! 619: /* Account the accumulated errors */
! 620: i82596_count_errors(sc);
! 621: timesthru = 1024;
! 622: }
! 623: break;
! 624: } else if ((status & IE_FD_OK) == 0) {
! 625: /*
! 626: * If the chip is configured to automatically
! 627: * discard bad frames, the only reason we can
! 628: * get here is an "out-of-resource" condition.
! 629: */
! 630: i82596_rx_errors(sc, i, status);
! 631: drop = 1;
! 632: }
! 633:
! 634: #ifdef I82596_DEBUG
! 635: if ((status & IE_FD_BUSY) != 0)
! 636: printf("%s: rint: frame(%d) busy; status=%x\n",
! 637: sc->sc_dev.dv_xname, i, status, IE_ST_BITS);
! 638: #endif
! 639:
! 640: /*
! 641: * Advance the RFD list, since we're done with
! 642: * this descriptor.
! 643: */
! 644:
! 645: /* Clear frame status */
! 646: sc->ie_bus_write16(sc, off, 0);
! 647:
! 648: /* Put fence at this frame (the head) */
! 649: off = IE_RFRAME_LAST(sc->rframes, i);
! 650: sc->ie_bus_write16(sc, off, IE_FD_EOL|IE_FD_SUSP);
! 651:
! 652: /* and clear RBD field */
! 653: off = IE_RFRAME_BUFDESC(sc->rframes, i);
! 654: sc->ie_bus_write16(sc, off, 0xffff);
! 655:
! 656: /* Remove fence from current tail */
! 657: off = IE_RFRAME_LAST(sc->rframes, sc->rftail);
! 658: sc->ie_bus_write16(sc, off, 0);
! 659:
! 660: if (++sc->rftail == sc->nframes)
! 661: sc->rftail = 0;
! 662: if (++sc->rfhead == sc->nframes)
! 663: sc->rfhead = 0;
! 664:
! 665: /* Pull the frame off the board */
! 666: if (drop) {
! 667: i82596_drop_frames(sc);
! 668: if ((status & IE_FD_RNR) != 0)
! 669: sc->rnr_expect = 1;
! 670: sc->sc_arpcom.ac_if.if_ierrors++;
! 671: } else if (i82596_readframe(sc, i) != 0)
! 672: return (1);
! 673: }
! 674:
! 675: if ((scbstatus & IE_ST_RNR) != 0) {
! 676:
! 677: /*
! 678: * Receiver went "Not Ready". We try to figure out
! 679: * whether this was an expected event based on past
! 680: * frame status values.
! 681: */
! 682:
! 683: if ((scbstatus & IE_RUS_SUSPEND) != 0) {
! 684: /*
! 685: * We use the "suspend on last frame" flag.
! 686: * Send a RU RESUME command in response, since
! 687: * we should have dealt with all completed frames
! 688: * by now.
! 689: */
! 690: printf("RINT: SUSPENDED; scbstatus=%b\n",
! 691: scbstatus, IE_ST_BITS);
! 692: if (i82596_start_cmd(sc, IE_RUC_RESUME, 0, 0, 0) == 0)
! 693: return (0);
! 694: printf("%s: RU RESUME command timed out\n",
! 695: sc->sc_dev.dv_xname);
! 696: return (1); /* Ask for a reset */
! 697: }
! 698:
! 699: if (sc->rnr_expect != 0) {
! 700: /*
! 701: * The RNR condition was announced in the previously
! 702: * completed frame. Assume the receive ring is Ok,
! 703: * so restart the receiver without further delay.
! 704: */
! 705: i82596_start_transceiver(sc);
! 706: sc->rnr_expect = 0;
! 707: return (0);
! 708:
! 709: } else if ((scbstatus & IE_RUS_NOSPACE) != 0) {
! 710: /*
! 711: * We saw no previous IF_FD_RNR flag.
! 712: * We check our ring invariants and, if ok,
! 713: * just restart the receiver at the current
! 714: * point in the ring.
! 715: */
! 716: if (i82596_chk_rx_ring(sc) != 0)
! 717: return (1);
! 718:
! 719: i82596_start_transceiver(sc);
! 720: sc->sc_arpcom.ac_if.if_ierrors++;
! 721: return (0);
! 722: } else
! 723: printf("%s: receiver not ready; scbstatus=%b\n",
! 724: sc->sc_dev.dv_xname, scbstatus, IE_ST_BITS);
! 725:
! 726: sc->sc_arpcom.ac_if.if_ierrors++;
! 727: return (1); /* Ask for a reset */
! 728: }
! 729:
! 730: return (0);
! 731: }
! 732:
! 733: /*
! 734: * Process a command-complete interrupt. These are only generated by the
! 735: * transmission of frames. This routine is deceptively simple, since most
! 736: * of the real work is done by i82596_start().
! 737: */
! 738: int
! 739: i82596_tint(sc, scbstatus)
! 740: struct ie_softc *sc;
! 741: int scbstatus;
! 742: {
! 743: register struct ifnet *ifp = &sc->sc_arpcom.ac_if;
! 744: register int off, status;
! 745:
! 746: ifp->if_timer = 0;
! 747: ifp->if_flags &= ~IFF_OACTIVE;
! 748:
! 749: #ifdef I82596_DEBUG
! 750: if (sc->xmit_busy <= 0) {
! 751: printf("%s: i82596_tint: WEIRD:"
! 752: "xmit_busy=%d, xctail=%d, xchead=%d\n",
! 753: sc->sc_dev.dv_xname,
! 754: sc->xmit_busy, sc->xctail, sc->xchead);
! 755: return (0);
! 756: }
! 757: #endif
! 758:
! 759: off = IE_CMD_XMIT_STATUS(sc->xmit_cmds, sc->xctail);
! 760: status = sc->ie_bus_read16(sc, off);
! 761:
! 762: #ifdef I82596_DEBUG
! 763: if (sc->sc_debug & IED_TINT)
! 764: printf("%s: tint: SCB status %b; xmit status %b\n",
! 765: sc->sc_dev.dv_xname, scbstatus, IE_ST_BITS,
! 766: status, IE_XS_BITS);
! 767: #endif
! 768:
! 769: if ((status & (IE_STAT_COMPL|IE_STAT_BUSY)) == IE_STAT_BUSY) {
! 770: printf("%s: i82596_tint: command still busy;"
! 771: "status=%b; tail=%d\n", sc->sc_dev.dv_xname,
! 772: status, IE_XS_BITS, sc->xctail);
! 773: printf("iestatus = %b\n", scbstatus, IE_ST_BITS);
! 774: }
! 775:
! 776: if (status & IE_STAT_OK) {
! 777: ifp->if_opackets++;
! 778: ifp->if_collisions += (status & IE_XS_MAXCOLL);
! 779: } else {
! 780: ifp->if_oerrors++;
! 781: /*
! 782: * Check SQE and DEFERRED?
! 783: * What if more than one bit is set?
! 784: */
! 785: if (status & IE_STAT_ABORT)
! 786: printf("%s: send aborted\n", sc->sc_dev.dv_xname);
! 787: else if (status & IE_XS_NOCARRIER)
! 788: printf("%s: no carrier\n", sc->sc_dev.dv_xname);
! 789: else if (status & IE_XS_LOSTCTS)
! 790: printf("%s: lost CTS\n", sc->sc_dev.dv_xname);
! 791: else if (status & IE_XS_UNDERRUN)
! 792: printf("%s: DMA underrun\n", sc->sc_dev.dv_xname);
! 793: else if (status & IE_XS_EXCMAX) {
! 794: printf("%s: too many collisions\n",
! 795: sc->sc_dev.dv_xname);
! 796: sc->sc_arpcom.ac_if.if_collisions += 16;
! 797: }
! 798: }
! 799:
! 800: /*
! 801: * If multicast addresses were added or deleted while transmitting,
! 802: * ie_mc_reset() set the want_mcsetup flag indicating that we
! 803: * should do it.
! 804: */
! 805: if (sc->want_mcsetup) {
! 806: ie_mc_setup(sc, IE_XBUF_ADDR(sc, sc->xctail));
! 807: sc->want_mcsetup = 0;
! 808: }
! 809:
! 810: /* Done with the buffer. */
! 811: sc->xmit_busy--;
! 812: sc->xctail = (sc->xctail + 1) % NTXBUF;
! 813:
! 814: /* Start the next packet, if any, transmitting. */
! 815: if (sc->xmit_busy > 0)
! 816: i82596_xmit(sc);
! 817:
! 818: i82596_start(ifp);
! 819: return (0);
! 820: }
! 821:
! 822: /*
! 823: * Get a range of receive buffer descriptors that represent one packet.
! 824: */
! 825: int
! 826: i82596_get_rbd_list(sc, start, end, pktlen)
! 827: struct ie_softc *sc;
! 828: u_int16_t *start;
! 829: u_int16_t *end;
! 830: int *pktlen;
! 831: {
! 832: int off, rbbase = sc->rbds;
! 833: int rbindex, count = 0;
! 834: int plen = 0;
! 835: int rbdstatus;
! 836:
! 837: *start = rbindex = sc->rbhead;
! 838:
! 839: do {
! 840: off = IE_RBD_STATUS(rbbase, rbindex);
! 841: bus_space_barrier(sc->bt, sc->bh, off, 2,
! 842: BUS_SPACE_BARRIER_READ);
! 843: rbdstatus = sc->ie_bus_read16(sc, off);
! 844: if ((rbdstatus & IE_RBD_USED) == 0) {
! 845: /*
! 846: * This means we are somehow out of sync. So, we
! 847: * reset the adapter.
! 848: */
! 849: #ifdef I82596_DEBUG
! 850: print_rbd(sc, rbindex);
! 851: #endif
! 852: log(LOG_ERR,
! 853: "%s: receive descriptors out of sync at %d\n",
! 854: sc->sc_dev.dv_xname, rbindex);
! 855: return (0);
! 856: }
! 857: plen += (rbdstatus & IE_RBD_CNTMASK);
! 858:
! 859: if (++rbindex == sc->nrxbuf)
! 860: rbindex = 0;
! 861:
! 862: ++count;
! 863: } while ((rbdstatus & IE_RBD_LAST) == 0);
! 864: *end = rbindex;
! 865: *pktlen = plen;
! 866: return (count);
! 867: }
! 868:
! 869:
! 870: /*
! 871: * Release a range of receive buffer descriptors after we've copied the packet.
! 872: */
! 873: void
! 874: i82596_release_rbd_list(sc, start, end)
! 875: struct ie_softc *sc;
! 876: u_int16_t start;
! 877: u_int16_t end;
! 878: {
! 879: register int off, rbbase = sc->rbds;
! 880: register int rbindex = start;
! 881:
! 882: do {
! 883: /* Clear buffer status */
! 884: off = IE_RBD_STATUS(rbbase, rbindex);
! 885: sc->ie_bus_write16(sc, off, 0);
! 886: if (++rbindex == sc->nrxbuf)
! 887: rbindex = 0;
! 888: } while (rbindex != end);
! 889:
! 890: /* Mark EOL at new tail */
! 891: rbindex = ((rbindex == 0) ? sc->nrxbuf : rbindex) - 1;
! 892: off = IE_RBD_BUFLEN(rbbase, rbindex);
! 893: sc->ie_bus_write16(sc, off, IE_RBUF_SIZE|IE_RBD_EOL);
! 894:
! 895: /* Remove EOL from current tail */
! 896: off = IE_RBD_BUFLEN(rbbase, sc->rbtail);
! 897: sc->ie_bus_write16(sc, off, IE_RBUF_SIZE);
! 898:
! 899: /* New head & tail pointer */
! 900: /* hmm, why have both? head is always (tail + 1) % NRXBUF */
! 901: sc->rbhead = end;
! 902: sc->rbtail = rbindex;
! 903: }
! 904:
! 905: /*
! 906: * Drop the packet at the head of the RX buffer ring.
! 907: * Called if the frame descriptor reports an error on this packet.
! 908: * Returns 1 if the buffer descriptor ring appears to be corrupt;
! 909: * and 0 otherwise.
! 910: */
! 911: int
! 912: i82596_drop_frames(sc)
! 913: struct ie_softc *sc;
! 914: {
! 915: u_int16_t bstart, bend;
! 916: int pktlen;
! 917:
! 918: if (!i82596_get_rbd_list(sc, &bstart, &bend, &pktlen))
! 919: return (1);
! 920: i82596_release_rbd_list(sc, bstart, bend);
! 921: return (0);
! 922: }
! 923:
! 924: /*
! 925: * Check the RX frame & buffer descriptor lists for our invariants,
! 926: * i.e.: EOL bit set iff. it is pointed at by the r*tail pointer.
! 927: *
! 928: * Called when the receive unit has stopped unexpectedly.
! 929: * Returns 1 if an inconsistency is detected; 0 otherwise.
! 930: *
! 931: * The Receive Unit is expected to be NOT RUNNING.
! 932: */
! 933: int
! 934: i82596_chk_rx_ring(sc)
! 935: struct ie_softc *sc;
! 936: {
! 937: int n, off, val;
! 938:
! 939: for (n = 0; n < sc->nrxbuf; n++) {
! 940: off = IE_RBD_BUFLEN(sc->rbds, n);
! 941: val = sc->ie_bus_read16(sc, off);
! 942: if ((n == sc->rbtail) ^ ((val & IE_RBD_EOL) != 0)) {
! 943: /* `rbtail' and EOL flag out of sync */
! 944: log(LOG_ERR,
! 945: "%s: rx buffer descriptors out of sync at %d\n",
! 946: sc->sc_dev.dv_xname, n);
! 947: return (1);
! 948: }
! 949:
! 950: /* Take the opportunity to clear the status fields here ? */
! 951: }
! 952:
! 953: for (n = 0; n < sc->nframes; n++) {
! 954: off = IE_RFRAME_LAST(sc->rframes, n);
! 955: val = sc->ie_bus_read16(sc, off);
! 956: if ((n == sc->rftail) ^ ((val & (IE_FD_EOL|IE_FD_SUSP)) != 0)) {
! 957: /* `rftail' and EOL flag out of sync */
! 958: log(LOG_ERR,
! 959: "%s: rx frame list out of sync at %d\n",
! 960: sc->sc_dev.dv_xname, n);
! 961: return (1);
! 962: }
! 963: }
! 964:
! 965: return (0);
! 966: }
! 967:
! 968: /*
! 969: * Read data off the interface, and turn it into an mbuf chain.
! 970: *
! 971: * This code is DRAMATICALLY different from the previous version; this
! 972: * version tries to allocate the entire mbuf chain up front, given the
! 973: * length of the data available. This enables us to allocate mbuf
! 974: * clusters in many situations where before we would have had a long
! 975: * chain of partially-full mbufs. This should help to speed up the
! 976: * operation considerably. (Provided that it works, of course.)
! 977: */
! 978: static __inline__ struct mbuf *
! 979: i82596_get(struct ie_softc *sc, int head, int totlen)
! 980: {
! 981: struct mbuf *m, *m0, *newm;
! 982: int off, len, resid;
! 983: int thisrboff, thismboff;
! 984: struct ether_header eh;
! 985:
! 986: /*
! 987: * Snarf the Ethernet header.
! 988: */
! 989: (sc->memcopyin)(sc, &eh, IE_RBUF_ADDR(sc, head),
! 990: sizeof(struct ether_header));
! 991:
! 992: resid = totlen;
! 993:
! 994: MGETHDR(m0, M_DONTWAIT, MT_DATA);
! 995: if (m0 == 0)
! 996: return (0);
! 997: m0->m_pkthdr.rcvif = &sc->sc_arpcom.ac_if;
! 998: m0->m_pkthdr.len = totlen;
! 999: len = MHLEN;
! 1000: m = m0;
! 1001:
! 1002: /*
! 1003: * This loop goes through and allocates mbufs for all the data we will
! 1004: * be copying in. It does not actually do the copying yet.
! 1005: */
! 1006: while (totlen > 0) {
! 1007: if (totlen >= MINCLSIZE) {
! 1008: MCLGET(m, M_DONTWAIT);
! 1009: if ((m->m_flags & M_EXT) == 0)
! 1010: goto bad;
! 1011: len = MCLBYTES;
! 1012: }
! 1013:
! 1014: if (m == m0) {
! 1015: caddr_t newdata = (caddr_t)
! 1016: ALIGN(m->m_data + sizeof(struct ether_header)) -
! 1017: sizeof(struct ether_header);
! 1018: len -= newdata - m->m_data;
! 1019: m->m_data = newdata;
! 1020: }
! 1021:
! 1022: m->m_len = len = min(totlen, len);
! 1023:
! 1024: totlen -= len;
! 1025: if (totlen > 0) {
! 1026: MGET(newm, M_DONTWAIT, MT_DATA);
! 1027: if (newm == 0)
! 1028: goto bad;
! 1029: len = MLEN;
! 1030: m = m->m_next = newm;
! 1031: }
! 1032: }
! 1033:
! 1034: m = m0;
! 1035: thismboff = 0;
! 1036:
! 1037: /*
! 1038: * Copy the Ethernet header into the mbuf chain.
! 1039: */
! 1040: bcopy(&eh, mtod(m, caddr_t), sizeof(struct ether_header));
! 1041: thismboff = sizeof(struct ether_header);
! 1042: thisrboff = sizeof(struct ether_header);
! 1043: resid -= sizeof(struct ether_header);
! 1044:
! 1045: /*
! 1046: * Now we take the mbuf chain (hopefully only one mbuf most of the
! 1047: * time) and stuff the data into it. There are no possible failures
! 1048: * at or after this point.
! 1049: */
! 1050: while (resid > 0) {
! 1051: int thisrblen = IE_RBUF_SIZE - thisrboff,
! 1052: thismblen = m->m_len - thismboff;
! 1053: len = min(thisrblen, thismblen);
! 1054:
! 1055: off = IE_RBUF_ADDR(sc,head) + thisrboff;
! 1056: (sc->memcopyin)(sc, mtod(m, caddr_t) + thismboff, off, len);
! 1057: resid -= len;
! 1058:
! 1059: if (len == thismblen) {
! 1060: m = m->m_next;
! 1061: thismboff = 0;
! 1062: } else
! 1063: thismboff += len;
! 1064:
! 1065: if (len == thisrblen) {
! 1066: if (++head == sc->nrxbuf)
! 1067: head = 0;
! 1068: thisrboff = 0;
! 1069: } else
! 1070: thisrboff += len;
! 1071: }
! 1072:
! 1073: /*
! 1074: * Unless something changed strangely while we were doing the copy,
! 1075: * we have now copied everything in from the shared memory.
! 1076: * This means that we are done.
! 1077: */
! 1078: return (m0);
! 1079:
! 1080: bad:
! 1081: m_freem(m0);
! 1082: return (NULL);
! 1083: }
! 1084:
! 1085: /*
! 1086: * Read frame NUM from unit UNIT (pre-cached as IE).
! 1087: *
! 1088: * This routine reads the RFD at NUM, and copies in the buffers from the list
! 1089: * of RBD, then rotates the RBD list so that the receiver doesn't start
! 1090: * complaining. Trailers are DROPPED---there's no point in wasting time
! 1091: * on confusing code to deal with them. Hopefully, this machine will
! 1092: * never ARP for trailers anyway.
! 1093: */
! 1094: int
! 1095: i82596_readframe(sc, num)
! 1096: struct ie_softc *sc;
! 1097: int num; /* frame number to read */
! 1098: {
! 1099: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
! 1100: struct mbuf *m;
! 1101: u_int16_t bstart, bend;
! 1102: int pktlen;
! 1103:
! 1104: if (i82596_get_rbd_list(sc, &bstart, &bend, &pktlen) == 0) {
! 1105: ifp->if_ierrors++;
! 1106: return (1);
! 1107: }
! 1108:
! 1109: m = i82596_get(sc, bstart, pktlen);
! 1110: i82596_release_rbd_list(sc, bstart, bend);
! 1111:
! 1112: if (m == 0) {
! 1113: sc->sc_arpcom.ac_if.if_ierrors++;
! 1114: return (0);
! 1115: }
! 1116:
! 1117: #ifdef I82596_DEBUG
! 1118: if (sc->sc_debug & IED_READFRAME) {
! 1119: struct ether_header *eh = mtod(m, struct ether_header *);
! 1120:
! 1121: printf("%s: frame from ether %s type 0x%x len %d\n",
! 1122: sc->sc_dev.dv_xname, ether_sprintf(eh->ether_shost),
! 1123: (u_int)eh->ether_type, pktlen);
! 1124: }
! 1125: #endif
! 1126:
! 1127: #if NBPFILTER > 0
! 1128: /* Check for a BPF filter; if so, hand it up. */
! 1129: if (ifp->if_bpf)
! 1130: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
! 1131: #endif /* NBPFILTER > 0 */
! 1132:
! 1133: /*
! 1134: * Finally pass this packet up to higher layers.
! 1135: */
! 1136: ether_input_mbuf(ifp, m);
! 1137: ifp->if_ipackets++;
! 1138: return (0);
! 1139: }
! 1140:
! 1141:
! 1142: /*
! 1143: * Setup all necessary artifacts for an XMIT command, and then pass the XMIT
! 1144: * command to the chip to be executed.
! 1145: */
! 1146: void
! 1147: i82596_xmit(sc)
! 1148: struct ie_softc *sc;
! 1149: {
! 1150: int off, cur, prev;
! 1151:
! 1152: cur = sc->xctail;
! 1153:
! 1154: #ifdef I82596_DEBUG
! 1155: if (sc->sc_debug & IED_XMIT)
! 1156: printf("%s: xmit buffer %d\n", sc->sc_dev.dv_xname, cur);
! 1157: #endif
! 1158:
! 1159: /*
! 1160: * Setup the transmit command.
! 1161: */
! 1162: sc->ie_bus_write16(sc, IE_CMD_XMIT_DESC(sc->xmit_cmds, cur),
! 1163: IE_XBD_ADDR(sc->xbds, cur));
! 1164:
! 1165: sc->ie_bus_write16(sc, IE_CMD_XMIT_STATUS(sc->xmit_cmds, cur), 0);
! 1166:
! 1167: if (sc->do_xmitnopchain) {
! 1168: /*
! 1169: * Gate this XMIT command to the following NOP
! 1170: */
! 1171: sc->ie_bus_write16(sc, IE_CMD_XMIT_LINK(sc->xmit_cmds, cur),
! 1172: IE_CMD_NOP_ADDR(sc->nop_cmds, cur));
! 1173: sc->ie_bus_write16(sc, IE_CMD_XMIT_CMD(sc->xmit_cmds, cur),
! 1174: IE_CMD_XMIT | IE_CMD_INTR);
! 1175:
! 1176: /*
! 1177: * Loopback at following NOP
! 1178: */
! 1179: sc->ie_bus_write16(sc, IE_CMD_NOP_STATUS(sc->nop_cmds, cur), 0);
! 1180: sc->ie_bus_write16(sc, IE_CMD_NOP_LINK(sc->nop_cmds, cur),
! 1181: IE_CMD_NOP_ADDR(sc->nop_cmds, cur));
! 1182:
! 1183: /*
! 1184: * Gate preceding NOP to this XMIT command
! 1185: */
! 1186: prev = (cur + NTXBUF - 1) % NTXBUF;
! 1187: sc->ie_bus_write16(sc, IE_CMD_NOP_STATUS(sc->nop_cmds, prev), 0);
! 1188: sc->ie_bus_write16(sc, IE_CMD_NOP_LINK(sc->nop_cmds, prev),
! 1189: IE_CMD_XMIT_ADDR(sc->xmit_cmds, cur));
! 1190:
! 1191: off = IE_SCB_STATUS(sc->scb);
! 1192: bus_space_barrier(sc->bt, sc->bh, off, 2,
! 1193: BUS_SPACE_BARRIER_READ);
! 1194: if ((sc->ie_bus_read16(sc, off) & IE_CUS_ACTIVE) == 0) {
! 1195: printf("i82596_xmit: CU not active\n");
! 1196: i82596_start_transceiver(sc);
! 1197: }
! 1198: } else {
! 1199: sc->ie_bus_write16(sc, IE_CMD_XMIT_LINK(sc->xmit_cmds,cur),
! 1200: 0xffff);
! 1201:
! 1202: sc->ie_bus_write16(sc, IE_CMD_XMIT_CMD(sc->xmit_cmds, cur),
! 1203: IE_CMD_XMIT | IE_CMD_INTR | IE_CMD_LAST);
! 1204:
! 1205: off = IE_SCB_CMDLST(sc->scb);
! 1206: sc->ie_bus_write16(sc, off, IE_CMD_XMIT_ADDR(sc->xmit_cmds, cur));
! 1207: bus_space_barrier(sc->bt, sc->bh, off, 2,
! 1208: BUS_SPACE_BARRIER_WRITE);
! 1209:
! 1210: if (i82596_start_cmd(sc, IE_CUC_START, 0, 0, 1)) {
! 1211: #ifdef I82596_DEBUG
! 1212: if (sc->sc_debug & IED_XMIT)
! 1213: printf("%s: i82596_xmit: "
! 1214: "start xmit command timed out\n",
! 1215: sc->sc_dev.dv_xname);
! 1216: #endif
! 1217: }
! 1218: }
! 1219:
! 1220: sc->sc_arpcom.ac_if.if_timer = 5;
! 1221: }
! 1222:
! 1223:
! 1224: /*
! 1225: * Start transmission on an interface.
! 1226: */
! 1227: void
! 1228: i82596_start(ifp)
! 1229: struct ifnet *ifp;
! 1230: {
! 1231: struct ie_softc *sc = ifp->if_softc;
! 1232: struct mbuf *m0, *m;
! 1233: int buffer, head, xbase;
! 1234: u_short len;
! 1235:
! 1236: #ifdef I82596_DEBUG
! 1237: if (sc->sc_debug & IED_ENQ)
! 1238: printf("i82596_start(%p)\n", ifp);
! 1239: #endif
! 1240:
! 1241: if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
! 1242: return;
! 1243:
! 1244: for (;;) {
! 1245: if (sc->xmit_busy == NTXBUF) {
! 1246: ifp->if_flags |= IFF_OACTIVE;
! 1247: break;
! 1248: }
! 1249:
! 1250: IFQ_DEQUEUE(&ifp->if_snd, m0);
! 1251: if (m0 == 0)
! 1252: break;
! 1253:
! 1254: /* We need to use m->m_pkthdr.len, so require the header */
! 1255: if ((m0->m_flags & M_PKTHDR) == 0)
! 1256: panic("i82596_start: no header mbuf");
! 1257:
! 1258: #if NBPFILTER > 0
! 1259: /* Tap off here if there is a BPF listener. */
! 1260: if (ifp->if_bpf)
! 1261: bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
! 1262: #endif
! 1263:
! 1264: if (m0->m_pkthdr.len > IE_TBUF_SIZE)
! 1265: printf("%s: tbuf overflow\n", sc->sc_dev.dv_xname);
! 1266:
! 1267: head = sc->xchead;
! 1268: sc->xchead = (head + 1) % NTXBUF;
! 1269: buffer = IE_XBUF_ADDR(sc, head);
! 1270:
! 1271: #ifdef I82596_DEBUG
! 1272: if (sc->sc_debug & IED_ENQ)
! 1273: printf("%s: fill buffer %d offset %x",
! 1274: sc->sc_dev.dv_xname, head, buffer);
! 1275: #endif
! 1276:
! 1277: for (m = m0; m != 0; m = m->m_next) {
! 1278: #ifdef I82596_DEBUG
! 1279: if (sc->sc_debug & IED_ENQ) {
! 1280: u_int8_t *e, *p = mtod(m, u_int8_t *);
! 1281: static int i;
! 1282: if (m == m0)
! 1283: i = 0;
! 1284: for (e = p + m->m_len; p < e; i++, p += 2) {
! 1285: if (!(i % 8))
! 1286: printf("\n%s:",
! 1287: sc->sc_dev.dv_xname);
! 1288: printf(" %02x%02x", p[0], p[1]);
! 1289: }
! 1290: }
! 1291: #endif
! 1292: (sc->memcopyout)(sc, mtod(m,caddr_t), buffer, m->m_len);
! 1293: buffer += m->m_len;
! 1294: }
! 1295:
! 1296: len = m0->m_pkthdr.len;
! 1297: if (len < ETHER_MIN_LEN - ETHER_CRC_LEN) {
! 1298: (sc->memcopyout)(sc, padbuf, buffer,
! 1299: ETHER_MIN_LEN - ETHER_CRC_LEN - len);
! 1300: buffer += ETHER_MIN_LEN - ETHER_CRC_LEN - len;
! 1301: len = ETHER_MIN_LEN - ETHER_CRC_LEN;
! 1302: }
! 1303:
! 1304: #ifdef I82596_DEBUG
! 1305: if (sc->sc_debug & IED_ENQ)
! 1306: printf("\n");
! 1307: #endif
! 1308:
! 1309: m_freem(m0);
! 1310:
! 1311: /*
! 1312: * Setup the transmit buffer descriptor here, while we
! 1313: * know the packet's length.
! 1314: */
! 1315: xbase = sc->xbds;
! 1316: sc->ie_bus_write16(sc, IE_XBD_FLAGS(xbase, head),
! 1317: len | IE_TBD_EOL);
! 1318: sc->ie_bus_write16(sc, IE_XBD_NEXT(xbase, head), 0xffff);
! 1319: sc->ie_bus_write24(sc, IE_XBD_BUF(xbase, head),
! 1320: sc->sc_maddr + IE_XBUF_ADDR(sc, head));
! 1321:
! 1322: /* Start the first packet transmitting. */
! 1323: if (sc->xmit_busy++ == 0)
! 1324: i82596_xmit(sc);
! 1325: }
! 1326: }
! 1327:
! 1328: /*
! 1329: * Probe IE's ram setup [ Move all this into MD front-end!? ]
! 1330: * Use only if SCP and ISCP represent offsets into shared ram space.
! 1331: */
! 1332: int
! 1333: i82596_proberam(sc)
! 1334: struct ie_softc *sc;
! 1335: {
! 1336: int result, off;
! 1337:
! 1338: /* Put in 16-bit mode */
! 1339: off = IE_SCP_BUS_USE(sc->scp);
! 1340: (sc->ie_bus_write16)(sc, off, 0);
! 1341: bus_space_barrier(sc->bt, sc->bh, off, 2, BUS_SPACE_BARRIER_WRITE);
! 1342:
! 1343: /* Set the ISCP `busy' bit */
! 1344: off = IE_ISCP_BUSY(sc->iscp);
! 1345: (sc->ie_bus_write16)(sc, off, 1);
! 1346: bus_space_barrier(sc->bt, sc->bh, off, 2, BUS_SPACE_BARRIER_WRITE);
! 1347:
! 1348: if (sc->hwreset)
! 1349: (sc->hwreset)(sc, IE_CHIP_PROBE);
! 1350:
! 1351: (sc->chan_attn) (sc);
! 1352:
! 1353: DELAY(100); /* wait a while... */
! 1354:
! 1355: /* Read back the ISCP `busy' bit; it should be clear by now */
! 1356: off = IE_ISCP_BUSY(sc->iscp);
! 1357: bus_space_barrier(sc->bt, sc->bh, off, 1, BUS_SPACE_BARRIER_READ);
! 1358: result = (sc->ie_bus_read16)(sc, off) == 0;
! 1359:
! 1360: /* Acknowledge any interrupts we may have caused. */
! 1361: ie_ack(sc, IE_ST_WHENCE);
! 1362:
! 1363: return (result);
! 1364: }
! 1365:
! 1366: void
! 1367: i82596_reset(sc, hard)
! 1368: struct ie_softc *sc;
! 1369: int hard;
! 1370: {
! 1371: int s = splnet();
! 1372:
! 1373: #ifdef I82596_DEBUG
! 1374: if (hard)
! 1375: printf("%s: reset\n", sc->sc_dev.dv_xname);
! 1376: #endif
! 1377:
! 1378: /* Clear OACTIVE in case we're called from watchdog (frozen xmit). */
! 1379: sc->sc_arpcom.ac_if.if_timer = 0;
! 1380: sc->sc_arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
! 1381:
! 1382: /*
! 1383: * Stop i82596 dead in its tracks.
! 1384: */
! 1385: if (i82596_start_cmd(sc, IE_RUC_ABORT | IE_CUC_ABORT, 0, 0, 0)) {
! 1386: #ifdef I82596_DEBUG
! 1387: printf("%s: abort commands timed out\n", sc->sc_dev.dv_xname);
! 1388: #endif
! 1389: }
! 1390:
! 1391: /*
! 1392: * This can really slow down the i82596_reset() on some cards, but it's
! 1393: * necessary to unwedge other ones (eg, the Sun VME ones) from certain
! 1394: * lockups.
! 1395: */
! 1396: if (hard && sc->hwreset)
! 1397: (sc->hwreset)(sc, IE_CARD_RESET);
! 1398:
! 1399: DELAY(100);
! 1400: ie_ack(sc, IE_ST_WHENCE);
! 1401:
! 1402: if ((sc->sc_arpcom.ac_if.if_flags & IFF_UP) != 0) {
! 1403: int retries=0; /* XXX - find out why init sometimes fails */
! 1404: while (retries++ < 2)
! 1405: if (i82596_init(sc) == 1)
! 1406: break;
! 1407: }
! 1408:
! 1409: splx(s);
! 1410: }
! 1411:
! 1412: void
! 1413: i82596_simple_command(sc, cmd, cmdbuf)
! 1414: struct ie_softc *sc;
! 1415: int cmd;
! 1416: int cmdbuf;
! 1417: {
! 1418: /* Setup a simple command */
! 1419: sc->ie_bus_write16(sc, IE_CMD_COMMON_STATUS(cmdbuf), 0);
! 1420: sc->ie_bus_write16(sc, IE_CMD_COMMON_CMD(cmdbuf), cmd | IE_CMD_LAST);
! 1421: sc->ie_bus_write16(sc, IE_CMD_COMMON_LINK(cmdbuf), 0xffff);
! 1422:
! 1423: /* Assign the command buffer to the SCB command list */
! 1424: sc->ie_bus_write16(sc, IE_SCB_CMDLST(sc->scb), cmdbuf);
! 1425: }
! 1426:
! 1427: /*
! 1428: * Run the time-domain reflectometer.
! 1429: */
! 1430: void
! 1431: ie_run_tdr(sc, cmd)
! 1432: struct ie_softc *sc;
! 1433: int cmd;
! 1434: {
! 1435: int result, clocks;
! 1436:
! 1437: i82596_simple_command(sc, IE_CMD_TDR, cmd);
! 1438: (sc->ie_bus_write16)(sc, IE_CMD_TDR_TIME(cmd), 0);
! 1439:
! 1440: if (i82596_start_cmd(sc, IE_CUC_START, cmd, IE_STAT_COMPL, 0) ||
! 1441: !(sc->ie_bus_read16(sc, IE_CMD_COMMON_STATUS(cmd)) & IE_STAT_OK))
! 1442: result = 0x10000; /* XXX */
! 1443: else
! 1444: result = sc->ie_bus_read16(sc, IE_CMD_TDR_TIME(cmd));
! 1445:
! 1446: /* Squash any pending interrupts */
! 1447: ie_ack(sc, IE_ST_WHENCE);
! 1448:
! 1449: if (result & IE_TDR_SUCCESS)
! 1450: return;
! 1451:
! 1452: clocks = result & IE_TDR_TIME;
! 1453: if (result & 0x10000)
! 1454: printf("%s: TDR command failed\n", sc->sc_dev.dv_xname);
! 1455: else if (result & IE_TDR_XCVR)
! 1456: printf("%s: transceiver problem\n", sc->sc_dev.dv_xname);
! 1457: else if (result & IE_TDR_OPEN)
! 1458: printf("%s: TDR detected an open %d clock%s away\n",
! 1459: sc->sc_dev.dv_xname, clocks, clocks == 1? "":"s");
! 1460: else if (result & IE_TDR_SHORT)
! 1461: printf("%s: TDR detected a short %d clock%s away\n",
! 1462: sc->sc_dev.dv_xname, clocks, clocks == 1? "":"s");
! 1463: else
! 1464: printf("%s: TDR returned unknown status 0x%x\n",
! 1465: sc->sc_dev.dv_xname, result);
! 1466: }
! 1467:
! 1468: /*
! 1469: * i82596_setup_bufs: set up the buffers
! 1470: *
! 1471: * We have a block of KVA at sc->buf_area which is of size sc->buf_area_sz.
! 1472: * this is to be used for the buffers. The chip indexs its control data
! 1473: * structures with 16 bit offsets, and it indexes actual buffers with
! 1474: * 24 bit addresses. So we should allocate control buffers first so that
! 1475: * we don't overflow the 16 bit offset field. The number of transmit
! 1476: * buffers is fixed at compile time.
! 1477: *
! 1478: */
! 1479: void
! 1480: i82596_setup_bufs(sc)
! 1481: struct ie_softc *sc;
! 1482: {
! 1483: int n, r, ptr = sc->buf_area; /* memory pool */
! 1484: int cl = 32;
! 1485:
! 1486: /*
! 1487: * step 0: zero memory and figure out how many recv buffers and
! 1488: * frames we can have.
! 1489: */
! 1490: ptr = (ptr + cl - 1) & ~(cl - 1); /* set alignment and stick with it */
! 1491:
! 1492: /*
! 1493: * step 1: lay out data structures in the shared-memory area
! 1494: */
! 1495:
! 1496: /* The no-op commands; used if "nop-chaining" is in effect */
! 1497: ptr += cl;
! 1498: sc->nop_cmds = ptr - 2;
! 1499: ptr += NTXBUF * 32;
! 1500:
! 1501: /* The transmit commands */
! 1502: ptr += cl;
! 1503: sc->xmit_cmds = ptr - 2;
! 1504: ptr += NTXBUF * 32;
! 1505:
! 1506: /* The transmit buffers descriptors */
! 1507: ptr += cl;
! 1508: sc->xbds = ptr - 2;
! 1509: ptr += NTXBUF * 32;
! 1510:
! 1511: /* The transmit buffers */
! 1512: sc->xbufs = ptr;
! 1513: ptr += NTXBUF * IE_TBUF_SIZE;
! 1514:
! 1515: ptr = (ptr + cl - 1) & ~(cl - 1); /* re-align.. just in case */
! 1516:
! 1517: /* Compute free space for RECV stuff */
! 1518: n = sc->buf_area_sz - (ptr - sc->buf_area);
! 1519:
! 1520: /* Compute size of one RECV frame */
! 1521: r = 64 + ((32 + IE_RBUF_SIZE) * B_PER_F);
! 1522:
! 1523: sc->nframes = n / r;
! 1524:
! 1525: if (sc->nframes <= 8)
! 1526: panic("ie: bogus buffer calc");
! 1527:
! 1528: sc->nrxbuf = sc->nframes * B_PER_F;
! 1529:
! 1530: /* The receive frame descriptors */
! 1531: ptr += cl;
! 1532: sc->rframes = ptr - 2;
! 1533: ptr += sc->nframes * 64;
! 1534:
! 1535: /* The receive buffer descriptors */
! 1536: ptr += cl;
! 1537: sc->rbds = ptr - 2;
! 1538: ptr += sc->nrxbuf * 32;
! 1539:
! 1540: /* The receive buffers */
! 1541: sc->rbufs = ptr;
! 1542: ptr += sc->nrxbuf * IE_RBUF_SIZE;
! 1543:
! 1544: #ifdef I82596_DEBUG
! 1545: printf("%s: %d frames %d bufs\n", sc->sc_dev.dv_xname, sc->nframes,
! 1546: sc->nrxbuf);
! 1547: #endif
! 1548:
! 1549: /*
! 1550: * step 2: link together the recv frames and set EOL on last one
! 1551: */
! 1552: for (n = 0; n < sc->nframes; n++) {
! 1553: int m = (n == sc->nframes - 1) ? 0 : n + 1;
! 1554:
! 1555: /* Clear status */
! 1556: sc->ie_bus_write16(sc, IE_RFRAME_STATUS(sc->rframes,n), 0);
! 1557:
! 1558: /* RBD link = NULL */
! 1559: sc->ie_bus_write16(sc, IE_RFRAME_BUFDESC(sc->rframes,n),
! 1560: 0xffff);
! 1561:
! 1562: /* Make a circular list */
! 1563: sc->ie_bus_write16(sc, IE_RFRAME_NEXT(sc->rframes,n),
! 1564: IE_RFRAME_ADDR(sc->rframes,m));
! 1565:
! 1566: /* Mark last as EOL */
! 1567: sc->ie_bus_write16(sc, IE_RFRAME_LAST(sc->rframes,n),
! 1568: ((m==0)? (IE_FD_EOL|IE_FD_SUSP) : 0));
! 1569: }
! 1570:
! 1571: /*
! 1572: * step 3: link the RBDs and set EOL on last one
! 1573: */
! 1574: for (n = 0; n < sc->nrxbuf; n++) {
! 1575: int m = (n == sc->nrxbuf - 1) ? 0 : n + 1;
! 1576:
! 1577: /* Clear status */
! 1578: sc->ie_bus_write16(sc, IE_RBD_STATUS(sc->rbds,n), 0);
! 1579:
! 1580: /* Make a circular list */
! 1581: sc->ie_bus_write16(sc, IE_RBD_NEXT(sc->rbds,n),
! 1582: IE_RBD_ADDR(sc->rbds,m));
! 1583:
! 1584: /* Link to data buffers */
! 1585: sc->ie_bus_write24(sc, IE_RBD_BUFADDR(sc->rbds, n),
! 1586: sc->sc_maddr + IE_RBUF_ADDR(sc, n));
! 1587: sc->ie_bus_write16(sc, IE_RBD_BUFLEN(sc->rbds,n),
! 1588: IE_RBUF_SIZE | ((m==0)?IE_RBD_EOL:0));
! 1589: }
! 1590:
! 1591: /*
! 1592: * step 4: all xmit no-op commands loopback onto themselves
! 1593: */
! 1594: for (n = 0; n < NTXBUF; n++) {
! 1595: (sc->ie_bus_write16)(sc, IE_CMD_NOP_STATUS(sc->nop_cmds, n), 0);
! 1596:
! 1597: (sc->ie_bus_write16)(sc, IE_CMD_NOP_CMD(sc->nop_cmds, n),
! 1598: IE_CMD_NOP);
! 1599:
! 1600: (sc->ie_bus_write16)(sc, IE_CMD_NOP_LINK(sc->nop_cmds, n),
! 1601: IE_CMD_NOP_ADDR(sc->nop_cmds, n));
! 1602: }
! 1603:
! 1604:
! 1605: /*
! 1606: * step 6: set the head and tail pointers on receive to keep track of
! 1607: * the order in which RFDs and RBDs are used.
! 1608: */
! 1609:
! 1610: /* Pointers to last packet sent and next available transmit buffer. */
! 1611: sc->xchead = sc->xctail = 0;
! 1612:
! 1613: /* Clear transmit-busy flag and set number of free transmit buffers. */
! 1614: sc->xmit_busy = 0;
! 1615:
! 1616: /*
! 1617: * Pointers to first and last receive frame.
! 1618: * The RFD pointed to by rftail is the only one that has EOL set.
! 1619: */
! 1620: sc->rfhead = 0;
! 1621: sc->rftail = sc->nframes - 1;
! 1622:
! 1623: /*
! 1624: * Pointers to first and last receive descriptor buffer.
! 1625: * The RBD pointed to by rbtail is the only one that has EOL set.
! 1626: */
! 1627: sc->rbhead = 0;
! 1628: sc->rbtail = sc->nrxbuf - 1;
! 1629:
! 1630: /* link in recv frames * and buffer into the scb. */
! 1631: #ifdef I82596_DEBUG
! 1632: printf("%s: reserved %d bytes\n",
! 1633: sc->sc_dev.dv_xname, ptr - sc->buf_area);
! 1634: #endif
! 1635: }
! 1636:
! 1637: int
! 1638: ie_cfg_setup(sc, cmd, promiscuous, manchester)
! 1639: struct ie_softc *sc;
! 1640: int cmd;
! 1641: int promiscuous, manchester;
! 1642: {
! 1643: int cmdresult, status;
! 1644:
! 1645: i82596_simple_command(sc, IE_CMD_CONFIG, cmd);
! 1646: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_CNT(cmd), 0x0c);
! 1647: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_FIFO(cmd), 8);
! 1648: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_SAVEBAD(cmd), 0x40);
! 1649: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_ADDRLEN(cmd), 0x2e);
! 1650: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_PRIORITY(cmd), 0);
! 1651: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_IFS(cmd), 0x60);
! 1652: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_SLOT_LOW(cmd), 0);
! 1653: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_SLOT_HIGH(cmd), 0xf2);
! 1654: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_PROMISC(cmd),
! 1655: !!promiscuous | manchester << 2);
! 1656: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_CRSCDT(cmd), 0);
! 1657: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_MINLEN(cmd), 64);
! 1658: bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_JUNK(cmd), 0xff);
! 1659: bus_space_barrier(sc->bt, sc->bh, cmd, IE_CMD_CFG_SZ,
! 1660: BUS_SPACE_BARRIER_WRITE);
! 1661:
! 1662: cmdresult = i82596_start_cmd(sc, IE_CUC_START, cmd, IE_STAT_COMPL, 0);
! 1663: status = sc->ie_bus_read16(sc, IE_CMD_COMMON_STATUS(cmd));
! 1664: if (cmdresult != 0) {
! 1665: printf("%s: configure command timed out; status %b\n",
! 1666: sc->sc_dev.dv_xname, status, IE_STAT_BITS);
! 1667: return (0);
! 1668: }
! 1669: if ((status & IE_STAT_OK) == 0) {
! 1670: printf("%s: configure command failed; status %b\n",
! 1671: sc->sc_dev.dv_xname, status, IE_STAT_BITS);
! 1672: return (0);
! 1673: }
! 1674:
! 1675: /* Squash any pending interrupts */
! 1676: ie_ack(sc, IE_ST_WHENCE);
! 1677: return (1);
! 1678: }
! 1679:
! 1680: int
! 1681: ie_ia_setup(sc, cmdbuf)
! 1682: struct ie_softc *sc;
! 1683: int cmdbuf;
! 1684: {
! 1685: int cmdresult, status;
! 1686:
! 1687: i82596_simple_command(sc, IE_CMD_IASETUP, cmdbuf);
! 1688:
! 1689: (sc->memcopyout)(sc, sc->sc_arpcom.ac_enaddr,
! 1690: IE_CMD_IAS_EADDR(cmdbuf), ETHER_ADDR_LEN);
! 1691:
! 1692: cmdresult = i82596_start_cmd(sc, IE_CUC_START, cmdbuf, IE_STAT_COMPL, 0);
! 1693: status = sc->ie_bus_read16(sc, IE_CMD_COMMON_STATUS(cmdbuf));
! 1694: if (cmdresult != 0) {
! 1695: printf("%s: individual address command timed out; status %b\n",
! 1696: sc->sc_dev.dv_xname, status, IE_STAT_BITS);
! 1697: return (0);
! 1698: }
! 1699: if ((status & IE_STAT_OK) == 0) {
! 1700: printf("%s: individual address command failed; status %b\n",
! 1701: sc->sc_dev.dv_xname, status, IE_STAT_BITS);
! 1702: return (0);
! 1703: }
! 1704:
! 1705: /* Squash any pending interrupts */
! 1706: ie_ack(sc, IE_ST_WHENCE);
! 1707: return (1);
! 1708: }
! 1709:
! 1710: /*
! 1711: * Run the multicast setup command.
! 1712: * Called at splnet().
! 1713: */
! 1714: int
! 1715: ie_mc_setup(sc, cmdbuf)
! 1716: struct ie_softc *sc;
! 1717: int cmdbuf;
! 1718: {
! 1719: int cmdresult, status;
! 1720:
! 1721: if (sc->mcast_count == 0)
! 1722: return (1);
! 1723:
! 1724: i82596_simple_command(sc, IE_CMD_MCAST, cmdbuf);
! 1725:
! 1726: (sc->memcopyout)(sc, (caddr_t)sc->mcast_addrs,
! 1727: IE_CMD_MCAST_MADDR(cmdbuf),
! 1728: sc->mcast_count * ETHER_ADDR_LEN);
! 1729:
! 1730: sc->ie_bus_write16(sc, IE_CMD_MCAST_BYTES(cmdbuf),
! 1731: sc->mcast_count * ETHER_ADDR_LEN);
! 1732:
! 1733: /* Start the command */
! 1734: cmdresult = i82596_start_cmd(sc, IE_CUC_START, cmdbuf, IE_STAT_COMPL, 0);
! 1735: status = sc->ie_bus_read16(sc, IE_CMD_COMMON_STATUS(cmdbuf));
! 1736: if (cmdresult != 0) {
! 1737: printf("%s: multicast setup command timed out; status %b\n",
! 1738: sc->sc_dev.dv_xname, status, IE_STAT_BITS);
! 1739: return (0);
! 1740: }
! 1741: if ((status & IE_STAT_OK) == 0) {
! 1742: printf("%s: multicast setup command failed; status %b\n",
! 1743: sc->sc_dev.dv_xname, status, IE_STAT_BITS);
! 1744: return (0);
! 1745: }
! 1746:
! 1747: /* Squash any pending interrupts */
! 1748: ie_ack(sc, IE_ST_WHENCE);
! 1749: return (1);
! 1750: }
! 1751:
! 1752: /*
! 1753: * This routine takes the environment generated by check_ie_present() and adds
! 1754: * to it all the other structures we need to operate the adapter. This
! 1755: * includes executing the CONFIGURE, IA-SETUP, and MC-SETUP commands, starting
! 1756: * the receiver unit, and clearing interrupts.
! 1757: *
! 1758: * THIS ROUTINE MUST BE CALLED AT splnet() OR HIGHER.
! 1759: */
! 1760: int
! 1761: i82596_init(sc)
! 1762: struct ie_softc *sc;
! 1763: {
! 1764: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
! 1765: int cmd;
! 1766:
! 1767: sc->async_cmd_inprogress = 0;
! 1768:
! 1769: cmd = sc->buf_area;
! 1770:
! 1771: /*
! 1772: * Send the configure command first.
! 1773: */
! 1774: if (ie_cfg_setup(sc, cmd, sc->promisc, 0) == 0)
! 1775: return (0);
! 1776:
! 1777: /*
! 1778: * Send the Individual Address Setup command.
! 1779: */
! 1780: if (ie_ia_setup(sc, cmd) == 0)
! 1781: return (0);
! 1782:
! 1783: /*
! 1784: * Run the time-domain reflectometer.
! 1785: */
! 1786: ie_run_tdr(sc, cmd);
! 1787:
! 1788: /*
! 1789: * Set the multi-cast filter, if any
! 1790: */
! 1791: if (ie_mc_setup(sc, cmd) == 0)
! 1792: return (0);
! 1793:
! 1794: /*
! 1795: * Acknowledge any interrupts we have generated thus far.
! 1796: */
! 1797: ie_ack(sc, IE_ST_WHENCE);
! 1798:
! 1799: /*
! 1800: * Set up the transmit and recv buffers.
! 1801: */
! 1802: i82596_setup_bufs(sc);
! 1803:
! 1804: if (sc->hwinit)
! 1805: (sc->hwinit)(sc);
! 1806:
! 1807: ifp->if_flags |= IFF_RUNNING;
! 1808: ifp->if_flags &= ~IFF_OACTIVE;
! 1809:
! 1810: if (NTXBUF < 2)
! 1811: sc->do_xmitnopchain = 0;
! 1812:
! 1813: i82596_start_transceiver(sc);
! 1814: return (1);
! 1815: }
! 1816:
! 1817: /*
! 1818: * Start the RU and possibly the CU unit
! 1819: */
! 1820: void
! 1821: i82596_start_transceiver(sc)
! 1822: struct ie_softc *sc;
! 1823: {
! 1824:
! 1825: /*
! 1826: * Start RU at current position in frame & RBD lists.
! 1827: */
! 1828: sc->ie_bus_write16(sc, IE_RFRAME_BUFDESC(sc->rframes,sc->rfhead),
! 1829: IE_RBD_ADDR(sc->rbds, sc->rbhead));
! 1830:
! 1831: sc->ie_bus_write16(sc, IE_SCB_RCVLST(sc->scb),
! 1832: IE_RFRAME_ADDR(sc->rframes,sc->rfhead));
! 1833:
! 1834: if (sc->do_xmitnopchain) {
! 1835: /* Stop transmit command chain */
! 1836: if (i82596_start_cmd(sc, IE_CUC_SUSPEND|IE_RUC_SUSPEND, 0, 0, 0))
! 1837: printf("%s: CU/RU stop command timed out\n",
! 1838: sc->sc_dev.dv_xname);
! 1839:
! 1840: /* Start the receiver & transmitter chain */
! 1841: /* sc->scb->ie_command_list =
! 1842: IEADDR(sc->nop_cmds[(sc->xctail+NTXBUF-1) % NTXBUF]);*/
! 1843: sc->ie_bus_write16(sc, IE_SCB_CMDLST(sc->scb),
! 1844: IE_CMD_NOP_ADDR(
! 1845: sc->nop_cmds,
! 1846: (sc->xctail + NTXBUF - 1) % NTXBUF));
! 1847:
! 1848: if (i82596_start_cmd(sc, IE_CUC_START|IE_RUC_START, 0, 0, 0))
! 1849: printf("%s: CU/RU command timed out\n",
! 1850: sc->sc_dev.dv_xname);
! 1851: } else {
! 1852: if (i82596_start_cmd(sc, IE_RUC_START, 0, 0, 0))
! 1853: printf("%s: RU command timed out\n",
! 1854: sc->sc_dev.dv_xname);
! 1855: }
! 1856: }
! 1857:
! 1858: void
! 1859: i82596_stop(sc)
! 1860: struct ie_softc *sc;
! 1861: {
! 1862:
! 1863: if (i82596_start_cmd(sc, IE_RUC_SUSPEND | IE_CUC_SUSPEND, 0, 0, 0))
! 1864: printf("%s: i82596_stop: disable commands timed out\n",
! 1865: sc->sc_dev.dv_xname);
! 1866: }
! 1867:
! 1868: int
! 1869: i82596_ioctl(ifp, cmd, data)
! 1870: register struct ifnet *ifp;
! 1871: u_long cmd;
! 1872: caddr_t data;
! 1873: {
! 1874: struct ie_softc *sc = ifp->if_softc;
! 1875: struct ifaddr *ifa = (struct ifaddr *)data;
! 1876: struct ifreq *ifr = (struct ifreq *)data;
! 1877: int s, error = 0;
! 1878:
! 1879: s = splnet();
! 1880:
! 1881: if ((error = ether_ioctl(ifp, &sc->sc_arpcom, cmd, data)) > 0) {
! 1882: splx(s);
! 1883: return error;
! 1884: }
! 1885:
! 1886: switch(cmd) {
! 1887:
! 1888: case SIOCSIFADDR:
! 1889: ifp->if_flags |= IFF_UP;
! 1890:
! 1891: switch(ifa->ifa_addr->sa_family) {
! 1892: #ifdef INET
! 1893: case AF_INET:
! 1894: i82596_init(sc);
! 1895: arp_ifinit(&sc->sc_arpcom, ifa);
! 1896: break;
! 1897: #endif
! 1898: default:
! 1899: i82596_init(sc);
! 1900: break;
! 1901: }
! 1902: break;
! 1903:
! 1904: case SIOCSIFFLAGS:
! 1905: sc->promisc = ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI);
! 1906: if ((ifp->if_flags & IFF_UP) == 0 &&
! 1907: (ifp->if_flags & IFF_RUNNING) != 0) {
! 1908: /*
! 1909: * If interface is marked down and it is running, then
! 1910: * stop it.
! 1911: */
! 1912: i82596_stop(sc);
! 1913: ifp->if_flags &= ~IFF_RUNNING;
! 1914: } else if ((ifp->if_flags & IFF_UP) != 0 &&
! 1915: (ifp->if_flags & IFF_RUNNING) == 0) {
! 1916: /*
! 1917: * If interface is marked up and it is stopped, then
! 1918: * start it.
! 1919: */
! 1920: i82596_init(sc);
! 1921: } else {
! 1922: /*
! 1923: * Reset the interface to pick up changes in any other
! 1924: * flags that affect hardware registers.
! 1925: */
! 1926: i82596_stop(sc);
! 1927: i82596_init(sc);
! 1928: }
! 1929: #ifdef I82596_DEBUG
! 1930: if (ifp->if_flags & IFF_DEBUG)
! 1931: sc->sc_debug = IED_ALL;
! 1932: else
! 1933: sc->sc_debug = 0;
! 1934: #endif
! 1935: break;
! 1936:
! 1937: case SIOCADDMULTI:
! 1938: case SIOCDELMULTI:
! 1939: error = (cmd == SIOCADDMULTI) ?
! 1940: ether_addmulti(ifr, &sc->sc_arpcom):
! 1941: ether_delmulti(ifr, &sc->sc_arpcom);
! 1942:
! 1943: if (error == ENETRESET) {
! 1944: /*
! 1945: * Multicast list has changed; set the hardware filter
! 1946: * accordingly.
! 1947: */
! 1948: if (ifp->if_flags & IFF_RUNNING)
! 1949: ie_mc_reset(sc);
! 1950: error = 0;
! 1951: }
! 1952: break;
! 1953:
! 1954: case SIOCGIFMEDIA:
! 1955: case SIOCSIFMEDIA:
! 1956: error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
! 1957: break;
! 1958:
! 1959: default:
! 1960: error = EINVAL;
! 1961: }
! 1962: splx(s);
! 1963: return (error);
! 1964: }
! 1965:
! 1966: void
! 1967: ie_mc_reset(sc)
! 1968: struct ie_softc *sc;
! 1969: {
! 1970: struct ether_multi *enm;
! 1971: struct ether_multistep step;
! 1972: int size;
! 1973:
! 1974: /*
! 1975: * Step through the list of addresses.
! 1976: */
! 1977: again:
! 1978: size = 0;
! 1979: sc->mcast_count = 0;
! 1980: ETHER_FIRST_MULTI(step, &sc->sc_arpcom, enm);
! 1981: while (enm) {
! 1982: size += 6;
! 1983: if (sc->mcast_count >= IE_MAXMCAST ||
! 1984: bcmp(enm->enm_addrlo, enm->enm_addrhi, 6) != 0) {
! 1985: sc->sc_arpcom.ac_if.if_flags |= IFF_ALLMULTI;
! 1986: i82596_ioctl(&sc->sc_arpcom.ac_if,
! 1987: SIOCSIFFLAGS, (void *)0);
! 1988: return;
! 1989: }
! 1990: ETHER_NEXT_MULTI(step, enm);
! 1991: }
! 1992:
! 1993: if (size > sc->mcast_addrs_size) {
! 1994: /* Need to allocate more space */
! 1995: if (sc->mcast_addrs_size)
! 1996: free(sc->mcast_addrs, M_IFMADDR);
! 1997: sc->mcast_addrs = (char *)
! 1998: malloc(size, M_IFMADDR, M_WAITOK);
! 1999: sc->mcast_addrs_size = size;
! 2000: }
! 2001:
! 2002: /*
! 2003: * We've got the space; now copy the addresses
! 2004: */
! 2005: ETHER_FIRST_MULTI(step, &sc->sc_arpcom, enm);
! 2006: while (enm) {
! 2007: if (sc->mcast_count >= IE_MAXMCAST)
! 2008: goto again; /* Just in case */
! 2009:
! 2010: bcopy(enm->enm_addrlo, &sc->mcast_addrs[sc->mcast_count], 6);
! 2011: sc->mcast_count++;
! 2012: ETHER_NEXT_MULTI(step, enm);
! 2013: }
! 2014: sc->want_mcsetup = 1;
! 2015: }
! 2016:
! 2017: /*
! 2018: * Media change callback.
! 2019: */
! 2020: int
! 2021: i82596_mediachange(ifp)
! 2022: struct ifnet *ifp;
! 2023: {
! 2024: struct ie_softc *sc = ifp->if_softc;
! 2025:
! 2026: if (sc->sc_mediachange)
! 2027: return ((*sc->sc_mediachange)(sc));
! 2028: return (EINVAL);
! 2029: }
! 2030:
! 2031: /*
! 2032: * Media status callback.
! 2033: */
! 2034: void
! 2035: i82596_mediastatus(ifp, ifmr)
! 2036: struct ifnet *ifp;
! 2037: struct ifmediareq *ifmr;
! 2038: {
! 2039: struct ie_softc *sc = ifp->if_softc;
! 2040:
! 2041: if (sc->sc_mediastatus)
! 2042: (*sc->sc_mediastatus)(sc, ifmr);
! 2043: }
! 2044:
! 2045: #ifdef I82596_DEBUG
! 2046: void
! 2047: print_rbd(sc, n)
! 2048: struct ie_softc *sc;
! 2049: int n;
! 2050: {
! 2051:
! 2052: printf("RBD at %08x:\n status %b, next %04x, buffer %lx\n"
! 2053: "length/EOL %04x\n", IE_RBD_ADDR(sc->rbds,n),
! 2054: sc->ie_bus_read16(sc, IE_RBD_STATUS(sc->rbds,n)), IE_STAT_BITS,
! 2055: sc->ie_bus_read16(sc, IE_RBD_NEXT(sc->rbds,n)),
! 2056: (u_long)0,/*bus_space_read_4(sc->bt, sc->bh, IE_RBD_BUFADDR(sc->rbds,n)),-* XXX */
! 2057: sc->ie_bus_read16(sc, IE_RBD_BUFLEN(sc->rbds,n)));
! 2058: }
! 2059: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to i82596.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic