root/dev/ic/i82596.c

DEFINITIONS

1. i82596_probe
2. i82596_attach
3. i82596_watchdog
4. i82596_cmd_wait
5. i82596_start_cmd
6. i82596_count_errors
7. i82596_rx_errors
8. i82596_intr
9. i82596_rint
10. i82596_tint
11. i82596_get_rbd_list
12. i82596_release_rbd_list
13. i82596_drop_frames
14. i82596_chk_rx_ring
15. i82596_get
16. i82596_readframe
17. i82596_xmit
18. i82596_start
19. i82596_proberam
20. i82596_reset
21. i82596_simple_command
22. ie_run_tdr
23. i82596_setup_bufs
24. ie_cfg_setup
25. ie_ia_setup
26. ie_mc_setup
27. i82596_init
28. i82596_start_transceiver
29. i82596_stop
30. i82596_ioctl
31. ie_mc_reset
32. i82596_mediachange
33. i82596_mediastatus
34. print_rbd

    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 $      */
    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  */
  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 */
  144 #include "bpfilter.h"
  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>
  155 #include <net/if.h>
  156 #include <net/if_dl.h>
  157 #include <net/if_types.h>
  158 #include <net/if_media.h>
  160 #if NBPFILTER > 0
  161 #include <net/bpf.h>
  162 #endif
  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
  172 #include <uvm/uvm_extern.h>
  174 #include <machine/bus.h>
  176 #include <dev/ic/i82596reg.h>
  177 #include <dev/ic/i82596var.h>
  179 static  char *padbuf;
  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 *);
  187 int     i82596_rint(struct ie_softc *, int);
  188 int     i82596_tint(struct ie_softc *, int);
  190 int     i82596_mediachange(struct ifnet *);
  191 void    i82596_mediastatus(struct ifnet *, struct ifmediareq *);
  193 int     i82596_readframe(struct ie_softc *, int);
  194 int     i82596_get_rbd_list(struct ie_softc *,
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 *);
  200 void    i82596_start_transceiver(struct ie_softc *);
  201 void    i82596_stop(struct ie_softc *);
  202 void    i82596_xmit(struct ie_softc *);
  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 *);
  213 #ifdef I82596_DEBUG
  214 void    print_rbd(struct ie_softc *, int);
  215 #endif
  217 struct cfdriver ie_cd = {
NULL, "ie", DV_IFNET
  219 };
  221 /*
  222  * generic i82596 probe routine
  223  */
  224 int
i82596_probe(sc)
  226         struct ie_softc *sc;
  227 {
  228         int i;
sc->scp = sc->sc_msize - IE_SCP_SZ;
sc->iscp = 0;
sc->scb = 32;
  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);
  240         (sc->hwreset)(sc, IE_CARD_RESET);
  242         if ((sc->ie_bus_read16)(sc, IE_ISCP_BUSY(sc->iscp))) {
  243 #ifdef I82596_DEBUG
printf("%s: ISCP set failed\n", sc->sc_dev.dv_xname);
  245 #endif
  246                 return 0;
  247         }
  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));
DELAY(100))
  256                         ;
  257         }
  259         return 1;
  260 }
  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
i82596_attach(sc, name, etheraddr, media, nmedia, defmedia)
  286         struct ie_softc *sc;
  287         const char *name;
u_int8_t *etheraddr;
  289         int *media, nmedia, defmedia;
  290 {
  291         int i;
  292         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  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);
  302         /* Setup Iface */
bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
ifp->if_softc = sc;
ifp->if_start = i82596_start;
ifp->if_ioctl = i82596_ioctl;
ifp->if_watchdog = i82596_watchdog;
ifp->if_flags =
  309 #ifdef I82596_DEBUG
IFF_DEBUG |
  311 #endif
IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS | IFF_MULTICAST;
IFQ_SET_READY(&ifp->if_snd);
  315         /* Initialize media goo. */
ifmedia_init(&sc->sc_media, 0, i82596_mediachange, i82596_mediastatus);
  317         if (media != NULL) {
  318                 for (i = 0; i < nmedia; i++)
ifmedia_add(&sc->sc_media, media[i], 0, NULL);
ifmedia_set(&sc->sc_media, defmedia);
  321         } else {
ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_MANUAL, 0, NULL);
ifmedia_set(&sc->sc_media, IFM_ETHER|IFM_MANUAL);
  324         }
  326         if (padbuf == NULL) {
padbuf = malloc(ETHER_MIN_LEN - ETHER_CRC_LEN, M_DEVBUF,
M_NOWAIT);
  329                 if (padbuf == NULL) {
printf("%s: can't allocate pad buffer\n",
sc->sc_dev.dv_xname);
  332                         return;
  333                 }
bzero(padbuf, ETHER_MIN_LEN - ETHER_CRC_LEN);
  335         }
  337         /* Attach the interface. */
if_attach(ifp);
ether_ifattach(ifp);
printf(" %s v%d.%d, address %s\n", name, sc->sc_vers / 10,
sc->sc_vers % 10, ether_sprintf(etheraddr));
  343 }
  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
i82596_watchdog(ifp)
  353         struct ifnet *ifp;
  354 {
  355         struct ie_softc *sc = ifp->if_softc;
log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
  358         ++ifp->if_oerrors;
i82596_reset(sc, 1);
  361 }
  363 int
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;
  370         for (i = 180000; i--; DELAY(5)) {
  371                 /* Read the command word */
off = IE_SCB_CMD(sc->scb);
bus_space_barrier(sc->bt, sc->bh, off, 2,
BUS_SPACE_BARRIER_READ);
  375                 if ((sc->ie_bus_read16)(sc, off) == 0) {
  376 #ifdef I82596_DEBUG
  377                         if (sc->sc_debug & IED_CMDS)
printf("%s: cmd_wait after %d usec\n",
sc->sc_dev.dv_xname, (180000 - i) * 5);
  380 #endif
  381                         return (0);
  382                 }
  383         }
  385 #ifdef I82596_DEBUG
  386         if (sc->sc_debug & IED_CMDS)
printf("i82596_cmd_wait: timo(%ssync): scb status: %b\n",
sc->async_cmd_inprogress? "a" : "",
sc->ie_bus_read16(sc, IE_SCB_STATUS(sc->scb)),
IE_STAT_BITS);
  391 #endif
  392         return (1);     /* Timeout */
  393 }
  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
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;
  415 #ifdef I82596_DEBUG
  416         if (sc->sc_debug & IED_CMDS)
printf("start_cmd: %p, %x, %x, %b, %ssync\n",
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);
sc->async_cmd_inprogress = 0;
  428         }
off = IE_SCB_CMD(sc->scb);
  431         (sc->ie_bus_write16)(sc, off, cmd);
bus_space_barrier(sc->bt, sc->bh, off, 2, BUS_SPACE_BARRIER_WRITE);
  433         (sc->chan_attn)(sc);
  435         if (async) {
sc->async_cmd_inprogress = 1;
  437                 return (0);
  438         }
  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 */
