net80211: validate control frame TA/RA before further processing

[adrian]

Summary

An earlier commit relaxed the TA/RA rules around control frames
to fix other issues, however it now results in control frames
not specifically from a known node / to us to be handled in the control
path.

Specifically, rtwn(4) RTL8812/RTL8821 NICs are currently passing BARs
from the AP TA to any destination to us; which is tripping up BAW
tracking and causing traffic hangs.

[adrian]

sys/net80211/ieee80211_adhoc.c

1056

I should migrate the ic_printf() calls to if_printf() like I did above.

(also we really should have a ieee80211_ic_printf() and ieee80211_vap_printf(), and _log() too, to make portability easier, sigh.)

[bz]

sys/net80211/ieee80211.c

2751

add the "int subtype" as argument; all callers have it.

2754

Can we save this and just expand it in the one use case?

2759

I would argue this should be a KASSERT; if you get there without it being a ctrl frame we are screwed.

2764

false

2767

switch (subtype) {
case IEEE80211_FC0_SUBTYPE_CTS:
case IEEE80211_FC0_SUBTYPE_ACK:
     /* No TA. */
     break;
default:
     /* XXX check TA here; log on error; return false on error. Feel free to leave as a comment for now. */
     break;
}

sys/net80211/ieee80211_adhoc.c

1054

Move wh into the if() block to keep it local; don't initialise if it may never be used.

1055

No space after !

1056

I think we need a shorted "internal" prefix other than ieee80211 for non-standard things. Or at least call it net80211_foo; I know I am 20 years late with that but ...

vap_printf() instead of adding more if_printf I would prefer for sure.

#define vap_printf(vap, fmt, ...)      if_printf(vap->iv_ifp, fmt, ##__VA_ARGS__)

And then make a full pass over all if_printf so that one only remains, just this one ...

1056

I'd also suggest to move the printf into your function as once you start checking TA there as well, you won't know anymore which one failed.

sys/net80211/ieee80211_hostap.c

2426

! no space;

next line indent

[adrian]

clean ups; feedback from bz

(still have a bunch more to do)

[adrian]

What do y'all think about defining calls to vap->iv_recv_ctl() as receiving "only frames from a known node (where possible), destined to this vap MAC address", so the filtering can be done /before/ the call to vap->iv_recv_ctl() ?

I think that was the intended / previous behaviour of this, before all the various monitor modes, hybrid modes, etc popped up.

[bz]

In D49575#1130371, @adrian wrote:

What do y'all think about defining calls to vap->iv_recv_ctl() as receiving "only frames from a known node (where possible), destined to this vap MAC address", so the filtering can be done /before/ the call to vap->iv_recv_ctl() ?

I think that was the intended / previous behaviour of this, before all the various monitor modes, hybrid modes, etc popped up.

I assume it's a 1:1; given you so nicely factored it out into a function the only question is where is error handling easier but I think what you are saying makes sense so please go ahead and move them.

sys/net80211/ieee80211.c

2757

if you do this do it before you need it. You have returns before that.

2762

With the KASSERT the if() has become useless.

[adrian]

sys/net80211/ieee80211.c

2762

With the KASSERT the if() has become useless.

No, because KASSERT()s aren't compiled in when INVARIANTS isn't enabled. We still need to handle the error case gracefully otherwise it becomes undefined behaviour.

[adrian]

migrate the check to before vap->iv_recv_ctl() is called

[adrian]

sys/net80211/ieee80211_adhoc.c

1056

I think we need a shorted "internal" prefix other than ieee80211 for non-standard things. Or at least call it net80211_foo; I know I am 20 years late with that but ...

vap_printf() instead of adding more if_printf I would prefer for sure.

#define vap_printf(vap, fmt, ...)      if_printf(vap->iv_ifp, fmt, ##__VA_ARGS__)

And then make a full pass over all if_printf so that one only remains, just this one ...

I'll add this as another specific clean-up to do once I've landed these diffs.

.. and when you're OK with the timing too, as it could make general merging a pain. :-)

[bz]

sys/net80211/ieee80211_adhoc.c

1056

👍 Merging is fine; it'll be net80211 internal so could even be merged; need to see anyway what we do about some MFCs for 14 at some point... but leave that for another day too. &

[jrtc27]

sys/net80211/ieee80211.c

2762

The reason KASSERTs are compiled out is to optimise the code, but if you want to have an explicit check in the code anyway regardless then it serves no purpose, you might as well do if (...) panic(...) and save the weird "treat as both assertion and graceful error".

[adrian]

sys/net80211/ieee80211.c

2762

I don't ENTIRELY like it either. I think it's worth thinking of some better ways to abstract this out in net80211 so we can do graceful error handling and print out warnings / panic where needed.

In any case I'm not fussed about this, I'm much more worried about making sure that BARs and other control frames destined to this node and from a valid sender MAC are verified.

[imp]

sys/net80211/ieee80211.c

2762

We have NASSERT at work for this...

[adrian]

sys/net80211/ieee80211.c

2781

Should this be IF_LLADDR(vap->iv_ifp) or vap->iv_myaddr?

It looks like ieee80211_freebsd.c:wlan_iflladdr() copies the LLADDR into vap->iv_myaddr. And thus maybe we shouldn't be using IF_LLADDR anywhere?

[adrian]

more updates from bz/jrtc27

[adrian]

@jrtc27 would you mind testing this and do some dtrace probing to make sure ieee80211_recv_bar() is only called when there's a BAR specifically for you? And it's still actually getting called? I'm super paranoid about actually breaking /all/ control traffic now. :-)

My home network APs don't send BARs. I know FreeBSD's ath(4) AP will send BARs, so I'll go create a test case or two that forcibly does BARs, but i'll be a few days before I can get all of that together.

[jrtc27]

In D49575#1130515, @adrian wrote:

@jrtc27 would you mind testing this and do some dtrace probing to make sure ieee80211_recv_bar() is only called when there's a BAR specifically for you? And it's still actually getting called? I'm super paranoid about actually breaking /all/ control traffic now. :-)

My home network APs don't send BARs. I know FreeBSD's ath(4) AP will send BARs, so I'll go create a test case or two that forcibly does BARs, but i'll be a few days before I can get all of that together.

I can try to do that tomorrow (and pick up testing the input errors for protected networks issue).

[jrtc27]

https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=285821 now filed with the important details for reproducing

sys/net80211/ieee80211.c

 static int        rt_detach(device_t dev);
 static int        rt_shutdown(device_t dev);
 static int        rt_suspend(device_t dev);
 static int        rt_resume(device_t dev);
 static void        rt_init_locked(void *priv);
 static void        rt_init(void *priv);
 static void        rt_stop_locked(void *priv);
 static void        rt_stop(void *priv);
-static void        rt_start(struct ifnet *ifp);
-static int        rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
+static void        rt_start(if_t ifp);
+static int        rt_ioctl(if_t ifp, u_long cmd, caddr_t data);
 static void        rt_tx_watchdog(void *arg);
 static void        rt_intr(void *arg);
 static void        rt_rt5350_intr(void *arg);
 static void        rt_tx_coherent_intr(struct rt_softc *sc);
 static void        rt_rx_coherent_intr(struct rt_softc *sc);
 static void        rt_rx_delay_intr(struct rt_softc *sc);
 static void        rt_tx_delay_intr(struct rt_softc *sc);
 static void        rt_rx_intr(struct rt_softc *sc, int qid);

 static void        rt_sysctl_attach(struct rt_softc *sc);
 #ifdef IF_RT_PHY_SUPPORT
 void            rt_miibus_statchg(device_t);
 #endif
 #if defined(IF_RT_PHY_SUPPORT) || defined(RT_MDIO)
 static int        rt_miibus_readreg(device_t, int, int);
 static int        rt_miibus_writereg(device_t, int, int, int);
 #endif
-static int        rt_ifmedia_upd(struct ifnet *);
-static void        rt_ifmedia_sts(struct ifnet *, struct ifmediareq *);
+static int        rt_ifmedia_upd(if_t );
+static void        rt_ifmedia_sts(if_t , struct ifmediareq *);
 
 static SYSCTL_NODE(_hw, OID_AUTO, rt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "RT driver parameters");
 #ifdef IF_RT_DEBUG
 static int rt_debug = 0;
 SYSCTL_INT(_hw_rt, OID_AUTO, debug, CTLFLAG_RWTUN, &rt_debug, 0,
     "RT debug level");
 #endif
reset_freng(struct rt_softc *sc)
         /* XXX hard reset kills everything so skip it ... */
         return;
 }
 
 static int
 rt_attach(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int error, i;
 #ifdef FDT
         phandle_t node;
         char fdtval[32];
 #endif
 
         sc = device_get_softc(dev);
         sc->dev = dev;
#endif
 
         ifp = sc->ifp = if_alloc(IFT_ETHER);
         if (ifp == NULL) {
                 device_printf(dev, "could not if_alloc()\n");
                 error = ENOMEM;
                 goto fail;
         }
 
-        ifp->if_softc = sc;
+        if_setsoftc(ifp, sc);
         if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev));
-        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
-        ifp->if_init = rt_init;
-        ifp->if_ioctl = rt_ioctl;
-        ifp->if_start = rt_start;
+        if_setflags(ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
+        if_setinitfn(ifp, rt_init);
+        if_setioctlfn(ifp, rt_ioctl);
+        if_setstartfn(ifp, rt_start);
 #define RT_TX_QLEN      256
 
-        IFQ_SET_MAXLEN(&ifp->if_snd, RT_TX_QLEN);
-        ifp->if_snd.ifq_drv_maxlen = RT_TX_QLEN;
-        IFQ_SET_READY(&ifp->if_snd);
+        if_setsendqlen(ifp, RT_TX_QLEN);
+        if_setsendqready(ifp);
 
 #ifdef IF_RT_PHY_SUPPORT
         error = mii_attach(dev, &sc->rt_miibus, ifp, rt_ifmedia_upd,
             rt_ifmedia_sts, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0);
         if (error != 0) {
                 device_printf(dev, "attaching PHYs failed\n");
                 error = ENXIO;
                 goto fail;
         }
 #else
         ifmedia_init(&sc->rt_ifmedia, 0, rt_ifmedia_upd, rt_ifmedia_sts);
         ifmedia_add(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX, 0,
             NULL);
         ifmedia_set(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX);
 
 #endif /* IF_RT_PHY_SUPPORT */
 
         ether_request_mac(dev, sc->mac_addr);
         ether_ifattach(ifp, sc->mac_addr);
 
         /*
          * Tell the upper layer(s) we support long frames.
          */
-        ifp->if_hdrlen = sizeof(struct ether_vlan_header);
-        ifp->if_capabilities |= IFCAP_VLAN_MTU;
-        ifp->if_capenable |= IFCAP_VLAN_MTU;
-        ifp->if_capabilities |= IFCAP_RXCSUM|IFCAP_TXCSUM;
-        ifp->if_capenable |= IFCAP_RXCSUM|IFCAP_TXCSUM;
+        if_setifheaderlen(ifp, sizeof(struct ether_vlan_header));
+        if_setcapabilitiesbit(ifp, IFCAP_VLAN_MTU, 0);
+        if_setcapenablebit(ifp, IFCAP_VLAN_MTU, 0);
+        if_setcapabilitiesbit(ifp, IFCAP_RXCSUM|IFCAP_TXCSUM, 0);
+        if_setcapenablebit(ifp, IFCAP_RXCSUM|IFCAP_TXCSUM, 0);
 
         /* init task queue */
         NET_TASK_INIT(&sc->rx_done_task, 0, rt_rx_done_task, sc);
         TASK_INIT(&sc->tx_done_task, 0, rt_tx_done_task, sc);
 
         sc->rx_process_limit = 100;
 
         sc->taskqueue = taskqueue_create("rt_taskq", M_NOWAIT,
fail:
 
         return (error);
 }
 
 /*
  * Set media options.
  */
 static int
-rt_ifmedia_upd(struct ifnet *ifp)
+rt_ifmedia_upd(if_t ifp)
 {
         struct rt_softc *sc;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
         struct mii_softc *miisc;
         int error = 0;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         RT_SOFTC_LOCK(sc);
 
         mii = device_get_softc(sc->rt_miibus);
         LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
                 PHY_RESET(miisc);
         error = mii_mediachg(mii);
         RT_SOFTC_UNLOCK(sc);
 
         return (error);
 
 #else /* !IF_RT_PHY_SUPPORT */
 
         struct ifmedia *ifm;
         struct ifmedia_entry *ife;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         ifm = &sc->rt_ifmedia;
         ife = ifm->ifm_cur;
 
         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
                 return (EINVAL);
 
         if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
                 device_printf(sc->dev,
                     "AUTO is not supported for multiphy MAC");
                 return (EINVAL);
         }
 
         /*
          * Ignore everything
          */
         return (0);
 #endif /* IF_RT_PHY_SUPPORT */
 }
 
 /*
  * Report current media status.
  */
 static void
-rt_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
+rt_ifmedia_sts(if_t ifp, struct ifmediareq *ifmr)
 {
 #ifdef IF_RT_PHY_SUPPORT
         struct rt_softc *sc;
         struct mii_data *mii;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
 
         RT_SOFTC_LOCK(sc);
         mii = device_get_softc(sc->rt_miibus);
         mii_pollstat(mii);
         ifmr->ifm_active = mii->mii_media_active;
         ifmr->ifm_status = mii->mii_media_status;
         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
         RT_SOFTC_UNLOCK(sc);
 #else /* !IF_RT_PHY_SUPPORT */
 
         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
 #endif /* IF_RT_PHY_SUPPORT */
 }
 
 static int
 rt_detach(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int i;
 
         sc = device_get_softc(dev);
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "detaching\n");
 
         RT_SOFTC_LOCK(sc);
-        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
         callout_stop(&sc->tx_watchdog_ch);
         RT_SOFTC_UNLOCK(sc);
 
         taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
         taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
         taskqueue_drain_timeout(sc->taskqueue, &sc->periodic_task);
 
         /* free Tx and Rx rings */
rt_suspend(device_t dev)
 
         return (0);
 }
 
 static int
 rt_resume(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = device_get_softc(dev);
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "resuming\n");
 
