Changeset 573b4cd6 in rtems-libbsd for rtemsbsd/sys


Ignore:
Timestamp:
10/08/14 06:04:59 (9 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
4.11, 5, 5-freebsd-12, 6-freebsd-12, freebsd-9.3, master
Children:
403d0b8
Parents:
70fa95a
git-author:
Sebastian Huber <sebastian.huber@…> (10/08/14 06:04:59)
git-committer:
Sebastian Huber <sebastian.huber@…> (10/08/14 13:03:29)
Message:

ppp: Port to new stack

Location:
rtemsbsd/sys/net
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • rtemsbsd/sys/net/if_ppp.c

    r70fa95a r573b4cd6  
     1#include <machine/rtems-bsd-kernel-space.h>
     2
    13/*
    24 * if_ppp.c - Point-to-Point Protocol (PPP) Asynchronous driver.
    … …  
    8082#endif
    8183
    82 #include "opt_inet.h"
    83 #include "opt_ipx.h"
    84 #include "opt_mac.h"
    85 #include "opt_ppp.h"
     84#include <rtems/bsd/local/opt_inet.h>
     85#include <rtems/bsd/local/opt_ipx.h>
     86#include <rtems/bsd/local/opt_mac.h>
     87#include <rtems/bsd/local/opt_ppp.h>
    8688
    8789#if NPPP > 0
    … …  
    9193#include <rtems/rtems_bsdnet.h>
    9294#include <rtems/rtemspppd.h>
    93 #include <sys/param.h>
     95#include <rtems/bsd/sys/param.h>
    9496#include <sys/systm.h>
    9597#include <sys/proc.h>
    … …  
    100102#include <sys/time.h>
    101103#include <sys/malloc.h>
     104#include <sys/module.h>
     105
     106#include <sys/bus.h>
     107#include <machine/bus.h>
    102108
    103109#include <net/if.h>
    … …  
    189195#endif /* PPP_COMPRESS */
    190196
    191 extern struct ifqueue    ipintrq;
    192197static struct timeval    ppp_time;
    193198
    … …  
    199204ppp_unit(struct ppp_softc *sc)
    200205{
    201   return sc->sc_if.if_unit;
     206  return device_get_unit(sc->sc_dev);
    202207}
    203208
    … …  
    205210{
    206211  rtems_event_set             events;
    207   rtems_interrupt_level       level;
    208212  struct ppp_softc           *sc = (struct ppp_softc *)arg;
    209213  struct mbuf                *mp = (struct mbuf      *)0;
    … …  
    220224
    221225    if ( events ) {
    222       /* get the network semaphore */
    223       rtems_bsdnet_semaphore_obtain();
    224 
    225226      /* check to see if new packet was received */
    226227      if ( events & RX_PACKET ) {
    227228        /* get received packet mbuf chain */
    228         rtems_interrupt_disable(level);
    229         IF_DEQUEUE(&sc->sc_rawq, m);
    230         rtems_interrupt_enable(level);
     229        m = if_ppp_dequeue(&sc->sc_rawq);
    231230
    232231        /* ensure packet was retrieved */
    … …  
    243242
    244243      /* place mbuf on freeq */
    245       rtems_interrupt_disable(level);
    246       IF_ENQUEUE(&sc->sc_freeq, mp);
    247       rtems_interrupt_enable(level);
     244      if_ppp_enqueue(&sc->sc_freeq, mp);
    248245      mp = (struct mbuf *)0;
    249 
    250       /* release the network semaphore */
    251       rtems_bsdnet_semaphore_release();
    252246
    253247      /* check to see if queue is empty */
    … …  
    280274    if ( events & TX_TRANSMIT ) {
    281275      /* received event from interrupt handler - free current mbuf */
    282       rtems_bsdnet_semaphore_obtain();
    283 
    284276      m_freem(sc->sc_outm);
    285      
    286       rtems_bsdnet_semaphore_release();
    287277
    288278      /* chain is done - clear the values */
    … …  
    304294          /* clear output flags */
    305295          sc->sc_outflag      = 0;
    306           sc->sc_if.if_flags &= ~IFF_OACTIVE;
     296          sc->sc_ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
    307297        }
    308298        else {
    … …  
    310300          iprocess            = 1;
    311301          sc->sc_outflag      = SC_TX_BUSY;
    312           sc->sc_if.if_flags |= IFF_OACTIVE;
     302          sc->sc_ifp->if_drv_flags |= IFF_DRV_OACTIVE;
    313303        }
    314304      }
    … …  
    390380        sc->sc_outfcsbuf[sc->sc_outfcslen++] = ~sc->sc_outfcs & 0xff;
    391381        sc->sc_outfcsbuf[sc->sc_outfcslen++] = (~sc->sc_outfcs >> 8) & 0xff;
    392         microtime(&sc->sc_if.if_lastchange);
     382        microtime(&sc->sc_ifp->if_lastchange);
    393383 
    394384        /* write out frame byte to start the transmission */
    … …  
    400390      if ( mf != (struct mbuf *)0 ) {
    401391        /* free empty mbufs */
    402         rtems_bsdnet_semaphore_obtain();
    403392        m_freem(mf);
    404         rtems_bsdnet_semaphore_release();
    405393      }
    406394    }
    … …  
    412400  rtems_status_code   status;
    413401  uint32_t      priority = 100;
    414 
    415   /* determine priority value */
    416   if ( rtems_bsdnet_config.network_task_priority ) {
    417     priority = rtems_bsdnet_config.network_task_priority;
    418   }
    419402
    420403  /* check to see if we need to start up daemons */
    … …  
    453436  /* mark driver running and output inactive */
    454437  /* ilya: IFF_RUNNING flag will be marked after the IPCP goes up */
    455 /*  sc->sc_if.if_flags |= IFF_RUNNING;  */
     438/*  sc->sc_ifp->if_flags |= IFF_RUNNING;        */
    456439}
    457440
    … …  
    459442 * Called from boot code to establish ppp interfaces.
    460443 */
    461 int rtems_ppp_driver_attach(struct rtems_bsdnet_ifconfig *config, int attaching)
     444static int ppp_attach(device_t dev)
    462445{
    463 /*    int                 i = (int)0;   */
    464     struct ppp_softc   *sc;
    465     char               *name;
    466     int                 number;
    467    
    468    
    469     number = rtems_bsdnet_parse_driver_name (config, &name);
    470    
    471     if (!attaching || (number >= NPPP))
    472         return 0;
    473        
    474     sc = &ppp_softc[number];
    475    
    476     if (sc->sc_if.if_name != NULL)
    477         return 0;       /* interface is already attached */
    478    
    479 /*    for (sc = ppp_softc; i < NPPP; sc++) {    */
    480         sc->sc_if.if_name = name /*"ppp"*/;
    481         sc->sc_if.if_unit = number /*i++*/;
    482         sc->sc_if.if_mtu = PPP_MTU;
    483         sc->sc_if.if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
    484         sc->sc_if.if_type = IFT_PPP;
    485         sc->sc_if.if_hdrlen = PPP_HDRLEN;
    486         sc->sc_if.if_ioctl = pppsioctl;
    487         sc->sc_if.if_output = pppoutput;
    488         sc->sc_if.if_snd.ifq_maxlen = IFQ_MAXLEN;
    489         sc->sc_inq.ifq_maxlen = IFQ_MAXLEN;
    490         sc->sc_fastq.ifq_maxlen = IFQ_MAXLEN;
    491         sc->sc_rawq.ifq_maxlen = IFQ_MAXLEN;
    492         sc->sc_freeq.ifq_maxlen = NUM_MBUFQ;
    493 
    494         /* initialize and attach */
    495         ppp_init(sc);
    496         if_attach(&sc->sc_if);
    497 #if NBPFILTER > 0
    498         bpfattach(&sc->sc_bpf, &sc->sc_if, DLT_PPP, PPP_HDRLEN);
    499 #endif
    500 /*    } */
    501 
    502     return ( 1 );
     446    int unit = device_get_unit(dev);
     447    struct ppp_softc *sc;
     448    struct ifnet *ifp;
     449
     450    if (unit >= NPPP)
     451        return (ENXIO);
     452
     453    sc = &ppp_softc[unit];
     454    device_set_softc(dev, sc);
     455
     456    sc->sc_ifp = ifp = if_alloc(IFT_PPP);
     457    if (sc->sc_ifp == NULL)
     458        return (ENOMEM);
     459
     460    sc->sc_dev = dev;
     461    sc->sc_inq.ifq_maxlen = IFQ_MAXLEN;
     462    sc->sc_rawq.ifq_maxlen = IFQ_MAXLEN;
     463    sc->sc_freeq.ifq_maxlen = NUM_MBUFQ;
     464
     465    ifq_init(&sc->sc_fastq, ifp);
     466
     467    if_initname(ifp, device_get_name(dev), device_get_unit(dev));
     468    ifp->if_softc = sc;
     469    ifp->if_mtu = PPP_MTU;
     470    ifp->if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
     471    ifp->if_type = IFT_PPP;
     472    ifp->if_hdrlen = PPP_HDRLEN;
     473    ifp->if_ioctl = pppsioctl;
     474    ifp->if_output = pppoutput;
     475    ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
     476
     477    /* initialize and attach */
     478    ppp_init(sc);
     479    if_attach(ifp);
     480
     481    return 0;
    503482}
    504483
    … …  
    554533{
    555534    struct mbuf *m;
    556     rtems_interrupt_level       level;
    557 
    558     if_down(&sc->sc_if);
    559     sc->sc_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
     535
     536    if_down(sc->sc_ifp);
     537    sc->sc_ifp->if_flags &= ~IFF_UP;
     538    sc->sc_ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
    560539    sc->sc_devp = NULL;
    561540    sc->sc_xfer = 0;
    562541
    563     rtems_interrupt_disable(level);
    564542    if ( sc->sc_m != NULL ) {
    565543        m_freem(sc->sc_m);
    … …  
    573551    }
    574552    do {
    575       IF_DEQUEUE(&sc->sc_freeq, m);
     553      m = if_ppp_dequeue(&sc->sc_freeq);
    576554      if (m != NULL) {
    577555        m_freem(m);
    … …  
    579557    } while ( m != NULL );
    580558    do {
    581       IF_DEQUEUE(&sc->sc_rawq, m);
     559      m = if_ppp_dequeue(&sc->sc_rawq);
    582560      if (m != NULL) {
    583561        m_freem(m);
    584562      }
    585563    } while ( m != NULL );
    586     rtems_interrupt_enable(level);
    587564
    588565    for (;;) {
    … …  
    851828{
    852829    /*struct proc *p = curproc;*/       /* XXX */
    853     register struct ppp_softc *sc = &ppp_softc[ifp->if_unit];
     830    register struct ppp_softc *sc = ifp->if_softc;
    854831    register struct ifaddr *ifa = (struct ifaddr *)data;
    855832    register struct ifreq *ifr = (struct ifreq *)data;
    … …  
    862839    switch (cmd) {
    863840    case SIOCSIFFLAGS:
    864         if ((ifp->if_flags & IFF_RUNNING) == 0)
     841        if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
    865842            ifp->if_flags &= ~IFF_UP;
    866843        break;
    … …  
    877854
    878855    case SIOCSIFMTU:
    879         sc->sc_if.if_mtu = ifr->ifr_mtu;
     856        sc->sc_ifp->if_mtu = ifr->ifr_mtu;
    880857        break;
    881858
    882859    case SIOCGIFMTU:
    883         ifr->ifr_mtu = sc->sc_if.if_mtu;
     860        ifr->ifr_mtu = sc->sc_ifp->if_mtu;
    884861        break;
    885862
    … …  
    899876            break;
    900877        }
    901         break;
    902 
    903     case SIO_RTEMS_SHOW_STATS:
    904         printf("              MRU:%-8u",   sc->sc_mru);
    905         printf("   Bytes received:%-8u",   sc->sc_stats.ppp_ibytes);
    906         printf(" Packets received:%-8u",   sc->sc_stats.ppp_ipackets);
    907         printf("   Receive errors:%-8u\n", sc->sc_stats.ppp_ierrors);
    908         printf("       Bytes sent:%-8u",   sc->sc_stats.ppp_obytes);
    909         printf("     Packets sent:%-8u",   sc->sc_stats.ppp_opackets);
    910         printf("  Transmit errors:%-8u\n", sc->sc_stats.ppp_oerrors);
    911878        break;
    912879
    … …  
    953920int
    954921pppoutput(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
    955     struct rtentry *rtp)
     922    struct route *rtp)
    956923{
    957     register struct ppp_softc *sc = &ppp_softc[ifp->if_unit];
     924    register struct ppp_softc *sc = ifp->if_softc;
    958925    int protocol, address, control;
    959926    u_char *cp;
    960927    int s, error;
    961928    struct ip *ip;
    962     struct ifqueue *ifq;
     929    struct ifaltq *ifq;
    963930    enum NPmode mode;
    964931    int len;
    965932    struct mbuf *m;
    966933
    967     if (sc->sc_devp == NULL || (ifp->if_flags & IFF_RUNNING) == 0
     934    if (sc->sc_devp == NULL || (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0
    968935        || ((ifp->if_flags & IFF_UP) == 0 && dst->sa_family != AF_UNSPEC)) {
    969936        error = ENETDOWN;       /* sort of */
    … …  
    10961063    } else {
    10971064        ifq = (m0->m_flags & M_HIGHPRI)? &sc->sc_fastq: &ifp->if_snd;
    1098         if (IF_QFULL(ifq) && dst->sa_family != AF_UNSPEC) {
    1099             IF_DROP(ifq);
     1065        if (_IF_QFULL(ifq) && dst->sa_family != AF_UNSPEC) {
     1066            IFQ_INC_DROPS(ifq);
    11001067            splx(s);
    1101             sc->sc_if.if_oerrors++;
     1068            sc->sc_ifp->if_oerrors++;
    11021069            sc->sc_stats.ppp_oerrors++;
    11031070            error = ENOBUFS;
    … …  
    11281095{
    11291096    struct mbuf *m, **mpp;
    1130     struct ifqueue *ifq;
     1097    struct ifaltq *ifq;
    11311098    enum NPmode mode;
    11321099
    … …  
    11471114            *mpp = m->m_nextpkt;
    11481115            m->m_nextpkt = NULL;
    1149             ifq = (m->m_flags & M_HIGHPRI)? &sc->sc_fastq: &sc->sc_if.if_snd;
    1150             if (IF_QFULL(ifq)) {
    1151                 IF_DROP(ifq);
    1152                 sc->sc_if.if_oerrors++;
     1116            ifq = (m->m_flags & M_HIGHPRI)? &sc->sc_fastq: &sc->sc_ifp->if_snd;
     1117            if (_IF_QFULL(ifq)) {
     1118                IFQ_INC_DROPS(ifq);
     1119                sc->sc_ifp->if_oerrors++;
    11531120                sc->sc_stats.ppp_oerrors++;
    11541121            } else
    … …  
    11901157     * normal queue.
    11911158     */
    1192     rtems_bsdnet_semaphore_obtain();
    11931159    IF_DEQUEUE(&sc->sc_fastq, m);
    11941160    if (m == NULL)
    1195         IF_DEQUEUE(&sc->sc_if.if_snd, m);
    1196     rtems_bsdnet_semaphore_release();
     1161        IF_DEQUEUE(&sc->sc_ifp->if_snd, m);
    11971162
    11981163    if (m == NULL)
    … …  
    12671232            slen += mp->m_len;
    12681233        clen = (*sc->sc_xcomp->compress)
    1269             (sc->sc_xc_state, &mcomp, m, slen, sc->sc_if.if_mtu + PPP_HDRLEN);
     1234            (sc->sc_xc_state, &mcomp, m, slen, sc->sc_ifp->if_mtu + PPP_HDRLEN);
    12701235        if (mcomp != NULL) {
    12711236            if (sc->sc_flags & SC_CCP_UP) {
    … …  
    14301395{
    14311396    struct mbuf  *mf = (struct mbuf *)0;
    1432     struct ifnet *ifp = &sc->sc_if;
     1397    struct ifnet *ifp = sc->sc_ifp;
    14331398    struct ifqueue *inq;
    14341399    int s, ilen, proto, rv;
    … …  
    16811646        m->m_data += PPP_HDRLEN;
    16821647        m->m_len -= PPP_HDRLEN;
    1683         schednetisr(NETISR_IP);
    1684         inq = &ipintrq;
     1648        netisr_dispatch(NETISR_IP, m);
    16851649        break;
    16861650#endif
    … …  
    16921656        inq = &sc->sc_inq;
    16931657        rv = 1;
    1694         break;
    1695     }
    1696 
    1697     /*
    1698      * Put the packet on the appropriate input queue.
    1699      */
    1700     s = splimp();
    1701     if (IF_QFULL(inq)) {
    1702         IF_DROP(inq);
     1658
     1659        /*
     1660         * Put the packet on the appropriate input queue.
     1661         */
     1662        s = splimp();
     1663        if (_IF_QFULL(inq)) {
     1664            IFQ_INC_DROPS(inq);
     1665            splx(s);
     1666            if (sc->sc_flags & SC_DEBUG)
     1667                printf("ppp%d: input queue full\n", ppp_unit(sc));
     1668            ifp->if_iqdrops++;
     1669            goto bad;
     1670        }
     1671        IF_ENQUEUE(inq, m);
    17031672        splx(s);
    1704         if (sc->sc_flags & SC_DEBUG)
    1705             printf("ppp%d: input queue full\n", ppp_unit(sc));
    1706         ifp->if_iqdrops++;
    1707         goto bad;
    1708     }
    1709     IF_ENQUEUE(inq, m);
    1710     splx(s);
     1673
     1674        break;
     1675    }
    17111676
    17121677    ifp->if_ipackets++;
    … …  
    17231688 bad:
    17241689    m_freem(m);
    1725     sc->sc_if.if_ierrors++;
     1690    sc->sc_ifp->if_ierrors++;
    17261691    sc->sc_stats.ppp_ierrors++;
    17271692    return mf;
    … …  
    17631728}
    17641729
     1730static int ppp_probe(device_t dev)
     1731{
     1732    int unit = device_get_unit(dev);
     1733    int error;
     1734
     1735    if (unit < NPPP) {
     1736        error = BUS_PROBE_DEFAULT;
     1737    } else {
     1738        error = ENXIO;
     1739    }
     1740
     1741    return error;
     1742}
     1743
     1744static device_method_t ppp_methods[] = {
     1745    /* Device interface */
     1746    DEVMETHOD(device_probe, ppp_probe),
     1747    DEVMETHOD(device_attach, ppp_attach),
     1748
     1749    DEVMETHOD_END
     1750};
     1751
     1752static driver_t ppp_nexus_driver = {
     1753    "ppp",
     1754    ppp_methods,
     1755    0,
     1756    NULL,
     1757    0,
     1758    NULL
     1759};
     1760
     1761static devclass_t ppp_devclass;
     1762
     1763DRIVER_MODULE(ppp, nexus, ppp_nexus_driver, ppp_devclass, 0, 0);
     1764MODULE_DEPEND(ppp, nexus, 1, 1, 1);
     1765
    17651766#endif  /* NPPP > 0 */

  • rtemsbsd/sys/net/if_pppvar.h

    r70fa95a r573b4cd6  
    7070 */
    7171struct ppp_softc {
    72         struct  ifnet sc_if;            /* network-visible interface */
     72        device_t sc_dev;
     73        struct mtx sc_mtx;
     74        struct  ifnet *sc_ifp;          /* network-visible interface */
    7375        u_int   sc_flags;               /* control/status bits; see if_ppp.h */
    7476        void    *sc_devp;               /* pointer to device-dep structure */
    … …  
    7880        short   sc_mru;                 /* max receive unit */
    7981        pid_t   sc_xfer;                /* used in transferring unit */
    80         struct  ifqueue sc_rawq;        /* received packets */
     82        struct  ifqueue sc_rawq;                /* received packets */
    8183        struct  ifqueue sc_inq;         /* queue of input packets for daemon */
    82         struct  ifqueue sc_fastq;       /* interactive output packet q */
     84        struct  ifaltq sc_fastq;        /* interactive output packet q */
    8385        struct  mbuf *sc_npqueue;       /* output packets not to be sent yet */
    8486        struct  mbuf **sc_npqtail;      /* ptr to last next ptr in npqueue */
    … …  
    131133void    pppdealloc(struct ppp_softc *sc);
    132134int     pppoutput(struct ifnet *, struct mbuf *,
    133                        struct sockaddr *, struct rtentry *);
     135                       struct sockaddr *, struct route *);
    134136int     pppioctl(struct ppp_softc *sc, ioctl_command_t cmd, caddr_t data,
    135137                      int flag, struct proc *p);
    … …  
    154156#define SC_TX_PENDING   0x0010
    155157
     158/*
     159 * Special interface queue functions to exchange mbufs between task and
     160 * interrupt context via pppinput() and pppstart().
     161 */
     162
     163static inline void
     164if_ppp_enqueue(struct ifqueue *ifq, struct mbuf *m)
     165{
     166        rtems_interrupt_level level;
     167
     168        rtems_interrupt_disable(level);
     169        _IF_ENQUEUE(ifq, m);
     170        rtems_interrupt_enable(level);
     171}
     172
     173static inline struct mbuf *
     174if_ppp_dequeue(struct ifqueue *ifq)
     175{
     176        struct mbuf *m;
     177        rtems_interrupt_level level;
     178
     179        rtems_interrupt_disable(level);
     180        _IF_DEQUEUE(ifq, m);
     181        rtems_interrupt_enable(level);
     182
     183        return m;
     184}
     185
    156186#ifdef __cplusplus
    157187}

  • rtemsbsd/sys/net/ppp_tty.c

    r70fa95a r573b4cd6  
     1#include <machine/rtems-bsd-kernel-space.h>
     2
    13/*
    24 * ppp_tty.c - Point-to-Point Protocol (PPP) driver for asynchronous
    … …  
    7981#endif
    8082
    81 #include "opt_ppp.h"            /* XXX for ppp_defs.h */
     83#include <rtems/bsd/local/opt_ppp.h>            /* XXX for ppp_defs.h */
    8284
    8385#if NPPP > 0
    8486
    85 #include <sys/param.h>
     87#include <rtems/bsd/sys/param.h>
    8688#include <sys/systm.h>
    8789#include <sys/proc.h>
    … …  
    227229   
    228230    /* preallocate mbufs for free queue */
    229     rtems_bsdnet_semaphore_obtain();
    230231    for (i=0; i<NUM_MBUFQ; i++) {
    231232      pppallocmbuf(sc, &m);
    … …  
    236237      else {
    237238        /* enqueue mbuf for later use */
    238         IF_ENQUEUE(&sc->sc_freeq, m);
     239        if_ppp_enqueue(&sc->sc_freeq, m);
    239240      }
    240241      m = (struct mbuf *)0;
    241242    }
    242     rtems_bsdnet_semaphore_release();
    243243
    244244    /* initialize values */
    245     sc->sc_if.if_flags |= IFF_RUNNING;
    246     sc->sc_if.if_baudrate =
     245    sc->sc_ifp->if_drv_flags |= IFF_DRV_RUNNING;
     246    sc->sc_ifp->if_baudrate =
    247247        rtems_termios_baud_to_number(tty->termios.c_cflag & CBAUD);
    248248
    … …  
    268268        tty->t_sc = NULL;
    269269        if (tty == (struct rtems_termios_tty *)sc->sc_devp) {
    270             rtems_bsdnet_semaphore_obtain();
    271270            pppasyncrelinq(sc);
    272271            pppdealloc(sc);
    273             rtems_bsdnet_semaphore_release();
    274272        }
    275273    }
    … …  
    329327
    330328    /* Get the packet from the input queue */
    331     rtems_bsdnet_semaphore_obtain();
    332329    IF_DEQUEUE(&sc->sc_inq, m0);
    333330
    … …  
    348345    /* free mbuf chain */
    349346    m_freem(m0);
    350     rtems_bsdnet_semaphore_release();
    351347
    352348    /* update return values */
    … …  
    381377    struct mbuf                 **mp;
    382378
    383     rtems_bsdnet_semaphore_obtain();
    384379    for (mp = &m0; maximum; mp = &m->m_next) {
    385380        MGET(m, M_WAIT, MT_DATA);
    … …  
    411406    m0->m_len  -= PPP_HDRLEN;
    412407
    413     n = pppoutput(&sc->sc_if, m0, &dst, (struct rtentry *)0);
    414     rtems_bsdnet_semaphore_release();
     408    n = pppoutput(sc->sc_ifp, m0, &dst, NULL);
    415409
    416410    return ( n );
    … …  
    471465
    472466    default:
    473         rtems_bsdnet_semaphore_obtain();
    474467        error = pppioctl(sc, cmd, data, 0, NULL);
    475         rtems_bsdnet_semaphore_release();
    476468    }
    477469    return error;
    … …  
    747739    if (sc->sc_m == NULL) {
    748740        rtems_event_send(sc->sc_rxtask, RX_EMPTY);
    749         IF_DEQUEUE(&sc->sc_freeq, sc->sc_m);
     741        sc->sc_m = if_ppp_dequeue(&sc->sc_freeq);
    750742        if ( sc->sc_m == NULL ) {
    751743          return 0;
    … …  
    778770            if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){
    779771                /* bad fcs error */
    780                 sc->sc_if.if_ierrors++;
     772                sc->sc_ifp->if_ierrors++;
    781773                sc->sc_stats.ppp_ierrors++;
    782774            } else
    … …  
    788780            if (ilen) {
    789781                /* too short error */
    790                 sc->sc_if.if_ierrors++;
     782                sc->sc_ifp->if_ierrors++;
    791783                sc->sc_stats.ppp_ierrors++;
    792784                sc->sc_flags |= SC_PKTLOST;
    … …  
    809801          sc->sc_flags &= ~SC_PKTLOST;
    810802        }
    811         IF_ENQUEUE(&sc->sc_rawq, m);
     803        if_ppp_enqueue(&sc->sc_rawq, m);
    812804
    813805        /* setup next mbuf chain */
    814         IF_DEQUEUE(&sc->sc_freeq, sc->sc_m);
     806        sc->sc_m = if_ppp_dequeue(&sc->sc_freeq);
    815807
    816808        /* send rx packet event */
    … …  
    883875        if (m->m_next == NULL) {
    884876          /* get next available mbuf for the chain */
    885           IF_DEQUEUE(&sc->sc_freeq, m->m_next);
     877          m->m_next = if_ppp_dequeue(&sc->sc_freeq);
    886878          if (m->m_next == NULL) {
    887879            /* too few mbufs */
    … …  
    907899 flush:
    908900    if (!(sc->sc_flags & SC_FLUSH)) {
    909         sc->sc_if.if_ierrors++;
     901        sc->sc_ifp->if_ierrors++;
    910902        sc->sc_stats.ppp_ierrors++;
    911903        sc->sc_flags |= SC_FLUSH;
Note: See TracChangeset for help on using the changeset viewer.