off = IE_CMD_COMMON_STATUS(iecmdbuf);
bus_space_barrier(sc->bt, sc->bh, off, 2,
BUS_SPACE_BARRIER_READ);
status = (sc->ie_bus_read16)(sc, off);
  454                         if (status & mask) {
  455 #ifdef I82596_DEBUG
  456                                 if (sc->sc_debug & IED_CMDS)
printf("%s: cmd status %b\n",
sc->sc_dev.dv_xname,
status, IE_STAT_BITS);
  460 #endif
  461                                 return (0);
  462                         }
  463                 }
  465         } else {
  466                 /*
  467                  * Otherwise, just wait for the command to be accepted.
  468                  */
  469                 return (i82596_cmd_wait(sc));
  470         }
  472         /* Timeout */
  473         return (1);
  474 }
  476 /*
  477  * Transfer accumulated chip error counters to IF.
  478  */
  479 static __inline void
i82596_count_errors(struct ie_softc *sc)
  481 {
  482         int scb = sc->scb;
sc->sc_arpcom.ac_if.if_ierrors +=
sc->ie_bus_read16(sc, IE_SCB_ERRCRC(scb)) +
sc->ie_bus_read16(sc, IE_SCB_ERRALN(scb)) +
sc->ie_bus_read16(sc, IE_SCB_ERRRES(scb)) +
sc->ie_bus_read16(sc, IE_SCB_ERROVR(scb));
  490         /* Clear error counters */
sc->ie_bus_write16(sc, IE_SCB_ERRCRC(scb), 0);
sc->ie_bus_write16(sc, IE_SCB_ERRALN(scb), 0);
sc->ie_bus_write16(sc, IE_SCB_ERRRES(scb), 0);
sc->ie_bus_write16(sc, IE_SCB_ERROVR(scb), 0);
  495 }
  497 static __inline void
i82596_rx_errors(struct ie_softc *sc, int fn, int status)
  499 {
log(LOG_ERR, "%s: rx error (frame# %d): %b\n", sc->sc_dev.dv_xname, fn,
status, IE_FD_STATUSBITS);
  502 }
  504 /*
  505  * i82596 interrupt entry point.
  506  */
  507 int
i82596_intr(v)
  509         void *v;
  510 {
  511         register struct ie_softc *sc = v;
  512         register u_int status;
  513         register int off;
off = IE_SCB_STATUS(sc->scb);
bus_space_barrier(sc->bt, sc->bh, off, 2, BUS_SPACE_BARRIER_READ);
status = sc->ie_bus_read16(sc, off) /* & IE_ST_WHENCE */;
  519         if ((status & IE_ST_WHENCE) == 0) {
  520                 if (sc->intrhook)
  521                         (sc->intrhook)(sc, IE_INTR_EXIT);
  523                 return (0);
  524         }
loop:
  527         /* Ack interrupts FIRST in case we receive more during the ISR. */
i82596_start_cmd(sc, status & IE_ST_WHENCE, 0, 0, 1);
  530         if (status & (IE_ST_FR | IE_ST_RNR)) {
  531                 if (sc->intrhook)
  532                         (sc->intrhook)(sc, IE_INTR_ENRCV);
  534                 if (i82596_rint(sc, status) != 0)
  535                         goto reset;
  536         }
  538         if (status & IE_ST_CX) {
  539                 if (sc->intrhook)
  540                         (sc->intrhook)(sc, IE_INTR_ENSND);
  542                 if (i82596_tint(sc, status) != 0)
  543                         goto reset;
  544         }
  546 #ifdef I82596_DEBUG
  547         if ((status & IE_ST_CNA) && (sc->sc_debug & IED_CNA))
printf("%s: cna; status=%b\n", sc->sc_dev.dv_xname,
status, IE_ST_BITS);
  550 #endif
  551         if (sc->intrhook)
  552                 (sc->intrhook)(sc, IE_INTR_LOOP);
  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;
bus_space_barrier(sc->bt, sc->bh, off, 2, BUS_SPACE_BARRIER_READ);
status = sc->ie_bus_read16(sc, off);
  566         if ((status & IE_ST_WHENCE) != 0)
  567                 goto loop;
out:
  570         if (sc->intrhook)
  571                 (sc->intrhook)(sc, IE_INTR_EXIT);
  572         return (1);
reset:
i82596_cmd_wait(sc);
i82596_reset(sc, 1);
  577         goto out;
  578 }
  580 /*
  581  * Process a received-frame interrupt.
  582  */
  583 int
i82596_rint(sc, scbstatus)
  585         struct  ie_softc *sc;
  586         int     scbstatus;
  587 {
  588         static int timesthru = 1024;
  589         register int i, status, off;
  591 #ifdef I82596_DEBUG
  592         if (sc->sc_debug & IED_RINT)
printf("%s: rint: status %b\n",
sc->sc_dev.dv_xname, scbstatus, IE_ST_BITS);
  595 #endif
  597         for (;;) {
  598                 register int drop = 0;
i = sc->rfhead;
off = IE_RFRAME_STATUS(sc->rframes, i);
bus_space_barrier(sc->bt, sc->bh, off, 2,
BUS_SPACE_BARRIER_READ);
status = sc->ie_bus_read16(sc, off);
  606 #ifdef I82596_DEBUG
  607                 if (sc->sc_debug & IED_RINT)
printf("%s: rint: frame(%d) status %b\n",
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) {
printf("%s: rint: weird: ",
sc->sc_dev.dv_xname);
i82596_rx_errors(sc, i, status);
  616                                 break;
  617                         }
  618                         if (--timesthru == 0) {
  619                                 /* Account the accumulated errors */
i82596_count_errors(sc);
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                          */
i82596_rx_errors(sc, i, status);
drop = 1;
  632                 }
  634 #ifdef I82596_DEBUG
  635                 if ((status & IE_FD_BUSY) != 0)
printf("%s: rint: frame(%d) busy; status=%x\n",
sc->sc_dev.dv_xname, i, status, IE_ST_BITS);
  638 #endif
  640                 /*
  641                  * Advance the RFD list, since we're done with
  642                  * this descriptor.
  643                  */
  645                 /* Clear frame status */
sc->ie_bus_write16(sc, off, 0);
  648                 /* Put fence at this frame (the head) */
off = IE_RFRAME_LAST(sc->rframes, i);
sc->ie_bus_write16(sc, off, IE_FD_EOL|IE_FD_SUSP);
  652                 /* and clear RBD field */
off = IE_RFRAME_BUFDESC(sc->rframes, i);
sc->ie_bus_write16(sc, off, 0xffff);
  656                 /* Remove fence from current tail */
off = IE_RFRAME_LAST(sc->rframes, sc->rftail);
sc->ie_bus_write16(sc, off, 0);
  660                 if (++sc->rftail == sc->nframes)
sc->rftail = 0;
  662                 if (++sc->rfhead == sc->nframes)
sc->rfhead = 0;
  665                 /* Pull the frame off the board */
  666                 if (drop) {
i82596_drop_frames(sc);
  668                         if ((status & IE_FD_RNR) != 0)
sc->rnr_expect = 1;
sc->sc_arpcom.ac_if.if_ierrors++;
  671                 } else if (i82596_readframe(sc, i) != 0)
  672                         return (1);
  673         }
  675         if ((scbstatus & IE_ST_RNR) != 0) {
  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                  */
  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                          */
printf("RINT: SUSPENDED; scbstatus=%b\n",
scbstatus, IE_ST_BITS);
  692                         if (i82596_start_cmd(sc, IE_RUC_RESUME, 0, 0, 0) == 0)
  693                                 return (0);
printf("%s: RU RESUME command timed out\n",
sc->sc_dev.dv_xname);
  696                         return (1);     /* Ask for a reset */
  697                 }
  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                          */
i82596_start_transceiver(sc);
sc->rnr_expect = 0;
  707                         return (0);
  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);
