将 FreeRTOS-Plus-TCP 移植到不同的微控制器

typedef struct xNetworkInterface

{

    const char * pcName;

    void * pvArgument;

    NetworkInterfaceInitialiseFunction_t pfInitialise;

    NetworkInterfaceOutputFunction_t pfOutput;

    GetPhyLinkStatusFunction_t pfGetPhyLinkStatus;

    struct

    {

        uint32_t

            bInterfaceUp : 1,

            bCallDownEvent : 1;

    } bits;



    struct xNetworkEndPoint * pxEndPoint;

    struct xNetworkInterface * pxNext;

} NetworkInterface_t;

typedef BaseType_t ( * NetworkInterfaceInitialiseFunction_t ) ( struct xNetworkInterface * pxDescriptor );

typedef BaseType_t ( * NetworkInterfaceOutputFunction_t ) ( struct xNetworkInterface * pxDescriptor,

                                                            NetworkBufferDescriptor_t * const pxNetworkBuffer,

                                                            BaseType_t xReleaseAfterSend );       

void vNetworkInterfaceAllocateRAMToBuffers(

       NetworkBufferDescriptor_t xDescriptors[ ipconfigNUM_NETWORK_BUFFERS ] );

/* First statically allocate the buffers, ensuring an additional ipBUFFER_PADDING

bytes are allocated to each buffer.  This example makes no effort to align

the start of the buffers, but most hardware will have an alignment requirement.

If an alignment is required then the size of each buffer must be adjusted to

ensure it also ends on an alignment boundary.  Below shows an example assuming

the buffers must also end on an 8-byte boundary. */

#define BUFFER_SIZE ( ipTOTAL_ETHERNET_FRAME_SIZE + ipBUFFER_PADDING )

#define BUFFER_SIZE_ROUNDED_UP ( ( BUFFER_SIZE + 7 ) & ~0x07UL )

static uint8_t ucBuffers[ ipconfigNUM_NETWORK_BUFFERS ][ BUFFER_SIZE_ROUNDED_UP ];



/* Next provide the vNetworkInterfaceAllocateRAMToBuffers() function, which

simply fills in the pucEthernetBuffer member of each descriptor. */

void vNetworkInterfaceAllocateRAMToBuffers(

    NetworkBufferDescriptor_t pxNetworkBuffers[ ipconfigNUM_NETWORK_BUFFERS ] )

{

BaseType_t x;



    for( x = 0; x < ipconfigNUM_NETWORK_BUFFERS; x++ )

    {

        /* pucEthernetBuffer is set to point ipBUFFER_PADDING bytes in from the

        beginning of the allocated buffer. */

        pxNetworkBuffers[ x ].pucEthernetBuffer = &( ucBuffers[ x ][ ipBUFFER_PADDING ] );



        /* The following line is also required, but will not be required in

        future versions. */

        *( ( uint32_t * ) &ucBuffers[ x ][ 0 ] ) = ( uint32_t ) &( pxNetworkBuffers[ x ] );

    }

}

typedef struct IP_TASK_COMMANDS

{

    /* Specifies the type of event being sent to the RTOS task and must be set to

    eNetworkRxEvent to signify a receive event. */

    eIPEvent_t eEventType;



    /* Points to additional data about the event.  In this case set pvData to the

    the address of the network buffer descriptor. */

    void *pvData;

} IPStackEvent_t;

/* The timeout is specified in RTOS ticks.  Returns pdTRUE if the message was

sent successfully, otherwise return pdFALSE. */

BaseType_t xSendEventStructToIPTask( const IPStackEvent_t *pxEvent, TickType_t xTimeout )

NetworkInterface_t * pxSAM_FillInterfaceDescriptor( BaseType_t xEMACIndex,

                                                    NetworkInterface_t * pxInterface )