-        if (ifp->if_flags & IFF_UP)
+        if (if_getflags(ifp) & IFF_UP)
                 rt_init(sc);
 
         return (0);
 }
 
 /*
  * rt_init_locked - Run initialization process having locked mtx.
  */
 static void
 rt_init_locked(void *priv)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
 #endif
         int i, ntries;
         uint32_t tmp;
 
         sc = priv;
         ifp = sc->ifp;
#endif
 
         if (rt_txrx_enable(sc) != 0)
                 goto fail;
 
 #ifdef IF_RT_PHY_SUPPORT
         if (mii) mii_mediachg(mii);
 #endif /* IF_RT_PHY_SUPPORT */
 
-        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
-        ifp->if_drv_flags |= IFF_DRV_RUNNING;
+        if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, IFF_DRV_RUNNING, 0);
 
         sc->periodic_round = 0;
 
         taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task, hz / 10);
 
         return;
 
 fail:

 
 /*
  * rt_stop_locked - stop TX/RX w/ lock
  */
 static void
 rt_stop_locked(void *priv)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = priv;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "stopping\n");
 
         RT_SOFTC_ASSERT_LOCKED(sc);
         sc->tx_timer = 0;
-        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
         callout_stop(&sc->tx_watchdog_ch);
         RT_SOFTC_UNLOCK(sc);
         taskqueue_block(sc->taskqueue);
 
         /*
          * Sometime rt_stop_locked called from isr and we get panic
          * When found, I fix it
          */

 }
 
 /*
  * rt_tx_data - transmit packet.
  */
 static int
 rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         struct rt_softc_tx_ring *ring;
         struct rt_softc_tx_data *data;
         struct rt_txdesc *desc;
         struct mbuf *m_d;
         bus_dma_segment_t dma_seg[RT_SOFTC_MAX_SCATTER];
         int error, ndmasegs, ndescs, i;
 
         KASSERT(qid >= 0 && qid < RT_SOFTC_TX_RING_COUNT,
for (i = 0; i < ndmasegs; i += 2) {
                  * one doesn't use word3 at all). And so does MT7621...
                  */
 
                 if (sc->rt_chipid != RT_CHIPID_MT7621) {
                         /* Set destination */
                         if (sc->rt_chipid != RT_CHIPID_MT7620)
                             desc->dst = (TXDSCR_DST_PORT_GDMA1);
 
-                        if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)
+                        if ((if_getcapenable(ifp) & IFCAP_TXCSUM) != 0)
                                 desc->dst |= (TXDSCR_IP_CSUM_GEN |
                                     TXDSCR_UDP_CSUM_GEN | TXDSCR_TCP_CSUM_GEN);
                         /* Set queue id */
                         desc->qn = qid;
                         /* No PPPoE */
                         desc->pppoe = 0;
                         /* No VLAN */
                         desc->vid = 0;
rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
 
         return (0);
 }
 
 /*
  * rt_start - start Transmit/Receive
  */
 static void
-rt_start(struct ifnet *ifp)
+rt_start(if_t ifp)
 {
         struct rt_softc *sc;
         struct mbuf *m;
         int qid = 0 /* XXX must check QoS priority */;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         for (;;) {
-                IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
+                m = if_dequeue(ifp);
                 if (m == NULL)
                         break;
 
                 m->m_pkthdr.rcvif = NULL;
 
                 RT_SOFTC_TX_RING_LOCK(&sc->tx_ring[qid]);
 
                 if (sc->tx_ring[qid].data_queued >=
                     RT_SOFTC_TX_RING_DATA_COUNT) {
                         RT_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
 
                         RT_DPRINTF(sc, RT_DEBUG_TX,
                             "if_start: Tx ring with qid=%d is full\n", qid);
 
                         m_freem(m);
 
-                        ifp->if_drv_flags |= IFF_DRV_OACTIVE;
+                        if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);
                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 
                         sc->tx_data_queue_full[qid]++;
 
                         break;
                 }
 
                 if (rt_tx_data(sc, m, qid) != 0) {
rt_start(if_t ifp)
         }
 }
 
 /*
  * rt_update_promisc - set/clear promiscuous mode. Unused yet, because
  * filtering done by attached Ethernet switch.
  */
 static void
-rt_update_promisc(struct ifnet *ifp)
+rt_update_promisc(if_t ifp)
 {
         struct rt_softc *sc;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         printf("%s: %s promiscuous mode\n",
                 device_get_nameunit(sc->dev),
-                (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving");
+                (if_getflags(ifp) & IFF_PROMISC) ? "entering" : "leaving");
 }
 
 /*
  * rt_ioctl - ioctl handler.
  */
 static int
-rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
+rt_ioctl(if_t ifp, u_long cmd, caddr_t data)
 {
         struct rt_softc *sc;
         struct ifreq *ifr;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
 #endif /* IF_RT_PHY_SUPPORT */
         int error, startall;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         ifr = (struct ifreq *) data;
 
         error = 0;
 
         switch (cmd) {
         case SIOCSIFFLAGS:
                 startall = 0;
                 RT_SOFTC_LOCK(sc);
-                if (ifp->if_flags & IFF_UP) {
-                        if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
-                                if ((ifp->if_flags ^ sc->if_flags) &
+                if (if_getflags(ifp) & IFF_UP) {
+                        if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
+                                if ((if_getflags(ifp) ^ sc->if_flags) &
                                     IFF_PROMISC)
                                         rt_update_promisc(ifp);
                         } else {
                                 rt_init_locked(sc);
                                 startall = 1;
                         }
                 } else {
-                        if (ifp->if_drv_flags & IFF_DRV_RUNNING)
+                        if (if_getdrvflags(ifp) & IFF_DRV_RUNNING)
                                 rt_stop_locked(sc);
                 }
-                sc->if_flags = ifp->if_flags;
+                sc->if_flags = if_getflags(ifp);
                 RT_SOFTC_UNLOCK(sc);
                 break;
         case SIOCGIFMEDIA:
         case SIOCSIFMEDIA:
 #ifdef IF_RT_PHY_SUPPORT
                 mii = device_get_softc(sc->rt_miibus);
                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
 #else

 
 /*
  * rt_tx_watchdog - Handler of TX Watchdog
  */
 static void
 rt_tx_watchdog(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = arg;
         ifp = sc->ifp;
 
         if (sc->tx_timer == 0)
                 return;
 
         if (--sc->tx_timer == 0) {

 
 /*
  * rt_intr - main ISR
  */
 static void
 rt_intr(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t status;
 
         sc = arg;
         ifp = sc->ifp;
 
         /* acknowledge interrupts */
         status = RT_READ(sc, sc->fe_int_status);
         RT_WRITE(sc, sc->fe_int_status, status);
 
         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
 
         if (status == 0xffffffff ||        /* device likely went away */
                 status == 0)            /* not for us */
                 return;
 
         sc->interrupts++;
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         if (status & CNT_PPE_AF)
                 rt_cnt_ppe_af(sc);
 
         if (status & CNT_GDM_AF)
                 rt_cnt_gdm_af(sc);
 

 
 /*
  * rt_rt5350_intr - main ISR for Ralink 5350 SoC
  */
 static void
 rt_rt5350_intr(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t status;
 
         sc = arg;
         ifp = sc->ifp;
 
         /* acknowledge interrupts */
         status = RT_READ(sc, sc->fe_int_status);
         RT_WRITE(sc, sc->fe_int_status, status);
 
         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
 
         if (status == 0xffffffff ||     /* device likely went away */
                 status == 0)            /* not for us */
                 return;
 
         sc->interrupts++;
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         if (status & RT5350_INT_TX_COHERENT)
                 rt_tx_coherent_intr(sc);
         if (status & RT5350_INT_RX_COHERENT)
                 rt_rx_coherent_intr(sc);
         if (status & RT5350_RX_DLY_INT)
                 rt_rx_delay_intr(sc);

 
 /*
  * rt_rx_done_task - run RX task
  */
 static void
 rt_rx_done_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int again;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_RX, "Rx done task\n");
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         sc->intr_pending_mask &= ~sc->int_rx_done_mask;
 
         again = rt_rx_eof(sc, &sc->rx_ring[0], sc->rx_process_limit);
 
         RT_SOFTC_LOCK(sc);
 

 
 /*
  * rt_tx_done_task - check for pending TX task in all queues
  */
 static void
 rt_tx_done_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t intr_mask;
         int i;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_TX, "Tx done task\n");
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         for (i = RT_SOFTC_TX_RING_COUNT - 1; i >= 0; i--) {
                 if (sc->intr_pending_mask & (sc->int_tx_done_mask << i)) {
                         sc->intr_pending_mask &= ~(sc->int_tx_done_mask << i);
                         rt_tx_eof(sc, &sc->tx_ring[i]);
                 }
         }
 
         sc->tx_timer = 0;
 
-        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
+        if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
 
         if(sc->rt_chipid == RT_CHIPID_RT5350 ||
            sc->rt_chipid == RT_CHIPID_MT7620 ||
            sc->rt_chipid == RT_CHIPID_MT7621)
           intr_mask = (
                 RT5350_INT_TXQ3_DONE |
                 RT5350_INT_TXQ2_DONE |
                 RT5350_INT_TXQ1_DONE |
rt_tx_done_task(void *context, int pending)
         if (sc->intr_pending_mask & intr_mask) {
                 RT_DPRINTF(sc, RT_DEBUG_TX,
                     "Tx done task: scheduling again\n");
                 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
         }
 
         RT_SOFTC_UNLOCK(sc);
 
-        if (!IFQ_IS_EMPTY(&ifp->if_snd))
+        if (!if_sendq_empty(ifp))
                 rt_start(ifp);
 }
 
 /*
  * rt_periodic_task - run periodic task
  */
 static void
 rt_periodic_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_PERIODIC, "periodic task: round=%lu\n",
             sc->periodic_round);
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         RT_SOFTC_LOCK(sc);
         sc->periodic_round++;
         rt_update_stats(sc);
 
         if ((sc->periodic_round % 10) == 0) {
                 rt_update_raw_counters(sc);
                 rt_watchdog(sc);
         }
 
         RT_SOFTC_UNLOCK(sc);
         taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task, hz / 10);
 }
 
 /*
  * rt_rx_eof - check for frames that done by DMA engine and pass it into
  * network subsystem.
  */
 static int
 rt_rx_eof(struct rt_softc *sc, struct rt_softc_rx_ring *ring, int limit)
 {
-        struct ifnet *ifp;
+        if_t ifp;
 /*      struct rt_softc_rx_ring *ring; */
         struct rt_rxdesc *desc;
         struct rt_softc_rx_data *data;
         struct mbuf *m, *mnew;
         bus_dma_segment_t segs[1];
         bus_dmamap_t dma_map;
         uint32_t index, desc_flags;
         int error, nsegs, len, nframes;
RT_DPRINTF(sc, RT_DEBUG_RX,
                     "Rx frame: rxdesc flags=0x%08x\n", desc_flags);
 
                 m->m_pkthdr.rcvif = ifp;
                 /* Add 2 to fix data align, after sdp0 = addr + 2 */
                 m->m_data += 2;
                 m->m_pkthdr.len = m->m_len = len;
 
                 /* check for crc errors */
-                if ((ifp->if_capenable & IFCAP_RXCSUM) != 0) {
+                if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0) {
                         /*check for valid checksum*/
                         if (desc_flags & (sc->csum_fail_ip|sc->csum_fail_l4)) {
                                 RT_DPRINTF(sc, RT_DEBUG_RX,
                                     "rxdesc: crc error\n");
 
                                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 
-                                if (!(ifp->if_flags & IFF_PROMISC)) {
+                                if (!(if_getflags(ifp) & IFF_PROMISC)) {
                                     m_freem(m);
                                     goto skip;
                                 }
                         }
                         if ((desc_flags & sc->csum_fail_ip) == 0) {
                                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
                                 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
                                 m->m_pkthdr.csum_data = 0xffff;
                         }
                         m->m_flags &= ~M_HASFCS;
                 }
 
-                (*ifp->if_input)(ifp, m);
+                if_input(ifp, m);
 skip:
                 desc->sdl0 &= ~htole16(RT_RXDESC_SDL0_DDONE);
 
                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
                         BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 
                 ring->cur = (ring->cur + 1) % RT_SOFTC_RX_RING_DATA_COUNT;
 

 
 /*
  * rt_tx_eof - check for successful transmitted frames and mark their
  * descriptor as free.
  */
 static void
 rt_tx_eof(struct rt_softc *sc, struct rt_softc_tx_ring *ring)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         struct rt_txdesc *desc;
         struct rt_softc_tx_data *data;
         uint32_t index;
         int ndescs, nframes;
 
         ifp = sc->ifp;
 
         ndescs = 0;

 }
 
 /*
  * rt_update_stats - query statistics counters and update related variables.
  */
 static void
 rt_update_stats(struct rt_softc *sc)
 {
-        struct ifnet *ifp;
+        if_t ifp;
 
         ifp = sc->ifp;
         RT_DPRINTF(sc, RT_DEBUG_STATS, "update statistic: \n");
         /* XXX do update stats here */
 }
 
 /*
  * rt_watchdog - reinit device on watchdog event.

 }
 
 /*
  * rt_txrx_enable - enable TX/RX DMA
  */
 static int
 rt_txrx_enable(struct rt_softc *sc)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t tmp;
         int ntries;
 
         ifp = sc->ifp;
 
         /* enable Tx/Rx DMA engine */
         for (ntries = 0; ntries < 200; ntries++) {
                 tmp = RT_READ(sc, sc->pdma_glo_cfg);

sys/net80211/ieee80211_adhoc.c

 static int        rt_detach(device_t dev);
 static int        rt_shutdown(device_t dev);
 static int        rt_suspend(device_t dev);
 static int        rt_resume(device_t dev);
 static void        rt_init_locked(void *priv);
 static void        rt_init(void *priv);
 static void        rt_stop_locked(void *priv);
 static void        rt_stop(void *priv);
-static void        rt_start(struct ifnet *ifp);
-static int        rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
+static void        rt_start(if_t ifp);
+static int        rt_ioctl(if_t ifp, u_long cmd, caddr_t data);
 static void        rt_tx_watchdog(void *arg);
 static void        rt_intr(void *arg);
 static void        rt_rt5350_intr(void *arg);
 static void        rt_tx_coherent_intr(struct rt_softc *sc);
 static void        rt_rx_coherent_intr(struct rt_softc *sc);
 static void        rt_rx_delay_intr(struct rt_softc *sc);
 static void        rt_tx_delay_intr(struct rt_softc *sc);
 static void        rt_rx_intr(struct rt_softc *sc, int qid);

 static void        rt_sysctl_attach(struct rt_softc *sc);
 #ifdef IF_RT_PHY_SUPPORT
 void            rt_miibus_statchg(device_t);
 #endif
 #if defined(IF_RT_PHY_SUPPORT) || defined(RT_MDIO)
 static int        rt_miibus_readreg(device_t, int, int);
 static int        rt_miibus_writereg(device_t, int, int, int);
 #endif
-static int        rt_ifmedia_upd(struct ifnet *);
-static void        rt_ifmedia_sts(struct ifnet *, struct ifmediareq *);
+static int        rt_ifmedia_upd(if_t );
+static void        rt_ifmedia_sts(if_t , struct ifmediareq *);
 
 static SYSCTL_NODE(_hw, OID_AUTO, rt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "RT driver parameters");
 #ifdef IF_RT_DEBUG
 static int rt_debug = 0;
 SYSCTL_INT(_hw_rt, OID_AUTO, debug, CTLFLAG_RWTUN, &rt_debug, 0,
     "RT debug level");
 #endif
reset_freng(struct rt_softc *sc)
         /* XXX hard reset kills everything so skip it ... */
         return;
 }
 
 static int
 rt_attach(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int error, i;
 #ifdef FDT
         phandle_t node;
         char fdtval[32];
 #endif
 
         sc = device_get_softc(dev);
         sc->dev = dev;
#endif
 
         ifp = sc->ifp = if_alloc(IFT_ETHER);
         if (ifp == NULL) {
                 device_printf(dev, "could not if_alloc()\n");
                 error = ENOMEM;
                 goto fail;
         }
 
-        ifp->if_softc = sc;
+        if_setsoftc(ifp, sc);
         if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev));
-        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
-        ifp->if_init = rt_init;
-        ifp->if_ioctl = rt_ioctl;
-        ifp->if_start = rt_start;
+        if_setflags(ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
+        if_setinitfn(ifp, rt_init);
+        if_setioctlfn(ifp, rt_ioctl);
+        if_setstartfn(ifp, rt_start);
 #define RT_TX_QLEN      256
 
-        IFQ_SET_MAXLEN(&ifp->if_snd, RT_TX_QLEN);
-        ifp->if_snd.ifq_drv_maxlen = RT_TX_QLEN;
-        IFQ_SET_READY(&ifp->if_snd);
+        if_setsendqlen(ifp, RT_TX_QLEN);
+        if_setsendqready(ifp);
 
 #ifdef IF_RT_PHY_SUPPORT
         error = mii_attach(dev, &sc->rt_miibus, ifp, rt_ifmedia_upd,
             rt_ifmedia_sts, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0);
         if (error != 0) {
                 device_printf(dev, "attaching PHYs failed\n");
                 error = ENXIO;
                 goto fail;
         }
 #else
         ifmedia_init(&sc->rt_ifmedia, 0, rt_ifmedia_upd, rt_ifmedia_sts);
         ifmedia_add(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX, 0,
             NULL);
         ifmedia_set(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX);
 
 #endif /* IF_RT_PHY_SUPPORT */
 
         ether_request_mac(dev, sc->mac_addr);
         ether_ifattach(ifp, sc->mac_addr);
 
         /*
          * Tell the upper layer(s) we support long frames.
          */
-        ifp->if_hdrlen = sizeof(struct ether_vlan_header);
-        ifp->if_capabilities |= IFCAP_VLAN_MTU;
-        ifp->if_capenable |= IFCAP_VLAN_MTU;
-        ifp->if_capabilities |= IFCAP_RXCSUM|IFCAP_TXCSUM;
-        ifp->if_capenable |= IFCAP_RXCSUM|IFCAP_TXCSUM;
+        if_setifheaderlen(ifp, sizeof(struct ether_vlan_header));
+        if_setcapabilitiesbit(ifp, IFCAP_VLAN_MTU, 0);
+        if_setcapenablebit(ifp, IFCAP_VLAN_MTU, 0);
+        if_setcapabilitiesbit(ifp, IFCAP_RXCSUM|IFCAP_TXCSUM, 0);
+        if_setcapenablebit(ifp, IFCAP_RXCSUM|IFCAP_TXCSUM, 0);
 
         /* init task queue */
         NET_TASK_INIT(&sc->rx_done_task, 0, rt_rx_done_task, sc);
         TASK_INIT(&sc->tx_done_task, 0, rt_tx_done_task, sc);
 
         sc->rx_process_limit = 100;
 
         sc->taskqueue = taskqueue_create("rt_taskq", M_NOWAIT,
fail:
 
         return (error);
 }
 
 /*
  * Set media options.
  */
 static int
-rt_ifmedia_upd(struct ifnet *ifp)
+rt_ifmedia_upd(if_t ifp)
 {
         struct rt_softc *sc;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
         struct mii_softc *miisc;
         int error = 0;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         RT_SOFTC_LOCK(sc);
 
         mii = device_get_softc(sc->rt_miibus);
         LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
                 PHY_RESET(miisc);
         error = mii_mediachg(mii);
         RT_SOFTC_UNLOCK(sc);
 
         return (error);
 
 #else /* !IF_RT_PHY_SUPPORT */
 
         struct ifmedia *ifm;
         struct ifmedia_entry *ife;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         ifm = &sc->rt_ifmedia;
         ife = ifm->ifm_cur;
 
         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
                 return (EINVAL);
 
         if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
                 device_printf(sc->dev,
                     "AUTO is not supported for multiphy MAC");
                 return (EINVAL);
         }
 
         /*
          * Ignore everything
          */
         return (0);
 #endif /* IF_RT_PHY_SUPPORT */
 }
 
 /*
  * Report current media status.
  */
 static void
-rt_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
+rt_ifmedia_sts(if_t ifp, struct ifmediareq *ifmr)
 {
 #ifdef IF_RT_PHY_SUPPORT
         struct rt_softc *sc;
         struct mii_data *mii;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
 
         RT_SOFTC_LOCK(sc);
         mii = device_get_softc(sc->rt_miibus);
         mii_pollstat(mii);
         ifmr->ifm_active = mii->mii_media_active;
         ifmr->ifm_status = mii->mii_media_status;
         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
         RT_SOFTC_UNLOCK(sc);
 #else /* !IF_RT_PHY_SUPPORT */
 
         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
 #endif /* IF_RT_PHY_SUPPORT */
 }
 
 static int
 rt_detach(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int i;
 
         sc = device_get_softc(dev);
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "detaching\n");
 
         RT_SOFTC_LOCK(sc);
-        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
         callout_stop(&sc->tx_watchdog_ch);
         RT_SOFTC_UNLOCK(sc);
 
         taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
         taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
         taskqueue_drain_timeout(sc->taskqueue, &sc->periodic_task);
 
         /* free Tx and Rx rings */
rt_suspend(device_t dev)
 
         return (0);
 }
 
 static int
 rt_resume(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = device_get_softc(dev);
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "resuming\n");
 
-        if (ifp->if_flags & IFF_UP)
+        if (if_getflags(ifp) & IFF_UP)
                 rt_init(sc);
 
         return (0);
 }
 
 /*
  * rt_init_locked - Run initialization process having locked mtx.
  */
 static void
 rt_init_locked(void *priv)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
 #endif
         int i, ntries;
         uint32_t tmp;
 
         sc = priv;
         ifp = sc->ifp;
#endif
 
         if (rt_txrx_enable(sc) != 0)
                 goto fail;
 
 #ifdef IF_RT_PHY_SUPPORT
         if (mii) mii_mediachg(mii);
 #endif /* IF_RT_PHY_SUPPORT */
 
-        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
-        ifp->if_drv_flags |= IFF_DRV_RUNNING;
+        if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, IFF_DRV_RUNNING, 0);
 
         sc->periodic_round = 0;
 
         taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task, hz / 10);
 
         return;
 
 fail:

 
 /*
  * rt_stop_locked - stop TX/RX w/ lock
  */
 static void
 rt_stop_locked(void *priv)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = priv;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "stopping\n");
 
         RT_SOFTC_ASSERT_LOCKED(sc);
         sc->tx_timer = 0;