i82596_start_transceiver(sc);
sc->sc_arpcom.ac_if.if_ierrors++;
  721                         return (0);
  722                 } else
printf("%s: receiver not ready; scbstatus=%b\n",
sc->sc_dev.dv_xname, scbstatus, IE_ST_BITS);
sc->sc_arpcom.ac_if.if_ierrors++;
  727                 return (1);     /* Ask for a reset */
  728         }
  730         return (0);
  731 }
  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
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;
ifp->if_timer = 0;
ifp->if_flags &= ~IFF_OACTIVE;
  749 #ifdef I82596_DEBUG
  750         if (sc->xmit_busy <= 0) {
printf("%s: i82596_tint: WEIRD:"
  752                        "xmit_busy=%d, xctail=%d, xchead=%d\n",
sc->sc_dev.dv_xname,
sc->xmit_busy, sc->xctail, sc->xchead);
  755                 return (0);
  756         }
  757 #endif
off = IE_CMD_XMIT_STATUS(sc->xmit_cmds, sc->xctail);
status = sc->ie_bus_read16(sc, off);
  762 #ifdef I82596_DEBUG
  763         if (sc->sc_debug & IED_TINT)
printf("%s: tint: SCB status %b; xmit status %b\n",
sc->sc_dev.dv_xname, scbstatus, IE_ST_BITS,
status, IE_XS_BITS);
  767 #endif
  769         if ((status & (IE_STAT_COMPL|IE_STAT_BUSY)) == IE_STAT_BUSY) {
printf("%s: i82596_tint: command still busy;"
  771                        "status=%b; tail=%d\n", sc->sc_dev.dv_xname,
status, IE_XS_BITS, sc->xctail);
printf("iestatus = %b\n", scbstatus, IE_ST_BITS);
  774         }
  776         if (status & IE_STAT_OK) {
ifp->if_opackets++;
ifp->if_collisions += (status & IE_XS_MAXCOLL);
  779         } else {
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)
printf("%s: send aborted\n", sc->sc_dev.dv_xname);
  787                 else if (status & IE_XS_NOCARRIER)
printf("%s: no carrier\n", sc->sc_dev.dv_xname);
  789                 else if (status & IE_XS_LOSTCTS)
printf("%s: lost CTS\n", sc->sc_dev.dv_xname);
  791                 else if (status & IE_XS_UNDERRUN)
printf("%s: DMA underrun\n", sc->sc_dev.dv_xname);
  793                 else if (status & IE_XS_EXCMAX) {
printf("%s: too many collisions\n",
sc->sc_dev.dv_xname);
sc->sc_arpcom.ac_if.if_collisions += 16;
  797                 }
  798         }
  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) {
ie_mc_setup(sc, IE_XBUF_ADDR(sc, sc->xctail));
sc->want_mcsetup = 0;
  808         }
  810         /* Done with the buffer. */
sc->xmit_busy--;
sc->xctail = (sc->xctail + 1) % NTXBUF;
  814         /* Start the next packet, if any, transmitting. */
  815         if (sc->xmit_busy > 0)
i82596_xmit(sc);
i82596_start(ifp);
  819         return (0);
  820 }
  822 /*
  823  * Get a range of receive buffer descriptors that represent one packet.
  824  */
  825 int
i82596_get_rbd_list(sc, start, end, pktlen)
  827         struct ie_softc *sc;
u_int16_t       *start;
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;
  837         *start = rbindex = sc->rbhead;
  839         do {
off = IE_RBD_STATUS(rbbase, rbindex);
bus_space_barrier(sc->bt, sc->bh, off, 2,
BUS_SPACE_BARRIER_READ);
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
print_rbd(sc, rbindex);
  851 #endif
log(LOG_ERR,
  853                             "%s: receive descriptors out of sync at %d\n",
sc->sc_dev.dv_xname, rbindex);
  855                         return (0);
  856                 }
plen += (rbdstatus & IE_RBD_CNTMASK);
  859                 if (++rbindex == sc->nrxbuf)
rbindex = 0;
  862                 ++count;
  863         } while ((rbdstatus & IE_RBD_LAST) == 0);
  864         *end = rbindex;
  865         *pktlen = plen;
  866         return (count);
  867 }
  870 /*
  871  * Release a range of receive buffer descriptors after we've copied the packet.
  872  */
  873 void
i82596_release_rbd_list(sc, start, end)
  875         struct ie_softc *sc;
u_int16_t       start;
u_int16_t       end;
  878 {
  879         register int    off, rbbase = sc->rbds;
  880         register int    rbindex = start;
  882         do {
  883                 /* Clear buffer status */
off = IE_RBD_STATUS(rbbase, rbindex);
sc->ie_bus_write16(sc, off, 0);
  886                 if (++rbindex == sc->nrxbuf)
rbindex = 0;
  888         } while (rbindex != end);
  890         /* Mark EOL at new tail */
rbindex = ((rbindex == 0) ? sc->nrxbuf : rbindex) - 1;
off = IE_RBD_BUFLEN(rbbase, rbindex);
sc->ie_bus_write16(sc, off, IE_RBUF_SIZE|IE_RBD_EOL);
  895         /* Remove EOL from current tail */
off = IE_RBD_BUFLEN(rbbase, sc->rbtail);
sc->ie_bus_write16(sc, off, IE_RBUF_SIZE);
  899         /* New head & tail pointer */
  900 /* hmm, why have both? head is always (tail + 1) % NRXBUF */
sc->rbhead = end;
sc->rbtail = rbindex;
  903 }
  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
i82596_drop_frames(sc)
  913         struct ie_softc *sc;
  914 {
u_int16_t bstart, bend;
  916         int pktlen;
  918         if (!i82596_get_rbd_list(sc, &bstart, &bend, &pktlen))
  919                 return (1);
i82596_release_rbd_list(sc, bstart, bend);
  921         return (0);
  922 }
  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
