sys/dev/xe/if_xe.c

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