-        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
         callout_stop(&sc->tx_watchdog_ch);
         RT_SOFTC_UNLOCK(sc);
         taskqueue_block(sc->taskqueue);
 
         /*
          * Sometime rt_stop_locked called from isr and we get panic
          * When found, I fix it
          */

 }
 
 /*
  * rt_tx_data - transmit packet.
  */
 static int
 rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         struct rt_softc_tx_ring *ring;
         struct rt_softc_tx_data *data;
         struct rt_txdesc *desc;
         struct mbuf *m_d;
         bus_dma_segment_t dma_seg[RT_SOFTC_MAX_SCATTER];
         int error, ndmasegs, ndescs, i;
 
         KASSERT(qid >= 0 && qid < RT_SOFTC_TX_RING_COUNT,
for (i = 0; i < ndmasegs; i += 2) {
                  * one doesn't use word3 at all). And so does MT7621...
                  */
 
                 if (sc->rt_chipid != RT_CHIPID_MT7621) {
                         /* Set destination */
                         if (sc->rt_chipid != RT_CHIPID_MT7620)
                             desc->dst = (TXDSCR_DST_PORT_GDMA1);
 
-                        if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)
+                        if ((if_getcapenable(ifp) & IFCAP_TXCSUM) != 0)
                                 desc->dst |= (TXDSCR_IP_CSUM_GEN |
                                     TXDSCR_UDP_CSUM_GEN | TXDSCR_TCP_CSUM_GEN);
                         /* Set queue id */
                         desc->qn = qid;
                         /* No PPPoE */
                         desc->pppoe = 0;
                         /* No VLAN */
                         desc->vid = 0;
rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
 
         return (0);
 }
 
 /*
  * rt_start - start Transmit/Receive
  */
 static void
-rt_start(struct ifnet *ifp)
+rt_start(if_t ifp)
 {
         struct rt_softc *sc;
         struct mbuf *m;
         int qid = 0 /* XXX must check QoS priority */;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         for (;;) {
-                IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
+                m = if_dequeue(ifp);
                 if (m == NULL)
                         break;
 
                 m->m_pkthdr.rcvif = NULL;
 
                 RT_SOFTC_TX_RING_LOCK(&sc->tx_ring[qid]);
 
                 if (sc->tx_ring[qid].data_queued >=
                     RT_SOFTC_TX_RING_DATA_COUNT) {
                         RT_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
 
                         RT_DPRINTF(sc, RT_DEBUG_TX,
                             "if_start: Tx ring with qid=%d is full\n", qid);
 
                         m_freem(m);
 
-                        ifp->if_drv_flags |= IFF_DRV_OACTIVE;
+                        if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);
                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 
                         sc->tx_data_queue_full[qid]++;
 
                         break;
                 }
 
                 if (rt_tx_data(sc, m, qid) != 0) {
rt_start(if_t ifp)
         }
 }
 
 /*
  * rt_update_promisc - set/clear promiscuous mode. Unused yet, because
  * filtering done by attached Ethernet switch.
  */
 static void
-rt_update_promisc(struct ifnet *ifp)
+rt_update_promisc(if_t ifp)
 {
         struct rt_softc *sc;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         printf("%s: %s promiscuous mode\n",
                 device_get_nameunit(sc->dev),
-                (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving");
+                (if_getflags(ifp) & IFF_PROMISC) ? "entering" : "leaving");
 }
 
 /*
  * rt_ioctl - ioctl handler.
  */
 static int
-rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
+rt_ioctl(if_t ifp, u_long cmd, caddr_t data)
 {
         struct rt_softc *sc;
         struct ifreq *ifr;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
 #endif /* IF_RT_PHY_SUPPORT */
         int error, startall;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         ifr = (struct ifreq *) data;
 
         error = 0;
 
         switch (cmd) {
         case SIOCSIFFLAGS:
                 startall = 0;
                 RT_SOFTC_LOCK(sc);
-                if (ifp->if_flags & IFF_UP) {
-                        if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
-                                if ((ifp->if_flags ^ sc->if_flags) &
+                if (if_getflags(ifp) & IFF_UP) {
+                        if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
+                                if ((if_getflags(ifp) ^ sc->if_flags) &
                                     IFF_PROMISC)
                                         rt_update_promisc(ifp);
                         } else {
                                 rt_init_locked(sc);
                                 startall = 1;
                         }
                 } else {
-                        if (ifp->if_drv_flags & IFF_DRV_RUNNING)
+                        if (if_getdrvflags(ifp) & IFF_DRV_RUNNING)
                                 rt_stop_locked(sc);
                 }
-                sc->if_flags = ifp->if_flags;
+                sc->if_flags = if_getflags(ifp);
                 RT_SOFTC_UNLOCK(sc);
                 break;
         case SIOCGIFMEDIA:
         case SIOCSIFMEDIA:
 #ifdef IF_RT_PHY_SUPPORT
                 mii = device_get_softc(sc->rt_miibus);
                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
 #else

 
 /*
  * rt_tx_watchdog - Handler of TX Watchdog
  */
 static void
 rt_tx_watchdog(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = arg;
         ifp = sc->ifp;
 
         if (sc->tx_timer == 0)
                 return;
 
         if (--sc->tx_timer == 0) {

 
 /*
  * rt_intr - main ISR
  */
 static void
 rt_intr(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t status;
 
         sc = arg;
         ifp = sc->ifp;
 
         /* acknowledge interrupts */
         status = RT_READ(sc, sc->fe_int_status);
         RT_WRITE(sc, sc->fe_int_status, status);
 
         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
 
         if (status == 0xffffffff ||        /* device likely went away */
                 status == 0)            /* not for us */
                 return;
 
         sc->interrupts++;
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         if (status & CNT_PPE_AF)
                 rt_cnt_ppe_af(sc);
 
         if (status & CNT_GDM_AF)
                 rt_cnt_gdm_af(sc);
 

 
 /*
  * rt_rt5350_intr - main ISR for Ralink 5350 SoC
  */
 static void
 rt_rt5350_intr(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t status;
 
         sc = arg;
         ifp = sc->ifp;
 
         /* acknowledge interrupts */
         status = RT_READ(sc, sc->fe_int_status);
         RT_WRITE(sc, sc->fe_int_status, status);
 
         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
 
         if (status == 0xffffffff ||     /* device likely went away */
                 status == 0)            /* not for us */
                 return;
 
         sc->interrupts++;
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         if (status & RT5350_INT_TX_COHERENT)
                 rt_tx_coherent_intr(sc);
         if (status & RT5350_INT_RX_COHERENT)
                 rt_rx_coherent_intr(sc);
         if (status & RT5350_RX_DLY_INT)
                 rt_rx_delay_intr(sc);

 
 /*
  * rt_rx_done_task - run RX task
  */
 static void
 rt_rx_done_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int again;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_RX, "Rx done task\n");
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         sc->intr_pending_mask &= ~sc->int_rx_done_mask;
 
         again = rt_rx_eof(sc, &sc->rx_ring[0], sc->rx_process_limit);
 
         RT_SOFTC_LOCK(sc);
 

 
 /*
  * rt_tx_done_task - check for pending TX task in all queues
  */
 static void
 rt_tx_done_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t intr_mask;
         int i;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_TX, "Tx done task\n");
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         for (i = RT_SOFTC_TX_RING_COUNT - 1; i >= 0; i--) {
                 if (sc->intr_pending_mask & (sc->int_tx_done_mask << i)) {
                         sc->intr_pending_mask &= ~(sc->int_tx_done_mask << i);
                         rt_tx_eof(sc, &sc->tx_ring[i]);
                 }
         }
 
         sc->tx_timer = 0;
 
-        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
+        if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
 
         if(sc->rt_chipid == RT_CHIPID_RT5350 ||
            sc->rt_chipid == RT_CHIPID_MT7620 ||
            sc->rt_chipid == RT_CHIPID_MT7621)
           intr_mask = (
                 RT5350_INT_TXQ3_DONE |
                 RT5350_INT_TXQ2_DONE |
                 RT5350_INT_TXQ1_DONE |
rt_tx_done_task(void *context, int pending)
         if (sc->intr_pending_mask & intr_mask) {
                 RT_DPRINTF(sc, RT_DEBUG_TX,
                     "Tx done task: scheduling again\n");
                 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
         }
 
         RT_SOFTC_UNLOCK(sc);
 
-        if (!IFQ_IS_EMPTY(&ifp->if_snd))
+        if (!if_sendq_empty(ifp))
                 rt_start(ifp);
 }
 
 /*
  * rt_periodic_task - run periodic task
  */
 static void
 rt_periodic_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_PERIODIC, "periodic task: round=%lu\n",
             sc->periodic_round);
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         RT_SOFTC_LOCK(sc);
         sc->periodic_round++;
         rt_update_stats(sc);
 
         if ((sc->periodic_round % 10) == 0) {
                 rt_update_raw_counters(sc);
                 rt_watchdog(sc);
         }
 
         RT_SOFTC_UNLOCK(sc);
         taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task, hz / 10);
 }
 
 /*
  * rt_rx_eof - check for frames that done by DMA engine and pass it into
  * network subsystem.
  */
 static int
 rt_rx_eof(struct rt_softc *sc, struct rt_softc_rx_ring *ring, int limit)
 {
-        struct ifnet *ifp;
+        if_t ifp;
 /*      struct rt_softc_rx_ring *ring; */
         struct rt_rxdesc *desc;
         struct rt_softc_rx_data *data;
         struct mbuf *m, *mnew;
         bus_dma_segment_t segs[1];
         bus_dmamap_t dma_map;
         uint32_t index, desc_flags;
         int error, nsegs, len, nframes;
RT_DPRINTF(sc, RT_DEBUG_RX,
                     "Rx frame: rxdesc flags=0x%08x\n", desc_flags);
 
                 m->m_pkthdr.rcvif = ifp;
                 /* Add 2 to fix data align, after sdp0 = addr + 2 */
                 m->m_data += 2;
                 m->m_pkthdr.len = m->m_len = len;
 
                 /* check for crc errors */
-                if ((ifp->if_capenable & IFCAP_RXCSUM) != 0) {
+                if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0) {
                         /*check for valid checksum*/
                         if (desc_flags & (sc->csum_fail_ip|sc->csum_fail_l4)) {
                                 RT_DPRINTF(sc, RT_DEBUG_RX,
                                     "rxdesc: crc error\n");
 
                                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 
-                                if (!(ifp->if_flags & IFF_PROMISC)) {
+                                if (!(if_getflags(ifp) & IFF_PROMISC)) {
                                     m_freem(m);
                                     goto skip;
                                 }
                         }
                         if ((desc_flags & sc->csum_fail_ip) == 0) {
                                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
                                 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
                                 m->m_pkthdr.csum_data = 0xffff;
                         }
                         m->m_flags &= ~M_HASFCS;
                 }
 
-                (*ifp->if_input)(ifp, m);
+                if_input(ifp, m);
 skip:
                 desc->sdl0 &= ~htole16(RT_RXDESC_SDL0_DDONE);
 
                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
                         BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 
                 ring->cur = (ring->cur + 1) % RT_SOFTC_RX_RING_DATA_COUNT;
 

 
 /*
  * rt_tx_eof - check for successful transmitted frames and mark their
  * descriptor as free.
  */
 static void
 rt_tx_eof(struct rt_softc *sc, struct rt_softc_tx_ring *ring)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         struct rt_txdesc *desc;
         struct rt_softc_tx_data *data;
         uint32_t index;
         int ndescs, nframes;
 
         ifp = sc->ifp;
 
         ndescs = 0;

 }
 
 /*
  * rt_update_stats - query statistics counters and update related variables.
  */
 static void
 rt_update_stats(struct rt_softc *sc)
 {
-        struct ifnet *ifp;
+        if_t ifp;
 
         ifp = sc->ifp;
         RT_DPRINTF(sc, RT_DEBUG_STATS, "update statistic: \n");
         /* XXX do update stats here */
 }
 
 /*
  * rt_watchdog - reinit device on watchdog event.

 }
 
 /*
  * rt_txrx_enable - enable TX/RX DMA
  */
 static int
 rt_txrx_enable(struct rt_softc *sc)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t tmp;
         int ntries;
 
         ifp = sc->ifp;
 
         /* enable Tx/Rx DMA engine */
         for (ntries = 0; ntries < 200; ntries++) {
                 tmp = RT_READ(sc, sc->pdma_glo_cfg);

sys/net80211/ieee80211_hostap.c

 static int        rt_detach(device_t dev);
 static int        rt_shutdown(device_t dev);
 static int        rt_suspend(device_t dev);
 static int        rt_resume(device_t dev);
 static void        rt_init_locked(void *priv);
 static void        rt_init(void *priv);
 static void        rt_stop_locked(void *priv);
 static void        rt_stop(void *priv);
-static void        rt_start(struct ifnet *ifp);
-static int        rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
+static void        rt_start(if_t ifp);
+static int        rt_ioctl(if_t ifp, u_long cmd, caddr_t data);
 static void        rt_tx_watchdog(void *arg);
 static void        rt_intr(void *arg);
 static void        rt_rt5350_intr(void *arg);
 static void        rt_tx_coherent_intr(struct rt_softc *sc);
 static void        rt_rx_coherent_intr(struct rt_softc *sc);
 static void        rt_rx_delay_intr(struct rt_softc *sc);
 static void        rt_tx_delay_intr(struct rt_softc *sc);
 static void        rt_rx_intr(struct rt_softc *sc, int qid);

 static void        rt_sysctl_attach(struct rt_softc *sc);
 #ifdef IF_RT_PHY_SUPPORT
 void            rt_miibus_statchg(device_t);
 #endif
 #if defined(IF_RT_PHY_SUPPORT) || defined(RT_MDIO)
 static int        rt_miibus_readreg(device_t, int, int);
 static int        rt_miibus_writereg(device_t, int, int, int);
 #endif
-static int        rt_ifmedia_upd(struct ifnet *);
-static void        rt_ifmedia_sts(struct ifnet *, struct ifmediareq *);
+static int        rt_ifmedia_upd(if_t );
+static void        rt_ifmedia_sts(if_t , struct ifmediareq *);
 
 static SYSCTL_NODE(_hw, OID_AUTO, rt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "RT driver parameters");
 #ifdef IF_RT_DEBUG
 static int rt_debug = 0;
 SYSCTL_INT(_hw_rt, OID_AUTO, debug, CTLFLAG_RWTUN, &rt_debug, 0,
     "RT debug level");
 #endif
reset_freng(struct rt_softc *sc)
         /* XXX hard reset kills everything so skip it ... */
         return;
 }
 
 static int
 rt_attach(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int error, i;
 #ifdef FDT
         phandle_t node;
         char fdtval[32];
 #endif
 
         sc = device_get_softc(dev);
         sc->dev = dev;
#endif
 
         ifp = sc->ifp = if_alloc(IFT_ETHER);
         if (ifp == NULL) {
                 device_printf(dev, "could not if_alloc()\n");
                 error = ENOMEM;
                 goto fail;
         }
 
-        ifp->if_softc = sc;
+        if_setsoftc(ifp, sc);
         if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev));
-        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
-        ifp->if_init = rt_init;
-        ifp->if_ioctl = rt_ioctl;
-        ifp->if_start = rt_start;
+        if_setflags(ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
+        if_setinitfn(ifp, rt_init);
+        if_setioctlfn(ifp, rt_ioctl);
+        if_setstartfn(ifp, rt_start);
 #define RT_TX_QLEN      256
 
-        IFQ_SET_MAXLEN(&ifp->if_snd, RT_TX_QLEN);
-        ifp->if_snd.ifq_drv_maxlen = RT_TX_QLEN;
-        IFQ_SET_READY(&ifp->if_snd);
+        if_setsendqlen(ifp, RT_TX_QLEN);
+        if_setsendqready(ifp);
 
 #ifdef IF_RT_PHY_SUPPORT
         error = mii_attach(dev, &sc->rt_miibus, ifp, rt_ifmedia_upd,
             rt_ifmedia_sts, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0);
         if (error != 0) {
                 device_printf(dev, "attaching PHYs failed\n");
                 error = ENXIO;
                 goto fail;
         }
 #else
         ifmedia_init(&sc->rt_ifmedia, 0, rt_ifmedia_upd, rt_ifmedia_sts);
         ifmedia_add(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX, 0,
             NULL);
         ifmedia_set(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX);
 
 #endif /* IF_RT_PHY_SUPPORT */
 
         ether_request_mac(dev, sc->mac_addr);
         ether_ifattach(ifp, sc->mac_addr);
 
         /*
          * Tell the upper layer(s) we support long frames.
          */
-        ifp->if_hdrlen = sizeof(struct ether_vlan_header);
-        ifp->if_capabilities |= IFCAP_VLAN_MTU;
-        ifp->if_capenable |= IFCAP_VLAN_MTU;
-        ifp->if_capabilities |= IFCAP_RXCSUM|IFCAP_TXCSUM;
-        ifp->if_capenable |= IFCAP_RXCSUM|IFCAP_TXCSUM;
+        if_setifheaderlen(ifp, sizeof(struct ether_vlan_header));
+        if_setcapabilitiesbit(ifp, IFCAP_VLAN_MTU, 0);
+        if_setcapenablebit(ifp, IFCAP_VLAN_MTU, 0);
+        if_setcapabilitiesbit(ifp, IFCAP_RXCSUM|IFCAP_TXCSUM, 0);
+        if_setcapenablebit(ifp, IFCAP_RXCSUM|IFCAP_TXCSUM, 0);
 
         /* init task queue */
         NET_TASK_INIT(&sc->rx_done_task, 0, rt_rx_done_task, sc);
         TASK_INIT(&sc->tx_done_task, 0, rt_tx_done_task, sc);
 
         sc->rx_process_limit = 100;
 
         sc->taskqueue = taskqueue_create("rt_taskq", M_NOWAIT,
fail:
 
         return (error);
 }
 
 /*
  * Set media options.
  */
 static int
-rt_ifmedia_upd(struct ifnet *ifp)
+rt_ifmedia_upd(if_t ifp)
 {
         struct rt_softc *sc;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
         struct mii_softc *miisc;
         int error = 0;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         RT_SOFTC_LOCK(sc);
 
         mii = device_get_softc(sc->rt_miibus);
         LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
                 PHY_RESET(miisc);
         error = mii_mediachg(mii);
         RT_SOFTC_UNLOCK(sc);
 
         return (error);
 
 #else /* !IF_RT_PHY_SUPPORT */
 
         struct ifmedia *ifm;
         struct ifmedia_entry *ife;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         ifm = &sc->rt_ifmedia;
         ife = ifm->ifm_cur;
 
         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
                 return (EINVAL);
 
         if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
                 device_printf(sc->dev,
                     "AUTO is not supported for multiphy MAC");
                 return (EINVAL);
         }
 
         /*
          * Ignore everything
          */
         return (0);
 #endif /* IF_RT_PHY_SUPPORT */
 }
 
 /*
  * Report current media status.
  */
 static void
-rt_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
+rt_ifmedia_sts(if_t ifp, struct ifmediareq *ifmr)
 {
 #ifdef IF_RT_PHY_SUPPORT
         struct rt_softc *sc;
         struct mii_data *mii;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
 
         RT_SOFTC_LOCK(sc);
         mii = device_get_softc(sc->rt_miibus);
         mii_pollstat(mii);
         ifmr->ifm_active = mii->mii_media_active;
         ifmr->ifm_status = mii->mii_media_status;
         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
         RT_SOFTC_UNLOCK(sc);
 #else /* !IF_RT_PHY_SUPPORT */
 
         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
 #endif /* IF_RT_PHY_SUPPORT */
 }
 
 static int
 rt_detach(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int i;
 
         sc = device_get_softc(dev);
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "detaching\n");
 
         RT_SOFTC_LOCK(sc);
-        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
         callout_stop(&sc->tx_watchdog_ch);
         RT_SOFTC_UNLOCK(sc);
 
         taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
         taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
         taskqueue_drain_timeout(sc->taskqueue, &sc->periodic_task);
 
         /* free Tx and Rx rings */
rt_suspend(device_t dev)
 
         return (0);
 }
 
 static int
 rt_resume(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = device_get_softc(dev);
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "resuming\n");
 
-        if (ifp->if_flags & IFF_UP)
+        if (if_getflags(ifp) & IFF_UP)
                 rt_init(sc);
 
         return (0);
 }
 
 /*
  * rt_init_locked - Run initialization process having locked mtx.
  */
 static void
 rt_init_locked(void *priv)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
 #endif
         int i, ntries;
         uint32_t tmp;
 
         sc = priv;
         ifp = sc->ifp;
#endif
 
         if (rt_txrx_enable(sc) != 0)
                 goto fail;
 
 #ifdef IF_RT_PHY_SUPPORT
         if (mii) mii_mediachg(mii);
 #endif /* IF_RT_PHY_SUPPORT */
 
-        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
-        ifp->if_drv_flags |= IFF_DRV_RUNNING;
+        if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, IFF_DRV_RUNNING, 0);
 
         sc->periodic_round = 0;
 
         taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task, hz / 10);
 
         return;
 
 fail:

 
 /*
  * rt_stop_locked - stop TX/RX w/ lock
  */
 static void
 rt_stop_locked(void *priv)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = priv;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "stopping\n");
 
         RT_SOFTC_ASSERT_LOCKED(sc);
         sc->tx_timer = 0;