i82596_chk_rx_ring(sc)
  935         struct ie_softc *sc;
  936 {
  937         int n, off, val;
  939         for (n = 0; n < sc->nrxbuf; n++) {
off = IE_RBD_BUFLEN(sc->rbds, n);
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 */
log(LOG_ERR,
  945                             "%s: rx buffer descriptors out of sync at %d\n",
sc->sc_dev.dv_xname, n);
  947                         return (1);
  948                 }
  950                 /* Take the opportunity to clear the status fields here ? */
  951         }
  953         for (n = 0; n < sc->nframes; n++) {
off = IE_RFRAME_LAST(sc->rframes, n);
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 */
log(LOG_ERR,
  959                             "%s: rx frame list out of sync at %d\n",
sc->sc_dev.dv_xname, n);
  961                         return (1);
  962                 }
  963         }
  965         return (0);
  966 }
  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 *
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;
  986         /*
  987          * Snarf the Ethernet header.
  988          */
  989         (sc->memcopyin)(sc, &eh, IE_RBUF_ADDR(sc, head),
  990             sizeof(struct ether_header));
resid = totlen;
MGETHDR(m0, M_DONTWAIT, MT_DATA);
  995         if (m0 == 0)
  996                 return (0);
m0->m_pkthdr.rcvif = &sc->sc_arpcom.ac_if;
m0->m_pkthdr.len = totlen;
len = MHLEN;
m = m0;
 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) {
MCLGET(m, M_DONTWAIT);
 1009                         if ((m->m_flags & M_EXT) == 0)
 1010                                 goto bad;
len = MCLBYTES;
 1012                 }
 1014                 if (m == m0) {
caddr_t newdata = (caddr_t)
ALIGN(m->m_data + sizeof(struct ether_header)) -
 1017                             sizeof(struct ether_header);
len -= newdata - m->m_data;
m->m_data = newdata;
 1020                 }
m->m_len = len = min(totlen, len);
totlen -= len;
 1025                 if (totlen > 0) {
MGET(newm, M_DONTWAIT, MT_DATA);
 1027                         if (newm == 0)
 1028                                 goto bad;
len = MLEN;
m = m->m_next = newm;
 1031                 }
 1032         }
m = m0;
thismboff = 0;
 1037         /*
 1038          * Copy the Ethernet header into the mbuf chain.
 1039          */
bcopy(&eh, mtod(m, caddr_t), sizeof(struct ether_header));
thismboff = sizeof(struct ether_header);
thisrboff = sizeof(struct ether_header);
resid -= sizeof(struct ether_header);
 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,
thismblen = m->m_len - thismboff;
len = min(thisrblen, thismblen);
off = IE_RBUF_ADDR(sc,head) + thisrboff;
 1056                 (sc->memcopyin)(sc, mtod(m, caddr_t) + thismboff, off, len);
resid -= len;
 1059                 if (len == thismblen) {
m = m->m_next;
thismboff = 0;
 1062                 } else
thismboff += len;
 1065                 if (len == thisrblen) {
 1066                         if (++head == sc->nrxbuf)
head = 0;
thisrboff = 0;
 1069                 } else
thisrboff += len;
 1071         }
 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);
bad:
m_freem(m0);
 1082         return (NULL);
 1083 }
 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
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;
u_int16_t bstart, bend;
 1102         int pktlen;
 1104         if (i82596_get_rbd_list(sc, &bstart, &bend, &pktlen) == 0) {
ifp->if_ierrors++;
 1106                 return (1);
 1107         }
m = i82596_get(sc, bstart, pktlen);
i82596_release_rbd_list(sc, bstart, bend);
 1112         if (m == 0) {
sc->sc_arpcom.ac_if.if_ierrors++;
 1114                 return (0);
 1115         }
 1117 #ifdef I82596_DEBUG
 1118         if (sc->sc_debug & IED_READFRAME) {
 1119                 struct ether_header *eh = mtod(m, struct ether_header *);
printf("%s: frame from ether %s type 0x%x len %d\n",
sc->sc_dev.dv_xname, ether_sprintf(eh->ether_shost),
 1123                     (u_int)eh->ether_type, pktlen);
 1124         }
 1125 #endif
 1127 #if NBPFILTER > 0
 1128         /* Check for a BPF filter; if so, hand it up. */
 1129         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
 1131 #endif /* NBPFILTER > 0 */
 1133         /*
 1134          * Finally pass this packet up to higher layers.
 1135          */
ether_input_mbuf(ifp, m);
ifp->if_ipackets++;
 1138         return (0);
 1139 }
 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
i82596_xmit(sc)
 1148         struct ie_softc *sc;
 1149 {
 1150         int off, cur, prev;
cur = sc->xctail;
 1154 #ifdef I82596_DEBUG
 1155         if (sc->sc_debug & IED_XMIT)
printf("%s: xmit buffer %d\n", sc->sc_dev.dv_xname, cur);
 1157 #endif
 1159         /*
 1160          * Setup the transmit command.
 1161          */
sc->ie_bus_write16(sc, IE_CMD_XMIT_DESC(sc->xmit_cmds, cur),
IE_XBD_ADDR(sc->xbds, cur));
sc->ie_bus_write16(sc, IE_CMD_XMIT_STATUS(sc->xmit_cmds, cur), 0);
 1167         if (sc->do_xmitnopchain) {
 1168                 /*
 1169                  * Gate this XMIT command to the following NOP
 1170                  */
sc->ie_bus_write16(sc, IE_CMD_XMIT_LINK(sc->xmit_cmds, cur),
IE_CMD_NOP_ADDR(sc->nop_cmds, cur));
sc->ie_bus_write16(sc, IE_CMD_XMIT_CMD(sc->xmit_cmds, cur),
IE_CMD_XMIT | IE_CMD_INTR);
 1176                 /*
 1177                  * Loopback at following NOP
 1178                  */
sc->ie_bus_write16(sc, IE_CMD_NOP_STATUS(sc->nop_cmds, cur), 0);
sc->ie_bus_write16(sc, IE_CMD_NOP_LINK(sc->nop_cmds, cur),
IE_CMD_NOP_ADDR(sc->nop_cmds, cur));
 1183                 /*
 1184                  * Gate preceding NOP to this XMIT command
 1185                  */
prev = (cur + NTXBUF - 1) % NTXBUF;
sc->ie_bus_write16(sc, IE_CMD_NOP_STATUS(sc->nop_cmds, prev), 0);
sc->ie_bus_write16(sc, IE_CMD_NOP_LINK(sc->nop_cmds, prev),
IE_CMD_XMIT_ADDR(sc->xmit_cmds, cur));
off = IE_SCB_STATUS(sc->scb);
bus_space_barrier(sc->bt, sc->bh, off, 2,
BUS_SPACE_BARRIER_READ);
 1194                 if ((sc->ie_bus_read16(sc, off) & IE_CUS_ACTIVE) == 0) {
printf("i82596_xmit: CU not active\n");
i82596_start_transceiver(sc);
 1197                 }
 1198         } else {
sc->ie_bus_write16(sc, IE_CMD_XMIT_LINK(sc->xmit_cmds,cur),
 1200                                        0xffff);
sc->ie_bus_write16(sc, IE_CMD_XMIT_CMD(sc->xmit_cmds, cur),
IE_CMD_XMIT | IE_CMD_INTR | IE_CMD_LAST);
off = IE_SCB_CMDLST(sc->scb);
sc->ie_bus_write16(sc, off, IE_CMD_XMIT_ADDR(sc->xmit_cmds, cur));
bus_space_barrier(sc->bt, sc->bh, off, 2,
BUS_SPACE_BARRIER_WRITE);
 1210                 if (i82596_start_cmd(sc, IE_CUC_START, 0, 0, 1)) {
 1211 #ifdef I82596_DEBUG
 1212                         if (sc->sc_debug & IED_XMIT)
printf("%s: i82596_xmit: "
 1214                                     "start xmit command timed out\n",
sc->sc_dev.dv_xname);
 1216 #endif
 1217                 }
 1218         }
sc->sc_arpcom.ac_if.if_timer = 5;
 1221 }
 1224 /*
 1225  * Start transmission on an interface.
 1226  */
 1227 void
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;
u_short len;
 1236 #ifdef I82596_DEBUG
 1237         if (sc->sc_debug & IED_ENQ)