{

    pxInterface->pcName = "InterfaceName";

    pxInterface->pvArgument = ( void * ) xEMACIndex;

    pxInterface->pfInitialise = prvSAM_NetworkInterfaceInitialise; /* The initialisation function of this driver. */

    pxInterface->pfOutput = prvSAM_NetworkInterfaceOutput; /* The output function of this driver. */

    pxInterface->pfGetPhyLinkStatus = prvSAM_GetPhyLinkStatus; /* The query status function of this driver. */



    FreeRTOS_AddNetworkInterface( pxInterface );



    return pxInterface;

}

#if ( ipconfigIPv4_BACKWARD_COMPATIBLE == 1 )

    NetworkInterface_t * pxFillInterfaceDescriptor( BaseType_t xEMACIndex,

                                                    NetworkInterface_t * pxInterface )

    {

        return pxSAM_FillInterfaceDescriptor( xEMACIndex, pxInterface );

    }

#endif

static BaseType_t prvSAM_NetworkInterfaceInitialise( NetworkInterface_t * pxInterface )

{

    BaseType_t xReturn;



    /*


     * Perform the hardware specific network initialisation here.  Typically


     * that will involve using the Ethernet driver library to initialise the


     * Ethernet (or other network) hardware, initialise DMA descriptors, and


     * perform a PHY auto-negotiation to obtain a network link.


     *


     * This example assumes InitialiseNetwork() is an Ethernet peripheral driver


     * library function that returns 0 if the initialisation fails.


     */

    if( InitialiseNetwork() == 0 )

    {

        xReturn = pdFAIL;

    }

    else

    {

        /* Set the MAC addresses by calling FreeRTOS_FirstEndPoint() and


         * FreeRTOS_NextEndPoint(). Make sure that all MAC addresses in


         * all end-points are set to the hardware (if necessary). */

        if( SetMACAddress() == 0 )

        {

            xReturn = pdFAIL;

        }

        else

        {

            xReturn = pdPASS;

        }

    }



    return xReturn;

}

static BaseType_t prvSAM_NetworkInterfaceOutput( NetworkInterface_t * pxInterface,

                                                 NetworkBufferDescriptor_t * const pxDescriptor,

                                                 BaseType_t xReleaseAfterSend )

{

    /* Simple network interfaces (as opposed to more efficient zero copy network

       interfaces) just use Ethernet peripheral driver library functions to copy

       data from the FreeRTOS-Plus-TCP buffer into the peripheral driver's own buffer.

       This example assumes SendData() is a peripheral driver library function that

       takes a pointer to the start of the data to be sent and the length of the

       data to be sent as two separate parameters.  The start of the data is located

       by pxDescriptor->pucEthernetBuffer.  The length of the data is located

       by pxDescriptor->xDataLength. */

    SendData( pxDescriptor->pucBuffer, pxDescriptor->xDataLength );



    /* Call the standard trace macro to log the send event. */

    iptraceNETWORK_INTERFACE_TRANSMIT();



    if( xReleaseAfterSend != pdFALSE )

    {

        /* It is assumed SendData() copies the data out of the FreeRTOS-Plus-TCP Ethernet

           buffer.  The Ethernet buffer is therefore no longer needed, and must be

           freed for re-use. */

        vReleaseNetworkBufferAndDescriptor( pxDescriptor );

    }



    return pdTRUE;

}

/* The deferred interrupt handler is a standard RTOS task.  FreeRTOS's 

   centralised deferred interrupt handling capabilities can also be used. */

static void prvEMACDeferredInterruptHandlerTask( void *pvParameters )