-        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
         callout_stop(&sc->tx_watchdog_ch);
         RT_SOFTC_UNLOCK(sc);
         taskqueue_block(sc->taskqueue);
 
         /*
          * Sometime rt_stop_locked called from isr and we get panic
          * When found, I fix it
          */

 }
 
 /*
  * rt_tx_data - transmit packet.
  */
 static int
 rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         struct rt_softc_tx_ring *ring;
         struct rt_softc_tx_data *data;
         struct rt_txdesc *desc;
         struct mbuf *m_d;
         bus_dma_segment_t dma_seg[RT_SOFTC_MAX_SCATTER];
         int error, ndmasegs, ndescs, i;
 
         KASSERT(qid >= 0 && qid < RT_SOFTC_TX_RING_COUNT,
for (i = 0; i < ndmasegs; i += 2) {
                  * one doesn't use word3 at all). And so does MT7621...
                  */
 
                 if (sc->rt_chipid != RT_CHIPID_MT7621) {
                         /* Set destination */
                         if (sc->rt_chipid != RT_CHIPID_MT7620)
                             desc->dst = (TXDSCR_DST_PORT_GDMA1);
 
-                        if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)
+                        if ((if_getcapenable(ifp) & IFCAP_TXCSUM) != 0)
                                 desc->dst |= (TXDSCR_IP_CSUM_GEN |
                                     TXDSCR_UDP_CSUM_GEN | TXDSCR_TCP_CSUM_GEN);
                         /* Set queue id */
                         desc->qn = qid;
                         /* No PPPoE */
                         desc->pppoe = 0;
                         /* No VLAN */
                         desc->vid = 0;
rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
 
         return (0);
 }
 
 /*
  * rt_start - start Transmit/Receive
  */
 static void
-rt_start(struct ifnet *ifp)
+rt_start(if_t ifp)
 {
         struct rt_softc *sc;
         struct mbuf *m;
         int qid = 0 /* XXX must check QoS priority */;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         for (;;) {
-                IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
+                m = if_dequeue(ifp);
                 if (m == NULL)
                         break;
 
                 m->m_pkthdr.rcvif = NULL;
 
                 RT_SOFTC_TX_RING_LOCK(&sc->tx_ring[qid]);
 
                 if (sc->tx_ring[qid].data_queued >=
                     RT_SOFTC_TX_RING_DATA_COUNT) {
                         RT_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
 
                         RT_DPRINTF(sc, RT_DEBUG_TX,
                             "if_start: Tx ring with qid=%d is full\n", qid);
 
                         m_freem(m);
 
-                        ifp->if_drv_flags |= IFF_DRV_OACTIVE;
+                        if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);
                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 
                         sc->tx_data_queue_full[qid]++;
 
                         break;
                 }
 
                 if (rt_tx_data(sc, m, qid) != 0) {
rt_start(if_t ifp)
         }
 }
 
 /*
  * rt_update_promisc - set/clear promiscuous mode. Unused yet, because
  * filtering done by attached Ethernet switch.
  */
 static void
-rt_update_promisc(struct ifnet *ifp)
+rt_update_promisc(if_t ifp)
 {
         struct rt_softc *sc;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         printf("%s: %s promiscuous mode\n",
                 device_get_nameunit(sc->dev),
-                (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving");
+                (if_getflags(ifp) & IFF_PROMISC) ? "entering" : "leaving");
 }
 
 /*
  * rt_ioctl - ioctl handler.
  */
 static int
-rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
+rt_ioctl(if_t ifp, u_long cmd, caddr_t data)
 {
         struct rt_softc *sc;
         struct ifreq *ifr;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
 #endif /* IF_RT_PHY_SUPPORT */
         int error, startall;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         ifr = (struct ifreq *) data;
 
         error = 0;
 
         switch (cmd) {
         case SIOCSIFFLAGS:
                 startall = 0;
                 RT_SOFTC_LOCK(sc);
-                if (ifp->if_flags & IFF_UP) {
-                        if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
-                                if ((ifp->if_flags ^ sc->if_flags) &
+                if (if_getflags(ifp) & IFF_UP) {
+                        if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
+                                if ((if_getflags(ifp) ^ sc->if_flags) &
                                     IFF_PROMISC)
                                         rt_update_promisc(ifp);
                         } else {
                                 rt_init_locked(sc);
                                 startall = 1;
                         }
                 } else {
-                        if (ifp->if_drv_flags & IFF_DRV_RUNNING)
+                        if (if_getdrvflags(ifp) & IFF_DRV_RUNNING)
                                 rt_stop_locked(sc);
                 }
-                sc->if_flags = ifp->if_flags;
+                sc->if_flags = if_getflags(ifp);
                 RT_SOFTC_UNLOCK(sc);
                 break;
         case SIOCGIFMEDIA:
         case SIOCSIFMEDIA:
 #ifdef IF_RT_PHY_SUPPORT
                 mii = device_get_softc(sc->rt_miibus);
                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
 #else

 
 /*
  * rt_tx_watchdog - Handler of TX Watchdog
  */
 static void
 rt_tx_watchdog(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = arg;
         ifp = sc->ifp;
 
         if (sc->tx_timer == 0)
                 return;
 
         if (--sc->tx_timer == 0) {

 
 /*
  * rt_intr - main ISR
  */
 static void
 rt_intr(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t status;
 
         sc = arg;
         ifp = sc->ifp;
 
         /* acknowledge interrupts */
         status = RT_READ(sc, sc->fe_int_status);
         RT_WRITE(sc, sc->fe_int_status, status);
 
         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
 
         if (status == 0xffffffff ||        /* device likely went away */
                 status == 0)            /* not for us */
                 return;
 
         sc->interrupts++;
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         if (status & CNT_PPE_AF)
                 rt_cnt_ppe_af(sc);
 
         if (status & CNT_GDM_AF)
                 rt_cnt_gdm_af(sc);
 

 
 /*
  * rt_rt5350_intr - main ISR for Ralink 5350 SoC
  */
 static void
 rt_rt5350_intr(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t status;
 
         sc = arg;
         ifp = sc->ifp;
 
         /* acknowledge interrupts */
         status = RT_READ(sc, sc->fe_int_status);
         RT_WRITE(sc, sc->fe_int_status, status);
 
         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
 
         if (status == 0xffffffff ||     /* device likely went away */
                 status == 0)            /* not for us */
                 return;
 
         sc->interrupts++;
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         if (status & RT5350_INT_TX_COHERENT)
                 rt_tx_coherent_intr(sc);
         if (status & RT5350_INT_RX_COHERENT)
                 rt_rx_coherent_intr(sc);
         if (status & RT5350_RX_DLY_INT)
                 rt_rx_delay_intr(sc);

 
 /*
  * rt_rx_done_task - run RX task
  */
 static void
 rt_rx_done_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int again;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_RX, "Rx done task\n");
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         sc->intr_pending_mask &= ~sc->int_rx_done_mask;
 
         again = rt_rx_eof(sc, &sc->rx_ring[0], sc->rx_process_limit);
 
         RT_SOFTC_LOCK(sc);
 

 
 /*
  * rt_tx_done_task - check for pending TX task in all queues
  */
 static void
 rt_tx_done_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t intr_mask;
         int i;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_TX, "Tx done task\n");
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         for (i = RT_SOFTC_TX_RING_COUNT - 1; i >= 0; i--) {
                 if (sc->intr_pending_mask & (sc->int_tx_done_mask << i)) {
                         sc->intr_pending_mask &= ~(sc->int_tx_done_mask << i);
                         rt_tx_eof(sc, &sc->tx_ring[i]);
                 }
         }
 
         sc->tx_timer = 0;
 
-        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
+        if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
 
         if(sc->rt_chipid == RT_CHIPID_RT5350 ||
            sc->rt_chipid == RT_CHIPID_MT7620 ||
            sc->rt_chipid == RT_CHIPID_MT7621)
           intr_mask = (
                 RT5350_INT_TXQ3_DONE |
                 RT5350_INT_TXQ2_DONE |
                 RT5350_INT_TXQ1_DONE |
rt_tx_done_task(void *context, int pending)
         if (sc->intr_pending_mask & intr_mask) {
                 RT_DPRINTF(sc, RT_DEBUG_TX,
                     "Tx done task: scheduling again\n");
                 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
         }
 
         RT_SOFTC_UNLOCK(sc);
 
-        if (!IFQ_IS_EMPTY(&ifp->if_snd))
+        if (!if_sendq_empty(ifp))
                 rt_start(ifp);
 }
 
 /*
  * rt_periodic_task - run periodic task
  */
 static void
 rt_periodic_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_PERIODIC, "periodic task: round=%lu\n",
             sc->periodic_round);
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         RT_SOFTC_LOCK(sc);
         sc->periodic_round++;
         rt_update_stats(sc);
 
         if ((sc->periodic_round % 10) == 0) {
                 rt_update_raw_counters(sc);
                 rt_watchdog(sc);
         }
 
         RT_SOFTC_UNLOCK(sc);
         taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task, hz / 10);
 }
 
 /*
  * rt_rx_eof - check for frames that done by DMA engine and pass it into
  * network subsystem.
  */
 static int
 rt_rx_eof(struct rt_softc *sc, struct rt_softc_rx_ring *ring, int limit)
 {
-        struct ifnet *ifp;
+        if_t ifp;
 /*      struct rt_softc_rx_ring *ring; */
         struct rt_rxdesc *desc;
         struct rt_softc_rx_data *data;
         struct mbuf *m, *mnew;
         bus_dma_segment_t segs[1];
         bus_dmamap_t dma_map;
         uint32_t index, desc_flags;
         int error, nsegs, len, nframes;
RT_DPRINTF(sc, RT_DEBUG_RX,
                     "Rx frame: rxdesc flags=0x%08x\n", desc_flags);
 
                 m->m_pkthdr.rcvif = ifp;
                 /* Add 2 to fix data align, after sdp0 = addr + 2 */
                 m->m_data += 2;
                 m->m_pkthdr.len = m->m_len = len;
 
                 /* check for crc errors */
-                if ((ifp->if_capenable & IFCAP_RXCSUM) != 0) {
+                if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0) {
                         /*check for valid checksum*/
                         if (desc_flags & (sc->csum_fail_ip|sc->csum_fail_l4)) {
                                 RT_DPRINTF(sc, RT_DEBUG_RX,
                                     "rxdesc: crc error\n");
 
                                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 
-                                if (!(ifp->if_flags & IFF_PROMISC)) {
+                                if (!(if_getflags(ifp) & IFF_PROMISC)) {
                                     m_freem(m);
                                     goto skip;
                                 }
                         }
                         if ((desc_flags & sc->csum_fail_ip) == 0) {
                                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
                                 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
                                 m->m_pkthdr.csum_data = 0xffff;
                         }
                         m->m_flags &= ~M_HASFCS;
                 }
 
-                (*ifp->if_input)(ifp, m);
+                if_input(ifp, m);
 skip:
                 desc->sdl0 &= ~htole16(RT_RXDESC_SDL0_DDONE);
 
                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
                         BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 
                 ring->cur = (ring->cur + 1) % RT_SOFTC_RX_RING_DATA_COUNT;
 

 
 /*
  * rt_tx_eof - check for successful transmitted frames and mark their
  * descriptor as free.
  */
 static void
 rt_tx_eof(struct rt_softc *sc, struct rt_softc_tx_ring *ring)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         struct rt_txdesc *desc;
         struct rt_softc_tx_data *data;
         uint32_t index;
         int ndescs, nframes;
 
         ifp = sc->ifp;
 
         ndescs = 0;

 }
 
 /*
  * rt_update_stats - query statistics counters and update related variables.
  */
 static void
 rt_update_stats(struct rt_softc *sc)
 {
-        struct ifnet *ifp;
+        if_t ifp;
 
         ifp = sc->ifp;
         RT_DPRINTF(sc, RT_DEBUG_STATS, "update statistic: \n");
         /* XXX do update stats here */
 }
 
 /*
  * rt_watchdog - reinit device on watchdog event.

 }
 
 /*
  * rt_txrx_enable - enable TX/RX DMA
  */
 static int
 rt_txrx_enable(struct rt_softc *sc)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t tmp;
         int ntries;
 
         ifp = sc->ifp;
 
         /* enable Tx/Rx DMA engine */
         for (ntries = 0; ntries < 200; ntries++) {
                 tmp = RT_READ(sc, sc->pdma_glo_cfg);

sys/net80211/ieee80211_sta.c

 static int        rt_detach(device_t dev);
 static int        rt_shutdown(device_t dev);
 static int        rt_suspend(device_t dev);
 static int        rt_resume(device_t dev);
 static void        rt_init_locked(void *priv);
 static void        rt_init(void *priv);
 static void        rt_stop_locked(void *priv);
 static void        rt_stop(void *priv);
-static void        rt_start(struct ifnet *ifp);
-static int        rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
+static void        rt_start(if_t ifp);
+static int        rt_ioctl(if_t ifp, u_long cmd, caddr_t data);
 static void        rt_tx_watchdog(void *arg);
 static void        rt_intr(void *arg);
 static void        rt_rt5350_intr(void *arg);
 static void        rt_tx_coherent_intr(struct rt_softc *sc);
 static void        rt_rx_coherent_intr(struct rt_softc *sc);
 static void        rt_rx_delay_intr(struct rt_softc *sc);
 static void        rt_tx_delay_intr(struct rt_softc *sc);
 static void        rt_rx_intr(struct rt_softc *sc, int qid);

 static void        rt_sysctl_attach(struct rt_softc *sc);
 #ifdef IF_RT_PHY_SUPPORT
 void            rt_miibus_statchg(device_t);
 #endif
 #if defined(IF_RT_PHY_SUPPORT) || defined(RT_MDIO)
 static int        rt_miibus_readreg(device_t, int, int);
 static int        rt_miibus_writereg(device_t, int, int, int);
 #endif
-static int        rt_ifmedia_upd(struct ifnet *);
-static void        rt_ifmedia_sts(struct ifnet *, struct ifmediareq *);
+static int        rt_ifmedia_upd(if_t );
+static void        rt_ifmedia_sts(if_t , struct ifmediareq *);
 
 static SYSCTL_NODE(_hw, OID_AUTO, rt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "RT driver parameters");
 #ifdef IF_RT_DEBUG
 static int rt_debug = 0;
 SYSCTL_INT(_hw_rt, OID_AUTO, debug, CTLFLAG_RWTUN, &rt_debug, 0,
     "RT debug level");
 #endif
reset_freng(struct rt_softc *sc)
         /* XXX hard reset kills everything so skip it ... */
         return;
 }
 
 static int
 rt_attach(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int error, i;
 #ifdef FDT
         phandle_t node;
         char fdtval[32];
 #endif
 
         sc = device_get_softc(dev);
         sc->dev = dev;
#endif
 
         ifp = sc->ifp = if_alloc(IFT_ETHER);
         if (ifp == NULL) {
                 device_printf(dev, "could not if_alloc()\n");
                 error = ENOMEM;
                 goto fail;
         }
 
-        ifp->if_softc = sc;
+        if_setsoftc(ifp, sc);
         if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev));
-        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
-        ifp->if_init = rt_init;
-        ifp->if_ioctl = rt_ioctl;
-        ifp->if_start = rt_start;
+        if_setflags(ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
+        if_setinitfn(ifp, rt_init);
+        if_setioctlfn(ifp, rt_ioctl);
+        if_setstartfn(ifp, rt_start);
 #define RT_TX_QLEN      256
 
-        IFQ_SET_MAXLEN(&ifp->if_snd, RT_TX_QLEN);
-        ifp->if_snd.ifq_drv_maxlen = RT_TX_QLEN;
-        IFQ_SET_READY(&ifp->if_snd);
+        if_setsendqlen(ifp, RT_TX_QLEN);
+        if_setsendqready(ifp);
 
 #ifdef IF_RT_PHY_SUPPORT
         error = mii_attach(dev, &sc->rt_miibus, ifp, rt_ifmedia_upd,
             rt_ifmedia_sts, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0);
         if (error != 0) {
                 device_printf(dev, "attaching PHYs failed\n");
                 error = ENXIO;
                 goto fail;
         }
 #else
         ifmedia_init(&sc->rt_ifmedia, 0, rt_ifmedia_upd, rt_ifmedia_sts);
         ifmedia_add(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX, 0,
             NULL);
         ifmedia_set(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX);
 
 #endif /* IF_RT_PHY_SUPPORT */
 
         ether_request_mac(dev, sc->mac_addr);
         ether_ifattach(ifp, sc->mac_addr);
 
         /*
          * Tell the upper layer(s) we support long frames.
          */
-        ifp->if_hdrlen = sizeof(struct ether_vlan_header);
-        ifp->if_capabilities |= IFCAP_VLAN_MTU;
-        ifp->if_capenable |= IFCAP_VLAN_MTU;
-        ifp->if_capabilities |= IFCAP_RXCSUM|IFCAP_TXCSUM;
-        ifp->if_capenable |= IFCAP_RXCSUM|IFCAP_TXCSUM;
+        if_setifheaderlen(ifp, sizeof(struct ether_vlan_header));
+        if_setcapabilitiesbit(ifp, IFCAP_VLAN_MTU, 0);
+        if_setcapenablebit(ifp, IFCAP_VLAN_MTU, 0);
+        if_setcapabilitiesbit(ifp, IFCAP_RXCSUM|IFCAP_TXCSUM, 0);
+        if_setcapenablebit(ifp, IFCAP_RXCSUM|IFCAP_TXCSUM, 0);
 
         /* init task queue */
         NET_TASK_INIT(&sc->rx_done_task, 0, rt_rx_done_task, sc);
         TASK_INIT(&sc->tx_done_task, 0, rt_tx_done_task, sc);
 
         sc->rx_process_limit = 100;
 
         sc->taskqueue = taskqueue_create("rt_taskq", M_NOWAIT,
fail:
 
         return (error);
 }
 
 /*
  * Set media options.
  */
 static int
-rt_ifmedia_upd(struct ifnet *ifp)
+rt_ifmedia_upd(if_t ifp)
 {
         struct rt_softc *sc;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
         struct mii_softc *miisc;
         int error = 0;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         RT_SOFTC_LOCK(sc);
 
         mii = device_get_softc(sc->rt_miibus);
         LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
                 PHY_RESET(miisc);
         error = mii_mediachg(mii);
         RT_SOFTC_UNLOCK(sc);
 
         return (error);
 
 #else /* !IF_RT_PHY_SUPPORT */
 
         struct ifmedia *ifm;
         struct ifmedia_entry *ife;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         ifm = &sc->rt_ifmedia;
         ife = ifm->ifm_cur;
 
         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
                 return (EINVAL);
 
         if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
                 device_printf(sc->dev,
                     "AUTO is not supported for multiphy MAC");
                 return (EINVAL);
         }
 
         /*
          * Ignore everything
          */
         return (0);
 #endif /* IF_RT_PHY_SUPPORT */
 }
 
 /*
  * Report current media status.
  */
 static void
-rt_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
+rt_ifmedia_sts(if_t ifp, struct ifmediareq *ifmr)
 {
 #ifdef IF_RT_PHY_SUPPORT
         struct rt_softc *sc;
         struct mii_data *mii;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
 
         RT_SOFTC_LOCK(sc);
         mii = device_get_softc(sc->rt_miibus);
         mii_pollstat(mii);
         ifmr->ifm_active = mii->mii_media_active;
         ifmr->ifm_status = mii->mii_media_status;
         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
         RT_SOFTC_UNLOCK(sc);
 #else /* !IF_RT_PHY_SUPPORT */
 
         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
 #endif /* IF_RT_PHY_SUPPORT */
 }
 
 static int
 rt_detach(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int i;
 
         sc = device_get_softc(dev);
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "detaching\n");
 
         RT_SOFTC_LOCK(sc);
-        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
         callout_stop(&sc->tx_watchdog_ch);
         RT_SOFTC_UNLOCK(sc);
 
         taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
         taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
         taskqueue_drain_timeout(sc->taskqueue, &sc->periodic_task);
 
         /* free Tx and Rx rings */
rt_suspend(device_t dev)
 
         return (0);
 }
 
 static int
 rt_resume(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = device_get_softc(dev);
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "resuming\n");
 
-        if (ifp->if_flags & IFF_UP)
+        if (if_getflags(ifp) & IFF_UP)
                 rt_init(sc);
 
         return (0);
 }
 
 /*
  * rt_init_locked - Run initialization process having locked mtx.
  */
 static void
 rt_init_locked(void *priv)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
 #endif
         int i, ntries;
         uint32_t tmp;
 
         sc = priv;
         ifp = sc->ifp;
#endif
 
         if (rt_txrx_enable(sc) != 0)
                 goto fail;
 
 #ifdef IF_RT_PHY_SUPPORT
         if (mii) mii_mediachg(mii);
 #endif /* IF_RT_PHY_SUPPORT */
 
-        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
-        ifp->if_drv_flags |= IFF_DRV_RUNNING;
+        if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, IFF_DRV_RUNNING, 0);
 
         sc->periodic_round = 0;
 
         taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task, hz / 10);
 
         return;
 
 fail:

 
 /*
  * rt_stop_locked - stop TX/RX w/ lock
  */
 static void
 rt_stop_locked(void *priv)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = priv;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "stopping\n");
 
         RT_SOFTC_ASSERT_LOCKED(sc);
         sc->tx_timer = 0;
