The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/xe/if_xe.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1998, 1999, 2003  Scott Mitchell
    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  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  */
   26 /*-
   27  * Portions of this software were derived from Werner Koch's xirc2ps driver
   28  * for Linux under the terms of the following license (from v1.30 of the
   29  * xirc2ps driver):
   30  *
   31  * Copyright (c) 1997 by Werner Koch (dd9jn)
   32  *
   33  * Redistribution and use in source and binary forms, with or without
   34  * modification, are permitted provided that the following conditions
   35  * are met:
   36  * 1. Redistributions of source code must retain the above copyright
   37  *    notice, and the entire permission notice in its entirety,
   38  *    including the disclaimer of warranties.
   39  * 2. Redistributions in binary form must reproduce the above copyright
   40  *    notice, this list of conditions and the following disclaimer in the
   41  *    documentation and/or other materials provided with the distribution.
   42  * 3. The name of the author may not be used to endorse or promote
   43  *    products derived from this software without specific prior
   44  *    written permission.
   45  *
   46  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
   47  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   48  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   49  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   50  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   51  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   52  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   53  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   54  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   55  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   56  * OF THE POSSIBILITY OF SUCH DAMAGE.
   57  */
   58 
   59 #include <sys/cdefs.h>
   60 __FBSDID("$FreeBSD: releng/11.0/sys/dev/xe/if_xe.c 297000 2016-03-18 01:28:41Z jhibbits $");
   61 
   62 /*              
   63  * FreeBSD device driver for Xircom CreditCard PCMCIA Ethernet adapters.  The
   64  * following cards are currently known to work with the driver:
   65  *   Xircom CreditCard 10/100 (CE3)
   66  *   Xircom CreditCard Ethernet + Modem 28 (CEM28)
   67  *   Xircom CreditCard Ethernet 10/100 + Modem 56 (CEM56)
   68  *   Xircom RealPort Ethernet 10
   69  *   Xircom RealPort Ethernet 10/100
   70  *   Xircom RealPort Ethernet 10/100 + Modem 56 (REM56, REM56G)
   71  *   Intel EtherExpress Pro/100 PC Card Mobile Adapter 16 (Pro/100 M16A)
   72  *   Compaq Netelligent 10/100 PC Card (CPQ-10/100)
   73  *
   74  * Some other cards *should* work, but support for them is either broken or in 
   75  * an unknown state at the moment.  I'm always interested in hearing from
   76  * people who own any of these cards:
   77  *   Xircom CreditCard 10Base-T (PS-CE2-10)
   78  *   Xircom CreditCard Ethernet + ModemII (CEM2)
   79  *   Xircom CEM28 and CEM33 Ethernet/Modem cards (may be variants of CEM2?)
   80  *
   81  * Thanks to all who assisted with the development and testing of the driver,
   82  * especially: Werner Koch, Duke Kamstra, Duncan Barclay, Jason George, Dru
   83  * Nelson, Mike Kephart, Bill Rainey and Douglas Rand.  Apologies if I've left
   84  * out anyone who deserves a mention here.
   85  *
   86  * Special thanks to Ade Lovett for both hosting the mailing list and doing
   87  * the CEM56/REM56 support code; and the FreeBSD UK Users' Group for hosting
   88  * the web pages.
   89  *
   90  * Author email: <scott@uk.freebsd.org>
   91  * Driver web page: http://ukug.uk.freebsd.org/~scott/xe_drv/
   92  */
   93 
   94 
   95 #include <sys/param.h>
   96 #include <sys/cdefs.h>
   97 #include <sys/errno.h>
   98 #include <sys/kernel.h>
   99 #include <sys/malloc.h>
  100 #include <sys/mbuf.h>
  101 #include <sys/socket.h>
  102 #include <sys/sockio.h>
  103 #include <sys/systm.h>
  104 #include <sys/uio.h>
  105 #include <sys/sysctl.h>
  106 
  107 #include <sys/module.h>
  108 #include <sys/bus.h>
  109 
  110 #include <machine/bus.h>
  111 #include <machine/resource.h>
  112 #include <sys/rman.h>
  113  
  114 #include <net/ethernet.h>
  115 #include <net/if.h>
  116 #include <net/if_var.h>
  117 #include <net/if_arp.h>
  118 #include <net/if_dl.h>
  119 #include <net/if_media.h>
  120 #include <net/if_mib.h>
  121 #include <net/bpf.h>
  122 #include <net/if_types.h>
  123 
  124 #include <dev/xe/if_xereg.h>
  125 #include <dev/xe/if_xevar.h>
  126 
  127 /*
  128  * MII command structure
  129  */
  130 struct xe_mii_frame {
  131         uint8_t         mii_stdelim;
  132         uint8_t         mii_opcode;
  133         uint8_t         mii_phyaddr;
  134         uint8_t         mii_regaddr;
  135         uint8_t         mii_turnaround;
  136         uint16_t        mii_data;
  137 };
  138 
  139 /*
  140  * Media autonegotiation progress constants
  141  */
  142 #define XE_AUTONEG_NONE         0       /* No autonegotiation in progress */
  143 #define XE_AUTONEG_WAITING      1       /* Waiting for transmitter to go idle */
  144 #define XE_AUTONEG_STARTED      2       /* Waiting for autonegotiation to complete */
  145 #define XE_AUTONEG_100TX        3       /* Trying to force 100baseTX link */
  146 #define XE_AUTONEG_FAIL         4       /* Autonegotiation failed */
  147 
  148 /*
  149  * Prototypes start here
  150  */
  151 static void     xe_init(void *xscp);
  152 static void     xe_init_locked(struct xe_softc *scp);
  153 static void     xe_start(struct ifnet *ifp);
  154 static void     xe_start_locked(struct ifnet *ifp);
  155 static int      xe_ioctl(struct ifnet *ifp, u_long command, caddr_t data);
  156 static void     xe_watchdog(void *arg);
  157 static void     xe_intr(void *xscp);
  158 static void     xe_txintr(struct xe_softc *scp, uint8_t txst1);
  159 static void     xe_macintr(struct xe_softc *scp, uint8_t rst0, uint8_t txst0,
  160                     uint8_t txst1);
  161 static void     xe_rxintr(struct xe_softc *scp, uint8_t rst0);
  162 static int      xe_media_change(struct ifnet *ifp);
  163 static void     xe_media_status(struct ifnet *ifp, struct ifmediareq *mrp);
  164 static void     xe_setmedia(void *arg);
  165 static void     xe_reset(struct xe_softc *scp);
  166 static void     xe_enable_intr(struct xe_softc *scp);
  167 static void     xe_disable_intr(struct xe_softc *scp);
  168 static void     xe_set_multicast(struct xe_softc *scp);
  169 static void     xe_set_addr(struct xe_softc *scp, uint8_t* addr, unsigned idx);
  170 static void     xe_mchash(struct xe_softc *scp, const uint8_t *addr);
  171 static int      xe_pio_write_packet(struct xe_softc *scp, struct mbuf *mbp);
  172 
  173 /*
  174  * MII functions
  175  */
  176 static void     xe_mii_sync(struct xe_softc *scp);
  177 static int      xe_mii_init(struct xe_softc *scp);
  178 static void     xe_mii_send(struct xe_softc *scp, uint32_t bits, int cnt);
  179 static int      xe_mii_readreg(struct xe_softc *scp,
  180                     struct xe_mii_frame *frame);
  181 static int      xe_mii_writereg(struct xe_softc *scp,
  182                     struct xe_mii_frame *frame);
  183 static uint16_t xe_phy_readreg(struct xe_softc *scp, uint16_t reg);
  184 static void     xe_phy_writereg(struct xe_softc *scp, uint16_t reg,
  185                     uint16_t data);
  186 
  187 /*
  188  * Debugging functions
  189  */
  190 static void     xe_mii_dump(struct xe_softc *scp);
  191 #if 0
  192 static void     xe_reg_dump(struct xe_softc *scp);
  193 #endif
  194 
  195 /*
  196  * Debug logging levels - set with hw.xe.debug sysctl
  197  * 0 = None
  198  * 1 = More hardware details, probe/attach progress
  199  * 2 = Most function calls, ioctls and media selection progress
  200  * 3 = Everything - interrupts, packets in/out and multicast address setup
  201  */
  202 #define XE_DEBUG
  203 #ifdef XE_DEBUG
  204 
  205 /* sysctl vars */
  206 static SYSCTL_NODE(_hw, OID_AUTO, xe, CTLFLAG_RD, 0, "if_xe parameters");
  207 
  208 int xe_debug = 0;
  209 SYSCTL_INT(_hw_xe, OID_AUTO, debug, CTLFLAG_RW, &xe_debug, 0,
  210     "if_xe debug level");
  211 
  212 #define DEVPRINTF(level, arg)   if (xe_debug >= (level)) device_printf arg
  213 #define DPRINTF(level, arg)     if (xe_debug >= (level)) printf arg
  214 #define XE_MII_DUMP(scp)        if (xe_debug >= 3) xe_mii_dump(scp)
  215 #if 0
  216 #define XE_REG_DUMP(scp)        if (xe_debug >= 3) xe_reg_dump(scp)
  217 #endif
  218 #else
  219 #define DEVPRINTF(level, arg)
  220 #define DPRINTF(level, arg)
  221 #define XE_MII_DUMP(scp)
  222 #if 0
  223 #define XE_REG_DUMP(scp)
  224 #endif
  225 #endif
  226 
  227 /*
  228  * Attach a device.
  229  */
  230 int
  231 xe_attach(device_t dev)
  232 {
  233         struct xe_softc *scp = device_get_softc(dev);
  234         int err;
  235 
  236         DEVPRINTF(2, (dev, "attach\n"));
  237 
  238         /* Initialise stuff... */
  239         scp->dev = dev;
  240         scp->ifp = if_alloc(IFT_ETHER);
  241         if (scp->ifp == NULL)
  242                 return (ENOSPC);
  243         scp->ifm = &scp->ifmedia;
  244         scp->autoneg_status = XE_AUTONEG_NONE;
  245         mtx_init(&scp->lock, device_get_nameunit(dev), MTX_NETWORK_LOCK,
  246             MTX_DEF);
  247         callout_init_mtx(&scp->wdog_timer, &scp->lock, 0);
  248 
  249         /* Initialise the ifnet structure */
  250         scp->ifp->if_softc = scp;
  251         if_initname(scp->ifp, device_get_name(dev), device_get_unit(dev));
  252         scp->ifp->if_flags = (IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
  253         scp->ifp->if_linkmib = &scp->mibdata;
  254         scp->ifp->if_linkmiblen = sizeof(scp->mibdata);
  255         scp->ifp->if_start = xe_start;
  256         scp->ifp->if_ioctl = xe_ioctl;
  257         scp->ifp->if_init = xe_init;
  258         scp->ifp->if_baudrate = 100000000;
  259         IFQ_SET_MAXLEN(&scp->ifp->if_snd, ifqmaxlen);
  260 
  261         /* Initialise the ifmedia structure */
  262         ifmedia_init(scp->ifm, 0, xe_media_change, xe_media_status);
  263         callout_init_mtx(&scp->media_timer, &scp->lock, 0);
  264 
  265         /* Add supported media types */
  266         if (scp->mohawk) {
  267                 ifmedia_add(scp->ifm, IFM_ETHER|IFM_100_TX, 0, NULL);
  268                 ifmedia_add(scp->ifm, IFM_ETHER|IFM_10_T|IFM_FDX, 0, NULL);
  269                 ifmedia_add(scp->ifm, IFM_ETHER|IFM_10_T|IFM_HDX, 0, NULL);
  270         }
  271         ifmedia_add(scp->ifm, IFM_ETHER|IFM_10_T, 0, NULL);
  272         if (scp->ce2)
  273                 ifmedia_add(scp->ifm, IFM_ETHER|IFM_10_2, 0, NULL);
  274         ifmedia_add(scp->ifm, IFM_ETHER|IFM_AUTO, 0, NULL);
  275 
  276         /* Default is to autoselect best supported media type */
  277         ifmedia_set(scp->ifm, IFM_ETHER|IFM_AUTO);
  278 
  279         /* Get the hardware into a known state */
  280         XE_LOCK(scp);
  281         xe_reset(scp);
  282         XE_UNLOCK(scp);
  283 
  284         /* Get hardware version numbers */
  285         XE_SELECT_PAGE(4);
  286         scp->version = XE_INB(XE_BOV);
  287         if (scp->mohawk)
  288                 scp->srev = (XE_INB(XE_BOV) & 0x70) >> 4;
  289         else
  290                 scp->srev = (XE_INB(XE_BOV) & 0x30) >> 4;
  291 
  292         /* Print some useful information */
  293         device_printf(dev, "version 0x%02x/0x%02x%s%s\n", scp->version,
  294             scp->srev, scp->mohawk ? ", 100Mbps capable" : "",
  295             scp->modem ?  ", with modem" : "");
  296         if (scp->mohawk) {
  297                 XE_SELECT_PAGE(0x10);
  298                 DEVPRINTF(1, (dev,
  299                     "DingoID=0x%04x, RevisionID=0x%04x, VendorID=0x%04x\n",
  300                     XE_INW(XE_DINGOID), XE_INW(XE_RevID), XE_INW(XE_VendorID)));
  301         }
  302         if (scp->ce2) {
  303                 XE_SELECT_PAGE(0x45);
  304                 DEVPRINTF(1, (dev, "CE2 version = 0x%02x\n", XE_INB(XE_REV)));
  305         }
  306 
  307         /* Attach the interface */
  308         ether_ifattach(scp->ifp, scp->enaddr);
  309 
  310         err = bus_setup_intr(dev, scp->irq_res, INTR_TYPE_NET | INTR_MPSAFE,
  311             NULL, xe_intr, scp, &scp->intrhand);
  312         if (err) {
  313                 ether_ifdetach(scp->ifp);
  314                 mtx_destroy(&scp->lock);
  315                 return (err);
  316         }
  317 
  318         /* Done */
  319         return (0);
  320 }
  321 
  322 /*
  323  * Complete hardware intitialisation and enable output.  Exits without doing
  324  * anything if there's no address assigned to the card, or if media selection
  325  * is in progress (the latter implies we've already run this function).
  326  */
  327 static void
  328 xe_init(void *xscp)
  329 {
  330         struct xe_softc *scp = xscp;
  331 
  332         XE_LOCK(scp);
  333         xe_init_locked(scp);
  334         XE_UNLOCK(scp);
  335 }
  336 
  337 static void
  338 xe_init_locked(struct xe_softc *scp)
  339 {
  340         unsigned i;
  341 
  342         if (scp->autoneg_status != XE_AUTONEG_NONE)
  343                 return;
  344 
  345         DEVPRINTF(2, (scp->dev, "init\n"));
  346 
  347         /* Reset transmitter flags */
  348         scp->tx_queued = 0;
  349         scp->tx_tpr = 0;
  350         scp->tx_timeouts = 0;
  351         scp->tx_thres = 64;
  352         scp->tx_min = ETHER_MIN_LEN - ETHER_CRC_LEN;
  353         scp->tx_timeout = 0;
  354 
  355         /* Soft reset the card */
  356         XE_SELECT_PAGE(0);
  357         XE_OUTB(XE_CR, XE_CR_SOFT_RESET);
  358         DELAY(40000);
  359         XE_OUTB(XE_CR, 0);
  360         DELAY(40000);
  361 
  362         if (scp->mohawk) {
  363                 /*
  364                  * set GP1 and GP2 as outputs (bits 2 & 3)
  365                  * set GP1 low to power on the ML6692 (bit 0)
  366                  * set GP2 high to power on the 10Mhz chip (bit 1)
  367                  */
  368                 XE_SELECT_PAGE(4);
  369                 XE_OUTB(XE_GPR0, XE_GPR0_GP2_SELECT | XE_GPR0_GP1_SELECT |
  370                     XE_GPR0_GP2_OUT);
  371         }
  372 
  373         /* Shut off interrupts */
  374         xe_disable_intr(scp);
  375 
  376         /* Wait for everything to wake up */
  377         DELAY(500000);
  378 
  379         /* Check for PHY */
  380         if (scp->mohawk)
  381                 scp->phy_ok = xe_mii_init(scp);
  382 
  383         /* Disable 'source insertion' (not sure what that means) */
  384         XE_SELECT_PAGE(0x42);
  385         XE_OUTB(XE_SWC0, XE_SWC0_NO_SRC_INSERT);
  386 
  387         /* Set 8K/24K Tx/Rx buffer split */
  388         if (scp->srev != 1) {
  389                 XE_SELECT_PAGE(2);
  390                 XE_OUTW(XE_RBS, 0x2000);
  391         }
  392 
  393         /* Enable early transmit mode on Mohawk/Dingo */
  394         if (scp->mohawk) {
  395                 XE_SELECT_PAGE(0x03);
  396                 XE_OUTW(XE_TPT, scp->tx_thres);
  397                 XE_SELECT_PAGE(0x01);
  398                 XE_OUTB(XE_ECR, XE_INB(XE_ECR) | XE_ECR_EARLY_TX);
  399         }
  400 
  401         /* Put MAC address in first 'individual address' register */
  402         XE_SELECT_PAGE(0x50);
  403         for (i = 0; i < ETHER_ADDR_LEN; i++)
  404                 XE_OUTB(0x08 + i, IF_LLADDR(scp->ifp)[scp->mohawk ? 5 - i : i]);
  405 
  406         /* Set up multicast addresses */
  407         xe_set_multicast(scp);
  408 
  409         /* Fix the receive data offset -- reset can leave it off-by-one */
  410         XE_SELECT_PAGE(0);
  411         XE_OUTW(XE_DO, 0x2000);
  412 
  413         /* Set interrupt masks */
  414         XE_SELECT_PAGE(1);
  415         XE_OUTB(XE_IMR0, XE_IMR0_TX_PACKET | XE_IMR0_MAC_INTR |
  416             XE_IMR0_RX_PACKET);
  417 
  418         /* Set MAC interrupt masks */
  419         XE_SELECT_PAGE(0x40);
  420         XE_OUTB(XE_RX0Msk,
  421             ~(XE_RX0M_RX_OVERRUN | XE_RX0M_CRC_ERROR | XE_RX0M_ALIGN_ERROR |
  422             XE_RX0M_LONG_PACKET));
  423         XE_OUTB(XE_TX0Msk,
  424             ~(XE_TX0M_SQE_FAIL | XE_TX0M_LATE_COLLISION | XE_TX0M_TX_UNDERRUN |
  425             XE_TX0M_16_COLLISIONS | XE_TX0M_NO_CARRIER));
  426 
  427         /* Clear MAC status registers */
  428         XE_SELECT_PAGE(0x40);
  429         XE_OUTB(XE_RST0, 0x00);
  430         XE_OUTB(XE_TXST0, 0x00);
  431 
  432         /* Enable receiver and put MAC online */
  433         XE_SELECT_PAGE(0x40);
  434         XE_OUTB(XE_CMD0, XE_CMD0_RX_ENABLE|XE_CMD0_ONLINE);
  435 
  436         /* Set up IMR, enable interrupts */
  437         xe_enable_intr(scp);
  438 
  439         /* Start media selection */
  440         xe_setmedia(scp);
  441 
  442         /* Enable output */
  443         scp->ifp->if_drv_flags |= IFF_DRV_RUNNING;
  444         scp->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
  445         callout_reset(&scp->wdog_timer, hz, xe_watchdog, scp);
  446 }
  447 
  448 /*
  449  * Start output on interface.  Should be called at splimp() priority.  Check
  450  * that the output is idle (ie, IFF_DRV_OACTIVE is not set) before calling this
  451  * function.  If media selection is in progress we set IFF_DRV_OACTIVE ourselves
  452  * and return immediately.
  453  */
  454 static void
  455 xe_start(struct ifnet *ifp)
  456 {
  457         struct xe_softc *scp = ifp->if_softc;
  458 
  459         XE_LOCK(scp);
  460         xe_start_locked(ifp);
  461         XE_UNLOCK(scp);
  462 }
  463 
  464 static void
  465 xe_start_locked(struct ifnet *ifp)
  466 {
  467         struct xe_softc *scp = ifp->if_softc;
  468         struct mbuf *mbp;
  469 
  470         if (scp->autoneg_status != XE_AUTONEG_NONE) {
  471                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
  472                 return;
  473         }
  474 
  475         DEVPRINTF(3, (scp->dev, "start\n"));
  476 
  477         /*
  478          * Loop while there are packets to be sent, and space to send
  479          * them.
  480          */
  481         for (;;) {
  482                 /* Suck a packet off the send queue */
  483                 IF_DEQUEUE(&ifp->if_snd, mbp);
  484 
  485                 if (mbp == NULL) {
  486                         /*
  487                          * We are using the !OACTIVE flag to indicate
  488                          * to the outside world that we can accept an
  489                          * additional packet rather than that the
  490                          * transmitter is _actually_ active. Indeed,
  491                          * the transmitter may be active, but if we
  492                          * haven't filled all the buffers with data
  493                          * then we still want to accept more.
  494                          */
  495                         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
  496                         return;
  497                 }
  498 
  499                 if (xe_pio_write_packet(scp, mbp) != 0) {
  500                         /* Push the packet back onto the queue */
  501                         IF_PREPEND(&ifp->if_snd, mbp);
  502                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
  503                         return;
  504                 }
  505 
  506                 /* Tap off here if there is a bpf listener */
  507                 BPF_MTAP(ifp, mbp);
  508 
  509                 /* In case we don't hear from the card again... */
  510                 scp->tx_timeout = 5;
  511                 scp->tx_queued++;
  512 
  513                 m_freem(mbp);
  514         }
  515 }
  516 
  517 /*
  518  * Process an ioctl request.  Adapted from the ed driver.
  519  */
  520 static int
  521 xe_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
  522 {
  523         struct xe_softc *scp;
  524         int error;
  525 
  526         scp = ifp->if_softc;
  527         error = 0;
  528 
  529         switch (command) {
  530         case SIOCSIFFLAGS:
  531                 DEVPRINTF(2, (scp->dev, "ioctl: SIOCSIFFLAGS: 0x%04x\n",
  532                         ifp->if_flags));
  533                 /*
  534                  * If the interface is marked up and stopped, then
  535                  * start it.  If it is marked down and running, then
  536                  * stop it.
  537                  */
  538                 XE_LOCK(scp);
  539                 if (ifp->if_flags & IFF_UP) {
  540                         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
  541                                 xe_reset(scp);
  542                                 xe_init_locked(scp);
  543                         }
  544                 } else {
  545                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
  546                                 xe_stop(scp);
  547                 }
  548 
  549                 /* handle changes to PROMISC/ALLMULTI flags */
  550                 xe_set_multicast(scp);
  551                 XE_UNLOCK(scp);
  552                 error = 0;
  553                 break;
  554         case SIOCADDMULTI:
  555         case SIOCDELMULTI:
  556                 DEVPRINTF(2, (scp->dev, "ioctl: SIOC{ADD,DEL}MULTI\n"));
  557                 /*
  558                  * Multicast list has (maybe) changed; set the
  559                  * hardware filters accordingly.
  560                  */
  561                 XE_LOCK(scp);
  562                 xe_set_multicast(scp);
  563                 XE_UNLOCK(scp);
  564                 error = 0;
  565                 break;
  566         case SIOCSIFMEDIA:
  567         case SIOCGIFMEDIA:
  568                 DEVPRINTF(3, (scp->dev, "ioctl: bounce to ifmedia_ioctl\n"));
  569                 /*
  570                  * Someone wants to get/set media options.
  571                  */
  572                 error = ifmedia_ioctl(ifp, (struct ifreq *)data, &scp->ifmedia,
  573                     command);
  574                 break;
  575         default:
  576                 DEVPRINTF(3, (scp->dev, "ioctl: bounce to ether_ioctl\n"));
  577                 error = ether_ioctl(ifp, command, data);
  578         }
  579 
  580         return (error);
  581 }
  582 
  583 /*
  584  * Card interrupt handler.
  585  *
  586  * This function is probably more complicated than it needs to be, as it
  587  * attempts to deal with the case where multiple packets get sent between
  588  * interrupts.  This is especially annoying when working out the collision
  589  * stats.  Not sure whether this case ever really happens or not (maybe on a
  590  * slow/heavily loaded machine?) so it's probably best to leave this like it
  591  * is.
  592  *
  593  * Note that the crappy PIO used to get packets on and off the card means that 
  594  * you will spend a lot of time in this routine -- I can get my P150 to spend
  595  * 90% of its time servicing interrupts if I really hammer the network.  Could 
  596  * fix this, but then you'd start dropping/losing packets.  The moral of this
  597  * story?  If you want good network performance _and_ some cycles left over to 
  598  * get your work done, don't buy a Xircom card.  Or convince them to tell me
  599  * how to do memory-mapped I/O :)
  600  */
  601 static void
  602 xe_txintr(struct xe_softc *scp, uint8_t txst1)
  603 {
  604         struct ifnet *ifp;
  605         uint8_t tpr, sent, coll;
  606 
  607         ifp = scp->ifp;
  608 
  609         /* Update packet count, accounting for rollover */
  610         tpr = XE_INB(XE_TPR);
  611         sent = -scp->tx_tpr + tpr;
  612 
  613         /* Update statistics if we actually sent anything */
  614         if (sent > 0) {
  615                 coll = txst1 & XE_TXST1_RETRY_COUNT;
  616                 scp->tx_tpr = tpr;
  617                 scp->tx_queued -= sent;
  618                 if_inc_counter(ifp, IFCOUNTER_OPACKETS, sent);
  619                 if_inc_counter(ifp, IFCOUNTER_COLLISIONS, coll);
  620 
  621                 /*
  622                  * According to the Xircom manual, Dingo will
  623                  * sometimes manage to transmit a packet with
  624                  * triggering an interrupt.  If this happens, we have
  625                  * sent > 1 and the collision count only reflects
  626                  * collisions on the last packet sent (the one that
  627                  * triggered the interrupt).  Collision stats might
  628                  * therefore be a bit low, but there doesn't seem to
  629                  * be anything we can do about that.
  630                  */
  631                 switch (coll) {
  632                 case 0:
  633                         break;
  634                 case 1:
  635                         scp->mibdata.dot3StatsSingleCollisionFrames++;
  636                         scp->mibdata.dot3StatsCollFrequencies[0]++;
  637                         break;
  638                 default:
  639                         scp->mibdata.dot3StatsMultipleCollisionFrames++;
  640                         scp->mibdata.dot3StatsCollFrequencies[coll-1]++;
  641                 }
  642         }
  643         scp->tx_timeout = 0;
  644         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
  645 }
  646 
  647 /* Handle most MAC interrupts */
  648 static void
  649 xe_macintr(struct xe_softc *scp, uint8_t rst0, uint8_t txst0, uint8_t txst1)
  650 {
  651         struct ifnet *ifp;
  652 
  653         ifp = scp->ifp;
  654 
  655 #if 0
  656         /* Carrier sense lost -- only in 10Mbit HDX mode */
  657         if (txst0 & XE_TXST0_NO_CARRIER || !(txst1 & XE_TXST1_LINK_STATUS)) {
  658                 /* XXX - Need to update media status here */
  659                 device_printf(scp->dev, "no carrier\n");
  660                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
  661                 scp->mibdata.dot3StatsCarrierSenseErrors++;
  662         }
  663 #endif
  664         /* Excessive collisions -- try sending again */
  665         if (txst0 & XE_TXST0_16_COLLISIONS) {
  666                 if_inc_counter(ifp, IFCOUNTER_COLLISIONS, 16);
  667                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
  668                 scp->mibdata.dot3StatsExcessiveCollisions++;
  669                 scp->mibdata.dot3StatsMultipleCollisionFrames++;
  670                 scp->mibdata.dot3StatsCollFrequencies[15]++;
  671                 XE_OUTB(XE_CR, XE_CR_RESTART_TX);
  672         }
  673 
  674         /* Transmit underrun -- increase early transmit threshold */
  675         if (txst0 & XE_TXST0_TX_UNDERRUN && scp->mohawk) {
  676                 DEVPRINTF(1, (scp->dev, "transmit underrun"));
  677                 if (scp->tx_thres < ETHER_MAX_LEN) {
  678                         if ((scp->tx_thres += 64) > ETHER_MAX_LEN)
  679                                 scp->tx_thres = ETHER_MAX_LEN;
  680                         DPRINTF(1, (": increasing transmit threshold to %u",
  681                             scp->tx_thres));
  682                         XE_SELECT_PAGE(0x3);
  683                         XE_OUTW(XE_TPT, scp->tx_thres);
  684                         XE_SELECT_PAGE(0x0);
  685                 }
  686                 DPRINTF(1, ("\n"));
  687                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
  688                 scp->mibdata.dot3StatsInternalMacTransmitErrors++;
  689         }
  690 
  691         /* Late collision -- just complain about it */
  692         if (txst0 & XE_TXST0_LATE_COLLISION) {
  693                 device_printf(scp->dev, "late collision\n");
  694                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
  695                 scp->mibdata.dot3StatsLateCollisions++;
  696         }
  697 
  698         /* SQE test failure -- just complain about it */
  699         if (txst0 & XE_TXST0_SQE_FAIL) {
  700                 device_printf(scp->dev, "SQE test failure\n");
  701                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
  702                 scp->mibdata.dot3StatsSQETestErrors++;
  703         }
  704 
  705         /* Packet too long -- what happens to these */
  706         if (rst0 & XE_RST0_LONG_PACKET) {
  707                 device_printf(scp->dev, "received giant packet\n");
  708                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
  709                 scp->mibdata.dot3StatsFrameTooLongs++;
  710         }
  711 
  712         /* CRC error -- packet dropped */
  713         if (rst0 & XE_RST0_CRC_ERROR) {
  714                 device_printf(scp->dev, "CRC error\n");
  715                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
  716                 scp->mibdata.dot3StatsFCSErrors++;
  717         }
  718 }
  719 
  720 static void
  721 xe_rxintr(struct xe_softc *scp, uint8_t rst0)
  722 {
  723         struct ifnet *ifp;
  724         uint8_t esr, rsr;
  725 
  726         ifp = scp->ifp;
  727 
  728         /* Handle received packet(s) */
  729         while ((esr = XE_INB(XE_ESR)) & XE_ESR_FULL_PACKET_RX) {
  730                 rsr = XE_INB(XE_RSR);
  731 
  732                 DEVPRINTF(3, (scp->dev, "intr: ESR=0x%02x, RSR=0x%02x\n", esr,
  733                     rsr));
  734 
  735                 /* Make sure packet is a good one */
  736                 if (rsr & XE_RSR_RX_OK) {
  737                         struct ether_header *ehp;
  738                         struct mbuf *mbp;
  739                         uint16_t len;
  740 
  741                         len = XE_INW(XE_RBC) - ETHER_CRC_LEN;
  742 
  743                         DEVPRINTF(3, (scp->dev, "intr: receive length = %d\n",
  744                             len));
  745 
  746                         if (len == 0) {
  747                                 if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
  748                                 continue;
  749                         }
  750 
  751                         /*
  752                          * Allocate mbuf to hold received packet.  If
  753                          * the mbuf header isn't big enough, we attach
  754                          * an mbuf cluster to hold the packet.  Note
  755                          * the +=2 to align the packet data on a
  756                          * 32-bit boundary, and the +3 to allow for
  757                          * the possibility of reading one more byte
  758                          * than the actual packet length (we always
  759                          * read 16-bit words).  XXX - Surely there's a
  760                          * better way to do this alignment?
  761                          */
  762                         MGETHDR(mbp, M_NOWAIT, MT_DATA);
  763                         if (mbp == NULL) {
  764                                 if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
  765                                 continue;
  766                         }
  767 
  768                         if (len + 3 > MHLEN) {
  769                                 if (!(MCLGET(mbp, M_NOWAIT))) {
  770                                         m_freem(mbp);
  771                                         if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
  772                                         continue;
  773                                 }
  774                         }
  775 
  776                         mbp->m_data += 2;
  777                         ehp = mtod(mbp, struct ether_header *);
  778 
  779                         /*
  780                          * Now get the packet in PIO mode, including
  781                          * the Ethernet header but omitting the
  782                          * trailing CRC.
  783                          */
  784 
  785                         /*
  786                          * Work around a bug in CE2 cards.  There
  787                          * seems to be a problem with duplicated and
  788                          * extraneous bytes in the receive buffer, but
  789                          * without any real documentation for the CE2
  790                          * it's hard to tell for sure.  XXX - Needs
  791                          * testing on CE2 hardware
  792                          */
  793                         if (scp->srev == 0) {
  794                                 u_short rhs;
  795 
  796                                 XE_SELECT_PAGE(5);
  797                                 rhs = XE_INW(XE_RHSA);
  798                                 XE_SELECT_PAGE(0);
  799 
  800                                 rhs += 3;        /* Skip control info */
  801 
  802                                 if (rhs >= 0x8000)
  803                                         rhs = 0;
  804 
  805                                 if (rhs + len > 0x8000) {
  806                                         int i;
  807 
  808                                         for (i = 0; i < len; i++, rhs++) {
  809                                                 ((char *)ehp)[i] =
  810                                                     XE_INB(XE_EDP);
  811                                                 if (rhs == 0x8000) {
  812                                                         rhs = 0;
  813                                                         i--;
  814                                                 }
  815                                         }
  816                                 } else
  817                                         bus_read_multi_2(scp->port_res, XE_EDP, 
  818                                             (uint16_t *)ehp, (len + 1) >> 1);
  819                         } else
  820                                 bus_read_multi_2(scp->port_res, XE_EDP, 
  821                                     (uint16_t *)ehp, (len + 1) >> 1);
  822 
  823                         /* Deliver packet to upper layers */
  824                         mbp->m_pkthdr.rcvif = ifp;
  825                         mbp->m_pkthdr.len = mbp->m_len = len;
  826                         XE_UNLOCK(scp);
  827                         (*ifp->if_input)(ifp, mbp);
  828                         XE_LOCK(scp);
  829                         if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
  830 
  831                 } else if (rsr & XE_RSR_ALIGN_ERROR) {
  832                         /* Packet alignment error -- drop packet */
  833                         device_printf(scp->dev, "alignment error\n");
  834                         scp->mibdata.dot3StatsAlignmentErrors++;
  835                         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
  836                 }
  837 
  838                 /* Skip to next packet, if there is one */
  839                 XE_OUTW(XE_DO, 0x8000);
  840         }
  841 
  842         /* Clear receiver overruns now we have some free buffer space */
  843         if (rst0 & XE_RST0_RX_OVERRUN) {
  844                 DEVPRINTF(1, (scp->dev, "receive overrun\n"));
  845                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
  846                 scp->mibdata.dot3StatsInternalMacReceiveErrors++;
  847                 XE_OUTB(XE_CR, XE_CR_CLEAR_OVERRUN);
  848         }
  849 }
  850 
  851 static void
  852 xe_intr(void *xscp)
  853 {
  854         struct xe_softc *scp = (struct xe_softc *) xscp;
  855         struct ifnet *ifp;
  856         uint8_t psr, isr, rst0, txst0, txst1;
  857 
  858         ifp = scp->ifp;
  859         XE_LOCK(scp);
  860 
  861         /* Disable interrupts */
  862         if (scp->mohawk)
  863                 XE_OUTB(XE_CR, 0);
  864 
  865         /* Cache current register page */
  866         psr = XE_INB(XE_PR);
  867 
  868         /* Read ISR to see what caused this interrupt */
  869         while ((isr = XE_INB(XE_ISR)) != 0) {
  870 
  871                 /* 0xff might mean the card is no longer around */
  872                 if (isr == 0xff) {
  873                         DEVPRINTF(3, (scp->dev,
  874                             "intr: interrupt received for missing card?\n"));
  875                         break;
  876                 }
  877 
  878                 /* Read other status registers */
  879                 XE_SELECT_PAGE(0x40);
  880                 rst0 = XE_INB(XE_RST0);
  881                 XE_OUTB(XE_RST0, 0);
  882                 txst0 = XE_INB(XE_TXST0);
  883                 txst1 = XE_INB(XE_TXST1);
  884                 XE_OUTB(XE_TXST0, 0);
  885                 XE_OUTB(XE_TXST1, 0);
  886                 XE_SELECT_PAGE(0);
  887 
  888                 DEVPRINTF(3, (scp->dev,
  889                     "intr: ISR=0x%02x, RST=0x%02x, TXT=0x%02x%02x\n", isr,
  890                     rst0, txst1, txst0));
  891 
  892                 if (isr & XE_ISR_TX_PACKET)
  893                         xe_txintr(scp, txst1);
  894 
  895                 if (isr & XE_ISR_MAC_INTR)
  896                         xe_macintr(scp, rst0, txst0, txst1);
  897 
  898                 xe_rxintr(scp, rst0);
  899         }
  900 
  901         /* Restore saved page */
  902         XE_SELECT_PAGE(psr);
  903 
  904         /* Re-enable interrupts */
  905         XE_OUTB(XE_CR, XE_CR_ENABLE_INTR);
  906 
  907         XE_UNLOCK(scp);
  908 }
  909 
  910 /*
  911  * Device timeout/watchdog routine.  Called automatically if we queue a packet 
  912  * for transmission but don't get an interrupt within a specified timeout
  913  * (usually 5 seconds).  When this happens we assume the worst and reset the
  914  * card.
  915  */
  916 static void
  917 xe_watchdog(void *arg)
  918 {
  919         struct xe_softc *scp = arg;
  920 
  921         XE_ASSERT_LOCKED(scp);
  922 
  923         if (scp->tx_timeout && --scp->tx_timeout == 0) {
  924                 device_printf(scp->dev, "watchdog timeout: resetting card\n");
  925                 scp->tx_timeouts++;
  926                 if_inc_counter(scp->ifp, IFCOUNTER_OERRORS, scp->tx_queued);
  927                 xe_stop(scp);
  928                 xe_reset(scp);
  929                 xe_init_locked(scp);
  930         }
  931         callout_reset(&scp->wdog_timer, hz, xe_watchdog, scp);
  932 }
  933 
  934 /*
  935  * Change media selection.
  936  */
  937 static int
  938 xe_media_change(struct ifnet *ifp)
  939 {
  940         struct xe_softc *scp = ifp->if_softc;
  941 
  942         DEVPRINTF(2, (scp->dev, "media_change\n"));
  943 
  944         XE_LOCK(scp);
  945         if (IFM_TYPE(scp->ifm->ifm_media) != IFM_ETHER) {
  946                 XE_UNLOCK(scp);
  947                 return(EINVAL);
  948         }
  949 
  950         /*
  951          * Some card/media combos aren't always possible -- filter
  952          * those out here.
  953          */
  954         if ((IFM_SUBTYPE(scp->ifm->ifm_media) == IFM_AUTO ||
  955             IFM_SUBTYPE(scp->ifm->ifm_media) == IFM_100_TX) && !scp->phy_ok) {
  956                 XE_UNLOCK(scp);
  957                 return (EINVAL);
  958         }
  959 
  960         xe_setmedia(scp);
  961         XE_UNLOCK(scp);
  962 
  963         return (0);
  964 }
  965 
  966 /*
  967  * Return current media selection.
  968  */
  969 static void
  970 xe_media_status(struct ifnet *ifp, struct ifmediareq *mrp)
  971 {
  972         struct xe_softc *scp = ifp->if_softc;
  973 
  974         DEVPRINTF(3, (scp->dev, "media_status\n"));
  975 
  976         /* XXX - This is clearly wrong.  Will fix once I have CE2 working */
  977         XE_LOCK(scp);
  978         mrp->ifm_status = IFM_AVALID | IFM_ACTIVE;
  979         mrp->ifm_active = ((struct xe_softc *)ifp->if_softc)->media;
  980         XE_UNLOCK(scp);
  981 }
  982 
  983 /*
  984  * Select active media.
  985  */
  986 static void
  987 xe_setmedia(void *xscp)
  988 {
  989         struct xe_softc *scp = xscp;
  990         uint16_t bmcr, bmsr, anar, lpar;
  991 
  992         DEVPRINTF(2, (scp->dev, "setmedia\n"));
  993 
  994         XE_ASSERT_LOCKED(scp);
  995 
  996         /* Cancel any pending timeout */
  997         callout_stop(&scp->media_timer);
  998         xe_disable_intr(scp);
  999 
 1000         /* Select media */
 1001         scp->media = IFM_ETHER;
 1002         switch (IFM_SUBTYPE(scp->ifm->ifm_media)) {
 1003 
 1004         case IFM_AUTO:  /* Autoselect media */
 1005                 scp->media = IFM_ETHER|IFM_AUTO;
 1006 
 1007                 /*
 1008                  * Autoselection is really awful.  It goes something like this:
 1009                  *
 1010                  * Wait until the transmitter goes idle (2sec timeout).
 1011                  * Reset card
 1012                  *   IF a 100Mbit PHY exists
 1013                  *     Start NWAY autonegotiation (3.5sec timeout)
 1014                  *     IF that succeeds
 1015                  *       Select 100baseTX or 10baseT, whichever was detected
 1016                  *     ELSE
 1017                  *       Reset card
 1018                  *       IF a 100Mbit PHY exists
 1019                  *         Try to force a 100baseTX link (3sec timeout)
 1020                  *         IF that succeeds
 1021                  *           Select 100baseTX
 1022                  *         ELSE
 1023                  *           Disable the PHY
 1024                  *         ENDIF
 1025                  *       ENDIF
 1026                  *     ENDIF
 1027                  *   ENDIF
 1028                  * IF nothing selected so far
 1029                  *   IF a 100Mbit PHY exists
 1030                  *     Select 10baseT
 1031                  *   ELSE
 1032                  *     Select 10baseT or 10base2, whichever is connected
 1033                  *   ENDIF
 1034                  * ENDIF
 1035                  */
 1036                 switch (scp->autoneg_status) {
 1037                 case XE_AUTONEG_NONE:
 1038                         DEVPRINTF(2, (scp->dev,
 1039                             "Waiting for idle transmitter\n"));
 1040                         scp->ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 1041                         scp->autoneg_status = XE_AUTONEG_WAITING;
 1042                         /* FALL THROUGH */
 1043                 case XE_AUTONEG_WAITING:
 1044                         if (scp->tx_queued != 0) {
 1045                                 callout_reset(&scp->media_timer, hz / 2,
 1046                                     xe_setmedia, scp);
 1047                                 return;
 1048                         }
 1049                         if (scp->phy_ok) {
 1050                                 DEVPRINTF(2, (scp->dev,
 1051                                         "Starting autonegotiation\n"));
 1052                                 bmcr = xe_phy_readreg(scp, PHY_BMCR);
 1053                                 bmcr &= ~(PHY_BMCR_AUTONEGENBL);
 1054                                 xe_phy_writereg(scp, PHY_BMCR, bmcr);
 1055                                 anar = xe_phy_readreg(scp, PHY_ANAR);
 1056                                 anar &= ~(PHY_ANAR_100BT4 |
 1057                                     PHY_ANAR_100BTXFULL | PHY_ANAR_10BTFULL);
 1058                                 anar |= PHY_ANAR_100BTXHALF | PHY_ANAR_10BTHALF;
 1059                                 xe_phy_writereg(scp, PHY_ANAR, anar);
 1060                                 bmcr |= PHY_BMCR_AUTONEGENBL |
 1061                                     PHY_BMCR_AUTONEGRSTR;
 1062                                 xe_phy_writereg(scp, PHY_BMCR, bmcr);
 1063                                 scp->autoneg_status = XE_AUTONEG_STARTED;
 1064                                 callout_reset(&scp->media_timer, hz * 7/2,
 1065                                     xe_setmedia, scp);
 1066                                 return;
 1067                         } else {
 1068                                 scp->autoneg_status = XE_AUTONEG_FAIL;
 1069                         }
 1070                         break;
 1071                 case XE_AUTONEG_STARTED:
 1072                         bmsr = xe_phy_readreg(scp, PHY_BMSR);
 1073                         lpar = xe_phy_readreg(scp, PHY_LPAR);
 1074                         if (bmsr & (PHY_BMSR_AUTONEGCOMP | PHY_BMSR_LINKSTAT)) {
 1075                                 DEVPRINTF(2, (scp->dev,
 1076                                     "Autonegotiation complete!\n"));
 1077 
 1078                                 /*
 1079                                  * XXX - Shouldn't have to do this,
 1080                                  * but (on my hub at least) the
 1081                                  * transmitter won't work after a
 1082                                  * successful autoneg.  So we see what
 1083                                  * the negotiation result was and
 1084                                  * force that mode.  I'm sure there is
 1085                                  * an easy fix for this.
 1086                                  */
 1087                                 if (lpar & PHY_LPAR_100BTXHALF) {
 1088                                         xe_phy_writereg(scp, PHY_BMCR,
 1089                                             PHY_BMCR_SPEEDSEL);
 1090                                         XE_MII_DUMP(scp);
 1091                                         XE_SELECT_PAGE(2);
 1092                                         XE_OUTB(XE_MSR, XE_INB(XE_MSR) | 0x08);
 1093                                         scp->media = IFM_ETHER | IFM_100_TX;
 1094                                         scp->autoneg_status = XE_AUTONEG_NONE;
 1095                                 } else {
 1096                                         /*
 1097                                          * XXX - Bit of a hack going
 1098                                          * on in here.  This is
 1099                                          * derived from Ken Hughes
 1100                                          * patch to the Linux driver
 1101                                          * to make it work with 10Mbit
 1102                                          * _autonegotiated_ links on
 1103                                          * CE3B cards.  What's a CE3B
 1104                                          * and how's it differ from a
 1105                                          * plain CE3?  these are the
 1106                                          * things we need to find out.
 1107                                          */
 1108                                         xe_phy_writereg(scp, PHY_BMCR, 0x0000);
 1109                                         XE_SELECT_PAGE(2);
 1110                                         /* BEGIN HACK */
 1111                                         XE_OUTB(XE_MSR, XE_INB(XE_MSR) | 0x08);
 1112                                         XE_SELECT_PAGE(0x42);
 1113                                         XE_OUTB(XE_SWC1, 0x80);
 1114                                         scp->media = IFM_ETHER | IFM_10_T;
 1115                                         scp->autoneg_status = XE_AUTONEG_NONE;
 1116                                         /* END HACK */
 1117 #if 0
 1118                                         /* Display PHY? */
 1119                                         XE_OUTB(XE_MSR, XE_INB(XE_MSR) & ~0x08);
 1120                                         scp->autoneg_status = XE_AUTONEG_FAIL;
 1121 #endif
 1122                                 }
 1123                         } else {
 1124                                 DEVPRINTF(2, (scp->dev,
 1125                             "Autonegotiation failed; trying 100baseTX\n"));
 1126                                 XE_MII_DUMP(scp);
 1127                                 if (scp->phy_ok) {
 1128                                         xe_phy_writereg(scp, PHY_BMCR,
 1129                                             PHY_BMCR_SPEEDSEL);
 1130                                         scp->autoneg_status = XE_AUTONEG_100TX;
 1131                                         callout_reset(&scp->media_timer, hz * 3,
 1132                                             xe_setmedia, scp);
 1133                                         return;
 1134                                 } else {
 1135                                         scp->autoneg_status = XE_AUTONEG_FAIL;
 1136                                 }
 1137                         }
 1138                         break;
 1139                 case XE_AUTONEG_100TX:
 1140                         (void)xe_phy_readreg(scp, PHY_BMSR);
 1141                         bmsr = xe_phy_readreg(scp, PHY_BMSR);
 1142                         if (bmsr & PHY_BMSR_LINKSTAT) {
 1143                                 DEVPRINTF(2, (scp->dev,
 1144                                     "Got 100baseTX link!\n"));
 1145                                 XE_MII_DUMP(scp);
 1146                                 XE_SELECT_PAGE(2);
 1147                                 XE_OUTB(XE_MSR, XE_INB(XE_MSR) | 0x08);
 1148                                 scp->media = IFM_ETHER | IFM_100_TX;
 1149                                 scp->autoneg_status = XE_AUTONEG_NONE;
 1150                         } else {
 1151                                 DEVPRINTF(2, (scp->dev,
 1152                                     "Autonegotiation failed; disabling PHY\n"));
 1153                                 XE_MII_DUMP(scp);
 1154                                 xe_phy_writereg(scp, PHY_BMCR, 0x0000);
 1155                                 XE_SELECT_PAGE(2);
 1156 
 1157                                 /* Disable PHY? */
 1158                                 XE_OUTB(XE_MSR, XE_INB(XE_MSR) & ~0x08);
 1159                                 scp->autoneg_status = XE_AUTONEG_FAIL;
 1160                         }
 1161                         break;
 1162                 }
 1163 
 1164                 /*
 1165                  * If we got down here _and_ autoneg_status is
 1166                  * XE_AUTONEG_FAIL, then either autonegotiation
 1167                  * failed, or never got started to begin with.  In
 1168                  * either case, select a suitable 10Mbit media and
 1169                  * hope it works.  We don't need to reset the card
 1170                  * again, since it will have been done already by the
 1171                  * big switch above.
 1172                  */
 1173                 if (scp->autoneg_status == XE_AUTONEG_FAIL) {
 1174                         DEVPRINTF(2, (scp->dev, "Selecting 10baseX\n"));
 1175                         if (scp->mohawk) {
 1176                                 XE_SELECT_PAGE(0x42);
 1177                                 XE_OUTB(XE_SWC1, 0x80);
 1178                                 scp->media = IFM_ETHER | IFM_10_T;
 1179                                 scp->autoneg_status = XE_AUTONEG_NONE;
 1180                         } else {
 1181                                 XE_SELECT_PAGE(4);
 1182                                 XE_OUTB(XE_GPR0, 4);
 1183                                 DELAY(50000);
 1184                                 XE_SELECT_PAGE(0x42);
 1185                                 XE_OUTB(XE_SWC1,
 1186                                     (XE_INB(XE_ESR) & XE_ESR_MEDIA_SELECT) ?
 1187                                     0x80 : 0xc0);
 1188                                 scp->media = IFM_ETHER | ((XE_INB(XE_ESR) &
 1189                                     XE_ESR_MEDIA_SELECT) ? IFM_10_T : IFM_10_2);
 1190                                 scp->autoneg_status = XE_AUTONEG_NONE;
 1191                         }
 1192                 }
 1193                 break;
 1194 
 1195         /*
 1196          * If a specific media has been requested, we just reset the
 1197          * card and select it (one small exception -- if 100baseTX is
 1198          * requested but there is no PHY, we fall back to 10baseT
 1199          * operation).
 1200          */
 1201         case IFM_100_TX:        /* Force 100baseTX */
 1202                 if (scp->phy_ok) {
 1203                         DEVPRINTF(2, (scp->dev, "Selecting 100baseTX\n"));
 1204                         XE_SELECT_PAGE(0x42);
 1205                         XE_OUTB(XE_SWC1, 0);
 1206                         xe_phy_writereg(scp, PHY_BMCR, PHY_BMCR_SPEEDSEL);
 1207                         XE_SELECT_PAGE(2);
 1208                         XE_OUTB(XE_MSR, XE_INB(XE_MSR) | 0x08);
 1209                         scp->media |= IFM_100_TX;
 1210                         break;
 1211                 }
 1212                 /* FALLTHROUGH */
 1213         case IFM_10_T:          /* Force 10baseT */
 1214                 DEVPRINTF(2, (scp->dev, "Selecting 10baseT\n"));
 1215                 if (scp->phy_ok) {
 1216                         xe_phy_writereg(scp, PHY_BMCR, 0x0000);
 1217                         XE_SELECT_PAGE(2);
 1218 
 1219                         /* Disable PHY */
 1220                         XE_OUTB(XE_MSR, XE_INB(XE_MSR) & ~0x08);
 1221                 }
 1222                 XE_SELECT_PAGE(0x42);
 1223                 XE_OUTB(XE_SWC1, 0x80);
 1224                 scp->media |= IFM_10_T;
 1225                 break;
 1226         case IFM_10_2:
 1227                 DEVPRINTF(2, (scp->dev, "Selecting 10base2\n"));
 1228                 XE_SELECT_PAGE(0x42);
 1229                 XE_OUTB(XE_SWC1, 0xc0);
 1230                 scp->media |= IFM_10_2;
 1231                 break;
 1232         }
 1233 
 1234         /*
 1235          * Finally, the LEDs are set to match whatever media was
 1236          * chosen and the transmitter is unblocked.
 1237          */
 1238         DEVPRINTF(2, (scp->dev, "Setting LEDs\n"));
 1239         XE_SELECT_PAGE(2);
 1240         switch (IFM_SUBTYPE(scp->media)) {
 1241         case IFM_100_TX:
 1242         case IFM_10_T:
 1243                 XE_OUTB(XE_LED, 0x3b);
 1244                 if (scp->dingo)
 1245                         XE_OUTB(0x0b, 0x04);    /* 100Mbit LED */
 1246                 break;
 1247         case IFM_10_2:
 1248                 XE_OUTB(XE_LED, 0x3a);
 1249                 break;
 1250         }
 1251 
 1252         /* Restart output? */
 1253         xe_enable_intr(scp);
 1254         scp->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 1255         xe_start_locked(scp->ifp);
 1256 }
 1257 
 1258 /*
 1259  * Hard reset (power cycle) the card.
 1260  */
 1261 static void
 1262 xe_reset(struct xe_softc *scp)
 1263 {
 1264 
 1265         DEVPRINTF(2, (scp->dev, "reset\n"));
 1266 
 1267         XE_ASSERT_LOCKED(scp);
 1268 
 1269         /* Power down */
 1270         XE_SELECT_PAGE(4);
 1271         XE_OUTB(XE_GPR1, 0);
 1272         DELAY(40000);
 1273 
 1274         /* Power up again */
 1275         if (scp->mohawk)
 1276                 XE_OUTB(XE_GPR1, XE_GPR1_POWER_DOWN);
 1277         else
 1278                 XE_OUTB(XE_GPR1, XE_GPR1_POWER_DOWN | XE_GPR1_AIC);
 1279 
 1280         DELAY(40000);
 1281         XE_SELECT_PAGE(0);
 1282 }
 1283 
 1284 /*
 1285  * Take interface offline.  This is done by powering down the device, which I
 1286  * assume means just shutting down the transceiver and Ethernet logic.  This
 1287  * requires a _hard_ reset to recover from, as we need to power up again.
 1288  */
 1289 void
 1290 xe_stop(struct xe_softc *scp)
 1291 {
 1292 
 1293         DEVPRINTF(2, (scp->dev, "stop\n"));
 1294 
 1295         XE_ASSERT_LOCKED(scp);
 1296 
 1297         /*
 1298          * Shut off interrupts.
 1299          */
 1300         xe_disable_intr(scp);
 1301 
 1302         /*
 1303          * Power down.
 1304          */
 1305         XE_SELECT_PAGE(4);
 1306         XE_OUTB(XE_GPR1, 0);
 1307         XE_SELECT_PAGE(0);
 1308         if (scp->mohawk) {
 1309                 /*
 1310                  * set GP1 and GP2 as outputs (bits 2 & 3)
 1311                  * set GP1 high to power on the ML6692 (bit 0)
 1312                  * set GP2 low to power on the 10Mhz chip (bit 1)
 1313                  */
 1314                 XE_SELECT_PAGE(4);
 1315                 XE_OUTB(XE_GPR0, XE_GPR0_GP2_SELECT | XE_GPR0_GP1_SELECT |
 1316                     XE_GPR0_GP1_OUT);
 1317         }
 1318 
 1319         /*
 1320          * ~IFF_DRV_RUNNING == interface down.
 1321          */
 1322         scp->ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
 1323         scp->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 1324         scp->tx_timeout = 0;
 1325         callout_stop(&scp->wdog_timer);
 1326         callout_stop(&scp->media_timer);
 1327 }
 1328 
 1329 /*
 1330  * Enable interrupts from the card.
 1331  */
 1332 static void
 1333 xe_enable_intr(struct xe_softc *scp)
 1334 {
 1335 
 1336         DEVPRINTF(2, (scp->dev, "enable_intr\n"));
 1337 
 1338         XE_SELECT_PAGE(0);
 1339         XE_OUTB(XE_CR, XE_CR_ENABLE_INTR);      /* Enable interrupts */
 1340         if (scp->modem && !scp->dingo) {        /* This bit is just magic */
 1341                 if (!(XE_INB(0x10) & 0x01)) {
 1342                         XE_OUTB(0x10, 0x11);    /* Unmask master int enable */
 1343                 }
 1344         }
 1345 }
 1346 
 1347 /*
 1348  * Disable interrupts from the card.
 1349  */
 1350 static void
 1351 xe_disable_intr(struct xe_softc *scp)
 1352 {
 1353 
 1354         DEVPRINTF(2, (scp->dev, "disable_intr\n"));
 1355 
 1356         XE_SELECT_PAGE(0);
 1357         XE_OUTB(XE_CR, 0);                      /* Disable interrupts */
 1358         if (scp->modem && !scp->dingo) {        /* More magic */
 1359                 XE_OUTB(0x10, 0x10);            /* Mask the master int enable */
 1360         }
 1361 }
 1362 
 1363 /*
 1364  * Set up multicast filter and promiscuous modes.
 1365  */
 1366 static void
 1367 xe_set_multicast(struct xe_softc *scp)
 1368 {
 1369         struct ifnet *ifp;
 1370         struct ifmultiaddr *maddr;
 1371         unsigned count, i;
 1372 
 1373         DEVPRINTF(2, (scp->dev, "set_multicast\n"));
 1374 
 1375         ifp = scp->ifp;
 1376         XE_SELECT_PAGE(0x42);
 1377 
 1378         /* Handle PROMISC flag */
 1379         if (ifp->if_flags & IFF_PROMISC) {
 1380                 XE_OUTB(XE_SWC1, XE_INB(XE_SWC1) | XE_SWC1_PROMISCUOUS);
 1381                 return;
 1382         } else
 1383                 XE_OUTB(XE_SWC1, XE_INB(XE_SWC1) & ~XE_SWC1_PROMISCUOUS);
 1384 
 1385         /* Handle ALLMULTI flag */
 1386         if (ifp->if_flags & IFF_ALLMULTI) {
 1387                 XE_OUTB(XE_SWC1, XE_INB(XE_SWC1) | XE_SWC1_ALLMULTI);
 1388                 return;
 1389         } else
 1390                 XE_OUTB(XE_SWC1, XE_INB(XE_SWC1) & ~XE_SWC1_ALLMULTI);
 1391 
 1392         /* Iterate over multicast address list */
 1393         count = 0;
 1394         if_maddr_rlock(ifp);
 1395         TAILQ_FOREACH(maddr, &ifp->if_multiaddrs, ifma_link) {
 1396                 if (maddr->ifma_addr->sa_family != AF_LINK)
 1397                         continue;
 1398 
 1399                 count++;
 1400 
 1401                 if (count < 10)
 1402                         /*
 1403                          * First 9 use Individual Addresses for exact
 1404                          * matching.
 1405                          */
 1406                         xe_set_addr(scp,
 1407                             LLADDR((struct sockaddr_dl *)maddr->ifma_addr),
 1408                             count);
 1409                 else if (scp->mohawk)
 1410                         /* Use hash filter on Mohawk and Dingo */
 1411                         xe_mchash(scp,
 1412                             LLADDR((struct sockaddr_dl *)maddr->ifma_addr));
 1413                 else
 1414                         /* Nowhere else to put them on CE2 */
 1415                         break;
 1416         }
 1417         if_maddr_runlock(ifp);
 1418 
 1419         DEVPRINTF(2, (scp->dev, "set_multicast: count = %u\n", count));
 1420 
 1421         /* Now do some cleanup and enable multicast handling as needed */
 1422         if (count == 0) {
 1423                 /* Disable all multicast handling */
 1424                 XE_SELECT_PAGE(0x42);
 1425                 XE_OUTB(XE_SWC1, XE_INB(XE_SWC1) &
 1426                     ~(XE_SWC1_IA_ENABLE | XE_SWC1_ALLMULTI));
 1427                 if (scp->mohawk) {
 1428                         XE_SELECT_PAGE(0x02);
 1429                         XE_OUTB(XE_MSR, XE_INB(XE_MSR) & ~XE_MSR_HASH_TABLE);
 1430                 }
 1431         } else if (count < 10) {
 1432                 /*
 1433                  * Full in any unused Individual Addresses with our
 1434                  * MAC address.
 1435                  */
 1436                 for (i = count + 1; i < 10; i++)
 1437                         xe_set_addr(scp, IF_LLADDR(scp->ifp), i);
 1438 
 1439                 /* Enable Individual Address matching only */
 1440                 XE_SELECT_PAGE(0x42);
 1441                 XE_OUTB(XE_SWC1, (XE_INB(XE_SWC1) & ~XE_SWC1_ALLMULTI) |
 1442                     XE_SWC1_IA_ENABLE);
 1443                 if (scp->mohawk) {
 1444                         XE_SELECT_PAGE(0x02);
 1445                         XE_OUTB(XE_MSR, XE_INB(XE_MSR) & ~XE_MSR_HASH_TABLE);
 1446                 }
 1447         } else if (scp->mohawk) {
 1448                 /* Check whether hash table is full */
 1449                 XE_SELECT_PAGE(0x58);
 1450                 for (i = 0x08; i < 0x10; i++)
 1451                         if (XE_INB(i) != 0xff)
 1452                                 break;
 1453                 if (i == 0x10) {
 1454                         /*
 1455                          * Hash table full - enable
 1456                          * promiscuous multicast matching
 1457                          */
 1458                         XE_SELECT_PAGE(0x42);
 1459                         XE_OUTB(XE_SWC1, (XE_INB(XE_SWC1) &
 1460                             ~XE_SWC1_IA_ENABLE) | XE_SWC1_ALLMULTI);
 1461                         XE_SELECT_PAGE(0x02);
 1462                         XE_OUTB(XE_MSR, XE_INB(XE_MSR) & ~XE_MSR_HASH_TABLE);
 1463                 } else {
 1464                         /* Enable hash table and Individual Address matching */
 1465                         XE_SELECT_PAGE(0x42);
 1466                         XE_OUTB(XE_SWC1, (XE_INB(XE_SWC1) & ~XE_SWC1_ALLMULTI) |
 1467                             XE_SWC1_IA_ENABLE);
 1468                         XE_SELECT_PAGE(0x02);
 1469                         XE_OUTB(XE_MSR, XE_INB(XE_MSR) | XE_MSR_HASH_TABLE);
 1470                 }
 1471         } else {
 1472                 /* Enable promiscuous multicast matching */
 1473                 XE_SELECT_PAGE(0x42);
 1474                 XE_OUTB(XE_SWC1, (XE_INB(XE_SWC1) & ~XE_SWC1_IA_ENABLE) |
 1475                     XE_SWC1_ALLMULTI);
 1476         }
 1477 
 1478         XE_SELECT_PAGE(0);
 1479 }
 1480 
 1481 /*
 1482  * Copy the Ethernet multicast address in addr to the on-chip registers for
 1483  * Individual Address idx.  Assumes that addr is really a multicast address
 1484  * and that idx > 0 (slot 0 is always used for the card MAC address).
 1485  */
 1486 static void
 1487 xe_set_addr(struct xe_softc *scp, uint8_t* addr, unsigned idx)
 1488 {
 1489         uint8_t page, reg;
 1490         unsigned i;
 1491 
 1492         /*
 1493          * Individual Addresses are stored in registers 8-F of pages
 1494          * 0x50-0x57.  IA1 therefore starts at register 0xE on page
 1495          * 0x50.  The expressions below compute the starting page and
 1496          * register for any IA index > 0.
 1497          */
 1498         --idx;
 1499         page = 0x50 + idx % 4 + idx / 4 * 3;
 1500         reg = 0x0e - 2 * (idx % 4);
 1501 
 1502         DEVPRINTF(3, (scp->dev,
 1503             "set_addr: idx = %u, page = 0x%02x, reg = 0x%02x\n", idx + 1, page,
 1504             reg));
 1505 
 1506         /*
 1507          * Copy the IA bytes.  Note that the byte order is reversed
 1508          * for Mohawk and Dingo wrt. CE2 hardware.
 1509          */
 1510         XE_SELECT_PAGE(page);
 1511         for (i = 0; i < ETHER_ADDR_LEN; i++) {
 1512                 if (i > 0) {
 1513                         DPRINTF(3, (":%02x", addr[i]));
 1514                 } else {
 1515                         DEVPRINTF(3, (scp->dev, "set_addr: %02x", addr[0]));
 1516                 }
 1517                 XE_OUTB(reg, addr[scp->mohawk ? 5 - i : i]);
 1518                 if (++reg == 0x10) {
 1519                         reg = 0x08;
 1520                         XE_SELECT_PAGE(++page);
 1521                 }
 1522         }
 1523         DPRINTF(3, ("\n"));
 1524 }
 1525 
 1526 /*
 1527  * Set the appropriate bit in the multicast hash table for the supplied
 1528  * Ethernet multicast address addr.  Assumes that addr is really a multicast
 1529  * address.
 1530  */
 1531 static void
 1532 xe_mchash(struct xe_softc* scp, const uint8_t *addr)
 1533 {
 1534         int bit;
 1535         uint8_t byte, hash;
 1536 
 1537         hash = ether_crc32_le(addr, ETHER_ADDR_LEN) & 0x3F;
 1538 
 1539         /*
 1540          * Top 3 bits of hash give register - 8, bottom 3 give bit
 1541          * within register.
 1542          */
 1543         byte = hash >> 3 | 0x08;
 1544         bit = 0x01 << (hash & 0x07);
 1545 
 1546         DEVPRINTF(3, (scp->dev,
 1547             "set_hash: hash = 0x%02x, byte = 0x%02x, bit = 0x%02x\n", hash,
 1548             byte, bit));
 1549 
 1550         XE_SELECT_PAGE(0x58);
 1551         XE_OUTB(byte, XE_INB(byte) | bit);
 1552 }
 1553 
 1554 /*
 1555  * Write an outgoing packet to the card using programmed I/O.
 1556  */
 1557 static int
 1558 xe_pio_write_packet(struct xe_softc *scp, struct mbuf *mbp)
 1559 {
 1560         unsigned len, pad;
 1561         unsigned char wantbyte;
 1562         uint8_t *data;
 1563         uint8_t savebyte[2];
 1564 
 1565         /* Get total packet length */
 1566         if (mbp->m_flags & M_PKTHDR)
 1567                 len = mbp->m_pkthdr.len;
 1568         else {
 1569                 struct mbuf* mbp2 = mbp;
 1570                 for (len = 0; mbp2 != NULL;
 1571                      len += mbp2->m_len, mbp2 = mbp2->m_next);
 1572         }
 1573 
 1574         DEVPRINTF(3, (scp->dev, "pio_write_packet: len = %u\n", len));
 1575 
 1576         /* Packets < minimum length may need to be padded out */
 1577         pad = 0;
 1578         if (len < scp->tx_min) {
 1579                 pad = scp->tx_min - len;
 1580                 len = scp->tx_min;
 1581         }
 1582 
 1583         /* Check transmit buffer space */
 1584         XE_SELECT_PAGE(0);
 1585         XE_OUTW(XE_TRS, len + 2);       /* Only effective on rev. 1 CE2 cards */
 1586         if ((XE_INW(XE_TSO) & 0x7fff) <= len + 2)
 1587                 return (1);
 1588 
 1589         /* Send packet length to card */
 1590         XE_OUTW(XE_EDP, len);
 1591 
 1592         /*
 1593          * Write packet to card using PIO (code stolen from the ed driver)
 1594          */
 1595         wantbyte = 0;
 1596         while (mbp != NULL) {
 1597                 len = mbp->m_len;
 1598                 if (len > 0) {
 1599                         data = mtod(mbp, caddr_t);
 1600                         if (wantbyte) {         /* Finish the last word */
 1601                                 savebyte[1] = *data;
 1602                                 XE_OUTW(XE_EDP, *(u_short *)savebyte);
 1603                                 data++;
 1604                                 len--;
 1605                                 wantbyte = 0;
 1606                         }
 1607                         if (len > 1) {          /* Output contiguous words */
 1608                                 bus_write_multi_2(scp->port_res, XE_EDP,
 1609                                     (uint16_t *)data, len >> 1);
 1610                                 data += len & ~1;
 1611                                 len &= 1;
 1612                         }
 1613                         if (len == 1) {         /* Save last byte, if needed */
 1614                                 savebyte[0] = *data;
 1615                                 wantbyte = 1;
 1616                         }
 1617                 }
 1618                 mbp = mbp->m_next;
 1619         }
 1620 
 1621         /*
 1622          * Send last byte of odd-length packets
 1623          */
 1624         if (wantbyte)
 1625                 XE_OUTB(XE_EDP, savebyte[0]);
 1626 
 1627         /*
 1628          * Can just tell CE3 cards to send; short packets will be
 1629          * padded out with random cruft automatically.  For CE2,
 1630          * manually pad the packet with garbage; it will be sent when
 1631          * the required number of bytes have been delivered to the
 1632          * card.
 1633          */
 1634         if (scp->mohawk)
 1635                 XE_OUTB(XE_CR, XE_CR_TX_PACKET | XE_CR_RESTART_TX |
 1636                     XE_CR_ENABLE_INTR);
 1637         else if (pad > 0) {
 1638                 if (pad & 0x01)
 1639                         XE_OUTB(XE_EDP, 0xaa);
 1640                 pad >>= 1;
 1641                 while (pad > 0) {
 1642                         XE_OUTW(XE_EDP, 0xdead);
 1643                         pad--;
 1644                 }
 1645         }
 1646 
 1647         return (0);
 1648 }
 1649 
 1650 /**************************************************************
 1651  *                                                            *
 1652  *                  M I I  F U N C T I O N S                  *
 1653  *                                                            *
 1654  **************************************************************/
 1655 
 1656 /*
 1657  * Alternative MII/PHY handling code adapted from the xl driver.  It doesn't
 1658  * seem to work any better than the xirc2_ps stuff, but it's cleaner code.
 1659  * XXX - this stuff shouldn't be here.  It should all be abstracted off to
 1660  * XXX - some kind of common MII-handling code, shared by all drivers.  But
 1661  * XXX - that's a whole other mission.
 1662  */
 1663 #define XE_MII_SET(x)   XE_OUTB(XE_GPR2, (XE_INB(XE_GPR2) | 0x04) | (x))
 1664 #define XE_MII_CLR(x)   XE_OUTB(XE_GPR2, (XE_INB(XE_GPR2) | 0x04) & ~(x))
 1665 
 1666 /*
 1667  * Sync the PHYs by setting data bit and strobing the clock 32 times.
 1668  */
 1669 static void
 1670 xe_mii_sync(struct xe_softc *scp)
 1671 {
 1672         int i;
 1673 
 1674         XE_SELECT_PAGE(2);
 1675         XE_MII_SET(XE_MII_DIR|XE_MII_WRD);
 1676 
 1677         for (i = 0; i < 32; i++) {
 1678                 XE_MII_SET(XE_MII_CLK);
 1679                 DELAY(1);
 1680                 XE_MII_CLR(XE_MII_CLK);
 1681                 DELAY(1);
 1682         }
 1683 }
 1684 
 1685 /*
 1686  * Look for a MII-compliant PHY.  If we find one, reset it.
 1687  */
 1688 static int
 1689 xe_mii_init(struct xe_softc *scp)
 1690 {
 1691         uint16_t status;
 1692 
 1693         status = xe_phy_readreg(scp, PHY_BMSR);
 1694         if ((status & 0xff00) != 0x7800) {
 1695                 DEVPRINTF(2, (scp->dev, "no PHY found, %0x\n", status));
 1696                 return (0);
 1697         } else {
 1698                 DEVPRINTF(2, (scp->dev, "PHY OK!\n"));
 1699 
 1700                 /* Reset the PHY */
 1701                 xe_phy_writereg(scp, PHY_BMCR, PHY_BMCR_RESET);
 1702                 DELAY(500);
 1703                 while(xe_phy_readreg(scp, PHY_BMCR) & PHY_BMCR_RESET)
 1704                         ;       /* nothing */
 1705                 XE_MII_DUMP(scp);
 1706                 return (1);
 1707         }
 1708 }
 1709 
 1710 /*
 1711  * Clock a series of bits through the MII.
 1712  */
 1713 static void
 1714 xe_mii_send(struct xe_softc *scp, uint32_t bits, int cnt)
 1715 {
 1716         int i;
 1717 
 1718         XE_SELECT_PAGE(2);
 1719         XE_MII_CLR(XE_MII_CLK);
 1720   
 1721         for (i = (0x1 << (cnt - 1)); i; i >>= 1) {
 1722                 if (bits & i) {
 1723                         XE_MII_SET(XE_MII_WRD);
 1724                 } else {
 1725                         XE_MII_CLR(XE_MII_WRD);
 1726                 }
 1727                 DELAY(1);
 1728                 XE_MII_CLR(XE_MII_CLK);
 1729                 DELAY(1);
 1730                 XE_MII_SET(XE_MII_CLK);
 1731         }
 1732 }
 1733 
 1734 /*
 1735  * Read an PHY register through the MII.
 1736  */
 1737 static int
 1738 xe_mii_readreg(struct xe_softc *scp, struct xe_mii_frame *frame)
 1739 {
 1740         int i, ack;
 1741 
 1742         XE_ASSERT_LOCKED(scp);
 1743 
 1744         /*
 1745          * Set up frame for RX.
 1746          */
 1747         frame->mii_stdelim = XE_MII_STARTDELIM;
 1748         frame->mii_opcode = XE_MII_READOP;
 1749         frame->mii_turnaround = 0;
 1750         frame->mii_data = 0;
 1751         
 1752         XE_SELECT_PAGE(2);
 1753         XE_OUTB(XE_GPR2, 0);
 1754 
 1755         /*
 1756          * Turn on data xmit.
 1757          */
 1758         XE_MII_SET(XE_MII_DIR);
 1759 
 1760         xe_mii_sync(scp);
 1761 
 1762         /*      
 1763          * Send command/address info.
 1764          */
 1765         xe_mii_send(scp, frame->mii_stdelim, 2);
 1766         xe_mii_send(scp, frame->mii_opcode, 2);
 1767         xe_mii_send(scp, frame->mii_phyaddr, 5);
 1768         xe_mii_send(scp, frame->mii_regaddr, 5);
 1769 
 1770         /* Idle bit */
 1771         XE_MII_CLR((XE_MII_CLK|XE_MII_WRD));
 1772         DELAY(1);
 1773         XE_MII_SET(XE_MII_CLK);
 1774         DELAY(1);
 1775 
 1776         /* Turn off xmit. */
 1777         XE_MII_CLR(XE_MII_DIR);
 1778 
 1779         /* Check for ack */
 1780         XE_MII_CLR(XE_MII_CLK);
 1781         DELAY(1);
 1782         ack = XE_INB(XE_GPR2) & XE_MII_RDD;
 1783         XE_MII_SET(XE_MII_CLK);
 1784         DELAY(1);
 1785 
 1786         /*
 1787          * Now try reading data bits. If the ack failed, we still
 1788          * need to clock through 16 cycles to keep the PHY(s) in sync.
 1789          */
 1790         if (ack) {
 1791                 for(i = 0; i < 16; i++) {
 1792                         XE_MII_CLR(XE_MII_CLK);
 1793                         DELAY(1);
 1794                         XE_MII_SET(XE_MII_CLK);
 1795                         DELAY(1);
 1796                 }
 1797                 goto fail;
 1798         }
 1799 
 1800         for (i = 0x8000; i; i >>= 1) {
 1801                 XE_MII_CLR(XE_MII_CLK);
 1802                 DELAY(1);
 1803                 if (!ack) {
 1804                         if (XE_INB(XE_GPR2) & XE_MII_RDD)
 1805                                 frame->mii_data |= i;
 1806                         DELAY(1);
 1807                 }
 1808                 XE_MII_SET(XE_MII_CLK);
 1809                 DELAY(1);
 1810         }
 1811 
 1812 fail:
 1813         XE_MII_CLR(XE_MII_CLK);
 1814         DELAY(1);
 1815         XE_MII_SET(XE_MII_CLK);
 1816         DELAY(1);
 1817 
 1818         if (ack)
 1819                 return(1);
 1820         return(0);
 1821 }
 1822 
 1823 /*
 1824  * Write to a PHY register through the MII.
 1825  */
 1826 static int
 1827 xe_mii_writereg(struct xe_softc *scp, struct xe_mii_frame *frame)
 1828 {
 1829 
 1830         XE_ASSERT_LOCKED(scp);
 1831 
 1832         /*
 1833          * Set up frame for TX.
 1834          */
 1835         frame->mii_stdelim = XE_MII_STARTDELIM;
 1836         frame->mii_opcode = XE_MII_WRITEOP;
 1837         frame->mii_turnaround = XE_MII_TURNAROUND;
 1838         
 1839         XE_SELECT_PAGE(2);
 1840 
 1841         /*              
 1842          * Turn on data output.
 1843          */
 1844         XE_MII_SET(XE_MII_DIR);
 1845 
 1846         xe_mii_sync(scp);
 1847 
 1848         xe_mii_send(scp, frame->mii_stdelim, 2);
 1849         xe_mii_send(scp, frame->mii_opcode, 2);
 1850         xe_mii_send(scp, frame->mii_phyaddr, 5);
 1851         xe_mii_send(scp, frame->mii_regaddr, 5);
 1852         xe_mii_send(scp, frame->mii_turnaround, 2);
 1853         xe_mii_send(scp, frame->mii_data, 16);
 1854 
 1855         /* Idle bit. */
 1856         XE_MII_SET(XE_MII_CLK);
 1857         DELAY(1);
 1858         XE_MII_CLR(XE_MII_CLK);
 1859         DELAY(1);
 1860 
 1861         /*
 1862          * Turn off xmit.
 1863          */
 1864         XE_MII_CLR(XE_MII_DIR);
 1865 
 1866         return(0);
 1867 }
 1868 
 1869 /*
 1870  * Read a register from the PHY.
 1871  */
 1872 static uint16_t
 1873 xe_phy_readreg(struct xe_softc *scp, uint16_t reg)
 1874 {
 1875         struct xe_mii_frame frame;
 1876 
 1877         bzero((char *)&frame, sizeof(frame));
 1878 
 1879         frame.mii_phyaddr = 0;
 1880         frame.mii_regaddr = reg;
 1881         xe_mii_readreg(scp, &frame);
 1882 
 1883         return (frame.mii_data);
 1884 }
 1885 
 1886 /*
 1887  * Write to a PHY register.
 1888  */
 1889 static void
 1890 xe_phy_writereg(struct xe_softc *scp, uint16_t reg, uint16_t data)
 1891 {
 1892         struct xe_mii_frame frame;
 1893 
 1894         bzero((char *)&frame, sizeof(frame));
 1895 
 1896         frame.mii_phyaddr = 0;
 1897         frame.mii_regaddr = reg;
 1898         frame.mii_data = data;
 1899         xe_mii_writereg(scp, &frame);
 1900 }
 1901 
 1902 /*
 1903  * A bit of debugging code.
 1904  */
 1905 static void
 1906 xe_mii_dump(struct xe_softc *scp)
 1907 {
 1908         int i;
 1909 
 1910         device_printf(scp->dev, "MII registers: ");
 1911         for (i = 0; i < 2; i++) {
 1912                 printf(" %d:%04x", i, xe_phy_readreg(scp, i));
 1913         }
 1914         for (i = 4; i < 7; i++) {
 1915                 printf(" %d:%04x", i, xe_phy_readreg(scp, i));
 1916         }
 1917         printf("\n");
 1918 }
 1919 
 1920 #if 0
 1921 void
 1922 xe_reg_dump(struct xe_softc *scp)
 1923 {
 1924         int page, i;
 1925 
 1926         device_printf(scp->dev, "Common registers: ");
 1927         for (i = 0; i < 8; i++) {
 1928                 printf(" %2.2x", XE_INB(i));
 1929         }
 1930         printf("\n");
 1931 
 1932         for (page = 0; page <= 8; page++) {
 1933                 device_printf(scp->dev, "Register page %2.2x: ", page);
 1934                 XE_SELECT_PAGE(page);
 1935                 for (i = 8; i < 16; i++) {
 1936                         printf(" %2.2x", XE_INB(i));
 1937                 }
 1938                 printf("\n");
 1939         }
 1940 
 1941         for (page = 0x10; page < 0x5f; page++) {
 1942                 if ((page >= 0x11 && page <= 0x3f) ||
 1943                     (page == 0x41) ||
 1944                     (page >= 0x43 && page <= 0x4f) ||
 1945                     (page >= 0x59))
 1946                         continue;
 1947                 device_printf(scp->dev, "Register page %2.2x: ", page);
 1948                 XE_SELECT_PAGE(page);
 1949                 for (i = 8; i < 16; i++) {
 1950                         printf(" %2.2x", XE_INB(i));
 1951                 }
 1952                 printf("\n");
 1953         }
 1954 }
 1955 #endif
 1956 
 1957 int
 1958 xe_activate(device_t dev)
 1959 {
 1960         struct xe_softc *sc = device_get_softc(dev);
 1961         int start, i;
 1962 
 1963         DEVPRINTF(2, (dev, "activate\n"));
 1964 
 1965         if (!sc->modem) {
 1966                 sc->port_rid = 0;       /* 0 is managed by pccard */
 1967                 sc->port_res = bus_alloc_resource_anywhere(dev, SYS_RES_IOPORT,
 1968                     &sc->port_rid, 16, RF_ACTIVE);
 1969         } else if (sc->dingo) {
 1970                 /*
 1971                  * Find a 16 byte aligned ioport for the card.
 1972                  */
 1973                 DEVPRINTF(1, (dev, "Finding an aligned port for RealPort\n"));
 1974                 sc->port_rid = 1;       /* 0 is managed by pccard */
 1975                 start = 0x100;
 1976                 do {
 1977                         sc->port_res = bus_alloc_resource(dev, SYS_RES_IOPORT,
 1978                             &sc->port_rid, start, 0x3ff, 16, RF_ACTIVE);
 1979                         if (sc->port_res == NULL)
 1980                                 break;
 1981                         if ((rman_get_start(sc->port_res) & 0xf) == 0)
 1982                                 break;
 1983                         bus_release_resource(dev, SYS_RES_IOPORT, sc->port_rid, 
 1984                             sc->port_res);
 1985                         start = (rman_get_start(sc->port_res) + 15) & ~0xf;
 1986                 } while (1);
 1987                 DEVPRINTF(1, (dev, "RealPort port 0x%0jx, size 0x%0jx\n",
 1988                     bus_get_resource_start(dev, SYS_RES_IOPORT, sc->port_rid),
 1989                     bus_get_resource_count(dev, SYS_RES_IOPORT, sc->port_rid)));
 1990         } else if (sc->ce2) {
 1991                 /*
 1992                  * Find contiguous I/O port for the Ethernet function
 1993                  * on CEM2 and CEM3 cards.  We allocate window 0
 1994                  * wherever pccard has decided it should be, then find
 1995                  * an available window adjacent to it for the second
 1996                  * function.  Not sure that both windows are actually
 1997                  * needed.
 1998                  */
 1999                 DEVPRINTF(1, (dev, "Finding I/O port for CEM2/CEM3\n"));
 2000                 sc->ce2_port_rid = 0;   /* 0 is managed by pccard */
 2001                 sc->ce2_port_res = bus_alloc_resource_anywhere(dev,
 2002                     SYS_RES_IOPORT, &sc->ce2_port_rid, 8, RF_ACTIVE);
 2003                 if (sc->ce2_port_res == NULL) {
 2004                         DEVPRINTF(1, (dev,
 2005                             "Cannot allocate I/O port for modem\n"));
 2006                         xe_deactivate(dev);
 2007                         return (ENOMEM);
 2008                 }
 2009 
 2010                 sc->port_rid = 1;
 2011                 start = bus_get_resource_start(dev, SYS_RES_IOPORT,
 2012                     sc->ce2_port_rid);
 2013                 for (i = 0; i < 2; i++) {
 2014                         start += (i == 0 ? 8 : -24);
 2015                         sc->port_res = bus_alloc_resource(dev, SYS_RES_IOPORT,
 2016                             &sc->port_rid, start, start + 15, 16, RF_ACTIVE);
 2017                         if (sc->port_res == NULL)
 2018                                 continue;
 2019                         if (bus_get_resource_start(dev, SYS_RES_IOPORT,
 2020                             sc->port_rid) == start)
 2021                                 break;
 2022 
 2023                         bus_release_resource(dev, SYS_RES_IOPORT, sc->port_rid,
 2024                             sc->port_res);
 2025                         sc->port_res = NULL;
 2026                 }
 2027                 DEVPRINTF(1, (dev, "CEM2/CEM3 port 0x%0jx, size 0x%0jx\n",
 2028                     bus_get_resource_start(dev, SYS_RES_IOPORT, sc->port_rid),
 2029                     bus_get_resource_count(dev, SYS_RES_IOPORT, sc->port_rid)));
 2030         }
 2031 
 2032         if (!sc->port_res) {
 2033                 DEVPRINTF(1, (dev, "Cannot allocate ioport\n"));
 2034                 xe_deactivate(dev);
 2035                 return (ENOMEM);
 2036         }
 2037 
 2038         sc->irq_rid = 0;
 2039         sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irq_rid, 
 2040             RF_ACTIVE);
 2041         if (sc->irq_res == NULL) {
 2042                 DEVPRINTF(1, (dev, "Cannot allocate irq\n"));
 2043                 xe_deactivate(dev);
 2044                 return (ENOMEM);
 2045         }
 2046 
 2047         return (0);
 2048 }
 2049 
 2050 void
 2051 xe_deactivate(device_t dev)
 2052 {
 2053         struct xe_softc *sc = device_get_softc(dev);
 2054         
 2055         DEVPRINTF(2, (dev, "deactivate\n"));
 2056         if (sc->intrhand)
 2057                 bus_teardown_intr(dev, sc->irq_res, sc->intrhand);
 2058         sc->intrhand = NULL;
 2059         if (sc->port_res)
 2060                 bus_release_resource(dev, SYS_RES_IOPORT, sc->port_rid, 
 2061                     sc->port_res);
 2062         sc->port_res = NULL;
 2063         if (sc->ce2_port_res)
 2064             bus_release_resource(dev, SYS_RES_IOPORT, sc->ce2_port_rid,
 2065                 sc->ce2_port_res);
 2066         sc->ce2_port_res = NULL;
 2067         if (sc->irq_res)
 2068                 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, 
 2069                     sc->irq_res);
 2070         sc->irq_res = NULL;
 2071         if (sc->ifp)
 2072                 if_free(sc->ifp);
 2073         sc->ifp = NULL;
 2074 }

Cache object: 867395db383a61a42a11c5be67a2032a


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.