{

    NetworkBufferDescriptor_t *pxBufferDescriptor;

    size_t xBytesReceived;

    /* Used to indicate that xSendEventStructToIPTask() is being called because

       of an Ethernet receive event. */

    IPStackEvent_t xRxEvent;



    for( ;; )

    {

        /* Wait for the Ethernet MAC interrupt to indicate that another packet

           has been received.  The task notification is used in a similar way to a

           counting semaphore to count Rx events, but is a lot more efficient than

           a semaphore. */

        ulTaskNotifyTake( pdFALSE, portMAX_DELAY );



        /* See how much data was received.  Here it is assumed ReceiveSize() is

           a peripheral driver function that returns the number of bytes in the

           received Ethernet frame. */

        xBytesReceived = ReceiveSize();



        if( xBytesReceived > 0 )

        {

            /* Allocate a network buffer descriptor that points to a buffer

               large enough to hold the received frame.  As this is the simple

               rather than efficient example the received data will just be copied

               into this buffer. */

            pxBufferDescriptor = pxGetNetworkBufferWithDescriptor( xBytesReceived, 0 );



            if( pxBufferDescriptor != NULL )

            {

                /* pxBufferDescriptor->pucEthernetBuffer now points to an Ethernet

                   buffer large enough to hold the received data.  Copy the

                   received data into pcNetworkBuffer->pucEthernetBuffer.  Here it

                   is assumed ReceiveData() is a peripheral driver function that

                   copies the received data into a buffer passed in as the function's

                   parameter.  Remember! While is is a simple robust technique -

                   it is not efficient.  An example that uses a zero copy technique

                   is provided further down this page. */

                ReceiveData( pxBufferDescriptor->pucEthernetBuffer );

                pxBufferDescriptor->xDataLength = xBytesReceived;



                /* See if the data contained in the received Ethernet frame needs

                   to be processed.  NOTE! It is preferable to do this in

                   the interrupt service routine itself, which would remove the need

                   to unblock this task for packets that don't need processing. */

                if( eConsiderFrameForProcessing( pxBufferDescriptor->pucEthernetBuffer )

                                                                      == eProcessBuffer )

                {

                    pxBufferDescriptor->pxEndPoint = FreeRTOS_MatchingEndpoint( pxMyInterface, pxBufferDescriptor->pucEthernetBuffer );

                    

                    if( pxBufferDescriptor->pxEndPoint != NULL )

                    {

                        /* The event about to be sent to the TCP/IP is an Rx event. */

                        xRxEvent.eEventType = eNetworkRxEvent;

    

                        /* pvData is used to point to the network buffer descriptor that


                           now references the received data. */

                        xRxEvent.pvData = ( void * ) pxBufferDescriptor;

    

                        /* Send the data to the TCP/IP stack. */

                        if( xSendEventStructToIPTask( &xRxEvent, 0 ) == pdFALSE )

                        {

                            /* The buffer could not be sent to the IP task so the buffer


                               must be released. */

                            vReleaseNetworkBufferAndDescriptor( pxBufferDescriptor );

    

                            /* Make a call to the standard trace macro to log the


                               occurrence. */

                            iptraceETHERNET_RX_EVENT_LOST();

                        }

                        else

                        {

                            /* The message was successfully sent to the TCP/IP stack.


                               Call the standard trace macro to log the occurrence. */

                            iptraceNETWORK_INTERFACE_RECEIVE();

                        }

                    }

                    else

                    {

                        /* The Ethernet frame can be dropped, but the Ethernet buffer


                           must be released. */

                        vReleaseNetworkBufferAndDescriptor( pxBufferDescriptor );

                    }

                }

                else

                {

                    /* The Ethernet frame can be dropped, but the Ethernet buffer

                       must be released. */

                    vReleaseNetworkBufferAndDescriptor( pxBufferDescriptor );

                }

            }

            else

            {

                /* The event was lost because a network buffer was not available.

                   Call the standard trace macro to log the occurrence. */

                iptraceETHERNET_RX_EVENT_LOST();

            }

        }

    }

}

static BaseType_t prvSAM_NetworkInterfaceOutput( 

                      NetworkInterface_t * pxInterface,

                      NetworkBufferDescriptor_t * const pxDescriptor,

                      BaseType_t xReleaseAfterSend )

