net_if_pkt.c

uCOS-II V2.84 LM3S6965 TCPIP Demo

#if (NET_CFG_LOAD_BAL_EN == DEF_ENABLED)                        /* --------------- HANDLE NET LOAD BAL ---------------- */
        NetIF_Pkt_RxHandlerLoadBal();
#endif


        NetOS_Unlock();                                         /* Release net lock.                                    */
    }
}


/*$PAGE*/
/*
*********************************************************************************************************
*                                           NetIF_Pkt_Tx()
*
* Description : (1) Transmit data packets from network interface layer to network interface card :
*
*                   (a) Check    NIC status
*                   (b) Prepare  NIC transmit packet(s)
*                   (c) Wait for NIC transmit ready signal
*                   (d) Transmit packet(s)
*                   (e) Free   transmit packet buffer(s)
*                   (f) Update transmit statistics
*
*
* Argument(s) : pbuf        Pointer to network buffer with data packet to transmit.
*
*               perr        Pointer to variable that will receive the return error code from this function :
*
*                               NET_IF_ERR_NONE                 Packet successfully transmitted.
*                               NET_ERR_INIT_INCOMPLETE         Network initialization NOT complete.
*
*                                                               - RETURNED BY NetIF_Pkt_TxPktDiscard() : -
*                               NET_ERR_TX                      Transmit error; packet discarded.
*
* Return(s)   : none.
*
* Caller(s)   : NetIF_TxPktHandler().
*
* Note(s)     : (2) NetIF_Pkt_Tx() blocked until network initialization completes; perform NO action.
*********************************************************************************************************
*/

