Changeset ab325ab in libbsdport


Ignore:
Timestamp:
Oct 20, 2009, 5:02:50 AM (10 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
master
Children:
11084a7
Parents:
d766703
Message:

2009-10-20 Chris Johns <chrisj@…>

  • bsd_eth_drivers/libbsdport/sysbus.cL Fixed the print message for no IRQ handler.
  • bsd_eth_drivers/libbsdport/misc.c: Add m_defrag and what else it needed. The RL driver needs it.
  • bsd_eth_drivers/libbsdport/libbsdport_post.h: Remove the define for m_defrag.
  • bsd_eth_drivers/libbsdport/libbsdport.h: Add if_maddr_rlock and if_maddr_runlock.
  • bsd_eth_drivers/libbsdport/bus.h: Add the bus_space_write_stream_4 call.
  • bsd_eth_drivers/libbsdport/libbsdport_post.h, bsd_eth_drivers/libbsdport/alldrv.c, bsd_eth_drivers/if_re/Makefile.am: Add RL driver support.
  • bsd_eth_drivers/if_re/if_re.c, bsd_eth_drivers/if_re/if_rlreg.h: Updated to the lastest version.
  • bsd_eth_drivers/if_re/if_rl.c: New. This is for the Realtek 8129/8139 PCI NIC while the RE driver does only the 8139C+ version.
Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed
  • ChangeLog

    rd766703 rab325ab  
     12009-10-20      Chris Johns <chrisj@rtems.org>
     2
     3        * bsd_eth_drivers/libbsdport/sysbus.cL Fixed the print message for
     4        no IRQ handler.
     5        * bsd_eth_drivers/libbsdport/misc.c: Add m_defrag and what else it
     6        needed. The RL driver needs it.
     7        * bsd_eth_drivers/libbsdport/libbsdport_post.h: Remove the define
     8        for m_defrag.
     9        * bsd_eth_drivers/libbsdport/libbsdport.h: Add if_maddr_rlock and
     10        if_maddr_runlock.
     11        * bsd_eth_drivers/libbsdport/bus.h: Add the
     12        bus_space_write_stream_4 call.
     13        * bsd_eth_drivers/libbsdport/libbsdport_post.h,
     14        bsd_eth_drivers/libbsdport/alldrv.c,
     15        bsd_eth_drivers/if_re/Makefile.am: Add RL driver support.
     16        * bsd_eth_drivers/if_re/if_re.c, bsd_eth_drivers/if_re/if_rlreg.h:
     17        Updated to the lastest version.
     18        * bsd_eth_drivers/if_re/if_rl.c: New. This is for the Realtek
     19        8129/8139 PCI NIC while the RE driver does only the 8139C+
     20        version.
     21
    1222009-05-13      Joel Sherrill <joel.sherrill@oarcorp.com>
    223
  • bsd_eth_drivers/if_re/Makefile.am

    rd766703 rab325ab  
    44include $(top_srcdir)/rtems-pre.am
    55
    6 libif_re_a_SOURCES               = if_re.c if_rlreg.h
     6libif_re_a_SOURCES               = if_re.c if_rl.c if_rlreg.h
    77
    88##EXTRA_libif_re_a_SOURCES         =
  • bsd_eth_drivers/if_re/if_re.c

    rd766703 rab325ab  
    3333#ifdef __rtems__
    3434#include <libbsdport.h>
     35#define M_ASSERTPKTHDR(_h)
    3536#endif
    3637
    3738#include <sys/cdefs.h>
    38 __FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v 1.46.2.39.2.1 2008/10/02 02:57:24 kensmith Exp $");
     39__FBSDID("$FreeBSD: src/sys/dev/re/if_re.c,v 1.161 2009/08/24 18:58:13 yongari Exp $");
    3940
    4041/*
     
    151152#include <dev/pci/pcivar.h>
    152153
    153 MODULE_DEPEND(re, pci, 1, 1, 1);
    154 MODULE_DEPEND(re, ether, 1, 1, 1);
    155 MODULE_DEPEND(re, miibus, 1, 1, 1);
    156 
    157 /* "device miibus" required.  See GENERIC if you get errors here. */
    158 #include "miibus_if.h"
    159 
    160 #ifdef __rtems__
    161 #include <libbsdport_post.h>
    162 #endif
    163 
    164154/*
    165155 * Default to using PIO access for this driver.
     
    173163#endif
    174164
     165MODULE_DEPEND(re, pci, 1, 1, 1);
     166MODULE_DEPEND(re, ether, 1, 1, 1);
     167MODULE_DEPEND(re, miibus, 1, 1, 1);
     168
     169/* "device miibus" required.  See GENERIC if you get errors here. */
     170#include "miibus_if.h"
     171
     172#ifdef __rtems__
     173#include <libbsdport_post.h>
     174#define TUNABLE_INT(_t, _v)
     175#endif
     176
     177/* Tunables. */
     178static int msi_disable = 0;
     179TUNABLE_INT("hw.re.msi_disable", &msi_disable);
     180static int prefer_iomap = 0;
     181TUNABLE_INT("hw.re.prefer_iomap", &prefer_iomap);
     182
    175183#define RE_CSUM_FEATURES    (CSUM_IP | CSUM_TCP | CSUM_UDP)
    176184
     
    179187 */
    180188static struct rl_type re_devs[] = {
    181         { DLINK_VENDORID, DLINK_DEVICEID_528T, RL_HWREV_8169S,
    182                 "D-Link DGE-528(T) Gigabit Ethernet Adapter" },
    183         { DLINK_VENDORID, DLINK_DEVICEID_528T, RL_HWREV_8169_8110SB,
    184                 "D-Link DGE-528(T) Rev.B1 Gigabit Ethernet Adapter" },
    185         { RT_VENDORID, RT_DEVICEID_8139, RL_HWREV_8139CPLUS,
    186                 "RealTek 8139C+ 10/100BaseTX" },
    187         { RT_VENDORID, RT_DEVICEID_8101E, RL_HWREV_8101E,
    188                 "RealTek 8101E PCIe 10/100baseTX" },
    189         { RT_VENDORID, RT_DEVICEID_8168, RL_HWREV_8168_SPIN1,
    190                 "RealTek 8168/8111B PCIe Gigabit Ethernet" },
    191         { RT_VENDORID, RT_DEVICEID_8168, RL_HWREV_8168_SPIN2,
    192                 "RealTek 8168/8111B PCIe Gigabit Ethernet" },
    193         { RT_VENDORID, RT_DEVICEID_8168, RL_HWREV_8168_SPIN3,
    194                 "RealTek 8168/8111B PCIe Gigabit Ethernet" },
    195         { RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169,
    196                 "RealTek 8169 Gigabit Ethernet" },
    197         { RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169S,
    198                 "RealTek 8169S Single-chip Gigabit Ethernet" },
    199         { RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169_8110SB,
    200                 "RealTek 8169SB/8110SB Single-chip Gigabit Ethernet" },
    201         { RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169_8110SC,
    202                 "RealTek 8169SC/8110SC Single-chip Gigabit Ethernet" },
    203         { RT_VENDORID, RT_DEVICEID_8169SC, RL_HWREV_8169_8110SC,
    204                 "RealTek 8169SC/8110SC Single-chip Gigabit Ethernet" },
    205         { RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8110S,
    206                 "RealTek 8110S Single-chip Gigabit Ethernet" },
    207         { COREGA_VENDORID, COREGA_DEVICEID_CGLAPCIGT, RL_HWREV_8169S,
    208                 "Corega CG-LAPCIGT (RTL8169S) Gigabit Ethernet" },
    209         { LINKSYS_VENDORID, LINKSYS_DEVICEID_EG1032, RL_HWREV_8169S,
    210                 "Linksys EG1032 (RTL8169S) Gigabit Ethernet" },
    211         { USR_VENDORID, USR_DEVICEID_997902, RL_HWREV_8169S,
    212                 "US Robotics 997902 (RTL8169S) Gigabit Ethernet" },
    213         { 0, 0, 0, NULL }
     189        { DLINK_VENDORID, DLINK_DEVICEID_528T, 0,
     190            "D-Link DGE-528(T) Gigabit Ethernet Adapter" },
     191        { RT_VENDORID, RT_DEVICEID_8139, 0,
     192            "RealTek 8139C+ 10/100BaseTX" },
     193        { RT_VENDORID, RT_DEVICEID_8101E, 0,
     194            "RealTek 8101E/8102E/8102EL PCIe 10/100baseTX" },
     195        { RT_VENDORID, RT_DEVICEID_8168, 0,
     196            "RealTek 8168/8168B/8168C/8168CP/8168D/8168DP/"
     197            "8111B/8111C/8111CP/8111DP PCIe Gigabit Ethernet" },
     198        { RT_VENDORID, RT_DEVICEID_8169, 0,
     199            "RealTek 8169/8169S/8169SB(L)/8110S/8110SB(L) Gigabit Ethernet" },
     200        { RT_VENDORID, RT_DEVICEID_8169SC, 0,
     201            "RealTek 8169SC/8110SC Single-chip Gigabit Ethernet" },
     202        { COREGA_VENDORID, COREGA_DEVICEID_CGLAPCIGT, 0,
     203            "Corega CG-LAPCIGT (RTL8169S) Gigabit Ethernet" },
     204        { LINKSYS_VENDORID, LINKSYS_DEVICEID_EG1032, 0,
     205            "Linksys EG1032 (RTL8169S) Gigabit Ethernet" },
     206        { USR_VENDORID, USR_DEVICEID_997902, 0,
     207            "US Robotics 997902 (RTL8169S) Gigabit Ethernet" }
    214208};
    215209
     
    227221        { RL_HWREV_8169S, RL_8169, "8169S"},
    228222        { RL_HWREV_8110S, RL_8169, "8110S"},
    229         { RL_HWREV_8169_8110SB, RL_8169, "8169SB"},
    230         { RL_HWREV_8169_8110SC, RL_8169, "8169SC"},
     223        { RL_HWREV_8169_8110SB, RL_8169, "8169SB/8110SB"},
     224        { RL_HWREV_8169_8110SC, RL_8169, "8169SC/8110SC"},
     225        { RL_HWREV_8169_8110SBL, RL_8169, "8169SBL/8110SBL"},
     226        { RL_HWREV_8169_8110SCE, RL_8169, "8169SC/8110SC"},
    231227        { RL_HWREV_8100, RL_8139, "8100"},
    232228        { RL_HWREV_8101, RL_8139, "8101"},
    233229        { RL_HWREV_8100E, RL_8169, "8100E"},
    234230        { RL_HWREV_8101E, RL_8169, "8101E"},
     231        { RL_HWREV_8102E, RL_8169, "8102E"},
     232        { RL_HWREV_8102EL, RL_8169, "8102EL"},
     233        { RL_HWREV_8102EL_SPIN1, RL_8169, "8102EL"},
    235234        { RL_HWREV_8168_SPIN2, RL_8169, "8168"},
    236235        { RL_HWREV_8168_SPIN3, RL_8169, "8168"},
     236        { RL_HWREV_8168C, RL_8169, "8168C/8111C"},
     237        { RL_HWREV_8168C_SPIN2, RL_8169, "8168C/8111C"},
     238        { RL_HWREV_8168CP, RL_8169, "8168CP/8111CP"},
     239        { RL_HWREV_8168D, RL_8169, "8168D/8111D"},
     240        { RL_HWREV_8168DP, RL_8169, "8168DP/8111DP"},
    237241        { 0, 0, NULL }
    238242};
     
    242246static int re_detach            (device_t);
    243247
    244 static int re_encap             (struct rl_softc *, struct mbuf **, int *);
     248static int re_encap             (struct rl_softc *, struct mbuf **);
    245249
    246250static void re_dma_map_addr     (void *, bus_dma_segment_t *, int, int);
    247 static void re_dma_map_desc     (void *, bus_dma_segment_t *, int,
    248                                     bus_size_t, int);
    249251static int re_allocmem          (device_t, struct rl_softc *);
    250 static int re_newbuf            (struct rl_softc *, int, struct mbuf *);
     252static __inline void re_discard_rxbuf
     253                                (struct rl_softc *, int);
     254static int re_newbuf            (struct rl_softc *, int);
    251255static int re_rx_list_init      (struct rl_softc *);
    252256static int re_tx_list_init      (struct rl_softc *);
     
    255259                                (struct mbuf *);
    256260#endif
    257 static int re_rxeof             (struct rl_softc *);
     261static int re_rxeof             (struct rl_softc *, int *);
    258262static void re_txeof            (struct rl_softc *);
    259263#ifdef DEVICE_POLLING
    260 static void re_poll             (struct ifnet *, enum poll_cmd, int);
    261 static void re_poll_locked      (struct ifnet *, enum poll_cmd, int);
    262 #endif
    263 #ifdef __rtems__
     264static int re_poll              (struct ifnet *, enum poll_cmd, int);
     265static int re_poll_locked       (struct ifnet *, enum poll_cmd, int);
     266#endif
    264267static int re_intr              (void *);
    265 #else
    266 static void re_intr             (void *);
    267 #endif
    268268static void re_tick             (void *);
    269269static void re_tx_task          (void *, int);
     
    283283static int re_resume            (device_t);
    284284#endif
    285 static void re_shutdown         (device_t);
     285#ifndef __rtems__
     286static int re_shutdown          (device_t);
     287#else
     288static void re_shutdown   (device_t);
     289#endif
    286290#ifndef __rtems__
    287291static int re_ifmedia_upd       (struct ifnet *);
     
    301305#endif
    302306
    303 static void re_setmulti         (struct rl_softc *);
     307static void re_set_rxmode               (struct rl_softc *);
    304308static void re_reset            (struct rl_softc *);
     309#ifndef __rtems__
     310static void re_setwol           (struct rl_softc *);
     311static void re_clrwol           (struct rl_softc *);
     312#endif
    305313
    306314#ifdef RE_DIAG
     
    347355
    348356DRIVER_MODULE(re, pci, re_driver, re_devclass, 0, 0);
    349 DRIVER_MODULE(re, cardbus, re_driver, re_devclass, 0, 0);
    350357DRIVER_MODULE(miibus, re, miibus_driver, miibus_devclass, 0, 0);
    351358#else
     
    421428 */
    422429static void
    423 re_eeprom_putbyte(sc, addr)
    424         struct rl_softc         *sc;
    425         int                     addr;
    426 {
    427         register int            d, i;
     430re_eeprom_putbyte(struct rl_softc *sc, int addr)
     431{
     432        int                     d, i;
    428433
    429434        d = addr | (RL_9346_READ << sc->rl_eewidth);
     
    445450                DELAY(100);
    446451        }
    447 
    448         return;
    449452}
    450453
     
    453456 */
    454457static void
    455 re_eeprom_getword(sc, addr, dest)
    456         struct rl_softc         *sc;
    457         int                     addr;
    458         u_int16_t               *dest;
    459 {
    460         register int            i;
     458re_eeprom_getword(struct rl_softc *sc, int addr, u_int16_t *dest)
     459{
     460        int                     i;
    461461        u_int16_t               word = 0;
    462462
     
    479479
    480480        *dest = word;
    481 
    482         return;
    483481}
    484482
     
    487485 */
    488486static void
    489 re_read_eeprom(sc, dest, off, cnt)
    490         struct rl_softc         *sc;
    491         caddr_t                 dest;
    492         int                     off;
    493         int                     cnt;
     487re_read_eeprom(struct rl_softc *sc, caddr_t dest, int off, int cnt)
    494488{
    495489        int                     i;
     
    509503
    510504        CSR_CLRBIT_1(sc, RL_EECMD, RL_EEMODE_PROGRAM);
    511 
    512         return;
    513505}
    514506
    515507static int
    516 re_gmii_readreg(dev, phy, reg)
    517         device_t                dev;
    518         int                     phy, reg;
     508re_gmii_readreg(device_t dev, int phy, int reg)
    519509{
    520510        struct rl_softc         *sc;
     
    537527        DELAY(1000);
    538528
    539         for (i = 0; i < RL_TIMEOUT; i++) {
     529        for (i = 0; i < RL_PHY_TIMEOUT; i++) {
    540530                rval = CSR_READ_4(sc, RL_PHYAR);
    541531                if (rval & RL_PHYAR_BUSY)
     
    544534        }
    545535
    546         if (i == RL_TIMEOUT) {
     536        if (i == RL_PHY_TIMEOUT) {
    547537                device_printf(sc->rl_dev, "PHY read failed\n");
    548538                return (0);
     
    553543
    554544static int
    555 re_gmii_writereg(dev, phy, reg, data)
    556         device_t                dev;
    557         int                     phy, reg, data;
     545re_gmii_writereg(device_t dev, int phy, int reg, int data)
    558546{
    559547        struct rl_softc         *sc;
     
    567555        DELAY(1000);
    568556
    569         for (i = 0; i < RL_TIMEOUT; i++) {
     557        for (i = 0; i < RL_PHY_TIMEOUT; i++) {
    570558                rval = CSR_READ_4(sc, RL_PHYAR);
    571559                if (!(rval & RL_PHYAR_BUSY))
     
    574562        }
    575563
    576         if (i == RL_TIMEOUT) {
     564        if (i == RL_PHY_TIMEOUT) {
    577565                device_printf(sc->rl_dev, "PHY write failed\n");
    578566                return (0);
     
    583571
    584572static int
    585 re_miibus_readreg(dev, phy, reg)
    586         device_t                dev;
    587         int                     phy, reg;
     573re_miibus_readreg(device_t dev, int phy, int reg)
    588574{
    589575        struct rl_softc         *sc;
     
    643629
    644630static int
    645 re_miibus_writereg(dev, phy, reg, data)
    646         device_t                dev;
    647         int                     phy, reg, data;
     631re_miibus_writereg(device_t dev, int phy, int reg, int data)
    648632{
    649633        struct rl_softc         *sc;
     
    696680#ifndef __rtems__
    697681static void
    698 re_miibus_statchg(dev)
    699         device_t                dev;
    700 {
    701 
     682re_miibus_statchg(device_t dev)
     683{
     684        struct rl_softc         *sc;
     685        struct ifnet            *ifp;
     686        struct mii_data         *mii;
     687
     688        sc = device_get_softc(dev);
     689        mii = device_get_softc(sc->rl_miibus);
     690        ifp = sc->rl_ifp;
     691        if (mii == NULL || ifp == NULL ||
     692            (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
     693                return;
     694
     695        sc->rl_flags &= ~RL_FLAG_LINK;
     696        if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
     697            (IFM_ACTIVE | IFM_AVALID)) {
     698                switch (IFM_SUBTYPE(mii->mii_media_active)) {
     699                case IFM_10_T:
     700                case IFM_100_TX:
     701                        sc->rl_flags |= RL_FLAG_LINK;
     702                        break;
     703                case IFM_1000_T:
     704                        if ((sc->rl_flags & RL_FLAG_FASTETHER) != 0)
     705                                break;
     706                        sc->rl_flags |= RL_FLAG_LINK;
     707                        break;
     708                default:
     709                        break;
     710                }
     711        }
     712        /*
     713         * RealTek controllers does not provide any interface to
     714         * Tx/Rx MACs for resolved speed, duplex and flow-control
     715         * parameters.
     716         */
    702717}
    703718#endif
    704719
    705720/*
    706  * Program the 64-bit multicast hash filter.
     721 * Set the RX configuration and 64-bit multicast hash filter.
    707722 */
    708723static void
    709 re_setmulti(sc)
    710         struct rl_softc         *sc;
     724re_set_rxmode(struct rl_softc *sc)
    711725{
    712726        struct ifnet            *ifp;
    713         int                     h = 0;
    714727#ifndef __rtems__
    715728        struct ifmultiaddr      *ifma;
    716729#endif
    717         u_int32_t               hashes[2] = { 0, 0 };
    718         u_int32_t               rxfilt;
    719         int                     mcnt = 0;
    720         u_int32_t               hwrev;
     730        uint32_t                hashes[2] = { 0, 0 };
     731        uint32_t                h, rxfilt;
    721732
    722733        RL_LOCK_ASSERT(sc);
     
    724735        ifp = sc->rl_ifp;
    725736
    726 
    727         rxfilt = CSR_READ_4(sc, RL_RXCFG);
    728         rxfilt &= ~(RL_RXCFG_RX_ALLPHYS | RL_RXCFG_RX_MULTI);
    729         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
     737        rxfilt = RL_RXCFG_CONFIG | RL_RXCFG_RX_INDIV | RL_RXCFG_RX_BROAD;
     738
     739        if (ifp->if_flags & (IFF_ALLMULTI | IFF_PROMISC)) {
    730740                if (ifp->if_flags & IFF_PROMISC)
    731741                        rxfilt |= RL_RXCFG_RX_ALLPHYS;
     
    736746                 */
    737747                rxfilt |= RL_RXCFG_RX_MULTI;
    738                 CSR_WRITE_4(sc, RL_RXCFG, rxfilt);
    739                 CSR_WRITE_4(sc, RL_MAR0, 0xFFFFFFFF);
    740                 CSR_WRITE_4(sc, RL_MAR4, 0xFFFFFFFF);
    741                 return;
    742         }
    743 
    744         /* first, zot all the existing hash bits */
    745         CSR_WRITE_4(sc, RL_MAR0, 0);
    746         CSR_WRITE_4(sc, RL_MAR4, 0);
    747 
    748         /* now program new ones */
    749 #ifndef __rtems__
    750         IF_ADDR_LOCK(ifp);
     748                hashes[0] = hashes[1] = 0xffffffff;
     749                goto done;
     750        }
     751
     752#ifndef __rtems__
     753        if_maddr_rlock(ifp);
    751754        TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
    752755                if (ifma->ifma_addr->sa_family != AF_LINK)
     
    758761                else
    759762                        hashes[1] |= (1 << (h - 32));
    760                 mcnt++;
    761         }
    762         IF_ADDR_UNLOCK(ifp);
     763        }
     764        if_maddr_runlock(ifp);
    763765#else
    764766        {
     
    773775                else
    774776                        hashes[1] |= (1 << (h - 32));
    775                 mcnt++;
    776         }
    777         }
    778 #endif
    779 
    780         if (mcnt)
     777        }
     778        }
     779#endif
     780 
     781        if (hashes[0] != 0 || hashes[1] != 0) {
     782                /*
     783                 * For some unfathomable reason, RealTek decided to
     784                 * reverse the order of the multicast hash registers
     785                 * in the PCI Express parts.  This means we have to
     786                 * write the hash pattern in reverse order for those
     787                 * devices.
     788                 */
     789                if ((sc->rl_flags & RL_FLAG_PCIE) != 0) {
     790                        h = bswap32(hashes[0]);
     791                        hashes[0] = bswap32(hashes[1]);
     792                        hashes[1] = h;
     793                }
    781794                rxfilt |= RL_RXCFG_RX_MULTI;
    782         else
    783                 rxfilt &= ~RL_RXCFG_RX_MULTI;
    784 
     795        }
     796
     797done:
     798        CSR_WRITE_4(sc, RL_MAR0, hashes[0]);
     799        CSR_WRITE_4(sc, RL_MAR4, hashes[1]);
    785800        CSR_WRITE_4(sc, RL_RXCFG, rxfilt);
    786 
    787         /*
    788          * For some unfathomable reason, RealTek decided to reverse
    789          * the order of the multicast hash registers in the PCI Express
    790          * parts. This means we have to write the hash pattern in reverse
    791          * order for those devices.
    792          */
    793 
    794         hwrev = CSR_READ_4(sc, RL_TXCFG) & RL_TXCFG_HWREV;
    795 
    796         switch (hwrev) {
    797         case RL_HWREV_8100E:
    798         case RL_HWREV_8101E:
    799         case RL_HWREV_8168_SPIN1:
    800         case RL_HWREV_8168_SPIN2:
    801         case RL_HWREV_8168_SPIN3:
    802                 CSR_WRITE_4(sc, RL_MAR0, bswap32(hashes[1]));
    803                 CSR_WRITE_4(sc, RL_MAR4, bswap32(hashes[0]));
    804                 break;
    805         default:
    806                 CSR_WRITE_4(sc, RL_MAR0, hashes[0]);
    807                 CSR_WRITE_4(sc, RL_MAR4, hashes[1]);
    808                 break;
    809         }
    810801}
    811802
    812803static void
    813 re_reset(sc)
    814         struct rl_softc         *sc;
    815 {
    816         register int            i;
     804re_reset(struct rl_softc *sc)
     805{
     806        int                     i;
    817807
    818808        RL_LOCK_ASSERT(sc);
     
    828818                device_printf(sc->rl_dev, "reset never completed!\n");
    829819
    830         CSR_WRITE_1(sc, 0x82, 1);
     820        if ((sc->rl_flags & RL_FLAG_MACRESET) != 0)
     821                CSR_WRITE_1(sc, 0x82, 1);
     822        if (sc->rl_hwrev == RL_HWREV_8169S)
     823                re_gmii_writereg(sc->rl_dev, 1, 0x0b, 0);
    831824}
    832825
     
    854847
    855848static int
    856 re_diag(sc)
    857         struct rl_softc         *sc;
     849re_diag(struct rl_softc *sc)
    858850{
    859851        struct ifnet            *ifp = sc->rl_ifp;
     
    885877        ifp->if_flags |= IFF_PROMISC;
    886878        sc->rl_testmode = 1;
    887         re_reset(sc);
    888879        re_init_locked(sc);
    889         sc->rl_link = 1;
     880        sc->rl_flags |= RL_FLAG_LINK;
    890881        if (sc->rl_type == RL_8169)
    891882                phyaddr = 1;
     
    953944            sc->rl_ldata.rl_rx_list_map,
    954945            BUS_DMASYNC_POSTREAD);
    955         bus_dmamap_sync(sc->rl_ldata.rl_mtag,
    956             sc->rl_ldata.rl_rx_dmamap[0],
    957             BUS_DMASYNC_POSTWRITE);
    958         bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    959             sc->rl_ldata.rl_rx_dmamap[0]);
    960 
    961         m0 = sc->rl_ldata.rl_rx_mbuf[0];
    962         sc->rl_ldata.rl_rx_mbuf[0] = NULL;
     946        bus_dmamap_sync(sc->rl_ldata.rl_rx_mtag,
     947            sc->rl_ldata.rl_rx_desc[0].rx_dmamap,
     948            BUS_DMASYNC_POSTREAD);
     949        bus_dmamap_unload(sc->rl_ldata.rl_rx_mtag,
     950            sc->rl_ldata.rl_rx_desc[0].rx_dmamap);
     951
     952        m0 = sc->rl_ldata.rl_rx_desc[0].rx_m;
     953        sc->rl_ldata.rl_rx_desc[0].rx_m = NULL;
    963954        eh = mtod(m0, struct ether_header *);
    964955
     
    998989
    999990        sc->rl_testmode = 0;
    1000         sc->rl_link = 0;
     991        sc->rl_flags &= ~RL_FLAG_LINK;
    1001992        ifp->if_flags &= ~IFF_PROMISC;
    1002993        re_stop(sc);
     
    10161007 */
    10171008static int
    1018 re_probe(dev)
    1019         device_t                dev;
     1009re_probe(device_t dev)
    10201010{
    10211011        struct rl_type          *t;
    1022         struct rl_softc         *sc;
    1023         int                     rid;
    1024         u_int32_t               hwrev;
    1025 
    1026         t = re_devs;
    1027         sc = device_get_softc(dev);
    1028 
    1029         while (t->rl_name != NULL) {
    1030                 if ((pci_get_vendor(dev) == t->rl_vid) &&
    1031                     (pci_get_device(dev) == t->rl_did)) {
     1012        uint16_t                devid, vendor;
     1013        uint16_t                revid, sdevid;
     1014        int                     i;
     1015       
     1016        vendor = pci_get_vendor(dev);
     1017        devid = pci_get_device(dev);
     1018        revid = pci_get_revid(dev);
     1019        sdevid = pci_get_subdevice(dev);
     1020
     1021        if (vendor == LINKSYS_VENDORID && devid == LINKSYS_DEVICEID_EG1032) {
     1022                if (sdevid != LINKSYS_SUBDEVICE_EG1032_REV3) {
    10321023                        /*
    10331024                         * Only attach to rev. 3 of the Linksys EG1032 adapter.
    1034                          * Rev. 2 i supported by sk(4).
     1025                         * Rev. 2 is supported by sk(4).
    10351026                         */
    1036                         if ((t->rl_vid == LINKSYS_VENDORID) &&
    1037                                 (t->rl_did == LINKSYS_DEVICEID_EG1032) &&
    1038                                 (pci_get_subdevice(dev) !=
    1039                                 LINKSYS_SUBDEVICE_EG1032_REV3)) {
    1040                                 t++;
    1041                                 continue;
    1042                         }
    1043 
    1044                         /*
    1045                          * Temporarily map the I/O space
    1046                          * so we can read the chip ID register.
    1047                          */
    1048                         rid = RL_RID;
    1049                         sc->rl_res = bus_alloc_resource_any(dev, RL_RES, &rid,
    1050                             RF_ACTIVE);
    1051                         if (sc->rl_res == NULL) {
    1052                                 device_printf(dev,
    1053                                     "couldn't map ports/memory\n");
    1054                                 return (ENXIO);
    1055                         }
    1056                         sc->rl_btag = rman_get_bustag(sc->rl_res);
    1057                         sc->rl_bhandle = rman_get_bushandle(sc->rl_res);
    1058                         hwrev = CSR_READ_4(sc, RL_TXCFG) & RL_TXCFG_HWREV;
    1059                         bus_release_resource(dev, RL_RES,
    1060                             RL_RID, sc->rl_res);
    1061                         if (t->rl_basetype == hwrev) {
    1062                                 device_set_desc(dev, t->rl_name);
    1063                                 return (BUS_PROBE_DEFAULT);
    1064                         }
    1065                 }
    1066                 t++;
     1027                        return (ENXIO);
     1028                }
     1029        }
     1030
     1031        if (vendor == RT_VENDORID && devid == RT_DEVICEID_8139) {
     1032                if (revid != 0x20) {
     1033                        /* 8139, let rl(4) take care of this device. */
     1034      printf ("need rl driver: %0x %0x %0x\n", vendor, devid, revid);
     1035                        return (ENXIO);
     1036                }
     1037        }
     1038
     1039        t = re_devs;
     1040        for (i = 0; i < sizeof(re_devs) / sizeof(re_devs[0]); i++, t++) {
     1041                if (vendor == t->rl_vid && devid == t->rl_did) {
     1042                        device_set_desc(dev, t->rl_name);
     1043                        return (BUS_PROBE_DEFAULT);
     1044                }
    10671045        }
    10681046
    10691047        return (ENXIO);
    1070 }
    1071 
    1072 /*
    1073  * This routine takes the segment list provided as the result of
    1074  * a bus_dma_map_load() operation and assigns the addresses/lengths
    1075  * to RealTek DMA descriptors. This can be called either by the RX
    1076  * code or the TX code. In the RX case, we'll probably wind up mapping
    1077  * at most one segment. For the TX case, there could be any number of
    1078  * segments since TX packets may span multiple mbufs. In either case,
    1079  * if the number of segments is larger than the rl_maxsegs limit
    1080  * specified by the caller, we abort the mapping operation. Sadly,
    1081  * whoever designed the buffer mapping API did not provide a way to
    1082  * return an error from here, so we have to fake it a bit.
    1083  */
    1084 
    1085 static void
    1086 re_dma_map_desc(arg, segs, nseg, mapsize, error)
    1087         void                    *arg;
    1088         bus_dma_segment_t       *segs;
    1089         int                     nseg;
    1090         bus_size_t              mapsize;
    1091         int                     error;
    1092 {
    1093         struct rl_dmaload_arg   *ctx;
    1094         struct rl_desc          *d = NULL;
    1095         int                     i = 0, idx;
    1096         u_int32_t               cmdstat;
    1097         int                     totlen = 0;
    1098 
    1099         if (error)
    1100                 return;
    1101 
    1102         ctx = arg;
    1103 
    1104         /* Signal error to caller if there's too many segments */
    1105         if (nseg > ctx->rl_maxsegs) {
    1106                 ctx->rl_maxsegs = 0;
    1107                 return;
    1108         }
    1109 
    1110         /*
    1111          * Map the segment array into descriptors. Note that we set the
    1112          * start-of-frame and end-of-frame markers for either TX or RX, but
    1113          * they really only have meaning in the TX case. (In the RX case,
    1114          * it's the chip that tells us where packets begin and end.)
    1115          * We also keep track of the end of the ring and set the
    1116          * end-of-ring bits as needed, and we set the ownership bits
    1117          * in all except the very first descriptor. (The caller will
    1118          * set this descriptor later when it start transmission or
    1119          * reception.)
    1120          */
    1121         idx = ctx->rl_idx;
    1122         for (;;) {
    1123                 d = &ctx->rl_ring[idx];
    1124                 if (le32toh(d->rl_cmdstat) & RL_RDESC_STAT_OWN) {
    1125                         ctx->rl_maxsegs = 0;
    1126                         return;
    1127                 }
    1128                 cmdstat = segs[i].ds_len;
    1129                 totlen += segs[i].ds_len;
    1130                 d->rl_vlanctl = 0;
    1131                 d->rl_bufaddr_lo = htole32(RL_ADDR_LO(segs[i].ds_addr));
    1132                 d->rl_bufaddr_hi = htole32(RL_ADDR_HI(segs[i].ds_addr));
    1133                 if (i == 0)
    1134                         cmdstat |= RL_TDESC_CMD_SOF;
    1135                 else
    1136                         cmdstat |= RL_TDESC_CMD_OWN;
    1137                 if (idx == (RL_RX_DESC_CNT - 1))
    1138                         cmdstat |= RL_TDESC_CMD_EOR;
    1139                 d->rl_cmdstat = htole32(cmdstat | ctx->rl_flags);
    1140                 i++;
    1141                 if (i == nseg)
    1142                         break;
    1143                 RL_DESC_INC(idx);
    1144         }
    1145 
    1146         d->rl_cmdstat |= htole32(RL_TDESC_CMD_EOF);
    1147         ctx->rl_maxsegs = nseg;
    1148         ctx->rl_idx = idx;
    11491048}
    11501049
     
    11541053
    11551054static void
    1156 re_dma_map_addr(arg, segs, nseg, error)
    1157         void                    *arg;
    1158         bus_dma_segment_t       *segs;
    1159         int                     nseg;
    1160         int                     error;
     1055re_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
    11611056{
    11621057        bus_addr_t              *addr;
     
    11711066
    11721067static int
    1173 re_allocmem(dev, sc)
    1174         device_t                dev;
    1175         struct rl_softc         *sc;
    1176 {
     1068re_allocmem(device_t dev, struct rl_softc *sc)
     1069{
     1070        bus_size_t              rx_list_size, tx_list_size;
    11771071        int                     error;
    1178         int                     nseg;
    11791072        int                     i;
    11801073
     1074        rx_list_size = sc->rl_ldata.rl_rx_desc_cnt * sizeof(struct rl_desc);
     1075        tx_list_size = sc->rl_ldata.rl_tx_desc_cnt * sizeof(struct rl_desc);
     1076
     1077        /*
     1078         * Allocate the parent bus DMA tag appropriate for PCI.
     1079         * In order to use DAC, RL_CPLUSCMD_PCI_DAC bit of RL_CPLUS_CMD
     1080         * register should be set. However some RealTek chips are known
     1081         * to be buggy on DAC handling, therefore disable DAC by limiting
     1082         * DMA address space to 32bit. PCIe variants of RealTek chips
     1083         * may not have the limitation but I took safer path.
     1084         */
     1085        error = bus_dma_tag_create(bus_get_dma_tag(dev), 1, 0,
     1086            BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
     1087            BUS_SPACE_MAXSIZE_32BIT, 0, BUS_SPACE_MAXSIZE_32BIT, 0,
     1088            NULL, NULL, &sc->rl_parent_tag);
     1089        if (error) {
     1090                device_printf(dev, "could not allocate parent DMA tag\n");
     1091                return (error);
     1092        }
     1093
     1094        /*
     1095         * Allocate map for TX mbufs.
     1096         */
     1097        error = bus_dma_tag_create(sc->rl_parent_tag, 1, 0,
     1098            BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL,
     1099            NULL, MCLBYTES * RL_NTXSEGS, RL_NTXSEGS, 4096, 0,
     1100            NULL, NULL, &sc->rl_ldata.rl_tx_mtag);
     1101        if (error) {
     1102                device_printf(dev, "could not allocate TX DMA tag\n");
     1103                return (error);
     1104        }
     1105
    11811106        /*
    11821107         * Allocate map for RX mbufs.
    11831108         */
    1184         nseg = 32;
    1185         error = bus_dma_tag_create(sc->rl_parent_tag, ETHER_ALIGN, 0,
    1186             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
    1187             NULL, MCLBYTES * nseg, nseg, MCLBYTES, BUS_DMA_ALLOCNOW,
    1188             NULL, NULL, &sc->rl_ldata.rl_mtag);
     1109
     1110        error = bus_dma_tag_create(sc->rl_parent_tag, sizeof(uint64_t), 0,
     1111            BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
     1112            MCLBYTES, 1, MCLBYTES, 0, NULL, NULL, &sc->rl_ldata.rl_rx_mtag);
    11891113        if (error) {
    1190                 device_printf(dev, "could not allocate dma tag\n");
    1191                 return (ENOMEM);
     1114                device_printf(dev, "could not allocate RX DMA tag\n");
     1115                return (error);
    11921116        }
    11931117
     
    11971121        error = bus_dma_tag_create(sc->rl_parent_tag, RL_RING_ALIGN,
    11981122            0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
    1199             NULL, RL_TX_LIST_SZ, 1, RL_TX_LIST_SZ, 0,
     1123            NULL, tx_list_size, 1, tx_list_size, 0,
    12001124            NULL, NULL, &sc->rl_ldata.rl_tx_list_tag);
    12011125        if (error) {
    1202                 device_printf(dev, "could not allocate dma tag\n");
     1126                device_printf(dev, "could not allocate TX DMA ring tag\n");
     1127                return (error);
     1128        }
     1129
     1130        /* Allocate DMA'able memory for the TX ring */
     1131
     1132        error = bus_dmamem_alloc(sc->rl_ldata.rl_tx_list_tag,
     1133            (void **)&sc->rl_ldata.rl_tx_list,
     1134            BUS_DMA_WAITOK | BUS_DMA_COHERENT | BUS_DMA_ZERO,
     1135            &sc->rl_ldata.rl_tx_list_map);
     1136        if (error) {
     1137                device_printf(dev, "could not allocate TX DMA ring\n");
     1138                return (error);
     1139        }
     1140
     1141        /* Load the map for the TX ring. */
     1142
     1143        sc->rl_ldata.rl_tx_list_addr = 0;
     1144        error = bus_dmamap_load(sc->rl_ldata.rl_tx_list_tag,
     1145             sc->rl_ldata.rl_tx_list_map, sc->rl_ldata.rl_tx_list,
     1146             tx_list_size, re_dma_map_addr,
     1147             &sc->rl_ldata.rl_tx_list_addr, BUS_DMA_NOWAIT);
     1148        if (error != 0 || sc->rl_ldata.rl_tx_list_addr == 0) {
     1149                device_printf(dev, "could not load TX DMA ring\n");
    12031150                return (ENOMEM);
    12041151        }
    12051152
    1206         /* Allocate DMA'able memory for the TX ring */
    1207 
    1208         error = bus_dmamem_alloc(sc->rl_ldata.rl_tx_list_tag,
    1209             (void **)&sc->rl_ldata.rl_tx_list, BUS_DMA_NOWAIT | BUS_DMA_ZERO,
    1210             &sc->rl_ldata.rl_tx_list_map);
    1211         if (error)
    1212                 return (ENOMEM);
    1213 
    1214         /* Load the map for the TX ring. */
    1215 
    1216         error = bus_dmamap_load(sc->rl_ldata.rl_tx_list_tag,
    1217              sc->rl_ldata.rl_tx_list_map, (caddr_t) sc->rl_ldata.rl_tx_list,
    1218              RL_TX_LIST_SZ, re_dma_map_addr,
    1219              &sc->rl_ldata.rl_tx_list_addr, BUS_DMA_NOWAIT);
    1220 
    12211153        /* Create DMA maps for TX buffers */
    12221154
    1223         for (i = 0; i < RL_TX_DESC_CNT; i++) {
    1224                 error = bus_dmamap_create(sc->rl_ldata.rl_mtag, 0,
    1225                             &sc->rl_ldata.rl_tx_dmamap[i]);
     1155        for (i = 0; i < sc->rl_ldata.rl_tx_desc_cnt; i++) {
     1156                error = bus_dmamap_create(sc->rl_ldata.rl_tx_mtag, 0,
     1157                    &sc->rl_ldata.rl_tx_desc[i].tx_dmamap);
    12261158                if (error) {
    1227                         device_printf(dev, "can't create DMA map for TX\n");
    1228                         return (ENOMEM);
     1159                        device_printf(dev, "could not create DMA map for TX\n");
     1160                        return (error);
    12291161                }
    12301162        }
     
    12351167        error = bus_dma_tag_create(sc->rl_parent_tag, RL_RING_ALIGN,
    12361168            0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
    1237             NULL, RL_RX_LIST_SZ, 1, RL_RX_LIST_SZ, 0,
     1169            NULL, rx_list_size, 1, rx_list_size, 0,
    12381170            NULL, NULL, &sc->rl_ldata.rl_rx_list_tag);
    12391171        if (error) {
    1240                 device_printf(dev, "could not allocate dma tag\n");
     1172                device_printf(dev, "could not create RX DMA ring tag\n");
     1173                return (error);
     1174        }
     1175
     1176        /* Allocate DMA'able memory for the RX ring */
     1177
     1178        error = bus_dmamem_alloc(sc->rl_ldata.rl_rx_list_tag,
     1179            (void **)&sc->rl_ldata.rl_rx_list,
     1180            BUS_DMA_WAITOK | BUS_DMA_COHERENT | BUS_DMA_ZERO,
     1181            &sc->rl_ldata.rl_rx_list_map);
     1182        if (error) {
     1183                device_printf(dev, "could not allocate RX DMA ring\n");
     1184                return (error);
     1185        }
     1186
     1187        /* Load the map for the RX ring. */
     1188
     1189        sc->rl_ldata.rl_rx_list_addr = 0;
     1190        error = bus_dmamap_load(sc->rl_ldata.rl_rx_list_tag,
     1191             sc->rl_ldata.rl_rx_list_map, sc->rl_ldata.rl_rx_list,
     1192             rx_list_size, re_dma_map_addr,
     1193             &sc->rl_ldata.rl_rx_list_addr, BUS_DMA_NOWAIT);
     1194        if (error != 0 || sc->rl_ldata.rl_rx_list_addr == 0) {
     1195                device_printf(dev, "could not load RX DMA ring\n");
    12411196                return (ENOMEM);
    12421197        }
    12431198
    1244         /* Allocate DMA'able memory for the RX ring */
    1245 
    1246         error = bus_dmamem_alloc(sc->rl_ldata.rl_rx_list_tag,
    1247             (void **)&sc->rl_ldata.rl_rx_list, BUS_DMA_NOWAIT | BUS_DMA_ZERO,
    1248             &sc->rl_ldata.rl_rx_list_map);
    1249         if (error)
    1250                 return (ENOMEM);
    1251 
    1252         /* Load the map for the RX ring. */
    1253 
    1254         error = bus_dmamap_load(sc->rl_ldata.rl_rx_list_tag,
    1255              sc->rl_ldata.rl_rx_list_map, (caddr_t) sc->rl_ldata.rl_rx_list,
    1256              RL_RX_LIST_SZ, re_dma_map_addr,
    1257              &sc->rl_ldata.rl_rx_list_addr, BUS_DMA_NOWAIT);
    1258 
    12591199        /* Create DMA maps for RX buffers */
    12601200
    1261         for (i = 0; i < RL_RX_DESC_CNT; i++) {
    1262                 error = bus_dmamap_create(sc->rl_ldata.rl_mtag, 0,
    1263                             &sc->rl_ldata.rl_rx_dmamap[i]);
     1201        error = bus_dmamap_create(sc->rl_ldata.rl_rx_mtag, 0,
     1202            &sc->rl_ldata.rl_rx_sparemap);
     1203        if (error) {
     1204                device_printf(dev, "could not create spare DMA map for RX\n");
     1205                return (error);
     1206        }
     1207        for (i = 0; i < sc->rl_ldata.rl_rx_desc_cnt; i++) {
     1208                error = bus_dmamap_create(sc->rl_ldata.rl_rx_mtag, 0,
     1209                    &sc->rl_ldata.rl_rx_desc[i].rx_dmamap);
    12641210                if (error) {
    1265                         device_printf(dev, "can't create DMA map for RX\n");
    1266                         return (ENOMEM);
     1211                        device_printf(dev, "could not create DMA map for RX\n");
     1212                        return (error);
    12671213                }
    12681214        }
     
    12761222 */
    12771223static int
    1278 re_attach(dev)
    1279         device_t                dev;
     1224re_attach(device_t dev)
    12801225{
    12811226        u_char                  eaddr[ETHER_ADDR_LEN];
     
    12851230        struct rl_hwrev         *hw_rev;
    12861231        int                     hwrev;
    1287         u_int16_t               re_did = 0;
     1232        u_int16_t               devid, re_did = 0;
    12881233        int                     error = 0, rid, i;
     1234#ifndef __rtems__
     1235        int                     msic, reg;
     1236#else
     1237        int                     msic;
     1238#endif
     1239        uint8_t                 cfg;
    12891240
    12901241        sc = device_get_softc(dev);
     
    13001251        pci_enable_busmaster(dev);
    13011252
    1302         rid = RL_RID;
    1303         sc->rl_res = bus_alloc_resource_any(dev, RL_RES, &rid,
    1304             RF_ACTIVE);
    1305 
     1253        devid = pci_get_device(dev);
     1254        /*
     1255         * Prefer memory space register mapping over IO space.
     1256         * Because RTL8169SC does not seem to work when memory mapping
     1257         * is used always activate io mapping.
     1258         */
     1259        if (devid == RT_DEVICEID_8169SC)
     1260                prefer_iomap = 1;
     1261        if (prefer_iomap == 0) {
     1262                sc->rl_res_id = PCIR_BAR(1);
     1263                sc->rl_res_type = SYS_RES_MEMORY;
     1264                /* RTL8168/8101E seems to use different BARs. */
     1265                if (devid == RT_DEVICEID_8168 || devid == RT_DEVICEID_8101E)
     1266                        sc->rl_res_id = PCIR_BAR(2);
     1267        } else {
     1268                sc->rl_res_id = PCIR_BAR(0);
     1269                sc->rl_res_type = SYS_RES_IOPORT;
     1270        }
     1271        sc->rl_res = bus_alloc_resource_any(dev, sc->rl_res_type,
     1272            &sc->rl_res_id, RF_ACTIVE);
     1273        if (sc->rl_res == NULL && prefer_iomap == 0) {
     1274                sc->rl_res_id = PCIR_BAR(0);
     1275                sc->rl_res_type = SYS_RES_IOPORT;
     1276                sc->rl_res = bus_alloc_resource_any(dev, sc->rl_res_type,
     1277                    &sc->rl_res_id, RF_ACTIVE);
     1278        }
    13061279        if (sc->rl_res == NULL) {
    13071280                device_printf(dev, "couldn't map ports/memory\n");
     
    13131286        sc->rl_bhandle = rman_get_bushandle(sc->rl_res);
    13141287
     1288        msic = 0;
     1289#ifndef __rtems__
     1290        if (pci_find_extcap(dev, PCIY_EXPRESS, &reg) == 0) {
     1291                sc->rl_flags |= RL_FLAG_PCIE;
     1292                msic = pci_msi_count(dev);
     1293                if (bootverbose)
     1294                        device_printf(dev, "MSI count : %d\n", msic);
     1295        }
     1296        if (msic > 0 && msi_disable == 0) {
     1297                msic = 1;
     1298                if (pci_alloc_msi(dev, &msic) == 0) {
     1299                        if (msic == RL_MSI_MESSAGES) {
     1300                                device_printf(dev, "Using %d MSI messages\n",
     1301                                    msic);
     1302                                sc->rl_flags |= RL_FLAG_MSI;
     1303                                /* Explicitly set MSI enable bit. */
     1304                                CSR_WRITE_1(sc, RL_EECMD, RL_EE_MODE);
     1305                                cfg = CSR_READ_1(sc, RL_CFG2);
     1306                                cfg |= RL_CFG2_MSI;
     1307                                CSR_WRITE_1(sc, RL_CFG2, cfg);
     1308                                CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
     1309                        } else
     1310                                pci_release_msi(dev);
     1311                }
     1312        }
     1313#endif
     1314 
    13151315        /* Allocate interrupt */
    1316         rid = 0;
    1317         sc->rl_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
    1318             RF_SHAREABLE | RF_ACTIVE);
    1319 
    1320         if (sc->rl_irq == NULL) {
    1321                 device_printf(dev, "couldn't map interrupt\n");
    1322                 error = ENXIO;
    1323                 goto fail;
     1316        if ((sc->rl_flags & RL_FLAG_MSI) == 0) {
     1317                rid = 0;
     1318                sc->rl_irq[0] = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
     1319                    RF_SHAREABLE | RF_ACTIVE);
     1320                if (sc->rl_irq[0] == NULL) {
     1321                        device_printf(dev, "couldn't allocate IRQ resources\n");
     1322                        error = ENXIO;
     1323                        goto fail;
     1324                }
     1325        } else {
     1326                for (i = 0, rid = 1; i < RL_MSI_MESSAGES; i++, rid++) {
     1327                        sc->rl_irq[i] = bus_alloc_resource_any(dev,
     1328                            SYS_RES_IRQ, &rid, RF_ACTIVE);
     1329                        if (sc->rl_irq[i] == NULL) {
     1330                                device_printf(dev,
     1331                                    "couldn't llocate IRQ resources for "
     1332                                    "message %d\n", rid);
     1333                                error = ENXIO;
     1334                                goto fail;
     1335                        }
     1336                }
     1337        }
     1338
     1339        if ((sc->rl_flags & RL_FLAG_MSI) == 0) {
     1340                CSR_WRITE_1(sc, RL_EECMD, RL_EE_MODE);
     1341                cfg = CSR_READ_1(sc, RL_CFG2);
     1342                if ((cfg & RL_CFG2_MSI) != 0) {
     1343                        device_printf(dev, "turning off MSI enable bit.\n");
     1344                        cfg &= ~RL_CFG2_MSI;
     1345                        CSR_WRITE_1(sc, RL_CFG2, cfg);
     1346                }
     1347                CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
    13241348        }
    13251349
     
    13301354
    13311355        hw_rev = re_hwrevs;
    1332         hwrev = CSR_READ_4(sc, RL_TXCFG) & RL_TXCFG_HWREV;
     1356        hwrev = CSR_READ_4(sc, RL_TXCFG);
     1357        switch (hwrev & 0x70000000) {
     1358        case 0x00000000:
     1359        case 0x10000000:
     1360                device_printf(dev, "Chip rev. 0x%08x\n", hwrev & 0xfc800000);
     1361                hwrev &= (RL_TXCFG_HWREV | 0x80000000);
     1362                break;
     1363        default:
     1364                device_printf(dev, "Chip rev. 0x%08x\n", hwrev & 0x7c800000);
     1365                hwrev &= RL_TXCFG_HWREV;
     1366                break;
     1367        }
     1368        device_printf(dev, "MAC rev. 0x%08x\n", hwrev & 0x00700000);
    13331369        while (hw_rev->rl_desc != NULL) {
    13341370                if (hw_rev->rl_rev == hwrev) {
    13351371                        sc->rl_type = hw_rev->rl_type;
     1372                        sc->rl_hwrev = hw_rev->rl_rev;
    13361373                        break;
    13371374                }
    13381375                hw_rev++;
    13391376        }
    1340 
    1341         sc->rl_eewidth = RL_9356_ADDR_LEN;
    1342         re_read_eeprom(sc, (caddr_t)&re_did, 0, 1);
    1343         if (re_did != 0x8129)
    1344                 sc->rl_eewidth = RL_9346_ADDR_LEN;
    1345 
    1346         /*
    1347          * Get station address from the EEPROM.
    1348          */
    1349         re_read_eeprom(sc, (caddr_t)as, RL_EE_EADDR, 3);
    1350         for (i = 0; i < ETHER_ADDR_LEN / 2; i++)
    1351                 as[i] = le16toh(as[i]);
    1352         bcopy(as, eaddr, sizeof(eaddr));
     1377        if (hw_rev->rl_desc == NULL) {
     1378                device_printf(dev, "Unknown H/W revision: 0x%08x\n", hwrev);
     1379                error = ENXIO;
     1380                goto fail;
     1381        }
     1382
     1383        switch (hw_rev->rl_rev) {
     1384        case RL_HWREV_8139CPLUS:
     1385                sc->rl_flags |= RL_FLAG_NOJUMBO | RL_FLAG_FASTETHER |
     1386                    RL_FLAG_AUTOPAD;
     1387                break;
     1388        case RL_HWREV_8100E:
     1389        case RL_HWREV_8101E:
     1390                sc->rl_flags |= RL_FLAG_NOJUMBO | RL_FLAG_PHYWAKE |
     1391                    RL_FLAG_FASTETHER;
     1392                break;
     1393        case RL_HWREV_8102E:
     1394        case RL_HWREV_8102EL:
     1395        case RL_HWREV_8102EL_SPIN1:
     1396                sc->rl_flags |= RL_FLAG_NOJUMBO | RL_FLAG_PHYWAKE |
     1397                    RL_FLAG_PAR | RL_FLAG_DESCV2 | RL_FLAG_MACSTAT |
     1398                    RL_FLAG_FASTETHER | RL_FLAG_CMDSTOP | RL_FLAG_AUTOPAD;
     1399                break;
     1400        case RL_HWREV_8168_SPIN1:
     1401        case RL_HWREV_8168_SPIN2:
     1402                sc->rl_flags |= RL_FLAG_WOLRXENB;
     1403                /* FALLTHROUGH */
     1404        case RL_HWREV_8168_SPIN3:
     1405                sc->rl_flags |= RL_FLAG_PHYWAKE | RL_FLAG_MACSTAT;
     1406                break;
     1407        case RL_HWREV_8168C_SPIN2:
     1408                sc->rl_flags |= RL_FLAG_MACSLEEP;
     1409                /* FALLTHROUGH */
     1410        case RL_HWREV_8168C:
     1411                if ((hwrev & 0x00700000) == 0x00200000)
     1412                        sc->rl_flags |= RL_FLAG_MACSLEEP;
     1413                /* FALLTHROUGH */
     1414        case RL_HWREV_8168CP:
     1415        case RL_HWREV_8168D:
     1416        case RL_HWREV_8168DP:
     1417                sc->rl_flags |= RL_FLAG_PHYWAKE | RL_FLAG_PAR |
     1418                    RL_FLAG_DESCV2 | RL_FLAG_MACSTAT | RL_FLAG_CMDSTOP |
     1419                    RL_FLAG_AUTOPAD;
     1420                /*
     1421                 * These controllers support jumbo frame but it seems
     1422                 * that enabling it requires touching additional magic
     1423                 * registers. Depending on MAC revisions some
     1424                 * controllers need to disable checksum offload. So
     1425                 * disable jumbo frame until I have better idea what
     1426                 * it really requires to make it support.
     1427                 * RTL8168C/CP : supports up to 6KB jumbo frame.
     1428                 * RTL8111C/CP : supports up to 9KB jumbo frame.
     1429                 */
     1430                sc->rl_flags |= RL_FLAG_NOJUMBO;
     1431                break;
     1432        case RL_HWREV_8169_8110SB:
     1433        case RL_HWREV_8169_8110SBL:
     1434        case RL_HWREV_8169_8110SC:
     1435        case RL_HWREV_8169_8110SCE:
     1436                sc->rl_flags |= RL_FLAG_PHYWAKE;
     1437                /* FALLTHROUGH */
     1438        case RL_HWREV_8169:
     1439        case RL_HWREV_8169S:
     1440        case RL_HWREV_8110S:
     1441                sc->rl_flags |= RL_FLAG_MACRESET;
     1442                break;
     1443        default:
     1444                break;
     1445        }
     1446
     1447        /* Enable PME. */
     1448        CSR_WRITE_1(sc, RL_EECMD, RL_EE_MODE);
     1449        cfg = CSR_READ_1(sc, RL_CFG1);
     1450        cfg |= RL_CFG1_PME;
     1451        CSR_WRITE_1(sc, RL_CFG1, cfg);
     1452        cfg = CSR_READ_1(sc, RL_CFG5);
     1453        cfg &= RL_CFG5_PME_STS;
     1454        CSR_WRITE_1(sc, RL_CFG5, cfg);
     1455        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
     1456
     1457        if ((sc->rl_flags & RL_FLAG_PAR) != 0) {
     1458                /*
     1459                 * XXX Should have a better way to extract station
     1460                 * address from EEPROM.
     1461                 */
     1462                for (i = 0; i < ETHER_ADDR_LEN; i++)
     1463                        eaddr[i] = CSR_READ_1(sc, RL_IDR0 + i);
     1464        } else {
     1465                sc->rl_eewidth = RL_9356_ADDR_LEN;
     1466                re_read_eeprom(sc, (caddr_t)&re_did, 0, 1);
     1467                if (re_did != 0x8129)
     1468                        sc->rl_eewidth = RL_9346_ADDR_LEN;
     1469
     1470                /*
     1471                 * Get station address from the EEPROM.
     1472                 */
     1473                re_read_eeprom(sc, (caddr_t)as, RL_EE_EADDR, 3);
     1474                for (i = 0; i < ETHER_ADDR_LEN / 2; i++)
     1475                        as[i] = le16toh(as[i]);
     1476                bcopy(as, eaddr, sizeof(eaddr));
     1477        }
    13531478
    13541479        if (sc->rl_type == RL_8169) {
    1355                 /* Set RX length mask */
     1480                /* Set RX length mask and number of descriptors. */
    13561481                sc->rl_rxlenmask = RL_RDESC_STAT_GFRAGLEN;
    13571482                sc->rl_txstart = RL_GTXSTART;
     1483                sc->rl_ldata.rl_tx_desc_cnt = RL_8169_TX_DESC_CNT;
     1484                sc->rl_ldata.rl_rx_desc_cnt = RL_8169_RX_DESC_CNT;
    13581485        } else {
    1359                 /* Set RX length mask */
     1486                /* Set RX length mask and number of descriptors. */
    13601487                sc->rl_rxlenmask = RL_RDESC_STAT_FRAGLEN;
    13611488                sc->rl_txstart = RL_TXSTART;
    1362         }
    1363 
    1364         /*
    1365          * Allocate the parent bus DMA tag appropriate for PCI.
    1366          */
    1367 #define RL_NSEG_NEW 32
    1368         error = bus_dma_tag_create(bus_get_dma_tag(dev), 1, 0,
    1369             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
    1370             MAXBSIZE, RL_NSEG_NEW, BUS_SPACE_MAXSIZE_32BIT, 0,
    1371             NULL, NULL, &sc->rl_parent_tag);
    1372         if (error)
    1373                 goto fail;
     1489                sc->rl_ldata.rl_tx_desc_cnt = RL_8139_TX_DESC_CNT;
     1490                sc->rl_ldata.rl_rx_desc_cnt = RL_8139_RX_DESC_CNT;
     1491        }
    13741492
    13751493        error = re_allocmem(dev, sc);
    1376 
    13771494        if (error)
    13781495                goto fail;
     
    13851502        }
    13861503
     1504        /* Take controller out of deep sleep mode. */
     1505        if ((sc->rl_flags & RL_FLAG_MACSLEEP) != 0) {
     1506                if ((CSR_READ_1(sc, RL_MACDBG) & 0x80) == 0x80)
     1507                        CSR_WRITE_1(sc, RL_GPIO,
     1508                            CSR_READ_1(sc, RL_GPIO) | 0x01);
     1509                else
     1510                        CSR_WRITE_1(sc, RL_GPIO,
     1511                            CSR_READ_1(sc, RL_GPIO) & ~0x01);
     1512        }
     1513
     1514        /* Take PHY out of power down mode. */
     1515        if ((sc->rl_flags & RL_FLAG_PHYWAKE) != 0) {
     1516                re_gmii_writereg(dev, 1, 0x1f, 0);
     1517                re_gmii_writereg(dev, 1, 0x0e, 0);
     1518        }
     1519
    13871520        /* Do MII setup */
    13881521#ifndef __rtems__
     
    13951528#endif
    13961529
    1397         /* Take PHY out of power down mode. */
    1398         if (sc->rl_type == RL_8169) {
    1399                 uint32_t rev;
    1400 
    1401                 rev = CSR_READ_4(sc, RL_TXCFG);
    1402                 /* HWVERID 0, 1 and 2 :  bit26-30, bit23 */
    1403                 rev &= 0x7c800000;
    1404                 if (rev != 0) {
    1405                         /* RTL8169S single chip */
    1406                         switch (rev) {
    1407                         case RL_HWREV_8169_8110SB:
    1408                         case RL_HWREV_8169_8110SC:
    1409                         case RL_HWREV_8168_SPIN2:
    1410                         case RL_HWREV_8168_SPIN3:
    1411                                 re_gmii_writereg(dev, 1, 0x1f, 0);
    1412                                 re_gmii_writereg(dev, 1, 0x0e, 0);
    1413                                 break;
    1414                         default:
    1415                                 break;
    1416                         }
    1417                 }
    1418         }
    1419 
    14201530        ifp->if_softc = sc;
    14211531        if_initname(ifp, device_get_name(dev), device_get_unit(dev));
     
    14441554
    14451555        /*
     1556         * XXX
     1557         * Still have no idea how to make TSO work on 8168C, 8168CP,
     1558         * 8111C and 8111CP.
     1559         */
     1560#ifndef __rtems__
     1561        if ((sc->rl_flags & RL_FLAG_DESCV2) == 0) {
     1562                ifp->if_hwassist |= CSUM_TSO;
     1563                ifp->if_capabilities |= IFCAP_TSO4;
     1564        }
     1565#endif
     1566 
     1567        /*
    14461568         * Call MI attach routine.
    14471569         */
     
    14511573        /* VLAN capability setup */
    14521574        ifp->if_capabilities |= IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING;
    1453 #ifdef IFCAP_VLAN_HWCSUM
    14541575        if (ifp->if_capabilities & IFCAP_HWCSUM)
    14551576                ifp->if_capabilities |= IFCAP_VLAN_HWCSUM;
    1456 #endif
     1577        /* Enable WOL if PM is supported. */
     1578        if (pci_find_extcap(sc->rl_dev, PCIY_PMG, &reg) == 0)
     1579                ifp->if_capabilities |= IFCAP_WOL;
    14571580        ifp->if_capenable = ifp->if_capabilities;
     1581        /*
     1582         * Don't enable TSO by default. Under certain
     1583         * circumtances the controller generated corrupted
     1584         * packets in TSO size.
     1585         */
     1586        ifp->if_hwassist &= ~CSUM_TSO;
     1587        ifp->if_capenable &= ~IFCAP_TSO4;
    14581588#ifdef DEVICE_POLLING
    14591589        ifp->if_capabilities |= IFCAP_POLLING;
     
    14661596        ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
    14671597#endif
    1468 
     1598 
    14691599#ifdef RE_DIAG
    14701600        /*
     
    14861616
    14871617        /* Hook interrupt last to avoid having to lock softc */
    1488 #ifndef __rtems__
    1489         error = bus_setup_intr(dev, sc->rl_irq, INTR_TYPE_NET | INTR_MPSAFE |
    1490             INTR_FAST, re_intr, sc, &sc->rl_intrhand);
    1491 #else
    1492         error = bus_setup_intr(dev, sc->rl_irq, INTR_TYPE_NET | INTR_MPSAFE,
    1493             re_intr, NULL, sc, &sc->rl_intrhand);
    1494 #endif
     1618        if ((sc->rl_flags & RL_FLAG_MSI) == 0)
     1619                error = bus_setup_intr(dev, sc->rl_irq[0],
     1620                    INTR_TYPE_NET | INTR_MPSAFE, re_intr, NULL, sc,
     1621                    &sc->rl_intrhand[0]);
     1622        else {
     1623                for (i = 0; i < RL_MSI_MESSAGES; i++) {
     1624                        error = bus_setup_intr(dev, sc->rl_irq[i],
     1625                            INTR_TYPE_NET | INTR_MPSAFE, re_intr, NULL, sc,
     1626                            &sc->rl_intrhand[i]);
     1627                        if (error != 0)
     1628                                break;
     1629                }
     1630        }
    14951631        if (error) {
    14961632                device_printf(dev, "couldn't set up irq\n");
     
    15141650 */
    15151651static int
    1516 re_detach(dev)
    1517         device_t                dev;
     1652re_detach(device_t dev)
    15181653{
    15191654        struct rl_softc         *sc;
    15201655        struct ifnet            *ifp;
    1521         int                     i;
     1656        int                     i, rid;
    15221657
    15231658        sc = device_get_softc(dev);
     
    15251660        KASSERT(mtx_initialized(&sc->rl_mtx), ("re mutex not initialized"));
    15261661
    1527 #ifdef DEVICE_POLLING
    1528         if (ifp->if_capenable & IFCAP_POLLING)
    1529                 ether_poll_deregister(ifp);
    1530 #endif
    15311662        /* These should only be active if attach succeeded */
    15321663        if (device_is_attached(dev)) {
     1664#ifdef DEVICE_POLLING
     1665                if (ifp->if_capenable & IFCAP_POLLING)
     1666                        ether_poll_deregister(ifp);
     1667#endif
    15331668                RL_LOCK(sc);
    15341669#if 0
     
    15641699         */
    15651700
    1566         if (sc->rl_intrhand)
    1567                 bus_teardown_intr(dev, sc->rl_irq, sc->rl_intrhand);
     1701        for (i = 0; i < RL_MSI_MESSAGES; i++) {
     1702                if (sc->rl_intrhand[i] != NULL) {
     1703                        bus_teardown_intr(dev, sc->rl_irq[i],
     1704                            sc->rl_intrhand[i]);
     1705                        sc->rl_intrhand[i] = NULL;
     1706                }
     1707        }
    15681708        if (ifp != NULL)
    15691709                if_free(ifp);
    1570         if (sc->rl_irq)
    1571                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->rl_irq);
     1710        if ((sc->rl_flags & RL_FLAG_MSI) == 0) {
     1711                if (sc->rl_irq[0] != NULL) {
     1712                        bus_release_resource(dev, SYS_RES_IRQ, 0,
     1713                            sc->rl_irq[0]);
     1714                        sc->rl_irq[0] = NULL;
     1715                }
     1716        } else {
     1717                for (i = 0, rid = 1; i < RL_MSI_MESSAGES; i++, rid++) {
     1718                        if (sc->rl_irq[i] != NULL) {
     1719                                bus_release_resource(dev, SYS_RES_IRQ, rid,
     1720                                    sc->rl_irq[i]);
     1721                                sc->rl_irq[i] = NULL;
     1722                        }
     1723                }
     1724                pci_release_msi(dev);
     1725        }
    15721726        if (sc->rl_res)
    1573                 bus_release_resource(dev, RL_RES, RL_RID, sc->rl_res);
     1727                bus_release_resource(dev, sc->rl_res_type, sc->rl_res_id,
     1728                    sc->rl_res);
    15741729
    15751730        /* Unload and free the RX DMA ring memory and map */
     
    15971752        /* Destroy all the RX and TX buffer maps */
    15981753
    1599         if (sc->rl_ldata.rl_mtag) {
    1600                 for (i = 0; i < RL_TX_DESC_CNT; i++)
    1601                         bus_dmamap_destroy(sc->rl_ldata.rl_mtag,
    1602                             sc->rl_ldata.rl_tx_dmamap[i]);
    1603                 for (i = 0; i < RL_RX_DESC_CNT; i++)
    1604                         bus_dmamap_destroy(sc->rl_ldata.rl_mtag,
    1605                             sc->rl_ldata.rl_rx_dmamap[i]);
    1606                 bus_dma_tag_destroy(sc->rl_ldata.rl_mtag);
     1754        if (sc->rl_ldata.rl_tx_mtag) {
     1755                for (i = 0; i < sc->rl_ldata.rl_tx_desc_cnt; i++)
     1756                        bus_dmamap_destroy(sc->rl_ldata.rl_tx_mtag,
     1757                            sc->rl_ldata.rl_tx_desc[i].tx_dmamap);
     1758                bus_dma_tag_destroy(sc->rl_ldata.rl_tx_mtag);
     1759        }
     1760        if (sc->rl_ldata.rl_rx_mtag) {
     1761                for (i = 0; i < sc->rl_ldata.rl_rx_desc_cnt; i++)
     1762                        bus_dmamap_destroy(sc->rl_ldata.rl_rx_mtag,
     1763                            sc->rl_ldata.rl_rx_desc[i].rx_dmamap);
     1764                if (sc->rl_ldata.rl_rx_sparemap)
     1765                        bus_dmamap_destroy(sc->rl_ldata.rl_rx_mtag,
     1766                            sc->rl_ldata.rl_rx_sparemap);
     1767                bus_dma_tag_destroy(sc->rl_ldata.rl_rx_mtag);
    16071768        }
    16081769
     
    16261787}
    16271788
     1789static __inline void
     1790re_discard_rxbuf(struct rl_softc *sc, int idx)
     1791{
     1792        struct rl_desc          *desc;
     1793        struct rl_rxdesc        *rxd;
     1794        uint32_t                cmdstat;
     1795
     1796        rxd = &sc->rl_ldata.rl_rx_desc[idx];
     1797        desc = &sc->rl_ldata.rl_rx_list[idx];
     1798        desc->rl_vlanctl = 0;
     1799        cmdstat = rxd->rx_size;
     1800        if (idx == sc->rl_ldata.rl_rx_desc_cnt - 1)
     1801                cmdstat |= RL_RDESC_CMD_EOR;
     1802        desc->rl_cmdstat = htole32(cmdstat | RL_RDESC_CMD_OWN);
     1803}
     1804
    16281805static int
    1629 re_newbuf(sc, idx, m)
    1630         struct rl_softc         *sc;
    1631         int                     idx;
     1806re_newbuf(struct rl_softc *sc, int idx)
     1807{
    16321808        struct mbuf             *m;
    1633 {
    1634         struct rl_dmaload_arg   arg;
    1635         struct mbuf             *n = NULL;
    1636         int                     error;
    1637 
    1638         if (m == NULL) {
    1639                 n = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
    1640                 if (n == NULL)
    1641                         return (ENOBUFS);
    1642                 m = n;
    1643         } else
    1644                 m->m_data = m->m_ext.ext_buf;
     1809        struct rl_rxdesc        *rxd;
     1810        bus_dma_segment_t       segs[1];
     1811        bus_dmamap_t            map;
     1812        struct rl_desc          *desc;
     1813        uint32_t                cmdstat;
     1814        int                     error, nsegs;
     1815
     1816        m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
     1817        if (m == NULL)
     1818                return (ENOBUFS);
    16451819
    16461820        m->m_len = m->m_pkthdr.len = MCLBYTES;
     
    16581832        m_adj(m, RE_ETHER_ALIGN);
    16591833#endif
    1660         arg.rl_idx = idx;
    1661         arg.rl_maxsegs = 1;
    1662         arg.rl_flags = 0;
    1663         arg.rl_ring = sc->rl_ldata.rl_rx_list;
    1664 
    1665         error = bus_dmamap_load_mbuf(sc->rl_ldata.rl_mtag,
    1666             sc->rl_ldata.rl_rx_dmamap[idx], m, re_dma_map_desc,
    1667             &arg, BUS_DMA_NOWAIT);
    1668         if (error || arg.rl_maxsegs != 1) {
    1669                 if (n != NULL)
    1670                         m_freem(n);
    1671                 if (arg.rl_maxsegs == 0)
    1672                         bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    1673                             sc->rl_ldata.rl_rx_dmamap[idx]);
    1674                 return (ENOMEM);
    1675         }
    1676 
    1677         sc->rl_ldata.rl_rx_list[idx].rl_cmdstat |= htole32(RL_RDESC_CMD_OWN);
    1678         sc->rl_ldata.rl_rx_mbuf[idx] = m;
    1679 
    1680         bus_dmamap_sync(sc->rl_ldata.rl_mtag,
    1681             sc->rl_ldata.rl_rx_dmamap[idx],
     1834        error = bus_dmamap_load_mbuf_sg(sc->rl_ldata.rl_rx_mtag,
     1835            sc->rl_ldata.rl_rx_sparemap, m, segs, &nsegs, BUS_DMA_NOWAIT);
     1836        if (error != 0) {
     1837                m_freem(m);
     1838                return (ENOBUFS);
     1839        }
     1840        KASSERT(nsegs == 1, ("%s: %d segment returned!", __func__, nsegs));
     1841
     1842        rxd = &sc->rl_ldata.rl_rx_desc[idx];
     1843        if (rxd->rx_m != NULL) {
     1844                bus_dmamap_sync(sc->rl_ldata.rl_rx_mtag, rxd->rx_dmamap,
     1845                    BUS_DMASYNC_POSTREAD);
     1846                bus_dmamap_unload(sc->rl_ldata.rl_rx_mtag, rxd->rx_dmamap);
     1847        }
     1848
     1849        rxd->rx_m = m;
     1850        map = rxd->rx_dmamap;
     1851        rxd->rx_dmamap = sc->rl_ldata.rl_rx_sparemap;
     1852        rxd->rx_size = segs[0].ds_len;
     1853        sc->rl_ldata.rl_rx_sparemap = map;
     1854        bus_dmamap_sync(sc->rl_ldata.rl_rx_mtag, rxd->rx_dmamap,
    16821855            BUS_DMASYNC_PREREAD);
     1856
     1857        desc = &sc->rl_ldata.rl_rx_list[idx];
     1858        desc->rl_vlanctl = 0;
     1859        desc->rl_bufaddr_lo = htole32(RL_ADDR_LO(segs[0].ds_addr));
     1860        desc->rl_bufaddr_hi = htole32(RL_ADDR_HI(segs[0].ds_addr));
     1861        cmdstat = segs[0].ds_len;
     1862        if (idx == sc->rl_ldata.rl_rx_desc_cnt - 1)
     1863                cmdstat |= RL_RDESC_CMD_EOR;
     1864        desc->rl_cmdstat = htole32(cmdstat | RL_RDESC_CMD_OWN);
    16831865
    16841866        return (0);
     
    16871869#ifdef RE_FIXUP_RX
    16881870static __inline void
    1689 re_fixup_rx(m)
    1690         struct mbuf             *m;
     1871re_fixup_rx(struct mbuf *m)
    16911872{
    16921873        int                     i;
     
    17001881
    17011882        m->m_data -= RE_ETHER_ALIGN - ETHER_ALIGN;
    1702 
    1703         return;
    17041883}
    17051884#endif
    17061885
    17071886static int
    1708 re_tx_list_init(sc)
    1709         struct rl_softc         *sc;
    1710 {
     1887re_tx_list_init(struct rl_softc *sc)
     1888{
     1889        struct rl_desc          *desc;
     1890        int                     i;
    17111891
    17121892        RL_LOCK_ASSERT(sc);
    17131893
    1714         bzero ((char *)sc->rl_ldata.rl_tx_list, RL_TX_LIST_SZ);
    1715         bzero ((char *)&sc->rl_ldata.rl_tx_mbuf,
    1716             (RL_TX_DESC_CNT * sizeof(struct mbuf *)));
     1894        bzero(sc->rl_ldata.rl_tx_list,
     1895            sc->rl_ldata.rl_tx_desc_cnt * sizeof(struct rl_desc));
     1896        for (i = 0; i < sc->rl_ldata.rl_tx_desc_cnt; i++)
     1897                sc->rl_ldata.rl_tx_desc[i].tx_m = NULL;
     1898        /* Set EOR. */
     1899        desc = &sc->rl_ldata.rl_tx_list[sc->rl_ldata.rl_tx_desc_cnt - 1];
     1900        desc->rl_cmdstat |= htole32(RL_TDESC_CMD_EOR);
    17171901
    17181902        bus_dmamap_sync(sc->rl_ldata.rl_tx_list_tag,
    1719             sc->rl_ldata.rl_tx_list_map, BUS_DMASYNC_PREWRITE);
     1903            sc->rl_ldata.rl_tx_list_map,
     1904            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
     1905
    17201906        sc->rl_ldata.rl_tx_prodidx = 0;
    17211907        sc->rl_ldata.rl_tx_considx = 0;
    1722         sc->rl_ldata.rl_tx_free = RL_TX_DESC_CNT;
     1908        sc->rl_ldata.rl_tx_free = sc->rl_ldata.rl_tx_desc_cnt;
    17231909
    17241910        return (0);
     
    17261912
    17271913static int
    1728 re_rx_list_init(sc)
    1729         struct rl_softc         *sc;
    1730 {
    1731         int                     i;
    1732 
    1733         bzero ((char *)sc->rl_ldata.rl_rx_list, RL_RX_LIST_SZ);
    1734         bzero ((char *)&sc->rl_ldata.rl_rx_mbuf,
    1735             (RL_RX_DESC_CNT * sizeof(struct mbuf *)));
    1736 
    1737         for (i = 0; i < RL_RX_DESC_CNT; i++) {
    1738                 if (re_newbuf(sc, i, NULL) == ENOBUFS)
    1739                         return (ENOBUFS);
     1914re_rx_list_init(struct rl_softc *sc)
     1915{
     1916        int                     error, i;
     1917
     1918        bzero(sc->rl_ldata.rl_rx_list,
     1919            sc->rl_ldata.rl_rx_desc_cnt * sizeof(struct rl_desc));
     1920        for (i = 0; i < sc->rl_ldata.rl_rx_desc_cnt; i++) {
     1921                sc->rl_ldata.rl_rx_desc[i].rx_m = NULL;
     1922                if ((error = re_newbuf(sc, i)) != 0)
     1923                        return (error);
    17401924        }
    17411925
     
    17581942 */
    17591943static int
    1760 re_rxeof(sc)
    1761         struct rl_softc         *sc;
     1944re_rxeof(struct rl_softc *sc, int *rx_npktsp)
    17621945{
    17631946        struct mbuf             *m;
     
    17661949        struct rl_desc          *cur_rx;
    17671950        u_int32_t               rxstat, rxvlan;
    1768         int                     maxpkt = 16;
     1951        int                     maxpkt = 16, rx_npkts = 0;
    17691952
    17701953        RL_LOCK_ASSERT(sc);
    17711954
    17721955        ifp = sc->rl_ifp;
    1773         i = sc->rl_ldata.rl_rx_prodidx;
    17741956
    17751957        /* Invalidate the descriptor memory */
     
    17771959        bus_dmamap_sync(sc->rl_ldata.rl_rx_list_tag,
    17781960            sc->rl_ldata.rl_rx_list_map,
    1779             BUS_DMASYNC_POSTREAD);
    1780 
    1781         while (!RL_OWN(&sc->rl_ldata.rl_rx_list[i]) && maxpkt) {
     1961            BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
     1962
     1963        for (i = sc->rl_ldata.rl_rx_prodidx; maxpkt > 0;
     1964            i = RL_RX_DESC_NXT(sc, i)) {
    17821965                cur_rx = &sc->rl_ldata.rl_rx_list[i];
    1783                 m = sc->rl_ldata.rl_rx_mbuf[i];
    1784                 total_len = RL_RXBYTES(cur_rx);
    17851966                rxstat = le32toh(cur_rx->rl_cmdstat);
     1967                if ((rxstat & RL_RDESC_STAT_OWN) != 0)
     1968                        break;
     1969                total_len = rxstat & sc->rl_rxlenmask;
    17861970                rxvlan = le32toh(cur_rx->rl_vlanctl);
    1787 
    1788                 /* Invalidate the RX mbuf and unload its map */
    1789 
    1790                 bus_dmamap_sync(sc->rl_ldata.rl_mtag,
    1791                     sc->rl_ldata.rl_rx_dmamap[i],
    1792                     BUS_DMASYNC_POSTWRITE);
    1793                 bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    1794                     sc->rl_ldata.rl_rx_dmamap[i]);
     1971                m = sc->rl_ldata.rl_rx_desc[i].rx_m;
    17951972
    17961973                if (!(rxstat & RL_RDESC_STAT_EOF)) {
     1974                        if (re_newbuf(sc, i) != 0) {
     1975                                /*
     1976                                 * If this is part of a multi-fragment packet,
     1977                                 * discard all the pieces.
     1978                                 */
     1979                                if (sc->rl_head != NULL) {
     1980                                        m_freem(sc->rl_head);
     1981                                        sc->rl_head = sc->rl_tail = NULL;
     1982                                }
     1983                                re_discard_rxbuf(sc, i);
     1984                                continue;
     1985                        }
    17971986                        m->m_len = RE_RX_DESC_BUFLEN;
    17981987                        if (sc->rl_head == NULL)
     
    18031992                                sc->rl_tail = m;
    18041993                        }
    1805                         re_newbuf(sc, i, NULL);
    1806                         RL_DESC_INC(i);
    18071994                        continue;
    18081995                }
     
    18422029                                sc->rl_head = sc->rl_tail = NULL;
    18432030                        }
    1844                         re_newbuf(sc, i, m);
    1845                         RL_DESC_INC(i);
     2031                        re_discard_rxbuf(sc, i);
    18462032                        continue;
    18472033                }
     
    18522038                 */
    18532039
    1854                 if (re_newbuf(sc, i, NULL)) {
    1855                         ifp->if_ierrors++;
     2040                if (re_newbuf(sc, i) != 0) {
     2041                        ifp->if_iqdrops++;
    18562042                        if (sc->rl_head != NULL) {
    18572043                                m_freem(sc->rl_head);
    18582044                                sc->rl_head = sc->rl_tail = NULL;
    18592045                        }
    1860                         re_newbuf(sc, i, m);
    1861                         RL_DESC_INC(i);
     2046                        re_discard_rxbuf(sc, i);
    18622047                        continue;
    18632048                }
    1864 
    1865                 RL_DESC_INC(i);
    18662049
    18672050                if (sc->rl_head != NULL) {
     
    19012084#ifndef __rtems__
    19022085                if (ifp->if_capenable & IFCAP_RXCSUM) {
    1903 
    1904                         /* Check IP header checksum */
    1905                         if (rxstat & RL_RDESC_STAT_PROTOID)
    1906                                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
    1907                         if (!(rxstat & RL_RDESC_STAT_IPSUMBAD))
    1908                                 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
    1909 
    1910                         /* Check TCP/UDP checksum */
    1911                         if ((RL_TCPPKT(rxstat) &&
    1912                             !(rxstat & RL_RDESC_STAT_TCPSUMBAD)) ||
    1913                             (RL_UDPPKT(rxstat) &&
    1914                             !(rxstat & RL_RDESC_STAT_UDPSUMBAD))) {
    1915                                 m->m_pkthdr.csum_flags |=
    1916                                     CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
    1917                                 m->m_pkthdr.csum_data = 0xffff;
     2086                        if ((sc->rl_flags & RL_FLAG_DESCV2) == 0) {
     2087                                /* Check IP header checksum */
     2088                                if (rxstat & RL_RDESC_STAT_PROTOID)
     2089                                        m->m_pkthdr.csum_flags |=
     2090                                            CSUM_IP_CHECKED;
     2091                                if (!(rxstat & RL_RDESC_STAT_IPSUMBAD))
     2092                                        m->m_pkthdr.csum_flags |=
     2093                                            CSUM_IP_VALID;
     2094
     2095                                /* Check TCP/UDP checksum */
     2096                                if ((RL_TCPPKT(rxstat) &&
     2097                                    !(rxstat & RL_RDESC_STAT_TCPSUMBAD)) ||
     2098                                    (RL_UDPPKT(rxstat) &&
     2099                                     !(rxstat & RL_RDESC_STAT_UDPSUMBAD))) {
     2100                                        m->m_pkthdr.csum_flags |=
     2101                                                CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
     2102                                        m->m_pkthdr.csum_data = 0xffff;
     2103                                }
     2104                        } else {
     2105                                /*
     2106                                 * RTL8168C/RTL816CP/RTL8111C/RTL8111CP
     2107                                 */
     2108                                if ((rxstat & RL_RDESC_STAT_PROTOID) &&
     2109                                    (rxvlan & RL_RDESC_IPV4))
     2110                                        m->m_pkthdr.csum_flags |=
     2111                                            CSUM_IP_CHECKED;
     2112                                if (!(rxstat & RL_RDESC_STAT_IPSUMBAD) &&
     2113                                    (rxvlan & RL_RDESC_IPV4))
     2114                                        m->m_pkthdr.csum_flags |=
     2115                                            CSUM_IP_VALID;
     2116                                if (((rxstat & RL_RDESC_STAT_TCP) &&
     2117                                    !(rxstat & RL_RDESC_STAT_TCPSUMBAD)) ||
     2118                                    ((rxstat & RL_RDESC_STAT_UDP) &&
     2119                                    !(rxstat & RL_RDESC_STAT_UDPSUMBAD))) {
     2120                                        m->m_pkthdr.csum_flags |=
     2121                                                CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
     2122                                        m->m_pkthdr.csum_data = 0xffff;
     2123                                }
    19182124                        }
    19192125                }
     
    19222128#ifndef __rtems__
    19232129                if (rxvlan & RL_RDESC_VLANCTL_TAG) {
    1924                         VLAN_INPUT_TAG_NEW(ifp, m,
    1925                             ntohs((rxvlan & RL_RDESC_VLANCTL_DATA)));
    1926                         if (m == NULL)
    1927                                 continue;
     2130                        m->m_pkthdr.ether_vtag =
     2131                            bswap16((rxvlan & RL_RDESC_VLANCTL_DATA));
     2132                        m->m_flags |= M_VLANTAG;
    19282133                }
    19292134#endif
     
    19352140#endif
    19362141                RL_LOCK(sc);
     2142                rx_npkts++;
    19372143        }
    19382144
     
    19452151        sc->rl_ldata.rl_rx_prodidx = i;
    19462152
     2153        if (rx_npktsp != NULL)
     2154                *rx_npktsp = rx_npkts;
    19472155        if (maxpkt)
    19482156                return(EAGAIN);
     
    19522160
    19532161static void
    1954 re_txeof(sc)
    1955         struct rl_softc         *sc;
     2162re_txeof(struct rl_softc *sc)
    19562163{
    19572164        struct ifnet            *ifp;
     2165        struct rl_txdesc        *txd;
    19582166        u_int32_t               txstat;
    1959         int                     idx;
     2167        int                     cons;
     2168
     2169        cons = sc->rl_ldata.rl_tx_considx;
     2170        if (cons == sc->rl_ldata.rl_tx_prodidx)
     2171                return;
    19602172
    19612173        ifp = sc->rl_ifp;
    1962         idx = sc->rl_ldata.rl_tx_considx;
    1963 
    19642174        /* Invalidate the TX descriptor list */
    19652175        bus_dmamap_sync(sc->rl_ldata.rl_tx_list_tag,
    19662176            sc->rl_ldata.rl_tx_list_map,
    1967             BUS_DMASYNC_POSTREAD);
    1968 
    1969         while (sc->rl_ldata.rl_tx_free < RL_TX_DESC_CNT) {
    1970                 txstat = le32toh(sc->rl_ldata.rl_tx_list[idx].rl_cmdstat);
    1971                 if (txstat & RL_TDESC_CMD_OWN)
     2177            BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
     2178
     2179        for (; cons != sc->rl_ldata.rl_tx_prodidx;
     2180            cons = RL_TX_DESC_NXT(sc, cons)) {
     2181                txstat = le32toh(sc->rl_ldata.rl_tx_list[cons].rl_cmdstat);
     2182                if (txstat & RL_TDESC_STAT_OWN)
    19722183                        break;
    1973 
    1974                 sc->rl_ldata.rl_tx_list[idx].rl_bufaddr_lo = 0;
    1975 
    19762184                /*
    19772185                 * We only stash mbufs in the last descriptor
     
    19812189                 */
    19822190                if (txstat & RL_TDESC_CMD_EOF) {
    1983                         m_freem(sc->rl_ldata.rl_tx_mbuf[idx]);
    1984                         sc->rl_ldata.rl_tx_mbuf[idx] = NULL;
    1985                         bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    1986                             sc->rl_ldata.rl_tx_dmamap[idx]);
     2191                        txd = &sc->rl_ldata.rl_tx_desc[cons];
     2192                        bus_dmamap_sync(sc->rl_ldata.rl_tx_mtag,
     2193                            txd->tx_dmamap, BUS_DMASYNC_POSTWRITE);
     2194                        bus_dmamap_unload(sc->rl_ldata.rl_tx_mtag,
     2195                            txd->tx_dmamap);
     2196                        KASSERT(txd->tx_m != NULL,
     2197                            ("%s: freeing NULL mbufs!", __func__));
     2198                        m_freem(txd->tx_m);
     2199                        txd->tx_m = NULL;
    19872200                        if (txstat & (RL_TDESC_STAT_EXCESSCOL|
    19882201                            RL_TDESC_STAT_COLCNT))
     
    19942207                }
    19952208                sc->rl_ldata.rl_tx_free++;
    1996                 RL_DESC_INC(idx);
    1997         }
    1998         sc->rl_ldata.rl_tx_considx = idx;
     2209                ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
     2210        }
     2211        sc->rl_ldata.rl_tx_considx = cons;
    19992212
    20002213        /* No changes made to the TX ring, so no flush needed */
    20012214
    2002         if (sc->rl_ldata.rl_tx_free > RL_TX_DESC_THLD)
    2003                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
    2004 
    2005         if (sc->rl_ldata.rl_tx_free < RL_TX_DESC_CNT) {
    2006                 /*
    2007                  * Some chips will ignore a second TX request issued
    2008                  * while an existing transmission is in progress. If
    2009                  * the transmitter goes idle but there are still
    2010                  * packets waiting to be sent, we need to restart the
    2011                  * channel here to flush them out. This only seems to
    2012                  * be required with the PCIe devices.
    2013                  */
    2014                 CSR_WRITE_1(sc, sc->rl_txstart, RL_TXSTART_START);
    2015 
     2215        if (sc->rl_ldata.rl_tx_free != sc->rl_ldata.rl_tx_desc_cnt) {
    20162216#ifdef RE_TX_MODERATION
    20172217                /*
     
    20282228
    20292229static void
    2030 re_tick(xsc)
    2031         void                    *xsc;
     2230re_tick(void *xsc)
    20322231{
    20332232        struct rl_softc         *sc;
    20342233        struct mii_data         *mii;
    2035         struct ifnet            *ifp;
    20362234
    20372235        sc = xsc;
    2038         ifp = sc->rl_ifp;
    20392236
    20402237        RL_LOCK_ASSERT(sc);
    20412238
    2042         re_watchdog(sc);
    2043 
    20442239        mii = device_get_softc(sc->rl_miibus);
    20452240#ifndef __rtems__
    20462241        mii_tick(mii);
    2047         if (sc->rl_link) {
    2048                 if (!(mii->mii_media_status & IFM_ACTIVE))
    2049                         sc->rl_link = 0;
    2050         } else {
    2051                 if (mii->mii_media_status & IFM_ACTIVE &&
    2052                     IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
    2053                         sc->rl_link = 1;
    2054                         if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
    2055                                 taskqueue_enqueue_fast(taskqueue_fast,
    2056                                     &sc->rl_txtask);
    2057                 }
    2058         }
     2242        if ((sc->rl_flags & RL_FLAG_LINK) == 0)
     2243                re_miibus_statchg(sc->rl_dev);
    20592244#else
    20602245        {
     2246        struct ifnet *ifp;
    20612247        int med, err;
    20622248
     2249  ifp = sc->rl_ifp;
     2250 
    20632251        med = IFM_MAKEWORD(0,0,0,0);
    20642252
     
    20692257
    20702258        /* link just died */
    2071         if ( sc->rl_link & !(IFM_LINK_OK & med) ) {
    2072                 sc->rl_link = 0;
     2259        if ( (sc->rl_flags & RL_FLAG_LINK) & !(IFM_LINK_OK & med) ) {
     2260                sc->rl_flags &= ~RL_FLAG_LINK;
    20732261        }
    20742262
    20752263        /* link just came up, restart */
    2076         if ( !sc->rl_link && (IFM_LINK_OK & med) ) {
    2077                 sc->rl_link = 1;
     2264        if ( ((sc->rl_flags & RL_FLAG_LINK) == 0) && (IFM_LINK_OK & med) ) {
     2265                sc->rl_flags |= RL_FLAG_LINK;
    20782266                if ( ifp->if_snd.ifq_head != NULL ) {
    20792267                        taskqueue_enqueue_fast(taskqueue_fast,
     
    20832271        }
    20842272#endif
     2273        /*
     2274         * Reclaim transmitted frames here. Technically it is not
     2275         * necessary to do here but it ensures periodic reclamation
     2276         * regardless of Tx completion interrupt which seems to be
     2277         * lost on PCIe based controllers under certain situations.
     2278         */
     2279        re_txeof(sc);
     2280        re_watchdog(sc);
    20852281        callout_reset(&sc->rl_stat_callout, hz, re_tick, sc);
    20862282}
    20872283
    20882284#ifdef DEVICE_POLLING
    2089 static void
     2285static int
    20902286re_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
    20912287{
    20922288        struct rl_softc *sc = ifp->if_softc;
     2289        int rx_npkts = 0;
    20932290
    20942291        RL_LOCK(sc);
    20952292        if (ifp->if_drv_flags & IFF_DRV_RUNNING)
    2096                 re_poll_locked(ifp, cmd, count);
     2293                rx_npkts = re_poll_locked(ifp, cmd, count);
    20972294        RL_UNLOCK(sc);
    2098 }
    2099 
    2100 static void
     2295        return (rx_npkts);
     2296}
     2297
     2298static int
    21012299re_poll_locked(struct ifnet *ifp, enum poll_cmd cmd, int count)
    21022300{
    21032301        struct rl_softc *sc = ifp->if_softc;
     2302        int rx_npkts;
    21042303
    21052304        RL_LOCK_ASSERT(sc);
    21062305
    21072306        sc->rxcycles = count;
    2108         re_rxeof(sc);
     2307        re_rxeof(sc, &rx_npkts);
    21092308        re_txeof(sc);
    21102309
     
    21172316                status = CSR_READ_2(sc, RL_ISR);
    21182317                if (status == 0xffff)
    2119                         return;
     2318                        return (rx_npkts);
    21202319                if (status)
    21212320                        CSR_WRITE_2(sc, RL_ISR, status);
     2321                if ((status & (RL_ISR_TX_OK | RL_ISR_TX_DESC_UNAVAIL)) &&
     2322                    (sc->rl_flags & RL_FLAG_PCIE))
     2323                        CSR_WRITE_1(sc, sc->rl_txstart, RL_TXSTART_START);
    21222324
    21232325                /*
     
    21252327                 */
    21262328
    2127                 if (status & RL_ISR_SYSTEM_ERR) {
    2128                         re_reset(sc);
     2329                if (status & RL_ISR_SYSTEM_ERR)
    21292330                        re_init_locked(sc);
    2130                 }
    2131         }
     2331        }
     2332        return (rx_npkts);
    21322333}
    21332334#endif /* DEVICE_POLLING */
    21342335
    2135 #ifdef __rtems__
    21362336static int
    2137 #else
    2138 static void
    2139 #endif
    2140 re_intr(arg)
    2141         void                    *arg;
     2337re_intr(void *arg)
    21422338{
    21432339        struct rl_softc         *sc;
     
    21482344        status = CSR_READ_2(sc, RL_ISR);
    21492345        if (status == 0xFFFF || (status & RL_INTRS_CPLUS) == 0)
    2150 #ifdef __rtems__
    2151                                 return FILTER_STRAY;
    2152 #else
    2153                 return;
    2154 #endif
     2346                return (FILTER_STRAY);
    21552347        CSR_WRITE_2(sc, RL_IMR, 0);
    21562348
    21572349        taskqueue_enqueue_fast(taskqueue_fast, &sc->rl_inttask);
    21582350
    2159 #ifdef __rtems__
    2160         return FILTER_HANDLED;
    2161 #else
    2162         return;
    2163 #endif
     2351        return (FILTER_HANDLED);
    21642352}
    21652353
    21662354static void
    2167 re_int_task(arg, npending)
    2168         void                    *arg;
    2169         int                     npending;
     2355re_int_task(void *arg, int npending)
    21702356{
    21712357        struct rl_softc         *sc;
     
    21772363        ifp = sc->rl_ifp;
    21782364
    2179         NET_LOCK_GIANT();
    21802365        RL_LOCK(sc);
    21812366
     
    21832368        CSR_WRITE_2(sc, RL_ISR, status);
    21842369
    2185         if (sc->suspended || !(ifp->if_flags & IFF_UP)) {
     2370        if (sc->suspended ||
     2371            (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
    21862372                RL_UNLOCK(sc);
    2187                 NET_UNLOCK_GIANT();
    21882373                return;
    21892374        }
     
    21922377        if  (ifp->if_capenable & IFCAP_POLLING) {
    21932378                RL_UNLOCK(sc);
    2194                 NET_UNLOCK_GIANT();
    21952379                return;
    21962380        }
     
    21982382
    21992383        if (status & (RL_ISR_RX_OK|RL_ISR_RX_ERR|RL_ISR_FIFO_OFLOW))
    2200                 rval = re_rxeof(sc);
    2201 
     2384                rval = re_rxeof(sc, NULL);
     2385
     2386        /*
     2387         * Some chips will ignore a second TX request issued
     2388         * while an existing transmission is in progress. If
     2389         * the transmitter goes idle but there are still
     2390         * packets waiting to be sent, we need to restart the
     2391         * channel here to flush them out. This only seems to
     2392         * be required with the PCIe devices.
     2393         */
     2394        if ((status & (RL_ISR_TX_OK | RL_ISR_TX_DESC_UNAVAIL)) &&
     2395            (sc->rl_flags & RL_FLAG_PCIE))
     2396                CSR_WRITE_1(sc, sc->rl_txstart, RL_TXSTART_START);
     2397        if (status & (
    22022398#ifdef RE_TX_MODERATION
    2203         if (status & (RL_ISR_TIMEOUT_EXPIRED|
     2399            RL_ISR_TIMEOUT_EXPIRED|
    22042400#else
    2205         if (status & (RL_ISR_TX_OK|
     2401            RL_ISR_TX_OK|
    22062402#endif
    22072403            RL_ISR_TX_ERR|RL_ISR_TX_DESC_UNAVAIL))
    22082404                re_txeof(sc);
    22092405
    2210         if (status & RL_ISR_SYSTEM_ERR) {
    2211                 re_reset(sc);
     2406        if (status & RL_ISR_SYSTEM_ERR)
    22122407                re_init_locked(sc);
    2213         }
    2214 
    2215         if (status & RL_ISR_LINKCHG) {
    2216                 callout_stop(&sc->rl_stat_callout);
    2217                 re_tick(sc);
    2218         }
    22192408
    22202409        if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
     
    22222411
    22232412        RL_UNLOCK(sc);
    2224         NET_UNLOCK_GIANT();
    22252413
    22262414        if ((CSR_READ_2(sc, RL_ISR) & RL_INTRS_CPLUS) || rval) {
     
    22302418
    22312419        CSR_WRITE_2(sc, RL_IMR, RL_INTRS_CPLUS);
    2232 
    2233         return;
    22342420}
    22352421
    22362422static int
    2237 re_encap(sc, m_head, idx)
    2238         struct rl_softc         *sc;
    2239         struct mbuf             **m_head;
    2240         int                     *idx;
    2241 {
    2242         struct mbuf             *m_new = NULL;
    2243         struct rl_dmaload_arg   arg;
     2423re_encap(struct rl_softc *sc, struct mbuf **m_head)
     2424{
     2425        struct rl_txdesc        *txd, *txd_last;
     2426        bus_dma_segment_t       segs[RL_NTXSEGS];
    22442427        bus_dmamap_t            map;
    2245         int                     error;
    2246 #ifndef __rtems__
    2247         struct m_tag            *mtag;
    2248 #endif
    2249 
     2428        struct mbuf             *m_new;
     2429        struct rl_desc          *desc;
     2430        int                     nsegs, prod;
     2431        int                     i, error, ei, si;
     2432#ifndef __rtems__
     2433        int                     padlen;
     2434#endif
     2435        uint32_t                cmdstat, csum_flags, vlanctl;
     2436 
    22502437        RL_LOCK_ASSERT(sc);
    2251 
    2252         if (sc->rl_ldata.rl_tx_free <= RL_TX_DESC_THLD)
    2253                 return (EFBIG);
    2254 
    2255         /*
    2256          * Set up checksum offload. Note: checksum offload bits must
    2257          * appear in all descriptors of a multi-descriptor transmit
    2258          * attempt. This is according to testing done with an 8169
    2259          * chip. This is a requirement.
    2260          */
    2261 
    2262         arg.rl_flags = 0;
    2263 
    2264 #ifndef __rtems__
    2265         if ((*m_head)->m_pkthdr.csum_flags & CSUM_IP)
    2266                 arg.rl_flags |= RL_TDESC_CMD_IPCSUM;
    2267         if ((*m_head)->m_pkthdr.csum_flags & CSUM_TCP)
    2268                 arg.rl_flags |= RL_TDESC_CMD_TCPCSUM;
    2269         if ((*m_head)->m_pkthdr.csum_flags & CSUM_UDP)
    2270                 arg.rl_flags |= RL_TDESC_CMD_UDPCSUM;
    2271 #endif
    2272 
    2273         arg.rl_idx = *idx;
    2274         arg.rl_maxsegs = sc->rl_ldata.rl_tx_free;
    2275         if (arg.rl_maxsegs > RL_TX_DESC_THLD)
    2276                 arg.rl_maxsegs -= RL_TX_DESC_THLD;
    2277         arg.rl_ring = sc->rl_ldata.rl_tx_list;
    2278 
    2279         map = sc->rl_ldata.rl_tx_dmamap[*idx];
     2438        M_ASSERTPKTHDR((*m_head));
    22802439
    22812440        /*
     
    22862445         * bytes in size, and IP header checksumming is enabled, the
    22872446         * resulting ethernet frame that appears on the wire will
    2288          * have garbled payload. To work around this, if TX checksum
     2447         * have garbled payload. To work around this, if TX IP checksum
    22892448         * offload is enabled, we always manually pad short frames out
    2290          * to the minimum ethernet frame size. We do this by pretending
    2291          * the mbuf chain has too many fragments so the coalescing code
    2292          * below can assemble the packet into a single buffer that's
    2293          * padded out to the mininum frame size.
    2294          *
    2295          * Note: this appears unnecessary for TCP, and doing it for TCP
    2296          * with PCIe adapters seems to result in bad checksums.
    2297          */
    2298 
    2299         if (arg.rl_flags && !(arg.rl_flags & RL_TDESC_CMD_TCPCSUM) &&
    2300             (*m_head)->m_pkthdr.len < RL_MIN_FRAMELEN)
    2301                 error = EFBIG;
    2302         else
    2303                 error = bus_dmamap_load_mbuf(sc->rl_ldata.rl_mtag, map,
    2304                     *m_head, re_dma_map_desc, &arg, BUS_DMA_NOWAIT);
    2305 
    2306         if (error && error != EFBIG) {
    2307                 device_printf(sc->rl_dev, "can't map mbuf (error %d)\n", error);
    2308                 return (ENOBUFS);
    2309         }
    2310 
    2311         /* Too many segments to map, coalesce into a single mbuf */
    2312 
    2313         if (error || arg.rl_maxsegs == 0) {
    2314                 if (arg.rl_maxsegs == 0)
    2315                         bus_dmamap_unload(sc->rl_ldata.rl_mtag, map);
    2316                 m_new = m_defrag(*m_head, M_DONTWAIT);
     2449         * to the minimum ethernet frame size.
     2450         */
     2451#ifndef __rtems__
     2452        if ((sc->rl_flags & RL_FLAG_AUTOPAD) == 0 &&
     2453            (*m_head)->m_pkthdr.len < RL_IP4CSUMTX_PADLEN &&
     2454            ((*m_head)->m_pkthdr.csum_flags & CSUM_IP) != 0) {
     2455                padlen = RL_MIN_FRAMELEN - (*m_head)->m_pkthdr.len;
     2456                if (M_WRITABLE(*m_head) == 0) {
     2457                        /* Get a writable copy. */
     2458                        m_new = m_dup(*m_head, M_DONTWAIT);
     2459                        m_freem(*m_head);
     2460                        if (m_new == NULL) {
     2461                                *m_head = NULL;
     2462                                return (ENOBUFS);
     2463                        }
     2464                        *m_head = m_new;
     2465                }
     2466                if ((*m_head)->m_next != NULL ||
     2467                    M_TRAILINGSPACE(*m_head) < padlen) {
     2468                        m_new = m_defrag(*m_head, M_DONTWAIT);
     2469                        if (m_new == NULL) {
     2470                                m_freem(*m_head);
     2471                                *m_head = NULL;
     2472                                return (ENOBUFS);
     2473                        }
     2474                } else
     2475                        m_new = *m_head;
     2476
     2477                /*
     2478                 * Manually pad short frames, and zero the pad space
     2479                 * to avoid leaking data.
     2480                 */
     2481                bzero(mtod(m_new, char *) + m_new->m_pkthdr.len, padlen);
     2482                m_new->m_pkthdr.len += padlen;
     2483                m_new->m_len = m_new->m_pkthdr.len;
     2484                *m_head = m_new;
     2485        }
     2486#endif
     2487 
     2488        prod = sc->rl_ldata.rl_tx_prodidx;
     2489        txd = &sc->rl_ldata.rl_tx_desc[prod];
     2490        error = bus_dmamap_load_mbuf_sg(sc->rl_ldata.rl_tx_mtag, txd->tx_dmamap,
     2491            *m_head, segs, &nsegs, BUS_DMA_NOWAIT);
     2492        if (error == EFBIG) {
     2493#ifndef __rtems__
     2494                m_new = m_collapse(*m_head, M_DONTWAIT, RL_NTXSEGS);
     2495#else
     2496    m_new = m_defrag(*m_head, M_DONTWAIT);
     2497#endif
    23172498                if (m_new == NULL) {
    23182499                        m_freem(*m_head);
     
    23212502                }
    23222503                *m_head = m_new;
    2323 
     2504                error = bus_dmamap_load_mbuf_sg(sc->rl_ldata.rl_tx_mtag,
     2505                    txd->tx_dmamap, *m_head, segs, &nsegs, BUS_DMA_NOWAIT);
     2506                if (error != 0) {
     2507                        m_freem(*m_head);
     2508                        *m_head = NULL;
     2509                        return (error);
     2510                }
     2511        } else if (error != 0)
     2512                return (error);
     2513        if (nsegs == 0) {
     2514                m_freem(*m_head);
     2515                *m_head = NULL;
     2516                return (EIO);
     2517        }
     2518
     2519        /* Check for number of available descriptors. */
     2520        if (sc->rl_ldata.rl_tx_free - nsegs <= 1) {
     2521                bus_dmamap_unload(sc->rl_ldata.rl_tx_mtag, txd->tx_dmamap);
     2522                return (ENOBUFS);
     2523        }
     2524
     2525        bus_dmamap_sync(sc->rl_ldata.rl_tx_mtag, txd->tx_dmamap,
     2526            BUS_DMASYNC_PREWRITE);
     2527
     2528        /*
     2529         * Set up checksum offload. Note: checksum offload bits must
     2530         * appear in all descriptors of a multi-descriptor transmit
     2531         * attempt. This is according to testing done with an 8169
     2532         * chip. This is a requirement.
     2533         */
     2534        vlanctl = 0;
     2535        csum_flags = 0;
     2536#ifndef __rtems__
     2537        if (((*m_head)->m_pkthdr.csum_flags & CSUM_TSO) != 0)
     2538                csum_flags = RL_TDESC_CMD_LGSEND |
     2539                    ((uint32_t)(*m_head)->m_pkthdr.tso_segsz <<
     2540                    RL_TDESC_CMD_MSSVAL_SHIFT);
     2541        else {
    23242542                /*
    2325                  * Manually pad short frames, and zero the pad space
    2326                  * to avoid leaking data.
     2543                 * Unconditionally enable IP checksum if TCP or UDP
     2544                 * checksum is required. Otherwise, TCP/UDP checksum
     2545                 * does't make effects.
    23272546                 */
    2328                 if (m_new->m_pkthdr.len < RL_MIN_FRAMELEN) {
    2329                         bzero(mtod(m_new, char *) + m_new->m_pkthdr.len,
    2330                             RL_MIN_FRAMELEN - m_new->m_pkthdr.len);
    2331                         m_new->m_pkthdr.len += RL_MIN_FRAMELEN -
    2332                             m_new->m_pkthdr.len;
    2333                         m_new->m_len = m_new->m_pkthdr.len;
    2334                 }
    2335 
    2336                 /* Note that we'll run over RL_TX_DESC_THLD here. */
    2337                 arg.rl_maxsegs = sc->rl_ldata.rl_tx_free;
    2338                 error = bus_dmamap_load_mbuf(sc->rl_ldata.rl_mtag, map,
    2339                     *m_head, re_dma_map_desc, &arg, BUS_DMA_NOWAIT);
    2340                 if (error || arg.rl_maxsegs == 0) {
    2341                         device_printf(sc->rl_dev,
    2342                             "can't map defragmented mbuf (error %d)\n", error);
    2343                         m_freem(m_new);
    2344                         *m_head = NULL;
    2345                         if (arg.rl_maxsegs == 0)
    2346                                 bus_dmamap_unload(sc->rl_ldata.rl_mtag, map);
    2347                         return (EFBIG);
    2348                 }
    2349         }
     2547                if (((*m_head)->m_pkthdr.csum_flags & RE_CSUM_FEATURES) != 0) {
     2548                        if ((sc->rl_flags & RL_FLAG_DESCV2) == 0) {
     2549                                csum_flags |= RL_TDESC_CMD_IPCSUM;
     2550                                if (((*m_head)->m_pkthdr.csum_flags &
     2551                                    CSUM_TCP) != 0)
     2552                                        csum_flags |= RL_TDESC_CMD_TCPCSUM;
     2553                                if (((*m_head)->m_pkthdr.csum_flags &
     2554                                    CSUM_UDP) != 0)
     2555                                        csum_flags |= RL_TDESC_CMD_UDPCSUM;
     2556                        } else {
     2557                                vlanctl |= RL_TDESC_CMD_IPCSUMV2;
     2558                                if (((*m_head)->m_pkthdr.csum_flags &
     2559                                    CSUM_TCP) != 0)
     2560                                        vlanctl |= RL_TDESC_CMD_TCPCSUMV2;
     2561                                if (((*m_head)->m_pkthdr.csum_flags &
     2562                                    CSUM_UDP) != 0)
     2563                                        vlanctl |= RL_TDESC_CMD_UDPCSUMV2;
     2564                        }
     2565                }
     2566        }
     2567#endif
     2568
     2569        /*
     2570         * Set up hardware VLAN tagging. Note: vlan tag info must
     2571         * appear in all descriptors of a multi-descriptor
     2572         * transmission attempt.
     2573         */
     2574#ifndef __rtems__
     2575        if ((*m_head)->m_flags & M_VLANTAG)
     2576                vlanctl |= bswap16((*m_head)->m_pkthdr.ether_vtag) |
     2577                    RL_TDESC_VLANCTL_TAG;
     2578#endif
     2579 
     2580        si = prod;
     2581        for (i = 0; i < nsegs; i++, prod = RL_TX_DESC_NXT(sc, prod)) {
     2582                desc = &sc->rl_ldata.rl_tx_list[prod];
     2583                desc->rl_vlanctl = htole32(vlanctl);
     2584                desc->rl_bufaddr_lo = htole32(RL_ADDR_LO(segs[i].ds_addr));
     2585                desc->rl_bufaddr_hi = htole32(RL_ADDR_HI(segs[i].ds_addr));
     2586                cmdstat = segs[i].ds_len;
     2587                if (i != 0)
     2588                        cmdstat |= RL_TDESC_CMD_OWN;
     2589                if (prod == sc->rl_ldata.rl_tx_desc_cnt - 1)
     2590                        cmdstat |= RL_TDESC_CMD_EOR;
     2591                desc->rl_cmdstat = htole32(cmdstat | csum_flags);
     2592                sc->rl_ldata.rl_tx_free--;
     2593        }
     2594        /* Update producer index. */
     2595        sc->rl_ldata.rl_tx_prodidx = prod;
     2596
     2597        /* Set EOF on the last descriptor. */
     2598        ei = RL_TX_DESC_PRV(sc, prod);
     2599        desc = &sc->rl_ldata.rl_tx_list[ei];
     2600        desc->rl_cmdstat |= htole32(RL_TDESC_CMD_EOF);
     2601
     2602        desc = &sc->rl_ldata.rl_tx_list[si];
     2603        /* Set SOF and transfer ownership of packet to the chip. */
     2604        desc->rl_cmdstat |= htole32(RL_TDESC_CMD_OWN | RL_TDESC_CMD_SOF);
    23502605
    23512606        /*
     
    23542609         * in this chain.  (Swap last and first dmamaps.)
    23552610         */
    2356         sc->rl_ldata.rl_tx_dmamap[*idx] =
    2357             sc->rl_ldata.rl_tx_dmamap[arg.rl_idx];
    2358         sc->rl_ldata.rl_tx_dmamap[arg.rl_idx] = map;
    2359 
    2360         sc->rl_ldata.rl_tx_mbuf[arg.rl_idx] = *m_head;
    2361         sc->rl_ldata.rl_tx_free -= arg.rl_maxsegs;
    2362 
    2363         /*
    2364          * Set up hardware VLAN tagging. Note: vlan tag info must
    2365          * appear in the first descriptor of a multi-descriptor
    2366          * transmission attempt.
    2367          */
    2368 
    2369 #ifndef __rtems__
    2370         mtag = VLAN_OUTPUT_TAG(sc->rl_ifp, *m_head);
    2371         if (mtag != NULL)
    2372                 sc->rl_ldata.rl_tx_list[*idx].rl_vlanctl =
    2373                     htole32(htons(VLAN_TAG_VALUE(mtag)) | RL_TDESC_VLANCTL_TAG);
    2374 #endif
    2375 
    2376         /* Transfer ownership of packet to the chip. */
    2377 
    2378         sc->rl_ldata.rl_tx_list[arg.rl_idx].rl_cmdstat |=
    2379             htole32(RL_TDESC_CMD_OWN);
    2380         if (*idx != arg.rl_idx)
    2381                 sc->rl_ldata.rl_tx_list[*idx].rl_cmdstat |=
    2382                     htole32(RL_TDESC_CMD_OWN);
    2383 
    2384         RL_DESC_INC(arg.rl_idx);
    2385         *idx = arg.rl_idx;
     2611        txd_last = &sc->rl_ldata.rl_tx_desc[ei];
     2612        map = txd->tx_dmamap;
     2613        txd->tx_dmamap = txd_last->tx_dmamap;
     2614        txd_last->tx_dmamap = map;
     2615        txd_last->tx_m = *m_head;
    23862616
    23872617        return (0);
     
    23892619
    23902620static void
    2391 re_tx_task(arg, npending)
    2392         void                    *arg;
    2393         int                     npending;
     2621re_tx_task(void *arg, int npending)
    23942622{
    23952623        struct ifnet            *ifp;
    23962624
    23972625        ifp = arg;
    2398         NET_LOCK_GIANT();
    23992626        re_start(ifp);
    2400         NET_UNLOCK_GIANT();
    2401 
    2402         return;
    24032627}
    24042628
     
    24072631 */
    24082632static void
    2409 re_start(ifp)
    2410         struct ifnet            *ifp;
     2633re_start(struct ifnet *ifp)
    24112634{
    24122635        struct rl_softc         *sc;
    2413         struct mbuf             *m_head = NULL;
    2414         int                     idx, queued = 0;
     2636        struct mbuf             *m_head;
     2637        int                     queued;
    24152638
    24162639        sc = ifp->if_softc;
     
    24182641        RL_LOCK(sc);
    24192642
    2420         if (!sc->rl_link || ifp->if_drv_flags & IFF_DRV_OACTIVE) {
     2643        if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) !=
     2644            IFF_DRV_RUNNING || (sc->rl_flags & RL_FLAG_LINK) == 0) {
    24212645                RL_UNLOCK(sc);
    24222646                return;
    24232647        }
    24242648
    2425         idx = sc->rl_ldata.rl_tx_prodidx;
    2426 
    2427         while (sc->rl_ldata.rl_tx_mbuf[idx] == NULL) {
     2649        for (queued = 0; !IFQ_DRV_IS_EMPTY(&ifp->if_snd) &&
     2650            sc->rl_ldata.rl_tx_free > 1;) {
    24282651                IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
    24292652                if (m_head == NULL)
    24302653                        break;
    24312654
    2432                 if (re_encap(sc, &m_head, &idx)) {
     2655                if (re_encap(sc, &m_head) != 0) {
    24332656                        if (m_head == NULL)
    24342657                                break;
     
    24492672        if (queued == 0) {
    24502673#ifdef RE_TX_MODERATION
    2451                 if (sc->rl_ldata.rl_tx_free != RL_TX_DESC_CNT)
     2674                if (sc->rl_ldata.rl_tx_free != sc->rl_ldata.rl_tx_desc_cnt)
    24522675                        CSR_WRITE_4(sc, RL_TIMERCNT, 1);
    24532676#endif
     
    24612684            sc->rl_ldata.rl_tx_list_map,
    24622685            BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
    2463 
    2464         sc->rl_ldata.rl_tx_prodidx = idx;
    24652686
    24662687        CSR_WRITE_1(sc, sc->rl_txstart, RL_TXSTART_START);
     
    24842705
    24852706        RL_UNLOCK(sc);
    2486 
    2487         return;
    24882707}
    24892708
    24902709static void
    2491 re_init(xsc)
    2492         void                    *xsc;
     2710re_init(void *xsc)
    24932711{
    24942712        struct rl_softc         *sc = xsc;
     
    25002718
    25012719static void
    2502 re_init_locked(sc)
    2503         struct rl_softc         *sc;
     2720re_init_locked(struct rl_softc *sc)
    25042721{
    25052722        struct ifnet            *ifp = sc->rl_ifp;
    25062723        struct mii_data         *mii;
    2507         u_int32_t               rxcfg = 0;
     2724        uint32_t                reg;
     2725        uint16_t                cfg;
     2726#ifndef __rtems__
    25082727        union {
    25092728                uint32_t align_dummy;
    25102729                u_char eaddr[ETHER_ADDR_LEN];
    25112730        } eaddr;
    2512 
     2731#else
     2732  uint32_t eaddr[2];
     2733#endif
     2734 
    25132735        RL_LOCK_ASSERT(sc);
    25142736
     
    25192741         */
    25202742        re_stop(sc);
     2743
     2744        /* Put controller into known state. */
     2745        re_reset(sc);
    25212746
    25222747        /*
     
    25252750         * before all others.
    25262751         */
    2527         CSR_WRITE_2(sc, RL_CPLUS_CMD, RL_CPLUSCMD_RXENB|
    2528             RL_CPLUSCMD_TXENB|RL_CPLUSCMD_PCI_MRW|
    2529             RL_CPLUSCMD_VLANSTRIP|RL_CPLUSCMD_RXCSUM_ENB);
    2530 
     2752        cfg = RL_CPLUSCMD_PCI_MRW;
     2753#ifndef __rtems__
     2754        if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
     2755                cfg |= RL_CPLUSCMD_RXCSUM_ENB;
     2756        if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0)
     2757                cfg |= RL_CPLUSCMD_VLANSTRIP;
     2758        if ((sc->rl_flags & RL_FLAG_MACSTAT) != 0) {
     2759                cfg |= RL_CPLUSCMD_MACSTAT_DIS;
     2760                /* XXX magic. */
     2761                cfg |= 0x0001;
     2762        } else
     2763#endif
     2764                cfg |= RL_CPLUSCMD_RXENB | RL_CPLUSCMD_TXENB;
     2765        CSR_WRITE_2(sc, RL_CPLUS_CMD, cfg);
     2766        if (sc->rl_hwrev == RL_HWREV_8169_8110SC ||
     2767            sc->rl_hwrev == RL_HWREV_8169_8110SCE) {
     2768                reg = 0x000fff00;
     2769                if ((CSR_READ_1(sc, RL_CFG2) & RL_CFG2_PCI66MHZ) != 0)
     2770                        reg |= 0x000000ff;
     2771                if (sc->rl_hwrev == RL_HWREV_8169_8110SCE)
     2772                        reg |= 0x00f00000;
     2773                CSR_WRITE_4(sc, 0x7c, reg);
     2774                /* Disable interrupt mitigation. */
     2775                CSR_WRITE_2(sc, 0xe2, 0);
     2776        }
     2777        /*
     2778         * Disable TSO if interface MTU size is greater than MSS
     2779         * allowed in controller.
     2780         */
     2781#ifndef __rtems__
     2782        if (ifp->if_mtu > RL_TSO_MTU && (ifp->if_capenable & IFCAP_TSO4) != 0) {
     2783                ifp->if_capenable &= ~IFCAP_TSO4;
     2784                ifp->if_hwassist &= ~CSUM_TSO;
     2785        }
     2786#endif
     2787 
    25312788        /*
    25322789         * Init our MAC address.  Even though the chipset
     
    25352792         */
    25362793        /* Copy MAC address on stack to align. */
     2794#ifndef __rtems__
    25372795        bcopy(IF_LLADDR(ifp), eaddr.eaddr, ETHER_ADDR_LEN);
    25382796        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_WRITECFG);
     
    25412799        CSR_WRITE_4(sc, RL_IDR4,
    25422800            htole32(*(u_int32_t *)(&eaddr.eaddr[4])));
     2801#else
     2802        bzero(eaddr, sizeof(eaddr));
     2803        bcopy(IF_LLADDR(ifp), eaddr, ETHER_ADDR_LEN);
     2804        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_WRITECFG);
     2805        CSR_WRITE_4(sc, RL_IDR0, htole32(eaddr[0]));
     2806        CSR_WRITE_4(sc, RL_IDR4, htole32(eaddr[1]));
     2807#endif
    25432808        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
    25442809
     
    25692834
    25702835        /*
    2571          * Set the initial TX and RX configuration.
     2836         * Set the initial TX configuration.
    25722837         */
    25732838        if (sc->rl_testmode) {
     
    25832848        CSR_WRITE_1(sc, RL_EARLY_TX_THRESH, 16);
    25842849
    2585         CSR_WRITE_4(sc, RL_RXCFG, RL_RXCFG_CONFIG);
    2586 
    2587         /* Set the individual bit to receive frames for this host only. */
    2588         rxcfg = CSR_READ_4(sc, RL_RXCFG);
    2589         rxcfg |= RL_RXCFG_RX_INDIV;
    2590 
    2591         /* If we want promiscuous mode, set the allframes bit. */
    2592         if (ifp->if_flags & IFF_PROMISC)
    2593                 rxcfg |= RL_RXCFG_RX_ALLPHYS;
    2594         else
    2595                 rxcfg &= ~RL_RXCFG_RX_ALLPHYS;
    2596         CSR_WRITE_4(sc, RL_RXCFG, rxcfg);
    2597 
    2598         /*
    2599          * Set capture broadcast bit to capture broadcast frames.
    2600          */
    2601         if (ifp->if_flags & IFF_BROADCAST)
    2602                 rxcfg |= RL_RXCFG_RX_BROAD;
    2603         else
    2604                 rxcfg &= ~RL_RXCFG_RX_BROAD;
    2605         CSR_WRITE_4(sc, RL_RXCFG, rxcfg);
    2606 
    2607         /*
    2608          * Program the multicast filter, if necessary.
    2609          */
    2610         re_setmulti(sc);
     2850        /*
     2851         * Set the initial RX configuration.
     2852         */
     2853        re_set_rxmode(sc);
    26112854
    26122855#ifdef DEVICE_POLLING
     
    26692912        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
    26702913
    2671         sc->rl_link = 0;
     2914        sc->rl_flags &= ~RL_FLAG_LINK;
    26722915        sc->rl_watchdog_timer = 0;
    26732916        callout_reset(&sc->rl_stat_callout, hz, re_tick, sc);
     
    26792922#ifndef __rtems__
    26802923static int
    2681 re_ifmedia_upd(ifp)
    2682         struct ifnet            *ifp;
     2924re_ifmedia_upd(struct ifnet *ifp)
    26832925{
    26842926        struct rl_softc         *sc;
    26852927        struct mii_data         *mii;
     2928        int                     error;
    26862929
    26872930        sc = ifp->if_softc;
    26882931        mii = device_get_softc(sc->rl_miibus);
    26892932        RL_LOCK(sc);
    2690         mii_mediachg(mii);
     2933        error = mii_mediachg(mii);
    26912934        RL_UNLOCK(sc);
    26922935
    2693         return (0);
     2936        return (error);
    26942937}
    26952938#endif
     
    27002943#ifndef __rtems__
    27012944static void
    2702 re_ifmedia_sts(ifp, ifmr)
    2703         struct ifnet            *ifp;
    2704         struct ifmediareq       *ifmr;
     2945re_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
    27052946{
    27062947        struct rl_softc         *sc;
     
    27322973        switch (command) {
    27332974        case SIOCSIFMTU:
     2975                if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > RL_JUMBO_MTU) {
     2976                        error = EINVAL;
     2977                        break;
     2978                }
     2979                if ((sc->rl_flags & RL_FLAG_NOJUMBO) != 0 &&
     2980                    ifr->ifr_mtu > RL_MAX_FRAMELEN) {
     2981                        error = EINVAL;
     2982                        break;
     2983                }
    27342984                RL_LOCK(sc);
    2735                 if (ifr->ifr_mtu > RL_JUMBO_MTU)
    2736                         error = EINVAL;
    2737                 ifp->if_mtu = ifr->ifr_mtu;
     2985                if (ifp->if_mtu != ifr->ifr_mtu)
     2986                        ifp->if_mtu = ifr->ifr_mtu;
     2987#ifndef __rtems__
     2988                if (ifp->if_mtu > RL_TSO_MTU &&
     2989                    (ifp->if_capenable & IFCAP_TSO4) != 0) {
     2990                        ifp->if_capenable &= ~IFCAP_TSO4;
     2991                        ifp->if_hwassist &= ~CSUM_TSO;
     2992                }
     2993#endif
    27382994                RL_UNLOCK(sc);
    27392995                break;
     
    27432999                        if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) {
    27443000                                if (((ifp->if_flags ^ sc->rl_if_flags)
    2745                                     & IFF_PROMISC) != 0)
    2746                                         re_setmulti(sc);
     3001                                    & (IFF_PROMISC | IFF_ALLMULTI)) != 0)
     3002                                        re_set_rxmode(sc);
    27473003                        } else
    27483004                                re_init_locked(sc);
     
    27563012        case SIOCADDMULTI:
    27573013        case SIOCDELMULTI:
    2758 #ifdef __rtems__
    2759                 if ( ETHER_SIOCMULTIFRAG(error, command, ifr, ifp) )
    2760                         break;
    2761 #endif
    27623014                RL_LOCK(sc);
    2763                 re_setmulti(sc);
     3015                re_set_rxmode(sc);
    27643016                RL_UNLOCK(sc);
    27653017                break;
     
    28043056                        ifp->if_capenable ^= IFCAP_HWCSUM;
    28053057                        if (ifp->if_capenable & IFCAP_TXCSUM)
    2806                                 ifp->if_hwassist = RE_CSUM_FEATURES;
     3058                                ifp->if_hwassist |= RE_CSUM_FEATURES;
    28073059                        else
    2808                                 ifp->if_hwassist = 0;
     3060                                ifp->if_hwassist &= ~RE_CSUM_FEATURES;
    28093061                        reinit = 1;
    28103062                }
     
    28133065                        reinit = 1;
    28143066                }
     3067                if (mask & IFCAP_TSO4) {
     3068                        ifp->if_capenable ^= IFCAP_TSO4;
     3069                        if ((IFCAP_TSO4 & ifp->if_capenable) &&
     3070                            (IFCAP_TSO4 & ifp->if_capabilities))
     3071                                ifp->if_hwassist |= CSUM_TSO;
     3072                        else
     3073                                ifp->if_hwassist &= ~CSUM_TSO;
     3074                        if (ifp->if_mtu > RL_TSO_MTU &&
     3075                            (ifp->if_capenable & IFCAP_TSO4) != 0) {
     3076                                ifp->if_capenable &= ~IFCAP_TSO4;
     3077                                ifp->if_hwassist &= ~CSUM_TSO;
     3078                        }
     3079                }
     3080                if ((mask & IFCAP_WOL) != 0 &&
     3081                    (ifp->if_capabilities & IFCAP_WOL) != 0) {
     3082                        if ((mask & IFCAP_WOL_UCAST) != 0)
     3083                                ifp->if_capenable ^= IFCAP_WOL_UCAST;
     3084                        if ((mask & IFCAP_WOL_MCAST) != 0)
     3085                                ifp->if_capenable ^= IFCAP_WOL_MCAST;
     3086                        if ((mask & IFCAP_WOL_MAGIC) != 0)
     3087                                ifp->if_capenable ^= IFCAP_WOL_MAGIC;
     3088                }
    28153089                if (reinit && ifp->if_drv_flags & IFF_DRV_RUNNING)
    28163090                        re_init(sc);
    2817 #ifdef VLAN_CAPABILITIES
    28183091                VLAN_CAPABILITIES(ifp);
    2819 #endif
    28203092            }
    2821 #endif
    28223093                break;
     3094#endif
    28233095        default:
    28243096                error = ether_ioctl(ifp, command, data);
     
    28303102
    28313103static void
    2832 re_watchdog(sc)
    2833         struct rl_softc         *sc;
    2834 {
     3104re_watchdog(struct rl_softc *sc)
     3105{
     3106        struct ifnet            *ifp;
    28353107
    28363108        RL_LOCK_ASSERT(sc);
     
    28393111                return;
    28403112
    2841         device_printf(sc->rl_dev, "watchdog timeout\n");
    2842         sc->rl_ifp->if_oerrors++;
    2843 
     3113        ifp = sc->rl_ifp;
    28443114        re_txeof(sc);
    2845         re_rxeof(sc);
     3115        if (sc->rl_ldata.rl_tx_free == sc->rl_ldata.rl_tx_desc_cnt) {
     3116                if_printf(ifp, "watchdog timeout (missed Tx interrupts) "
     3117                    "-- recovering\n");
     3118                if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
     3119                        taskqueue_enqueue_fast(taskqueue_fast, &sc->rl_txtask);
     3120                return;
     3121        }
     3122
     3123        if_printf(ifp, "watchdog timeout\n");
     3124        ifp->if_oerrors++;
     3125
     3126        re_rxeof(sc, NULL);
    28463127        re_init_locked(sc);
     3128        if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
     3129                taskqueue_enqueue_fast(taskqueue_fast, &sc->rl_txtask);
    28473130}
    28483131
     
    28523135 */
    28533136static void
    2854 re_stop(sc)
    2855         struct rl_softc         *sc;
    2856 {
    2857         register int            i;
     3137re_stop(struct rl_softc *sc)
     3138{
     3139        int                     i;
    28583140        struct ifnet            *ifp;
     3141        struct rl_txdesc        *txd;
     3142        struct rl_rxdesc        *rxd;
    28593143
    28603144        RL_LOCK_ASSERT(sc);
     
    28663150        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
    28673151
    2868         CSR_WRITE_1(sc, RL_COMMAND, 0x00);
     3152        if ((sc->rl_flags & RL_FLAG_CMDSTOP) != 0)
     3153                CSR_WRITE_1(sc, RL_COMMAND, RL_CMD_STOPREQ | RL_CMD_TX_ENB |
     3154                    RL_CMD_RX_ENB);
     3155        else
     3156                CSR_WRITE_1(sc, RL_COMMAND, 0x00);
     3157        DELAY(1000);
    28693158        CSR_WRITE_2(sc, RL_IMR, 0x0000);
    28703159        CSR_WRITE_2(sc, RL_ISR, 0xFFFF);
     
    28773166        /* Free the TX list buffers. */
    28783167
    2879         for (i = 0; i < RL_TX_DESC_CNT; i++) {
    2880                 if (sc->rl_ldata.rl_tx_mbuf[i] != NULL) {
    2881                         bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    2882                             sc->rl_ldata.rl_tx_dmamap[i]);
    2883                         m_freem(sc->rl_ldata.rl_tx_mbuf[i]);
    2884                         sc->rl_ldata.rl_tx_mbuf[i] = NULL;
     3168        for (i = 0; i < sc->rl_ldata.rl_tx_desc_cnt; i++) {
     3169                txd = &sc->rl_ldata.rl_tx_desc[i];
     3170                if (txd->tx_m != NULL) {
     3171                        bus_dmamap_sync(sc->rl_ldata.rl_tx_mtag,
     3172                            txd->tx_dmamap, BUS_DMASYNC_POSTWRITE);
     3173                        bus_dmamap_unload(sc->rl_ldata.rl_tx_mtag,
     3174                            txd->tx_dmamap);
     3175                        m_freem(txd->tx_m);
     3176                        txd->tx_m = NULL;
    28853177                }
    28863178        }
     
    28883180        /* Free the RX list buffers. */
    28893181
    2890         for (i = 0; i < RL_RX_DESC_CNT; i++) {
    2891                 if (sc->rl_ldata.rl_rx_mbuf[i] != NULL) {
    2892                         bus_dmamap_unload(sc->rl_ldata.rl_mtag,
    2893                             sc->rl_ldata.rl_rx_dmamap[i]);
    2894                         m_freem(sc->rl_ldata.rl_rx_mbuf[i]);
    2895                         sc->rl_ldata.rl_rx_mbuf[i] = NULL;
     3182        for (i = 0; i < sc->rl_ldata.rl_rx_desc_cnt; i++) {
     3183                rxd = &sc->rl_ldata.rl_rx_desc[i];
     3184                if (rxd->rx_m != NULL) {
     3185                        bus_dmamap_sync(sc->rl_ldata.rl_tx_mtag,
     3186                            rxd->rx_dmamap, BUS_DMASYNC_POSTREAD);
     3187                        bus_dmamap_unload(sc->rl_ldata.rl_rx_mtag,
     3188                            rxd->rx_dmamap);
     3189                        m_freem(rxd->rx_m);
     3190                        rxd->rx_m = NULL;
    28963191                }
    28973192        }
     
    29053200#ifndef __rtems__
    29063201static int
    2907 re_suspend(dev)
    2908         device_t                dev;
     3202re_suspend(device_t dev)
    29093203{
    29103204        struct rl_softc         *sc;
     
    29143208        RL_LOCK(sc);
    29153209        re_stop(sc);
     3210        re_setwol(sc);
    29163211        sc->suspended = 1;
    29173212        RL_UNLOCK(sc);
     
    29283223#ifndef __rtems__
    29293224static int
    2930 re_resume(dev)
    2931         device_t                dev;
     3225re_resume(device_t dev)
    29323226{
    29333227        struct rl_softc         *sc;
     
    29393233
    29403234        ifp = sc->rl_ifp;
     3235        /* Take controller out of sleep mode. */
     3236        if ((sc->rl_flags & RL_FLAG_MACSLEEP) != 0) {
     3237                if ((CSR_READ_1(sc, RL_MACDBG) & 0x80) == 0x80)
     3238                        CSR_WRITE_1(sc, RL_GPIO,
     3239                            CSR_READ_1(sc, RL_GPIO) | 0x01);
     3240        }
    29413241
    29423242        /* reinitialize interface if necessary */
     
    29443244                re_init_locked(sc);
    29453245
     3246        /*
     3247         * Clear WOL matching such that normal Rx filtering
     3248         * wouldn't interfere with WOL patterns.
     3249         */
     3250        re_clrwol(sc);
    29463251        sc->suspended = 0;
    29473252        RL_UNLOCK(sc);
     
    29553260 * get confused by errant DMAs when rebooting.
    29563261 */
     3262#ifndef __rtems__
     3263static int
     3264#else
    29573265static void
    2958 re_shutdown(dev)
    2959         device_t                dev;
     3266#endif
     3267re_shutdown(device_t dev)
    29603268{
    29613269        struct rl_softc         *sc;
     
    29713279         */
    29723280        sc->rl_ifp->if_flags &= ~IFF_UP;
     3281#ifndef __rtems__
     3282        re_setwol(sc);
     3283#endif
    29733284        RL_UNLOCK(sc);
    2974 }
     3285
     3286#ifndef __rtems__
     3287        return (0);
     3288#endif
     3289}
     3290
     3291#ifndef __rtems__
     3292static void
     3293re_setwol(struct rl_softc *sc)
     3294{
     3295        struct ifnet            *ifp;
     3296        int                     pmc;
     3297        uint16_t                pmstat;
     3298        uint8_t                 v;
     3299
     3300        RL_LOCK_ASSERT(sc);
     3301
     3302        if (pci_find_extcap(sc->rl_dev, PCIY_PMG, &pmc) != 0)
     3303                return;
     3304
     3305        ifp = sc->rl_ifp;
     3306        /* Put controller into sleep mode. */
     3307        if ((sc->rl_flags & RL_FLAG_MACSLEEP) != 0) {
     3308                if ((CSR_READ_1(sc, RL_MACDBG) & 0x80) == 0x80)
     3309                        CSR_WRITE_1(sc, RL_GPIO,
     3310                            CSR_READ_1(sc, RL_GPIO) & ~0x01);
     3311        }
     3312        if ((ifp->if_capenable & IFCAP_WOL) != 0 &&
     3313            (sc->rl_flags & RL_FLAG_WOLRXENB) != 0)
     3314                CSR_WRITE_1(sc, RL_COMMAND, RL_CMD_RX_ENB);
     3315        /* Enable config register write. */
     3316        CSR_WRITE_1(sc, RL_EECMD, RL_EE_MODE);
     3317
     3318        /* Enable PME. */
     3319        v = CSR_READ_1(sc, RL_CFG1);
     3320        v &= ~RL_CFG1_PME;
     3321        if ((ifp->if_capenable & IFCAP_WOL) != 0)
     3322                v |= RL_CFG1_PME;
     3323        CSR_WRITE_1(sc, RL_CFG1, v);
     3324
     3325        v = CSR_READ_1(sc, RL_CFG3);
     3326        v &= ~(RL_CFG3_WOL_LINK | RL_CFG3_WOL_MAGIC);
     3327        if ((ifp->if_capenable & IFCAP_WOL_MAGIC) != 0)
     3328                v |= RL_CFG3_WOL_MAGIC;
     3329        CSR_WRITE_1(sc, RL_CFG3, v);
     3330
     3331        /* Config register write done. */
     3332        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
     3333
     3334        v = CSR_READ_1(sc, RL_CFG5);
     3335        v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST);
     3336        v &= ~RL_CFG5_WOL_LANWAKE;
     3337        if ((ifp->if_capenable & IFCAP_WOL_UCAST) != 0)
     3338                v |= RL_CFG5_WOL_UCAST;
     3339        if ((ifp->if_capenable & IFCAP_WOL_MCAST) != 0)
     3340                v |= RL_CFG5_WOL_MCAST | RL_CFG5_WOL_BCAST;
     3341        if ((ifp->if_capenable & IFCAP_WOL) != 0)
     3342                v |= RL_CFG5_WOL_LANWAKE;
     3343        CSR_WRITE_1(sc, RL_CFG5, v);
     3344
     3345        /*
     3346         * It seems that hardware resets its link speed to 100Mbps in
     3347         * power down mode so switching to 100Mbps in driver is not
     3348         * needed.
     3349         */
     3350
     3351        /* Request PME if WOL is requested. */
     3352        pmstat = pci_read_config(sc->rl_dev, pmc + PCIR_POWER_STATUS, 2);
     3353        pmstat &= ~(PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE);
     3354        if ((ifp->if_capenable & IFCAP_WOL) != 0)
     3355                pmstat |= PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE;
     3356        pci_write_config(sc->rl_dev, pmc + PCIR_POWER_STATUS, pmstat, 2);
     3357}
     3358
     3359static void
     3360re_clrwol(struct rl_softc *sc)
     3361{
     3362        int                     pmc;
     3363        uint8_t                 v;
     3364
     3365        RL_LOCK_ASSERT(sc);
     3366
     3367        if (pci_find_extcap(sc->rl_dev, PCIY_PMG, &pmc) != 0)
     3368                return;
     3369
     3370        /* Enable config register write. */
     3371        CSR_WRITE_1(sc, RL_EECMD, RL_EE_MODE);
     3372
     3373        v = CSR_READ_1(sc, RL_CFG3);
     3374        v &= ~(RL_CFG3_WOL_LINK | RL_CFG3_WOL_MAGIC);
     3375        CSR_WRITE_1(sc, RL_CFG3, v);
     3376
     3377        /* Config register write done. */
     3378        CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
     3379
     3380        v = CSR_READ_1(sc, RL_CFG5);
     3381        v &= ~(RL_CFG5_WOL_BCAST | RL_CFG5_WOL_MCAST | RL_CFG5_WOL_UCAST);
     3382        v &= ~RL_CFG5_WOL_LANWAKE;
     3383        CSR_WRITE_1(sc, RL_CFG5, v);
     3384}
     3385#endif
  • bsd_eth_drivers/if_re/if_rlreg.h

    rd766703 rab325ab  
    3030 * THE POSSIBILITY OF SUCH DAMAGE.
    3131 *
    32  * $FreeBSD: src/sys/pci/if_rlreg.h,v 1.51.2.14.2.1 2008/10/02 02:57:24 kensmith Exp $
     32 * $FreeBSD: src/sys/pci/if_rlreg.h,v 1.98 2009/08/24 18:58:13 yongari Exp $
    3333 */
    3434
     
    7777#define RL_CFG0         0x0051          /* config register #0 */
    7878#define RL_CFG1         0x0052          /* config register #1 */
    79                                         /* 0053-0057 reserved */   
     79#define RL_CFG2         0x0053          /* config register #2 */
     80#define RL_CFG3         0x0054          /* config register #3 */
     81#define RL_CFG4         0x0055          /* config register #4 */
     82#define RL_CFG5         0x0056          /* config register #5 */
     83                                        /* 0057 reserved */
    8084#define RL_MEDIASTAT    0x0058          /* media status register (8139) */
    8185                                        /* 0059-005A reserved */
     
    128132#define RL_TBI_LPAR             0x006A
    129133#define RL_GMEDIASTAT           0x006C  /* 8 bits */
     134#define RL_MACDBG               0x006D  /* 8 bits, 8168C SPIN2 only */
     135#define RL_GPIO                 0x006E  /* 8 bits, 8168C SPIN2 only */
    130136#define RL_MAXRXPKTLEN          0x00DA  /* 16 bits, chip multiplies by 8 */
    131 #define RL_GTXSTART             0x0038  /* 16 bits */
     137#define RL_GTXSTART             0x0038  /* 8 bits */
    132138
    133139/*
     
    149155
    150156#define RL_HWREV_8169           0x00000000
    151 #define RL_HWREV_8110S          0x00800000
    152 #define RL_HWREV_8169S          0x04000000
     157#define RL_HWREV_8169S          0x00800000
     158#define RL_HWREV_8110S          0x04000000
    153159#define RL_HWREV_8169_8110SB    0x10000000
    154160#define RL_HWREV_8169_8110SC    0x18000000
     161#define RL_HWREV_8102EL         0x24800000
     162#define RL_HWREV_8102EL_SPIN1   0x24c00000
     163#define RL_HWREV_8168D          0x28000000
     164#define RL_HWREV_8168DP         0x28800000
    155165#define RL_HWREV_8168_SPIN1     0x30000000
    156166#define RL_HWREV_8100E          0x30800000
    157167#define RL_HWREV_8101E          0x34000000
     168#define RL_HWREV_8102E          0x34800000
    158169#define RL_HWREV_8168_SPIN2     0x38000000
    159170#define RL_HWREV_8168_SPIN3     0x38400000
     171#define RL_HWREV_8168C          0x3C000000
     172#define RL_HWREV_8168C_SPIN2    0x3C400000
     173#define RL_HWREV_8168CP         0x3C800000
    160174#define RL_HWREV_8139           0x60000000
    161175#define RL_HWREV_8139A          0x70000000
     
    168182#define RL_HWREV_8101           0x74c00000
    169183#define RL_HWREV_8100           0x78800000
     184#define RL_HWREV_8169_8110SBL   0x7CC00000
     185#define RL_HWREV_8169_8110SCE   0x98000000
    170186
    171187#define RL_TXDMA_16BYTES        0x00000000
     
    298314#define RL_CMD_RX_ENB           0x0008
    299315#define RL_CMD_RESET            0x0010
    300 
     316#define RL_CMD_STOPREQ          0x0080
     317
     318/*
     319 * Twister register values.  These are completely undocumented and derived
     320 * from public sources.
     321 */
     322#define RL_CSCFG_LINK_OK        0x0400
     323#define RL_CSCFG_CHANGE         0x0800
     324#define RL_CSCFG_STATUS         0xf000
     325#define RL_CSCFG_ROW3           0x7000
     326#define RL_CSCFG_ROW2           0x3000
     327#define RL_CSCFG_ROW1           0x1000
     328#define RL_CSCFG_LINK_DOWN_OFF_CMD 0x03c0
     329#define RL_CSCFG_LINK_DOWN_CMD  0xf3c0
     330
     331#define RL_NWAYTST_RESET        0
     332#define RL_NWAYTST_CBL_TEST     0x20
     333
     334#define RL_PARA78               0x78
     335#define RL_PARA78_DEF           0x78fa8388
     336#define RL_PARA7C               0x7C
     337#define RL_PARA7C_DEF           0xcb38de43
     338#define RL_PARA7C_RETUNE        0xfb38de03
    301339/*
    302340 * EEPROM control register
     
    360398 */
    361399#define RL_CFG1_PWRDWN          0x01
     400#define RL_CFG1_PME             0x01   
    362401#define RL_CFG1_SLEEP           0x02
     402#define RL_CFG1_VPDEN           0x02
    363403#define RL_CFG1_IOMAP           0x04
    364404#define RL_CFG1_MEMMAP          0x08
    365405#define RL_CFG1_RSVD            0x10
     406#define RL_CFG1_LWACT           0x10
    366407#define RL_CFG1_DRVLOAD         0x20
    367408#define RL_CFG1_LED0            0x40
    368409#define RL_CFG1_FULLDUPLEX      0x40    /* 8129 only */
    369410#define RL_CFG1_LED1            0x80
     411
     412/*
     413 * Config 2 register
     414 */
     415#define RL_CFG2_PCI33MHZ        0x00
     416#define RL_CFG2_PCI66MHZ        0x01
     417#define RL_CFG2_PCI64BIT        0x08
     418#define RL_CFG2_AUXPWR          0x10
     419#define RL_CFG2_MSI             0x20
     420
     421/*
     422 * Config 3 register
     423 */
     424#define RL_CFG3_GRANTSEL        0x80
     425#define RL_CFG3_WOL_MAGIC       0x20
     426#define RL_CFG3_WOL_LINK        0x10
     427#define RL_CFG3_FAST_B2B        0x01
     428
     429/*
     430 * Config 4 register
     431 */
     432#define RL_CFG4_LWPTN           0x04
     433#define RL_CFG4_LWPME           0x10
     434
     435/*
     436 * Config 5 register
     437 */
     438#define RL_CFG5_WOL_BCAST       0x40
     439#define RL_CFG5_WOL_MCAST       0x20
     440#define RL_CFG5_WOL_UCAST       0x10
     441#define RL_CFG5_WOL_LANWAKE     0x02
     442#define RL_CFG5_PME_STS         0x01
    370443
    371444/*
     
    404477#define RL_CPLUSCMD_RXCSUM_ENB  0x0020  /* enable RX checksum offload */
    405478#define RL_CPLUSCMD_VLANSTRIP   0x0040  /* enable VLAN tag stripping */
     479#define RL_CPLUSCMD_MACSTAT_DIS 0x0080  /* 8168B/C/CP */
     480#define RL_CPLUSCMD_ASF         0x0100  /* 8168C/CP */
     481#define RL_CPLUSCMD_DBG_SEL     0x0200  /* 8168C/CP */
     482#define RL_CPLUSCMD_FORCE_TXFC  0x0400  /* 8168C/CP */
     483#define RL_CPLUSCMD_FORCE_RXFC  0x0800  /* 8168C/CP */
     484#define RL_CPLUSCMD_FORCE_HDPX  0x1000  /* 8168C/CP */
     485#define RL_CPLUSCMD_NORMAL_MODE 0x2000  /* 8168C/CP */
     486#define RL_CPLUSCMD_DBG_ENB     0x4000  /* 8168C/CP */
     487#define RL_CPLUSCMD_BIST_ENB    0x8000  /* 8168C/CP */
    406488
    407489/* C+ early transmit threshold */
     
    448530#define RL_TX_LIST_CNT          4
    449531#define RL_MIN_FRAMELEN         60
     532#define RL_TX_8139_BUF_ALIGN    4
     533#define RL_RX_8139_BUF_ALIGN    8
     534#define RL_RX_8139_BUF_RESERVE  sizeof(int64_t)
     535#define RL_RX_8139_BUF_GUARD_SZ \
     536        (ETHER_MAX_LEN + ETHER_VLAN_ENCAP_LEN + RL_RX_8139_BUF_RESERVE)
    450537#define RL_TXTHRESH(x)          ((x) << 11)
    451538#define RL_TX_THRESH_INIT       96
     
    457544#define RL_TXCFG_CONFIG (RL_TXCFG_IFG|RL_TX_MAXDMA)
    458545
     546#ifndef __rtems__
    459547#define RL_ETHER_ALIGN  2
     548#else
     549#define RL_ETHER_ALIGN  0
     550#endif
     551
     552/*
     553 * re(4) hardware ip4csum-tx could be mangled with 28 bytes or less IP packets.
     554 */
     555#define RL_IP4CSUMTX_MINLEN     28
     556#define RL_IP4CSUMTX_PADLEN     (ETHER_HDR_LEN + RL_IP4CSUMTX_MINLEN)
    460557
    461558struct rl_chain_data {
     
    463560        uint8_t                 *rl_rx_buf;
    464561        uint8_t                 *rl_rx_buf_ptr;
    465         bus_dmamap_t            rl_rx_dmamap;
    466562
    467563        struct mbuf             *rl_tx_chain[RL_TX_LIST_CNT];
    468564        bus_dmamap_t            rl_tx_dmamap[RL_TX_LIST_CNT];
     565        bus_dma_tag_t           rl_tx_tag;
     566        bus_dma_tag_t           rl_rx_tag;
     567        bus_dmamap_t            rl_rx_dmamap;
     568        bus_addr_t              rl_rx_buf_paddr;
    469569        uint8_t                 last_tx;
    470570        uint8_t                 cur_tx;
     
    545645#define RL_TDESC_CMD_IPCSUM     0x00040000      /* IP header checksum enable */
    546646#define RL_TDESC_CMD_MSSVAL     0x07FF0000      /* Large send MSS value */
     647#define RL_TDESC_CMD_MSSVAL_SHIFT       16      /* Large send MSS value shift */
    547648#define RL_TDESC_CMD_LGSEND     0x08000000      /* TCP large send enb */
    548649#define RL_TDESC_CMD_EOF        0x10000000      /* end of frame marker */
     
    553654#define RL_TDESC_VLANCTL_TAG    0x00020000      /* Insert VLAN tag */
    554655#define RL_TDESC_VLANCTL_DATA   0x0000FFFF      /* TAG data */
     656/* RTL8168C/RTL8168CP/RTL8111C/RTL8111CP */
     657#define RL_TDESC_CMD_UDPCSUMV2  0x80000000
     658#define RL_TDESC_CMD_TCPCSUMV2  0x40000000     
     659#define RL_TDESC_CMD_IPCSUMV2   0x20000000     
    555660
    556661/*
     
    590695#define RL_RDESC_STAT_CRCERR    0x00040000      /* CRC error */
    591696#define RL_RDESC_STAT_PROTOID   0x00030000      /* Protocol type */
     697#define RL_RDESC_STAT_UDP       0x00020000      /* UDP, 8168C/CP, 8111C/CP */
     698#define RL_RDESC_STAT_TCP       0x00010000      /* TCP, 8168C/CP, 8111C/CP */
    592699#define RL_RDESC_STAT_IPSUMBAD  0x00008000      /* IP header checksum bad */
    593700#define RL_RDESC_STAT_UDPSUMBAD 0x00004000      /* UDP checksum bad */
     
    601708                                                   (rl_vlandata valid)*/
    602709#define RL_RDESC_VLANCTL_DATA   0x0000FFFF      /* TAG data */
     710/* RTL8168C/RTL8168CP/RTL8111C/RTL8111CP */
     711#define RL_RDESC_IPV6           0x80000000
     712#define RL_RDESC_IPV4           0x40000000
    603713
    604714#define RL_PROTOID_NONIP        0x00000000
     
    636746 * Rx/Tx descriptor parameters (8139C+ and 8169 only)
    637747 *
    638  * Tx/Rx count must be equal.  Shared code like re_dma_map_desc assumes this.
    639  * Buffers must be a multiple of 8 bytes.  Currently limit to 64 descriptors
    640  * due to the 8139C+.  We need to put the number of descriptors in the ring
    641  * structure and use that value instead.
    642  */
    643 #if !defined(__i386__) && !defined(__amd64__)
     748 * 8139C+
     749 *  Number of descriptors supported : up to 64
     750 *  Descriptor alignment : 256 bytes
     751 *  Tx buffer : At least 4 bytes in length.
     752 *  Rx buffer : At least 8 bytes in length and 8 bytes alignment required.
     753 * 
     754 * 8169
     755 *  Number of descriptors supported : up to 1024
     756 *  Descriptor alignment : 256 bytes
     757 *  Tx buffer : At least 4 bytes in length.
     758 *  Rx buffer : At least 8 bytes in length and 8 bytes alignment required.
     759 */
     760#ifndef __NO_STRICT_ALIGNMENT
    644761#define RE_FIXUP_RX     1
    645762#endif
    646763
    647 #define RL_TX_DESC_CNT          64
    648 #define RL_TX_DESC_THLD         4
    649 #define RL_RX_DESC_CNT          RL_TX_DESC_CNT
    650 
    651 #define RL_RX_LIST_SZ           (RL_RX_DESC_CNT * sizeof(struct rl_desc))
    652 #define RL_TX_LIST_SZ           (RL_TX_DESC_CNT * sizeof(struct rl_desc))
     764#define RL_8169_TX_DESC_CNT     256
     765#define RL_8169_RX_DESC_CNT     256
     766#define RL_8139_TX_DESC_CNT     64
     767#define RL_8139_RX_DESC_CNT     64
     768#define RL_TX_DESC_CNT          RL_8169_TX_DESC_CNT
     769#define RL_RX_DESC_CNT          RL_8169_RX_DESC_CNT
     770#define RL_NTXSEGS              32
     771
    653772#define RL_RING_ALIGN           256
    654773#define RL_IFQ_MAXLEN           512
    655 #define RL_DESC_INC(x)          (x = (x + 1) % RL_TX_DESC_CNT)
     774#define RL_TX_DESC_NXT(sc,x)    ((x + 1) & ((sc)->rl_ldata.rl_tx_desc_cnt - 1))
     775#define RL_TX_DESC_PRV(sc,x)    ((x - 1) & ((sc)->rl_ldata.rl_tx_desc_cnt - 1))
     776#define RL_RX_DESC_NXT(sc,x)    ((x + 1) & ((sc)->rl_ldata.rl_rx_desc_cnt - 1))
    656777#define RL_OWN(x)               (le32toh((x)->rl_cmdstat) & RL_RDESC_STAT_OWN)
    657778#define RL_RXBYTES(x)           (le32toh((x)->rl_cmdstat) & sc->rl_rxlenmask)
     
    665786#endif
    666787
     788#define RL_MSI_MESSAGES 1
     789
    667790#define RL_ADDR_LO(y)           ((uint64_t) (y) & 0xFFFFFFFF)
    668791#define RL_ADDR_HI(y)           ((uint64_t) (y) >> 32)
     792
     793/*
     794 * The number of bits reserved for MSS in RealTek controllers is
     795 * 11bits. This limits the maximum interface MTU size in TSO case
     796 * as upper stack should not generate TCP segments with MSS greater
     797 * than the limit.
     798 */
     799#define RL_TSO_MTU              (2047 - ETHER_HDR_LEN - ETHER_CRC_LEN)
    669800
    670801/* see comment in dev/re/if_re.c */
    671802#define RL_JUMBO_FRAMELEN       7440
    672803#define RL_JUMBO_MTU            (RL_JUMBO_FRAMELEN-ETHER_HDR_LEN-ETHER_CRC_LEN)
    673 
    674 struct rl_softc;
    675 
    676 struct rl_dmaload_arg {
    677         int                     rl_idx;
    678         int                     rl_maxsegs;
    679         uint32_t                rl_flags;
    680         struct rl_desc          *rl_ring;
     804#define RL_MAX_FRAMELEN         \
     805        (ETHER_MAX_LEN + ETHER_VLAN_ENCAP_LEN - ETHER_HDR_LEN - ETHER_CRC_LEN)
     806
     807struct rl_txdesc {
     808        struct mbuf             *tx_m;
     809        bus_dmamap_t            tx_dmamap;
    681810};
    682811
     812struct rl_rxdesc {
     813        struct mbuf             *rx_m;
     814        bus_dmamap_t            rx_dmamap;
     815        bus_size_t              rx_size;
     816};
     817
    683818struct rl_list_data {
    684         struct mbuf             *rl_tx_mbuf[RL_TX_DESC_CNT];
    685         struct mbuf             *rl_rx_mbuf[RL_RX_DESC_CNT];
     819        struct rl_txdesc        rl_tx_desc[RL_TX_DESC_CNT];
     820        struct rl_rxdesc        rl_rx_desc[RL_RX_DESC_CNT];
     821        int                     rl_tx_desc_cnt;
     822        int                     rl_rx_desc_cnt;
    686823        int                     rl_tx_prodidx;
    687824        int                     rl_rx_prodidx;
    688825        int                     rl_tx_considx;
    689826        int                     rl_tx_free;
    690         bus_dmamap_t            rl_tx_dmamap[RL_TX_DESC_CNT];
    691         bus_dmamap_t            rl_rx_dmamap[RL_RX_DESC_CNT];
    692         bus_dma_tag_t           rl_mtag;        /* mbuf mapping tag */
     827        bus_dma_tag_t           rl_tx_mtag;     /* mbuf TX mapping tag */
     828        bus_dma_tag_t           rl_rx_mtag;     /* mbuf RX mapping tag */
     829        bus_dmamap_t            rl_rx_sparemap;
    693830        bus_dma_tag_t           rl_stag;        /* stats mapping tag */
    694831        bus_dmamap_t            rl_smap;        /* stats map */
     
    705842};
    706843
     844enum rl_twist { DONE, CHK_LINK, FIND_ROW, SET_PARAM, RECHK_LONG, RETUNE };
     845
    707846struct rl_softc {
    708847        struct ifnet            *rl_ifp;        /* interface info */
     
    711850        device_t                rl_dev;
    712851        struct resource         *rl_res;
    713         struct resource         *rl_irq;
    714         void                    *rl_intrhand;
     852        int                     rl_res_id;
     853        int                     rl_res_type;
     854        struct resource         *rl_irq[RL_MSI_MESSAGES];
     855        void                    *rl_intrhand[RL_MSI_MESSAGES];
    715856        device_t                rl_miibus;
    716857        bus_dma_tag_t           rl_parent_tag;
    717         bus_dma_tag_t           rl_tag;
    718858        uint8_t                 rl_type;
    719859        int                     rl_eecmd_read;
     
    732872        int                     rl_testmode;
    733873        int                     rl_if_flags;
     874        int                     rl_twister_enable;
     875        enum rl_twist           rl_twister;
     876        int                     rl_twist_row;
     877        int                     rl_twist_col;
    734878        int                     suspended;      /* 0 = normal  1 = suspended */
    735879#ifdef DEVICE_POLLING
     
    740884        struct task             rl_inttask;
    741885
    742         struct mtx              rl_intlock;
    743886        int                     rl_txstart;
    744         int                     rl_link;
     887        uint32_t                rl_flags;
     888#define RL_FLAG_MSI             0x0001
     889#define RL_FLAG_AUTOPAD         0x0002
     890#define RL_FLAG_PHYWAKE         0x0008
     891#define RL_FLAG_NOJUMBO         0x0010
     892#define RL_FLAG_PAR             0x0020
     893#define RL_FLAG_DESCV2          0x0040
     894#define RL_FLAG_MACSTAT         0x0080
     895#define RL_FLAG_FASTETHER       0x0100
     896#define RL_FLAG_CMDSTOP         0x0200
     897#define RL_FLAG_MACRESET        0x0400
     898#define RL_FLAG_WOLRXENB        0x1000
     899#define RL_FLAG_MACSLEEP        0x2000
     900#define RL_FLAG_PCIE            0x4000
     901#define RL_FLAG_LINK            0x8000
    745902};
    746903
     
    787944
    788945#define RL_TIMEOUT              1000
     946#define RL_PHY_TIMEOUT          2000
    789947
    790948/*
  • bsd_eth_drivers/libbsdport/alldrv.c

    rd766703 rab325ab  
    1010        &libbsdport_bge_driver,
    1111        &libbsdport_re_driver,
     12        &libbsdport_rl_driver,
    1213        0
    1314};
     
    2728extern driver_t libbsdport_re_driver
    2829        __attribute__((weak,alias("libbsdport_null_driver")));
     30extern driver_t libbsdport_rl_driver
     31        __attribute__((weak,alias("libbsdport_null_driver")));
    2932
    3033
  • bsd_eth_drivers/libbsdport/bus.h

    rd766703 rab325ab  
    6666        }\
    6767}
    68 
    6968BUS_SPACE_DECL(u_int32_t, long, 4)
    7069BUS_SPACE_DECL(u_int16_t, word, 2)
     
    122121#endif
    123122
     123#define bus_space_write_stream_4(_t, _h, _o, _v) \
     124  bus_space_write_4(_t, _h, _o, htole32(_v))
    124125
    125126#undef BUS_SPACE_DECL
  • bsd_eth_drivers/libbsdport/libbsdport.h

    rd766703 rab325ab  
    360360#define if_link_state_change(ifp, state) do {} while (0)
    361361
     362#define if_maddr_rlock(ifp) do {} while (0)
     363#define if_maddr_runlock(ifp) do {} while (0)
     364
    362365/* if_name should probably be const char * but isn't */
    363366#define if_initname(ifp, name, unit) \
  • bsd_eth_drivers/libbsdport/libbsdport_api.h

    rd766703 rab325ab  
    3232extern driver_t libbsdport_pcn_driver;
    3333
    34 /* RealTek RTL8139, 8168, 8169, 8169S, 8110, 8101E, and 8111 PCI */
     34/* RealTek RTL8139C+, 8168, 8169, 8169S, 8110, 8101E, and 8111 PCI */
    3535extern driver_t libbsdport_re_driver;
     36
     37/* RealTek RTL8139 PCI */
     38extern driver_t libbsdport_rl_driver;
    3639
    3740/* AMD/Lance older (and later) chips; this driver also supports what 'pcn'
  • bsd_eth_drivers/libbsdport/libbsdport_post.h

    rd766703 rab325ab  
    2424#define IFF_DRV_RUNNING IFF_RUNNING
    2525#define IFF_DRV_OACTIVE IFF_OACTIVE
    26 
    27 /* FIXME: should implement m_defrag() */
    28 #define m_defrag(m_headp, opt) NULL
    2926
    3027static inline struct mbuf *
  • bsd_eth_drivers/libbsdport/misc.c

    rd766703 rab325ab  
     1
     2#include <libbsdport.h>
     3
     4#include <sys/param.h>
     5#include <sys/systm.h>
     6#include <sys/kernel.h>
     7#include <sys/socket.h>
     8#include <sys/sysctl.h>
     9#include <sys/taskqueue.h>
     10#include <sys/mbuf.h>
     11
     12#include <net/if.h>
     13#include <net/if_arp.h>
     14#include <net/ethernet.h>
     15#include <net/if_dl.h>
     16#include <net/if_media.h>
     17#include <net/if_types.h>
     18
     19#include <libbsdport_post.h>
     20
    121int libbsdport_bootverbose = 0;
     22
     23#ifdef WITNESS
     24#define MBUF_CHECKSLEEP(how) do {\
     25  if (how == M_WAITOK)\
     26  WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,\
     27               "Sleeping in \"%s\"", __func__);\
     28  } while (0)
     29#else
     30#define MBUF_CHECKSLEEP(how)
     31#endif
     32
     33#define MBTOM(how)(how)
     34
     35u_int
     36m_length(struct mbuf *m0, struct mbuf **last)
     37{
     38  struct mbuf *m;
     39  u_int len;
     40
     41  len = 0;
     42  for (m = m0; m != NULL; m = m->m_next) {
     43    len += m->m_len;
     44    if (m->m_next == NULL)
     45      break;
     46  }
     47  if (last != NULL)
     48    *last = m;
     49  return (len);
     50}
     51
     52/*
     53 * Duplicate "from"'s mbuf pkthdr in "to".
     54 * "from" must have M_PKTHDR set, and "to" must be empty.
     55 * In particular, this does a deep copy of the packet tags.
     56 */
     57int
     58m_dup_pkthdr(struct mbuf *to, struct mbuf *from, int how)
     59{
     60
     61  #if 0
     62  /*
     63   * The mbuf allocator only initializes the pkthdr
     64   * when the mbuf is allocated with MGETHDR. Many users
     65   * (e.g. m_copy*, m_prepend) use MGET and then
     66   * smash the pkthdr as needed causing these
     67   * assertions to trip.  For now just disable them.
     68   */
     69  M_ASSERTPKTHDR(to);
     70  /* Note: with MAC, this may not be a good assertion. */
     71  KASSERT(SLIST_EMPTY(&to->m_pkthdr.tags), ("m_dup_pkthdr: to has tags"));
     72  #endif
     73  MBUF_CHECKSLEEP(how);
     74  #ifdef MAC
     75  if (to->m_flags & M_PKTHDR)
     76    m_tag_delete_chain(to, NULL);
     77  #endif
     78  to->m_flags = (from->m_flags & M_COPYFLAGS) | (to->m_flags & M_EXT);
     79  if ((to->m_flags & M_EXT) == 0)
     80    to->m_data = to->m_pktdat;
     81  to->m_pkthdr = from->m_pkthdr;
     82  return 1;
     83}
     84
     85u_int
     86m_fixhdr(struct mbuf *m0)
     87{
     88  u_int len;
     89
     90  len = m_length(m0, NULL);
     91  m0->m_pkthdr.len = len;
     92  return (len);
     93}
     94
     95/*
     96 * Defragment a mbuf chain, returning the shortest possible
     97 * chain of mbufs and clusters.  If allocation fails and
     98 * this cannot be completed, NULL will be returned, but
     99 * the passed in chain will be unchanged.  Upon success,
     100 * the original chain will be freed, and the new chain
     101 * will be returned.
     102 *
     103 * If a non-packet header is passed in, the original
     104 * mbuf (chain?) will be returned unharmed.
     105 */
     106struct mbuf *
     107m_defrag(struct mbuf *m0, int how)
     108{
     109  struct mbuf *m_new = NULL, *m_final = NULL;
     110  int progress = 0, length;
     111
     112  MBUF_CHECKSLEEP(how);
     113  if (!(m0->m_flags & M_PKTHDR))
     114    return (m0);
     115
     116  m_fixhdr(m0); /* Needed sanity check */
     117
     118  #ifdef MBUF_STRESS_TEST
     119  if (m_defragrandomfailures) {
     120    int temp = arc4random() & 0xff;
     121    if (temp == 0xba)
     122      goto nospace;
     123  }
     124  #endif
     125
     126  if (m0->m_pkthdr.len > MHLEN)
     127    m_final = m_getcl(how, MT_DATA, M_PKTHDR);
     128  else
     129    m_final = m_gethdr(how, MT_DATA);
     130
     131  if (m_final == NULL)
     132    goto nospace;
     133
     134  if (m_dup_pkthdr(m_final, m0, how) == 0)
     135    goto nospace;
     136
     137  m_new = m_final;
     138
     139  while (progress < m0->m_pkthdr.len) {
     140    length = m0->m_pkthdr.len - progress;
     141    if (length > MCLBYTES)
     142      length = MCLBYTES;
     143
     144    if (m_new == NULL) {
     145      if (length > MLEN)
     146        m_new = m_getcl(how, MT_DATA, 0);
     147      else
     148        m_new = m_get(how, MT_DATA);
     149      if (m_new == NULL)
     150        goto nospace;
     151    }
     152
     153    m_copydata(m0, progress, length, mtod(m_new, caddr_t));
     154    progress += length;
     155    m_new->m_len = length;
     156    if (m_new != m_final)
     157      m_cat(m_final, m_new);
     158    m_new = NULL;
     159  }
     160  #ifdef MBUF_STRESS_TEST
     161  if (m0->m_next == NULL)
     162    m_defraguseless++;
     163  #endif
     164  m_freem(m0);
     165  m0 = m_final;
     166  #ifdef MBUF_STRESS_TEST
     167  m_defragpackets++;
     168  m_defragbytes += m0->m_pkthdr.len;
     169  #endif
     170  return (m0);
     171  nospace:
     172  #ifdef MBUF_STRESS_TEST
     173  m_defragfailure++;
     174  #endif
     175  if (m_final)
     176    m_freem(m_final);
     177  return (NULL);
     178}
     179
  • bsd_eth_drivers/libbsdport/sysbus.c

    rd766703 rab325ab  
    188188                        return EINVAL;
    189189                } else if ( !dev->drv->methods->irq_check_dis ) {
    190                         device_printf(dev, "bus_setup_intr: driver has no 'irq_dis' method\n");
     190                        device_printf(dev, "bus_setup_intr: driver has no 'irq_check_dis' method\n");
    191191                        return EINVAL;
    192192                }
Note: See TracChangeset for help on using the changeset viewer.