printf("i82596_start(%p)\n", ifp);
 1239 #endif
 1241         if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
 1242                 return;
 1244         for (;;) {
 1245                 if (sc->xmit_busy == NTXBUF) {
ifp->if_flags |= IFF_OACTIVE;
 1247                         break;
 1248                 }
IFQ_DEQUEUE(&ifp->if_snd, m0);
 1251                 if (m0 == 0)
 1252                         break;
 1254                 /* We need to use m->m_pkthdr.len, so require the header */
 1255                 if ((m0->m_flags & M_PKTHDR) == 0)
panic("i82596_start: no header mbuf");
 1258 #if NBPFILTER > 0
 1259                 /* Tap off here if there is a BPF listener. */
 1260                 if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
 1262 #endif
 1264                 if (m0->m_pkthdr.len > IE_TBUF_SIZE)
printf("%s: tbuf overflow\n", sc->sc_dev.dv_xname);
head = sc->xchead;
sc->xchead = (head + 1) % NTXBUF;
buffer = IE_XBUF_ADDR(sc, head);
 1271 #ifdef I82596_DEBUG
 1272                 if (sc->sc_debug & IED_ENQ)
printf("%s: fill buffer %d offset %x",
sc->sc_dev.dv_xname, head, buffer);
 1275 #endif
 1277                 for (m = m0; m != 0; m = m->m_next) {
 1278 #ifdef I82596_DEBUG
 1279                         if (sc->sc_debug & IED_ENQ) {
u_int8_t *e, *p = mtod(m, u_int8_t *);
 1281                                 static int i;
 1282                                 if (m == m0)
i = 0;
 1284                                 for (e = p + m->m_len; p < e; i++, p += 2) {
 1285                                         if (!(i % 8))
printf("\n%s:",
sc->sc_dev.dv_xname);
printf(" %02x%02x", p[0], p[1]);
 1289                                 }
 1290                         }
 1291 #endif
 1292                         (sc->memcopyout)(sc, mtod(m,caddr_t), buffer, m->m_len);
buffer += m->m_len;
 1294                 }
len = m0->m_pkthdr.len;
 1297                 if (len < ETHER_MIN_LEN - ETHER_CRC_LEN) {
 1298                         (sc->memcopyout)(sc, padbuf, buffer,
ETHER_MIN_LEN - ETHER_CRC_LEN - len);
buffer += ETHER_MIN_LEN - ETHER_CRC_LEN - len;
len = ETHER_MIN_LEN - ETHER_CRC_LEN;
 1302                 }
 1304 #ifdef I82596_DEBUG
 1305                 if (sc->sc_debug & IED_ENQ)
printf("\n");
 1307 #endif
m_freem(m0);
 1311                 /*
 1312                  * Setup the transmit buffer descriptor here, while we
 1313                  * know the packet's length.
 1314                  */
xbase = sc->xbds;
sc->ie_bus_write16(sc, IE_XBD_FLAGS(xbase, head),
len | IE_TBD_EOL);
sc->ie_bus_write16(sc, IE_XBD_NEXT(xbase, head), 0xffff);
sc->ie_bus_write24(sc, IE_XBD_BUF(xbase, head),
sc->sc_maddr + IE_XBUF_ADDR(sc, head));
 1322                 /* Start the first packet transmitting. */
 1323                 if (sc->xmit_busy++ == 0)
i82596_xmit(sc);
 1325         }
 1326 }
 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
i82596_proberam(sc)
 1334         struct ie_softc *sc;
 1335 {
 1336         int result, off;
 1338         /* Put in 16-bit mode */
off = IE_SCP_BUS_USE(sc->scp);
 1340         (sc->ie_bus_write16)(sc, off, 0);
bus_space_barrier(sc->bt, sc->bh, off, 2, BUS_SPACE_BARRIER_WRITE);
 1343         /* Set the ISCP `busy' bit */
off = IE_ISCP_BUSY(sc->iscp);
 1345         (sc->ie_bus_write16)(sc, off, 1);
bus_space_barrier(sc->bt, sc->bh, off, 2, BUS_SPACE_BARRIER_WRITE);
 1348         if (sc->hwreset)
 1349                 (sc->hwreset)(sc, IE_CHIP_PROBE);
 1351         (sc->chan_attn) (sc);
DELAY(100);             /* wait a while... */
 1355         /* Read back the ISCP `busy' bit; it should be clear by now */
off = IE_ISCP_BUSY(sc->iscp);
bus_space_barrier(sc->bt, sc->bh, off, 1, BUS_SPACE_BARRIER_READ);
result = (sc->ie_bus_read16)(sc, off) == 0;
 1360         /* Acknowledge any interrupts we may have caused. */
ie_ack(sc, IE_ST_WHENCE);
 1363         return (result);
 1364 }
 1366 void
i82596_reset(sc, hard)
 1368         struct ie_softc *sc;
 1369         int hard;
 1370 {
 1371         int s = splnet();
 1373 #ifdef I82596_DEBUG
 1374         if (hard)
printf("%s: reset\n", sc->sc_dev.dv_xname);
 1376 #endif
 1378         /* Clear OACTIVE in case we're called from watchdog (frozen xmit). */
sc->sc_arpcom.ac_if.if_timer = 0;
sc->sc_arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
 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
printf("%s: abort commands timed out\n", sc->sc_dev.dv_xname);
 1388 #endif
 1389         }
 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);
DELAY(100);
ie_ack(sc, IE_ST_WHENCE);
 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         }
