Transmission using DMA

When µC/TCP-IP has a packet to transmit, it updates an available descriptor in memory and then writes to a DMA register to start the stalled DMA channel. On transmissions, it is simpler to setup the descriptors. The number and length of the packets to transmit is well defined. This information determines the number of transmit descriptors required and the number of bytes to transmit on each descriptor. The transmit descriptor list is often used in a non-circular fashion. The initial descriptors in the descriptor list are setup for transmission, when the transmission is completed they are cleared, and the process starts over in the next transmission.

Initialization

Similarly to the receive descriptors, the Network Device Driver should allocate a memory block for all transmit buffers and descriptors shown in the figure below.

Finally, the DMA controller is initialized and hardware is informed of the descriptor list's starting address.

Transmission

If no descriptor is free an error should be returned to the Network Protocol stack.

ISR Handler

When the ISR handler receives a DMA interrupt after the transmission completion, a list of descriptors for the completed transmit buffers is determined. Each completed transmit buffer address is passed to the Network Transmit De-allocation task, where the corresponding buffer gets released if it is not referenced by any other part of the Network stack. The Network interface is also signaled for each one of the completed transmit buffers to allow the Network stack to continue transmission of subsequent packets. To complete the operation, the transmit descriptors are cleared to make room for subsequent transmissions.

Transmission of packets can also benefit from a DMA implementation. Similar to the reception of packets, the DMA can be used to move the packet data from the application memory space to the memory location of the Ethernet controller. By utilizing the DMA, the CPU can work on other tasks allowing overall driver performance to increase.

Description of the Transmission Pointers

We use three pointers to manage the transmission of buffers:

TxBufDescPtrStart

This pointer points to the first descriptor and should not take any other value.

TxBufDescPtrComp

This pointer tracks the current descriptor which completed its transmission.

TxBufDescPtrCur

This pointer tracks the current descriptor available for transmission.

Initialization of the transmission descriptors

The function NetDev_Start() initializes the Transmit buffer descriptor pointers and the DMA Transmit descriptors. The sub-function NetDev_TxDescInit() initializes the Transmit descriptors ring. The descriptors must not be filled with buffers and must be owned by the software. Your code should activate the current Transmit descriptor only when NetDev_Tx() is called.

The following is the pseudo code for this initialization:

pdesc                       = (DEV_DESC *)pdev_data->TxBufDescPtrStart;       (1)
pdev_data->TxBufDescPtrComp = (DEV_DESC *)pdev_data->TxBufDescPtrStart;
pdev_data->TxBufDescPtrCur  = (DEV_DESC *)pdev_data->TxBufDescPtrStart;
for (i = 0; i < pdev_cfg->TxDescNbr; i++) {                                   (2)
    pdesc->Addr   =  0;
    pdesc->Len    =  0;
    pdesc->Status =  (not started) & (owned by software)
    pdesc->Next   = (DEV_DESC *)(pdesc + 1);
    pdesc++;                                                                  (3)
}
pdesc--;                                                                      (4)
pdesc->Next    = (DEV_DESC *)pdev_data->TxBufDescPtrStart;                    (5)

The function NetDev_Tx() is called by the µC/TCP-IP module when a packet must be transmitted over the network. This function resets and activates a DMA Transmit descriptor for the packet to transmit. It must first make sure that a Transmit descriptor is available to initialize a transmission. Once the buffer has been assigned to the current Transmit descriptor, an interrupt will be generated to signal that the packet has been transmitted.

The following is the pseudo code for the NetDev_Tx() function.

static  void  NetDev_Tx (NET_IF      *pif,
                         CPU_INT08U  *p_data,
                         CPU_INT16U   size,
                         NET_ERR     *perr)
{
    NET_DEV_CFG_ETHER  *pdev_cfg;
    NET_DEV_DATA       *pdev_data;
    NET_DEV            *pdev;
    DEV_DESC           *pdesc;
    pdev_cfg  = (NET_DEV_CFG_ETHER *)pif->Dev_Cfg;
    pdev_data = (NET_DEV_DATA      *)pif->Dev_Data;
    pdev      = (NET_DEV           *)pdev_cfg->BaseAddr;           
    pdesc     = (DEV_DESC          *)pdev_data->TxBufDescPtrCur;
    if ((pdesc->Status & Hardware) != 0) {                                              (1)
       *perr = NET_DEV_ERR_TX_BUSY;
        return;
    }
    pdesc->Addr                =  p_data;                                               (2)
    pdesc->Len                 =  size;                                                 (3)
 
    pdesc->Status              =  Hardware;                                             (4)
    pdev->REGISTER             =  Inform harware that a Tx desc has been made avail;
    pdev_data->TxBufDescPtrCur =  pdesc->Next;                                          (5)
    
   *perr = NET_DEV_ERR_NONE;
}  

Deallocating packets after transmission

NetDev_ISR_Handler() is called when the transmission is completed. Within the ISR handler, you must signal the µC/TCP-IP module for each packet transmitted successfully.

    int_status = pdev->REGISTER;                                              (1)
    
    clear active int;
    if ((int_status & TX_INTERRUPT) > 0) {                                    (2)
        
        while(p_desc         != TxBufDescPtrCur ||
            pdev->REGISTER == Owned by software) {                            (3)
            pdesc = pdev_data->TxBufDescPtrComp;
            pdev_data->TxBufDescPtrComp = pdesc->Next;
            NetOS_IF_TxDeallocTaskPost(pdesc->Addr, &err);
            NetOS_Dev_TxRdySignal(pif->Nbr);                                  (4)
        }
         pdesc = pdev_data->TxBufDescPtrComp;
         pdev_data->TxBufDescPtrComp = pdesc->Next;                           (5)
    } 

Deallocating the transmit buffers

NetDev_Stop() is called to free the receive descriptors ring and to deallocate all transmit buffers. To do that, a sub-function is called NetDev_TxDescFreeAll() where each descriptor’s buffer is freed:

pdesc = pdev_data->TxBufDescPtrStart;                                        (1)
for (i = 0; i < pdev_cfg->TxDescNbr; i++) {
    NetOS_IF_TxDeallocTaskPost((CPU_INT08U *)pdesc->Addr, &err);             (2)
    (void)&err;                                                              (3)
    pdesc++;
}