void  NetIF_Pkt_Tx (NET_BUF  *pbuf,
                    NET_ERR  *perr)
{
#if ((NET_CTR_CFG_STAT_EN     == DEF_ENABLED)                    && \
     (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
    CPU_SR         cpu_sr;
#endif
    NET_BUF_HDR   *pbuf_hdr;
    NET_BUF_SIZE   size;
    CPU_INT08U    *p_data;
    CPU_BOOLEAN    conn_status;


#if (NET_ERR_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
    if (Net_InitDone != DEF_YES) {                              /* If init NOT complete, exit tx (see Note #2).         */
        NetIF_Pkt_TxPktDiscard(pbuf, perr);
       *perr = NET_ERR_INIT_INCOMPLETE;
        return;
    }
#endif


#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
                                                                /* ------------------- VALIDATE PTR ------------------- */
    if (pbuf == (NET_BUF *)0) {
        NetIF_Pkt_TxPktDiscard(pbuf, perr);
        return;
    }
#endif


                                                                /* ----------------- VALIDATE DRV PKT ----------------- */
    pbuf_hdr = &pbuf->Hdr;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
    NetIF_Pkt_TxPktValidate(pbuf, pbuf_hdr, perr);
    switch (*perr) {
        case NET_IF_ERR_NONE:
             break;


        case NET_ERR_INVALID_PROTOCOL:
        case NET_BUF_ERR_INVALID_IX:
        default:
             NetIF_Pkt_TxPktDiscard(pbuf, perr);
             return;                                            /* Prevent 'break NOT reachable' compiler warning.      */
    }
#endif


/*$PAGE*/
                                                                /* ------------------ CHK NIC STATUS ------------------ */
    conn_status = NetNIC_ConnStatusGet();
    switch (conn_status) {
        case DEF_ON:
             break;


        case DEF_OFF:
        default:
             NetIF_Pkt_TxPktDiscard(pbuf, perr);
             return;                                            /* Prevent 'break NOT reachable' compiler warning.      */
    }


                                                                /* ---------------- PREPARE NIC TX PKT ---------------- */
    p_data = &pbuf->Data[pbuf_hdr->IF_HdrIx];
    size   =  pbuf_hdr->TotLen;

#if (NET_NIC_CFG_TX_PKT_PREPARE_EN == DEF_ENABLED)
    NetNIC_TxPktPrepare((void     *)p_data,
                        (CPU_INT16U)size,
                        (NET_ERR  *)perr);
    switch (*perr) {
        case NET_NIC_ERR_NONE:
             break;


        default:
             NetIF_Pkt_TxPktDiscard(pbuf, perr);
             return;                                            /* Prevent 'break NOT reachable' compiler warning.      */
    }
#endif


                                                                /* ---- WAIT FOR NIC TX READY SIGNAL & TX NIC PKT ----- */
    NetOS_NIC_TxRdyWait(perr);
    switch (*perr) {
        case NET_NIC_ERR_NONE:
             NetNIC_TxPkt((void     *)p_data,
                          (CPU_INT16U)size,
                          (NET_ERR  *)perr);
             break;


        case NET_NIC_ERR_TX_RDY_SIGNAL_TIMEOUT:
        default:
             NetIF_Pkt_TxPktDiscard(pbuf, perr);
             return;                                            /* Prevent 'break NOT reachable' compiler warning.      */
    }


                                                                /* ---------- FREE TX PKT / UPDATE TX STATS ----------- */
    switch (*perr) {                                            /* Chk err from NetNIC_TxPkt().                         */
        case NET_NIC_ERR_NONE:
             NetIF_Pkt_TxPktFree(pbuf);
             NET_CTR_STAT_INC(NetIF_Pkt_StatTxPktCtr);
            *perr = NET_IF_ERR_NONE;
             break;


        default:
             NetIF_Pkt_TxPktDiscard(pbuf, perr);
             return;                                            /* Prevent 'break NOT reachable' compiler warning.      */
    }
}


/*$PAGE*/
/*
*********************************************************************************************************
*********************************************************************************************************
*                                           LOCAL FUNCTIONS
*********************************************************************************************************
*********************************************************************************************************
*/

/*
*********************************************************************************************************
*                                           NetIF_Pkt_Rx()
*
* Description : (1) Receive data packets from network interface card & demultiplex to network interface layer :
*
*                   (a) Validate receive packet size
*                   (b) Get network buffer of sufficient size to receive packet
*                   (c) Read receive packet from NIC
*                   (d) Demultiplex to network interface layer
*                   (e) Update receive statistics
*
*
* Argument(s) : none.
*
* Return(s)   : none.
*
* Caller(s)   : NetIF_RxTaskHandler().
*
* Note(s)     : (2) When network buffer is demultiplexed to network IF receive, the buffer's reference  
*                   counter is NOT incremented since the packet interface layer does NOT maintain a 
*                   reference to the buffer.
*
*               (3) Network buffer already freed by higher layer; only increment error counter.
*********************************************************************************************************
*/

static  void  NetIF_Pkt_Rx (void)
{
#if (((NET_CTR_CFG_STAT_EN     == DEF_ENABLED)                    || \
      (NET_CTR_CFG_ERR_EN      == DEF_ENABLED))                   && \
      (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
    CPU_SR        cpu_sr;
#endif
    NET_ERR       err_rx;
    CPU_BOOLEAN   size_valid;
    CPU_INT16U    size;
    CPU_INT16U    ix_rx;
    NET_BUF      *pbuf;
    NET_BUF_HDR  *pbuf_hdr;
    CPU_INT08U   *p_data;



    NET_CTR_STAT_INC(NetIF_Pkt_StatRxPktCtr);


                                                                /* --------------- VALIDATE RX PKT SIZE --------------- */
    size       = NetNIC_RxPktGetSize();                         /* Get pkt size.                                        */
    size_valid = NetIF_IsValidPktSize(size);
    if (size_valid != DEF_YES) {
        NetNIC_RxPktDiscard(size, &err_rx);                     /* If size err, rd data from NIC & discard.             */
        NetIF_Pkt_RxPktDiscard((NET_BUF *)0);
        return;
    }


                                                                /* ----------------- GET BUF / RX PKT ----------------- */
    ix_rx = NET_IF_RX_IX;
    pbuf  = NetBuf_Get((NET_BUF_SIZE) size,                     /* Get buf large enough for pkt.                        */
                       (NET_BUF_SIZE) ix_rx,
                       (CPU_INT16U  ) NET_BUF_FLAG_NONE,
                       (NET_ERR    *)&err_rx);
    switch (err_rx) {
        case NET_BUF_ERR_NONE:                                  /* If NO errs, buf avail;    ...                        */
             p_data = &pbuf->Data[ix_rx];                       /* ... set appropriate rx ix ...                        */
             NetNIC_RxPkt((void *)p_data, size, &err_rx);       /* ...       & rd data from NIC into buf.               */
             break;


        case NET_BUF_ERR_NONE_AVAIL:
        case NET_BUF_ERR_INVALID_TYPE:
        case NET_BUF_ERR_INVALID_SIZE:
        default:
             NetNIC_RxPktDiscard(size, &err_rx);                /* If errs,    rd data from NIC & discard.              */
             NetIF_Pkt_RxPktDiscard(pbuf);
             return;                                            /* Prevent 'break NOT reachable' compiler warning.      */
    }


/*$PAGE*/
                                                                /* -------------------- DEMUX PKT --------------------- */
    switch (err_rx) {                                           /* Chk err from NetNIC_RxPkt().                         */
        case NET_NIC_ERR_NONE:
             pbuf_hdr                  = &pbuf->Hdr;
             pbuf_hdr->TotLen          = (NET_BUF_SIZE)size;    /* Set pkt size as buf tot len & data len.              */
             pbuf_hdr->DataLen         = (NET_BUF_SIZE)pbuf_hdr->TotLen;
             pbuf_hdr->IF_HdrIx        =  ix_rx;
             pbuf_hdr->ProtocolHdrType =  NET_PROTOCOL_TYPE_FRAME;
                                                                /* See Note #2.                                         */
             NetIF_Rx(pbuf, &err_rx);
             break;


        case NET_ERR_INIT_INCOMPLETE:
        default:
             NetIF_Pkt_RxPktDiscard(pbuf);