splx(s);
 1410 }
 1412 void
i82596_simple_command(sc, cmd, cmdbuf)
 1414         struct ie_softc *sc;
 1415         int cmd;
 1416         int cmdbuf;
 1417 {
 1418         /* Setup a simple command */
sc->ie_bus_write16(sc, IE_CMD_COMMON_STATUS(cmdbuf), 0);
sc->ie_bus_write16(sc, IE_CMD_COMMON_CMD(cmdbuf), cmd | IE_CMD_LAST);
sc->ie_bus_write16(sc, IE_CMD_COMMON_LINK(cmdbuf), 0xffff);
 1423         /* Assign the command buffer to the SCB command list */
sc->ie_bus_write16(sc, IE_SCB_CMDLST(sc->scb), cmdbuf);
 1425 }
 1427 /*
 1428  * Run the time-domain reflectometer.
 1429  */
 1430 void
ie_run_tdr(sc, cmd)
 1432         struct ie_softc *sc;
 1433         int cmd;
 1434 {
 1435         int result, clocks;
i82596_simple_command(sc, IE_CMD_TDR, cmd);
 1438         (sc->ie_bus_write16)(sc, IE_CMD_TDR_TIME(cmd), 0);
 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))
result = 0x10000; /* XXX */
 1443         else
result = sc->ie_bus_read16(sc, IE_CMD_TDR_TIME(cmd));
 1446         /* Squash any pending interrupts */
ie_ack(sc, IE_ST_WHENCE);
 1449         if (result & IE_TDR_SUCCESS)
 1450                 return;
clocks = result & IE_TDR_TIME;
 1453         if (result & 0x10000)
printf("%s: TDR command failed\n", sc->sc_dev.dv_xname);
 1455         else if (result & IE_TDR_XCVR)
printf("%s: transceiver problem\n", sc->sc_dev.dv_xname);
 1457         else if (result & IE_TDR_OPEN)
printf("%s: TDR detected an open %d clock%s away\n",
sc->sc_dev.dv_xname, clocks, clocks == 1? "":"s");
 1460         else if (result & IE_TDR_SHORT)
printf("%s: TDR detected a short %d clock%s away\n",
sc->sc_dev.dv_xname, clocks, clocks == 1? "":"s");
 1463         else
printf("%s: TDR returned unknown status 0x%x\n",
sc->sc_dev.dv_xname, result);
 1466 }
 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
i82596_setup_bufs(sc)
 1481         struct ie_softc *sc;
 1482 {
 1483         int n, r, ptr = sc->buf_area;   /* memory pool */
 1484         int cl = 32;
 1486         /*
 1487          * step 0: zero memory and figure out how many recv buffers and
 1488          * frames we can have.
 1489          */
ptr = (ptr + cl - 1) & ~(cl - 1); /* set alignment and stick with it */
 1492         /*
 1493          *  step 1: lay out data structures in the shared-memory area
 1494          */
 1496         /* The no-op commands; used if "nop-chaining" is in effect */
ptr += cl;
sc->nop_cmds = ptr - 2;
ptr += NTXBUF * 32;
 1501         /* The transmit commands */
ptr += cl;
sc->xmit_cmds = ptr - 2;
ptr += NTXBUF * 32;
 1506         /* The transmit buffers descriptors */
ptr += cl;
sc->xbds = ptr - 2;
ptr += NTXBUF * 32;
 1511         /* The transmit buffers */
sc->xbufs = ptr;
ptr += NTXBUF * IE_TBUF_SIZE;
ptr = (ptr + cl - 1) & ~(cl - 1);       /* re-align.. just in case */
 1517         /* Compute free space for RECV stuff */
n = sc->buf_area_sz - (ptr - sc->buf_area);
 1520         /* Compute size of one RECV frame */
r = 64 + ((32 + IE_RBUF_SIZE) * B_PER_F);
sc->nframes = n / r;
 1525         if (sc->nframes <= 8)
panic("ie: bogus buffer calc");
sc->nrxbuf = sc->nframes * B_PER_F;
 1530         /* The receive frame descriptors */
ptr += cl;
sc->rframes = ptr - 2;
ptr += sc->nframes * 64;
 1535         /* The receive buffer descriptors */
ptr += cl;
sc->rbds = ptr - 2;
ptr += sc->nrxbuf * 32;
 1540         /* The receive buffers */
sc->rbufs = ptr;
ptr += sc->nrxbuf * IE_RBUF_SIZE;
 1544 #ifdef I82596_DEBUG
printf("%s: %d frames %d bufs\n", sc->sc_dev.dv_xname, sc->nframes,
sc->nrxbuf);
 1547 #endif
 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;
 1555                 /* Clear status */
sc->ie_bus_write16(sc, IE_RFRAME_STATUS(sc->rframes,n), 0);
 1558                 /* RBD link = NULL */
sc->ie_bus_write16(sc, IE_RFRAME_BUFDESC(sc->rframes,n),
 1560                                        0xffff);
 1562                 /* Make a circular list */
sc->ie_bus_write16(sc, IE_RFRAME_NEXT(sc->rframes,n),
IE_RFRAME_ADDR(sc->rframes,m));
 1566                 /* Mark last as EOL */
sc->ie_bus_write16(sc, IE_RFRAME_LAST(sc->rframes,n),
 1568                                        ((m==0)? (IE_FD_EOL|IE_FD_SUSP) : 0));
 1569         }
 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;
 1577                 /* Clear status */
sc->ie_bus_write16(sc, IE_RBD_STATUS(sc->rbds,n), 0);
 1580                 /* Make a circular list */
sc->ie_bus_write16(sc, IE_RBD_NEXT(sc->rbds,n),
IE_RBD_ADDR(sc->rbds,m));
 1584                 /* Link to data buffers */
sc->ie_bus_write24(sc, IE_RBD_BUFADDR(sc->rbds, n),
sc->sc_maddr + IE_RBUF_ADDR(sc, n));
sc->ie_bus_write16(sc, IE_RBD_BUFLEN(sc->rbds,n),
IE_RBUF_SIZE | ((m==0)?IE_RBD_EOL:0));
 1589         }
 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);
 1597                 (sc->ie_bus_write16)(sc, IE_CMD_NOP_CMD(sc->nop_cmds, n),
IE_CMD_NOP);
 1600                 (sc->ie_bus_write16)(sc, IE_CMD_NOP_LINK(sc->nop_cmds, n),
IE_CMD_NOP_ADDR(sc->nop_cmds, n));
 1602         }
 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          */
 1610         /* Pointers to last packet sent and next available transmit buffer. */
sc->xchead = sc->xctail = 0;
 1613         /* Clear transmit-busy flag and set number of free transmit buffers. */
sc->xmit_busy = 0;
 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          */
sc->rfhead = 0;
sc->rftail = sc->nframes - 1;
 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          */
