stand/elf: Only support swapping headers on powerpc.

[imp]

Summary

Powerpc is currently the only architecture that we support more than one
endian. It's the only one that benefits from this swapping, so restrict
the code to there. This saves about 1k in the i386 BIOS loader.

Sponsored by: Netflix

stand/common/load_elf.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);