sys/dev/netif/dc/if_dc.c

   1 /*
   2  * Copyright (c) 1997, 1998, 1999
   3  *      Bill Paul <wpaul@ee.columbia.edu>.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Bill Paul.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  30  * THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * $FreeBSD: src/sys/pci/if_dc.c,v 1.9.2.45 2003/06/08 14:31:53 mux Exp $
  33  * $DragonFly: src/sys/dev/netif/dc/if_dc.c,v 1.21 2005/02/20 04:12:32 joerg Exp $
  34  *
  35  * $FreeBSD: src/sys/pci/if_dc.c,v 1.9.2.45 2003/06/08 14:31:53 mux Exp $
  36  */
  37
  38 /*
  39  * DEC "tulip" clone ethernet driver. Supports the DEC/Intel 21143
  40  * series chips and several workalikes including the following:
  41  *
  42  * Macronix 98713/98715/98725/98727/98732 PMAC (www.macronix.com)
  43  * Macronix/Lite-On 82c115 PNIC II (www.macronix.com)
  44  * Lite-On 82c168/82c169 PNIC (www.litecom.com)
  45  * ASIX Electronics AX88140A (www.asix.com.tw)
  46  * ASIX Electronics AX88141 (www.asix.com.tw)
  47  * ADMtek AL981 (www.admtek.com.tw)
  48  * ADMtek AN985 (www.admtek.com.tw)
  49  * Davicom DM9100, DM9102, DM9102A (www.davicom8.com)
  50  * Accton EN1217 (www.accton.com)
  51  * Conexant LANfinity (www.conexant.com)
  52  *
  53  * Datasheets for the 21143 are available at developer.intel.com.
  54  * Datasheets for the clone parts can be found at their respective sites.
  55  * (Except for the PNIC; see www.freebsd.org/~wpaul/PNIC/pnic.ps.gz.)
  56  * The PNIC II is essentially a Macronix 98715A chip; the only difference
  57  * worth noting is that its multicast hash table is only 128 bits wide
  58  * instead of 512.
  59  *
  60  * Written by Bill Paul <wpaul@ee.columbia.edu>
  61  * Electrical Engineering Department
  62  * Columbia University, New York City
  63  */
  64
  65 /*
  66  * The Intel 21143 is the successor to the DEC 21140. It is basically
  67  * the same as the 21140 but with a few new features. The 21143 supports
  68  * three kinds of media attachments:
  69  *
  70  * o MII port, for 10Mbps and 100Mbps support and NWAY
  71  *   autonegotiation provided by an external PHY.
  72  * o SYM port, for symbol mode 100Mbps support.
  73  * o 10baseT port.
  74  * o AUI/BNC port.
  75  *
  76  * The 100Mbps SYM port and 10baseT port can be used together in
  77  * combination with the internal NWAY support to create a 10/100
  78  * autosensing configuration.
  79  *
  80  * Note that not all tulip workalikes are handled in this driver: we only
  81  * deal with those which are relatively well behaved. The Winbond is
  82  * handled separately due to its different register offsets and the
  83  * special handling needed for its various bugs. The PNIC is handled
  84  * here, but I'm not thrilled about it.
  85  *
  86  * All of the workalike chips use some form of MII transceiver support
  87  * with the exception of the Macronix chips, which also have a SYM port.
  88  * The ASIX AX88140A is also documented to have a SYM port, but all
  89  * the cards I've seen use an MII transceiver, probably because the
  90  * AX88140A doesn't support internal NWAY.
  91  */
  92
  93 #include <sys/param.h>
  94 #include <sys/systm.h>
  95 #include <sys/sockio.h>
  96 #include <sys/mbuf.h>
  97 #include <sys/malloc.h>
  98 #include <sys/kernel.h>
  99 #include <sys/socket.h>
 100 #include <sys/sysctl.h>
 101
 102 #include <net/if.h>
 103 #include <net/if_arp.h>
 104 #include <net/ethernet.h>
 105 #include <net/if_dl.h>
 106 #include <net/if_media.h>
 107 #include <net/if_types.h>
 108 #include <net/vlan/if_vlan_var.h>
 109
 110 #include <net/bpf.h>
 111
 112 #include <vm/vm.h>              /* for vtophys */
 113 #include <vm/pmap.h>            /* for vtophys */
 114 #include <machine/clock.h>      /* for DELAY */
 115 #include <machine/bus_pio.h>
 116 #include <machine/bus_memio.h>
 117 #include <machine/bus.h>
 118 #include <machine/resource.h>
 119 #include <sys/bus.h>
 120 #include <sys/rman.h>
 121
 122 #include "../mii_layer/mii.h"
 123 #include "../mii_layer/miivar.h"
 124
 125 #include <bus/pci/pcireg.h>
 126 #include <bus/pci/pcivar.h>
 127
 128 #define DC_USEIOSPACE
 129 #ifdef __alpha__
 130 #define SRM_MEDIA
 131 #endif
 132
 133 #include "if_dcreg.h"
 134
 135 /* "controller miibus0" required.  See GENERIC if you get errors here. */
 136 #include "miibus_if.h"
 137
 138 /*
 139  * Various supported device vendors/types and their names.
 140  */
 141 static struct dc_type dc_devs[] = {
 142         { DC_VENDORID_DEC, DC_DEVICEID_21143,
 143                 "Intel 21143 10/100BaseTX" },
 144         { DC_VENDORID_DAVICOM, DC_DEVICEID_DM9009,
 145                 "Davicom DM9009 10/100BaseTX" },
 146         { DC_VENDORID_DAVICOM, DC_DEVICEID_DM9100,
 147                 "Davicom DM9100 10/100BaseTX" },
 148         { DC_VENDORID_DAVICOM, DC_DEVICEID_DM9102,
 149                 "Davicom DM9102 10/100BaseTX" },
 150         { DC_VENDORID_DAVICOM, DC_DEVICEID_DM9102,
 151                 "Davicom DM9102A 10/100BaseTX" },
 152         { DC_VENDORID_ADMTEK, DC_DEVICEID_AL981,
 153                 "ADMtek AL981 10/100BaseTX" },
 154         { DC_VENDORID_ADMTEK, DC_DEVICEID_AN985,
 155                 "ADMtek AN985 10/100BaseTX" },
 156         { DC_VENDORID_ASIX, DC_DEVICEID_AX88140A,
 157                 "ASIX AX88140A 10/100BaseTX" },
 158         { DC_VENDORID_ASIX, DC_DEVICEID_AX88140A,
 159                 "ASIX AX88141 10/100BaseTX" },
 160         { DC_VENDORID_MX, DC_DEVICEID_98713,
 161                 "Macronix 98713 10/100BaseTX" },
 162         { DC_VENDORID_MX, DC_DEVICEID_98713,
 163                 "Macronix 98713A 10/100BaseTX" },
 164         { DC_VENDORID_CP, DC_DEVICEID_98713_CP,
 165                 "Compex RL100-TX 10/100BaseTX" },
 166         { DC_VENDORID_CP, DC_DEVICEID_98713_CP,
 167                 "Compex RL100-TX 10/100BaseTX" },
 168         { DC_VENDORID_MX, DC_DEVICEID_987x5,
 169                 "Macronix 98715/98715A 10/100BaseTX" },
 170         { DC_VENDORID_MX, DC_DEVICEID_987x5,
 171                 "Macronix 98715AEC-C 10/100BaseTX" },
 172         { DC_VENDORID_MX, DC_DEVICEID_987x5,
 173                 "Macronix 98725 10/100BaseTX" },
 174         { DC_VENDORID_MX, DC_DEVICEID_98727,
 175                 "Macronix 98727/98732 10/100BaseTX" },
 176         { DC_VENDORID_LO, DC_DEVICEID_82C115,
 177                 "LC82C115 PNIC II 10/100BaseTX" },
 178         { DC_VENDORID_LO, DC_DEVICEID_82C168,
 179                 "82c168 PNIC 10/100BaseTX" },
 180         { DC_VENDORID_LO, DC_DEVICEID_82C168,
 181                 "82c169 PNIC 10/100BaseTX" },
 182         { DC_VENDORID_ACCTON, DC_DEVICEID_EN1217,
 183                 "Accton EN1217 10/100BaseTX" },
 184         { DC_VENDORID_ACCTON, DC_DEVICEID_EN2242,
 185                 "Accton EN2242 MiniPCI 10/100BaseTX" },
 186         { DC_VENDORID_CONEXANT, DC_DEVICEID_RS7112,
 187                 "Conexant LANfinity MiniPCI 10/100BaseTX" },
 188         { DC_VENDORID_3COM, DC_DEVICEID_3CSOHOB,
 189                 "3Com OfficeConnect 10/100B" },
 190         { 0, 0, NULL }
 191 };
 192
 193 static int dc_probe             (device_t);
 194 static int dc_attach            (device_t);
 195 static int dc_detach            (device_t);
 196 static int dc_suspend           (device_t);
 197 static int dc_resume            (device_t);
 198 static void dc_acpi             (device_t);
 199 static struct dc_type *dc_devtype       (device_t);
 200 static int dc_newbuf            (struct dc_softc *, int, struct mbuf *);
 201 static int dc_encap             (struct dc_softc *, struct mbuf *,
 202                                         u_int32_t *);
 203 static void dc_pnic_rx_bug_war  (struct dc_softc *, int);
 204 static int dc_rx_resync         (struct dc_softc *);
 205 static void dc_rxeof            (struct dc_softc *);
 206 static void dc_txeof            (struct dc_softc *);
 207 static void dc_tick             (void *);
 208 static void dc_tx_underrun      (struct dc_softc *);
 209 static void dc_intr             (void *);
 210 static void dc_start            (struct ifnet *);
 211 static int dc_ioctl             (struct ifnet *, u_long, caddr_t,
 212                                         struct ucred *);
 213 static void dc_init             (void *);
 214 static void dc_stop             (struct dc_softc *);
 215 static void dc_watchdog         (struct ifnet *);
 216 static void dc_shutdown         (device_t);
 217 static int dc_ifmedia_upd       (struct ifnet *);
 218 static void dc_ifmedia_sts      (struct ifnet *, struct ifmediareq *);
 219
 220 static void dc_delay            (struct dc_softc *);
 221 static void dc_eeprom_idle      (struct dc_softc *);
 222 static void dc_eeprom_putbyte   (struct dc_softc *, int);
 223 static void dc_eeprom_getword   (struct dc_softc *, int, u_int16_t *);
 224 static void dc_eeprom_getword_pnic
 225                                 (struct dc_softc *, int, u_int16_t *);
 226 static void dc_eeprom_width     (struct dc_softc *);
 227 static void dc_read_eeprom      (struct dc_softc *, caddr_t, int,
 228                                                         int, int);
 229
 230 static void dc_mii_writebit     (struct dc_softc *, int);
 231 static int dc_mii_readbit       (struct dc_softc *);
 232 static void dc_mii_sync         (struct dc_softc *);
 233 static void dc_mii_send         (struct dc_softc *, u_int32_t, int);
 234 static int dc_mii_readreg       (struct dc_softc *, struct dc_mii_frame *);
 235 static int dc_mii_writereg      (struct dc_softc *, struct dc_mii_frame *);
 236 static int dc_miibus_readreg    (device_t, int, int);
 237 static int dc_miibus_writereg   (device_t, int, int, int);
 238 static void dc_miibus_statchg   (device_t);
 239 static void dc_miibus_mediainit (device_t);
 240
 241 static void dc_setcfg           (struct dc_softc *, int);
 242 static u_int32_t dc_crc_le      (struct dc_softc *, c_caddr_t);
 243 static u_int32_t dc_crc_be      (caddr_t);
 244 static void dc_setfilt_21143    (struct dc_softc *);
 245 static void dc_setfilt_asix     (struct dc_softc *);
 246 static void dc_setfilt_admtek   (struct dc_softc *);
 247
 248 static void dc_setfilt          (struct dc_softc *);
 249
 250 static void dc_reset            (struct dc_softc *);
 251 static int dc_list_rx_init      (struct dc_softc *);
 252 static int dc_list_tx_init      (struct dc_softc *);
 253
 254 static void dc_read_srom        (struct dc_softc *, int);
 255 static void dc_parse_21143_srom (struct dc_softc *);
 256 static void dc_decode_leaf_sia  (struct dc_softc *,
 257                                     struct dc_eblock_sia *);
 258 static void dc_decode_leaf_mii  (struct dc_softc *,
 259                                     struct dc_eblock_mii *);
 260 static void dc_decode_leaf_sym  (struct dc_softc *,
 261                                     struct dc_eblock_sym *);
 262 static void dc_apply_fixup      (struct dc_softc *, int);
 263
 264 #ifdef DC_USEIOSPACE
 265 #define DC_RES                  SYS_RES_IOPORT
 266 #define DC_RID                  DC_PCI_CFBIO
 267 #else
 268 #define DC_RES                  SYS_RES_MEMORY
 269 #define DC_RID                  DC_PCI_CFBMA
 270 #endif
 271
 272 static device_method_t dc_methods[] = {
 273         /* Device interface */
 274         DEVMETHOD(device_probe,         dc_probe),
 275         DEVMETHOD(device_attach,        dc_attach),
 276         DEVMETHOD(device_detach,        dc_detach),
 277         DEVMETHOD(device_suspend,       dc_suspend),
 278         DEVMETHOD(device_resume,        dc_resume),
 279         DEVMETHOD(device_shutdown,      dc_shutdown),
 280
 281         /* bus interface */
 282         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 283         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
 284
 285         /* MII interface */
 286         DEVMETHOD(miibus_readreg,       dc_miibus_readreg),
 287         DEVMETHOD(miibus_writereg,      dc_miibus_writereg),
 288         DEVMETHOD(miibus_statchg,       dc_miibus_statchg),
 289         DEVMETHOD(miibus_mediainit,     dc_miibus_mediainit),
 290
 291         { 0, 0 }
 292 };
 293
 294 static driver_t dc_driver = {
 295         "dc",
 296         dc_methods,
 297         sizeof(struct dc_softc)
 298 };
 299
 300 static devclass_t dc_devclass;
 301
 302 #ifdef __i386__
 303 static int dc_quick=1;
 304 SYSCTL_INT(_hw, OID_AUTO, dc_quick, CTLFLAG_RW,
 305         &dc_quick,0,"do not mdevget in dc driver");
 306 #endif
 307
 308 DECLARE_DUMMY_MODULE(if_dc);
 309 DRIVER_MODULE(if_dc, pci, dc_driver, dc_devclass, 0, 0);
 310 DRIVER_MODULE(miibus, dc, miibus_driver, miibus_devclass, 0, 0);
 311
 312 #define DC_SETBIT(sc, reg, x)                           \
 313         CSR_WRITE_4(sc, reg, CSR_READ_4(sc, reg) | (x))
 314
 315 #define DC_CLRBIT(sc, reg, x)                           \
 316         CSR_WRITE_4(sc, reg, CSR_READ_4(sc, reg) & ~(x))
 317
 318 #define SIO_SET(x)      DC_SETBIT(sc, DC_SIO, (x))
 319 #define SIO_CLR(x)      DC_CLRBIT(sc, DC_SIO, (x))
 320
 321 static void dc_delay(sc)
 322         struct dc_softc         *sc;
 323 {
 324         int                     idx;
 325
 326         for (idx = (300 / 33) + 1; idx > 0; idx--)
 327                 CSR_READ_4(sc, DC_BUSCTL);
 328 }
 329
 330 static void dc_eeprom_width(sc)
 331         struct dc_softc         *sc;
 332 {
 333         int i;
 334
 335         /* Force EEPROM to idle state. */
 336         dc_eeprom_idle(sc);
 337
 338         /* Enter EEPROM access mode. */
 339         CSR_WRITE_4(sc, DC_SIO, DC_SIO_EESEL);
 340         dc_delay(sc);
 341         DC_SETBIT(sc, DC_SIO, DC_SIO_ROMCTL_READ);
 342         dc_delay(sc);
 343         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 344         dc_delay(sc);
 345         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CS);
 346         dc_delay(sc);
 347
 348         for (i = 3; i--;) {
 349                 if (6 & (1 << i))
 350                         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_DATAIN);
 351                 else
 352                         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_DATAIN);
 353                 dc_delay(sc);
 354                 DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 355                 dc_delay(sc);
 356                 DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 357                 dc_delay(sc);
 358         }
 359
 360         for (i = 1; i <= 12; i++) {
 361                 DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 362                 dc_delay(sc);
 363                 if (!(CSR_READ_4(sc, DC_SIO) & DC_SIO_EE_DATAOUT)) {
 364                         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 365                         dc_delay(sc);
 366                         break;
 367                 }
 368                 DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 369                 dc_delay(sc);
 370         }
 371
 372         /* Turn off EEPROM access mode. */
 373         dc_eeprom_idle(sc);
 374
 375         if (i < 4 || i > 12)
 376                 sc->dc_romwidth = 6;
 377         else
 378                 sc->dc_romwidth = i;
 379
 380         /* Enter EEPROM access mode. */
 381         CSR_WRITE_4(sc, DC_SIO, DC_SIO_EESEL);
 382         dc_delay(sc);
 383         DC_SETBIT(sc, DC_SIO, DC_SIO_ROMCTL_READ);
 384         dc_delay(sc);
 385         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 386         dc_delay(sc);
 387         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CS);
 388         dc_delay(sc);
 389
 390         /* Turn off EEPROM access mode. */
 391         dc_eeprom_idle(sc);
 392 }
 393
 394 static void dc_eeprom_idle(sc)
 395         struct dc_softc         *sc;
 396 {
 397         int             i;
 398
 399         CSR_WRITE_4(sc, DC_SIO, DC_SIO_EESEL);
 400         dc_delay(sc);
 401         DC_SETBIT(sc, DC_SIO, DC_SIO_ROMCTL_READ);
 402         dc_delay(sc);
 403         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 404         dc_delay(sc);
 405         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CS);
 406         dc_delay(sc);
 407
 408         for (i = 0; i < 25; i++) {
 409                 DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 410                 dc_delay(sc);
 411                 DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 412                 dc_delay(sc);
 413         }
 414
 415         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 416         dc_delay(sc);
 417         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CS);
 418         dc_delay(sc);
 419         CSR_WRITE_4(sc, DC_SIO, 0x00000000);
 420
 421         return;
 422 }
 423
 424 /*
 425  * Send a read command and address to the EEPROM, check for ACK.
 426  */
 427 static void dc_eeprom_putbyte(sc, addr)
 428         struct dc_softc         *sc;
 429         int                     addr;
 430 {
 431         int             d, i;
 432
 433         d = DC_EECMD_READ >> 6;
 434         for (i = 3; i--; ) {
 435                 if (d & (1 << i))
 436                         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_DATAIN);
 437                 else
 438                         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_DATAIN);
 439                 dc_delay(sc);
 440                 DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 441                 dc_delay(sc);
 442                 DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 443                 dc_delay(sc);
 444         }
 445
 446         /*
 447          * Feed in each bit and strobe the clock.
 448          */
 449         for (i = sc->dc_romwidth; i--;) {
 450                 if (addr & (1 << i)) {
 451                         SIO_SET(DC_SIO_EE_DATAIN);
 452                 } else {
 453                         SIO_CLR(DC_SIO_EE_DATAIN);
 454                 }
 455                 dc_delay(sc);
 456                 SIO_SET(DC_SIO_EE_CLK);
 457                 dc_delay(sc);
 458                 SIO_CLR(DC_SIO_EE_CLK);
 459                 dc_delay(sc);
 460         }
 461
 462         return;
 463 }
 464
 465 /*
 466  * Read a word of data stored in the EEPROM at address 'addr.'
 467  * The PNIC 82c168/82c169 has its own non-standard way to read
 468  * the EEPROM.
 469  */
 470 static void dc_eeprom_getword_pnic(sc, addr, dest)
 471         struct dc_softc         *sc;
 472         int                     addr;
 473         u_int16_t               *dest;
 474 {
 475         int             i;
 476         u_int32_t               r;
 477
 478         CSR_WRITE_4(sc, DC_PN_SIOCTL, DC_PN_EEOPCODE_READ|addr);
 479
 480         for (i = 0; i < DC_TIMEOUT; i++) {
 481                 DELAY(1);
 482                 r = CSR_READ_4(sc, DC_SIO);
 483                 if (!(r & DC_PN_SIOCTL_BUSY)) {
 484                         *dest = (u_int16_t)(r & 0xFFFF);
 485                         return;
 486                 }
 487         }
 488
 489         return;
 490 }
 491
 492 /*
 493  * Read a word of data stored in the EEPROM at address 'addr.'
 494  */
 495 static void dc_eeprom_getword(sc, addr, dest)
 496         struct dc_softc         *sc;
 497         int                     addr;
 498         u_int16_t               *dest;
 499 {
 500         int             i;
 501         u_int16_t               word = 0;
 502
 503         /* Force EEPROM to idle state. */
 504         dc_eeprom_idle(sc);
 505
 506         /* Enter EEPROM access mode. */
 507         CSR_WRITE_4(sc, DC_SIO, DC_SIO_EESEL);
 508         dc_delay(sc);
 509         DC_SETBIT(sc, DC_SIO,  DC_SIO_ROMCTL_READ);
 510         dc_delay(sc);
 511         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
 512         dc_delay(sc);
 513         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CS);
 514         dc_delay(sc);
 515
 516         /*
 517          * Send address of word we want to read.
 518          */
 519         dc_eeprom_putbyte(sc, addr);
 520
 521         /*
 522          * Start reading bits from EEPROM.
 523          */
 524         for (i = 0x8000; i; i >>= 1) {
 525                 SIO_SET(DC_SIO_EE_CLK);
 526                 dc_delay(sc);
 527                 if (CSR_READ_4(sc, DC_SIO) & DC_SIO_EE_DATAOUT)
 528                         word |= i;
 529                 dc_delay(sc);
 530                 SIO_CLR(DC_SIO_EE_CLK);
 531                 dc_delay(sc);
 532         }
 533
 534         /* Turn off EEPROM access mode. */
 535         dc_eeprom_idle(sc);
 536
 537         *dest = word;
 538
 539         return;
 540 }
 541
 542 /*
 543  * Read a sequence of words from the EEPROM.
 544  */
 545 static void dc_read_eeprom(sc, dest, off, cnt, swap)
 546         struct dc_softc         *sc;
 547         caddr_t                 dest;
 548         int                     off;
 549         int                     cnt;
 550         int                     swap;
 551 {
 552         int                     i;
 553         u_int16_t               word = 0, *ptr;
 554
 555         for (i = 0; i < cnt; i++) {
 556                 if (DC_IS_PNIC(sc))
 557                         dc_eeprom_getword_pnic(sc, off + i, &word);
 558                 else
 559                         dc_eeprom_getword(sc, off + i, &word);
 560                 ptr = (u_int16_t *)(dest + (i * 2));
 561                 if (swap)
 562                         *ptr = ntohs(word);
 563                 else
 564                         *ptr = word;
 565         }
 566
 567         return;
 568 }
 569
 570 /*
 571  * The following two routines are taken from the Macronix 98713
 572  * Application Notes pp.19-21.
 573  */
 574 /*
 575  * Write a bit to the MII bus.
 576  */
 577 static void dc_mii_writebit(sc, bit)
 578         struct dc_softc         *sc;
 579         int                     bit;
 580 {
 581         if (bit)
 582                 CSR_WRITE_4(sc, DC_SIO,
 583                     DC_SIO_ROMCTL_WRITE|DC_SIO_MII_DATAOUT);
 584         else
 585                 CSR_WRITE_4(sc, DC_SIO, DC_SIO_ROMCTL_WRITE);
 586
 587         DC_SETBIT(sc, DC_SIO, DC_SIO_MII_CLK);
 588         DC_CLRBIT(sc, DC_SIO, DC_SIO_MII_CLK);
 589
 590         return;
 591 }
 592
 593 /*
 594  * Read a bit from the MII bus.
 595  */
 596 static int dc_mii_readbit(sc)
 597         struct dc_softc         *sc;
 598 {
 599         CSR_WRITE_4(sc, DC_SIO, DC_SIO_ROMCTL_READ|DC_SIO_MII_DIR);
 600         CSR_READ_4(sc, DC_SIO);
 601         DC_SETBIT(sc, DC_SIO, DC_SIO_MII_CLK);
 602         DC_CLRBIT(sc, DC_SIO, DC_SIO_MII_CLK);
 603         if (CSR_READ_4(sc, DC_SIO) & DC_SIO_MII_DATAIN)
 604                 return(1);
 605
 606         return(0);
 607 }
 608
 609 /*
 610  * Sync the PHYs by setting data bit and strobing the clock 32 times.
 611  */
 612 static void dc_mii_sync(sc)
 613         struct dc_softc         *sc;
 614 {
 615         int             i;
 616
 617         CSR_WRITE_4(sc, DC_SIO, DC_SIO_ROMCTL_WRITE);
 618
 619         for (i = 0; i < 32; i++)
 620                 dc_mii_writebit(sc, 1);
 621
 622         return;
 623 }
 624
 625 /*
 626  * Clock a series of bits through the MII.
 627  */
 628 static void dc_mii_send(sc, bits, cnt)
 629         struct dc_softc         *sc;
 630         u_int32_t               bits;
 631         int                     cnt;
 632 {
 633         int                     i;
 634
 635         for (i = (0x1 << (cnt - 1)); i; i >>= 1)
 636                 dc_mii_writebit(sc, bits & i);
 637 }
 638
 639 /*
 640  * Read an PHY register through the MII.
 641  */
 642 static int dc_mii_readreg(sc, frame)
 643         struct dc_softc         *sc;
 644         struct dc_mii_frame     *frame;
 645
 646 {
 647         int                     i, ack, s;
 648
 649         s = splimp();
 650
 651         /*
 652          * Set up frame for RX.
 653          */
 654         frame->mii_stdelim = DC_MII_STARTDELIM;
 655         frame->mii_opcode = DC_MII_READOP;
 656         frame->mii_turnaround = 0;
 657         frame->mii_data = 0;
 658
 659         /*
 660          * Sync the PHYs.
 661          */
 662         dc_mii_sync(sc);
 663
 664         /*
 665          * Send command/address info.
 666          */
 667         dc_mii_send(sc, frame->mii_stdelim, 2);
 668         dc_mii_send(sc, frame->mii_opcode, 2);
 669         dc_mii_send(sc, frame->mii_phyaddr, 5);
 670         dc_mii_send(sc, frame->mii_regaddr, 5);
 671
 672 #ifdef notdef
 673         /* Idle bit */
 674         dc_mii_writebit(sc, 1);
 675         dc_mii_writebit(sc, 0);
 676 #endif
 677
 678         /* Check for ack */
 679         ack = dc_mii_readbit(sc);
 680
 681         /*
 682          * Now try reading data bits. If the ack failed, we still
 683          * need to clock through 16 cycles to keep the PHY(s) in sync.
 684          */
 685         if (ack) {
 686                 for(i = 0; i < 16; i++) {
 687                         dc_mii_readbit(sc);
 688                 }
 689                 goto fail;
 690         }
 691
 692         for (i = 0x8000; i; i >>= 1) {
 693                 if (!ack) {
 694                         if (dc_mii_readbit(sc))
 695                                 frame->mii_data |= i;
 696                 }
 697         }
 698
 699 fail:
 700
 701         dc_mii_writebit(sc, 0);
 702         dc_mii_writebit(sc, 0);
 703
 704         splx(s);
 705
 706         if (ack)
 707                 return(1);
 708         return(0);
 709 }
 710
 711 /*
 712  * Write to a PHY register through the MII.
 713  */
 714 static int dc_mii_writereg(sc, frame)
 715         struct dc_softc         *sc;
 716         struct dc_mii_frame     *frame;
 717
 718 {
 719         int                     s;
 720
 721         s = splimp();
 722         /*
 723          * Set up frame for TX.
 724          */
 725
 726         frame->mii_stdelim = DC_MII_STARTDELIM;
 727         frame->mii_opcode = DC_MII_WRITEOP;
 728         frame->mii_turnaround = DC_MII_TURNAROUND;
 729
 730         /*
 731          * Sync the PHYs.
 732          */
 733         dc_mii_sync(sc);
 734
 735         dc_mii_send(sc, frame->mii_stdelim, 2);
 736         dc_mii_send(sc, frame->mii_opcode, 2);
 737         dc_mii_send(sc, frame->mii_phyaddr, 5);
 738         dc_mii_send(sc, frame->mii_regaddr, 5);
 739         dc_mii_send(sc, frame->mii_turnaround, 2);
 740         dc_mii_send(sc, frame->mii_data, 16);
 741
 742         /* Idle bit. */
 743         dc_mii_writebit(sc, 0);
 744         dc_mii_writebit(sc, 0);
 745
 746         splx(s);
 747
 748         return(0);
 749 }
 750
 751 static int dc_miibus_readreg(dev, phy, reg)
 752         device_t                dev;
 753         int                     phy, reg;
 754 {
 755         struct dc_mii_frame     frame;
 756         struct dc_softc         *sc;
 757         int                     i, rval, phy_reg = 0;
 758
 759         sc = device_get_softc(dev);
 760         bzero((char *)&frame, sizeof(frame));
 761
 762         /*
 763          * Note: both the AL981 and AN985 have internal PHYs,
 764          * however the AL981 provides direct access to the PHY
 765          * registers while the AN985 uses a serial MII interface.
 766          * The AN985's MII interface is also buggy in that you
 767          * can read from any MII address (0 to 31), but only address 1
 768          * behaves normally. To deal with both cases, we pretend
 769          * that the PHY is at MII address 1.
 770          */
 771         if (DC_IS_ADMTEK(sc) && phy != DC_ADMTEK_PHYADDR)
 772                 return(0);
 773
 774         /*
 775          * Note: the ukphy probes of the RS7112 report a PHY at
 776          * MII address 0 (possibly HomePNA?) and 1 (ethernet)
 777          * so we only respond to correct one.
 778          */
 779         if (DC_IS_CONEXANT(sc) && phy != DC_CONEXANT_PHYADDR)
 780                 return(0);
 781
 782         if (sc->dc_pmode != DC_PMODE_MII) {
 783                 if (phy == (MII_NPHY - 1)) {
 784                         switch(reg) {
 785                         case MII_BMSR:
 786                         /*
 787                          * Fake something to make the probe
 788                          * code think there's a PHY here.
 789                          */
 790                                 return(BMSR_MEDIAMASK);
 791                                 break;
 792                         case MII_PHYIDR1:
 793                                 if (DC_IS_PNIC(sc))
 794                                         return(DC_VENDORID_LO);
 795                                 return(DC_VENDORID_DEC);
 796                                 break;
 797                         case MII_PHYIDR2:
 798                                 if (DC_IS_PNIC(sc))
 799                                         return(DC_DEVICEID_82C168);
 800                                 return(DC_DEVICEID_21143);
 801                                 break;
 802                         default:
 803                                 return(0);
 804                                 break;
 805                         }
 806                 } else
 807                         return(0);
 808         }
 809
 810         if (DC_IS_PNIC(sc)) {
 811                 CSR_WRITE_4(sc, DC_PN_MII, DC_PN_MIIOPCODE_READ |
 812                     (phy << 23) | (reg << 18));
 813                 for (i = 0; i < DC_TIMEOUT; i++) {
 814                         DELAY(1);
 815                         rval = CSR_READ_4(sc, DC_PN_MII);
 816                         if (!(rval & DC_PN_MII_BUSY)) {
 817                                 rval &= 0xFFFF;
 818                                 return(rval == 0xFFFF ? 0 : rval);
 819                         }
 820                 }
 821                 return(0);
 822         }
 823
 824         if (DC_IS_COMET(sc)) {
 825                 switch(reg) {
 826                 case MII_BMCR:
 827                         phy_reg = DC_AL_BMCR;
 828                         break;
 829                 case MII_BMSR:
 830                         phy_reg = DC_AL_BMSR;
 831                         break;
 832                 case MII_PHYIDR1:
 833                         phy_reg = DC_AL_VENID;
 834                         break;
 835                 case MII_PHYIDR2:
 836                         phy_reg = DC_AL_DEVID;
 837                         break;
 838                 case MII_ANAR:
 839                         phy_reg = DC_AL_ANAR;
 840                         break;
 841                 case MII_ANLPAR:
 842                         phy_reg = DC_AL_LPAR;
 843                         break;
 844                 case MII_ANER:
 845                         phy_reg = DC_AL_ANER;
 846                         break;
 847                 default:
 848                         printf("dc%d: phy_read: bad phy register %x\n",
 849                             sc->dc_unit, reg);
 850                         return(0);
 851                         break;
 852                 }
 853
 854                 rval = CSR_READ_4(sc, phy_reg) & 0x0000FFFF;
 855
 856                 if (rval == 0xFFFF)
 857                         return(0);
 858                 return(rval);
 859         }
 860
 861         frame.mii_phyaddr = phy;
 862         frame.mii_regaddr = reg;
 863         if (sc->dc_type == DC_TYPE_98713) {
 864                 phy_reg = CSR_READ_4(sc, DC_NETCFG);
 865                 CSR_WRITE_4(sc, DC_NETCFG, phy_reg & ~DC_NETCFG_PORTSEL);
 866         }
 867         dc_mii_readreg(sc, &frame);
 868         if (sc->dc_type == DC_TYPE_98713)
 869                 CSR_WRITE_4(sc, DC_NETCFG, phy_reg);
 870
 871         return(frame.mii_data);
 872 }
 873
 874 static int dc_miibus_writereg(dev, phy, reg, data)
 875         device_t                dev;
 876         int                     phy, reg, data;
 877 {
 878         struct dc_softc         *sc;
 879         struct dc_mii_frame     frame;
 880         int                     i, phy_reg = 0;
 881
 882         sc = device_get_softc(dev);
 883         bzero((char *)&frame, sizeof(frame));
 884
 885         if (DC_IS_ADMTEK(sc) && phy != DC_ADMTEK_PHYADDR)
 886                 return(0);
 887
 888         if (DC_IS_CONEXANT(sc) && phy != DC_CONEXANT_PHYADDR)
 889                 return(0);
 890
 891         if (DC_IS_PNIC(sc)) {
 892                 CSR_WRITE_4(sc, DC_PN_MII, DC_PN_MIIOPCODE_WRITE |
 893                     (phy << 23) | (reg << 10) | data);
 894                 for (i = 0; i < DC_TIMEOUT; i++) {
 895                         if (!(CSR_READ_4(sc, DC_PN_MII) & DC_PN_MII_BUSY))
 896                                 break;
 897                 }
 898                 return(0);
 899         }
 900
 901         if (DC_IS_COMET(sc)) {
 902                 switch(reg) {
 903                 case MII_BMCR:
 904                         phy_reg = DC_AL_BMCR;
 905                         break;
 906                 case MII_BMSR:
 907                         phy_reg = DC_AL_BMSR;
 908                         break;
 909                 case MII_PHYIDR1:
 910                         phy_reg = DC_AL_VENID;
 911                         break;
 912                 case MII_PHYIDR2:
 913                         phy_reg = DC_AL_DEVID;
 914                         break;
 915                 case MII_ANAR:
 916                         phy_reg = DC_AL_ANAR;
 917                         break;
 918                 case MII_ANLPAR:
 919                         phy_reg = DC_AL_LPAR;
 920                         break;
 921                 case MII_ANER:
 922                         phy_reg = DC_AL_ANER;
 923                         break;
 924                 default:
 925                         printf("dc%d: phy_write: bad phy register %x\n",
 926                             sc->dc_unit, reg);
 927                         return(0);
 928                         break;
 929                 }
 930
 931                 CSR_WRITE_4(sc, phy_reg, data);
 932                 return(0);
 933         }
 934
 935         frame.mii_phyaddr = phy;
 936         frame.mii_regaddr = reg;
 937         frame.mii_data = data;
 938
 939         if (sc->dc_type == DC_TYPE_98713) {
 940                 phy_reg = CSR_READ_4(sc, DC_NETCFG);
 941                 CSR_WRITE_4(sc, DC_NETCFG, phy_reg & ~DC_NETCFG_PORTSEL);
 942         }
 943         dc_mii_writereg(sc, &frame);
 944         if (sc->dc_type == DC_TYPE_98713)
 945                 CSR_WRITE_4(sc, DC_NETCFG, phy_reg);
 946
 947         return(0);
 948 }
 949
 950 static void dc_miibus_statchg(dev)
 951         device_t                dev;
 952 {
 953         struct dc_softc         *sc;
 954         struct mii_data         *mii;
 955         struct ifmedia          *ifm;
 956
 957         sc = device_get_softc(dev);
 958         if (DC_IS_ADMTEK(sc))
 959                 return;
 960
 961         mii = device_get_softc(sc->dc_miibus);
 962         ifm = &mii->mii_media;
 963         if (DC_IS_DAVICOM(sc) &&
 964             IFM_SUBTYPE(ifm->ifm_media) == IFM_HPNA_1) {
 965                 dc_setcfg(sc, ifm->ifm_media);
 966                 sc->dc_if_media = ifm->ifm_media;
 967         } else {
 968                 dc_setcfg(sc, mii->mii_media_active);
 969                 sc->dc_if_media = mii->mii_media_active;
 970         }
 971
 972         return;
 973 }
 974
 975 /*
 976  * Special support for DM9102A cards with HomePNA PHYs. Note:
 977  * with the Davicom DM9102A/DM9801 eval board that I have, it seems
 978  * to be impossible to talk to the management interface of the DM9801
 979  * PHY (its MDIO pin is not connected to anything). Consequently,
 980  * the driver has to just 'know' about the additional mode and deal
 981  * with it itself. *sigh*
 982  */
 983 static void dc_miibus_mediainit(dev)
 984         device_t                dev;
 985 {
 986         struct dc_softc         *sc;
 987         struct mii_data         *mii;
 988         struct ifmedia          *ifm;
 989         int                     rev;
 990
 991         rev = pci_read_config(dev, DC_PCI_CFRV, 4) & 0xFF;
 992
 993         sc = device_get_softc(dev);
 994         mii = device_get_softc(sc->dc_miibus);
 995         ifm = &mii->mii_media;
 996
 997         if (DC_IS_DAVICOM(sc) && rev >= DC_REVISION_DM9102A)
 998                 ifmedia_add(ifm, IFM_ETHER | IFM_HPNA_1, 0, NULL);
 999
1000         return;
1001 }
1002
1003 #define DC_POLY         0xEDB88320
1004 #define DC_BITS_512     9
1005 #define DC_BITS_128     7
1006 #define DC_BITS_64      6
1007
1008 static u_int32_t dc_crc_le(sc, addr)
1009         struct dc_softc         *sc;
1010         c_caddr_t               addr;
1011 {
1012         u_int32_t               idx, bit, data, crc;
1013
1014         /* Compute CRC for the address value. */
1015         crc = 0xFFFFFFFF; /* initial value */
1016
1017         for (idx = 0; idx < 6; idx++) {
1018                 for (data = *addr++, bit = 0; bit < 8; bit++, data >>= 1)
1019                         crc = (crc >> 1) ^ (((crc ^ data) & 1) ? DC_POLY : 0);
1020         }
1021
1022         /*
1023          * The hash table on the PNIC II and the MX98715AEC-C/D/E
1024          * chips is only 128 bits wide.
1025          */
1026         if (sc->dc_flags & DC_128BIT_HASH)
1027                 return (crc & ((1 << DC_BITS_128) - 1));
1028
1029         /* The hash table on the MX98715BEC is only 64 bits wide. */
1030         if (sc->dc_flags & DC_64BIT_HASH)
1031                 return (crc & ((1 << DC_BITS_64) - 1));
1032
1033         return (crc & ((1 << DC_BITS_512) - 1));
1034 }
1035
1036 /*
1037  * Calculate CRC of a multicast group address, return the lower 6 bits.
1038  */
1039 static u_int32_t dc_crc_be(addr)
1040         caddr_t                 addr;
1041 {
1042         u_int32_t               crc, carry;
1043         int                     i, j;
1044         u_int8_t                c;
1045
1046         /* Compute CRC for the address value. */
1047         crc = 0xFFFFFFFF; /* initial value */
1048
1049         for (i = 0; i < 6; i++) {
1050                 c = *(addr + i);
1051                 for (j = 0; j < 8; j++) {
1052                         carry = ((crc & 0x80000000) ? 1 : 0) ^ (c & 0x01);
1053                         crc <<= 1;
1054                         c >>= 1;
1055                         if (carry)
1056                                 crc = (crc ^ 0x04c11db6) | carry;
1057                 }
1058         }
1059
1060         /* return the filter bit position */
1061         return((crc >> 26) & 0x0000003F);
1062 }
1063
1064 /*
1065  * 21143-style RX filter setup routine. Filter programming is done by
1066  * downloading a special setup frame into the TX engine. 21143, Macronix,
1067  * PNIC, PNIC II and Davicom chips are programmed this way.
1068  *
1069  * We always program the chip using 'hash perfect' mode, i.e. one perfect
1070  * address (our node address) and a 512-bit hash filter for multicast
1071  * frames. We also sneak the broadcast address into the hash filter since
1072  * we need that too.
1073  */
1074 void dc_setfilt_21143(sc)
1075         struct dc_softc         *sc;
1076 {
1077         struct dc_desc          *sframe;
1078         u_int32_t               h, *sp;
1079         struct ifmultiaddr      *ifma;
1080         struct ifnet            *ifp;
1081         int                     i;
1082
1083         ifp = &sc->arpcom.ac_if;
1084
1085         i = sc->dc_cdata.dc_tx_prod;
1086         DC_INC(sc->dc_cdata.dc_tx_prod, DC_TX_LIST_CNT);
1087         sc->dc_cdata.dc_tx_cnt++;
1088         sframe = &sc->dc_ldata->dc_tx_list[i];
1089         sp = (u_int32_t *)&sc->dc_cdata.dc_sbuf;
1090         bzero((char *)sp, DC_SFRAME_LEN);
1091
1092         sframe->dc_data = vtophys(&sc->dc_cdata.dc_sbuf);
1093         sframe->dc_ctl = DC_SFRAME_LEN | DC_TXCTL_SETUP | DC_TXCTL_TLINK |
1094             DC_FILTER_HASHPERF | DC_TXCTL_FINT;
1095
1096         sc->dc_cdata.dc_tx_chain[i] = (struct mbuf *)&sc->dc_cdata.dc_sbuf;
1097
1098         /* If we want promiscuous mode, set the allframes bit. */
1099         if (ifp->if_flags & IFF_PROMISC)
1100                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1101         else
1102                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1103
1104         if (ifp->if_flags & IFF_ALLMULTI)
1105                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1106         else
1107                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1108
1109         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
1110             ifma = ifma->ifma_link.le_next) {
1111                 if (ifma->ifma_addr->sa_family != AF_LINK)
1112                         continue;
1113                 h = dc_crc_le(sc,
1114                     LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1115                 sp[h >> 4] |= 1 << (h & 0xF);
1116         }
1117
1118         if (ifp->if_flags & IFF_BROADCAST) {
1119                 h = dc_crc_le(sc, ifp->if_broadcastaddr);
1120                 sp[h >> 4] |= 1 << (h & 0xF);
1121         }
1122
1123         /* Set our MAC address */
1124         sp[39] = ((u_int16_t *)sc->arpcom.ac_enaddr)[0];
1125         sp[40] = ((u_int16_t *)sc->arpcom.ac_enaddr)[1];
1126         sp[41] = ((u_int16_t *)sc->arpcom.ac_enaddr)[2];
1127
1128         sframe->dc_status = DC_TXSTAT_OWN;
1129         CSR_WRITE_4(sc, DC_TXSTART, 0xFFFFFFFF);
1130
1131         /*
1132          * The PNIC takes an exceedingly long time to process its
1133          * setup frame; wait 10ms after posting the setup frame
1134          * before proceeding, just so it has time to swallow its
1135          * medicine.
1136          */
1137         DELAY(10000);
1138
1139         ifp->if_timer = 5;
1140
1141         return;
1142 }
1143
1144 void dc_setfilt_admtek(sc)
1145         struct dc_softc         *sc;
1146 {
1147         struct ifnet            *ifp;
1148         int                     h = 0;
1149         u_int32_t               hashes[2] = { 0, 0 };
1150         struct ifmultiaddr      *ifma;
1151
1152         ifp = &sc->arpcom.ac_if;
1153
1154         /* Init our MAC address */
1155         CSR_WRITE_4(sc, DC_AL_PAR0, *(u_int32_t *)(&sc->arpcom.ac_enaddr[0]));
1156         CSR_WRITE_4(sc, DC_AL_PAR1, *(u_int32_t *)(&sc->arpcom.ac_enaddr[4]));
1157
1158         /* If we want promiscuous mode, set the allframes bit. */
1159         if (ifp->if_flags & IFF_PROMISC)
1160                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1161         else
1162                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1163
1164         if (ifp->if_flags & IFF_ALLMULTI)
1165                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1166         else
1167                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1168
1169         /* first, zot all the existing hash bits */
1170         CSR_WRITE_4(sc, DC_AL_MAR0, 0);
1171         CSR_WRITE_4(sc, DC_AL_MAR1, 0);
1172
1173         /*
1174          * If we're already in promisc or allmulti mode, we
1175          * don't have to bother programming the multicast filter.
1176          */
1177         if (ifp->if_flags & (IFF_PROMISC|IFF_ALLMULTI))
1178                 return;
1179
1180         /* now program new ones */
1181         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
1182             ifma = ifma->ifma_link.le_next) {
1183                 if (ifma->ifma_addr->sa_family != AF_LINK)
1184                         continue;
1185                 if (DC_IS_CENTAUR(sc))
1186                         h = dc_crc_le(sc, LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1187                 else
1188                         h = dc_crc_be(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1189                 if (h < 32)
1190                         hashes[0] |= (1 << h);
1191                 else
1192                         hashes[1] |= (1 << (h - 32));
1193         }
1194
1195         CSR_WRITE_4(sc, DC_AL_MAR0, hashes[0]);
1196         CSR_WRITE_4(sc, DC_AL_MAR1, hashes[1]);
1197
1198         return;
1199 }
1200
1201 void dc_setfilt_asix(sc)
1202         struct dc_softc         *sc;
1203 {
1204         struct ifnet            *ifp;
1205         int                     h = 0;
1206         u_int32_t               hashes[2] = { 0, 0 };
1207         struct ifmultiaddr      *ifma;
1208
1209         ifp = &sc->arpcom.ac_if;
1210
1211         /* Init our MAC address */
1212         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_PAR0);
1213         CSR_WRITE_4(sc, DC_AX_FILTDATA,
1214             *(u_int32_t *)(&sc->arpcom.ac_enaddr[0]));
1215         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_PAR1);
1216         CSR_WRITE_4(sc, DC_AX_FILTDATA,
1217             *(u_int32_t *)(&sc->arpcom.ac_enaddr[4]));
1218
1219         /* If we want promiscuous mode, set the allframes bit. */
1220         if (ifp->if_flags & IFF_PROMISC)
1221                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1222         else
1223                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1224
1225         if (ifp->if_flags & IFF_ALLMULTI)
1226                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1227         else
1228                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1229
1230         /*
1231          * The ASIX chip has a special bit to enable reception
1232          * of broadcast frames.
1233          */
1234         if (ifp->if_flags & IFF_BROADCAST)
1235                 DC_SETBIT(sc, DC_NETCFG, DC_AX_NETCFG_RX_BROAD);
1236         else
1237                 DC_CLRBIT(sc, DC_NETCFG, DC_AX_NETCFG_RX_BROAD);
1238
1239         /* first, zot all the existing hash bits */
1240         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_MAR0);
1241         CSR_WRITE_4(sc, DC_AX_FILTDATA, 0);
1242         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_MAR1);
1243         CSR_WRITE_4(sc, DC_AX_FILTDATA, 0);
1244
1245         /*
1246          * If we're already in promisc or allmulti mode, we
1247          * don't have to bother programming the multicast filter.
1248          */
1249         if (ifp->if_flags & (IFF_PROMISC|IFF_ALLMULTI))
1250                 return;
1251
1252         /* now program new ones */
1253         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
1254             ifma = ifma->ifma_link.le_next) {
1255                 if (ifma->ifma_addr->sa_family != AF_LINK)
1256                         continue;
1257                 h = dc_crc_be(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1258                 if (h < 32)
1259                         hashes[0] |= (1 << h);
1260                 else
1261                         hashes[1] |= (1 << (h - 32));
1262         }
1263
1264         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_MAR0);
1265         CSR_WRITE_4(sc, DC_AX_FILTDATA, hashes[0]);
1266         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_MAR1);
1267         CSR_WRITE_4(sc, DC_AX_FILTDATA, hashes[1]);
1268
1269         return;
1270 }
1271
1272 static void dc_setfilt(sc)
1273         struct dc_softc         *sc;
1274 {
1275         if (DC_IS_INTEL(sc) || DC_IS_MACRONIX(sc) || DC_IS_PNIC(sc) ||
1276             DC_IS_PNICII(sc) || DC_IS_DAVICOM(sc) || DC_IS_CONEXANT(sc))
1277                 dc_setfilt_21143(sc);
1278
1279         if (DC_IS_ASIX(sc))
1280                 dc_setfilt_asix(sc);
1281
1282         if (DC_IS_ADMTEK(sc))
1283                 dc_setfilt_admtek(sc);
1284
1285         return;
1286 }
1287
1288 /*
1289  * In order to fiddle with the
1290  * 'full-duplex' and '100Mbps' bits in the netconfig register, we
1291  * first have to put the transmit and/or receive logic in the idle state.
1292  */
1293 static void dc_setcfg(sc, media)
1294         struct dc_softc         *sc;
1295         int                     media;
1296 {
1297         int                     i, restart = 0;
1298         u_int32_t               isr;
1299
1300         if (IFM_SUBTYPE(media) == IFM_NONE)
1301                 return;
1302
1303         if (CSR_READ_4(sc, DC_NETCFG) & (DC_NETCFG_TX_ON|DC_NETCFG_RX_ON)) {
1304                 restart = 1;
1305                 DC_CLRBIT(sc, DC_NETCFG, (DC_NETCFG_TX_ON|DC_NETCFG_RX_ON));
1306
1307                 for (i = 0; i < DC_TIMEOUT; i++) {
1308                         isr = CSR_READ_4(sc, DC_ISR);
1309                         if (isr & DC_ISR_TX_IDLE ||
1310                             (isr & DC_ISR_RX_STATE) == DC_RXSTATE_STOPPED)
1311                                 break;
1312                         DELAY(10);
1313                 }
1314
1315                 if (i == DC_TIMEOUT)
1316                         printf("dc%d: failed to force tx and "
1317                                 "rx to idle state\n", sc->dc_unit);
1318         }
1319
1320         if (IFM_SUBTYPE(media) == IFM_100_TX) {
1321                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_SPEEDSEL);
1322                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_HEARTBEAT);
1323                 if (sc->dc_pmode == DC_PMODE_MII) {
1324                         int     watchdogreg;
1325
1326                         if (DC_IS_INTEL(sc)) {
1327                         /* there's a write enable bit here that reads as 1 */
1328                                 watchdogreg = CSR_READ_4(sc, DC_WATCHDOG);
1329                                 watchdogreg &= ~DC_WDOG_CTLWREN;
1330                                 watchdogreg |= DC_WDOG_JABBERDIS;
1331                                 CSR_WRITE_4(sc, DC_WATCHDOG, watchdogreg);
1332                         } else {
1333                                 DC_SETBIT(sc, DC_WATCHDOG, DC_WDOG_JABBERDIS);
1334                         }
1335                         DC_CLRBIT(sc, DC_NETCFG, (DC_NETCFG_PCS|
1336                             DC_NETCFG_PORTSEL|DC_NETCFG_SCRAMBLER));
1337                         if (sc->dc_type == DC_TYPE_98713)
1338                                 DC_SETBIT(sc, DC_NETCFG, (DC_NETCFG_PCS|
1339                                     DC_NETCFG_SCRAMBLER));
1340                         if (!DC_IS_DAVICOM(sc))
1341                                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1342                         DC_CLRBIT(sc, DC_10BTCTRL, 0xFFFF);
1343                         if (DC_IS_INTEL(sc))
1344                                 dc_apply_fixup(sc, IFM_AUTO);
1345                 } else {
1346                         if (DC_IS_PNIC(sc)) {
1347                                 DC_PN_GPIO_SETBIT(sc, DC_PN_GPIO_SPEEDSEL);
1348                                 DC_PN_GPIO_SETBIT(sc, DC_PN_GPIO_100TX_LOOP);
1349                                 DC_SETBIT(sc, DC_PN_NWAY, DC_PN_NWAY_SPEEDSEL);
1350                         }
1351                         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1352                         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PCS);
1353                         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_SCRAMBLER);
1354                         if (DC_IS_INTEL(sc))
1355                                 dc_apply_fixup(sc,
1356                                     (media & IFM_GMASK) == IFM_FDX ?
1357                                     IFM_100_TX|IFM_FDX : IFM_100_TX);
1358                 }
1359         }
1360
1361         if (IFM_SUBTYPE(media) == IFM_10_T) {
1362                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_SPEEDSEL);
1363                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_HEARTBEAT);
1364                 if (sc->dc_pmode == DC_PMODE_MII) {
1365                         int     watchdogreg;
1366
1367                         /* there's a write enable bit here that reads as 1 */
1368                         if (DC_IS_INTEL(sc)) {
1369                                 watchdogreg = CSR_READ_4(sc, DC_WATCHDOG);
1370                                 watchdogreg &= ~DC_WDOG_CTLWREN;
1371                                 watchdogreg |= DC_WDOG_JABBERDIS;
1372                                 CSR_WRITE_4(sc, DC_WATCHDOG, watchdogreg);
1373                         } else {
1374                                 DC_SETBIT(sc, DC_WATCHDOG, DC_WDOG_JABBERDIS);
1375                         }
1376                         DC_CLRBIT(sc, DC_NETCFG, (DC_NETCFG_PCS|
1377                             DC_NETCFG_PORTSEL|DC_NETCFG_SCRAMBLER));
1378                         if (sc->dc_type == DC_TYPE_98713)
1379                                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PCS);
1380                         if (!DC_IS_DAVICOM(sc))
1381                                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1382                         DC_CLRBIT(sc, DC_10BTCTRL, 0xFFFF);
1383                         if (DC_IS_INTEL(sc))
1384                                 dc_apply_fixup(sc, IFM_AUTO);
1385                 } else {
1386                         if (DC_IS_PNIC(sc)) {
1387                                 DC_PN_GPIO_CLRBIT(sc, DC_PN_GPIO_SPEEDSEL);
1388                                 DC_PN_GPIO_SETBIT(sc, DC_PN_GPIO_100TX_LOOP);
1389                                 DC_CLRBIT(sc, DC_PN_NWAY, DC_PN_NWAY_SPEEDSEL);
1390                         }
1391                         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1392                         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_PCS);
1393                         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_SCRAMBLER);
1394                         if (DC_IS_INTEL(sc)) {
1395                                 DC_CLRBIT(sc, DC_SIARESET, DC_SIA_RESET);
1396                                 DC_CLRBIT(sc, DC_10BTCTRL, 0xFFFF);
1397                                 if ((media & IFM_GMASK) == IFM_FDX)
1398                                         DC_SETBIT(sc, DC_10BTCTRL, 0x7F3D);
1399                                 else
1400                                         DC_SETBIT(sc, DC_10BTCTRL, 0x7F3F);
1401                                 DC_SETBIT(sc, DC_SIARESET, DC_SIA_RESET);
1402                                 DC_CLRBIT(sc, DC_10BTCTRL,
1403                                     DC_TCTL_AUTONEGENBL);
1404                                 dc_apply_fixup(sc,
1405                                     (media & IFM_GMASK) == IFM_FDX ?
1406                                     IFM_10_T|IFM_FDX : IFM_10_T);
1407                                 DELAY(20000);
1408                         }
1409                 }
1410         }
1411
1412         /*
1413          * If this is a Davicom DM9102A card with a DM9801 HomePNA
1414          * PHY and we want HomePNA mode, set the portsel bit to turn
1415          * on the external MII port.
1416          */
1417         if (DC_IS_DAVICOM(sc)) {
1418                 if (IFM_SUBTYPE(media) == IFM_HPNA_1) {
1419                         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1420                         sc->dc_link = 1;
1421                 } else {
1422                         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1423                 }
1424         }
1425
1426         if ((media & IFM_GMASK) == IFM_FDX) {
1427                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_FULLDUPLEX);
1428                 if (sc->dc_pmode == DC_PMODE_SYM && DC_IS_PNIC(sc))
1429                         DC_SETBIT(sc, DC_PN_NWAY, DC_PN_NWAY_DUPLEX);
1430         } else {
1431                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_FULLDUPLEX);
1432                 if (sc->dc_pmode == DC_PMODE_SYM && DC_IS_PNIC(sc))
1433                         DC_CLRBIT(sc, DC_PN_NWAY, DC_PN_NWAY_DUPLEX);
1434         }
1435
1436         if (restart)
1437                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_TX_ON|DC_NETCFG_RX_ON);
1438
1439         return;
1440 }
1441
1442 static void dc_reset(sc)
1443         struct dc_softc         *sc;
1444 {
1445         int             i;
1446
1447         DC_SETBIT(sc, DC_BUSCTL, DC_BUSCTL_RESET);
1448
1449         for (i = 0; i < DC_TIMEOUT; i++) {
1450                 DELAY(10);
1451                 if (!(CSR_READ_4(sc, DC_BUSCTL) & DC_BUSCTL_RESET))
1452                         break;
1453         }
1454
1455         if (DC_IS_ASIX(sc) || DC_IS_ADMTEK(sc) || DC_IS_CONEXANT(sc)) {
1456                 DELAY(10000);
1457                 DC_CLRBIT(sc, DC_BUSCTL, DC_BUSCTL_RESET);
1458                 i = 0;
1459         }
1460
1461         if (i == DC_TIMEOUT)
1462                 printf("dc%d: reset never completed!\n", sc->dc_unit);
1463
1464         /* Wait a little while for the chip to get its brains in order. */
1465         DELAY(1000);
1466
1467         CSR_WRITE_4(sc, DC_IMR, 0x00000000);
1468         CSR_WRITE_4(sc, DC_BUSCTL, 0x00000000);
1469         CSR_WRITE_4(sc, DC_NETCFG, 0x00000000);
1470
1471         /*
1472          * Bring the SIA out of reset. In some cases, it looks
1473          * like failing to unreset the SIA soon enough gets it
1474          * into a state where it will never come out of reset
1475          * until we reset the whole chip again.
1476          */
1477         if (DC_IS_INTEL(sc)) {
1478                 DC_SETBIT(sc, DC_SIARESET, DC_SIA_RESET);
1479                 CSR_WRITE_4(sc, DC_10BTCTRL, 0);
1480                 CSR_WRITE_4(sc, DC_WATCHDOG, 0);
1481         }
1482
1483         return;
1484 }
1485
1486 static struct dc_type *dc_devtype(dev)
1487         device_t                dev;
1488 {
1489         struct dc_type          *t;
1490         u_int32_t               rev;
1491
1492         t = dc_devs;
1493
1494         while(t->dc_name != NULL) {
1495                 if ((pci_get_vendor(dev) == t->dc_vid) &&
1496                     (pci_get_device(dev) == t->dc_did)) {
1497                         /* Check the PCI revision */
1498                         rev = pci_read_config(dev, DC_PCI_CFRV, 4) & 0xFF;
1499                         if (t->dc_did == DC_DEVICEID_98713 &&
1500                             rev >= DC_REVISION_98713A)
1501                                 t++;
1502                         if (t->dc_did == DC_DEVICEID_98713_CP &&
1503                             rev >= DC_REVISION_98713A)
1504                                 t++;
1505                         if (t->dc_did == DC_DEVICEID_987x5 &&
1506                             rev >= DC_REVISION_98715AEC_C)
1507                                 t++;
1508                         if (t->dc_did == DC_DEVICEID_987x5 &&
1509                             rev >= DC_REVISION_98725)
1510                                 t++;
1511                         if (t->dc_did == DC_DEVICEID_AX88140A &&
1512                             rev >= DC_REVISION_88141)
1513                                 t++;
1514                         if (t->dc_did == DC_DEVICEID_82C168 &&
1515                             rev >= DC_REVISION_82C169)
1516                                 t++;
1517                         if (t->dc_did == DC_DEVICEID_DM9102 &&
1518                             rev >= DC_REVISION_DM9102A)
1519                                 t++;
1520                         return(t);
1521                 }
1522                 t++;
1523         }
1524
1525         return(NULL);
1526 }
1527
1528 /*
1529  * Probe for a 21143 or clone chip. Check the PCI vendor and device
1530  * IDs against our list and return a device name if we find a match.
1531  * We do a little bit of extra work to identify the exact type of
1532  * chip. The MX98713 and MX98713A have the same PCI vendor/device ID,
1533  * but different revision IDs. The same is true for 98715/98715A
1534  * chips and the 98725, as well as the ASIX and ADMtek chips. In some
1535  * cases, the exact chip revision affects driver behavior.
1536  */
1537 static int dc_probe(dev)
1538         device_t                dev;
1539 {
1540         struct dc_type          *t;
1541
1542         t = dc_devtype(dev);
1543
1544         if (t != NULL) {
1545                 device_set_desc(dev, t->dc_name);
1546                 return(0);
1547         }
1548
1549         return(ENXIO);
1550 }
1551
1552 static void dc_acpi(dev)
1553         device_t                dev;
1554 {
1555         u_int32_t               r, cptr;
1556         int                     unit;
1557
1558         unit = device_get_unit(dev);
1559
1560         /* Find the location of the capabilities block */
1561         cptr = pci_read_config(dev, DC_PCI_CCAP, 4) & 0xFF;
1562
1563         r = pci_read_config(dev, cptr, 4) & 0xFF;
1564         if (r == 0x01) {
1565
1566                 r = pci_read_config(dev, cptr + 4, 4);
1567                 if (r & DC_PSTATE_D3) {
1568                         u_int32_t               iobase, membase, irq;
1569
1570                         /* Save important PCI config data. */
1571                         iobase = pci_read_config(dev, DC_PCI_CFBIO, 4);
1572                         membase = pci_read_config(dev, DC_PCI_CFBMA, 4);
1573                         irq = pci_read_config(dev, DC_PCI_CFIT, 4);
1574
1575                         /* Reset the power state. */
1576                         printf("dc%d: chip is in D%d power mode "
1577                             "-- setting to D0\n", unit, r & DC_PSTATE_D3);
1578                         r &= 0xFFFFFFFC;
1579                         pci_write_config(dev, cptr + 4, r, 4);
1580
1581                         /* Restore PCI config data. */
1582                         pci_write_config(dev, DC_PCI_CFBIO, iobase, 4);
1583                         pci_write_config(dev, DC_PCI_CFBMA, membase, 4);
1584                         pci_write_config(dev, DC_PCI_CFIT, irq, 4);
1585                 }
1586         }
1587         return;
1588 }
1589
1590 static void dc_apply_fixup(sc, media)
1591         struct dc_softc         *sc;
1592         int                     media;
1593 {
1594         struct dc_mediainfo     *m;
1595         u_int8_t                *p;
1596         int                     i;
1597         u_int32_t               reg;
1598
1599         m = sc->dc_mi;
1600
1601         while (m != NULL) {
1602                 if (m->dc_media == media)
1603                         break;
1604                 m = m->dc_next;
1605         }
1606
1607         if (m == NULL)
1608                 return;
1609
1610         for (i = 0, p = m->dc_reset_ptr; i < m->dc_reset_len; i++, p += 2) {
1611                 reg = (p[0] | (p[1] << 8)) << 16;
1612                 CSR_WRITE_4(sc, DC_WATCHDOG, reg);
1613         }
1614
1615         for (i = 0, p = m->dc_gp_ptr; i < m->dc_gp_len; i++, p += 2) {
1616                 reg = (p[0] | (p[1] << 8)) << 16;
1617                 CSR_WRITE_4(sc, DC_WATCHDOG, reg);
1618         }
1619
1620         return;
1621 }
1622
1623 static void dc_decode_leaf_sia(sc, l)
1624         struct dc_softc         *sc;
1625         struct dc_eblock_sia    *l;
1626 {
1627         struct dc_mediainfo     *m;
1628
1629         m = malloc(sizeof(struct dc_mediainfo), M_DEVBUF, M_INTWAIT | M_ZERO);
1630         if (l->dc_sia_code == DC_SIA_CODE_10BT)
1631                 m->dc_media = IFM_10_T;
1632
1633         if (l->dc_sia_code == DC_SIA_CODE_10BT_FDX)
1634                 m->dc_media = IFM_10_T|IFM_FDX;
1635
1636         if (l->dc_sia_code == DC_SIA_CODE_10B2)
1637                 m->dc_media = IFM_10_2;
1638
1639         if (l->dc_sia_code == DC_SIA_CODE_10B5)
1640                 m->dc_media = IFM_10_5;
1641
1642         m->dc_gp_len = 2;
1643         m->dc_gp_ptr = (u_int8_t *)&l->dc_sia_gpio_ctl;
1644
1645         m->dc_next = sc->dc_mi;
1646         sc->dc_mi = m;
1647
1648         sc->dc_pmode = DC_PMODE_SIA;
1649
1650         return;
1651 }
1652
1653 static void dc_decode_leaf_sym(sc, l)
1654         struct dc_softc         *sc;
1655         struct dc_eblock_sym    *l;
1656 {
1657         struct dc_mediainfo     *m;
1658
1659         m = malloc(sizeof(struct dc_mediainfo), M_DEVBUF, M_INTWAIT | M_ZERO);
1660         if (l->dc_sym_code == DC_SYM_CODE_100BT)
1661                 m->dc_media = IFM_100_TX;
1662
1663         if (l->dc_sym_code == DC_SYM_CODE_100BT_FDX)
1664                 m->dc_media = IFM_100_TX|IFM_FDX;
1665
1666         m->dc_gp_len = 2;
1667         m->dc_gp_ptr = (u_int8_t *)&l->dc_sym_gpio_ctl;
1668
1669         m->dc_next = sc->dc_mi;
1670         sc->dc_mi = m;
1671
1672         sc->dc_pmode = DC_PMODE_SYM;
1673
1674         return;
1675 }
1676
1677 static void dc_decode_leaf_mii(sc, l)
1678         struct dc_softc         *sc;
1679         struct dc_eblock_mii    *l;
1680 {
1681         u_int8_t                *p;
1682         struct dc_mediainfo     *m;
1683
1684         m = malloc(sizeof(struct dc_mediainfo), M_DEVBUF, M_INTWAIT | M_ZERO);
1685         /* We abuse IFM_AUTO to represent MII. */
1686         m->dc_media = IFM_AUTO;
1687         m->dc_gp_len = l->dc_gpr_len;
1688
1689         p = (u_int8_t *)l;
1690         p += sizeof(struct dc_eblock_mii);
1691         m->dc_gp_ptr = p;
1692         p += 2 * l->dc_gpr_len;
1693         m->dc_reset_len = *p;
1694         p++;
1695         m->dc_reset_ptr = p;
1696
1697         m->dc_next = sc->dc_mi;
1698         sc->dc_mi = m;
1699
1700         return;
1701 }
1702
1703 static void dc_read_srom(sc, bits)
1704         struct dc_softc         *sc;
1705         int                     bits;
1706 {
1707         int size;
1708
1709         size = 2 << bits;
1710         sc->dc_srom = malloc(size, M_DEVBUF, M_INTWAIT);
1711         dc_read_eeprom(sc, (caddr_t)sc->dc_srom, 0, (size / 2), 0);
1712 }
1713
1714 static void dc_parse_21143_srom(sc)
1715         struct dc_softc         *sc;
1716 {
1717         struct dc_leaf_hdr      *lhdr;
1718         struct dc_eblock_hdr    *hdr;
1719         int                     i, loff;
1720         char                    *ptr;
1721         int                     have_mii;
1722
1723         have_mii = 0;
1724         loff = sc->dc_srom[27];
1725         lhdr = (struct dc_leaf_hdr *)&(sc->dc_srom[loff]);
1726
1727         ptr = (char *)lhdr;
1728         ptr += sizeof(struct dc_leaf_hdr) - 1;
1729         /*
1730          * Look if we got a MII media block.
1731          */
1732         for (i = 0; i < lhdr->dc_mcnt; i++) {
1733                 hdr = (struct dc_eblock_hdr *)ptr;
1734                 if (hdr->dc_type == DC_EBLOCK_MII)
1735                     have_mii++;
1736
1737                 ptr += (hdr->dc_len & 0x7F);
1738                 ptr++;
1739         }
1740
1741         /*
1742          * Do the same thing again. Only use SIA and SYM media
1743          * blocks if no MII media block is available.
1744          */
1745         ptr = (char *)lhdr;
1746         ptr += sizeof(struct dc_leaf_hdr) - 1;
1747         for (i = 0; i < lhdr->dc_mcnt; i++) {
1748                 hdr = (struct dc_eblock_hdr *)ptr;
1749                 switch(hdr->dc_type) {
1750                 case DC_EBLOCK_MII:
1751                         dc_decode_leaf_mii(sc, (struct dc_eblock_mii *)hdr);
1752                         break;
1753                 case DC_EBLOCK_SIA:
1754                         if (! have_mii)
1755                                 dc_decode_leaf_sia(sc,
1756                                     (struct dc_eblock_sia *)hdr);
1757                         break;
1758                 case DC_EBLOCK_SYM:
1759                         if (! have_mii)
1760                                 dc_decode_leaf_sym(sc,
1761                                     (struct dc_eblock_sym *)hdr);
1762                         break;
1763                 default:
1764                         /* Don't care. Yet. */
1765                         break;
1766                 }
1767                 ptr += (hdr->dc_len & 0x7F);
1768                 ptr++;
1769         }
1770
1771         return;
1772 }
1773
1774 /*
1775  * Attach the interface. Allocate softc structures, do ifmedia
1776  * setup and ethernet/BPF attach.
1777  */
1778 static int dc_attach(dev)
1779         device_t                dev;
1780 {
1781         int                     s, tmp = 0;
1782         u_char                  eaddr[ETHER_ADDR_LEN];
1783         u_int32_t               command;
1784         struct dc_softc         *sc;
1785         struct ifnet            *ifp;
1786         u_int32_t               revision;
1787         int                     unit, error = 0, rid, mac_offset;
1788
1789         s = splimp();
1790
1791         sc = device_get_softc(dev);
1792         unit = device_get_unit(dev);
1793         bzero(sc, sizeof(struct dc_softc));
1794         callout_init(&sc->dc_stat_timer);
1795
1796         /*
1797          * Handle power management nonsense.
1798          */
1799         dc_acpi(dev);
1800
1801         /*
1802          * Map control/status registers.
1803          */
1804         command = pci_read_config(dev, PCIR_COMMAND, 4);
1805         command |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
1806         pci_write_config(dev, PCIR_COMMAND, command, 4);
1807         command = pci_read_config(dev, PCIR_COMMAND, 4);
1808
1809 #ifdef DC_USEIOSPACE
1810         if (!(command & PCIM_CMD_PORTEN)) {
1811                 printf("dc%d: failed to enable I/O ports!\n", unit);
1812                 error = ENXIO;
1813                 goto fail;
1814         }
1815 #else
1816         if (!(command & PCIM_CMD_MEMEN)) {
1817                 printf("dc%d: failed to enable memory mapping!\n", unit);
1818                 error = ENXIO;
1819                 goto fail;
1820         }
1821 #endif
1822
1823         rid = DC_RID;
1824         sc->dc_res = bus_alloc_resource(dev, DC_RES, &rid,
1825             0, ~0, 1, RF_ACTIVE);
1826
1827         if (sc->dc_res == NULL) {
1828                 printf("dc%d: couldn't map ports/memory\n", unit);
1829                 error = ENXIO;
1830                 goto fail;
1831         }
1832
1833         sc->dc_btag = rman_get_bustag(sc->dc_res);
1834         sc->dc_bhandle = rman_get_bushandle(sc->dc_res);
1835
1836         /* Allocate interrupt */
1837         rid = 0;
1838         sc->dc_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
1839             RF_SHAREABLE | RF_ACTIVE);
1840
1841         if (sc->dc_irq == NULL) {
1842                 printf("dc%d: couldn't map interrupt\n", unit);
1843                 bus_release_resource(dev, DC_RES, DC_RID, sc->dc_res);
1844                 error = ENXIO;
1845                 goto fail;
1846         }
1847
1848         error = bus_setup_intr(dev, sc->dc_irq, INTR_TYPE_NET,
1849             dc_intr, sc, &sc->dc_intrhand);
1850
1851         if (error) {
1852                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->dc_irq);
1853                 bus_release_resource(dev, DC_RES, DC_RID, sc->dc_res);
1854                 printf("dc%d: couldn't set up irq\n", unit);
1855                 goto fail;
1856         }
1857
1858         /* Need this info to decide on a chip type. */
1859         sc->dc_info = dc_devtype(dev);
1860         revision = pci_read_config(dev, DC_PCI_CFRV, 4) & 0x000000FF;
1861
1862         /* Get the eeprom width, but PNIC has diff eeprom */
1863         if (sc->dc_info->dc_did != DC_DEVICEID_82C168)
1864                 dc_eeprom_width(sc);
1865
1866         switch(sc->dc_info->dc_did) {
1867         case DC_DEVICEID_21143:
1868                 sc->dc_type = DC_TYPE_21143;
1869                 sc->dc_flags |= DC_TX_POLL|DC_TX_USE_TX_INTR;
1870                 sc->dc_flags |= DC_REDUCED_MII_POLL;
1871                 /* Save EEPROM contents so we can parse them later. */
1872                 dc_read_srom(sc, sc->dc_romwidth);
1873                 break;
1874         case DC_DEVICEID_DM9009:
1875         case DC_DEVICEID_DM9100:
1876         case DC_DEVICEID_DM9102:
1877                 sc->dc_type = DC_TYPE_DM9102;
1878                 sc->dc_flags |= DC_TX_COALESCE|DC_TX_INTR_ALWAYS;
1879                 sc->dc_flags |= DC_REDUCED_MII_POLL|DC_TX_STORENFWD;
1880                 sc->dc_pmode = DC_PMODE_MII;
1881                 /* Increase the latency timer value. */
1882                 command = pci_read_config(dev, DC_PCI_CFLT, 4);
1883                 command &= 0xFFFF00FF;
1884                 command |= 0x00008000;
1885                 pci_write_config(dev, DC_PCI_CFLT, command, 4);
1886                 break;
1887         case DC_DEVICEID_AL981:
1888                 sc->dc_type = DC_TYPE_AL981;
1889                 sc->dc_flags |= DC_TX_USE_TX_INTR;
1890                 sc->dc_flags |= DC_TX_ADMTEK_WAR;
1891                 sc->dc_pmode = DC_PMODE_MII;
1892                 dc_read_srom(sc, sc->dc_romwidth);
1893                 break;
1894         case DC_DEVICEID_AN985:
1895         case DC_DEVICEID_EN2242:
1896         case DC_DEVICEID_3CSOHOB:
1897                 sc->dc_type = DC_TYPE_AN985;
1898                 sc->dc_flags |= DC_64BIT_HASH;
1899                 sc->dc_flags |= DC_TX_USE_TX_INTR;
1900                 sc->dc_flags |= DC_TX_ADMTEK_WAR;
1901                 sc->dc_pmode = DC_PMODE_MII;
1902                 dc_read_srom(sc, sc->dc_romwidth);
1903                 break;
1904         case DC_DEVICEID_98713:
1905         case DC_DEVICEID_98713_CP:
1906                 if (revision < DC_REVISION_98713A) {
1907                         sc->dc_type = DC_TYPE_98713;
1908                 }
1909                 if (revision >= DC_REVISION_98713A) {
1910                         sc->dc_type = DC_TYPE_98713A;
1911                         sc->dc_flags |= DC_21143_NWAY;
1912                 }
1913                 sc->dc_flags |= DC_REDUCED_MII_POLL;
1914                 sc->dc_flags |= DC_TX_POLL|DC_TX_USE_TX_INTR;
1915                 break;
1916         case DC_DEVICEID_987x5:
1917         case DC_DEVICEID_EN1217:
1918                 /*
1919                  * Macronix MX98715AEC-C/D/E parts have only a
1920                  * 128-bit hash table. We need to deal with these
1921                  * in the same manner as the PNIC II so that we
1922                  * get the right number of bits out of the
1923                  * CRC routine.
1924                  */
1925                 if (revision >= DC_REVISION_98715AEC_C &&
1926                     revision < DC_REVISION_98725)
1927                         sc->dc_flags |= DC_128BIT_HASH;
1928                 sc->dc_type = DC_TYPE_987x5;
1929                 sc->dc_flags |= DC_TX_POLL|DC_TX_USE_TX_INTR;
1930                 sc->dc_flags |= DC_REDUCED_MII_POLL|DC_21143_NWAY;
1931                 break;
1932         case DC_DEVICEID_98727:
1933                 sc->dc_type = DC_TYPE_987x5;
1934                 sc->dc_flags |= DC_TX_POLL|DC_TX_USE_TX_INTR;
1935                 sc->dc_flags |= DC_REDUCED_MII_POLL|DC_21143_NWAY;
1936                 break;
1937         case DC_DEVICEID_82C115:
1938                 sc->dc_type = DC_TYPE_PNICII;
1939                 sc->dc_flags |= DC_TX_POLL|DC_TX_USE_TX_INTR|DC_128BIT_HASH;
1940                 sc->dc_flags |= DC_REDUCED_MII_POLL|DC_21143_NWAY;
1941                 break;
1942         case DC_DEVICEID_82C168:
1943                 sc->dc_type = DC_TYPE_PNIC;
1944                 sc->dc_flags |= DC_TX_STORENFWD|DC_TX_INTR_ALWAYS;
1945                 sc->dc_flags |= DC_PNIC_RX_BUG_WAR;
1946                 sc->dc_pnic_rx_buf = malloc(DC_RXLEN * 5, M_DEVBUF, M_WAITOK);
1947                 if (revision < DC_REVISION_82C169)
1948                         sc->dc_pmode = DC_PMODE_SYM;
1949                 break;
1950         case DC_DEVICEID_AX88140A:
1951                 sc->dc_type = DC_TYPE_ASIX;
1952                 sc->dc_flags |= DC_TX_USE_TX_INTR|DC_TX_INTR_FIRSTFRAG;
1953                 sc->dc_flags |= DC_REDUCED_MII_POLL;
1954                 sc->dc_pmode = DC_PMODE_MII;
1955                 break;
1956         case DC_DEVICEID_RS7112:
1957                 sc->dc_type = DC_TYPE_CONEXANT;
1958                 sc->dc_flags |= DC_TX_INTR_ALWAYS;
1959                 sc->dc_flags |= DC_REDUCED_MII_POLL;
1960                 sc->dc_pmode = DC_PMODE_MII;
1961                 dc_read_srom(sc, sc->dc_romwidth);
1962                 break;
1963         default:
1964                 printf("dc%d: unknown device: %x\n", sc->dc_unit,
1965                     sc->dc_info->dc_did);
1966                 break;
1967         }
1968
1969         /* Save the cache line size. */
1970         if (DC_IS_DAVICOM(sc))
1971                 sc->dc_cachesize = 0;
1972         else
1973                 sc->dc_cachesize = pci_read_config(dev,
1974                     DC_PCI_CFLT, 4) & 0xFF;
1975
1976         /* Reset the adapter. */
1977         dc_reset(sc);
1978
1979         /* Take 21143 out of snooze mode */
1980         if (DC_IS_INTEL(sc)) {
1981                 command = pci_read_config(dev, DC_PCI_CFDD, 4);
1982                 command &= ~(DC_CFDD_SNOOZE_MODE|DC_CFDD_SLEEP_MODE);
1983                 pci_write_config(dev, DC_PCI_CFDD, command, 4);
1984         }
1985
1986         /*
1987          * Try to learn something about the supported media.
1988          * We know that ASIX and ADMtek and Davicom devices
1989          * will *always* be using MII media, so that's a no-brainer.
1990          * The tricky ones are the Macronix/PNIC II and the
1991          * Intel 21143.
1992          */
1993         if (DC_IS_INTEL(sc))
1994                 dc_parse_21143_srom(sc);
1995         else if (DC_IS_MACRONIX(sc) || DC_IS_PNICII(sc)) {
1996                 if (sc->dc_type == DC_TYPE_98713)
1997                         sc->dc_pmode = DC_PMODE_MII;
1998                 else
1999                         sc->dc_pmode = DC_PMODE_SYM;
2000         } else if (!sc->dc_pmode)
2001                 sc->dc_pmode = DC_PMODE_MII;
2002
2003         /*
2004          * Get station address from the EEPROM.
2005          */
2006         switch(sc->dc_type) {
2007         case DC_TYPE_98713:
2008         case DC_TYPE_98713A:
2009         case DC_TYPE_987x5:
2010         case DC_TYPE_PNICII:
2011                 dc_read_eeprom(sc, (caddr_t)&mac_offset,
2012                     (DC_EE_NODEADDR_OFFSET / 2), 1, 0);
2013                 dc_read_eeprom(sc, (caddr_t)&eaddr, (mac_offset / 2), 3, 0);
2014                 break;
2015         case DC_TYPE_PNIC:
2016                 dc_read_eeprom(sc, (caddr_t)&eaddr, 0, 3, 1);
2017                 break;
2018         case DC_TYPE_DM9102:
2019         case DC_TYPE_21143:
2020         case DC_TYPE_ASIX:
2021                 dc_read_eeprom(sc, (caddr_t)&eaddr, DC_EE_NODEADDR, 3, 0);
2022                 break;
2023         case DC_TYPE_AL981:
2024         case DC_TYPE_AN985:
2025                 bcopy(&sc->dc_srom[DC_AL_EE_NODEADDR], (caddr_t)&eaddr,
2026                     ETHER_ADDR_LEN);
2027                 dc_read_eeprom(sc, (caddr_t)&eaddr, DC_AL_EE_NODEADDR, 3, 0);
2028                 break;
2029         case DC_TYPE_CONEXANT:
2030                 bcopy(sc->dc_srom + DC_CONEXANT_EE_NODEADDR, &eaddr, 6);
2031                 break;
2032         default:
2033                 dc_read_eeprom(sc, (caddr_t)&eaddr, DC_EE_NODEADDR, 3, 0);
2034                 break;
2035         }
2036
2037         sc->dc_unit = unit;
2038
2039         sc->dc_ldata = contigmalloc(sizeof(struct dc_list_data), M_DEVBUF,
2040             M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0);
2041
2042         if (sc->dc_ldata == NULL) {
2043                 printf("dc%d: no memory for list buffers!\n", unit);
2044                 if (sc->dc_pnic_rx_buf != NULL)
2045                         free(sc->dc_pnic_rx_buf, M_DEVBUF);
2046                 bus_teardown_intr(dev, sc->dc_irq, sc->dc_intrhand);
2047                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->dc_irq);
2048                 bus_release_resource(dev, DC_RES, DC_RID, sc->dc_res);
2049                 error = ENXIO;
2050                 goto fail;
2051         }
2052
2053         bzero(sc->dc_ldata, sizeof(struct dc_list_data));
2054
2055         ifp = &sc->arpcom.ac_if;
2056         ifp->if_softc = sc;
2057         if_initname(ifp, "dc", unit);
2058         ifp->if_mtu = ETHERMTU;
2059         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
2060         ifp->if_ioctl = dc_ioctl;
2061         ifp->if_start = dc_start;
2062         ifp->if_watchdog = dc_watchdog;
2063         ifp->if_init = dc_init;
2064         ifp->if_baudrate = 10000000;
2065         ifp->if_snd.ifq_maxlen = DC_TX_LIST_CNT - 1;
2066
2067         /*
2068          * Do MII setup. If this is a 21143, check for a PHY on the
2069          * MII bus after applying any necessary fixups to twiddle the
2070          * GPIO bits. If we don't end up finding a PHY, restore the
2071          * old selection (SIA only or SIA/SYM) and attach the dcphy
2072          * driver instead.
2073          */
2074         if (DC_IS_INTEL(sc)) {
2075                 dc_apply_fixup(sc, IFM_AUTO);
2076                 tmp = sc->dc_pmode;
2077                 sc->dc_pmode = DC_PMODE_MII;
2078         }
2079
2080         error = mii_phy_probe(dev, &sc->dc_miibus,
2081             dc_ifmedia_upd, dc_ifmedia_sts);
2082
2083         if (error && DC_IS_INTEL(sc)) {
2084                 sc->dc_pmode = tmp;
2085                 if (sc->dc_pmode != DC_PMODE_SIA)
2086                         sc->dc_pmode = DC_PMODE_SYM;
2087                 sc->dc_flags |= DC_21143_NWAY;
2088                 mii_phy_probe(dev, &sc->dc_miibus,
2089                     dc_ifmedia_upd, dc_ifmedia_sts);
2090                 /*
2091                  * For non-MII cards, we need to have the 21143
2092                  * drive the LEDs. Except there are some systems
2093                  * like the NEC VersaPro NoteBook PC which have no
2094                  * LEDs, and twiddling these bits has adverse effects
2095                  * on them. (I.e. you suddenly can't get a link.)
2096                  */
2097                 if (pci_read_config(dev, DC_PCI_CSID, 4) != 0x80281033)
2098                         sc->dc_flags |= DC_TULIP_LEDS;
2099                 error = 0;
2100         }
2101
2102         if (error) {
2103                 printf("dc%d: MII without any PHY!\n", sc->dc_unit);
2104                 contigfree(sc->dc_ldata, sizeof(struct dc_list_data),
2105                     M_DEVBUF);
2106                 if (sc->dc_pnic_rx_buf != NULL)
2107                         free(sc->dc_pnic_rx_buf, M_DEVBUF);
2108                 bus_teardown_intr(dev, sc->dc_irq, sc->dc_intrhand);
2109                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->dc_irq);
2110                 bus_release_resource(dev, DC_RES, DC_RID, sc->dc_res);
2111                 error = ENXIO;
2112                 goto fail;
2113         }
2114
2115         /*
2116          * Call MI attach routine.
2117          */
2118         ether_ifattach(ifp, eaddr);
2119
2120         if (DC_IS_ADMTEK(sc)) {
2121                 /*
2122                  * Set automatic TX underrun recovery for the ADMtek chips
2123                  */
2124                 DC_SETBIT(sc, DC_AL_CR, DC_AL_CR_ATUR);
2125         }
2126
2127         /*
2128          * Tell the upper layer(s) we support long frames.
2129          */
2130         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
2131
2132 #ifdef SRM_MEDIA
2133         sc->dc_srm_media = 0;
2134
2135         /* Remember the SRM console media setting */
2136         if (DC_IS_INTEL(sc)) {
2137                 command = pci_read_config(dev, DC_PCI_CFDD, 4);
2138                 command &= ~(DC_CFDD_SNOOZE_MODE|DC_CFDD_SLEEP_MODE);
2139                 switch ((command >> 8) & 0xff) {
2140                 case 3:
2141                         sc->dc_srm_media = IFM_10_T;
2142                         break;
2143                 case 4:
2144                         sc->dc_srm_media = IFM_10_T | IFM_FDX;
2145                         break;
2146                 case 5:
2147                         sc->dc_srm_media = IFM_100_TX;
2148                         break;
2149                 case 6:
2150                         sc->dc_srm_media = IFM_100_TX | IFM_FDX;
2151                         break;
2152                 }
2153                 if (sc->dc_srm_media)
2154                         sc->dc_srm_media |= IFM_ACTIVE | IFM_ETHER;
2155         }
2156 #endif
2157
2158
2159 fail:
2160         splx(s);
2161
2162         return(error);
2163 }
2164
2165 static int dc_detach(dev)
2166         device_t                dev;
2167 {
2168         struct dc_softc         *sc;
2169         struct ifnet            *ifp;
2170         int                     s;
2171         struct dc_mediainfo     *m;
2172
2173         s = splimp();
2174
2175         sc = device_get_softc(dev);
2176         ifp = &sc->arpcom.ac_if;
2177
2178         dc_stop(sc);
2179         ether_ifdetach(ifp);
2180
2181         bus_generic_detach(dev);
2182         device_delete_child(dev, sc->dc_miibus);
2183
2184         bus_teardown_intr(dev, sc->dc_irq, sc->dc_intrhand);
2185         bus_release_resource(dev, SYS_RES_IRQ, 0, sc->dc_irq);
2186         bus_release_resource(dev, DC_RES, DC_RID, sc->dc_res);
2187
2188         contigfree(sc->dc_ldata, sizeof(struct dc_list_data), M_DEVBUF);
2189         if (sc->dc_pnic_rx_buf != NULL)
2190                 free(sc->dc_pnic_rx_buf, M_DEVBUF);
2191
2192         while(sc->dc_mi != NULL) {
2193                 m = sc->dc_mi->dc_next;
2194                 free(sc->dc_mi, M_DEVBUF);
2195                 sc->dc_mi = m;
2196         }
2197         free(sc->dc_srom, M_DEVBUF);
2198
2199         splx(s);
2200
2201         return(0);
2202 }
2203
2204 /*
2205  * Initialize the transmit descriptors.
2206  */
2207 static int dc_list_tx_init(sc)
2208         struct dc_softc         *sc;
2209 {
2210         struct dc_chain_data    *cd;
2211         struct dc_list_data     *ld;
2212         int                     i;
2213
2214         cd = &sc->dc_cdata;
2215         ld = sc->dc_ldata;
2216         for (i = 0; i < DC_TX_LIST_CNT; i++) {
2217                 if (i == (DC_TX_LIST_CNT - 1)) {
2218                         ld->dc_tx_list[i].dc_next =
2219                             vtophys(&ld->dc_tx_list[0]);
2220                 } else {
2221                         ld->dc_tx_list[i].dc_next =
2222                             vtophys(&ld->dc_tx_list[i + 1]);
2223                 }
2224                 cd->dc_tx_chain[i] = NULL;
2225                 ld->dc_tx_list[i].dc_data = 0;
2226                 ld->dc_tx_list[i].dc_ctl = 0;
2227         }
2228
2229         cd->dc_tx_prod = cd->dc_tx_cons = cd->dc_tx_cnt = 0;
2230
2231         return(0);
2232 }
2233
2234
2235 /*
2236  * Initialize the RX descriptors and allocate mbufs for them. Note that
2237  * we arrange the descriptors in a closed ring, so that the last descriptor
2238  * points back to the first.
2239  */
2240 static int dc_list_rx_init(sc)
2241         struct dc_softc         *sc;
2242 {
2243         struct dc_chain_data    *cd;
2244         struct dc_list_data     *ld;
2245         int                     i;
2246
2247         cd = &sc->dc_cdata;
2248         ld = sc->dc_ldata;
2249
2250         for (i = 0; i < DC_RX_LIST_CNT; i++) {
2251                 if (dc_newbuf(sc, i, NULL) == ENOBUFS)
2252                         return(ENOBUFS);
2253                 if (i == (DC_RX_LIST_CNT - 1)) {
2254                         ld->dc_rx_list[i].dc_next =
2255                             vtophys(&ld->dc_rx_list[0]);
2256                 } else {
2257                         ld->dc_rx_list[i].dc_next =
2258                             vtophys(&ld->dc_rx_list[i + 1]);
2259                 }
2260         }
2261
2262         cd->dc_rx_prod = 0;
2263
2264         return(0);
2265 }
2266
2267 /*
2268  * Initialize an RX descriptor and attach an MBUF cluster.
2269  */
2270 static int dc_newbuf(sc, i, m)
2271         struct dc_softc         *sc;
2272         int                     i;
2273         struct mbuf             *m;
2274 {
2275         struct mbuf             *m_new = NULL;
2276         struct dc_desc          *c;
2277
2278         c = &sc->dc_ldata->dc_rx_list[i];
2279
2280         if (m == NULL) {
2281                 MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
2282                 if (m_new == NULL)
2283                         return(ENOBUFS);
2284
2285                 MCLGET(m_new, MB_DONTWAIT);
2286                 if (!(m_new->m_flags & M_EXT)) {
2287                         m_freem(m_new);
2288                         return(ENOBUFS);
2289                 }
2290                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
2291         } else {
2292                 m_new = m;
2293                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
2294                 m_new->m_data = m_new->m_ext.ext_buf;
2295         }
2296
2297         m_adj(m_new, sizeof(u_int64_t));
2298
2299         /*
2300          * If this is a PNIC chip, zero the buffer. This is part
2301          * of the workaround for the receive bug in the 82c168 and
2302          * 82c169 chips.
2303          */
2304         if (sc->dc_flags & DC_PNIC_RX_BUG_WAR)
2305                 bzero((char *)mtod(m_new, char *), m_new->m_len);
2306
2307         sc->dc_cdata.dc_rx_chain[i] = m_new;
2308         c->dc_data = vtophys(mtod(m_new, caddr_t));
2309         c->dc_ctl = DC_RXCTL_RLINK | DC_RXLEN;
2310         c->dc_status = DC_RXSTAT_OWN;
2311
2312         return(0);
2313 }
2314
2315 /*
2316  * Grrrrr.
2317  * The PNIC chip has a terrible bug in it that manifests itself during
2318  * periods of heavy activity. The exact mode of failure if difficult to
2319  * pinpoint: sometimes it only happens in promiscuous mode, sometimes it
2320  * will happen on slow machines. The bug is that sometimes instead of
2321  * uploading one complete frame during reception, it uploads what looks
2322  * like the entire contents of its FIFO memory. The frame we want is at
2323  * the end of the whole mess, but we never know exactly how much data has
2324  * been uploaded, so salvaging the frame is hard.
2325  *
2326  * There is only one way to do it reliably, and it's disgusting.
2327  * Here's what we know:
2328  *
2329  * - We know there will always be somewhere between one and three extra
2330  *   descriptors uploaded.
2331  *
2332  * - We know the desired received frame will always be at the end of the
2333  *   total data upload.
2334  *
2335  * - We know the size of the desired received frame because it will be
2336  *   provided in the length field of the status word in the last descriptor.
2337  *
2338  * Here's what we do:
2339  *
2340  * - When we allocate buffers for the receive ring, we bzero() them.
2341  *   This means that we know that the buffer contents should be all
2342  *   zeros, except for data uploaded by the chip.
2343  *
2344  * - We also force the PNIC chip to upload frames that include the
2345  *   ethernet CRC at the end.
2346  *
2347  * - We gather all of the bogus frame data into a single buffer.
2348  *
2349  * - We then position a pointer at the end of this buffer and scan
2350  *   backwards until we encounter the first non-zero byte of data.
2351  *   This is the end of the received frame. We know we will encounter
2352  *   some data at the end of the frame because the CRC will always be
2353  *   there, so even if the sender transmits a packet of all zeros,
2354  *   we won't be fooled.
2355  *
2356  * - We know the size of the actual received frame, so we subtract
2357  *   that value from the current pointer location. This brings us
2358  *   to the start of the actual received packet.
2359  *
2360  * - We copy this into an mbuf and pass it on, along with the actual
2361  *   frame length.
2362  *
2363  * The performance hit is tremendous, but it beats dropping frames all
2364  * the time.
2365  */
2366
2367 #define DC_WHOLEFRAME   (DC_RXSTAT_FIRSTFRAG|DC_RXSTAT_LASTFRAG)
2368 static void dc_pnic_rx_bug_war(sc, idx)
2369         struct dc_softc         *sc;
2370         int                     idx;
2371 {
2372         struct dc_desc          *cur_rx;
2373         struct dc_desc          *c = NULL;
2374         struct mbuf             *m = NULL;
2375         unsigned char           *ptr;
2376         int                     i, total_len;
2377         u_int32_t               rxstat = 0;
2378
2379         i = sc->dc_pnic_rx_bug_save;
2380         cur_rx = &sc->dc_ldata->dc_rx_list[idx];
2381         ptr = sc->dc_pnic_rx_buf;
2382         bzero(ptr, DC_RXLEN * 5);
2383
2384         /* Copy all the bytes from the bogus buffers. */
2385         while (1) {
2386                 c = &sc->dc_ldata->dc_rx_list[i];
2387                 rxstat = c->dc_status;
2388                 m = sc->dc_cdata.dc_rx_chain[i];
2389                 bcopy(mtod(m, char *), ptr, DC_RXLEN);
2390                 ptr += DC_RXLEN;
2391                 /* If this is the last buffer, break out. */
2392                 if (i == idx || rxstat & DC_RXSTAT_LASTFRAG)
2393                         break;
2394                 dc_newbuf(sc, i, m);
2395                 DC_INC(i, DC_RX_LIST_CNT);
2396         }
2397
2398         /* Find the length of the actual receive frame. */
2399         total_len = DC_RXBYTES(rxstat);
2400
2401         /* Scan backwards until we hit a non-zero byte. */
2402         while(*ptr == 0x00)
2403                 ptr--;
2404
2405         /* Round off. */
2406         if ((uintptr_t)(ptr) & 0x3)
2407                 ptr -= 1;
2408
2409         /* Now find the start of the frame. */
2410         ptr -= total_len;
2411         if (ptr < sc->dc_pnic_rx_buf)
2412                 ptr = sc->dc_pnic_rx_buf;
2413
2414         /*
2415          * Now copy the salvaged frame to the last mbuf and fake up
2416          * the status word to make it look like a successful
2417          * frame reception.
2418          */
2419         dc_newbuf(sc, i, m);
2420         bcopy(ptr, mtod(m, char *), total_len);
2421         cur_rx->dc_status = rxstat | DC_RXSTAT_FIRSTFRAG;
2422
2423         return;
2424 }
2425
2426 /*
2427  * This routine searches the RX ring for dirty descriptors in the
2428  * event that the rxeof routine falls out of sync with the chip's
2429  * current descriptor pointer. This may happen sometimes as a result
2430  * of a "no RX buffer available" condition that happens when the chip
2431  * consumes all of the RX buffers before the driver has a chance to
2432  * process the RX ring. This routine may need to be called more than
2433  * once to bring the driver back in sync with the chip, however we
2434  * should still be getting RX DONE interrupts to drive the search
2435  * for new packets in the RX ring, so we should catch up eventually.
2436  */
2437 static int dc_rx_resync(sc)
2438         struct dc_softc         *sc;
2439 {
2440         int                     i, pos;
2441         struct dc_desc          *cur_rx;
2442
2443         pos = sc->dc_cdata.dc_rx_prod;
2444
2445         for (i = 0; i < DC_RX_LIST_CNT; i++) {
2446                 cur_rx = &sc->dc_ldata->dc_rx_list[pos];
2447                 if (!(cur_rx->dc_status & DC_RXSTAT_OWN))
2448                         break;
2449                 DC_INC(pos, DC_RX_LIST_CNT);
2450         }
2451
2452         /* If the ring really is empty, then just return. */
2453         if (i == DC_RX_LIST_CNT)
2454                 return(0);
2455
2456         /* We've fallen behing the chip: catch it. */
2457         sc->dc_cdata.dc_rx_prod = pos;
2458
2459         return(EAGAIN);
2460 }
2461
2462 /*
2463  * A frame has been uploaded: pass the resulting mbuf chain up to
2464  * the higher level protocols.
2465  */
2466 static void dc_rxeof(sc)
2467         struct dc_softc         *sc;
2468 {
2469         struct mbuf             *m;
2470         struct ifnet            *ifp;
2471         struct dc_desc          *cur_rx;
2472         int                     i, total_len = 0;
2473         u_int32_t               rxstat;
2474
2475         ifp = &sc->arpcom.ac_if;
2476         i = sc->dc_cdata.dc_rx_prod;
2477
2478         while(!(sc->dc_ldata->dc_rx_list[i].dc_status & DC_RXSTAT_OWN)) {
2479
2480 #ifdef DEVICE_POLLING
2481                 if (ifp->if_flags & IFF_POLLING) {
2482                         if (sc->rxcycles <= 0)
2483                                 break;
2484                         sc->rxcycles--;
2485                 }
2486 #endif /* DEVICE_POLLING */
2487                 cur_rx = &sc->dc_ldata->dc_rx_list[i];
2488                 rxstat = cur_rx->dc_status;
2489                 m = sc->dc_cdata.dc_rx_chain[i];
2490                 total_len = DC_RXBYTES(rxstat);
2491
2492                 if (sc->dc_flags & DC_PNIC_RX_BUG_WAR) {
2493                         if ((rxstat & DC_WHOLEFRAME) != DC_WHOLEFRAME) {
2494                                 if (rxstat & DC_RXSTAT_FIRSTFRAG)
2495                                         sc->dc_pnic_rx_bug_save = i;
2496                                 if ((rxstat & DC_RXSTAT_LASTFRAG) == 0) {
2497                                         DC_INC(i, DC_RX_LIST_CNT);
2498                                         continue;
2499                                 }
2500                                 dc_pnic_rx_bug_war(sc, i);
2501                                 rxstat = cur_rx->dc_status;
2502                                 total_len = DC_RXBYTES(rxstat);
2503                         }
2504                 }
2505
2506                 sc->dc_cdata.dc_rx_chain[i] = NULL;
2507
2508                 /*
2509                  * If an error occurs, update stats, clear the
2510                  * status word and leave the mbuf cluster in place:
2511                  * it should simply get re-used next time this descriptor
2512                  * comes up in the ring.  However, don't report long
2513                  * frames as errors since they could be vlans
2514                  */
2515                 if ((rxstat & DC_RXSTAT_RXERR)){
2516                         if (!(rxstat & DC_RXSTAT_GIANT) ||
2517                             (rxstat & (DC_RXSTAT_CRCERR | DC_RXSTAT_DRIBBLE |
2518                                        DC_RXSTAT_MIIERE | DC_RXSTAT_COLLSEEN |
2519                                        DC_RXSTAT_RUNT   | DC_RXSTAT_DE))) {
2520                                 ifp->if_ierrors++;
2521                                 if (rxstat & DC_RXSTAT_COLLSEEN)
2522                                         ifp->if_collisions++;
2523                                 dc_newbuf(sc, i, m);
2524                                 if (rxstat & DC_RXSTAT_CRCERR) {
2525                                         DC_INC(i, DC_RX_LIST_CNT);
2526                                         continue;
2527                                 } else {
2528                                         dc_init(sc);
2529                                         return;
2530                                 }
2531                         }
2532                 }
2533
2534                 /* No errors; receive the packet. */
2535                 total_len -= ETHER_CRC_LEN;
2536
2537 #ifdef __i386__
2538                 /*
2539                  * On the x86 we do not have alignment problems, so try to
2540                  * allocate a new buffer for the receive ring, and pass up
2541                  * the one where the packet is already, saving the expensive
2542                  * copy done in m_devget().
2543                  * If we are on an architecture with alignment problems, or
2544                  * if the allocation fails, then use m_devget and leave the
2545                  * existing buffer in the receive ring.
2546                  */
2547                 if (dc_quick && dc_newbuf(sc, i, NULL) == 0) {
2548                         m->m_pkthdr.rcvif = ifp;
2549                         m->m_pkthdr.len = m->m_len = total_len;
2550                         DC_INC(i, DC_RX_LIST_CNT);
2551                 } else
2552 #endif
2553                 {
2554                         struct mbuf *m0;
2555
2556                         m0 = m_devget(mtod(m, char *) - ETHER_ALIGN,
2557                             total_len + ETHER_ALIGN, 0, ifp, NULL);
2558                         dc_newbuf(sc, i, m);
2559                         DC_INC(i, DC_RX_LIST_CNT);
2560                         if (m0 == NULL) {
2561                                 ifp->if_ierrors++;
2562                                 continue;
2563                         }
2564                         m_adj(m0, ETHER_ALIGN);
2565                         m = m0;
2566                 }
2567
2568                 ifp->if_ipackets++;
2569                 (*ifp->if_input)(ifp, m);
2570         }
2571
2572         sc->dc_cdata.dc_rx_prod = i;
2573 }
2574
2575 /*
2576  * A frame was downloaded to the chip. It's safe for us to clean up
2577  * the list buffers.
2578  */
2579
2580 static void
2581 dc_txeof(sc)
2582         struct dc_softc         *sc;
2583 {
2584         struct dc_desc          *cur_tx = NULL;
2585         struct ifnet            *ifp;
2586         int                     idx;
2587
2588         ifp = &sc->arpcom.ac_if;
2589
2590         /*
2591          * Go through our tx list and free mbufs for those
2592          * frames that have been transmitted.
2593          */
2594         idx = sc->dc_cdata.dc_tx_cons;
2595         while(idx != sc->dc_cdata.dc_tx_prod) {
2596                 u_int32_t               txstat;
2597
2598                 cur_tx = &sc->dc_ldata->dc_tx_list[idx];
2599                 txstat = cur_tx->dc_status;
2600
2601                 if (txstat & DC_TXSTAT_OWN)
2602                         break;
2603
2604                 if (!(cur_tx->dc_ctl & DC_TXCTL_LASTFRAG) ||
2605                     cur_tx->dc_ctl & DC_TXCTL_SETUP) {
2606                         if (cur_tx->dc_ctl & DC_TXCTL_SETUP) {
2607                                 /*
2608                                  * Yes, the PNIC is so brain damaged
2609                                  * that it will sometimes generate a TX
2610                                  * underrun error while DMAing the RX
2611                                  * filter setup frame. If we detect this,
2612                                  * we have to send the setup frame again,
2613                                  * or else the filter won't be programmed
2614                                  * correctly.
2615                                  */
2616                                 if (DC_IS_PNIC(sc)) {
2617                                         if (txstat & DC_TXSTAT_ERRSUM)
2618                                                 dc_setfilt(sc);
2619                                 }
2620                                 sc->dc_cdata.dc_tx_chain[idx] = NULL;
2621                         }
2622                         sc->dc_cdata.dc_tx_cnt--;
2623                         DC_INC(idx, DC_TX_LIST_CNT);
2624                         continue;
2625                 }
2626
2627                 if (DC_IS_CONEXANT(sc)) {
2628                         /*
2629                          * For some reason Conexant chips like
2630                          * setting the CARRLOST flag even when
2631                          * the carrier is there. In CURRENT we
2632                          * have the same problem for Xircom
2633                          * cards !
2634                          */
2635                         if (/*sc->dc_type == DC_TYPE_21143 &&*/
2636                             sc->dc_pmode == DC_PMODE_MII &&
2637                             ((txstat & 0xFFFF) & ~(DC_TXSTAT_ERRSUM|
2638                             DC_TXSTAT_NOCARRIER)))
2639                                 txstat &= ~DC_TXSTAT_ERRSUM;
2640                 } else {
2641                         if (/*sc->dc_type == DC_TYPE_21143 &&*/
2642                             sc->dc_pmode == DC_PMODE_MII &&
2643                             ((txstat & 0xFFFF) & ~(DC_TXSTAT_ERRSUM|
2644                             DC_TXSTAT_NOCARRIER|DC_TXSTAT_CARRLOST)))
2645                                 txstat &= ~DC_TXSTAT_ERRSUM;
2646                 }
2647
2648                 if (txstat & DC_TXSTAT_ERRSUM) {
2649                         ifp->if_oerrors++;
2650                         if (txstat & DC_TXSTAT_EXCESSCOLL)
2651                                 ifp->if_collisions++;
2652                         if (txstat & DC_TXSTAT_LATECOLL)
2653                                 ifp->if_collisions++;
2654                         if (!(txstat & DC_TXSTAT_UNDERRUN)) {
2655                                 dc_init(sc);
2656                                 return;
2657                         }
2658                 }
2659
2660                 ifp->if_collisions += (txstat & DC_TXSTAT_COLLCNT) >> 3;
2661
2662                 ifp->if_opackets++;
2663                 if (sc->dc_cdata.dc_tx_chain[idx] != NULL) {
2664                         m_freem(sc->dc_cdata.dc_tx_chain[idx]);
2665                         sc->dc_cdata.dc_tx_chain[idx] = NULL;
2666                 }
2667
2668                 sc->dc_cdata.dc_tx_cnt--;
2669                 DC_INC(idx, DC_TX_LIST_CNT);
2670         }
2671
2672         if (idx != sc->dc_cdata.dc_tx_cons) {
2673                 /* some buffers have been freed */
2674                 sc->dc_cdata.dc_tx_cons = idx;
2675                 ifp->if_flags &= ~IFF_OACTIVE;
2676         }
2677         ifp->if_timer = (sc->dc_cdata.dc_tx_cnt == 0) ? 0 : 5;
2678
2679         return;
2680 }
2681
2682 static void dc_tick(xsc)
2683         void                    *xsc;
2684 {
2685         struct dc_softc         *sc;
2686         struct mii_data         *mii;
2687         struct ifnet            *ifp;
2688         int                     s;
2689         u_int32_t               r;
2690
2691         s = splimp();
2692
2693         sc = xsc;
2694         ifp = &sc->arpcom.ac_if;
2695         mii = device_get_softc(sc->dc_miibus);
2696
2697         if (sc->dc_flags & DC_REDUCED_MII_POLL) {
2698                 if (sc->dc_flags & DC_21143_NWAY) {
2699                         r = CSR_READ_4(sc, DC_10BTSTAT);
2700                         if (IFM_SUBTYPE(mii->mii_media_active) ==
2701                             IFM_100_TX && (r & DC_TSTAT_LS100)) {
2702                                 sc->dc_link = 0;
2703                                 mii_mediachg(mii);
2704                         }
2705                         if (IFM_SUBTYPE(mii->mii_media_active) ==
2706                             IFM_10_T && (r & DC_TSTAT_LS10)) {
2707                                 sc->dc_link = 0;
2708                                 mii_mediachg(mii);
2709                         }
2710                         if (sc->dc_link == 0)
2711                                 mii_tick(mii);
2712                 } else {
2713                         r = CSR_READ_4(sc, DC_ISR);
2714                         if ((r & DC_ISR_RX_STATE) == DC_RXSTATE_WAIT &&
2715                             sc->dc_cdata.dc_tx_cnt == 0)
2716                                 mii_tick(mii);
2717                                 if (!(mii->mii_media_status & IFM_ACTIVE))
2718                                         sc->dc_link = 0;
2719                 }
2720         } else
2721                 mii_tick(mii);
2722
2723         /*
2724          * When the init routine completes, we expect to be able to send
2725          * packets right away, and in fact the network code will send a
2726          * gratuitous ARP the moment the init routine marks the interface
2727          * as running. However, even though the MAC may have been initialized,
2728          * there may be a delay of a few seconds before the PHY completes
2729          * autonegotiation and the link is brought up. Any transmissions
2730          * made during that delay will be lost. Dealing with this is tricky:
2731          * we can't just pause in the init routine while waiting for the
2732          * PHY to come ready since that would bring the whole system to
2733          * a screeching halt for several seconds.
2734          *
2735          * What we do here is prevent the TX start routine from sending
2736          * any packets until a link has been established. After the
2737          * interface has been initialized, the tick routine will poll
2738          * the state of the PHY until the IFM_ACTIVE flag is set. Until
2739          * that time, packets will stay in the send queue, and once the
2740          * link comes up, they will be flushed out to the wire.
2741          */
2742         if (!sc->dc_link) {
2743                 mii_pollstat(mii);
2744                 if (mii->mii_media_status & IFM_ACTIVE &&
2745                     IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
2746                         sc->dc_link++;
2747                         if (ifp->if_snd.ifq_head != NULL)
2748                                 dc_start(ifp);
2749                 }
2750         }
2751
2752         if (sc->dc_flags & DC_21143_NWAY && !sc->dc_link)
2753                 callout_reset(&sc->dc_stat_timer, hz / 10, dc_tick, sc);
2754         else
2755                 callout_reset(&sc->dc_stat_timer, hz, dc_tick, sc);
2756
2757         splx(s);
2758
2759         return;
2760 }
2761
2762 /*
2763  * A transmit underrun has occurred.  Back off the transmit threshold,
2764  * or switch to store and forward mode if we have to.
2765  */
2766 static void dc_tx_underrun(sc)
2767         struct dc_softc         *sc;
2768 {
2769         u_int32_t               isr;
2770         int                     i;
2771
2772         if (DC_IS_DAVICOM(sc))
2773                 dc_init(sc);
2774
2775         if (DC_IS_INTEL(sc)) {
2776                 /*
2777                  * The real 21143 requires that the transmitter be idle
2778                  * in order to change the transmit threshold or store
2779                  * and forward state.
2780                  */
2781                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_TX_ON);
2782
2783                 for (i = 0; i < DC_TIMEOUT; i++) {
2784                         isr = CSR_READ_4(sc, DC_ISR);
2785                         if (isr & DC_ISR_TX_IDLE)
2786                                 break;
2787                         DELAY(10);
2788                 }
2789                 if (i == DC_TIMEOUT) {
2790                         printf("dc%d: failed to force tx to idle state\n",
2791                             sc->dc_unit);
2792                         dc_init(sc);
2793                 }
2794         }
2795
2796         printf("dc%d: TX underrun -- ", sc->dc_unit);
2797         sc->dc_txthresh += DC_TXTHRESH_INC;
2798         if (sc->dc_txthresh > DC_TXTHRESH_MAX) {
2799                 printf("using store and forward mode\n");
2800                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_STORENFWD);
2801         } else {
2802                 printf("increasing TX threshold\n");
2803                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_TX_THRESH);
2804                 DC_SETBIT(sc, DC_NETCFG, sc->dc_txthresh);
2805         }
2806
2807         if (DC_IS_INTEL(sc))
2808                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_TX_ON);
2809
2810         return;
2811 }
2812
2813 #ifdef DEVICE_POLLING
2814 static poll_handler_t dc_poll;
2815
2816 static void
2817 dc_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
2818 {
2819         struct  dc_softc *sc = ifp->if_softc;
2820
2821         if (cmd == POLL_DEREGISTER) { /* final call, enable interrupts */
2822                 /* Re-enable interrupts. */
2823                 CSR_WRITE_4(sc, DC_IMR, DC_INTRS);
2824                 return;
2825         }
2826         sc->rxcycles = count;
2827         dc_rxeof(sc);
2828         dc_txeof(sc);
2829         if (ifp->if_snd.ifq_head != NULL && !(ifp->if_flags & IFF_OACTIVE))
2830                 dc_start(ifp);
2831
2832         if (cmd == POLL_AND_CHECK_STATUS) { /* also check status register */
2833                 u_int32_t          status;
2834
2835                 status = CSR_READ_4(sc, DC_ISR);
2836                 status &= (DC_ISR_RX_WATDOGTIMEO|DC_ISR_RX_NOBUF|
2837                         DC_ISR_TX_NOBUF|DC_ISR_TX_IDLE|DC_ISR_TX_UNDERRUN|
2838                         DC_ISR_BUS_ERR);
2839                 if (!status)
2840                         return ;
2841                 /* ack what we have */
2842                 CSR_WRITE_4(sc, DC_ISR, status);
2843
2844                 if (status & (DC_ISR_RX_WATDOGTIMEO|DC_ISR_RX_NOBUF) ) {
2845                         u_int32_t r = CSR_READ_4(sc, DC_FRAMESDISCARDED);
2846                         ifp->if_ierrors += (r & 0xffff) + ((r >> 17) & 0x7ff);
2847
2848                         if (dc_rx_resync(sc))
2849                                 dc_rxeof(sc);
2850                 }
2851                 /* restart transmit unit if necessary */
2852                 if (status & DC_ISR_TX_IDLE && sc->dc_cdata.dc_tx_cnt)
2853                         CSR_WRITE_4(sc, DC_TXSTART, 0xFFFFFFFF);
2854
2855                 if (status & DC_ISR_TX_UNDERRUN)
2856                         dc_tx_underrun(sc);
2857
2858                 if (status & DC_ISR_BUS_ERR) {
2859                         printf("dc_poll: dc%d bus error\n", sc->dc_unit);
2860                         dc_reset(sc);
2861                         dc_init(sc);
2862                 }
2863         }
2864 }
2865 #endif /* DEVICE_POLLING */
2866
2867 static void dc_intr(arg)
2868         void                    *arg;
2869 {
2870         struct dc_softc         *sc;
2871         struct ifnet            *ifp;
2872         u_int32_t               status;
2873
2874         sc = arg;
2875
2876         if (sc->suspended) {
2877                 return;
2878         }
2879
2880         ifp = &sc->arpcom.ac_if;
2881
2882 #ifdef DEVICE_POLLING
2883         if (ifp->if_flags & IFF_POLLING)
2884                 return;
2885         if (ether_poll_register(dc_poll, ifp)) { /* ok, disable interrupts */
2886                 CSR_WRITE_4(sc, DC_IMR, 0x00000000);
2887                 return;
2888         }
2889 #endif /* DEVICE_POLLING */
2890
2891         if ( (CSR_READ_4(sc, DC_ISR) & DC_INTRS) == 0)
2892                 return ;
2893
2894         /* Suppress unwanted interrupts */
2895         if (!(ifp->if_flags & IFF_UP)) {
2896                 if (CSR_READ_4(sc, DC_ISR) & DC_INTRS)
2897                         dc_stop(sc);
2898                 return;
2899         }
2900
2901         /* Disable interrupts. */
2902         CSR_WRITE_4(sc, DC_IMR, 0x00000000);
2903
2904         while((status = CSR_READ_4(sc, DC_ISR)) & DC_INTRS) {
2905
2906                 CSR_WRITE_4(sc, DC_ISR, status);
2907
2908                 if (status & DC_ISR_RX_OK) {
2909                         int             curpkts;
2910                         curpkts = ifp->if_ipackets;
2911                         dc_rxeof(sc);
2912                         if (curpkts == ifp->if_ipackets) {
2913                                 while(dc_rx_resync(sc))
2914                                         dc_rxeof(sc);
2915                         }
2916                 }
2917
2918                 if (status & (DC_ISR_TX_OK|DC_ISR_TX_NOBUF))
2919                         dc_txeof(sc);
2920
2921                 if (status & DC_ISR_TX_IDLE) {
2922                         dc_txeof(sc);
2923                         if (sc->dc_cdata.dc_tx_cnt) {
2924                                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_TX_ON);
2925                                 CSR_WRITE_4(sc, DC_TXSTART, 0xFFFFFFFF);
2926                         }
2927                 }
2928
2929                 if (status & DC_ISR_TX_UNDERRUN)
2930                         dc_tx_underrun(sc);
2931
2932                 if ((status & DC_ISR_RX_WATDOGTIMEO)
2933                     || (status & DC_ISR_RX_NOBUF)) {
2934                         int             curpkts;
2935                         curpkts = ifp->if_ipackets;
2936                         dc_rxeof(sc);
2937                         if (curpkts == ifp->if_ipackets) {
2938                                 while(dc_rx_resync(sc))
2939                                         dc_rxeof(sc);
2940                         }
2941                 }
2942
2943                 if (status & DC_ISR_BUS_ERR) {
2944                         dc_reset(sc);
2945                         dc_init(sc);
2946                 }
2947         }
2948
2949         /* Re-enable interrupts. */
2950         CSR_WRITE_4(sc, DC_IMR, DC_INTRS);
2951
2952         if (ifp->if_snd.ifq_head != NULL)
2953                 dc_start(ifp);
2954
2955         return;
2956 }
2957
2958 /*
2959  * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
2960  * pointers to the fragment pointers.
2961  */
2962 static int dc_encap(sc, m_head, txidx)
2963         struct dc_softc         *sc;
2964         struct mbuf             *m_head;
2965         u_int32_t               *txidx;
2966 {
2967         struct dc_desc          *f = NULL;
2968         struct mbuf             *m;
2969         int                     frag, cur, cnt = 0;
2970
2971         /*
2972          * Start packing the mbufs in this chain into
2973          * the fragment pointers. Stop when we run out
2974          * of fragments or hit the end of the mbuf chain.
2975          */
2976         m = m_head;
2977         cur = frag = *txidx;
2978
2979         for (m = m_head; m != NULL; m = m->m_next) {
2980                 if (m->m_len != 0) {
2981                         if (sc->dc_flags & DC_TX_ADMTEK_WAR) {
2982                                 if (*txidx != sc->dc_cdata.dc_tx_prod &&
2983                                     frag == (DC_TX_LIST_CNT - 1))
2984                                         return(ENOBUFS);
2985                         }
2986                         if ((DC_TX_LIST_CNT -
2987                             (sc->dc_cdata.dc_tx_cnt + cnt)) < 5)
2988                                 return(ENOBUFS);
2989
2990                         f = &sc->dc_ldata->dc_tx_list[frag];
2991                         f->dc_ctl = DC_TXCTL_TLINK | m->m_len;
2992                         if (cnt == 0) {
2993                                 f->dc_status = 0;
2994                                 f->dc_ctl |= DC_TXCTL_FIRSTFRAG;
2995                         } else
2996                                 f->dc_status = DC_TXSTAT_OWN;
2997                         f->dc_data = vtophys(mtod(m, vm_offset_t));
2998                         cur = frag;
2999                         DC_INC(frag, DC_TX_LIST_CNT);
3000                         cnt++;
3001                 }
3002         }
3003
3004         if (m != NULL)
3005                 return(ENOBUFS);
3006
3007         sc->dc_cdata.dc_tx_cnt += cnt;
3008         sc->dc_cdata.dc_tx_chain[cur] = m_head;
3009         sc->dc_ldata->dc_tx_list[cur].dc_ctl |= DC_TXCTL_LASTFRAG;
3010         if (sc->dc_flags & DC_TX_INTR_FIRSTFRAG)
3011                 sc->dc_ldata->dc_tx_list[*txidx].dc_ctl |= DC_TXCTL_FINT;
3012         if (sc->dc_flags & DC_TX_INTR_ALWAYS)
3013                 sc->dc_ldata->dc_tx_list[cur].dc_ctl |= DC_TXCTL_FINT;
3014         if (sc->dc_flags & DC_TX_USE_TX_INTR && sc->dc_cdata.dc_tx_cnt > 64)
3015                 sc->dc_ldata->dc_tx_list[cur].dc_ctl |= DC_TXCTL_FINT;
3016         sc->dc_ldata->dc_tx_list[*txidx].dc_status = DC_TXSTAT_OWN;
3017         *txidx = frag;
3018
3019         return(0);
3020 }
3021
3022 /*
3023  * Main transmit routine. To avoid having to do mbuf copies, we put pointers
3024  * to the mbuf data regions directly in the transmit lists. We also save a
3025  * copy of the pointers since the transmit list fragment pointers are
3026  * physical addresses.
3027  */
3028
3029 static void dc_start(ifp)
3030         struct ifnet            *ifp;
3031 {
3032         struct dc_softc         *sc;
3033         struct mbuf *m_head = NULL, *m_new;
3034         int                     idx;
3035
3036         sc = ifp->if_softc;
3037
3038         if (!sc->dc_link && ifp->if_snd.ifq_len < 10)
3039                 return;
3040
3041         if (ifp->if_flags & IFF_OACTIVE)
3042                 return;
3043
3044         idx = sc->dc_cdata.dc_tx_prod;
3045
3046         while(sc->dc_cdata.dc_tx_chain[idx] == NULL) {
3047                 IF_DEQUEUE(&ifp->if_snd, m_head);
3048                 if (m_head == NULL)
3049                         break;
3050
3051                 if (sc->dc_flags & DC_TX_COALESCE &&
3052                     m_head->m_next != NULL) {
3053                         /* only coalesce if have >1 mbufs */
3054                         if ((m_new = m_defrag(m_head, MB_DONTWAIT)) == NULL) {
3055                                 IF_PREPEND(&ifp->if_snd, m_head);
3056                                 ifp->if_flags |= IFF_OACTIVE;
3057                                 break;
3058                         }
3059                         m_freem(m_head);
3060                         m_head = m_new;
3061                 }
3062
3063                 if (dc_encap(sc, m_head, &idx)) {
3064                         IF_PREPEND(&ifp->if_snd, m_head);
3065                         ifp->if_flags |= IFF_OACTIVE;
3066                         break;
3067                 }
3068
3069                 /*
3070                  * If there's a BPF listener, bounce a copy of this frame
3071                  * to him.
3072                  */
3073                 BPF_MTAP(ifp, m_head);
3074
3075                 if (sc->dc_flags & DC_TX_ONE) {
3076                         ifp->if_flags |= IFF_OACTIVE;
3077                         break;
3078                 }
3079         }
3080
3081         /* Transmit */
3082         sc->dc_cdata.dc_tx_prod = idx;
3083         if (!(sc->dc_flags & DC_TX_POLL))
3084                 CSR_WRITE_4(sc, DC_TXSTART, 0xFFFFFFFF);
3085
3086         /*
3087          * Set a timeout in case the chip goes out to lunch.
3088          */
3089         ifp->if_timer = 5;
3090
3091         return;
3092 }
3093
3094 static void dc_init(xsc)
3095         void                    *xsc;
3096 {
3097         struct dc_softc         *sc = xsc;
3098         struct ifnet            *ifp = &sc->arpcom.ac_if;
3099         struct mii_data         *mii;
3100         int                     s;
3101
3102         s = splimp();
3103
3104         mii = device_get_softc(sc->dc_miibus);
3105
3106         /*
3107          * Cancel pending I/O and free all RX/TX buffers.
3108          */
3109         dc_stop(sc);
3110         dc_reset(sc);
3111
3112         /*
3113          * Set cache alignment and burst length.
3114          */
3115         if (DC_IS_ASIX(sc) || DC_IS_DAVICOM(sc))
3116                 CSR_WRITE_4(sc, DC_BUSCTL, 0);
3117         else
3118                 CSR_WRITE_4(sc, DC_BUSCTL, DC_BUSCTL_MRME|DC_BUSCTL_MRLE);
3119         /*
3120          * Evenly share the bus between receive and transmit process.
3121          */
3122         if (DC_IS_INTEL(sc))
3123                 DC_SETBIT(sc, DC_BUSCTL, DC_BUSCTL_ARBITRATION);
3124         if (DC_IS_DAVICOM(sc) || DC_IS_INTEL(sc)) {
3125                 DC_SETBIT(sc, DC_BUSCTL, DC_BURSTLEN_USECA);
3126         } else {
3127                 DC_SETBIT(sc, DC_BUSCTL, DC_BURSTLEN_16LONG);
3128         }
3129         if (sc->dc_flags & DC_TX_POLL)
3130                 DC_SETBIT(sc, DC_BUSCTL, DC_TXPOLL_1);
3131         switch(sc->dc_cachesize) {
3132         case 32:
3133                 DC_SETBIT(sc, DC_BUSCTL, DC_CACHEALIGN_32LONG);
3134                 break;
3135         case 16:
3136                 DC_SETBIT(sc, DC_BUSCTL, DC_CACHEALIGN_16LONG);
3137                 break;
3138         case 8:
3139                 DC_SETBIT(sc, DC_BUSCTL, DC_CACHEALIGN_8LONG);
3140                 break;
3141         case 0:
3142         default:
3143                 DC_SETBIT(sc, DC_BUSCTL, DC_CACHEALIGN_NONE);
3144                 break;
3145         }
3146
3147         if (sc->dc_flags & DC_TX_STORENFWD)
3148                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_STORENFWD);
3149         else {
3150                 if (sc->dc_txthresh > DC_TXTHRESH_MAX) {
3151                         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_STORENFWD);
3152                 } else {
3153                         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_STORENFWD);
3154                         DC_SETBIT(sc, DC_NETCFG, sc->dc_txthresh);
3155                 }
3156         }
3157
3158         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_NO_RXCRC);
3159         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_TX_BACKOFF);
3160
3161         if (DC_IS_MACRONIX(sc) || DC_IS_PNICII(sc)) {
3162                 /*
3163                  * The app notes for the 98713 and 98715A say that
3164                  * in order to have the chips operate properly, a magic
3165                  * number must be written to CSR16. Macronix does not
3166                  * document the meaning of these bits so there's no way
3167                  * to know exactly what they do. The 98713 has a magic
3168                  * number all its own; the rest all use a different one.
3169                  */
3170                 DC_CLRBIT(sc, DC_MX_MAGICPACKET, 0xFFFF0000);
3171                 if (sc->dc_type == DC_TYPE_98713)
3172                         DC_SETBIT(sc, DC_MX_MAGICPACKET, DC_MX_MAGIC_98713);
3173                 else
3174                         DC_SETBIT(sc, DC_MX_MAGICPACKET, DC_MX_MAGIC_98715);
3175         }
3176
3177         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_TX_THRESH);
3178         DC_SETBIT(sc, DC_NETCFG, DC_TXTHRESH_MIN);
3179
3180         /* Init circular RX list. */
3181         if (dc_list_rx_init(sc) == ENOBUFS) {
3182                 printf("dc%d: initialization failed: no "
3183                     "memory for rx buffers\n", sc->dc_unit);
3184                 dc_stop(sc);
3185                 (void)splx(s);
3186                 return;
3187         }
3188
3189         /*
3190          * Init tx descriptors.
3191          */
3192         dc_list_tx_init(sc);
3193
3194         /*
3195          * Load the address of the RX list.
3196          */
3197         CSR_WRITE_4(sc, DC_RXADDR, vtophys(&sc->dc_ldata->dc_rx_list[0]));
3198         CSR_WRITE_4(sc, DC_TXADDR, vtophys(&sc->dc_ldata->dc_tx_list[0]));
3199
3200         /*
3201          * Enable interrupts.
3202          */
3203 #ifdef DEVICE_POLLING
3204         /*
3205          * ... but only if we are not polling, and make sure they are off in
3206          * the case of polling. Some cards (e.g. fxp) turn interrupts on
3207          * after a reset.
3208          */
3209         if (ifp->if_flags & IFF_POLLING)
3210                 CSR_WRITE_4(sc, DC_IMR, 0x00000000);
3211         else
3212 #endif
3213         CSR_WRITE_4(sc, DC_IMR, DC_INTRS);
3214         CSR_WRITE_4(sc, DC_ISR, 0xFFFFFFFF);
3215
3216         /* Enable transmitter. */
3217         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_TX_ON);
3218
3219         /*
3220          * If this is an Intel 21143 and we're not using the
3221          * MII port, program the LED control pins so we get
3222          * link and activity indications.
3223          */
3224         if (sc->dc_flags & DC_TULIP_LEDS) {
3225                 CSR_WRITE_4(sc, DC_WATCHDOG,
3226                     DC_WDOG_CTLWREN|DC_WDOG_LINK|DC_WDOG_ACTIVITY);
3227                 CSR_WRITE_4(sc, DC_WATCHDOG, 0);
3228         }
3229
3230         /*
3231          * Load the RX/multicast filter. We do this sort of late
3232          * because the filter programming scheme on the 21143 and
3233          * some clones requires DMAing a setup frame via the TX
3234          * engine, and we need the transmitter enabled for that.
3235          */
3236         dc_setfilt(sc);
3237
3238         /* Enable receiver. */
3239         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_ON);
3240         CSR_WRITE_4(sc, DC_RXSTART, 0xFFFFFFFF);
3241
3242         mii_mediachg(mii);
3243         dc_setcfg(sc, sc->dc_if_media);
3244
3245         ifp->if_flags |= IFF_RUNNING;
3246         ifp->if_flags &= ~IFF_OACTIVE;
3247
3248         (void)splx(s);
3249
3250         /* Don't start the ticker if this is a homePNA link. */
3251         if (IFM_SUBTYPE(mii->mii_media.ifm_media) == IFM_HPNA_1)
3252                 sc->dc_link = 1;
3253         else {
3254                 if (sc->dc_flags & DC_21143_NWAY)
3255                         callout_reset(&sc->dc_stat_timer, hz/10, dc_tick, sc);
3256                 else
3257                         callout_reset(&sc->dc_stat_timer, hz, dc_tick, sc);
3258         }
3259
3260 #ifdef SRM_MEDIA
3261         if(sc->dc_srm_media) {
3262                 struct ifreq ifr;
3263
3264                 ifr.ifr_media = sc->dc_srm_media;
3265                 ifmedia_ioctl(ifp, &ifr, &mii->mii_media, SIOCSIFMEDIA);
3266                 sc->dc_srm_media = 0;
3267         }
3268 #endif
3269         return;
3270 }
3271
3272 /*
3273  * Set media options.
3274  */
3275 static int dc_ifmedia_upd(ifp)
3276         struct ifnet            *ifp;
3277 {
3278         struct dc_softc         *sc;
3279         struct mii_data         *mii;
3280         struct ifmedia          *ifm;
3281
3282         sc = ifp->if_softc;
3283         mii = device_get_softc(sc->dc_miibus);
3284         mii_mediachg(mii);
3285         ifm = &mii->mii_media;
3286
3287         if (DC_IS_DAVICOM(sc) &&
3288             IFM_SUBTYPE(ifm->ifm_media) == IFM_HPNA_1)
3289                 dc_setcfg(sc, ifm->ifm_media);
3290         else
3291                 sc->dc_link = 0;
3292
3293         return(0);
3294 }
3295
3296 /*
3297  * Report current media status.
3298  */
3299 static void dc_ifmedia_sts(ifp, ifmr)
3300         struct ifnet            *ifp;
3301         struct ifmediareq       *ifmr;
3302 {
3303         struct dc_softc         *sc;
3304         struct mii_data         *mii;
3305         struct ifmedia          *ifm;
3306
3307         sc = ifp->if_softc;
3308         mii = device_get_softc(sc->dc_miibus);
3309         mii_pollstat(mii);
3310         ifm = &mii->mii_media;
3311         if (DC_IS_DAVICOM(sc)) {
3312                 if (IFM_SUBTYPE(ifm->ifm_media) == IFM_HPNA_1) {
3313                         ifmr->ifm_active = ifm->ifm_media;
3314                         ifmr->ifm_status = 0;
3315                         return;
3316                 }
3317         }
3318         ifmr->ifm_active = mii->mii_media_active;
3319         ifmr->ifm_status = mii->mii_media_status;
3320
3321         return;
3322 }
3323
3324 static int dc_ioctl(ifp, command, data, cr)
3325         struct ifnet            *ifp;
3326         u_long                  command;
3327         caddr_t                 data;
3328         struct ucred            *cr;
3329 {
3330         struct dc_softc         *sc = ifp->if_softc;
3331         struct ifreq            *ifr = (struct ifreq *) data;
3332         struct mii_data         *mii;
3333         int                     s, error = 0;
3334
3335         s = splimp();
3336
3337         switch(command) {
3338         case SIOCSIFADDR:
3339         case SIOCGIFADDR:
3340         case SIOCSIFMTU:
3341                 error = ether_ioctl(ifp, command, data);
3342                 break;
3343         case SIOCSIFFLAGS:
3344                 if (ifp->if_flags & IFF_UP) {
3345                         int need_setfilt = (ifp->if_flags ^ sc->dc_if_flags) &
3346                                 (IFF_PROMISC | IFF_ALLMULTI);
3347                         if (ifp->if_flags & IFF_RUNNING) {
3348                                 if (need_setfilt)
3349                                         dc_setfilt(sc);
3350                         } else {
3351                                 sc->dc_txthresh = 0;
3352                                 dc_init(sc);
3353                         }
3354                 } else {
3355                         if (ifp->if_flags & IFF_RUNNING)
3356                                 dc_stop(sc);
3357                 }
3358                 sc->dc_if_flags = ifp->if_flags;
3359                 error = 0;
3360                 break;
3361         case SIOCADDMULTI:
3362         case SIOCDELMULTI:
3363                 dc_setfilt(sc);
3364                 error = 0;
3365                 break;
3366         case SIOCGIFMEDIA:
3367         case SIOCSIFMEDIA:
3368                 mii = device_get_softc(sc->dc_miibus);
3369                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
3370 #ifdef SRM_MEDIA
3371                 if (sc->dc_srm_media)
3372                         sc->dc_srm_media = 0;
3373 #endif
3374                 break;
3375         default:
3376                 error = EINVAL;
3377                 break;
3378         }
3379
3380         (void)splx(s);
3381
3382         return(error);
3383 }
3384
3385 static void dc_watchdog(ifp)
3386         struct ifnet            *ifp;
3387 {
3388         struct dc_softc         *sc;
3389
3390         sc = ifp->if_softc;
3391
3392         ifp->if_oerrors++;
3393         printf("dc%d: watchdog timeout\n", sc->dc_unit);
3394
3395         dc_stop(sc);
3396         dc_reset(sc);
3397         dc_init(sc);
3398
3399         if (ifp->if_snd.ifq_head != NULL)
3400                 dc_start(ifp);
3401
3402         return;
3403 }
3404
3405 /*
3406  * Stop the adapter and free any mbufs allocated to the
3407  * RX and TX lists.
3408  */
3409 static void dc_stop(sc)
3410         struct dc_softc         *sc;
3411 {
3412         int             i;
3413         struct ifnet            *ifp;
3414
3415         ifp = &sc->arpcom.ac_if;
3416         ifp->if_timer = 0;
3417
3418         callout_stop(&sc->dc_stat_timer);
3419
3420         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
3421 #ifdef DEVICE_POLLING
3422         ether_poll_deregister(ifp);
3423 #endif
3424
3425         DC_CLRBIT(sc, DC_NETCFG, (DC_NETCFG_RX_ON|DC_NETCFG_TX_ON));
3426         CSR_WRITE_4(sc, DC_IMR, 0x00000000);
3427         CSR_WRITE_4(sc, DC_TXADDR, 0x00000000);
3428         CSR_WRITE_4(sc, DC_RXADDR, 0x00000000);
3429         sc->dc_link = 0;
3430
3431         /*
3432          * Free data in the RX lists.
3433          */
3434         for (i = 0; i < DC_RX_LIST_CNT; i++) {
3435                 if (sc->dc_cdata.dc_rx_chain[i] != NULL) {
3436                         m_freem(sc->dc_cdata.dc_rx_chain[i]);
3437                         sc->dc_cdata.dc_rx_chain[i] = NULL;
3438                 }
3439         }
3440         bzero((char *)&sc->dc_ldata->dc_rx_list,
3441                 sizeof(sc->dc_ldata->dc_rx_list));
3442
3443         /*
3444          * Free the TX list buffers.
3445          */
3446         for (i = 0; i < DC_TX_LIST_CNT; i++) {
3447                 if (sc->dc_cdata.dc_tx_chain[i] != NULL) {
3448                         if ((sc->dc_ldata->dc_tx_list[i].dc_ctl &
3449                             DC_TXCTL_SETUP) ||
3450                             !(sc->dc_ldata->dc_tx_list[i].dc_ctl &
3451                             DC_TXCTL_LASTFRAG)) {
3452                                 sc->dc_cdata.dc_tx_chain[i] = NULL;
3453                                 continue;
3454                         }
3455                         m_freem(sc->dc_cdata.dc_tx_chain[i]);
3456                         sc->dc_cdata.dc_tx_chain[i] = NULL;
3457                 }
3458         }
3459
3460         bzero((char *)&sc->dc_ldata->dc_tx_list,
3461                 sizeof(sc->dc_ldata->dc_tx_list));
3462
3463         return;
3464 }
3465
3466 /*
3467  * Stop all chip I/O so that the kernel's probe routines don't
3468  * get confused by errant DMAs when rebooting.
3469  */
3470 static void dc_shutdown(dev)
3471         device_t                dev;
3472 {
3473         struct dc_softc         *sc;
3474
3475         sc = device_get_softc(dev);
3476
3477         dc_stop(sc);
3478
3479         return;
3480 }
3481
3482 /*
3483  * Device suspend routine.  Stop the interface and save some PCI
3484  * settings in case the BIOS doesn't restore them properly on
3485  * resume.
3486  */
3487 static int dc_suspend(dev)
3488         device_t                dev;
3489 {
3490         int             i;
3491         int                     s;
3492         struct dc_softc         *sc;
3493
3494         s = splimp();
3495
3496         sc = device_get_softc(dev);
3497
3498         dc_stop(sc);
3499
3500         for (i = 0; i < 5; i++)
3501                 sc->saved_maps[i] = pci_read_config(dev, PCIR_MAPS + i * 4, 4);
3502         sc->saved_biosaddr = pci_read_config(dev, PCIR_BIOS, 4);
3503         sc->saved_intline = pci_read_config(dev, PCIR_INTLINE, 1);
3504         sc->saved_cachelnsz = pci_read_config(dev, PCIR_CACHELNSZ, 1);
3505         sc->saved_lattimer = pci_read_config(dev, PCIR_LATTIMER, 1);
3506
3507         sc->suspended = 1;
3508
3509         splx(s);
3510         return (0);
3511 }
3512
3513 /*
3514  * Device resume routine.  Restore some PCI settings in case the BIOS
3515  * doesn't, re-enable busmastering, and restart the interface if
3516  * appropriate.
3517  */
3518 static int dc_resume(dev)
3519         device_t                dev;
3520 {
3521         int             i;
3522         int                     s;
3523         struct dc_softc         *sc;
3524         struct ifnet            *ifp;
3525
3526         s = splimp();
3527
3528         sc = device_get_softc(dev);
3529         ifp = &sc->arpcom.ac_if;
3530
3531         dc_acpi(dev);
3532
3533         /* better way to do this? */
3534         for (i = 0; i < 5; i++)
3535                 pci_write_config(dev, PCIR_MAPS + i * 4, sc->saved_maps[i], 4);
3536         pci_write_config(dev, PCIR_BIOS, sc->saved_biosaddr, 4);
3537         pci_write_config(dev, PCIR_INTLINE, sc->saved_intline, 1);
3538         pci_write_config(dev, PCIR_CACHELNSZ, sc->saved_cachelnsz, 1);
3539         pci_write_config(dev, PCIR_LATTIMER, sc->saved_lattimer, 1);
3540
3541         /* reenable busmastering */
3542         pci_enable_busmaster(dev);
3543         pci_enable_io(dev, DC_RES);
3544
3545         /* reinitialize interface if necessary */
3546         if (ifp->if_flags & IFF_UP)
3547                 dc_init(sc);
3548
3549         sc->suspended = 0;
3550
3551         splx(s);
3552         return (0);
3553 }