sc->rbhead = 0;
sc->rbtail = sc->nrxbuf - 1;
 1630 /* link in recv frames * and buffer into the scb. */
 1631 #ifdef I82596_DEBUG
printf("%s: reserved %d bytes\n",
sc->sc_dev.dv_xname, ptr - sc->buf_area);
 1634 #endif
 1635 }
 1637 int
ie_cfg_setup(sc, cmd, promiscuous, manchester)
 1639         struct ie_softc *sc;
 1640         int cmd;
 1641         int promiscuous, manchester;
 1642 {
 1643         int cmdresult, status;
i82596_simple_command(sc, IE_CMD_CONFIG, cmd);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_CNT(cmd), 0x0c);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_FIFO(cmd), 8);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_SAVEBAD(cmd), 0x40);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_ADDRLEN(cmd), 0x2e);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_PRIORITY(cmd), 0);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_IFS(cmd), 0x60);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_SLOT_LOW(cmd), 0);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_SLOT_HIGH(cmd), 0xf2);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_PROMISC(cmd),
 1655                                           !!promiscuous | manchester << 2);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_CRSCDT(cmd), 0);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_MINLEN(cmd), 64);
bus_space_write_1(sc->bt, sc->bh, IE_CMD_CFG_JUNK(cmd), 0xff);
bus_space_barrier(sc->bt, sc->bh, cmd, IE_CMD_CFG_SZ,
BUS_SPACE_BARRIER_WRITE);
cmdresult = i82596_start_cmd(sc, IE_CUC_START, cmd, IE_STAT_COMPL, 0);
status = sc->ie_bus_read16(sc, IE_CMD_COMMON_STATUS(cmd));
 1664         if (cmdresult != 0) {
printf("%s: configure command timed out; status %b\n",
sc->sc_dev.dv_xname, status, IE_STAT_BITS);
 1667                 return (0);
 1668         }
 1669         if ((status & IE_STAT_OK) == 0) {
printf("%s: configure command failed; status %b\n",
sc->sc_dev.dv_xname, status, IE_STAT_BITS);
 1672                 return (0);
 1673         }
 1675         /* Squash any pending interrupts */
ie_ack(sc, IE_ST_WHENCE);
 1677         return (1);
 1678 }
 1680 int
ie_ia_setup(sc, cmdbuf)
 1682         struct ie_softc *sc;
 1683         int cmdbuf;
 1684 {
 1685         int cmdresult, status;
i82596_simple_command(sc, IE_CMD_IASETUP, cmdbuf);
 1689         (sc->memcopyout)(sc, sc->sc_arpcom.ac_enaddr,
IE_CMD_IAS_EADDR(cmdbuf), ETHER_ADDR_LEN);
cmdresult = i82596_start_cmd(sc, IE_CUC_START, cmdbuf, IE_STAT_COMPL, 0);
status = sc->ie_bus_read16(sc, IE_CMD_COMMON_STATUS(cmdbuf));
 1694         if (cmdresult != 0) {
printf("%s: individual address command timed out; status %b\n",
sc->sc_dev.dv_xname, status, IE_STAT_BITS);
 1697                 return (0);
 1698         }
 1699         if ((status & IE_STAT_OK) == 0) {
printf("%s: individual address command failed; status %b\n",
sc->sc_dev.dv_xname, status, IE_STAT_BITS);
 1702                 return (0);
 1703         }
 1705         /* Squash any pending interrupts */
ie_ack(sc, IE_ST_WHENCE);
 1707         return (1);
 1708 }
 1710 /*
 1711  * Run the multicast setup command.
 1712  * Called at splnet().
 1713  */
 1714 int
ie_mc_setup(sc, cmdbuf)
 1716         struct ie_softc *sc;
 1717         int cmdbuf;
 1718 {
 1719         int cmdresult, status;
 1721         if (sc->mcast_count == 0)
 1722                 return (1);
i82596_simple_command(sc, IE_CMD_MCAST, cmdbuf);
 1726         (sc->memcopyout)(sc, (caddr_t)sc->mcast_addrs,
IE_CMD_MCAST_MADDR(cmdbuf),
sc->mcast_count * ETHER_ADDR_LEN);
sc->ie_bus_write16(sc, IE_CMD_MCAST_BYTES(cmdbuf),
sc->mcast_count * ETHER_ADDR_LEN);
 1733         /* Start the command */
cmdresult = i82596_start_cmd(sc, IE_CUC_START, cmdbuf, IE_STAT_COMPL, 0);
status = sc->ie_bus_read16(sc, IE_CMD_COMMON_STATUS(cmdbuf));
 1736         if (cmdresult != 0) {
printf("%s: multicast setup command timed out; status %b\n",
sc->sc_dev.dv_xname, status, IE_STAT_BITS);
 1739                 return (0);
 1740         }
 1741         if ((status & IE_STAT_OK) == 0) {
printf("%s: multicast setup command failed; status %b\n",
sc->sc_dev.dv_xname, status, IE_STAT_BITS);
 1744                 return (0);
 1745         }
 1747         /* Squash any pending interrupts */
ie_ack(sc, IE_ST_WHENCE);
 1749         return (1);
 1750 }
 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
i82596_init(sc)
 1762         struct ie_softc *sc;
 1763 {
 1764         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
 1765         int cmd;
sc->async_cmd_inprogress = 0;
cmd = sc->buf_area;
 1771         /*
 1772          * Send the configure command first.
 1773          */
 1774         if (ie_cfg_setup(sc, cmd, sc->promisc, 0) == 0)
 1775                 return (0);
 1777         /*
 1778          * Send the Individual Address Setup command.
 1779          */
 1780         if (ie_ia_setup(sc, cmd) == 0)
 1781                 return (0);
 1783         /*
 1784          * Run the time-domain reflectometer.
 1785          */
ie_run_tdr(sc, cmd);
 1788         /*
 1789          * Set the multi-cast filter, if any
 1790          */
 1791         if (ie_mc_setup(sc, cmd) == 0)
 1792                 return (0);
 1794         /*
 1795          * Acknowledge any interrupts we have generated thus far.
 1796          */
ie_ack(sc, IE_ST_WHENCE);
 1799         /*
 1800          * Set up the transmit and recv buffers.
 1801          */
i82596_setup_bufs(sc);
 1804         if (sc->hwinit)
 1805                 (sc->hwinit)(sc);
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
 1810         if (NTXBUF < 2)
sc->do_xmitnopchain = 0;
i82596_start_transceiver(sc);
 1814         return (1);
 1815 }
 1817 /*
 1818  * Start the RU and possibly the CU unit
 1819  */
 1820 void
i82596_start_transceiver(sc)
 1822         struct ie_softc *sc;
 1823 {
 1825         /*
 1826          * Start RU at current position in frame & RBD lists.
 1827          */
sc->ie_bus_write16(sc, IE_RFRAME_BUFDESC(sc->rframes,sc->rfhead),
IE_RBD_ADDR(sc->rbds, sc->rbhead));
sc->ie_bus_write16(sc, IE_SCB_RCVLST(sc->scb),
IE_RFRAME_ADDR(sc->rframes,sc->rfhead));
 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))
