git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/Common/ethernet/lwip-1.4.0/ports/MicroBlaze-Ethernet-Lite/ethernetif.c

   1 /*\r
   2  * FreeRTOS Kernel V10.3.0\r
   3  * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
   4  *\r
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
   6  * this software and associated documentation files (the "Software"), to deal in\r
   7  * the Software without restriction, including without limitation the rights to\r
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
   9  * the Software, and to permit persons to whom the Software is furnished to do so,\r
  10  * subject to the following conditions:\r
  11  *\r
  12  * The above copyright notice and this permission notice shall be included in all\r
  13  * copies or substantial portions of the Software.\r
  14  *\r
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
  17  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
  18  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
  19  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  21  *\r
  22  * http://www.FreeRTOS.org\r
  23  * http://aws.amazon.com/freertos\r
  24  *\r
  25  * 1 tab == 4 spaces!\r
  26  */\r
  27 \r
  28 /* FreeRTOS includes. */\r
  29 #include "FreeRTOS.h"\r
  30 #include "task.h"\r
  31 #include "queue.h"\r
  32 \r
  33 /* BSP includes. */\r
  34 #include "xemaclite.h"\r
  35 #include "xintc_l.h"\r
  36 \r
  37 /* lwIP includes. */\r
  38 #include "lwip/opt.h"\r
  39 #include "lwip/def.h"\r
  40 #include "lwip/mem.h"\r
  41 #include "lwip/pbuf.h"\r
  42 #include "lwip/sys.h"\r
  43 #include <lwip/stats.h>\r
  44 #include <lwip/snmp.h>\r
  45 #include "netif/etharp.h"\r
  46 \r
  47 /* Define those to better describe your network interface. */\r
  48 #define IFNAME0 'e'\r
  49 #define IFNAME1 'l'\r
  50 \r
  51 /* When a packet is ready to be sent, if it cannot be sent immediately then\r
  52  * the task performing the transmit will block for netifTX_BUFFER_FREE_WAIT\r
  53  * milliseconds.  It will do this a maximum of netifMAX_TX_ATTEMPTS before\r
  54  * giving up.\r
  55  */\r
  56 #define netifTX_BUFFER_FREE_WAIT        ( ( TickType_t ) 2UL / portTICK_PERIOD_MS )\r
  57 #define netifMAX_TX_ATTEMPTS            ( 5 )\r
  58 \r
  59 #define netifMAX_MTU 1500\r
  60 \r
  61 struct xEthernetIf\r
  62 {\r
  63         struct eth_addr *ethaddr;\r
  64         /* Add whatever per-interface state that is needed here. */\r
  65 };\r
  66 \r
  67 /*\r
  68  * Copy the received data into a pbuf.\r
  69  */\r
  70 static struct pbuf *prvLowLevelInput( const unsigned char * const pucInputData, unsigned short usDataLength );\r
  71 \r
  72 /*\r
  73  * Send data from a pbuf to the hardware.\r
  74  */\r
  75 static err_t prvLowLevelOutput( struct netif *pxNetIf, struct pbuf *p );\r
  76 \r
  77 /*\r
  78  * Perform any hardware and/or driver initialisation necessary.\r
  79  */\r
  80 static void prvLowLevelInit( struct netif *pxNetIf );\r
  81 \r
  82 /*\r
  83  * Functions that get registered as the Rx and Tx interrupt handers\r
  84  * respectively.\r
  85  */\r
  86 static void prvRxHandler( void *pvNetIf );\r
  87 static void prvTxHandler( void *pvUnused );\r
  88 \r
  89 \r
  90 /*-----------------------------------------------------------*/\r
  91 \r
  92 /* The instance of the xEmacLite IP being used in this driver. */\r
  93 static XEmacLite xEMACInstance;\r
  94 \r
  95 /*-----------------------------------------------------------*/\r
  96 \r
  97 /**\r
  98  * In this function, the hardware should be initialized.\r
  99  * Called from ethernetif_init().\r
 100  *\r
 101  * @param pxNetIf the already initialized lwip network interface structure\r
 102  *              for this etherpxNetIf\r
 103  */\r
 104 static void prvLowLevelInit( struct netif *pxNetIf )\r
 105 {\r
 106 portBASE_TYPE xStatus;\r
 107 extern void vInitialisePHY( XEmacLite *xemaclitep );\r
 108 unsigned portBASE_TYPE uxOriginalPriority;\r
 109 \r
 110         /* Hardware initialisation can take some time, so temporarily lower the\r
 111         task priority to ensure other functionality is not adversely effected.\r
 112         The priority will get raised again before this function exits. */\r
 113         uxOriginalPriority = uxTaskPriorityGet( NULL );\r
 114         vTaskPrioritySet( NULL, tskIDLE_PRIORITY );\r
 115 \r
 116         /* set MAC hardware address length */\r
 117         pxNetIf->hwaddr_len = ETHARP_HWADDR_LEN;\r
 118 \r
 119         /* set MAC hardware address */\r
 120         pxNetIf->hwaddr[ 0 ] = configMAC_ADDR0;\r
 121         pxNetIf->hwaddr[ 1 ] = configMAC_ADDR1;\r
 122         pxNetIf->hwaddr[ 2 ] = configMAC_ADDR2;\r
 123         pxNetIf->hwaddr[ 3 ] = configMAC_ADDR3;\r
 124         pxNetIf->hwaddr[ 4 ] = configMAC_ADDR4;\r
 125         pxNetIf->hwaddr[ 5 ] = configMAC_ADDR5;\r
 126 \r
 127         /* device capabilities */\r
 128         pxNetIf->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;\r
 129 \r
 130         /* maximum transfer unit */\r
 131         pxNetIf->mtu = netifMAX_MTU;\r
 132 \r
 133         /* Broadcast capability */\r
 134         pxNetIf->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;\r
 135 \r
 136         /* Initialize the mac */\r
 137         xStatus = XEmacLite_Initialize( &xEMACInstance, XPAR_EMACLITE_0_DEVICE_ID );\r
 138 \r
 139         if( xStatus == XST_SUCCESS )\r
 140         {\r
 141                 /* Set mac address */\r
 142                 XEmacLite_SetMacAddress( &xEMACInstance, ( Xuint8* )( pxNetIf->hwaddr ) );\r
 143 \r
 144                 /* Flush any frames already received */\r
 145                 XEmacLite_FlushReceive( &xEMACInstance );\r
 146 \r
 147                 /* Set Rx, Tx interrupt handlers */\r
 148                 XEmacLite_SetRecvHandler( &xEMACInstance, ( void * ) pxNetIf, prvRxHandler );\r
 149                 XEmacLite_SetSendHandler( &xEMACInstance, NULL, prvTxHandler );\r
 150 \r
 151                 /* Enable Rx, Tx interrupts */\r
 152                 XEmacLite_EnableInterrupts( &xEMACInstance );\r
 153 \r
 154                 /* Install the standard Xilinx library interrupt handler itself.\r
 155                 *NOTE* The xPortInstallInterruptHandler() API function must be used\r
 156                 for     this purpose. */\r
 157                 xStatus = xPortInstallInterruptHandler( XPAR_INTC_0_EMACLITE_0_VEC_ID, ( XInterruptHandler ) XEmacLite_InterruptHandler, &xEMACInstance );\r
 158 \r
 159                 vInitialisePHY( &xEMACInstance );\r
 160 \r
 161                 /* Enable the interrupt in the interrupt controller.\r
 162                 *NOTE* The vPortEnableInterrupt() API function must be used for this\r
 163                 purpose. */\r
 164                 vPortEnableInterrupt( XPAR_INTC_0_EMACLITE_0_VEC_ID );\r
 165         }\r
 166 \r
 167         /* Reset the task priority back to its original value. */\r
 168         vTaskPrioritySet( NULL, uxOriginalPriority );\r
 169 \r
 170         configASSERT( xStatus == pdPASS );\r
 171 }\r
 172 \r
 173 /**\r
 174  * This function should do the actual transmission of the packet. The packet is\r
 175  * contained in the pbuf that is passed to the function. This pbuf\r
 176  * might be chained.\r
 177  *\r
 178  * @param pxNetIf the lwip network interface structure for this etherpxNetIf\r
 179  * @param p the MAC packet to send (e.g. IP packet including MAC addresses and type)\r
 180  * @return ERR_OK if the packet could be sent\r
 181  *               an err_t value if the packet couldn't be sent\r
 182  *\r
 183  * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to\r
 184  *         strange results. You might consider waiting for space in the DMA queue\r
 185  *         to become availale since the stack doesn't retry to send a packet\r
 186  *         dropped because of memory failure (except for the TCP timers).\r
 187  */\r
 188 \r
 189 static err_t prvLowLevelOutput( struct netif *pxNetIf, struct pbuf *p )\r
 190 {\r
 191 \r
 192         /* This is taken from lwIP example code and therefore does not conform\r
 193         to the FreeRTOS coding standard. */\r
 194 \r
 195 struct pbuf *q;\r
 196 static unsigned char ucBuffer[ 1520 ] __attribute__((aligned(32)));\r
 197 unsigned char *pucBuffer = ucBuffer;\r
 198 unsigned char *pucChar;\r
 199 struct eth_hdr *pxHeader;\r
 200 u16_t usTotalLength = p->tot_len - ETH_PAD_SIZE;\r
 201 err_t xReturn = ERR_OK;\r
 202 long x;\r
 203 \r
 204         ( void ) pxNetIf;\r
 205 \r
 206         #if defined(LWIP_DEBUG) && LWIP_NETIF_TX_SINGLE_PBUF\r
 207                 LWIP_ASSERT("p->next == NULL && p->len == p->tot_len", p->next == NULL && p->len == p->tot_len);\r
 208         #endif\r
 209 \r
 210         /* Initiate transfer. */\r
 211         if( p->len == p->tot_len ) \r
 212         {\r
 213                 /* No pbuf chain, don't have to copy -> faster. */\r
 214                 pucBuffer = &( ( unsigned char * ) p->payload )[ ETH_PAD_SIZE ];\r
 215         } \r
 216         else \r
 217         {\r
 218                 /* pbuf chain, copy into contiguous ucBuffer. */\r
 219                 if( p->tot_len >= sizeof( ucBuffer ) )\r
 220                 {\r
 221                         LINK_STATS_INC( link.lenerr );\r
 222                         LINK_STATS_INC( link.drop );\r
 223                         snmp_inc_ifoutdiscards( pxNetIf );\r
 224                         xReturn = ERR_BUF;\r
 225                 }\r
 226                 else\r
 227                 {\r
 228                         pucChar = ucBuffer;\r
 229 \r
 230                         for( q = p; q != NULL; q = q->next )\r
 231                         {\r
 232                                 /* Send the data from the pbuf to the interface, one pbuf at a\r
 233                                 time. The size of the data in each pbuf is kept in the ->len\r
 234                                 variable. */\r
 235                                 /* send data from(q->payload, q->len); */\r
 236                                 LWIP_DEBUGF( NETIF_DEBUG, ( "NETIF: send pucChar %p q->payload %p q->len %i q->next %p\n", pucChar, q->payload, ( int ) q->len, ( void* ) q->next ) );\r
 237                                 if( q == p )\r
 238                                 {\r
 239                                         memcpy( pucChar, &( ( char * ) q->payload )[ ETH_PAD_SIZE ], q->len - ETH_PAD_SIZE );\r
 240                                         pucChar += q->len - ETH_PAD_SIZE;\r
 241                                 }\r
 242                                 else\r
 243                                 {\r
 244                                         memcpy( pucChar, q->payload, q->len );\r
 245                                         pucChar += q->len;\r
 246                                 }\r
 247                         }\r
 248                 }\r
 249         }\r
 250 \r
 251         if( xReturn == ERR_OK )\r
 252         {\r
 253                 for( x = 0; x < netifMAX_TX_ATTEMPTS; x++ )\r
 254                 {\r
 255                         xReturn =  XEmacLite_Send( &xEMACInstance, pucBuffer, ( int ) usTotalLength );\r
 256                         if( xReturn == XST_SUCCESS )\r
 257                         {\r
 258                                 break;\r
 259                         }\r
 260                         else\r
 261                         {\r
 262                                 vTaskDelay( netifTX_BUFFER_FREE_WAIT );\r
 263                         }\r
 264                 }\r
 265 \r
 266                 if( xReturn != XST_SUCCESS )\r
 267                 {\r
 268                         LINK_STATS_INC( link.memerr );\r
 269                         LINK_STATS_INC( link.drop );\r
 270                         snmp_inc_ifoutdiscards( pxNetIf );\r
 271                         xReturn = ERR_BUF;\r
 272                 }\r
 273                 else\r
 274                 {\r
 275                         LINK_STATS_INC( link.xmit );\r
 276                         snmp_add_ifoutoctets( pxNetIf, usTotalLength );\r
 277                         pxHeader = ( struct eth_hdr * )p->payload;\r
 278 \r
 279                         if( ( pxHeader->dest.addr[ 0 ] & 1 ) != 0 ) \r
 280                         {\r
 281                                 /* broadcast or multicast packet*/\r
 282                                 snmp_inc_ifoutnucastpkts( pxNetIf );\r
 283                         } \r
 284                         else \r
 285                         {\r
 286                                 /* unicast packet */\r
 287                                 snmp_inc_ifoutucastpkts( pxNetIf );\r
 288                         }\r
 289                 }\r
 290         }\r
 291 \r
 292         return xReturn;\r
 293 }\r
 294 \r
 295 /**\r
 296  * Should allocate a pbuf and transfer the bytes of the incoming\r
 297  * packet from the interface into the pbuf.\r
 298  *\r
 299  * @param pxNetIf the lwip network interface structure for this etherpxNetIf\r
 300  * @return a pbuf filled with the received packet (including MAC header)\r
 301  *               NULL on memory error\r
 302  */\r
 303 static struct pbuf *prvLowLevelInput( const unsigned char * const pucInputData, unsigned short usDataLength )\r
 304 {\r
 305 struct pbuf *p = NULL, *q;\r
 306 \r
 307         if( usDataLength > 0U )\r
 308         {\r
 309                 #if ETH_PAD_SIZE\r
 310                         len += ETH_PAD_SIZE; /* allow room for Ethernet padding */\r
 311                 #endif\r
 312 \r
 313                 /* We allocate a pbuf chain of pbufs from the pool. */\r
 314                 p = pbuf_alloc( PBUF_RAW, usDataLength, PBUF_POOL );\r
 315   \r
 316                 if( p != NULL ) \r
 317                 {\r
 318                         #if ETH_PAD_SIZE\r
 319                                 pbuf_header( p, -ETH_PAD_SIZE ); /* drop the padding word */\r
 320                         #endif\r
 321 \r
 322                         /* We iterate over the pbuf chain until we have read the entire\r
 323                         * packet into the pbuf. */\r
 324                         usDataLength = 0U;\r
 325                         for( q = p; q != NULL; q = q->next ) \r
 326                         {\r
 327                                 /* Read enough bytes to fill this pbuf in the chain. The\r
 328                                 * available data in the pbuf is given by the q->len\r
 329                                 * variable.\r
 330                                 * This does not necessarily have to be a memcpy, you can also preallocate\r
 331                                 * pbufs for a DMA-enabled MAC and after receiving truncate it to the\r
 332                                 * actually received size. In this case, ensure the usTotalLength member of the\r
 333                                 * pbuf is the sum of the chained pbuf len members.\r
 334                                 */\r
 335                                 memcpy( q->payload, &( pucInputData[ usDataLength ] ), q->len );\r
 336                                 usDataLength += q->len;\r
 337                         }\r
 338 \r
 339                         #if ETH_PAD_SIZE\r
 340                                 pbuf_header( p, ETH_PAD_SIZE ); /* reclaim the padding word */\r
 341                         #endif\r
 342 \r
 343                         LINK_STATS_INC(link.recv);\r
 344                 }\r
 345         }\r
 346 \r
 347         return p;  \r
 348 }\r
 349 \r
 350 /**\r
 351  * Should be called at the beginning of the program to set up the\r
 352  * network interface. It calls the function prvLowLevelInit() to do the\r
 353  * actual setup of the hardware.\r
 354  *\r
 355  * This function should be passed as a parameter to pxNetIf_add().\r
 356  *\r
 357  * @param pxNetIf the lwip network interface structure for this etherpxNetIf\r
 358  * @return ERR_OK if the loopif is initialized\r
 359  *               ERR_MEM if private data couldn't be allocated\r
 360  *               any other err_t on error\r
 361  */\r
 362 err_t ethernetif_init( struct netif *pxNetIf )\r
 363 {\r
 364 err_t xReturn = ERR_OK;\r
 365 \r
 366         /* This is taken from lwIP example code and therefore does not conform\r
 367         to the FreeRTOS coding standard. */\r
 368         \r
 369 struct xEthernetIf *pxEthernetIf;\r
 370 \r
 371         LWIP_ASSERT( "pxNetIf != NULL", ( pxNetIf != NULL ) );\r
 372         \r
 373         pxEthernetIf = mem_malloc( sizeof( struct xEthernetIf ) );\r
 374         if( pxEthernetIf == NULL ) \r
 375         {\r
 376                 LWIP_DEBUGF(NETIF_DEBUG, ( "ethernetif_init: out of memory\n" ) );\r
 377                 xReturn = ERR_MEM;\r
 378         }\r
 379         else\r
 380         {\r
 381                 #if LWIP_NETIF_HOSTNAME\r
 382                 {\r
 383                         /* Initialize interface hostname */\r
 384                         pxNetIf->hostname = "lwip";\r
 385                 }\r
 386                 #endif /* LWIP_NETIF_HOSTNAME */\r
 387 \r
 388                 pxNetIf->state = pxEthernetIf;\r
 389                 pxNetIf->name[ 0 ] = IFNAME0;\r
 390                 pxNetIf->name[ 1 ] = IFNAME1;\r
 391 \r
 392                 /* We directly use etharp_output() here to save a function call.\r
 393                 * You can instead declare your own function an call etharp_output()\r
 394                 * from it if you have to do some checks before sending (e.g. if link\r
 395                 * is available...) */\r
 396                 pxNetIf->output = etharp_output;\r
 397                 pxNetIf->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP;\r
 398                 pxNetIf->hwaddr_len = ETHARP_HWADDR_LEN;\r
 399                 pxNetIf->mtu = netifMAX_MTU;\r
 400                 pxNetIf->linkoutput = prvLowLevelOutput;\r
 401 \r
 402                 pxEthernetIf->ethaddr = ( struct eth_addr * ) &( pxNetIf->hwaddr[ 0 ] );\r
 403 \r
 404                 /* initialize the hardware */\r
 405                 prvLowLevelInit( pxNetIf );\r
 406         }\r
 407 \r
 408         return xReturn;\r
 409 }\r
 410 /*-----------------------------------------------------------*/\r
 411 \r
 412 static void prvRxHandler( void *pvNetIf )\r
 413 {\r
 414         /* This is taken from lwIP example code and therefore does not conform\r
 415         to the FreeRTOS coding standard. */\r
 416 \r
 417 struct eth_hdr *pxHeader;\r
 418 struct pbuf *p;\r
 419 unsigned short usInputLength;\r
 420 static unsigned char ucBuffer[ 1520 ] __attribute__((aligned(32)));\r
 421 extern portBASE_TYPE xInsideISR;\r
 422 struct netif *pxNetIf = ( struct netif * ) pvNetIf;\r
 423 \r
 424         XIntc_AckIntr( XPAR_ETHERNET_LITE_BASEADDR, XPAR_ETHERNET_LITE_IP2INTC_IRPT_MASK );\r
 425 \r
 426         /* Ensure the pbuf handling functions don't attempt to use critical\r
 427         sections. */\r
 428         xInsideISR++;\r
 429 \r
 430         usInputLength = ( long ) XEmacLite_Recv( &xEMACInstance, ucBuffer );\r
 431 \r
 432         /* move received packet into a new pbuf */\r
 433         p = prvLowLevelInput( ucBuffer, usInputLength );\r
 434 \r
 435         /* no packet could be read, silently ignore this */\r
 436         if( p != NULL )\r
 437         {\r
 438                 /* points to packet payload, which starts with an Ethernet header */\r
 439                 pxHeader = p->payload;\r
 440 \r
 441                 switch( htons( pxHeader->type ) )\r
 442                 {\r
 443                         /* IP or ARP packet? */\r
 444                         case ETHTYPE_IP:\r
 445                         case ETHTYPE_ARP:\r
 446                                                                 /* full packet send to tcpip_thread to process */\r
 447                                                                 if( pxNetIf->input( p, pxNetIf ) != ERR_OK )\r
 448                                                                 {\r
 449                                                                         LWIP_DEBUGF(NETIF_DEBUG, ( "ethernetif_input: IP input error\n" ) );\r
 450                                                                         pbuf_free(p);\r
 451                                                                         p = NULL;\r
 452                                                                 }\r
 453                                                                 break;\r
 454 \r
 455                         default:\r
 456                                                                 pbuf_free( p );\r
 457                                                                 p = NULL;\r
 458                         break;\r
 459                 }\r
 460         }\r
 461 \r
 462         xInsideISR--;\r
 463 }\r
 464 /*-----------------------------------------------------------*/\r
 465 \r
 466 static void prvTxHandler( void *pvUnused )\r
 467 {\r
 468         ( void ) pvUnused;\r
 469         XIntc_AckIntr( XPAR_ETHERNET_LITE_BASEADDR, XPAR_ETHERNET_LITE_IP2INTC_IRPT_MASK );\r
 470 }\r
 471 \r
 472 \r
 473 \r
 474 \r