{

DMADescriptor_t *pxDMATxDescriptor;



    /* This example assumes GetNextTxDescriptor() is an Ethernet MAC driver library

       function that returns a pointer to a DMA descriptor of type DMADescriptor_t. */

    pxDMATxDescriptor = GetNextTxDescriptor();



    /* Further, this example assumes the DMADescriptor_t type has a member

       called pucEthernetBuffer that points to the buffer the DMA will transmit, and

       a member called xDataLength that holds the length of the data the DMA will

       transmit.  If BufferAllocation_2.c is being used then the DMA descriptor may

       still be pointing to the buffer it last transmitted.  If this is the case

       then the old buffer must be released (returned to the TCP/IP stack) before

       descriptor is updated to point to the new data waiting to be transmitted. */

    if( pxDMATxDescriptor->pucEthernetBuffer != NULL )

    {

        /* Note this is releasing just an Ethernet buffer, not a network buffer

           descriptor as the descriptor has already been released. */

        vReleaseNetworkBuffer( pxDMATxDescriptor->pucEthernetBuffer );

    }



    /* Configure the DMA descriptor to send the data referenced by the network buffer

       descriptor.  This example assumes SendData() is an Ethernet peripheral driver

       function. */

    pxDMATxDescriptor->pucEthernetBuffer = pxDescriptor->pucEthernetBuffer;

    pxDMATxDescriptor->xDataLength = pxDescriptor->xDataLength;

    SendData( pxDMATxDescriptor );



    /* Call the standard trace macro to log the send event. */

    iptraceNETWORK_INTERFACE_TRANSMIT();



    /* The network buffer descriptor must now be returned to the TCP/IP stack, but

       the Ethernet buffer referenced by the network buffer descriptor is still in

       use by the DMA.  Remove the reference to the Ethernet buffer from the network

       buffer descriptor so releasing the network buffer descriptor does not result

       in the Ethernet buffer also being released.  xReleaseAfterSend() should never

       equal pdFALSE when  ipconfigZERO_COPY_TX_DRIVER is set to 1 (as it should be

       if data is transmitted using a zero copy driver.*/

    if( xReleaseAfterSend != pdFALSE )

    {

        pxDescriptor->pucEthernetBuffer = NULL;

        vReleaseNetworkBufferAndDescriptor( pxDescriptor );

    }



    return pdTRUE;

}

/* The deferred interrupt handler is a standard RTOS task.  FreeRTOS's 

   centralised deferred interrupt handling capabilities can also be used - 

   however for additional speed use BufferAllocation_1.c to perform the entire operation in the interrupt

   handler. */

static void prvEMACDeferredInterruptHandlerTask( void *pvParameters )

