git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/RX600_RX62N-RSK_Renesas/RTOSDemo/webserver/EMAC.c

   1 /*\r
   2  * FreeRTOS Kernel V10.0.0\r
   3  * Copyright (C) 2017 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. If you wish to use our Amazon\r
  14  * FreeRTOS name, please do so in a fair use way that does not cause confusion.\r
  15  *\r
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
  18  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
  19  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
  20  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  22  *\r
  23  * http://www.FreeRTOS.org\r
  24  * http://aws.amazon.com/freertos\r
  25  *\r
  26  * 1 tab == 4 spaces!\r
  27  */\r
  28 \r
  29 /* Hardware specific includes. */\r
  30 #include "iodefine.h"\r
  31 #include "typedefine.h"\r
  32 #include "r_ether.h"\r
  33 #include "phy.h"\r
  34 \r
  35 /* FreeRTOS includes. */\r
  36 #include "FreeRTOS.h"\r
  37 #include "task.h"\r
  38 #include "semphr.h"\r
  39 \r
  40 /* uIP includes. */\r
  41 #include "net/uip.h"\r
  42 \r
  43 /* The time to wait between attempts to obtain a free buffer. */\r
  44 #define emacBUFFER_WAIT_DELAY_ms                ( 3 / portTICK_PERIOD_MS )\r
  45 \r
  46 /* The number of times emacBUFFER_WAIT_DELAY_ms should be waited before giving\r
  47 up on attempting to obtain a free buffer all together. */\r
  48 #define emacBUFFER_WAIT_ATTEMPTS        ( 30 )\r
  49 \r
  50 /* The number of Rx descriptors. */\r
  51 #define emacNUM_RX_DESCRIPTORS  8\r
  52 \r
  53 /* The number of Tx descriptors.  When using uIP there is not point in having\r
  54 more than two. */\r
  55 #define emacNUM_TX_BUFFERS      2\r
  56 \r
  57 /* The total number of EMAC buffers to allocate. */\r
  58 #define emacNUM_BUFFERS         ( emacNUM_RX_DESCRIPTORS + emacNUM_TX_BUFFERS )\r
  59 \r
  60 /* The time to wait for the Tx descriptor to become free. */\r
  61 #define emacTX_WAIT_DELAY_ms ( 10 / portTICK_PERIOD_MS )\r
  62 \r
  63 /* The total number of times to wait emacTX_WAIT_DELAY_ms for the Tx descriptor to\r
  64 become free. */\r
  65 #define emacTX_WAIT_ATTEMPTS ( 50 )\r
  66 \r
  67 /* Only Rx end and Tx end interrupts are used by this driver. */\r
  68 #define emacTX_END_INTERRUPT    ( 1UL << 21UL )\r
  69 #define emacRX_END_INTERRUPT    ( 1UL << 18UL )\r
  70 \r
  71 /*-----------------------------------------------------------*/\r
  72 \r
  73 /* The buffers and descriptors themselves.  */\r
  74 #pragma section _RX_DESC\r
  75         volatile ethfifo xRxDescriptors[ emacNUM_RX_DESCRIPTORS ];\r
  76 #pragma section _TX_DESC\r
  77         volatile ethfifo xTxDescriptors[ emacNUM_TX_BUFFERS ];\r
  78 #pragma section _ETHERNET_BUFFERS\r
  79         struct\r
  80         {\r
  81                 unsigned long ulAlignmentVariable;\r
  82                 char cBuffer[ emacNUM_BUFFERS ][ UIP_BUFSIZE ];\r
  83         } xEthernetBuffers;\r
  84 #pragma section\r
  85 \r
  86 \r
  87 \r
  88 \r
  89 /* Used to indicate which buffers are free and which are in use.  If an index\r
  90 contains 0 then the corresponding buffer in xEthernetBuffers is free, otherwise \r
  91 the buffer is in use or about to be used. */\r
  92 static unsigned char ucBufferInUse[ emacNUM_BUFFERS ];\r
  93 \r
  94 /*-----------------------------------------------------------*/\r
  95 \r
  96 /*\r
  97  * Initialise both the Rx and Tx descriptors.\r
  98  */\r
  99 static void prvInitialiseDescriptors( void );\r
 100 \r
 101 /*\r
 102  * Return a pointer to a free buffer within xEthernetBuffers.\r
 103  */\r
 104 static unsigned char *prvGetNextBuffer( void );\r
 105 \r
 106 /*\r
 107  * Return a buffer to the list of free buffers.\r
 108  */\r
 109 static void prvReturnBuffer( unsigned char *pucBuffer );\r
 110 \r
 111 /*\r
 112  * Examine the status of the next Rx FIFO to see if it contains new data.\r
 113  */\r
 114 static unsigned long prvCheckRxFifoStatus( void );\r
 115 \r
 116 /*\r
 117  * Setup the microcontroller for communication with the PHY.\r
 118  */\r
 119 static void prvResetMAC( void );\r
 120 \r
 121 /*\r
 122  * Configure the Ethernet interface peripherals.\r
 123  */\r
 124 static void prvConfigureEtherCAndEDMAC( void );\r
 125 \r
 126 /*\r
 127  * Something has gone wrong with the descriptor usage.  Reset all the buffers\r
 128  * and descriptors.\r
 129  */\r
 130 static void prvResetEverything( void );\r
 131 \r
 132 /*-----------------------------------------------------------*/\r
 133 \r
 134 /* Points to the Rx descriptor currently in use. */\r
 135 static ethfifo *pxCurrentRxDesc = NULL;\r
 136 \r
 137 /* The buffer used by the uIP stack to both receive and send.  This points to\r
 138 one of the Ethernet buffers when its actually in use. */\r
 139 unsigned char *uip_buf = NULL;\r
 140 \r
 141 /*-----------------------------------------------------------*/\r
 142 \r
 143 void vInitEmac( void )\r
 144 {\r
 145         /* Software reset. */\r
 146         prvResetMAC();\r
 147         \r
 148         /* Set the Rx and Tx descriptors into their initial state. */\r
 149         prvInitialiseDescriptors();\r
 150 \r
 151         /* Set the MAC address into the ETHERC */\r
 152         ETHERC.MAHR =   ( ( unsigned long ) configMAC_ADDR0 << 24UL ) | \r
 153                                         ( ( unsigned long ) configMAC_ADDR1 << 16UL ) | \r
 154                                         ( ( unsigned long ) configMAC_ADDR2 << 8UL ) | \r
 155                                         ( unsigned long ) configMAC_ADDR3;\r
 156                                         \r
 157         ETHERC.MALR.BIT.MA = ( ( unsigned long ) configMAC_ADDR4 << 8UL ) |\r
 158                                                  ( unsigned long ) configMAC_ADDR5;\r
 159 \r
 160         /* Perform rest of interface hardware configuration. */\r
 161         prvConfigureEtherCAndEDMAC();\r
 162         \r
 163         /* Nothing received yet, so uip_buf points nowhere. */\r
 164         uip_buf = NULL;\r
 165 \r
 166         /* Initialize the PHY */\r
 167         phy_init();\r
 168 }\r
 169 /*-----------------------------------------------------------*/\r
 170 \r
 171 void vEMACWrite( void )\r
 172 {\r
 173 long x;\r
 174 \r
 175         /* Wait until the second transmission of the last packet has completed. */\r
 176         for( x = 0; x < emacTX_WAIT_ATTEMPTS; x++ )\r
 177         {\r
 178                 if( ( xTxDescriptors[ 1 ].status & ACT ) != 0 )\r
 179                 {\r
 180                         /* Descriptor is still active. */\r
 181                         vTaskDelay( emacTX_WAIT_DELAY_ms );\r
 182                 }\r
 183                 else\r
 184                 {\r
 185                         break;\r
 186                 }\r
 187         }\r
 188         \r
 189         /* Is the descriptor free after waiting for it? */\r
 190         if( ( xTxDescriptors[ 1 ].status & ACT ) != 0 )\r
 191         {\r
 192                 /* Something has gone wrong. */\r
 193                 prvResetEverything();\r
 194         }\r
 195         \r
 196         /* Setup both descriptors to transmit the frame. */\r
 197         xTxDescriptors[ 0 ].buf_p = ( char * ) uip_buf;\r
 198         xTxDescriptors[ 0 ].bufsize = uip_len;  \r
 199         xTxDescriptors[ 1 ].buf_p = ( char * ) uip_buf;\r
 200         xTxDescriptors[ 1 ].bufsize = uip_len;\r
 201 \r
 202         /* uip_buf is being sent by the Tx descriptor.  Allocate a new buffer\r
 203         for use by the stack. */\r
 204         uip_buf = prvGetNextBuffer();\r
 205 \r
 206         /* Clear previous settings and go. */\r
 207         xTxDescriptors[0].status &= ~( FP1 | FP0 );\r
 208         xTxDescriptors[0].status |= ( FP1 | FP0 | ACT );\r
 209         xTxDescriptors[1].status &= ~( FP1 | FP0 );\r
 210         xTxDescriptors[1].status |= ( FP1 | FP0 | ACT );\r
 211 \r
 212         EDMAC.EDTRR.LONG = 0x00000001;\r
 213 }\r
 214 /*-----------------------------------------------------------*/\r
 215 \r
 216 unsigned long ulEMACRead( void )\r
 217 {\r
 218 unsigned long ulBytesReceived;\r
 219 \r
 220         ulBytesReceived = prvCheckRxFifoStatus();\r
 221 \r
 222         if( ulBytesReceived > 0 )\r
 223         {\r
 224                 /* Mark the pxDescriptor buffer as free as uip_buf is going to be set to\r
 225                 the buffer that contains the received data. */\r
 226                 prvReturnBuffer( uip_buf );\r
 227 \r
 228                 /* Point uip_buf to the data about ot be processed. */\r
 229                 uip_buf = ( void * ) pxCurrentRxDesc->buf_p;\r
 230                 \r
 231                 /* Allocate a new buffer to the descriptor, as uip_buf is now using it's\r
 232                 old descriptor. */\r
 233                 pxCurrentRxDesc->buf_p = prvGetNextBuffer();\r
 234 \r
 235                 /* Prepare the descriptor to go again. */\r
 236                 pxCurrentRxDesc->status &= ~( FP1 | FP0 );\r
 237                 pxCurrentRxDesc->status |= ACT;\r
 238 \r
 239                 /* Move onto the next buffer in the ring. */\r
 240                 pxCurrentRxDesc = pxCurrentRxDesc->next;\r
 241                 \r
 242                 if( EDMAC.EDRRR.LONG == 0x00000000L )\r
 243                 {\r
 244                         /* Restart Ethernet if it has stopped */\r
 245                         EDMAC.EDRRR.LONG = 0x00000001L;\r
 246                 }\r
 247         }\r
 248 \r
 249         return ulBytesReceived;\r
 250 }\r
 251 /*-----------------------------------------------------------*/\r
 252 \r
 253 long lEMACWaitForLink( void )\r
 254 {\r
 255 long lReturn;\r
 256 \r
 257         /* Set the link status. */\r
 258         switch( phy_set_autonegotiate() )\r
 259         {\r
 260                 /* Half duplex link */\r
 261                 case PHY_LINK_100H:\r
 262                                                                 ETHERC.ECMR.BIT.DM = 0;\r
 263                                                                 ETHERC.ECMR.BIT.RTM = 1;\r
 264                                                                 lReturn = pdPASS;\r
 265                                                                 break;\r
 266 \r
 267                 case PHY_LINK_10H:\r
 268                                                                 ETHERC.ECMR.BIT.DM = 0;\r
 269                                                                 ETHERC.ECMR.BIT.RTM = 0;\r
 270                                                                 lReturn = pdPASS;\r
 271                                                                 break;\r
 272 \r
 273 \r
 274                 /* Full duplex link */\r
 275                 case PHY_LINK_100F:\r
 276                                                                 ETHERC.ECMR.BIT.DM = 1;\r
 277                                                                 ETHERC.ECMR.BIT.RTM = 1;\r
 278                                                                 lReturn = pdPASS;\r
 279                                                                 break;\r
 280                 \r
 281                 case PHY_LINK_10F:\r
 282                                                                 ETHERC.ECMR.BIT.DM = 1;\r
 283                                                                 ETHERC.ECMR.BIT.RTM = 0;\r
 284                                                                 lReturn = pdPASS;\r
 285                                                                 break;\r
 286 \r
 287                 default:\r
 288                                                                 lReturn = pdFAIL;\r
 289                                                                 break;\r
 290         }\r
 291 \r
 292         if( lReturn == pdPASS )\r
 293         {\r
 294                 /* Enable receive and transmit. */\r
 295                 ETHERC.ECMR.BIT.RE = 1;\r
 296                 ETHERC.ECMR.BIT.TE = 1;\r
 297 \r
 298                 /* Enable EDMAC receive */\r
 299                 EDMAC.EDRRR.LONG = 0x1;\r
 300         }\r
 301         \r
 302         return lReturn;\r
 303 }\r
 304 /*-----------------------------------------------------------*/\r
 305 \r
 306 static void prvInitialiseDescriptors( void )\r
 307 {\r
 308 ethfifo *pxDescriptor;\r
 309 long x;\r
 310 \r
 311         for( x = 0; x < emacNUM_BUFFERS; x++ )\r
 312         {\r
 313                 /* Ensure none of the buffers are shown as in use at the start. */\r
 314                 ucBufferInUse[ x ] = pdFALSE;\r
 315         }\r
 316 \r
 317         /* Initialise the Rx descriptors. */\r
 318         for( x = 0; x < emacNUM_RX_DESCRIPTORS; x++ )\r
 319         {\r
 320                 pxDescriptor = &( xRxDescriptors[ x ] );\r
 321                 pxDescriptor->buf_p = &( xEthernetBuffers.cBuffer[ x ][ 0 ] );\r
 322 \r
 323                 pxDescriptor->bufsize = UIP_BUFSIZE;\r
 324                 pxDescriptor->size = 0;\r
 325                 pxDescriptor->status = ACT;\r
 326                 pxDescriptor->next = &xRxDescriptors[ x + 1 ];  \r
 327                 \r
 328                 /* Mark this buffer as in use. */\r
 329                 ucBufferInUse[ x ] = pdTRUE;\r
 330         }\r
 331 \r
 332         /* The last descriptor points back to the start. */\r
 333         pxDescriptor->status |= DL;\r
 334         pxDescriptor->next = &xRxDescriptors[ 0 ];\r
 335         \r
 336         /* Initialise the Tx descriptors. */\r
 337         for( x = 0; x < emacNUM_TX_BUFFERS; x++ )\r
 338         {\r
 339                 pxDescriptor = &( xTxDescriptors[ x ] );\r
 340                 \r
 341                 /* A buffer is not allocated to the Tx descriptor until a send is\r
 342                 actually required. */\r
 343                 pxDescriptor->buf_p = NULL;\r
 344 \r
 345                 pxDescriptor->bufsize = UIP_BUFSIZE;\r
 346                 pxDescriptor->size = 0;\r
 347                 pxDescriptor->status = 0;\r
 348                 pxDescriptor->next = &xTxDescriptors[ x + 1 ];  \r
 349         }\r
 350 \r
 351         /* The last descriptor points back to the start. */\r
 352         pxDescriptor->status |= DL;\r
 353         pxDescriptor->next = &( xTxDescriptors[ 0 ] );\r
 354         \r
 355         /* Use the first Rx descriptor to start with. */\r
 356         pxCurrentRxDesc = &( xRxDescriptors[ 0 ] );\r
 357 }\r
 358 /*-----------------------------------------------------------*/\r
 359 \r
 360 static unsigned char *prvGetNextBuffer( void )\r
 361 {\r
 362 long x;\r
 363 unsigned char *pucReturn = NULL;\r
 364 unsigned long ulAttempts = 0;\r
 365 \r
 366         while( pucReturn == NULL )\r
 367         {\r
 368                 /* Look through the buffers to find one that is not in use by\r
 369                 anything else. */\r
 370                 for( x = 0; x < emacNUM_BUFFERS; x++ )\r
 371                 {\r
 372                         if( ucBufferInUse[ x ] == pdFALSE )\r
 373                         {\r
 374                                 ucBufferInUse[ x ] = pdTRUE;\r
 375                                 pucReturn = ( unsigned char * ) &( xEthernetBuffers.cBuffer[ x ][ 0 ] );\r
 376                                 break;\r
 377                         }\r
 378                 }\r
 379 \r
 380                 /* Was a buffer found? */\r
 381                 if( pucReturn == NULL )\r
 382                 {\r
 383                         ulAttempts++;\r
 384 \r
 385                         if( ulAttempts >= emacBUFFER_WAIT_ATTEMPTS )\r
 386                         {\r
 387                                 break;\r
 388                         }\r
 389 \r
 390                         /* Wait then look again. */\r
 391                         vTaskDelay( emacBUFFER_WAIT_DELAY_ms );\r
 392                 }\r
 393         }\r
 394 \r
 395         return pucReturn;\r
 396 }\r
 397 /*-----------------------------------------------------------*/\r
 398 \r
 399 static void prvReturnBuffer( unsigned char *pucBuffer )\r
 400 {\r
 401 unsigned long ul;\r
 402 \r
 403         /* Return a buffer to the pool of free buffers. */\r
 404         for( ul = 0; ul < emacNUM_BUFFERS; ul++ )\r
 405         {\r
 406                 if( &( xEthernetBuffers.cBuffer[ ul ][ 0 ] ) == ( void * ) pucBuffer )\r
 407                 {\r
 408                         ucBufferInUse[ ul ] = pdFALSE;\r
 409                         break;\r
 410                 }\r
 411         }\r
 412 }\r
 413 /*-----------------------------------------------------------*/\r
 414 \r
 415 static void prvResetEverything( void )\r
 416 {\r
 417         /* Temporary code just to see if this gets called.  This function has not\r
 418         been implemented. */\r
 419         portDISABLE_INTERRUPTS();\r
 420         for( ;; );\r
 421 }\r
 422 /*-----------------------------------------------------------*/\r
 423 \r
 424 static unsigned long prvCheckRxFifoStatus( void )\r
 425 {\r
 426 unsigned long ulReturn = 0;\r
 427 \r
 428         if( ( pxCurrentRxDesc->status & ACT ) != 0 )\r
 429         {\r
 430                 /* Current descriptor is still active. */\r
 431         }\r
 432         else if( ( pxCurrentRxDesc->status & FE ) != 0 )\r
 433         {\r
 434                 /* Frame error.  Clear the error. */\r
 435                 pxCurrentRxDesc->status &= ~( FP1 | FP0 | FE );\r
 436                 pxCurrentRxDesc->status &= ~( RMAF | RRF | RTLF | RTSF | PRE | CERF );\r
 437                 pxCurrentRxDesc->status |= ACT;\r
 438                 pxCurrentRxDesc = pxCurrentRxDesc->next;\r
 439 \r
 440                 if( EDMAC.EDRRR.LONG == 0x00000000UL )\r
 441                 {\r
 442                         /* Restart Ethernet if it has stopped. */\r
 443                         EDMAC.EDRRR.LONG = 0x00000001UL;\r
 444                 }       \r
 445         }\r
 446         else\r
 447         {\r
 448                 /* The descriptor contains a frame.  Because of the size of the buffers\r
 449                 the frame should always be complete. */\r
 450                 if( ( pxCurrentRxDesc->status & FP0 ) == FP0 )\r
 451                 {\r
 452                         ulReturn = pxCurrentRxDesc->size;\r
 453                 }\r
 454                 else\r
 455                 {\r
 456                         /* Do not expect to get here. */\r
 457                         prvResetEverything();\r
 458                 }\r
 459         }\r
 460         \r
 461         return ulReturn;\r
 462 }\r
 463 /*-----------------------------------------------------------*/\r
 464 \r
 465 static void prvResetMAC( void )\r
 466 {\r
 467         /* Ensure the EtherC and EDMAC are enabled. */\r
 468         SYSTEM.MSTPCRB.BIT.MSTPB15 = 0;\r
 469         vTaskDelay( 100 / portTICK_PERIOD_MS );\r
 470         \r
 471         EDMAC.EDMR.BIT.SWR = 1; \r
 472         \r
 473         /* Crude wait for reset to complete. */\r
 474         vTaskDelay( 500 / portTICK_PERIOD_MS ); \r
 475 }\r
 476 /*-----------------------------------------------------------*/\r
 477 \r
 478 static void prvConfigureEtherCAndEDMAC( void )\r
 479 {\r
 480         /* Initialisation code taken from Renesas example project. */\r
 481         \r
 482         /* TODO:    Check   bit 5   */\r
 483         ETHERC.ECSR.LONG = 0x00000037;                          /* Clear all ETHERC statuS BFR, PSRTO, LCHNG, MPD, ICD */\r
 484 \r
 485         /* Set the EDMAC interrupt priority. */\r
 486         _IPR( _ETHER_EINT ) = configKERNEL_INTERRUPT_PRIORITY;\r
 487 \r
 488         /* TODO:    Check   bit 5   */\r
 489         /* Enable interrupts of interest only. */\r
 490         EDMAC.EESIPR.LONG = emacTX_END_INTERRUPT | emacRX_END_INTERRUPT;\r
 491         ETHERC.RFLR.LONG = 1518;                                        /* Ether payload is 1500+ CRC */\r
 492         ETHERC.IPGR.LONG = 0x00000014;                          /* Intergap is 96-bit time */\r
 493 \r
 494         /* EDMAC */\r
 495         EDMAC.EESR.LONG = 0x47FF0F9F;                           /* Clear all ETHERC and EDMAC status bits */\r
 496         #ifdef __LIT\r
 497                 EDMAC.EDMR.BIT.DE = 1;\r
 498         #endif\r
 499         EDMAC.RDLAR = ( void * ) pxCurrentRxDesc;       /* Initialaize Rx Descriptor List Address */\r
 500         EDMAC.TDLAR = &( xTxDescriptors[ 0 ] );         /* Initialaize Tx Descriptor List Address */\r
 501         EDMAC.TRSCER.LONG = 0x00000000;                         /* Copy-back status is RFE & TFE only   */\r
 502         EDMAC.TFTR.LONG = 0x00000000;                           /* Threshold of Tx_FIFO */\r
 503         EDMAC.FDR.LONG = 0x00000000;                            /* Transmit fifo & receive fifo is 256 bytes */\r
 504         EDMAC.RMCR.LONG = 0x00000003;                           /* Receive function is normal mode(continued) */\r
 505         ETHERC.ECMR.BIT.PRM = 0;                                        /* Ensure promiscuous mode is off. */\r
 506                 \r
 507         /* Enable the interrupt... */\r
 508         _IEN( _ETHER_EINT ) = 1;        \r
 509 }\r
 510 /*-----------------------------------------------------------*/\r
 511 \r
 512 #pragma interrupt ( vEMAC_ISR_Handler( vect = VECT_ETHER_EINT, enable ) )\r
 513 void vEMAC_ISR_Handler( void )\r
 514 {\r
 515 unsigned long ul = EDMAC.EESR.LONG;\r
 516 long lHigherPriorityTaskWoken = pdFALSE;\r
 517 extern QueueHandle_t xEMACEventQueue;\r
 518 const unsigned long ulRxEvent = uipETHERNET_RX_EVENT;\r
 519 \r
 520         /* Has a Tx end occurred? */\r
 521         if( ul & emacTX_END_INTERRUPT )\r
 522         {\r
 523                 /* Only return the buffer to the pool once both Txes have completed. */\r
 524                 prvReturnBuffer( ( void * ) xTxDescriptors[ 0 ].buf_p );\r
 525                 EDMAC.EESR.LONG = emacTX_END_INTERRUPT;\r
 526         }\r
 527 \r
 528         /* Has an Rx end occurred? */\r
 529         if( ul & emacRX_END_INTERRUPT )\r
 530         {\r
 531                 /* Make sure the Ethernet task is not blocked waiting for a packet. */\r
 532                 xQueueSendFromISR( xEMACEventQueue, &ulRxEvent, &lHigherPriorityTaskWoken );\r
 533                 portYIELD_FROM_ISR( lHigherPriorityTaskWoken );\r
 534                 EDMAC.EESR.LONG = emacRX_END_INTERRUPT;\r
 535         }\r
 536 }\r
 537 \r