-        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
         callout_stop(&sc->tx_watchdog_ch);
         RT_SOFTC_UNLOCK(sc);
         taskqueue_block(sc->taskqueue);
 
         /*
          * Sometime rt_stop_locked called from isr and we get panic
          * When found, I fix it
          */

 }
 
 /*
  * rt_tx_data - transmit packet.
  */
 static int
 rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         struct rt_softc_tx_ring *ring;
         struct rt_softc_tx_data *data;
         struct rt_txdesc *desc;
         struct mbuf *m_d;
         bus_dma_segment_t dma_seg[RT_SOFTC_MAX_SCATTER];
         int error, ndmasegs, ndescs, i;
 
         KASSERT(qid >= 0 && qid < RT_SOFTC_TX_RING_COUNT,
for (i = 0; i < ndmasegs; i += 2) {
                  * one doesn't use word3 at all). And so does MT7621...
                  */
 
                 if (sc->rt_chipid != RT_CHIPID_MT7621) {
                         /* Set destination */
                         if (sc->rt_chipid != RT_CHIPID_MT7620)
                             desc->dst = (TXDSCR_DST_PORT_GDMA1);
 
-                        if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)
+                        if ((if_getcapenable(ifp) & IFCAP_TXCSUM) != 0)
                                 desc->dst |= (TXDSCR_IP_CSUM_GEN |
                                     TXDSCR_UDP_CSUM_GEN | TXDSCR_TCP_CSUM_GEN);
                         /* Set queue id */
                         desc->qn = qid;
                         /* No PPPoE */
                         desc->pppoe = 0;
                         /* No VLAN */
                         desc->vid = 0;
rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
 
         return (0);
 }
 
 /*
  * rt_start - start Transmit/Receive
  */
 static void
-rt_start(struct ifnet *ifp)
+rt_start(if_t ifp)
 {
         struct rt_softc *sc;
         struct mbuf *m;
         int qid = 0 /* XXX must check QoS priority */;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         for (;;) {
-                IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
+                m = if_dequeue(ifp);
                 if (m == NULL)
                         break;
 
                 m->m_pkthdr.rcvif = NULL;
 
                 RT_SOFTC_TX_RING_LOCK(&sc->tx_ring[qid]);
 
                 if (sc->tx_ring[qid].data_queued >=
                     RT_SOFTC_TX_RING_DATA_COUNT) {
                         RT_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
 
                         RT_DPRINTF(sc, RT_DEBUG_TX,
                             "if_start: Tx ring with qid=%d is full\n", qid);
 
                         m_freem(m);
 
-                        ifp->if_drv_flags |= IFF_DRV_OACTIVE;
+                        if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);
                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 
                         sc->tx_data_queue_full[qid]++;
 
                         break;
                 }
 
                 if (rt_tx_data(sc, m, qid) != 0) {
rt_start(if_t ifp)
         }
 }
 
 /*
  * rt_update_promisc - set/clear promiscuous mode. Unused yet, because
  * filtering done by attached Ethernet switch.
  */
 static void
-rt_update_promisc(struct ifnet *ifp)
+rt_update_promisc(if_t ifp)
 {
         struct rt_softc *sc;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         printf("%s: %s promiscuous mode\n",
                 device_get_nameunit(sc->dev),
-                (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving");
+                (if_getflags(ifp) & IFF_PROMISC) ? "entering" : "leaving");
 }
 
 /*
  * rt_ioctl - ioctl handler.
  */
 static int
-rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
+rt_ioctl(if_t ifp, u_long cmd, caddr_t data)
 {
         struct rt_softc *sc;
         struct ifreq *ifr;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
 #endif /* IF_RT_PHY_SUPPORT */
         int error, startall;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         ifr = (struct ifreq *) data;
 
         error = 0;
 
         switch (cmd) {
         case SIOCSIFFLAGS:
                 startall = 0;
                 RT_SOFTC_LOCK(sc);
-                if (ifp->if_flags & IFF_UP) {
-                        if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
-                                if ((ifp->if_flags ^ sc->if_flags) &
+                if (if_getflags(ifp) & IFF_UP) {
+                        if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
+                                if ((if_getflags(ifp) ^ sc->if_flags) &
                                     IFF_PROMISC)
                                         rt_update_promisc(ifp);
                         } else {
                                 rt_init_locked(sc);
                                 startall = 1;
                         }
                 } else {
-                        if (ifp->if_drv_flags & IFF_DRV_RUNNING)
+                        if (if_getdrvflags(ifp) & IFF_DRV_RUNNING)
                                 rt_stop_locked(sc);
                 }
-                sc->if_flags = ifp->if_flags;
+                sc->if_flags = if_getflags(ifp);
                 RT_SOFTC_UNLOCK(sc);
                 break;
         case SIOCGIFMEDIA:
         case SIOCSIFMEDIA:
 #ifdef IF_RT_PHY_SUPPORT
                 mii = device_get_softc(sc->rt_miibus);
                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
 #else

 
 /*
  * rt_tx_watchdog - Handler of TX Watchdog
  */
 static void
 rt_tx_watchdog(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = arg;
         ifp = sc->ifp;
 
         if (sc->tx_timer == 0)
                 return;
 
         if (--sc->tx_timer == 0) {

 
 /*
  * rt_intr - main ISR
  */
 static void
 rt_intr(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t status;
 
         sc = arg;
         ifp = sc->ifp;
 
         /* acknowledge interrupts */
         status = RT_READ(sc, sc->fe_int_status);
         RT_WRITE(sc, sc->fe_int_status, status);
 
         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
 
         if (status == 0xffffffff ||        /* device likely went away */
                 status == 0)            /* not for us */
                 return;
 
         sc->interrupts++;
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         if (status & CNT_PPE_AF)
                 rt_cnt_ppe_af(sc);
 
         if (status & CNT_GDM_AF)
                 rt_cnt_gdm_af(sc);
 

 
 /*
  * rt_rt5350_intr - main ISR for Ralink 5350 SoC
  */
 static void
 rt_rt5350_intr(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t status;
 
         sc = arg;
         ifp = sc->ifp;
 
         /* acknowledge interrupts */
         status = RT_READ(sc, sc->fe_int_status);
         RT_WRITE(sc, sc->fe_int_status, status);
 
         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
 
         if (status == 0xffffffff ||     /* device likely went away */
                 status == 0)            /* not for us */
                 return;
 
         sc->interrupts++;
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         if (status & RT5350_INT_TX_COHERENT)
                 rt_tx_coherent_intr(sc);
         if (status & RT5350_INT_RX_COHERENT)
                 rt_rx_coherent_intr(sc);
         if (status & RT5350_RX_DLY_INT)
                 rt_rx_delay_intr(sc);

 
 /*
  * rt_rx_done_task - run RX task
  */
 static void
 rt_rx_done_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int again;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_RX, "Rx done task\n");
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         sc->intr_pending_mask &= ~sc->int_rx_done_mask;
 
         again = rt_rx_eof(sc, &sc->rx_ring[0], sc->rx_process_limit);
 
         RT_SOFTC_LOCK(sc);
 

 
 /*
  * rt_tx_done_task - check for pending TX task in all queues
  */
 static void
 rt_tx_done_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t intr_mask;
         int i;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_TX, "Tx done task\n");
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         for (i = RT_SOFTC_TX_RING_COUNT - 1; i >= 0; i--) {
                 if (sc->intr_pending_mask & (sc->int_tx_done_mask << i)) {
                         sc->intr_pending_mask &= ~(sc->int_tx_done_mask << i);
                         rt_tx_eof(sc, &sc->tx_ring[i]);
                 }
         }
 
         sc->tx_timer = 0;
 
-        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
+        if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
 
         if(sc->rt_chipid == RT_CHIPID_RT5350 ||
            sc->rt_chipid == RT_CHIPID_MT7620 ||
            sc->rt_chipid == RT_CHIPID_MT7621)
           intr_mask = (
                 RT5350_INT_TXQ3_DONE |
                 RT5350_INT_TXQ2_DONE |
                 RT5350_INT_TXQ1_DONE |
rt_tx_done_task(void *context, int pending)
         if (sc->intr_pending_mask & intr_mask) {
                 RT_DPRINTF(sc, RT_DEBUG_TX,
                     "Tx done task: scheduling again\n");
                 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
         }
 
         RT_SOFTC_UNLOCK(sc);
 
-        if (!IFQ_IS_EMPTY(&ifp->if_snd))
+        if (!if_sendq_empty(ifp))
                 rt_start(ifp);
 }
 
 /*
  * rt_periodic_task - run periodic task
  */
 static void
 rt_periodic_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_PERIODIC, "periodic task: round=%lu\n",
             sc->periodic_round);
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         RT_SOFTC_LOCK(sc);
         sc->periodic_round++;
         rt_update_stats(sc);
 
         if ((sc->periodic_round % 10) == 0) {
                 rt_update_raw_counters(sc);
                 rt_watchdog(sc);
         }
 
         RT_SOFTC_UNLOCK(sc);
         taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task, hz / 10);
 }
 
 /*
  * rt_rx_eof - check for frames that done by DMA engine and pass it into
  * network subsystem.
  */
 static int
 rt_rx_eof(struct rt_softc *sc, struct rt_softc_rx_ring *ring, int limit)
 {
-        struct ifnet *ifp;
+        if_t ifp;
 /*      struct rt_softc_rx_ring *ring; */
         struct rt_rxdesc *desc;
         struct rt_softc_rx_data *data;
         struct mbuf *m, *mnew;
         bus_dma_segment_t segs[1];
         bus_dmamap_t dma_map;
         uint32_t index, desc_flags;
         int error, nsegs, len, nframes;
RT_DPRINTF(sc, RT_DEBUG_RX,
                     "Rx frame: rxdesc flags=0x%08x\n", desc_flags);
 
                 m->m_pkthdr.rcvif = ifp;
                 /* Add 2 to fix data align, after sdp0 = addr + 2 */
                 m->m_data += 2;
                 m->m_pkthdr.len = m->m_len = len;
 
                 /* check for crc errors */
-                if ((ifp->if_capenable & IFCAP_RXCSUM) != 0) {
+                if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0) {
                         /*check for valid checksum*/
                         if (desc_flags & (sc->csum_fail_ip|sc->csum_fail_l4)) {
                                 RT_DPRINTF(sc, RT_DEBUG_RX,
                                     "rxdesc: crc error\n");
 
                                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 
-                                if (!(ifp->if_flags & IFF_PROMISC)) {
+                                if (!(if_getflags(ifp) & IFF_PROMISC)) {
                                     m_freem(m);
                                     goto skip;
                                 }
                         }
                         if ((desc_flags & sc->csum_fail_ip) == 0) {
                                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
                                 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
                                 m->m_pkthdr.csum_data = 0xffff;
                         }
                         m->m_flags &= ~M_HASFCS;
                 }
 
-                (*ifp->if_input)(ifp, m);
+                if_input(ifp, m);
 skip:
                 desc->sdl0 &= ~htole16(RT_RXDESC_SDL0_DDONE);
 
                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
                         BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 
                 ring->cur = (ring->cur + 1) % RT_SOFTC_RX_RING_DATA_COUNT;
 

 
 /*
  * rt_tx_eof - check for successful transmitted frames and mark their
  * descriptor as free.
  */
 static void
 rt_tx_eof(struct rt_softc *sc, struct rt_softc_tx_ring *ring)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         struct rt_txdesc *desc;
         struct rt_softc_tx_data *data;
         uint32_t index;
         int ndescs, nframes;
 
         ifp = sc->ifp;
 
         ndescs = 0;

 }
 
 /*
  * rt_update_stats - query statistics counters and update related variables.
  */
 static void
 rt_update_stats(struct rt_softc *sc)
 {
-        struct ifnet *ifp;
+        if_t ifp;
 
         ifp = sc->ifp;
         RT_DPRINTF(sc, RT_DEBUG_STATS, "update statistic: \n");
         /* XXX do update stats here */
 }
 
 /*
  * rt_watchdog - reinit device on watchdog event.

 }
 
 /*
  * rt_txrx_enable - enable TX/RX DMA
  */
 static int
 rt_txrx_enable(struct rt_softc *sc)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t tmp;
         int ntries;
 
         ifp = sc->ifp;
 
         /* enable Tx/Rx DMA engine */
         for (ntries = 0; ntries < 200; ntries++) {
                 tmp = RT_READ(sc, sc->pdma_glo_cfg);

sys/net80211/ieee80211_var.h

 static int        rt_detach(device_t dev);
 static int        rt_shutdown(device_t dev);
 static int        rt_suspend(device_t dev);
 static int        rt_resume(device_t dev);
 static void        rt_init_locked(void *priv);
 static void        rt_init(void *priv);
 static void        rt_stop_locked(void *priv);
 static void        rt_stop(void *priv);
-static void        rt_start(struct ifnet *ifp);
-static int        rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
+static void        rt_start(if_t ifp);
+static int        rt_ioctl(if_t ifp, u_long cmd, caddr_t data);
 static void        rt_tx_watchdog(void *arg);
 static void        rt_intr(void *arg);
 static void        rt_rt5350_intr(void *arg);
 static void        rt_tx_coherent_intr(struct rt_softc *sc);
 static void        rt_rx_coherent_intr(struct rt_softc *sc);
 static void        rt_rx_delay_intr(struct rt_softc *sc);
 static void        rt_tx_delay_intr(struct rt_softc *sc);
 static void        rt_rx_intr(struct rt_softc *sc, int qid);

 static void        rt_sysctl_attach(struct rt_softc *sc);
 #ifdef IF_RT_PHY_SUPPORT
 void            rt_miibus_statchg(device_t);
 #endif
 #if defined(IF_RT_PHY_SUPPORT) || defined(RT_MDIO)
 static int        rt_miibus_readreg(device_t, int, int);
 static int        rt_miibus_writereg(device_t, int, int, int);
 #endif
-static int        rt_ifmedia_upd(struct ifnet *);
-static void        rt_ifmedia_sts(struct ifnet *, struct ifmediareq *);
+static int        rt_ifmedia_upd(if_t );
+static void        rt_ifmedia_sts(if_t , struct ifmediareq *);
 
 static SYSCTL_NODE(_hw, OID_AUTO, rt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
     "RT driver parameters");
 #ifdef IF_RT_DEBUG
 static int rt_debug = 0;
 SYSCTL_INT(_hw_rt, OID_AUTO, debug, CTLFLAG_RWTUN, &rt_debug, 0,
     "RT debug level");
 #endif
reset_freng(struct rt_softc *sc)
         /* XXX hard reset kills everything so skip it ... */
         return;
 }
 
 static int
 rt_attach(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int error, i;
 #ifdef FDT
         phandle_t node;
         char fdtval[32];
 #endif
 
         sc = device_get_softc(dev);
         sc->dev = dev;
#endif
 
         ifp = sc->ifp = if_alloc(IFT_ETHER);
         if (ifp == NULL) {
                 device_printf(dev, "could not if_alloc()\n");
                 error = ENOMEM;
                 goto fail;
         }
 
-        ifp->if_softc = sc;
+        if_setsoftc(ifp, sc);
         if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev));
-        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
-        ifp->if_init = rt_init;
-        ifp->if_ioctl = rt_ioctl;
-        ifp->if_start = rt_start;
+        if_setflags(ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
+        if_setinitfn(ifp, rt_init);
+        if_setioctlfn(ifp, rt_ioctl);
+        if_setstartfn(ifp, rt_start);
 #define RT_TX_QLEN      256
 
-        IFQ_SET_MAXLEN(&ifp->if_snd, RT_TX_QLEN);
-        ifp->if_snd.ifq_drv_maxlen = RT_TX_QLEN;
-        IFQ_SET_READY(&ifp->if_snd);
+        if_setsendqlen(ifp, RT_TX_QLEN);
+        if_setsendqready(ifp);
 
 #ifdef IF_RT_PHY_SUPPORT
         error = mii_attach(dev, &sc->rt_miibus, ifp, rt_ifmedia_upd,
             rt_ifmedia_sts, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0);
         if (error != 0) {
                 device_printf(dev, "attaching PHYs failed\n");
                 error = ENXIO;
                 goto fail;
         }
 #else
         ifmedia_init(&sc->rt_ifmedia, 0, rt_ifmedia_upd, rt_ifmedia_sts);
         ifmedia_add(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX, 0,
             NULL);
         ifmedia_set(&sc->rt_ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX);
 
 #endif /* IF_RT_PHY_SUPPORT */
 
         ether_request_mac(dev, sc->mac_addr);
         ether_ifattach(ifp, sc->mac_addr);
 
         /*
          * Tell the upper layer(s) we support long frames.
          */
-        ifp->if_hdrlen = sizeof(struct ether_vlan_header);
-        ifp->if_capabilities |= IFCAP_VLAN_MTU;
-        ifp->if_capenable |= IFCAP_VLAN_MTU;
-        ifp->if_capabilities |= IFCAP_RXCSUM|IFCAP_TXCSUM;
-        ifp->if_capenable |= IFCAP_RXCSUM|IFCAP_TXCSUM;
+        if_setifheaderlen(ifp, sizeof(struct ether_vlan_header));
+        if_setcapabilitiesbit(ifp, IFCAP_VLAN_MTU, 0);
+        if_setcapenablebit(ifp, IFCAP_VLAN_MTU, 0);
+        if_setcapabilitiesbit(ifp, IFCAP_RXCSUM|IFCAP_TXCSUM, 0);
+        if_setcapenablebit(ifp, IFCAP_RXCSUM|IFCAP_TXCSUM, 0);
 
         /* init task queue */
         NET_TASK_INIT(&sc->rx_done_task, 0, rt_rx_done_task, sc);
         TASK_INIT(&sc->tx_done_task, 0, rt_tx_done_task, sc);
 
         sc->rx_process_limit = 100;
 
         sc->taskqueue = taskqueue_create("rt_taskq", M_NOWAIT,
fail:
 
         return (error);
 }
 
 /*
  * Set media options.
  */
 static int
-rt_ifmedia_upd(struct ifnet *ifp)
+rt_ifmedia_upd(if_t ifp)
 {
         struct rt_softc *sc;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
         struct mii_softc *miisc;
         int error = 0;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         RT_SOFTC_LOCK(sc);
 
         mii = device_get_softc(sc->rt_miibus);
         LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
                 PHY_RESET(miisc);
         error = mii_mediachg(mii);
         RT_SOFTC_UNLOCK(sc);
 
         return (error);
 
 #else /* !IF_RT_PHY_SUPPORT */
 
         struct ifmedia *ifm;
         struct ifmedia_entry *ife;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         ifm = &sc->rt_ifmedia;
         ife = ifm->ifm_cur;
 
         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
                 return (EINVAL);
 
         if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
                 device_printf(sc->dev,
                     "AUTO is not supported for multiphy MAC");
                 return (EINVAL);
         }
 
         /*
          * Ignore everything
          */
         return (0);
 #endif /* IF_RT_PHY_SUPPORT */
 }
 
 /*
  * Report current media status.
  */
 static void
-rt_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
+rt_ifmedia_sts(if_t ifp, struct ifmediareq *ifmr)
 {
 #ifdef IF_RT_PHY_SUPPORT
         struct rt_softc *sc;
         struct mii_data *mii;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
 
         RT_SOFTC_LOCK(sc);
         mii = device_get_softc(sc->rt_miibus);
         mii_pollstat(mii);
         ifmr->ifm_active = mii->mii_media_active;
         ifmr->ifm_status = mii->mii_media_status;
         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
         RT_SOFTC_UNLOCK(sc);
 #else /* !IF_RT_PHY_SUPPORT */
 
         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
         ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
 #endif /* IF_RT_PHY_SUPPORT */
 }
 
 static int
 rt_detach(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int i;
 
         sc = device_get_softc(dev);
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "detaching\n");
 
         RT_SOFTC_LOCK(sc);
-        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
         callout_stop(&sc->tx_watchdog_ch);
         RT_SOFTC_UNLOCK(sc);
 
         taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
         taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
         taskqueue_drain_timeout(sc->taskqueue, &sc->periodic_task);
 
         /* free Tx and Rx rings */
rt_suspend(device_t dev)
 
         return (0);
 }
 
 static int
 rt_resume(device_t dev)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = device_get_softc(dev);
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "resuming\n");
 
-        if (ifp->if_flags & IFF_UP)
+        if (if_getflags(ifp) & IFF_UP)
                 rt_init(sc);
 
         return (0);
 }
 
 /*
  * rt_init_locked - Run initialization process having locked mtx.
  */
 static void
 rt_init_locked(void *priv)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
 #endif
         int i, ntries;
         uint32_t tmp;
 
         sc = priv;
         ifp = sc->ifp;
#endif
 
         if (rt_txrx_enable(sc) != 0)
                 goto fail;
 
 #ifdef IF_RT_PHY_SUPPORT
         if (mii) mii_mediachg(mii);
 #endif /* IF_RT_PHY_SUPPORT */
 
-        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
-        ifp->if_drv_flags |= IFF_DRV_RUNNING;
+        if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, IFF_DRV_RUNNING, 0);
 
         sc->periodic_round = 0;
 
         taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task, hz / 10);
 
         return;
 
 fail:

 
 /*
  * rt_stop_locked - stop TX/RX w/ lock
  */
 static void
 rt_stop_locked(void *priv)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = priv;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_ANY, "stopping\n");
 
         RT_SOFTC_ASSERT_LOCKED(sc);
         sc->tx_timer = 0;
