sys/dev/vx/if_vx.c

   1 /*
   2  * Copyright (c) 1994 Herb Peyerl <hpeyerl@novatel.ca>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Herb Peyerl.
  16  * 4. The name of Herb Peyerl may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * $FreeBSD$
  31  *
  32  */
  33
  34 /*
  35  * Created from if_ep.c driver by Fred Gray (fgray@rice.edu) to support
  36  * the 3c590 family.
  37  */
  38
  39 /*
  40  *      Modified from the FreeBSD 1.1.5.1 version by:
  41  *                      Andres Vega Garcia
  42  *                      INRIA - Sophia Antipolis, France
  43  *                      avega@sophia.inria.fr
  44  */
  45
  46 /*
  47  *  Promiscuous mode added and interrupt logic slightly changed
  48  *  to reduce the number of adapter failures. Transceiver select
  49  *  logic changed to use value from EEPROM. Autoconfiguration
  50  *  features added.
  51  *  Done by:
  52  *          Serge Babkin
  53  *          Chelindbank (Chelyabinsk, Russia)
  54  *          babkin@hq.icb.chel.su
  55  */
  56
  57
  58 #include <sys/param.h>
  59 #include <sys/systm.h>
  60 #include <sys/sockio.h>
  61 #include <sys/malloc.h>
  62 #include <sys/mbuf.h>
  63 #include <sys/socket.h>
  64
  65 #include <net/if.h>
  66
  67 #include <net/ethernet.h>
  68 #include <net/if_arp.h>
  69
  70 #include <machine/bus_pio.h>
  71 #include <machine/bus.h>
  72
  73 #include <net/bpf.h>
  74
  75
  76 #include <dev/vx/if_vxreg.h>
  77
  78 #define ETHER_MAX_LEN   1518
  79 #define ETHER_ADDR_LEN  6
  80 #define ETHER_ALIGN     2
  81
  82 static struct connector_entry {
  83   int bit;
  84   char *name;
  85 } conn_tab[VX_CONNECTORS] = {
  86 #define CONNECTOR_UTP   0
  87   { 0x08, "utp"},
  88 #define CONNECTOR_AUI   1
  89   { 0x20, "aui"},
  90 /* dummy */
  91   { 0, "???"},
  92 #define CONNECTOR_BNC   3
  93   { 0x10, "bnc"},
  94 #define CONNECTOR_TX    4
  95   { 0x02, "tx"},
  96 #define CONNECTOR_FX    5
  97   { 0x04, "fx"},
  98 #define CONNECTOR_MII   6
  99   { 0x40, "mii"},
 100   { 0, "???"}
 101 };
 102
 103 /* int vxattach(struct vx_softc *); */
 104 static void vxtxstat(struct vx_softc *);
 105 static int vxstatus(struct vx_softc *);
 106 static void vxinit(void *);
 107 static int vxioctl(struct ifnet *, u_long, caddr_t);
 108 static void vxstart(struct ifnet *ifp);
 109 static void vxwatchdog(struct ifnet *);
 110 static void vxreset(struct vx_softc *);
 111 /* void vxstop(struct vx_softc *); */
 112 static void vxread(struct vx_softc *);
 113 static struct mbuf *vxget(struct vx_softc *, u_int);
 114 static void vxmbuffill(void *);
 115 static void vxmbufempty(struct vx_softc *);
 116 static void vxsetfilter(struct vx_softc *);
 117 static void vxgetlink(struct vx_softc *);
 118 static void vxsetlink(struct vx_softc *);
 119 /* int vxbusyeeprom(struct vx_softc *); */
 120
 121
 122 int
 123 vxattach(sc)
 124     struct vx_softc *sc;
 125 {
 126     struct ifnet *ifp = &sc->arpcom.ac_if;
 127     int i;
 128
 129     callout_handle_init(&sc->ch);
 130     GO_WINDOW(0);
 131     CSR_WRITE_2(sc, VX_COMMAND, GLOBAL_RESET);
 132     VX_BUSY_WAIT;
 133
 134     vxgetlink(sc);
 135
 136     /*
 137      * Read the station address from the eeprom
 138      */
 139     GO_WINDOW(0);
 140     for (i = 0; i < 3; i++) {
 141         int x;
 142         if (vxbusyeeprom(sc))
 143             return 0;
 144         CSR_WRITE_2(sc,  VX_W0_EEPROM_COMMAND, EEPROM_CMD_RD
 145              | (EEPROM_OEM_ADDR_0 + i));
 146         if (vxbusyeeprom(sc))
 147             return 0;
 148         x = CSR_READ_2(sc, VX_W0_EEPROM_DATA);
 149         sc->arpcom.ac_enaddr[(i << 1)] = x >> 8;
 150         sc->arpcom.ac_enaddr[(i << 1) + 1] = x;
 151     }
 152
 153     printf(" address %6D\n", sc->arpcom.ac_enaddr, ":");
 154
 155     ifp->if_unit = sc->unit;
 156     ifp->if_name = "vx";
 157     ifp->if_mtu = ETHERMTU;
 158     ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
 159     ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 160     ifp->if_output = ether_output;
 161     ifp->if_start = vxstart;
 162     ifp->if_ioctl = vxioctl;
 163     ifp->if_init = vxinit;
 164     ifp->if_watchdog = vxwatchdog;
 165     ifp->if_softc = sc;
 166
 167     ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
 168
 169     sc->tx_start_thresh = 20;   /* probably a good starting point. */
 170
 171     vxstop(sc);
 172
 173     return 1;
 174 }
 175
 176
 177
 178 /*
 179  * The order in here seems important. Otherwise we may not receive
 180  * interrupts. ?!
 181  */
 182 static void
 183 vxinit(xsc)
 184         void *xsc;
 185 {
 186     struct vx_softc *sc = (struct vx_softc *) xsc;
 187     struct ifnet *ifp = &sc->arpcom.ac_if;
 188     int i;
 189
 190     VX_BUSY_WAIT;
 191
 192     GO_WINDOW(2);
 193
 194     for (i = 0; i < 6; i++) /* Reload the ether_addr. */
 195         CSR_WRITE_1(sc,  VX_W2_ADDR_0 + i, sc->arpcom.ac_enaddr[i]);
 196
 197     CSR_WRITE_2(sc,  VX_COMMAND, RX_RESET);
 198     VX_BUSY_WAIT;
 199     CSR_WRITE_2(sc,  VX_COMMAND, TX_RESET);
 200     VX_BUSY_WAIT;
 201
 202     GO_WINDOW(1);       /* Window 1 is operating window */
 203     for (i = 0; i < 31; i++)
 204         CSR_READ_1(sc,  VX_W1_TX_STATUS);
 205
 206     CSR_WRITE_2(sc,  VX_COMMAND,SET_RD_0_MASK | S_CARD_FAILURE |
 207                         S_RX_COMPLETE | S_TX_COMPLETE | S_TX_AVAIL);
 208     CSR_WRITE_2(sc,  VX_COMMAND,SET_INTR_MASK | S_CARD_FAILURE |
 209                         S_RX_COMPLETE | S_TX_COMPLETE | S_TX_AVAIL);
 210
 211     /*
 212      * Attempt to get rid of any stray interrupts that occured during
 213      * configuration.  On the i386 this isn't possible because one may
 214      * already be queued.  However, a single stray interrupt is
 215      * unimportant.
 216      */
 217     CSR_WRITE_2(sc,  VX_COMMAND, ACK_INTR | 0xff);
 218
 219     vxsetfilter(sc);
 220     vxsetlink(sc);
 221
 222     CSR_WRITE_2(sc,  VX_COMMAND, RX_ENABLE);
 223     CSR_WRITE_2(sc,  VX_COMMAND, TX_ENABLE);
 224
 225     vxmbuffill((caddr_t) sc);
 226
 227     /* Interface is now `running', with no output active. */
 228     ifp->if_flags |= IFF_RUNNING;
 229     ifp->if_flags &= ~IFF_OACTIVE;
 230
 231     /* Attempt to start output, if any. */
 232     vxstart(ifp);
 233 }
 234
 235 static void
 236 vxsetfilter(sc)
 237     struct vx_softc *sc;
 238 {
 239     register struct ifnet *ifp = &sc->arpcom.ac_if;
 240
 241     GO_WINDOW(1);           /* Window 1 is operating window */
 242     CSR_WRITE_2(sc,  VX_COMMAND, SET_RX_FILTER | FIL_INDIVIDUAL | FIL_BRDCST |
 243          FIL_MULTICAST |
 244          ((ifp->if_flags & IFF_PROMISC) ? FIL_PROMISC : 0 ));
 245 }
 246
 247 static void
 248 vxgetlink(sc)
 249     struct vx_softc *sc;
 250 {
 251     int n, k;
 252
 253     GO_WINDOW(3);
 254     sc->vx_connectors = CSR_READ_2(sc, VX_W3_RESET_OPT) & 0x7f;
 255     for (n = 0, k = 0; k < VX_CONNECTORS; k++) {
 256       if (sc->vx_connectors & conn_tab[k].bit) {
 257         if (n > 0) {
 258           printf("/");
 259         }
 260         printf("%s", conn_tab[k].name);
 261         n++;
 262       }
 263     }
 264     if (sc->vx_connectors == 0) {
 265         printf("no connectors!");
 266         return;
 267     }
 268     GO_WINDOW(3);
 269     sc->vx_connector = (CSR_READ_4(sc,  VX_W3_INTERNAL_CFG)
 270                         & INTERNAL_CONNECTOR_MASK)
 271                         >> INTERNAL_CONNECTOR_BITS;
 272     if (sc->vx_connector & 0x10) {
 273         sc->vx_connector &= 0x0f;
 274         printf("[*%s*]", conn_tab[(int)sc->vx_connector].name);
 275         printf(": disable 'auto select' with DOS util!");
 276     } else {
 277         printf("[*%s*]", conn_tab[(int)sc->vx_connector].name);
 278     }
 279 }
 280
 281 static void
 282 vxsetlink(sc)
 283     struct vx_softc *sc;
 284 {
 285     register struct ifnet *ifp = &sc->arpcom.ac_if;
 286     int i, j, k;
 287     char *reason, *warning;
 288     static int prev_flags;
 289     static char prev_conn = -1;
 290
 291     if (prev_conn == -1) {
 292         prev_conn = sc->vx_connector;
 293     }
 294
 295     /*
 296      * S.B.
 297      *
 298      * Now behavior was slightly changed:
 299      *
 300      * if any of flags link[0-2] is used and its connector is
 301      * physically present the following connectors are used:
 302      *
 303      *   link0 - AUI * highest precedence
 304      *   link1 - BNC
 305      *   link2 - UTP * lowest precedence
 306      *
 307      * If none of them is specified then
 308      * connector specified in the EEPROM is used
 309      * (if present on card or UTP if not).
 310      */
 311
 312     i = sc->vx_connector;       /* default in EEPROM */
 313     reason = "default";
 314     warning = 0;
 315
 316     if (ifp->if_flags & IFF_LINK0) {
 317         if (sc->vx_connectors & conn_tab[CONNECTOR_AUI].bit) {
 318             i = CONNECTOR_AUI;
 319             reason = "link0";
 320         } else {
 321             warning = "aui not present! (link0)";
 322         }
 323     } else if (ifp->if_flags & IFF_LINK1) {
 324         if (sc->vx_connectors & conn_tab[CONNECTOR_BNC].bit) {
 325             i = CONNECTOR_BNC;
 326             reason = "link1";
 327         } else {
 328             warning = "bnc not present! (link1)";
 329         }
 330     } else if (ifp->if_flags & IFF_LINK2) {
 331         if (sc->vx_connectors & conn_tab[CONNECTOR_UTP].bit) {
 332             i = CONNECTOR_UTP;
 333             reason = "link2";
 334         } else {
 335             warning = "utp not present! (link2)";
 336         }
 337     } else if ((sc->vx_connectors & conn_tab[(int)sc->vx_connector].bit) == 0) {
 338         warning = "strange connector type in EEPROM.";
 339         reason = "forced";
 340         i = CONNECTOR_UTP;
 341     }
 342
 343     /* Avoid unnecessary message. */
 344     k = (prev_flags ^ ifp->if_flags) & (IFF_LINK0 | IFF_LINK1 | IFF_LINK2);
 345     if ((k != 0) || (prev_conn != i)) {
 346         if (warning != 0) {
 347             printf("vx%d: warning: %s\n", sc->unit, warning);
 348         }
 349         printf("vx%d: selected %s. (%s)\n",
 350                sc->unit, conn_tab[i].name, reason);
 351     }
 352
 353     /* Set the selected connector. */
 354     GO_WINDOW(3);
 355     j = CSR_READ_4(sc,  VX_W3_INTERNAL_CFG) & ~INTERNAL_CONNECTOR_MASK;
 356     CSR_WRITE_4(sc,  VX_W3_INTERNAL_CFG, j | (i <<INTERNAL_CONNECTOR_BITS));
 357
 358     /* First, disable all. */
 359     CSR_WRITE_2(sc,  VX_COMMAND, STOP_TRANSCEIVER);
 360     DELAY(800);
 361     GO_WINDOW(4);
 362     CSR_WRITE_2(sc,  VX_W4_MEDIA_TYPE, 0);
 363
 364     /* Second, enable the selected one. */
 365     switch(i) {
 366       case CONNECTOR_UTP:
 367         GO_WINDOW(4);
 368         CSR_WRITE_2(sc,  VX_W4_MEDIA_TYPE, ENABLE_UTP);
 369         break;
 370       case CONNECTOR_BNC:
 371         CSR_WRITE_2(sc,  VX_COMMAND, START_TRANSCEIVER);
 372         DELAY(800);
 373         break;
 374       case CONNECTOR_TX:
 375       case CONNECTOR_FX:
 376         GO_WINDOW(4);
 377         CSR_WRITE_2(sc,  VX_W4_MEDIA_TYPE, LINKBEAT_ENABLE);
 378         break;
 379       default:  /* AUI and MII fall here */
 380         break;
 381     }
 382     GO_WINDOW(1);
 383
 384     prev_flags = ifp->if_flags;
 385     prev_conn = i;
 386 }
 387
 388 static void
 389 vxstart(ifp)
 390     struct ifnet *ifp;
 391 {
 392     register struct vx_softc *sc = ifp->if_softc;
 393     register struct mbuf *m;
 394     int sh, len, pad;
 395
 396     /* Don't transmit if interface is busy or not running */
 397     if ((sc->arpcom.ac_if.if_flags & (IFF_RUNNING|IFF_OACTIVE)) != IFF_RUNNING)
 398         return;
 399
 400 startagain:
 401     /* Sneak a peek at the next packet */
 402     m = ifp->if_snd.ifq_head;
 403     if (m == NULL) {
 404         return;
 405     }
 406     /* We need to use m->m_pkthdr.len, so require the header */
 407      if ((m->m_flags & M_PKTHDR) == 0)
 408         panic("vxstart: no header mbuf");
 409      len = m->m_pkthdr.len;
 410
 411      pad = (4 - len) & 3;
 412
 413     /*
 414      * The 3c509 automatically pads short packets to minimum ethernet length,
 415      * but we drop packets that are too large. Perhaps we should truncate
 416      * them instead?
 417      */
 418     if (len + pad > ETHER_MAX_LEN) {
 419         /* packet is obviously too large: toss it */
 420         ++ifp->if_oerrors;
 421         IF_DEQUEUE(&ifp->if_snd, m);
 422         m_freem(m);
 423         goto readcheck;
 424     }
 425     VX_BUSY_WAIT;
 426     if (CSR_READ_2(sc, VX_W1_FREE_TX) < len + pad + 4) {
 427         CSR_WRITE_2(sc,  VX_COMMAND, SET_TX_AVAIL_THRESH | ((len + pad + 4) >> 2));
 428         /* not enough room in FIFO */
 429         if (CSR_READ_2(sc, VX_W1_FREE_TX) < len + pad + 4) { /* make sure */
 430             ifp->if_flags |= IFF_OACTIVE;
 431             ifp->if_timer = 1;
 432             return;
 433         }
 434     }
 435     CSR_WRITE_2(sc,  VX_COMMAND, SET_TX_AVAIL_THRESH | (8188 >> 2));
 436     IF_DEQUEUE(&ifp->if_snd, m);
 437     if (m == NULL)              /* not really needed */
 438         return;
 439
 440     VX_BUSY_WAIT;
 441     CSR_WRITE_2(sc,  VX_COMMAND, SET_TX_START_THRESH |
 442         ((len / 4 + sc->tx_start_thresh) >> 2));
 443
 444     if (sc->arpcom.ac_if.if_bpf) {
 445         bpf_mtap(&sc->arpcom.ac_if, m);
 446     }
 447
 448     /*
 449      * Do the output at splhigh() so that an interrupt from another device
 450      * won't cause a FIFO underrun.
 451      */
 452     sh = splhigh();
 453
 454     CSR_WRITE_4(sc,  VX_W1_TX_PIO_WR_1, len | TX_INDICATE);
 455
 456     while (m) {
 457         if (m->m_len > 3)
 458             bus_space_write_multi_4(sc->vx_btag, sc->vx_bhandle,
 459                 VX_W1_TX_PIO_WR_1, (u_int32_t *)mtod(m, caddr_t), m->m_len / 4);
 460         if (m->m_len & 3)
 461             bus_space_write_multi_1(sc->vx_btag, sc->vx_bhandle,
 462                 VX_W1_TX_PIO_WR_1,
 463                 mtod(m, caddr_t) + (m->m_len & ~3) , m->m_len & 3);
 464         m = m_free(m);
 465     }
 466     while (pad--)
 467         CSR_WRITE_1(sc,  VX_W1_TX_PIO_WR_1, 0); /* Padding */
 468
 469     splx(sh);
 470
 471     ++ifp->if_opackets;
 472     ifp->if_timer = 1;
 473
 474 readcheck:
 475     if ((CSR_READ_2(sc, VX_W1_RX_STATUS) & ERR_INCOMPLETE) == 0) {
 476         /* We received a complete packet. */
 477
 478         if ((CSR_READ_2(sc, VX_STATUS) & S_INTR_LATCH) == 0) {
 479             /*
 480              * No interrupt, read the packet and continue
 481              * Is  this supposed to happen? Is my motherboard
 482              * completely busted?
 483              */
 484             vxread(sc);
 485         } else
 486             /* Got an interrupt, return so that it gets serviced. */
 487             return;
 488     } else {
 489         /* Check if we are stuck and reset [see XXX comment] */
 490         if (vxstatus(sc)) {
 491             if (ifp->if_flags & IFF_DEBUG)
 492                printf("vx%d: adapter reset\n", ifp->if_unit);
 493             vxreset(sc);
 494         }
 495     }
 496
 497     goto startagain;
 498 }
 499
 500 /*
 501  * XXX: The 3c509 card can get in a mode where both the fifo status bit
 502  *      FIFOS_RX_OVERRUN and the status bit ERR_INCOMPLETE are set
 503  *      We detect this situation and we reset the adapter.
 504  *      It happens at times when there is a lot of broadcast traffic
 505  *      on the cable (once in a blue moon).
 506  */
 507 static int
 508 vxstatus(sc)
 509     struct vx_softc *sc;
 510 {
 511     int fifost;
 512
 513     /*
 514      * Check the FIFO status and act accordingly
 515      */
 516     GO_WINDOW(4);
 517     fifost = CSR_READ_2(sc, VX_W4_FIFO_DIAG);
 518     GO_WINDOW(1);
 519
 520     if (fifost & FIFOS_RX_UNDERRUN) {
 521         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 522             printf("vx%d: RX underrun\n", sc->unit);
 523         vxreset(sc);
 524         return 0;
 525     }
 526
 527     if (fifost & FIFOS_RX_STATUS_OVERRUN) {
 528         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 529             printf("vx%d: RX Status overrun\n", sc->unit);
 530         return 1;
 531     }
 532
 533     if (fifost & FIFOS_RX_OVERRUN) {
 534         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 535             printf("vx%d: RX overrun\n", sc->unit);
 536         return 1;
 537     }
 538
 539     if (fifost & FIFOS_TX_OVERRUN) {
 540         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 541             printf("vx%d: TX overrun\n", sc->unit);
 542         vxreset(sc);
 543         return 0;
 544     }
 545
 546     return 0;
 547 }
 548
 549 static void
 550 vxtxstat(sc)
 551     struct vx_softc *sc;
 552 {
 553     int i;
 554
 555     /*
 556     * We need to read+write TX_STATUS until we get a 0 status
 557     * in order to turn off the interrupt flag.
 558     */
 559     while ((i = CSR_READ_1(sc,  VX_W1_TX_STATUS)) & TXS_COMPLETE) {
 560         CSR_WRITE_1(sc,  VX_W1_TX_STATUS, 0x0);
 561
 562     if (i & TXS_JABBER) {
 563         ++sc->arpcom.ac_if.if_oerrors;
 564         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 565             printf("vx%d: jabber (%x)\n", sc->unit, i);
 566         vxreset(sc);
 567     } else if (i & TXS_UNDERRUN) {
 568         ++sc->arpcom.ac_if.if_oerrors;
 569         if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
 570             printf("vx%d: fifo underrun (%x) @%d\n",
 571                 sc->unit, i, sc->tx_start_thresh);
 572         if (sc->tx_succ_ok < 100)
 573             sc->tx_start_thresh = min(ETHER_MAX_LEN, sc->tx_start_thresh + 20);
 574         sc->tx_succ_ok = 0;
 575         vxreset(sc);
 576     } else if (i & TXS_MAX_COLLISION) {
 577         ++sc->arpcom.ac_if.if_collisions;
 578         CSR_WRITE_2(sc,  VX_COMMAND, TX_ENABLE);
 579         sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
 580     } else
 581         sc->tx_succ_ok = (sc->tx_succ_ok+1) & 127;
 582     }
 583 }
 584
 585 void
 586 vxintr(voidsc)
 587     void *voidsc;
 588 {
 589     register short status;
 590     struct vx_softc *sc = voidsc;
 591     struct ifnet *ifp = &sc->arpcom.ac_if;
 592
 593     for (;;) {
 594         CSR_WRITE_2(sc,  VX_COMMAND, C_INTR_LATCH);
 595
 596         status = CSR_READ_2(sc, VX_STATUS);
 597
 598         if ((status & (S_TX_COMPLETE | S_TX_AVAIL |
 599                 S_RX_COMPLETE | S_CARD_FAILURE)) == 0)
 600             break;
 601
 602         /*
 603          * Acknowledge any interrupts.  It's important that we do this
 604          * first, since there would otherwise be a race condition.
 605          * Due to the i386 interrupt queueing, we may get spurious
 606          * interrupts occasionally.
 607          */
 608         CSR_WRITE_2(sc,  VX_COMMAND, ACK_INTR | status);
 609
 610         if (status & S_RX_COMPLETE)
 611             vxread(sc);
 612         if (status & S_TX_AVAIL) {
 613             ifp->if_timer = 0;
 614             sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
 615             vxstart(&sc->arpcom.ac_if);
 616         }
 617         if (status & S_CARD_FAILURE) {
 618             printf("vx%d: adapter failure (%x)\n", sc->unit, status);
 619             ifp->if_timer = 0;
 620             vxreset(sc);
 621             return;
 622         }
 623         if (status & S_TX_COMPLETE) {
 624             ifp->if_timer = 0;
 625             vxtxstat(sc);
 626             vxstart(ifp);
 627         }
 628     }
 629
 630     /* no more interrupts */
 631     return;
 632 }
 633
 634 static void
 635 vxread(sc)
 636     struct vx_softc *sc;
 637 {
 638     struct ifnet *ifp = &sc->arpcom.ac_if;
 639     struct mbuf *m;
 640     struct ether_header *eh;
 641     u_int len;
 642
 643     len = CSR_READ_2(sc, VX_W1_RX_STATUS);
 644
 645 again:
 646
 647     if (ifp->if_flags & IFF_DEBUG) {
 648         int err = len & ERR_MASK;
 649         char *s = NULL;
 650
 651         if (len & ERR_INCOMPLETE)
 652             s = "incomplete packet";
 653         else if (err == ERR_OVERRUN)
 654             s = "packet overrun";
 655         else if (err == ERR_RUNT)
 656             s = "runt packet";
 657         else if (err == ERR_ALIGNMENT)
 658             s = "bad alignment";
 659         else if (err == ERR_CRC)
 660             s = "bad crc";
 661         else if (err == ERR_OVERSIZE)
 662             s = "oversized packet";
 663         else if (err == ERR_DRIBBLE)
 664             s = "dribble bits";
 665
 666         if (s)
 667         printf("vx%d: %s\n", sc->unit, s);
 668     }
 669
 670     if (len & ERR_INCOMPLETE)
 671         return;
 672
 673     if (len & ERR_RX) {
 674         ++ifp->if_ierrors;
 675         goto abort;
 676     }
 677
 678     len &= RX_BYTES_MASK;       /* Lower 11 bits = RX bytes. */
 679
 680     /* Pull packet off interface. */
 681     m = vxget(sc, len);
 682     if (m == 0) {
 683         ifp->if_ierrors++;
 684         goto abort;
 685     }
 686
 687     ++ifp->if_ipackets;
 688
 689     {
 690         struct mbuf             *m0;
 691
 692         m0 = m_devget(mtod(m, char *), m->m_pkthdr.len, ETHER_ALIGN, ifp, NULL);
 693         if (m0 == NULL) {
 694                 ifp->if_ierrors++;
 695                 goto abort;
 696         }
 697
 698         m_freem(m);
 699         m = m0;
 700     }
 701
 702     /* We assume the header fit entirely in one mbuf. */
 703     eh = mtod(m, struct ether_header *);
 704
 705     /*
 706      * XXX: Some cards seem to be in promiscous mode all the time.
 707      * we need to make sure we only get our own stuff always.
 708      * bleah!
 709      */
 710
 711     if ((eh->ether_dhost[0] & 1) == 0           /* !mcast and !bcast */
 712       && bcmp(eh->ether_dhost, sc->arpcom.ac_enaddr, ETHER_ADDR_LEN) != 0) {
 713         m_freem(m);
 714         return;
 715     }
 716
 717     m_adj(m, sizeof(struct ether_header));
 718     ether_input(ifp, eh, m);
 719
 720     /*
 721     * In periods of high traffic we can actually receive enough
 722     * packets so that the fifo overrun bit will be set at this point,
 723     * even though we just read a packet. In this case we
 724     * are not going to receive any more interrupts. We check for
 725     * this condition and read again until the fifo is not full.
 726     * We could simplify this test by not using vxstatus(), but
 727     * rechecking the RX_STATUS register directly. This test could
 728     * result in unnecessary looping in cases where there is a new
 729     * packet but the fifo is not full, but it will not fix the
 730     * stuck behavior.
 731     *
 732     * Even with this improvement, we still get packet overrun errors
 733     * which are hurting performance. Maybe when I get some more time
 734     * I'll modify vxread() so that it can handle RX_EARLY interrupts.
 735     */
 736     if (vxstatus(sc)) {
 737         len = CSR_READ_2(sc, VX_W1_RX_STATUS);
 738         /* Check if we are stuck and reset [see XXX comment] */
 739         if (len & ERR_INCOMPLETE) {
 740             if (ifp->if_flags & IFF_DEBUG)
 741                 printf("vx%d: adapter reset\n", sc->unit);
 742             vxreset(sc);
 743             return;
 744         }
 745         goto again;
 746     }
 747
 748     return;
 749
 750 abort:
 751     CSR_WRITE_2(sc,  VX_COMMAND, RX_DISCARD_TOP_PACK);
 752 }
 753
 754 static struct mbuf *
 755 vxget(sc, totlen)
 756     struct vx_softc *sc;
 757     u_int totlen;
 758 {
 759     struct ifnet *ifp = &sc->arpcom.ac_if;
 760     struct mbuf *top, **mp, *m;
 761     int len;
 762     int sh;
 763
 764     m = sc->mb[sc->next_mb];
 765     sc->mb[sc->next_mb] = 0;
 766     if (m == 0) {
 767         MGETHDR(m, M_DONTWAIT, MT_DATA);
 768         if (m == 0)
 769             return 0;
 770     } else {
 771         /* If the queue is no longer full, refill. */
 772         if (sc->last_mb == sc->next_mb && sc->buffill_pending == 0) {
 773             sc->ch = timeout(vxmbuffill, sc, 1);
 774             sc->buffill_pending = 1;
 775         }
 776         /* Convert one of our saved mbuf's. */
 777         sc->next_mb = (sc->next_mb + 1) % MAX_MBS;
 778         m->m_data = m->m_pktdat;
 779         m->m_flags = M_PKTHDR;
 780         bzero(&m->m_pkthdr, sizeof(m->m_pkthdr));
 781     }
 782     m->m_pkthdr.rcvif = ifp;
 783     m->m_pkthdr.len = totlen;
 784     len = MHLEN;
 785     top = 0;
 786     mp = &top;
 787
 788     /*
 789      * We read the packet at splhigh() so that an interrupt from another
 790      * device doesn't cause the card's buffer to overflow while we're
 791      * reading it.  We may still lose packets at other times.
 792      */
 793     sh = splhigh();
 794
 795     /*
 796      * Since we don't set allowLargePackets bit in MacControl register,
 797      * we can assume that totlen <= 1500bytes.
 798      * The while loop will be performed iff we have a packet with
 799      * MLEN < m_len < MINCLSIZE.
 800      */
 801     while (totlen > 0) {
 802         if (top) {
 803             m = sc->mb[sc->next_mb];
 804             sc->mb[sc->next_mb] = 0;
 805             if (m == 0) {
 806                 MGET(m, M_DONTWAIT, MT_DATA);
 807                 if (m == 0) {
 808                     splx(sh);
 809                     m_freem(top);
 810                     return 0;
 811                 }
 812             } else {
 813                 sc->next_mb = (sc->next_mb + 1) % MAX_MBS;
 814             }
 815             len = MLEN;
 816         }
 817         if (totlen >= MINCLSIZE) {
 818             MCLGET(m, M_DONTWAIT);
 819             if (m->m_flags & M_EXT)
 820                 len = MCLBYTES;
 821         }
 822         len = min(totlen, len);
 823         if (len > 3)
 824             bus_space_read_multi_4(sc->vx_btag, sc->vx_bhandle,
 825                 VX_W1_RX_PIO_RD_1, mtod(m, u_int32_t *), len / 4);
 826         if (len & 3) {
 827             bus_space_read_multi_1(sc->vx_btag, sc->vx_bhandle,
 828                 VX_W1_RX_PIO_RD_1, mtod(m, u_int8_t *) + (len & ~3),
 829                 len & 3);
 830         }
 831         m->m_len = len;
 832         totlen -= len;
 833         *mp = m;
 834         mp = &m->m_next;
 835     }
 836
 837     CSR_WRITE_2(sc, VX_COMMAND, RX_DISCARD_TOP_PACK);
 838
 839     splx(sh);
 840
 841     return top;
 842 }
 843
 844
 845 static int
 846 vxioctl(ifp, cmd, data)
 847     register struct ifnet *ifp;
 848     u_long cmd;
 849     caddr_t data;
 850 {
 851     struct vx_softc *sc = ifp->if_softc;
 852     struct ifreq *ifr = (struct ifreq *) data;
 853     int s, error = 0;
 854
 855     s = splimp();
 856
 857     switch (cmd) {
 858     case SIOCSIFADDR:
 859     case SIOCGIFADDR:
 860         ether_ioctl(ifp, cmd, data);
 861         break;
 862
 863     case SIOCSIFFLAGS:
 864         if ((ifp->if_flags & IFF_UP) == 0 &&
 865             (ifp->if_flags & IFF_RUNNING) != 0) {
 866             /*
 867              * If interface is marked up and it is stopped, then
 868              * start it.
 869              */
 870             vxstop(sc);
 871             ifp->if_flags &= ~IFF_RUNNING;
 872         } else if ((ifp->if_flags & IFF_UP) != 0 &&
 873                    (ifp->if_flags & IFF_RUNNING) == 0) {
 874             /*
 875              * If interface is marked up and it is stopped, then
 876              * start it.
 877              */
 878             vxinit(sc);
 879         } else {
 880             /*
 881              * deal with flags changes:
 882              * IFF_MULTICAST, IFF_PROMISC,
 883              * IFF_LINK0, IFF_LINK1,
 884              */
 885             vxsetfilter(sc);
 886             vxsetlink(sc);
 887         }
 888         break;
 889
 890     case SIOCSIFMTU:
 891         /*
 892          * Set the interface MTU.
 893          */
 894         if (ifr->ifr_mtu > ETHERMTU) {
 895             error = EINVAL;
 896         } else {
 897             ifp->if_mtu = ifr->ifr_mtu;
 898         }
 899         break;
 900
 901     case SIOCADDMULTI:
 902     case SIOCDELMULTI:
 903         /*
 904          * Multicast list has changed; set the hardware filter
 905          * accordingly.
 906          */
 907         vxreset(sc);
 908         error = 0;
 909         break;
 910
 911
 912     default:
 913         error = EINVAL;
 914     }
 915
 916     splx(s);
 917
 918     return (error);
 919 }
 920
 921 static void
 922 vxreset(sc)
 923     struct vx_softc *sc;
 924 {
 925     int s;
 926     s = splimp();
 927
 928     vxstop(sc);
 929     vxinit(sc);
 930     splx(s);
 931 }
 932
 933 static void
 934 vxwatchdog(ifp)
 935     struct ifnet *ifp;
 936 {
 937     struct vx_softc *sc = ifp->if_softc;
 938
 939     if (ifp->if_flags & IFF_DEBUG)
 940         printf("vx%d: device timeout\n", ifp->if_unit);
 941     ifp->if_flags &= ~IFF_OACTIVE;
 942     vxstart(ifp);
 943     vxintr(sc);
 944 }
 945
 946 void
 947 vxstop(sc)
 948     struct vx_softc *sc;
 949 {
 950     struct ifnet *ifp = &sc->arpcom.ac_if;
 951
 952     ifp->if_timer = 0;
 953
 954     CSR_WRITE_2(sc,  VX_COMMAND, RX_DISABLE);
 955     CSR_WRITE_2(sc,  VX_COMMAND, RX_DISCARD_TOP_PACK);
 956     VX_BUSY_WAIT;
 957     CSR_WRITE_2(sc,  VX_COMMAND, TX_DISABLE);
 958     CSR_WRITE_2(sc,  VX_COMMAND, STOP_TRANSCEIVER);
 959     DELAY(800);
 960     CSR_WRITE_2(sc,  VX_COMMAND, RX_RESET);
 961     VX_BUSY_WAIT;
 962     CSR_WRITE_2(sc,  VX_COMMAND, TX_RESET);
 963     VX_BUSY_WAIT;
 964     CSR_WRITE_2(sc,  VX_COMMAND, C_INTR_LATCH);
 965     CSR_WRITE_2(sc,  VX_COMMAND, SET_RD_0_MASK);
 966     CSR_WRITE_2(sc,  VX_COMMAND, SET_INTR_MASK);
 967     CSR_WRITE_2(sc,  VX_COMMAND, SET_RX_FILTER);
 968
 969     vxmbufempty(sc);
 970 }
 971
 972 int
 973 vxbusyeeprom(sc)
 974     struct vx_softc *sc;
 975 {
 976     int j, i = 100;
 977
 978     while (i--) {
 979         j = CSR_READ_2(sc, VX_W0_EEPROM_COMMAND);
 980         if (j & EEPROM_BUSY)
 981             DELAY(100);
 982         else
 983             break;
 984     }
 985     if (!i) {
 986         printf("vx%d: eeprom failed to come ready\n", sc->unit);
 987         return (1);
 988     }
 989     return (0);
 990 }
 991
 992 static void
 993 vxmbuffill(sp)
 994     void *sp;
 995 {
 996     struct vx_softc *sc = (struct vx_softc *) sp;
 997     int s, i;
 998
 999     s = splimp();
1000     i = sc->last_mb;
1001     do {
1002         if (sc->mb[i] == NULL)
1003             MGET(sc->mb[i], M_DONTWAIT, MT_DATA);
1004         if (sc->mb[i] == NULL)
1005             break;
1006         i = (i + 1) % MAX_MBS;
1007     } while (i != sc->next_mb);
1008     sc->last_mb = i;
1009     /* If the queue was not filled, try again. */
1010     if (sc->last_mb != sc->next_mb) {
1011         sc->ch = timeout(vxmbuffill, sc, 1);
1012         sc->buffill_pending = 1;
1013     } else {
1014         sc->buffill_pending = 0;
1015     }
1016     splx(s);
1017 }
1018
1019 static void
1020 vxmbufempty(sc)
1021     struct vx_softc *sc;
1022 {
1023     int s, i;
1024
1025     s = splimp();
1026     for (i = 0; i < MAX_MBS; i++) {
1027         if (sc->mb[i]) {
1028             m_freem(sc->mb[i]);
1029             sc->mb[i] = NULL;
1030         }
1031     }
1032     sc->last_mb = sc->next_mb = 0;
1033     if (sc->buffill_pending != 0)
1034         untimeout(vxmbuffill, sc, sc->ch);
1035     splx(s);
1036 }