sys/dev/xe/if_xe.c

   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$");
  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/mbuf.h>
 100 #include <sys/socket.h>
 101 #include <sys/sockio.h>
 102 #include <sys/systm.h>
 103 #include <sys/uio.h>
 104 #include <sys/sysctl.h>
 105
 106 #include <sys/module.h>
 107 #include <sys/bus.h>
 108
 109 #include <machine/bus.h>
 110 #include <machine/resource.h>
 111 #include <sys/rman.h>
 112
 113 #include <net/ethernet.h>
 114 #include <net/if.h>
 115 #include <net/if_var.h>
 116 #include <net/if_arp.h>
 117 #include <net/if_dl.h>
 118 #include <net/if_media.h>
 119 #include <net/if_mib.h>
 120 #include <net/bpf.h>
 121 #include <net/if_types.h>
 122
 123 #include <dev/xe/if_xereg.h>
 124 #include <dev/xe/if_xevar.h>
 125
 126 /*
 127  * MII command structure
 128  */
 129 struct xe_mii_frame {
 130         uint8_t         mii_stdelim;
 131         uint8_t         mii_opcode;
 132         uint8_t         mii_phyaddr;
 133         uint8_t         mii_regaddr;
 134         uint8_t         mii_turnaround;
 135         uint16_t        mii_data;
 136 };
 137
 138 /*
 139  * Media autonegotiation progress constants
 140  */
 141 #define XE_AUTONEG_NONE         0       /* No autonegotiation in progress */
 142 #define XE_AUTONEG_WAITING      1       /* Waiting for transmitter to go idle */
 143 #define XE_AUTONEG_STARTED      2       /* Waiting for autonegotiation to complete */
 144 #define XE_AUTONEG_100TX        3       /* Trying to force 100baseTX link */
 145 #define XE_AUTONEG_FAIL         4       /* Autonegotiation failed */
 146
 147 /*
 148  * Prototypes start here
 149  */
 150 static void     xe_init(void *xscp);
 151 static void     xe_init_locked(struct xe_softc *scp);
 152 static void     xe_start(struct ifnet *ifp);
 153 static void     xe_start_locked(struct ifnet *ifp);
 154 static int      xe_ioctl(struct ifnet *ifp, u_long command, caddr_t data);
 155 static void     xe_watchdog(void *arg);
 156 static void     xe_intr(void *xscp);
 157 static void     xe_txintr(struct xe_softc *scp, uint8_t txst1);
 158 static void     xe_macintr(struct xe_softc *scp, uint8_t rst0, uint8_t txst0,
 159                     uint8_t txst1);
 160 static void     xe_rxintr(struct xe_softc *scp, uint8_t rst0);
 161 static int      xe_media_change(struct ifnet *ifp);
 162 static void     xe_media_status(struct ifnet *ifp, struct ifmediareq *mrp);
 163 static void     xe_setmedia(void *arg);
 164 static void     xe_reset(struct xe_softc *scp);
 165 static void     xe_enable_intr(struct xe_softc *scp);
 166 static void     xe_disable_intr(struct xe_softc *scp);
 167 static void     xe_set_multicast(struct xe_softc *scp);
 168 static void     xe_set_addr(struct xe_softc *scp, uint8_t* addr, unsigned idx);
 169 static void     xe_mchash(struct xe_softc *scp, const uint8_t *addr);
 170 static int      xe_pio_write_packet(struct xe_softc *scp, struct mbuf *mbp);
 171
 172 /*
 173  * MII functions
 174  */
 175 static void     xe_mii_sync(struct xe_softc *scp);
 176 static int      xe_mii_init(struct xe_softc *scp);
 177 static void     xe_mii_send(struct xe_softc *scp, uint32_t bits, int cnt);
 178 static int      xe_mii_readreg(struct xe_softc *scp,
 179                     struct xe_mii_frame *frame);
 180 static int      xe_mii_writereg(struct xe_softc *scp,
 181                     struct xe_mii_frame *frame);
 182 static uint16_t xe_phy_readreg(struct xe_softc *scp, uint16_t reg);
 183 static void     xe_phy_writereg(struct xe_softc *scp, uint16_t reg,
 184                     uint16_t data);
 185
 186 /*
 187  * Debugging functions
 188  */
 189 static void     xe_mii_dump(struct xe_softc *scp);
 190 #if 0
 191 static void     xe_reg_dump(struct xe_softc *scp);
 192 #endif
 193
 194 /*
 195  * Debug logging levels - set with hw.xe.debug sysctl
 196  * 0 = None
 197  * 1 = More hardware details, probe/attach progress
 198  * 2 = Most function calls, ioctls and media selection progress
 199  * 3 = Everything - interrupts, packets in/out and multicast address setup
 200  */
 201 #define XE_DEBUG
 202 #ifdef XE_DEBUG
 203
 204 /* sysctl vars */
 205 static SYSCTL_NODE(_hw, OID_AUTO, xe, CTLFLAG_RD, 0, "if_xe parameters");
 206
 207 int xe_debug = 0;
 208 SYSCTL_INT(_hw_xe, OID_AUTO, debug, CTLFLAG_RW, &xe_debug, 0,
 209     "if_xe debug level");
 210
 211 #define DEVPRINTF(level, arg)   if (xe_debug >= (level)) device_printf arg
 212 #define DPRINTF(level, arg)     if (xe_debug >= (level)) printf arg
 213 #define XE_MII_DUMP(scp)        if (xe_debug >= 3) xe_mii_dump(scp)
 214 #if 0
 215 #define XE_REG_DUMP(scp)        if (xe_debug >= 3) xe_reg_dump(scp)
 216 #endif
 217 #else
 218 #define DEVPRINTF(level, arg)
 219 #define DPRINTF(level, arg)
 220 #define XE_MII_DUMP(scp)
 221 #if 0
 222 #define XE_REG_DUMP(scp)
 223 #endif
 224 #endif
 225
 226 /*
 227  * Attach a device.
 228  */
 229 int
 230 xe_attach(device_t dev)
 231 {
 232         struct xe_softc *scp = device_get_softc(dev);
 233         int err;
 234
 235         DEVPRINTF(2, (dev, "attach\n"));
 236
 237         /* Initialise stuff... */
 238         scp->dev = dev;
 239         scp->ifp = if_alloc(IFT_ETHER);
 240         if (scp->ifp == NULL)
 241                 return (ENOSPC);
 242         scp->ifm = &scp->ifmedia;
 243         scp->autoneg_status = XE_AUTONEG_NONE;
 244         mtx_init(&scp->lock, device_get_nameunit(dev), MTX_NETWORK_LOCK,
 245             MTX_DEF);
 246         callout_init_mtx(&scp->wdog_timer, &scp->lock, 0);
 247
 248         /* Initialise the ifnet structure */
 249         scp->ifp->if_softc = scp;
 250         if_initname(scp->ifp, device_get_name(dev), device_get_unit(dev));
 251         scp->ifp->if_flags = (IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
 252         scp->ifp->if_linkmib = &scp->mibdata;
 253         scp->ifp->if_linkmiblen = sizeof(scp->mibdata);
 254         scp->ifp->if_start = xe_start;
 255         scp->ifp->if_ioctl = xe_ioctl;
 256         scp->ifp->if_init = xe_init;
 257         scp->ifp->if_baudrate = 100000000;
 258         IFQ_SET_MAXLEN(&scp->ifp->if_snd, ifqmaxlen);
 259
 260         /* Initialise the ifmedia structure */
 261         ifmedia_init(scp->ifm, 0, xe_media_change, xe_media_status);
 262         callout_init_mtx(&scp->media_timer, &scp->lock, 0);
 263
 264         /* Add supported media types */
 265         if (scp->mohawk) {
 266                 ifmedia_add(scp->ifm, IFM_ETHER|IFM_100_TX, 0, NULL);
 267                 ifmedia_add(scp->ifm, IFM_ETHER|IFM_10_T|IFM_FDX, 0, NULL);
 268                 ifmedia_add(scp->ifm, IFM_ETHER|IFM_10_T|IFM_HDX, 0, NULL);
 269         }
 270         ifmedia_add(scp->ifm, IFM_ETHER|IFM_10_T, 0, NULL);
 271         if (scp->ce2)
 272                 ifmedia_add(scp->ifm, IFM_ETHER|IFM_10_2, 0, NULL);
 273         ifmedia_add(scp->ifm, IFM_ETHER|IFM_AUTO, 0, NULL);
 274
 275         /* Default is to autoselect best supported media type */
 276         ifmedia_set(scp->ifm, IFM_ETHER|IFM_AUTO);
 277
 278         /* Get the hardware into a known state */
 279         XE_LOCK(scp);
 280         xe_reset(scp);
 281         XE_UNLOCK(scp);
 282
 283         /* Get hardware version numbers */
 284         XE_SELECT_PAGE(4);
 285         scp->version = XE_INB(XE_BOV);
 286         if (scp->mohawk)
 287                 scp->srev = (XE_INB(XE_BOV) & 0x70) >> 4;
 288         else
 289                 scp->srev = (XE_INB(XE_BOV) & 0x30) >> 4;
 290
 291         /* Print some useful information */
 292         device_printf(dev, "version 0x%02x/0x%02x%s%s\n", scp->version,
 293             scp->srev, scp->mohawk ? ", 100Mbps capable" : "",
 294             scp->modem ?  ", with modem" : "");
 295         if (scp->mohawk) {
 296                 XE_SELECT_PAGE(0x10);
 297                 DEVPRINTF(1, (dev,
 298                     "DingoID=0x%04x, RevisionID=0x%04x, VendorID=0x%04x\n",
 299                     XE_INW(XE_DINGOID), XE_INW(XE_RevID), XE_INW(XE_VendorID)));
 300         }
 301         if (scp->ce2) {
 302                 XE_SELECT_PAGE(0x45);
 303                 DEVPRINTF(1, (dev, "CE2 version = 0x%02x\n", XE_INB(XE_REV)));
 304         }
 305
 306         /* Attach the interface */
 307         ether_ifattach(scp->ifp, scp->enaddr);
 308
 309         err = bus_setup_intr(dev, scp->irq_res, INTR_TYPE_NET | INTR_MPSAFE,
 310             NULL, xe_intr, scp, &scp->intrhand);
 311         if (err) {
 312                 ether_ifdetach(scp->ifp);
 313                 mtx_destroy(&scp->lock);
 314                 return (err);
 315         }
 316
 317         /* Done */
 318         return (0);
 319 }
 320
 321 /*
 322  * Complete hardware intitialisation and enable output.  Exits without doing
 323  * anything if there's no address assigned to the card, or if media selection
 324  * is in progress (the latter implies we've already run this function).
 325  */
 326 static void
 327 xe_init(void *xscp)
 328 {
 329         struct xe_softc *scp = xscp;
 330
 331         XE_LOCK(scp);
 332         xe_init_locked(scp);
 333         XE_UNLOCK(scp);
 334 }
 335
 336 static void
 337 xe_init_locked(struct xe_softc *scp)
 338 {
 339         unsigned i;
 340
 341         if (scp->autoneg_status != XE_AUTONEG_NONE)
 342                 return;
 343
 344         DEVPRINTF(2, (scp->dev, "init\n"));
 345
 346         /* Reset transmitter flags */
 347         scp->tx_queued = 0;
 348         scp->tx_tpr = 0;
 349         scp->tx_timeouts = 0;
 350         scp->tx_thres = 64;
 351         scp->tx_min = ETHER_MIN_LEN - ETHER_CRC_LEN;
 352         scp->tx_timeout = 0;
 353
 354         /* Soft reset the card */
 355         XE_SELECT_PAGE(0);
 356         XE_OUTB(XE_CR, XE_CR_SOFT_RESET);
 357         DELAY(40000);
 358         XE_OUTB(XE_CR, 0);
 359         DELAY(40000);
 360
 361         if (scp->mohawk) {
 362                 /*
 363                  * set GP1 and GP2 as outputs (bits 2 & 3)
 364                  * set GP1 low to power on the ML6692 (bit 0)
 365                  * set GP2 high to power on the 10Mhz chip (bit 1)
 366                  */
 367                 XE_SELECT_PAGE(4);
 368                 XE_OUTB(XE_GPR0, XE_GPR0_GP2_SELECT | XE_GPR0_GP1_SELECT |
 369                     XE_GPR0_GP2_OUT);
 370         }
 371
 372         /* Shut off interrupts */
 373         xe_disable_intr(scp);
 374
 375         /* Wait for everything to wake up */
 376         DELAY(500000);
 377
 378         /* Check for PHY */
 379         if (scp->mohawk)
 380                 scp->phy_ok = xe_mii_init(scp);
 381
 382         /* Disable 'source insertion' (not sure what that means) */
 383         XE_SELECT_PAGE(0x42);
 384         XE_OUTB(XE_SWC0, XE_SWC0_NO_SRC_INSERT);
 385
 386         /* Set 8K/24K Tx/Rx buffer split */
 387         if (scp->srev != 1) {
 388                 XE_SELECT_PAGE(2);
 389                 XE_OUTW(XE_RBS, 0x2000);
 390         }
 391
 392         /* Enable early transmit mode on Mohawk/Dingo */
 393         if (scp->mohawk) {
 394                 XE_SELECT_PAGE(0x03);
 395                 XE_OUTW(XE_TPT, scp->tx_thres);
 396                 XE_SELECT_PAGE(0x01);
 397                 XE_OUTB(XE_ECR, XE_INB(XE_ECR) | XE_ECR_EARLY_TX);
 398         }
 399
 400         /* Put MAC address in first 'individual address' register */
 401         XE_SELECT_PAGE(0x50);
 402         for (i = 0; i < ETHER_ADDR_LEN; i++)
 403                 XE_OUTB(0x08 + i, IF_LLADDR(scp->ifp)[scp->mohawk ? 5 - i : i]);
 404
 405         /* Set up multicast addresses */
 406         xe_set_multicast(scp);
 407
 408         /* Fix the receive data offset -- reset can leave it off-by-one */
 409         XE_SELECT_PAGE(0);
 410         XE_OUTW(XE_DO, 0x2000);
 411
 412         /* Set interrupt masks */
 413         XE_SELECT_PAGE(1);
 414         XE_OUTB(XE_IMR0, XE_IMR0_TX_PACKET | XE_IMR0_MAC_INTR |
 415             XE_IMR0_RX_PACKET);
 416
 417         /* Set MAC interrupt masks */
 418         XE_SELECT_PAGE(0x40);
 419         XE_OUTB(XE_RX0Msk,
 420             ~(XE_RX0M_RX_OVERRUN | XE_RX0M_CRC_ERROR | XE_RX0M_ALIGN_ERROR |
 421             XE_RX0M_LONG_PACKET));
 422         XE_OUTB(XE_TX0Msk,
 423             ~(XE_TX0M_SQE_FAIL | XE_TX0M_LATE_COLLISION | XE_TX0M_TX_UNDERRUN |
 424             XE_TX0M_16_COLLISIONS | XE_TX0M_NO_CARRIER));
 425
 426         /* Clear MAC status registers */
 427         XE_SELECT_PAGE(0x40);
 428         XE_OUTB(XE_RST0, 0x00);
 429         XE_OUTB(XE_TXST0, 0x00);
 430
 431         /* Enable receiver and put MAC online */
 432         XE_SELECT_PAGE(0x40);
 433         XE_OUTB(XE_CMD0, XE_CMD0_RX_ENABLE|XE_CMD0_ONLINE);
 434
 435         /* Set up IMR, enable interrupts */
 436         xe_enable_intr(scp);
 437
 438         /* Start media selection */
 439         xe_setmedia(scp);
 440
 441         /* Enable output */
 442         scp->ifp->if_drv_flags |= IFF_DRV_RUNNING;
 443         scp->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 444         callout_reset(&scp->wdog_timer, hz, xe_watchdog, scp);
 445 }
 446
 447 /*
 448  * Start output on interface.  Should be called at splimp() priority.  Check
 449  * that the output is idle (ie, IFF_DRV_OACTIVE is not set) before calling this
 450  * function.  If media selection is in progress we set IFF_DRV_OACTIVE ourselves
 451  * and return immediately.
 452  */
 453 static void
 454 xe_start(struct ifnet *ifp)
 455 {
 456         struct xe_softc *scp = ifp->if_softc;
 457
 458         XE_LOCK(scp);
 459         xe_start_locked(ifp);
 460         XE_UNLOCK(scp);
 461 }
 462
 463 static void
 464 xe_start_locked(struct ifnet *ifp)
 465 {
 466         struct xe_softc *scp = ifp->if_softc;
 467         struct mbuf *mbp;
 468
 469         if (scp->autoneg_status != XE_AUTONEG_NONE) {
 470                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 471                 return;
 472         }
 473
 474         DEVPRINTF(3, (scp->dev, "start\n"));
 475
 476         /*
 477          * Loop while there are packets to be sent, and space to send
 478          * them.
 479          */
 480         for (;;) {
 481                 /* Suck a packet off the send queue */
 482                 IF_DEQUEUE(&ifp->if_snd, mbp);
 483
 484                 if (mbp == NULL) {
 485                         /*
 486                          * We are using the !OACTIVE flag to indicate
 487                          * to the outside world that we can accept an
 488                          * additional packet rather than that the
 489                          * transmitter is _actually_ active. Indeed,
 490                          * the transmitter may be active, but if we
 491                          * haven't filled all the buffers with data
 492                          * then we still want to accept more.
 493                          */
 494                         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 495                         return;
 496                 }
 497
 498                 if (xe_pio_write_packet(scp, mbp) != 0) {
 499                         /* Push the packet back onto the queue */
 500                         IF_PREPEND(&ifp->if_snd, mbp);
 501                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 502                         return;
 503                 }
 504
 505                 /* Tap off here if there is a bpf listener */
 506                 BPF_MTAP(ifp, mbp);
 507
 508                 /* In case we don't hear from the card again... */
 509                 scp->tx_timeout = 5;
 510                 scp->tx_queued++;
 511
 512                 m_freem(mbp);
 513         }
 514 }
 515
 516 /*
 517  * Process an ioctl request.  Adapted from the ed driver.
 518  */
 519 static int
 520 xe_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 521 {
 522         struct xe_softc *scp;
 523         int error;
 524
 525         scp = ifp->if_softc;
 526         error = 0;
 527
 528         switch (command) {
 529         case SIOCSIFFLAGS:
 530                 DEVPRINTF(2, (scp->dev, "ioctl: SIOCSIFFLAGS: 0x%04x\n",
 531                         ifp->if_flags));
 532                 /*
 533                  * If the interface is marked up and stopped, then
 534                  * start it.  If it is marked down and running, then
 535                  * stop it.
 536                  */
 537                 XE_LOCK(scp);
 538                 if (ifp->if_flags & IFF_UP) {
 539                         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
 540                                 xe_reset(scp);
 541                                 xe_init_locked(scp);
 542                         }
 543                 } else {
 544                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 545                                 xe_stop(scp);
 546                 }
 547
 548                 /* handle changes to PROMISC/ALLMULTI flags */
 549                 xe_set_multicast(scp);
 550                 XE_UNLOCK(scp);
 551                 error = 0;
 552                 break;
 553         case SIOCADDMULTI:
 554         case SIOCDELMULTI:
 555                 DEVPRINTF(2, (scp->dev, "ioctl: SIOC{ADD,DEL}MULTI\n"));
 556                 /*
 557                  * Multicast list has (maybe) changed; set the
 558                  * hardware filters accordingly.
 559                  */
 560                 XE_LOCK(scp);
 561                 xe_set_multicast(scp);
 562                 XE_UNLOCK(scp);
 563                 error = 0;
 564                 break;
 565         case SIOCSIFMEDIA:
 566         case SIOCGIFMEDIA:
 567                 DEVPRINTF(3, (scp->dev, "ioctl: bounce to ifmedia_ioctl\n"));
 568                 /*
 569                  * Someone wants to get/set media options.
 570                  */
 571                 error = ifmedia_ioctl(ifp, (struct ifreq *)data, &scp->ifmedia,
 572                     command);
 573                 break;
 574         default:
 575                 DEVPRINTF(3, (scp->dev, "ioctl: bounce to ether_ioctl\n"));
 576                 error = ether_ioctl(ifp, command, data);
 577         }
 578
 579         return (error);
 580 }
 581
 582 /*
 583  * Card interrupt handler.
 584  *
 585  * This function is probably more complicated than it needs to be, as it
 586  * attempts to deal with the case where multiple packets get sent between
 587  * interrupts.  This is especially annoying when working out the collision
 588  * stats.  Not sure whether this case ever really happens or not (maybe on a
 589  * slow/heavily loaded machine?) so it's probably best to leave this like it
 590  * is.
 591  *
 592  * Note that the crappy PIO used to get packets on and off the card means that
 593  * you will spend a lot of time in this routine -- I can get my P150 to spend
 594  * 90% of its time servicing interrupts if I really hammer the network.  Could
 595  * fix this, but then you'd start dropping/losing packets.  The moral of this
 596  * story?  If you want good network performance _and_ some cycles left over to
 597  * get your work done, don't buy a Xircom card.  Or convince them to tell me
 598  * how to do memory-mapped I/O :)
 599  */
 600 static void
 601 xe_txintr(struct xe_softc *scp, uint8_t txst1)
 602 {
 603         struct ifnet *ifp;
 604         uint8_t tpr, sent, coll;
 605
 606         ifp = scp->ifp;
 607
 608         /* Update packet count, accounting for rollover */
 609         tpr = XE_INB(XE_TPR);
 610         sent = -scp->tx_tpr + tpr;
 611
 612         /* Update statistics if we actually sent anything */
 613         if (sent > 0) {
 614                 coll = txst1 & XE_TXST1_RETRY_COUNT;
 615                 scp->tx_tpr = tpr;
 616                 scp->tx_queued -= sent;
 617                 if_inc_counter(ifp, IFCOUNTER_OPACKETS, sent);
 618                 if_inc_counter(ifp, IFCOUNTER_COLLISIONS, coll);
 619
 620                 /*
 621                  * According to the Xircom manual, Dingo will
 622                  * sometimes manage to transmit a packet with
 623                  * triggering an interrupt.  If this happens, we have
 624                  * sent > 1 and the collision count only reflects
 625                  * collisions on the last packet sent (the one that
 626                  * triggered the interrupt).  Collision stats might
 627                  * therefore be a bit low, but there doesn't seem to
 628                  * be anything we can do about that.
 629                  */
 630                 switch (coll) {
 631                 case 0:
 632                         break;
 633                 case 1:
 634                         scp->mibdata.dot3StatsSingleCollisionFrames++;
 635                         scp->mibdata.dot3StatsCollFrequencies[0]++;
 636                         break;
 637                 default:
 638                         scp->mibdata.dot3StatsMultipleCollisionFrames++;
 639                         scp->mibdata.dot3StatsCollFrequencies[coll-1]++;
 640                 }
 641         }
 642         scp->tx_timeout = 0;
 643         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 644 }
 645
 646 /* Handle most MAC interrupts */
 647 static void
 648 xe_macintr(struct xe_softc *scp, uint8_t rst0, uint8_t txst0, uint8_t txst1)
 649 {
 650         struct ifnet *ifp;
 651
 652         ifp = scp->ifp;
 653
 654 #if 0
 655         /* Carrier sense lost -- only in 10Mbit HDX mode */
 656         if (txst0 & XE_TXST0_NO_CARRIER || !(txst1 & XE_TXST1_LINK_STATUS)) {
 657                 /* XXX - Need to update media status here */
 658                 device_printf(scp->dev, "no carrier\n");
 659                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 660                 scp->mibdata.dot3StatsCarrierSenseErrors++;
 661         }
 662 #endif
 663         /* Excessive collisions -- try sending again */
 664         if (txst0 & XE_TXST0_16_COLLISIONS) {
 665                 if_inc_counter(ifp, IFCOUNTER_COLLISIONS, 16);
 666                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 667                 scp->mibdata.dot3StatsExcessiveCollisions++;
 668                 scp->mibdata.dot3StatsMultipleCollisionFrames++;
 669                 scp->mibdata.dot3StatsCollFrequencies[15]++;
 670                 XE_OUTB(XE_CR, XE_CR_RESTART_TX);
 671         }
 672
 673         /* Transmit underrun -- increase early transmit threshold */
 674         if (txst0 & XE_TXST0_TX_UNDERRUN && scp->mohawk) {
 675                 DEVPRINTF(1, (scp->dev, "transmit underrun"));
 676                 if (scp->tx_thres < ETHER_MAX_LEN) {
 677                         if ((scp->tx_thres += 64) > ETHER_MAX_LEN)
 678                                 scp->tx_thres = ETHER_MAX_LEN;
 679                         DPRINTF(1, (": increasing transmit threshold to %u",
 680                             scp->tx_thres));
 681                         XE_SELECT_PAGE(0x3);
 682                         XE_OUTW(XE_TPT, scp->tx_thres);
 683                         XE_SELECT_PAGE(0x0);
 684                 }
 685                 DPRINTF(1, ("\n"));
 686                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 687                 scp->mibdata.dot3StatsInternalMacTransmitErrors++;
 688         }
 689
 690         /* Late collision -- just complain about it */
 691         if (txst0 & XE_TXST0_LATE_COLLISION) {
 692                 device_printf(scp->dev, "late collision\n");
 693                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 694                 scp->mibdata.dot3StatsLateCollisions++;
 695         }
 696
 697         /* SQE test failure -- just complain about it */
 698         if (txst0 & XE_TXST0_SQE_FAIL) {
 699                 device_printf(scp->dev, "SQE test failure\n");
 700                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 701                 scp->mibdata.dot3StatsSQETestErrors++;
 702         }
 703
 704         /* Packet too long -- what happens to these */
 705         if (rst0 & XE_RST0_LONG_PACKET) {
 706                 device_printf(scp->dev, "received giant packet\n");
 707                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 708                 scp->mibdata.dot3StatsFrameTooLongs++;
 709         }
 710
 711         /* CRC error -- packet dropped */
 712         if (rst0 & XE_RST0_CRC_ERROR) {
 713                 device_printf(scp->dev, "CRC error\n");
 714                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 715                 scp->mibdata.dot3StatsFCSErrors++;
 716         }
 717 }
 718
 719 static void
 720 xe_rxintr(struct xe_softc *scp, uint8_t rst0)
 721 {
 722         struct ifnet *ifp;
 723         uint8_t esr, rsr;
 724
 725         ifp = scp->ifp;
 726
 727         /* Handle received packet(s) */
 728         while ((esr = XE_INB(XE_ESR)) & XE_ESR_FULL_PACKET_RX) {
 729                 rsr = XE_INB(XE_RSR);
 730
 731                 DEVPRINTF(3, (scp->dev, "intr: ESR=0x%02x, RSR=0x%02x\n", esr,
 732                     rsr));
 733
 734                 /* Make sure packet is a good one */
 735                 if (rsr & XE_RSR_RX_OK) {
 736                         struct ether_header *ehp;
 737                         struct mbuf *mbp;
 738                         uint16_t len;
 739
 740                         len = XE_INW(XE_RBC) - ETHER_CRC_LEN;
 741
 742                         DEVPRINTF(3, (scp->dev, "intr: receive length = %d\n",
 743                             len));
 744
 745                         if (len == 0) {
 746                                 if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
 747                                 continue;
 748                         }
 749
 750                         /*
 751                          * Allocate mbuf to hold received packet.  If
 752                          * the mbuf header isn't big enough, we attach
 753                          * an mbuf cluster to hold the packet.  Note
 754                          * the +=2 to align the packet data on a
 755                          * 32-bit boundary, and the +3 to allow for
 756                          * the possibility of reading one more byte
 757                          * than the actual packet length (we always
 758                          * read 16-bit words).  XXX - Surely there's a
 759                          * better way to do this alignment?
 760                          */
 761                         MGETHDR(mbp, M_NOWAIT, MT_DATA);
 762                         if (mbp == NULL) {
 763                                 if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
 764                                 continue;
 765                         }
 766
 767                         if (len + 3 > MHLEN) {
 768                                 MCLGET(mbp, M_NOWAIT);
 769                                 if ((mbp->m_flags & M_EXT) == 0) {
 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(dev, SYS_RES_IOPORT,
1968                     &sc->port_rid, 0ul, ~0ul, 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%0lx, size 0x%0lx\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(dev, SYS_RES_IOPORT,
2002                     &sc->ce2_port_rid, 0ul, ~0ul, 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%0lx, size 0x%0lx\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 }