sys/dev/netif/ep/if_ep.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  *      if_ep.c,v 1.19 1995/01/24 20:53:45 davidg Exp
  31  */
  32
  33 /*
  34  *      Modified from the FreeBSD 1.1.5.1 version by:
  35  *                      Andres Vega Garcia
  36  *                      INRIA - Sophia Antipolis, France
  37  *                      avega@sophia.inria.fr
  38  */
  39
  40 /*
  41  * $FreeBSD: src/sys/dev/ep/if_ep.c,v 1.95.2.3 2002/03/06 07:26:35 imp Exp $
  42  *
  43  *  Promiscuous mode added and interrupt logic slightly changed
  44  *  to reduce the number of adapter failures. Transceiver select
  45  *  logic changed to use value from EEPROM. Autoconfiguration
  46  *  features added.
  47  *  Done by:
  48  *          Serge Babkin
  49  *          Chelindbank (Chelyabinsk, Russia)
  50  *          babkin@hq.icb.chel.su
  51  */
  52
  53 /*
  54  * Pccard support for 3C589 by:
  55  *              HAMADA Naoki
  56  *              nao@tom-yam.or.jp
  57  */
  58
  59 /*
  60  * MAINTAINER: Matthew N. Dodd <winter@jurai.net>
  61  *                             <mdodd@FreeBSD.org>
  62  */
  63
  64 #include <sys/param.h>
  65 #include <sys/kernel.h>
  66 #include <sys/systm.h>
  67 #include <sys/malloc.h>
  68 #include <sys/mbuf.h>
  69 #include <sys/socket.h>
  70 #include <sys/sockio.h>
  71 #include <sys/module.h>
  72 #include <sys/bus.h>
  73 #include <sys/rman.h>
  74 #include <sys/thread2.h>
  75
  76 #include <net/if.h>
  77 #include <net/ifq_var.h>
  78 #include <net/if_arp.h>
  79 #include <net/if_media.h>
  80 #include <net/ethernet.h>
  81 #include <net/bpf.h>
  82
  83 #include <netinet/in.h>
  84 #include <netinet/if_ether.h>
  85
  86 #include <machine/clock.h>
  87
  88 #include "if_epreg.h"
  89 #include "if_epvar.h"
  90 #include "../elink_layer/elink.h"
  91
  92 /* Exported variables */
  93 devclass_t ep_devclass;
  94
  95 #if 0
  96 static char *   ep_conn_type[] = {"UTP", "AUI", "???", "BNC"};
  97 static int      if_media2ep_media[] = { 0, 0, 0, UTP, BNC, AUI };
  98 #endif
  99
 100 static int      ep_media2if_media[] =
 101         { IFM_10_T, IFM_10_5, IFM_NONE, IFM_10_2, IFM_NONE };
 102
 103 /* if functions */
 104 static void     ep_if_init      (void *);
 105 static int      ep_if_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
 106 static void     ep_if_start     (struct ifnet *);
 107 static void     ep_if_watchdog  (struct ifnet *);
 108
 109 /* if_media functions */
 110 static int      ep_ifmedia_upd  (struct ifnet *);
 111 static void     ep_ifmedia_sts  (struct ifnet *, struct ifmediareq *);
 112
 113 static void     epstop          (struct ep_softc *);
 114 static void     epread          (struct ep_softc *);
 115 static int      eeprom_rdy      (struct ep_softc *);
 116
 117 DECLARE_DUMMY_MODULE(if_ep);
 118
 119 #define EP_FTST(sc, f)  (sc->stat &   (f))
 120 #define EP_FSET(sc, f)  (sc->stat |=  (f))
 121 #define EP_FRST(sc, f)  (sc->stat &= ~(f))
 122
 123 static int
 124 eeprom_rdy(struct ep_softc *sc)
 125 {
 126     int i;
 127
 128     for (i = 0; is_eeprom_busy(BASE) && i < MAX_EEPROMBUSY; i++) {
 129         DELAY(100);
 130     }
 131     if (i >= MAX_EEPROMBUSY) {
 132         if_printf(&sc->arpcom.ac_if, "eeprom failed to come ready.\n");
 133         return (0);
 134     }
 135     return (1);
 136 }
 137
 138 /*
 139  * get_e: gets a 16 bits word from the EEPROM. we must have set the window
 140  * before
 141  */
 142 u_int16_t
 143 get_e(struct ep_softc *sc, int offset)
 144 {
 145     if (!eeprom_rdy(sc))
 146         return (0);
 147     outw(BASE + EP_W0_EEPROM_COMMAND, (EEPROM_CMD_RD << sc->epb.cmd_off) | offset);
 148     if (!eeprom_rdy(sc))
 149         return (0);
 150     return (inw(BASE + EP_W0_EEPROM_DATA));
 151 }
 152
 153 void
 154 ep_get_macaddr(struct ep_softc *sc, uint8_t *addr)
 155 {
 156         int                     i;
 157         u_int16_t *             macaddr = (u_int16_t *)addr;
 158
 159         GO_WINDOW(0);
 160         for(i = EEPROM_NODE_ADDR_0; i <= EEPROM_NODE_ADDR_2; i++) {
 161                 macaddr[i] = htons(get_e(sc, i));
 162         }
 163
 164         return;
 165 }
 166
 167 int
 168 ep_alloc(device_t dev)
 169 {
 170         struct ep_softc *       sc = device_get_softc(dev);
 171         int                     rid;
 172         int                     error = 0;
 173
 174         rid = 0;
 175         sc->iobase = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid,
 176             RF_ACTIVE);
 177         if (!sc->iobase) {
 178                 device_printf(dev, "No I/O space?!\n");
 179                 error = ENXIO;
 180                 goto bad;
 181         }
 182
 183         rid = 0;
 184         sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE);
 185         if (!sc->irq) {
 186                 device_printf(dev, "No irq?!\n");
 187                 error = ENXIO;
 188                 goto bad;
 189         }
 190
 191         if_initname(&sc->arpcom.ac_if,
 192                     device_get_name(dev), device_get_unit(dev));
 193         sc->stat = 0;   /* 16 bit access */
 194
 195         sc->ep_io_addr = rman_get_start(sc->iobase);
 196
 197         sc->ep_btag = rman_get_bustag(sc->iobase);
 198         sc->ep_bhandle = rman_get_bushandle(sc->iobase);
 199
 200         sc->ep_connectors = 0;
 201         sc->ep_connector = 0;
 202
 203         GO_WINDOW(0);
 204         sc->epb.cmd_off = 0;
 205         sc->epb.prod_id = get_e(sc, EEPROM_PROD_ID);
 206         sc->epb.res_cfg = get_e(sc, EEPROM_RESOURCE_CFG);
 207
 208 bad:
 209         return (error);
 210 }
 211
 212 void
 213 ep_get_media(struct ep_softc *sc)
 214 {
 215         u_int16_t               config;
 216
 217         GO_WINDOW(0);
 218         config = inw(BASE + EP_W0_CONFIG_CTRL);
 219         if (config & IS_AUI)
 220                 sc->ep_connectors |= AUI;
 221         if (config & IS_BNC)
 222                 sc->ep_connectors |= BNC;
 223         if (config & IS_UTP)
 224                 sc->ep_connectors |= UTP;
 225
 226         if (!(sc->ep_connectors & 7)) {
 227                 if (bootverbose)
 228                         if_printf(&sc->arpcom.ac_if, "no connectors!\n");
 229         }
 230
 231         /*
 232          * This works for most of the cards so we'll do it here.
 233          * The cards that require something different can override
 234          * this later on.
 235          */
 236         sc->ep_connector = inw(BASE + EP_W0_ADDRESS_CFG) >> ACF_CONNECTOR_BITS;
 237
 238         return;
 239 }
 240
 241 void
 242 ep_free(device_t dev)
 243 {
 244         struct ep_softc *       sc = device_get_softc(dev);
 245
 246         if (sc->iobase)
 247                 bus_release_resource(dev, SYS_RES_IOPORT, 0, sc->iobase);
 248         if (sc->irq)
 249                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
 250
 251         return;
 252 }
 253
 254 int
 255 ep_attach(struct ep_softc *sc)
 256 {
 257         struct ifnet *          ifp = NULL;
 258         struct ifmedia *        ifm = NULL;
 259         u_short *               p;
 260         uint8_t                 ether_addr[ETHER_ADDR_LEN];
 261         int                     i;
 262
 263         sc->gone = 0;
 264
 265         ep_get_macaddr(sc, ether_addr);
 266
 267         /*
 268          * Setup the station address
 269          */
 270         p = (u_short*)ether_addr;
 271         GO_WINDOW(2);
 272         for (i = 0; i < 3; i++) {
 273                 outw(BASE + EP_W2_ADDR_0 + (i * 2), ntohs(p[i]));
 274         }
 275
 276         ifp = &sc->arpcom.ac_if;
 277
 278         ifp->if_softc = sc;
 279         ifp->if_mtu = ETHERMTU;
 280         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 281         ifp->if_start = ep_if_start;
 282         ifp->if_ioctl = ep_if_ioctl;
 283         ifp->if_watchdog = ep_if_watchdog;
 284         ifp->if_init = ep_if_init;
 285         ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
 286         ifq_set_ready(&ifp->if_snd);
 287
 288         if (!sc->epb.mii_trans) {
 289                 ifmedia_init(&sc->ifmedia, 0, ep_ifmedia_upd, ep_ifmedia_sts);
 290
 291                 if (sc->ep_connectors & AUI)
 292                         ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_5, 0, NULL);
 293                 if (sc->ep_connectors & UTP)
 294                         ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_T, 0, NULL);
 295                 if (sc->ep_connectors & BNC)
 296                         ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_2, 0, NULL);
 297                 if (!sc->ep_connectors)
 298                         ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_NONE, 0, NULL);
 299
 300                 ifmedia_set(&sc->ifmedia, IFM_ETHER|ep_media2if_media[sc->ep_connector]);
 301
 302                 ifm = &sc->ifmedia;
 303                 ifm->ifm_media = ifm->ifm_cur->ifm_media;
 304                 ep_ifmedia_upd(ifp);
 305         }
 306
 307         ether_ifattach(ifp, ether_addr, NULL);
 308
 309 #ifdef EP_LOCAL_STATS
 310         sc->rx_no_first = sc->rx_no_mbuf = sc->rx_bpf_disc =
 311                 sc->rx_overrunf = sc->rx_overrunl = sc->tx_underrun = 0;
 312 #endif
 313         EP_FSET(sc, F_RX_FIRST);
 314         sc->top = sc->mcur = 0;
 315
 316         return 0;
 317 }
 318
 319 /*
 320  * The order in here seems important. Otherwise we may not receive
 321  * interrupts. ?!
 322  */
 323 static void
 324 ep_if_init(void *xsc)
 325 {
 326     struct ep_softc *sc = xsc;
 327     struct ifnet *ifp = &sc->arpcom.ac_if;
 328     int i;
 329
 330     if (sc->gone)
 331         return;
 332
 333     crit_enter();
 334
 335     while (inw(BASE + EP_STATUS) & S_COMMAND_IN_PROGRESS);
 336
 337     GO_WINDOW(0);
 338     outw(BASE + EP_COMMAND, STOP_TRANSCEIVER);
 339     GO_WINDOW(4);
 340     outw(BASE + EP_W4_MEDIA_TYPE, DISABLE_UTP);
 341     GO_WINDOW(0);
 342
 343     /* Disable the card */
 344     outw(BASE + EP_W0_CONFIG_CTRL, 0);
 345
 346     /* Enable the card */
 347     outw(BASE + EP_W0_CONFIG_CTRL, ENABLE_DRQ_IRQ);
 348
 349     GO_WINDOW(2);
 350
 351     /* Reload the ether_addr. */
 352     for (i = 0; i < 6; i++)
 353         outb(BASE + EP_W2_ADDR_0 + i, sc->arpcom.ac_enaddr[i]);
 354
 355     outw(BASE + EP_COMMAND, RX_RESET);
 356     outw(BASE + EP_COMMAND, TX_RESET);
 357     while (inw(BASE + EP_STATUS) & S_COMMAND_IN_PROGRESS);
 358
 359     /* Window 1 is operating window */
 360     GO_WINDOW(1);
 361     for (i = 0; i < 31; i++)
 362         inb(BASE + EP_W1_TX_STATUS);
 363
 364     /* get rid of stray intr's */
 365     outw(BASE + EP_COMMAND, ACK_INTR | 0xff);
 366
 367     outw(BASE + EP_COMMAND, SET_RD_0_MASK | S_5_INTS);
 368
 369     outw(BASE + EP_COMMAND, SET_INTR_MASK | S_5_INTS);
 370
 371     if (ifp->if_flags & IFF_PROMISC)
 372         outw(BASE + EP_COMMAND, SET_RX_FILTER | FIL_INDIVIDUAL |
 373          FIL_GROUP | FIL_BRDCST | FIL_ALL);
 374     else
 375         outw(BASE + EP_COMMAND, SET_RX_FILTER | FIL_INDIVIDUAL |
 376          FIL_GROUP | FIL_BRDCST);
 377
 378     if (!sc->epb.mii_trans) {
 379         ep_ifmedia_upd(ifp);
 380     }
 381
 382     outw(BASE + EP_COMMAND, RX_ENABLE);
 383     outw(BASE + EP_COMMAND, TX_ENABLE);
 384
 385     ifp->if_flags |= IFF_RUNNING;
 386     ifq_clr_oactive(&ifp->if_snd);      /* just in case */
 387
 388 #ifdef EP_LOCAL_STATS
 389     sc->rx_no_first = sc->rx_no_mbuf =
 390         sc->rx_overrunf = sc->rx_overrunl = sc->tx_underrun = 0;
 391 #endif
 392     EP_FSET(sc, F_RX_FIRST);
 393     if (sc->top) {
 394         m_freem(sc->top);
 395         sc->top = sc->mcur = 0;
 396     }
 397     outw(BASE + EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH);
 398     outw(BASE + EP_COMMAND, SET_TX_START_THRESH | 16);
 399
 400     /*
 401      * Store up a bunch of mbuf's for use later. (MAX_MBS). First we free up
 402      * any that we had in case we're being called from intr or somewhere
 403      * else.
 404      */
 405
 406     GO_WINDOW(1);
 407
 408     if_devstart(ifp);
 409
 410     crit_exit();
 411 }
 412
 413 static const char padmap[] = {0, 3, 2, 1};
 414
 415 static void
 416 ep_if_start(struct ifnet *ifp)
 417 {
 418     struct ep_softc *sc = ifp->if_softc;
 419     u_int len;
 420     struct mbuf *m;
 421     struct mbuf *top;
 422     int pad;
 423
 424     if (sc->gone) {
 425         ifq_purge(&ifp->if_snd);
 426         return;
 427     }
 428
 429     while (inw(BASE + EP_STATUS) & S_COMMAND_IN_PROGRESS);
 430     if (ifq_is_oactive(&ifp->if_snd)) {
 431         return;
 432     }
 433
 434     crit_enter();
 435
 436 startagain:
 437     /* Sneak a peek at the next packet */
 438     m = ifq_dequeue(&ifp->if_snd, NULL);
 439     if (m == NULL) {
 440         crit_exit();
 441         return;
 442     }
 443
 444     for (len = 0, top = m; m; m = m->m_next)
 445         len += m->m_len;
 446     m = top;
 447
 448     pad = padmap[len & 3];
 449
 450     /*
 451      * The 3c509 automatically pads short packets to minimum ethernet length,
 452      * but we drop packets that are too large. Perhaps we should truncate
 453      * them instead?
 454      */
 455     if (len + pad > ETHER_MAX_LEN) {
 456         /* packet is obviously too large: toss it */
 457         ++ifp->if_oerrors;
 458         m_freem(m);
 459         goto readcheck;
 460     }
 461     if (inw(BASE + EP_W1_FREE_TX) < len + pad + 4) {
 462         /* no room in FIFO */
 463         outw(BASE + EP_COMMAND, SET_TX_AVAIL_THRESH | (len + pad + 4));
 464         /* make sure */
 465         if (inw(BASE + EP_W1_FREE_TX) < len + pad + 4) {
 466             ifq_set_oactive(&ifp->if_snd);
 467             ifq_prepend(&ifp->if_snd, top);
 468             crit_exit();
 469             return;
 470         }
 471     } else {
 472         outw(BASE + EP_COMMAND, SET_TX_AVAIL_THRESH | EP_THRESH_DISABLE);
 473     }
 474
 475     outw(BASE + EP_W1_TX_PIO_WR_1, len);
 476     outw(BASE + EP_W1_TX_PIO_WR_1, 0x0);        /* Second dword meaningless */
 477
 478     if (EP_FTST(sc, F_ACCESS_32_BITS)) {
 479         for (top = m; m != NULL; m = m->m_next) {
 480             outsl(BASE + EP_W1_TX_PIO_WR_1, mtod(m, caddr_t),
 481                   m->m_len / 4);
 482             if (m->m_len & 3)
 483                 outsb(BASE + EP_W1_TX_PIO_WR_1,
 484                       mtod(m, caddr_t) + (m->m_len & (~3)),
 485                       m->m_len & 3);
 486         }
 487     } else {
 488         for (top = m; m != NULL; m = m->m_next) {
 489             outsw(BASE + EP_W1_TX_PIO_WR_1, mtod(m, caddr_t), m->m_len / 2);
 490             if (m->m_len & 1)
 491                 outb(BASE + EP_W1_TX_PIO_WR_1,
 492                      *(mtod(m, caddr_t) + m->m_len - 1));
 493         }
 494     }
 495
 496     while (pad--)
 497         outb(BASE + EP_W1_TX_PIO_WR_1, 0);      /* Padding */
 498
 499     BPF_MTAP(ifp, top);
 500
 501     ifp->if_timer = 2;
 502     ifp->if_opackets++;
 503     m_freem(top);
 504
 505     /*
 506      * Is another packet coming in? We don't want to overflow the tiny RX
 507      * fifo.
 508      */
 509 readcheck:
 510     if (inw(BASE + EP_W1_RX_STATUS) & RX_BYTES_MASK) {
 511         /*
 512          * we check if we have packets left, in that case we prepare to come
 513          * back later
 514          */
 515         if (!ifq_is_empty(&ifp->if_snd))
 516             outw(BASE + EP_COMMAND, SET_TX_AVAIL_THRESH | 8);
 517
 518         crit_exit();
 519         return;
 520     }
 521     goto startagain;
 522 }
 523
 524 void
 525 ep_intr(void *arg)
 526 {
 527     struct ep_softc *sc = arg;
 528     struct ifnet *ifp = &sc->arpcom.ac_if;
 529     int status;
 530
 531      /*
 532       * quick fix: Try to detect an interrupt when the card goes away.
 533       */
 534     if (sc->gone || inw(BASE + EP_STATUS) == 0xffff) {
 535             return;
 536     }
 537
 538     outw(BASE + EP_COMMAND, SET_INTR_MASK); /* disable all Ints */
 539
 540 rescan:
 541
 542     while ((status = inw(BASE + EP_STATUS)) & S_5_INTS) {
 543
 544         /* first acknowledge all interrupt sources */
 545         outw(BASE + EP_COMMAND, ACK_INTR | (status & S_MASK));
 546
 547         if (status & (S_RX_COMPLETE | S_RX_EARLY))
 548             epread(sc);
 549         if (status & S_TX_AVAIL) {
 550             /* we need ACK */
 551             ifp->if_timer = 0;
 552             ifq_clr_oactive(&ifp->if_snd);
 553             GO_WINDOW(1);
 554             inw(BASE + EP_W1_FREE_TX);
 555             if_devstart(ifp);
 556         }
 557         if (status & S_CARD_FAILURE) {
 558             ifp->if_timer = 0;
 559 #ifdef EP_LOCAL_STATS
 560             kprintf("\n");
 561             if_printf(ifp, "\n\tStatus: %x\n", status);
 562             GO_WINDOW(4);
 563             kprintf("\tFIFO Diagnostic: %x\n", inw(BASE + EP_W4_FIFO_DIAG));
 564             kprintf("\tStat: %x\n", sc->stat);
 565             kprintf("\tIpackets=%d, Opackets=%d\n",
 566                 ifp->if_ipackets, ifp->if_opackets);
 567             kprintf("\tNOF=%d, NOMB=%d, RXOF=%d, RXOL=%d, TXU=%d\n",
 568                    sc->rx_no_first, sc->rx_no_mbuf, sc->rx_overrunf,
 569                    sc->rx_overrunl, sc->tx_underrun);
 570 #else
 571
 572 #ifdef DIAGNOSTIC
 573             if_printf(ifp, "Status: %x (input buffer overflow)\n", status);
 574 #else
 575             ++ifp->if_ierrors;
 576 #endif
 577
 578 #endif
 579             ep_if_init(sc);
 580             return;
 581         }
 582         if (status & S_TX_COMPLETE) {
 583             ifp->if_timer = 0;
 584             /* we  need ACK. we do it at the end */
 585             /*
 586              * We need to read TX_STATUS until we get a 0 status in order to
 587              * turn off the interrupt flag.
 588              */
 589             while ((status = inb(BASE + EP_W1_TX_STATUS)) & TXS_COMPLETE) {
 590                 if (status & TXS_SUCCES_INTR_REQ);
 591                 else if (status & (TXS_UNDERRUN | TXS_JABBER | TXS_MAX_COLLISION)) {
 592                     outw(BASE + EP_COMMAND, TX_RESET);
 593                     if (status & TXS_UNDERRUN) {
 594 #ifdef EP_LOCAL_STATS
 595                         sc->tx_underrun++;
 596 #endif
 597                     } else {
 598                         if (status & TXS_JABBER);
 599                         else    /* TXS_MAX_COLLISION - we shouldn't get here */
 600                             ++ifp->if_collisions;
 601                     }
 602                     ++ifp->if_oerrors;
 603                     outw(BASE + EP_COMMAND, TX_ENABLE);
 604                     /*
 605                      * To have a tx_avail_int but giving the chance to the
 606                      * Reception
 607                      */
 608                     if (!ifq_is_empty(&ifp->if_snd))
 609                         outw(BASE + EP_COMMAND, SET_TX_AVAIL_THRESH | 8);
 610                 }
 611                 outb(BASE + EP_W1_TX_STATUS, 0x0);      /* pops up the next
 612                                                          * status */
 613             }                   /* while */
 614             ifq_clr_oactive(&ifp->if_snd);
 615             GO_WINDOW(1);
 616             inw(BASE + EP_W1_FREE_TX);
 617             if_devstart(ifp);
 618         }                       /* end TX_COMPLETE */
 619     }
 620
 621     outw(BASE + EP_COMMAND, C_INTR_LATCH);      /* ACK int Latch */
 622
 623     if ((status = inw(BASE + EP_STATUS)) & S_5_INTS)
 624         goto rescan;
 625
 626     /* re-enable Ints */
 627     outw(BASE + EP_COMMAND, SET_INTR_MASK | S_5_INTS);
 628 }
 629
 630 static void
 631 epread(struct ep_softc *sc)
 632 {
 633     struct mbuf *top, *mcur, *m;
 634     struct ifnet *ifp;
 635     int lenthisone;
 636
 637     short rx_fifo2, status;
 638     short rx_fifo;
 639
 640     ifp = &sc->arpcom.ac_if;
 641     status = inw(BASE + EP_W1_RX_STATUS);
 642
 643 read_again:
 644
 645     if (status & ERR_RX) {
 646         ++ifp->if_ierrors;
 647         if (status & ERR_RX_OVERRUN) {
 648             /*
 649              * we can think the rx latency is actually greather than we
 650              * expect
 651              */
 652 #ifdef EP_LOCAL_STATS
 653             if (EP_FTST(sc, F_RX_FIRST))
 654                 sc->rx_overrunf++;
 655             else
 656                 sc->rx_overrunl++;
 657 #endif
 658         }
 659         goto out;
 660     }
 661     rx_fifo = rx_fifo2 = status & RX_BYTES_MASK;
 662
 663     if (EP_FTST(sc, F_RX_FIRST)) {
 664         m = m_getl(rx_fifo, MB_DONTWAIT, MT_DATA, M_PKTHDR, NULL);
 665         if (!m)
 666             goto out;
 667         sc->top = sc->mcur = top = m;
 668 #define EROUND  ((sizeof(struct ether_header) + 3) & ~3)
 669 #define EOFF    (EROUND - sizeof(struct ether_header))
 670         top->m_data += EOFF;
 671
 672         /* Read what should be the header. */
 673         insw(BASE + EP_W1_RX_PIO_RD_1,
 674              mtod(top, caddr_t), sizeof(struct ether_header) / 2);
 675         top->m_len = sizeof(struct ether_header);
 676         rx_fifo -= sizeof(struct ether_header);
 677         sc->cur_len = rx_fifo2;
 678     } else {
 679         /* come here if we didn't have a complete packet last time */
 680         top = sc->top;
 681         m = sc->mcur;
 682         sc->cur_len += rx_fifo2;
 683     }
 684
 685     /* Reads what is left in the RX FIFO */
 686     while (rx_fifo > 0) {
 687         lenthisone = min(rx_fifo, M_TRAILINGSPACE(m));
 688         if (lenthisone == 0) {  /* no room in this one */
 689             mcur = m;
 690             m = m_getl(rx_fifo, MB_DONTWAIT, MT_DATA, 0, NULL);
 691             if (!m)
 692                 goto out;
 693             m->m_len = 0;
 694             mcur->m_next = m;
 695             lenthisone = min(rx_fifo, M_TRAILINGSPACE(m));
 696         }
 697         if (EP_FTST(sc, F_ACCESS_32_BITS)) { /* default for EISA configured cards*/
 698             insl(BASE + EP_W1_RX_PIO_RD_1, mtod(m, caddr_t) + m->m_len,
 699                  lenthisone / 4);
 700             m->m_len += (lenthisone & ~3);
 701             if (lenthisone & 3)
 702                 insb(BASE + EP_W1_RX_PIO_RD_1,
 703                      mtod(m, caddr_t) + m->m_len,
 704                      lenthisone & 3);
 705             m->m_len += (lenthisone & 3);
 706         } else {
 707             insw(BASE + EP_W1_RX_PIO_RD_1, mtod(m, caddr_t) + m->m_len,
 708                  lenthisone / 2);
 709             m->m_len += lenthisone;
 710             if (lenthisone & 1)
 711                 *(mtod(m, caddr_t) + m->m_len - 1) = inb(BASE + EP_W1_RX_PIO_RD_1);
 712         }
 713         rx_fifo -= lenthisone;
 714     }
 715
 716     if (status & ERR_RX_INCOMPLETE) {   /* we haven't received the complete
 717                                          * packet */
 718         sc->mcur = m;
 719 #ifdef EP_LOCAL_STATS
 720         sc->rx_no_first++;      /* to know how often we come here */
 721 #endif
 722         EP_FRST(sc, F_RX_FIRST);
 723         if (!((status = inw(BASE + EP_W1_RX_STATUS)) & ERR_RX_INCOMPLETE)) {
 724             /* we see if by now, the packet has completly arrived */
 725             goto read_again;
 726         }
 727         outw(BASE + EP_COMMAND, SET_RX_EARLY_THRESH | RX_NEXT_EARLY_THRESH);
 728         return;
 729     }
 730     outw(BASE + EP_COMMAND, RX_DISCARD_TOP_PACK);
 731     ++ifp->if_ipackets;
 732     EP_FSET(sc, F_RX_FIRST);
 733     top->m_pkthdr.rcvif = &sc->arpcom.ac_if;
 734     top->m_pkthdr.len = sc->cur_len;
 735
 736     ifp->if_input(ifp, top);
 737     sc->top = 0;
 738     while (inw(BASE + EP_STATUS) & S_COMMAND_IN_PROGRESS);
 739     outw(BASE + EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH);
 740     return;
 741
 742 out:
 743     outw(BASE + EP_COMMAND, RX_DISCARD_TOP_PACK);
 744     if (sc->top) {
 745         m_freem(sc->top);
 746         sc->top = 0;
 747 #ifdef EP_LOCAL_STATS
 748         sc->rx_no_mbuf++;
 749 #endif
 750     }
 751     EP_FSET(sc, F_RX_FIRST);
 752     while (inw(BASE + EP_STATUS) & S_COMMAND_IN_PROGRESS);
 753     outw(BASE + EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH);
 754 }
 755
 756 static int
 757 ep_ifmedia_upd(struct ifnet *ifp)
 758 {
 759         struct ep_softc *       sc = ifp->if_softc;
 760         int                     i = 0, j;
 761
 762         GO_WINDOW(0);
 763         outw(BASE + EP_COMMAND, STOP_TRANSCEIVER);
 764         GO_WINDOW(4);
 765         outw(BASE + EP_W4_MEDIA_TYPE, DISABLE_UTP);
 766         GO_WINDOW(0);
 767
 768         switch (IFM_SUBTYPE(sc->ifmedia.ifm_media)) {
 769                 case IFM_10_T:
 770                         if (sc->ep_connectors & UTP) {
 771                                 i = ACF_CONNECTOR_UTP;
 772                                 GO_WINDOW(4);
 773                                 outw(BASE + EP_W4_MEDIA_TYPE, ENABLE_UTP);
 774                         }
 775                         break;
 776                 case IFM_10_2:
 777                         if (sc->ep_connectors & BNC) {
 778                                 i = ACF_CONNECTOR_BNC;
 779                                 outw(BASE + EP_COMMAND, START_TRANSCEIVER);
 780                                 DELAY(DELAY_MULTIPLE * 1000);
 781                         }
 782                         break;
 783                 case IFM_10_5:
 784                         if (sc->ep_connectors & AUI)
 785                                 i = ACF_CONNECTOR_AUI;
 786                         break;
 787                 default:
 788                         i = sc->ep_connector;
 789                         if_printf(ifp, "strange connector type in EEPROM: "
 790                                   "assuming AUI\n");
 791                         break;
 792         }
 793
 794         GO_WINDOW(0);
 795         j = inw(BASE + EP_W0_ADDRESS_CFG) & 0x3fff;
 796         outw(BASE + EP_W0_ADDRESS_CFG, j | (i << ACF_CONNECTOR_BITS));
 797
 798         return (0);
 799 }
 800
 801 static void
 802 ep_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 803 {
 804         struct ep_softc *       sc = ifp->if_softc;
 805
 806         ifmr->ifm_active = sc->ifmedia.ifm_media;
 807
 808         return;
 809 }
 810
 811 static int
 812 ep_if_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
 813 {
 814         struct ep_softc *       sc = ifp->if_softc;
 815         struct ifreq *          ifr = (struct ifreq *)data;
 816         int error = 0;
 817
 818         crit_enter();
 819
 820         switch (cmd) {
 821         case SIOCSIFFLAGS:
 822                 if (((ifp->if_flags & IFF_UP) == 0) &&
 823                     (ifp->if_flags & IFF_RUNNING)) {
 824                         ifp->if_flags &= ~IFF_RUNNING;
 825                         epstop(sc);
 826                 } else {
 827                         /* reinitialize card on any parameter change */
 828                         ep_if_init(sc);
 829                 }
 830                 break;
 831 #ifdef notdef
 832         case SIOCGHWADDR:
 833                 bcopy((caddr_t) sc->sc_addr, (caddr_t) & ifr->ifr_data,
 834                       sizeof(sc->sc_addr));
 835                 break;
 836 #endif
 837         case SIOCADDMULTI:
 838         case SIOCDELMULTI:
 839                 /*
 840                  * The Etherlink III has no programmable multicast
 841                  * filter.  We always initialize the card to be
 842                  * promiscuous to multicast, since we're always a
 843                  * member of the ALL-SYSTEMS group, so there's no
 844                  * need to process SIOC*MULTI requests.
 845                  */
 846                 error = 0;
 847                 break;
 848         case SIOCSIFMEDIA:
 849         case SIOCGIFMEDIA:
 850                 if (!sc->epb.mii_trans) {
 851                         error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, cmd);
 852                 } else {
 853                         error = EINVAL;
 854                 }
 855                 break;
 856         default:
 857                 error = ether_ioctl(ifp, cmd, data);
 858                 break;
 859         }
 860
 861         crit_exit();
 862
 863         return (error);
 864 }
 865
 866 static void
 867 ep_if_watchdog(struct ifnet *ifp)
 868 {
 869     struct ep_softc *sc = ifp->if_softc;
 870
 871     /*
 872     if_printf(ifp, "watchdog\n");
 873
 874     log(LOG_ERR, "%s: watchdog\n", ifp->if_xname);
 875     ifp->if_oerrors++;
 876     */
 877
 878     if (sc->gone) {
 879         return;
 880     }
 881
 882     ifq_clr_oactive(&ifp->if_snd);
 883     if_devstart(ifp);
 884     ep_intr(ifp->if_softc);
 885 }
 886
 887 static void
 888 epstop(struct ep_softc *sc)
 889 {
 890     if (sc->gone) {
 891         return;
 892     }
 893
 894     outw(BASE + EP_COMMAND, RX_DISABLE);
 895     outw(BASE + EP_COMMAND, RX_DISCARD_TOP_PACK);
 896     while (inw(BASE + EP_STATUS) & S_COMMAND_IN_PROGRESS);
 897     outw(BASE + EP_COMMAND, TX_DISABLE);
 898     outw(BASE + EP_COMMAND, STOP_TRANSCEIVER);
 899     outw(BASE + EP_COMMAND, RX_RESET);
 900     outw(BASE + EP_COMMAND, TX_RESET);
 901     while (inw(BASE + EP_STATUS) & S_COMMAND_IN_PROGRESS);
 902     outw(BASE + EP_COMMAND, C_INTR_LATCH);
 903     outw(BASE + EP_COMMAND, SET_RD_0_MASK);
 904     outw(BASE + EP_COMMAND, SET_INTR_MASK);
 905     outw(BASE + EP_COMMAND, SET_RX_FILTER);
 906 }