{

    NetworkBufferDescriptor_t *pxDescriptor;

    size_t xBytesReceived;

    DMADescriptor_t *pxDMARxDescriptor;

    uint8_t *pucTemp;

    /* Used to indicate that xSendEventStructToIPTask() is being called because

       of an Ethernet receive event. */

    IPStackEvent_t xRxEvent;



    for( ;; )

    {

        /* Wait for the Ethernet MAC interrupt to indicate that another packet

           has been received.  The task notification is used in a similar way to a

           counting semaphore to count Rx events, but is a lot more efficient than

           a semaphore. */

      ulTaskNotifyTake( pdFALSE, portMAX_DELAY );



      /* This example assumes GetNextRxDescriptor() is an Ethernet MAC driver

         library function that returns a pointer to the DMA descriptor (of type

         DMADescriptor_t again) that references the Ethernet buffer containing the

         received data. */

      pxDMARxDescriptor = GetNextRxDescriptor();



      /* Allocate a new network buffer descriptor that references an Ethernet

          frame large enough to hold the maximum network packet size (as defined

          in the FreeRTOSIPConfig.h header file). */

      pxDescriptor = pxGetNetworkBufferWithDescriptor( ipTOTAL_ETHERNET_FRAME_SIZE, 0 );



      /* Copy the pointer to the newly allocated Ethernet frame to a temporary

         variable. */

      pucTemp = pxDescriptor->pucEthernetBuffer;



      /* This example assumes that the DMADescriptor_t type has a member

         called pucEthernetBuffer that points to the Ethernet buffer containing

         the received data, and a member called xDataLength that holds the length

         of the received data.  Update the newly allocated network buffer descriptor

         to point to the Ethernet buffer that contains the received data. */

      pxDescriptor->pucEthernetBuffer = pxDMARxDescriptor->pucEthernetBuffer;

      pxDescriptor->xDataLength = pxDMARxDescriptor->xDataLength;



      /* Update the Ethernet Rx DMA descriptor to point to the newly allocated

         Ethernet buffer. */

      pxDMARxDescriptor->puxEthernetBuffer = pucTemp;



      /* A pointer to the descriptor is stored at the front of the buffer, so

         swap these too. */

      *( ( NetworkBufferDescriptor_t ** )

         ( pxDescriptor->pucEthernetBuffer - ipBUFFER_PADDING ) ) = pxDescriptor;



      *( ( NetworkBufferDescriptor_t ** )

         ( pxDMARxDescriptor->pucEthernetBuffer - ipBUFFER_PADDING ) ) = pxDMARxDescriptor;



      /*

       * The network buffer descriptor now points to the Ethernet buffer that

       * contains the received data, and the Ethernet DMA descriptor now points

       * to a newly allocated (and empty) Ethernet buffer ready to receive more

       * data.  No data was copied.  Only pointers to data were swapped.

       *

       * THE REST OF THE RECEIVE HANDLER FUNCTION FOLLOWS THE EXAMPLE PROVIDED

       * FOR THE SIMPLE ETHERNET INTERFACE IMPLEMENTATION, whereby the network

       * buffer descriptor is sent to the TCP/IP on the network event queue.

       */







      /* See if the data contained in the received Ethernet frame needs

         to be processed.  NOTE! It might be possible to do this in

         the interrupt service routine itself, which would remove the need

         to unblock this task for packets that don't need processing. */

      if( eConsiderFrameForProcessing( pxDescriptor->pucEthernetBuffer )

                                  == eProcessBuffer )

      {

          pxDescriptor->pxEndPoint = FreeRTOS_MatchingEndpoint( pxMyInterface, pxBufferDescriptor->pucEthernetBuffer );

            

          if( pxDescriptor->pxEndPoint != NULL )

          {

              /* The event about to be sent to the TCP/IP is an Rx event. */

              xRxEvent.eEventType = eNetworkRxEvent;

    

              /* pvData is used to point to the network buffer descriptor that


                 references the received data. */

              xRxEvent.pvData = ( void * ) pxDescriptor;

    

              /* Send the data to the TCP/IP stack. */

              if( xSendEventStructToIPTask( &xRxEvent, 0 ) == pdFALSE )

              {

                  /* The buffer could not be sent to the IP task so the buffer


                     must be released. */

                  vReleaseNetworkBufferAndDescriptor( pxDescriptor );

    

                  /* Make a call to the standard trace macro to log the


                     occurrence. */

                  iptraceETHERNET_RX_EVENT_LOST();

              }

              else

              {

                  /* The message was successfully sent to the TCP/IP stack.


                     Call the standard trace macro to log the occurrence. */

                  iptraceNETWORK_INTERFACE_RECEIVE();

              }

          }

          else

          {

              /* The Ethernet frame can be dropped, but the Ethernet buffer


                 must be released. */

              vReleaseNetworkBufferAndDescriptor( pxDescriptor );

          }

      }

      else

      {

          /* The Ethernet frame can be dropped, but the Ethernet buffer

             must be released. */

          vReleaseNetworkBufferAndDescriptor( pxDescriptor );

      }

  }

}