-        ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+        if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
         callout_stop(&sc->tx_watchdog_ch);
         RT_SOFTC_UNLOCK(sc);
         taskqueue_block(sc->taskqueue);
 
         /*
          * Sometime rt_stop_locked called from isr and we get panic
          * When found, I fix it
          */

 }
 
 /*
  * rt_tx_data - transmit packet.
  */
 static int
 rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         struct rt_softc_tx_ring *ring;
         struct rt_softc_tx_data *data;
         struct rt_txdesc *desc;
         struct mbuf *m_d;
         bus_dma_segment_t dma_seg[RT_SOFTC_MAX_SCATTER];
         int error, ndmasegs, ndescs, i;
 
         KASSERT(qid >= 0 && qid < RT_SOFTC_TX_RING_COUNT,
for (i = 0; i < ndmasegs; i += 2) {
                  * one doesn't use word3 at all). And so does MT7621...
                  */
 
                 if (sc->rt_chipid != RT_CHIPID_MT7621) {
                         /* Set destination */
                         if (sc->rt_chipid != RT_CHIPID_MT7620)
                             desc->dst = (TXDSCR_DST_PORT_GDMA1);
 
-                        if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)
+                        if ((if_getcapenable(ifp) & IFCAP_TXCSUM) != 0)
                                 desc->dst |= (TXDSCR_IP_CSUM_GEN |
                                     TXDSCR_UDP_CSUM_GEN | TXDSCR_TCP_CSUM_GEN);
                         /* Set queue id */
                         desc->qn = qid;
                         /* No PPPoE */
                         desc->pppoe = 0;
                         /* No VLAN */
                         desc->vid = 0;
rt_tx_data(struct rt_softc *sc, struct mbuf *m, int qid)
 
         return (0);
 }
 
 /*
  * rt_start - start Transmit/Receive
  */
 static void
-rt_start(struct ifnet *ifp)
+rt_start(if_t ifp)
 {
         struct rt_softc *sc;
         struct mbuf *m;
         int qid = 0 /* XXX must check QoS priority */;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         for (;;) {
-                IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
+                m = if_dequeue(ifp);
                 if (m == NULL)
                         break;
 
                 m->m_pkthdr.rcvif = NULL;
 
                 RT_SOFTC_TX_RING_LOCK(&sc->tx_ring[qid]);
 
                 if (sc->tx_ring[qid].data_queued >=
                     RT_SOFTC_TX_RING_DATA_COUNT) {
                         RT_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
 
                         RT_DPRINTF(sc, RT_DEBUG_TX,
                             "if_start: Tx ring with qid=%d is full\n", qid);
 
                         m_freem(m);
 
-                        ifp->if_drv_flags |= IFF_DRV_OACTIVE;
+                        if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);
                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 
                         sc->tx_data_queue_full[qid]++;
 
                         break;
                 }
 
                 if (rt_tx_data(sc, m, qid) != 0) {
rt_start(if_t ifp)
         }
 }
 
 /*
  * rt_update_promisc - set/clear promiscuous mode. Unused yet, because
  * filtering done by attached Ethernet switch.
  */
 static void
-rt_update_promisc(struct ifnet *ifp)
+rt_update_promisc(if_t ifp)
 {
         struct rt_softc *sc;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         printf("%s: %s promiscuous mode\n",
                 device_get_nameunit(sc->dev),
-                (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving");
+                (if_getflags(ifp) & IFF_PROMISC) ? "entering" : "leaving");
 }
 
 /*
  * rt_ioctl - ioctl handler.
  */
 static int
-rt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
+rt_ioctl(if_t ifp, u_long cmd, caddr_t data)
 {
         struct rt_softc *sc;
         struct ifreq *ifr;
 #ifdef IF_RT_PHY_SUPPORT
         struct mii_data *mii;
 #endif /* IF_RT_PHY_SUPPORT */
         int error, startall;
 
-        sc = ifp->if_softc;
+        sc = if_getsoftc(ifp);
         ifr = (struct ifreq *) data;
 
         error = 0;
 
         switch (cmd) {
         case SIOCSIFFLAGS:
                 startall = 0;
                 RT_SOFTC_LOCK(sc);
-                if (ifp->if_flags & IFF_UP) {
-                        if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
-                                if ((ifp->if_flags ^ sc->if_flags) &
+                if (if_getflags(ifp) & IFF_UP) {
+                        if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
+                                if ((if_getflags(ifp) ^ sc->if_flags) &
                                     IFF_PROMISC)
                                         rt_update_promisc(ifp);
                         } else {
                                 rt_init_locked(sc);
                                 startall = 1;
                         }
                 } else {
-                        if (ifp->if_drv_flags & IFF_DRV_RUNNING)
+                        if (if_getdrvflags(ifp) & IFF_DRV_RUNNING)
                                 rt_stop_locked(sc);
                 }
-                sc->if_flags = ifp->if_flags;
+                sc->if_flags = if_getflags(ifp);
                 RT_SOFTC_UNLOCK(sc);
                 break;
         case SIOCGIFMEDIA:
         case SIOCSIFMEDIA:
 #ifdef IF_RT_PHY_SUPPORT
                 mii = device_get_softc(sc->rt_miibus);
                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
 #else

 
 /*
  * rt_tx_watchdog - Handler of TX Watchdog
  */
 static void
 rt_tx_watchdog(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = arg;
         ifp = sc->ifp;
 
         if (sc->tx_timer == 0)
                 return;
 
         if (--sc->tx_timer == 0) {

 
 /*
  * rt_intr - main ISR
  */
 static void
 rt_intr(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t status;
 
         sc = arg;
         ifp = sc->ifp;
 
         /* acknowledge interrupts */
         status = RT_READ(sc, sc->fe_int_status);
         RT_WRITE(sc, sc->fe_int_status, status);
 
         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
 
         if (status == 0xffffffff ||        /* device likely went away */
                 status == 0)            /* not for us */
                 return;
 
         sc->interrupts++;
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         if (status & CNT_PPE_AF)
                 rt_cnt_ppe_af(sc);
 
         if (status & CNT_GDM_AF)
                 rt_cnt_gdm_af(sc);
 

 
 /*
  * rt_rt5350_intr - main ISR for Ralink 5350 SoC
  */
 static void
 rt_rt5350_intr(void *arg)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t status;
 
         sc = arg;
         ifp = sc->ifp;
 
         /* acknowledge interrupts */
         status = RT_READ(sc, sc->fe_int_status);
         RT_WRITE(sc, sc->fe_int_status, status);
 
         RT_DPRINTF(sc, RT_DEBUG_INTR, "interrupt: status=0x%08x\n", status);
 
         if (status == 0xffffffff ||     /* device likely went away */
                 status == 0)            /* not for us */
                 return;
 
         sc->interrupts++;
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         if (status & RT5350_INT_TX_COHERENT)
                 rt_tx_coherent_intr(sc);
         if (status & RT5350_INT_RX_COHERENT)
                 rt_rx_coherent_intr(sc);
         if (status & RT5350_RX_DLY_INT)
                 rt_rx_delay_intr(sc);

 
 /*
  * rt_rx_done_task - run RX task
  */
 static void
 rt_rx_done_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         int again;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_RX, "Rx done task\n");
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         sc->intr_pending_mask &= ~sc->int_rx_done_mask;
 
         again = rt_rx_eof(sc, &sc->rx_ring[0], sc->rx_process_limit);
 
         RT_SOFTC_LOCK(sc);
 

 
 /*
  * rt_tx_done_task - check for pending TX task in all queues
  */
 static void
 rt_tx_done_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t intr_mask;
         int i;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_TX, "Tx done task\n");
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         for (i = RT_SOFTC_TX_RING_COUNT - 1; i >= 0; i--) {
                 if (sc->intr_pending_mask & (sc->int_tx_done_mask << i)) {
                         sc->intr_pending_mask &= ~(sc->int_tx_done_mask << i);
                         rt_tx_eof(sc, &sc->tx_ring[i]);
                 }
         }
 
         sc->tx_timer = 0;
 
-        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
+        if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
 
         if(sc->rt_chipid == RT_CHIPID_RT5350 ||
            sc->rt_chipid == RT_CHIPID_MT7620 ||
            sc->rt_chipid == RT_CHIPID_MT7621)
           intr_mask = (
                 RT5350_INT_TXQ3_DONE |
                 RT5350_INT_TXQ2_DONE |
                 RT5350_INT_TXQ1_DONE |
rt_tx_done_task(void *context, int pending)
         if (sc->intr_pending_mask & intr_mask) {
                 RT_DPRINTF(sc, RT_DEBUG_TX,
                     "Tx done task: scheduling again\n");
                 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
         }
 
         RT_SOFTC_UNLOCK(sc);
 
-        if (!IFQ_IS_EMPTY(&ifp->if_snd))
+        if (!if_sendq_empty(ifp))
                 rt_start(ifp);
 }
 
 /*
  * rt_periodic_task - run periodic task
  */
 static void
 rt_periodic_task(void *context, int pending)
 {
         struct rt_softc *sc;
-        struct ifnet *ifp;
+        if_t ifp;
 
         sc = context;
         ifp = sc->ifp;
 
         RT_DPRINTF(sc, RT_DEBUG_PERIODIC, "periodic task: round=%lu\n",
             sc->periodic_round);
 
-        if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
+        if (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING))
                 return;
 
         RT_SOFTC_LOCK(sc);
         sc->periodic_round++;
         rt_update_stats(sc);
 
         if ((sc->periodic_round % 10) == 0) {
                 rt_update_raw_counters(sc);
                 rt_watchdog(sc);
         }
 
         RT_SOFTC_UNLOCK(sc);
         taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task, hz / 10);
 }
 
 /*
  * rt_rx_eof - check for frames that done by DMA engine and pass it into
  * network subsystem.
  */
 static int
 rt_rx_eof(struct rt_softc *sc, struct rt_softc_rx_ring *ring, int limit)
 {
-        struct ifnet *ifp;
+        if_t ifp;
 /*      struct rt_softc_rx_ring *ring; */
         struct rt_rxdesc *desc;
         struct rt_softc_rx_data *data;
         struct mbuf *m, *mnew;
         bus_dma_segment_t segs[1];
         bus_dmamap_t dma_map;
         uint32_t index, desc_flags;
         int error, nsegs, len, nframes;
RT_DPRINTF(sc, RT_DEBUG_RX,
                     "Rx frame: rxdesc flags=0x%08x\n", desc_flags);
 
                 m->m_pkthdr.rcvif = ifp;
                 /* Add 2 to fix data align, after sdp0 = addr + 2 */
                 m->m_data += 2;
                 m->m_pkthdr.len = m->m_len = len;
 
                 /* check for crc errors */
-                if ((ifp->if_capenable & IFCAP_RXCSUM) != 0) {
+                if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0) {
                         /*check for valid checksum*/
                         if (desc_flags & (sc->csum_fail_ip|sc->csum_fail_l4)) {
                                 RT_DPRINTF(sc, RT_DEBUG_RX,
                                     "rxdesc: crc error\n");
 
                                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 
-                                if (!(ifp->if_flags & IFF_PROMISC)) {
+                                if (!(if_getflags(ifp) & IFF_PROMISC)) {
                                     m_freem(m);
                                     goto skip;
                                 }
                         }
                         if ((desc_flags & sc->csum_fail_ip) == 0) {
                                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
                                 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
                                 m->m_pkthdr.csum_data = 0xffff;
                         }
                         m->m_flags &= ~M_HASFCS;
                 }
 
-                (*ifp->if_input)(ifp, m);
+                if_input(ifp, m);
 skip:
                 desc->sdl0 &= ~htole16(RT_RXDESC_SDL0_DDONE);
 
                 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
                         BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 
                 ring->cur = (ring->cur + 1) % RT_SOFTC_RX_RING_DATA_COUNT;
 

 
 /*
  * rt_tx_eof - check for successful transmitted frames and mark their
  * descriptor as free.
  */
 static void
 rt_tx_eof(struct rt_softc *sc, struct rt_softc_tx_ring *ring)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         struct rt_txdesc *desc;
         struct rt_softc_tx_data *data;
         uint32_t index;
         int ndescs, nframes;
 
         ifp = sc->ifp;
 
         ndescs = 0;

 }
 
 /*
  * rt_update_stats - query statistics counters and update related variables.
  */
 static void
 rt_update_stats(struct rt_softc *sc)
 {
-        struct ifnet *ifp;
+        if_t ifp;
 
         ifp = sc->ifp;
         RT_DPRINTF(sc, RT_DEBUG_STATS, "update statistic: \n");
         /* XXX do update stats here */
 }
 
 /*
  * rt_watchdog - reinit device on watchdog event.

 }
 
 /*
  * rt_txrx_enable - enable TX/RX DMA
  */
 static int
 rt_txrx_enable(struct rt_softc *sc)
 {
-        struct ifnet *ifp;
+        if_t ifp;
         uint32_t tmp;
         int ntries;
 
         ifp = sc->ifp;
 
         /* enable Tx/Rx DMA engine */
         for (ntries = 0; ntries < 200; ntries++) {
                 tmp = RT_READ(sc, sc->pdma_glo_cfg);