printf("%s: CU/RU stop command timed out\n",
sc->sc_dev.dv_xname);
 1840                 /* Start the receiver & transmitter chain */
 1841                 /* sc->scb->ie_command_list =
 1842                         IEADDR(sc->nop_cmds[(sc->xctail+NTXBUF-1) % NTXBUF]);*/
sc->ie_bus_write16(sc, IE_SCB_CMDLST(sc->scb),
IE_CMD_NOP_ADDR(
sc->nop_cmds,
 1846                                         (sc->xctail + NTXBUF - 1) % NTXBUF));
 1848                 if (i82596_start_cmd(sc, IE_CUC_START|IE_RUC_START, 0, 0, 0))
printf("%s: CU/RU command timed out\n",
sc->sc_dev.dv_xname);
 1851         } else {
 1852                 if (i82596_start_cmd(sc, IE_RUC_START, 0, 0, 0))
printf("%s: RU command timed out\n",
sc->sc_dev.dv_xname);
 1855         }
 1856 }
 1858 void
i82596_stop(sc)
 1860         struct ie_softc *sc;
 1861 {
 1863         if (i82596_start_cmd(sc, IE_RUC_SUSPEND | IE_CUC_SUSPEND, 0, 0, 0))
printf("%s: i82596_stop: disable commands timed out\n",
sc->sc_dev.dv_xname);
 1866 }
 1868 int
i82596_ioctl(ifp, cmd, data)
 1870         register struct ifnet *ifp;
u_long cmd;
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;
s = splnet();
 1881         if ((error = ether_ioctl(ifp, &sc->sc_arpcom, cmd, data)) > 0) {
splx(s);
 1883                 return error;
 1884         }
 1886         switch(cmd) {
 1888         case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
 1891                 switch(ifa->ifa_addr->sa_family) {
 1892 #ifdef INET
 1893                 case AF_INET:
i82596_init(sc);
arp_ifinit(&sc->sc_arpcom, ifa);
 1896                         break;
 1897 #endif
 1898                 default:
i82596_init(sc);
 1900                         break;
 1901                 }
 1902                 break;
 1904         case SIOCSIFFLAGS:
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                          */
i82596_stop(sc);
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                          */
i82596_init(sc);
 1921                 } else {
 1922                         /*
 1923                          * Reset the interface to pick up changes in any other
 1924                          * flags that affect hardware registers.
 1925                          */
i82596_stop(sc);
i82596_init(sc);
 1928                 }
 1929 #ifdef I82596_DEBUG
 1930                 if (ifp->if_flags & IFF_DEBUG)
sc->sc_debug = IED_ALL;
 1932                 else
sc->sc_debug = 0;
 1934 #endif
 1935                 break;
 1937         case SIOCADDMULTI:
 1938         case SIOCDELMULTI:
error = (cmd == SIOCADDMULTI) ?
ether_addmulti(ifr, &sc->sc_arpcom):
ether_delmulti(ifr, &sc->sc_arpcom);
 1943                 if (error == ENETRESET) {
 1944                         /*
 1945                          * Multicast list has changed; set the hardware filter
 1946                          * accordingly.
 1947                          */
 1948                         if (ifp->if_flags & IFF_RUNNING)
ie_mc_reset(sc);
error = 0;
 1951                 }
 1952                 break;
 1954         case SIOCGIFMEDIA:
 1955         case SIOCSIFMEDIA:
error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
 1957                 break;
 1959         default:
error = EINVAL;
 1961         }
splx(s);
 1963         return (error);
 1964 }
 1966 void
ie_mc_reset(sc)
 1968         struct ie_softc *sc;
 1969 {
 1970         struct ether_multi *enm;
 1971         struct ether_multistep step;
 1972         int size;
 1974         /*
 1975          * Step through the list of addresses.
 1976          */
again:
size = 0;
sc->mcast_count = 0;
ETHER_FIRST_MULTI(step, &sc->sc_arpcom, enm);
 1981         while (enm) {
size += 6;
 1983                 if (sc->mcast_count >= IE_MAXMCAST ||
bcmp(enm->enm_addrlo, enm->enm_addrhi, 6) != 0) {
sc->sc_arpcom.ac_if.if_flags |= IFF_ALLMULTI;
i82596_ioctl(&sc->sc_arpcom.ac_if,
SIOCSIFFLAGS, (void *)0);
 1988                         return;
 1989                 }
ETHER_NEXT_MULTI(step, enm);
 1991         }
 1993         if (size > sc->mcast_addrs_size) {
 1994                 /* Need to allocate more space */
 1995                 if (sc->mcast_addrs_size)
free(sc->mcast_addrs, M_IFMADDR);
sc->mcast_addrs = (char *)
malloc(size, M_IFMADDR, M_WAITOK);
sc->mcast_addrs_size = size;
 2000         }
 2002         /*
 2003          * We've got the space; now copy the addresses
 2004          */
ETHER_FIRST_MULTI(step, &sc->sc_arpcom, enm);
 2006         while (enm) {
 2007                 if (sc->mcast_count >= IE_MAXMCAST)
 2008                         goto again; /* Just in case */
bcopy(enm->enm_addrlo, &sc->mcast_addrs[sc->mcast_count], 6);
sc->mcast_count++;
ETHER_NEXT_MULTI(step, enm);
 2013         }
sc->want_mcsetup = 1;
 2015 }
 2017 /*
 2018  * Media change callback.
 2019  */
 2020 int
i82596_mediachange(ifp)
 2022         struct ifnet *ifp;
 2023 {
 2024         struct ie_softc *sc = ifp->if_softc;
 2026         if (sc->sc_mediachange)
 2027                 return ((*sc->sc_mediachange)(sc));
 2028         return (EINVAL);
 2029 }
 2031 /*
 2032  * Media status callback.
 2033  */
 2034 void
i82596_mediastatus(ifp, ifmr)
 2036         struct ifnet *ifp;
 2037         struct ifmediareq *ifmr;
 2038 {
 2039         struct ie_softc *sc = ifp->if_softc;
 2041         if (sc->sc_mediastatus)
 2042                 (*sc->sc_mediastatus)(sc, ifmr);
 2043 }
 2045 #ifdef I82596_DEBUG
 2046 void
print_rbd(sc, n)
 2048         struct ie_softc *sc;
 2049         int n;
 2050 {
printf("RBD at %08x:\n  status %b, next %04x, buffer %lx\n"
 2053                 "length/EOL %04x\n", IE_RBD_ADDR(sc->rbds,n),
sc->ie_bus_read16(sc, IE_RBD_STATUS(sc->rbds,n)), IE_STAT_BITS,
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 */
sc->ie_bus_read16(sc, IE_RBD_BUFLEN(sc->rbds,n)));
 2058 }
 2059 #endif