git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/ARM9_STR91X_IAR/Library/source/91x_enet.c

   1 /********************\r
   2 * Original work (C) COPYRIGHT 2006 STMicroelectronics **************************\r
   3 * Modifications (C) CopyRight 2006 Richard barry\r
   4 * File Name          : 91x_enet.c\r
   5 * Author             : MCD Application Team\r
   6 * Date First Issued  : May 2006\r
   7 * Description        : ENET library functions\r
   8 ********************************************************************************\r
   9 * History:\r
  10 * May 2006: v1.0\r
  11 ********************************************************************************\r
  12 * THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS\r
  13 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.\r
  14 * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,\r
  15 * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE\r
  16 * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING\r
  17 * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.\r
  18 *******************************************************************************/\r
  19 \r
  20 \r
  21 /* Includes ------------------------------------------------------------------*/\r
  22 #include "FreeRTOS.h"\r
  23 #include "task.h"\r
  24 #include "91x_lib.h"\r
  25 #include "string.h"  //include when using memcpy function\r
  26 \r
  27 /* Include of other module interface headers ---------------------------------*/\r
  28 /* Local includes ------------------------------------------------------------*/\r
  29 /* Private typedef -----------------------------------------------------------*/\r
  30 /* Private define ------------------------------------------------------------*/\r
  31 #ifndef NULL\r
  32 #define NULL    (0)\r
  33 #endif\r
  34 /* Function return values */\r
  35 #define ENET_OK  (1)\r
  36 #define ENET_NOK (0)\r
  37 \r
  38 /* PHY interface constants. */\r
  39 #define STE100P_STATUS_REG                              0x01\r
  40 #define STE100P_CONTROL_REG                             0x00\r
  41 #define STE100P_LINK_ABILITY                    0x05\r
  42 #define STE100P_STATUS_LINKED                   0x0004\r
  43 #define STE100P_AUTO_NEGOTIATE_ABILITY  0x1000\r
  44 #define STE100P_AUTO_NEGOTIATE_COMPLETE 0x20\r
  45 #define STE100P_10HALF                  0x0020\r
  46 #define STE100P_10FULL                  0x0040\r
  47 #define STE100P_100HALF                 0x0080\r
  48 #define STE100P_100FULL                 0x0100\r
  49 #define STE100P_CTRL_FULL               0x0100\r
  50 \r
  51 \r
  52 /* Private macro -------------------------------------------------------------*/\r
  53 /* Private variables ---------------------------------------------------------*/\r
  54 #define ENET_NUM_RX_BUFFERS 8\r
  55 \r
  56 static ENET_DMADSCRBase  dmaTxDscrBase, dmaRxDscrBase[ ENET_NUM_RX_BUFFERS ];\r
  57 static u8 RxBuff[ ENET_NUM_RX_BUFFERS ][ENET_BUFFER_SIZE];\r
  58 u8 TxBuff[ENET_BUFFER_SIZE];\r
  59 \r
  60 /* Interface functions -------------------------------------------------------*/\r
  61 /* Private functions ---------------------------------------------------------*/\r
  62 \r
  63 /*******************************************************************************\r
  64 * Function Name  : ENET_SetMACConfig(ENET_MACConfig * MAC_Config)\r
  65 * Description    : MAC Control Register Configuration\r
  66 * Input          : MAC_Config structure\r
  67 * Output         : None\r
  68 * Return         : None\r
  69 *******************************************************************************/\r
  70 void ENET_MACControlConfig(ENET_MACConfig *MAC_Config)\r
  71 {\r
  72   /* ReceiveALL bit */\r
  73   if (MAC_Config->ReceiveALL==ENABLE) ENET_MAC->MCR |= MAC_MCR_RA;\r
  74   else ENET_MAC->MCR &=~MAC_MCR_RA;\r
  75 \r
  76   /* MIIPrescaler */\r
  77   ENET_MAC->MCR &=~(0x3<<24);\r
  78   if ((MAC_Config->MIIPrescaler) == MIIPrescaler_2)\r
  79   ENET_MAC->MCR |=0x1<<24;\r
  80 \r
  81   /* Loopback mode */\r
  82   if (MAC_Config->LoopbackMode==ENABLE)\r
  83   {\r
  84     ENET_MAC->MCR &=~MAC_MCR_LM;\r
  85     ENET_MAC->MCR |=0x1<<21;\r
  86     ENET_MAC->MCR &=~MAC_MCR_DRO;  /*enable frame reception during transmission*/\r
  87   }\r
  88 \r
  89   /* Address filtering mode */\r
  90   ENET_MAC->MCR &=~MAC_MCR_AFM;\r
  91   ENET_MAC->MCR |= MAC_Config->AddressFilteringMode;\r
  92 \r
  93   /* VLAN Filtering Mode */\r
  94         ENET_MAC->MCR |= (MAC_Config->VLANFilteringMode)<<15;\r
  95 \r
  96   /*Wrong Frame Pass */\r
  97   if (MAC_Config->PassWrongFrame == ENABLE) ENET_MAC->MCR |=MAC_MCR_PWF;\r
  98   else ENET_MAC->MCR &=~MAC_MCR_PWF;\r
  99 \r
 100   /* Late Collision Retransmission*/\r
 101   if (MAC_Config->LateCollision == ENABLE) ENET_MAC->MCR |=MAC_MCR_ELC;\r
 102   else ENET_MAC->MCR &=~MAC_MCR_ELC;\r
 103 \r
 104   /* Broadcast Frame Reception */\r
 105   if (MAC_Config->BroadcastFrameReception == ENABLE) ENET_MAC->MCR &=~MAC_MCR_DBF;\r
 106   else ENET_MAC->MCR |=MAC_MCR_DBF;\r
 107 \r
 108   /* PacketRetry */\r
 109   if (MAC_Config->PacketRetry == ENABLE) ENET_MAC->MCR &=~MAC_MCR_DPR;\r
 110   else ENET_MAC->MCR |=MAC_MCR_DPR;\r
 111 \r
 112   /* RxFrameFiltering */\r
 113   if (MAC_Config->RxFrameFiltering == ENABLE) ENET_MAC->MCR |=MAC_MCR_RVFF;\r
 114   else ENET_MAC->MCR &=~MAC_MCR_RVFF;\r
 115 \r
 116   /* AutomaticPadRemoval */\r
 117   if (MAC_Config->AutomaticPadRemoval == ENABLE) ENET_MAC->MCR |=MAC_MCR_APR;\r
 118   else ENET_MAC->MCR &=~MAC_MCR_APR;\r
 119 \r
 120   /* DefferalCheck */\r
 121   if (MAC_Config->DeferralCheck == ENABLE) ENET_MAC->MCR |=MAC_MCR_DCE;\r
 122   else ENET_MAC->MCR &=~MAC_MCR_DCE;\r
 123 \r
 124 }\r
 125 \r
 126 \r
 127 \r
 128 /*******************************************************************************\r
 129 * Function Name  : ENET_SetOperatingMode\r
 130 * Description    : Sets the Operating mode\r
 131 * Input          : ENET_OperatingMode:(see ENET_OperatingMode in 91x_enet.h)\r
 132 * Output         : None\r
 133 * Return         : None\r
 134 *******************************************************************************/\r
 135 portBASE_TYPE ENET_SetOperatingMode( void )\r
 136 {\r
 137 unsigned long ulStatusReg, ulControlReg, ulLinkAbilityReg;\r
 138 \r
 139         /* Link status is latched, so read twice to get current value */\r
 140         ulStatusReg = ENET_MIIReadReg(0, STE100P_STATUS_REG);\r
 141         ulStatusReg = ENET_MIIReadReg(0, STE100P_STATUS_REG);\r
 142 \r
 143         if( !( ulStatusReg & STE100P_STATUS_LINKED ) )\r
 144         {       \r
 145                 /* No Link. */\r
 146                 return pdFAIL;\r
 147         }\r
 148 \r
 149         ulControlReg = ENET_MIIReadReg(0, STE100P_CONTROL_REG);\r
 150         if (ulControlReg & STE100P_AUTO_NEGOTIATE_ABILITY)\r
 151         {                               \r
 152                 /* AutoNegotiation is enabled. */\r
 153                 if (!(ulStatusReg & STE100P_AUTO_NEGOTIATE_COMPLETE))\r
 154                 {\r
 155                         /* Auto-negotiation in progress. */\r
 156                         return pdFAIL;                          \r
 157                 }               \r
 158 \r
 159                 ulLinkAbilityReg = ENET_MIIReadReg(0, STE100P_LINK_ABILITY);\r
 160                 if( ( ulLinkAbilityReg & STE100P_100FULL ) || ( ulLinkAbilityReg & STE100P_10FULL ) )\r
 161                 {\r
 162                         ENET_MAC->MCR |=MAC_MCR_FDM;   /* full duplex mode */\r
 163                         ENET_MAC->MCR &=~MAC_MCR_DRO;  /* enable frame reception during transmission */\r
 164                 }\r
 165                 else\r
 166                 {\r
 167                         ENET_MAC->MCR &=~MAC_MCR_FDM; /* half duplex mode */\r
 168                         ENET_MAC->MCR |=MAC_MCR_DRO;  /* disable frame reception during transmission */\r
 169                 }\r
 170         }\r
 171         else\r
 172         {\r
 173                 if( ulStatusReg & STE100P_CTRL_FULL )\r
 174                 {\r
 175                         ENET_MAC->MCR |=MAC_MCR_FDM;   /* full duplex mode */\r
 176                         ENET_MAC->MCR &=~MAC_MCR_DRO;  /* enable frame reception during transmission */         \r
 177                 }\r
 178                 else\r
 179                 {\r
 180                         ENET_MAC->MCR &=~MAC_MCR_FDM; /* half duplex mode */\r
 181                         ENET_MAC->MCR |=MAC_MCR_DRO;  /* disable frame reception during transmission */\r
 182                 }\r
 183         }       \r
 184         \r
 185         return pdPASS;\r
 186 }\r
 187 \r
 188 /*******************************************************************************\r
 189 * Function Name  : ENET_MIIWriteReg\r
 190 * Description    : Writes a value on the PHY registers\r
 191 * Input          : phyDev PHY device address\r
 192                  : phyReg PHY register to be written\r
 193 *                : phyVal PHY register value\r
 194 * Output         : None\r
 195 * Return         : None\r
 196 *******************************************************************************/\r
 197 void ENET_MIIWriteReg (u8 phyDev, u8 phyReg, u32  phyVal)\r
 198 {\r
 199 \r
 200   volatile u32 addr;\r
 201   volatile u32 res;     /* temporary result for address register status */\r
 202   volatile u32 timeout;\r
 203 \r
 204   /* Prepare the MII register address */\r
 205   addr = 0;\r
 206   addr |= ((phyDev<<11) & MAC_MII_ADDR_PHY_ADDR); /* set the PHY address */\r
 207   addr |= ((phyReg<<6) & MAC_MII_ADDR_MII_REG); /* select the corresponding register */\r
 208   addr |= MAC_MII_ADDR_MII_WRITE;  /* in write mode */\r
 209   addr |= MAC_MII_ADDR_MII_BUSY;\r
 210 \r
 211   /* Check for the Busy flag */\r
 212   timeout=0;\r
 213   do\r
 214   {\r
 215     timeout++;\r
 216     res = ENET_MAC->MIIA;\r
 217   } while ((res & MAC_MII_ADDR_MII_BUSY) && (timeout < (u32 )MII_WRITE_TO));\r
 218 \r
 219   /* Give the value to the MII data register */\r
 220   ENET_MAC->MIID = (phyVal & 0xFFFF);\r
 221 \r
 222   /* write the result value into the MII Address register */\r
 223   ENET_MAC->MIIA =addr;\r
 224 \r
 225   /* Check for the Busy flag */\r
 226   timeout=0;\r
 227   do\r
 228   {\r
 229     timeout++;\r
 230     res = ENET_MAC->MIIA;\r
 231   } while ((res & MAC_MII_ADDR_MII_BUSY) && (timeout < (u32 )MII_WRITE_TO));\r
 232 \r
 233 }\r
 234 \r
 235 /*******************************************************************************\r
 236 * Function Name  : ENET_MIIReadReg\r
 237 * Description    : Writes a value on the PHY\r
 238 * Input          : phyDev PHY device address\r
 239 *                : phyReg PHY register to be read\r
 240 * Output         : None\r
 241 * Return         : The read value (16 bits)\r
 242 *******************************************************************************/\r
 243 u32 ENET_MIIReadReg (u8 phyDev, u32 phyReg )\r
 244 {\r
 245 \r
 246   u32 rValue;\r
 247   u32 addr;\r
 248   u32 res;     /* temporary result for address register status */\r
 249   u32 timeout; /* timeout value for read process */\r
 250 \r
 251   /* prepare the MII register address */\r
 252   addr = 0;\r
 253   addr |= ((phyDev<<11) & MAC_MII_ADDR_PHY_ADDR); /* set the PHY address */\r
 254   addr |= ((phyReg<<6) & MAC_MII_ADDR_MII_REG); /* select the corresponding register */\r
 255   addr &= ~(MAC_MII_ADDR_MII_WRITE);  /* ... in read mode */\r
 256   addr |= MAC_MII_ADDR_MII_BUSY;\r
 257 \r
 258   /* Check for the Busy flag */\r
 259   timeout = 0;\r
 260 \r
 261   do\r
 262   {\r
 263     timeout++;\r
 264     res = ENET_MAC->MIIA;\r
 265   } while ((res & MAC_MII_ADDR_MII_BUSY) && (timeout < (u32 )MII_READ_TO));\r
 266 \r
 267   /* write the result value into the MII Address register */\r
 268   ENET_MAC->MIIA = addr;\r
 269 \r
 270   /* Check for the Busy flag */\r
 271   timeout = 0;\r
 272 \r
 273   do\r
 274   {\r
 275     timeout++;\r
 276     res = ENET_MAC->MIIA;\r
 277   } while ((res & MAC_MII_ADDR_MII_BUSY) && (timeout < (u32 )MII_READ_TO));\r
 278 \r
 279   /* read the result value from data register*/\r
 280   rValue = ENET_MAC->MIID;\r
 281 \r
 282   return (rValue & 0x0000FFFF);\r
 283 }\r
 284 \r
 285 /*******************************************************************************\r
 286 * Function Name  : ENET_RxDscrInit\r
 287 * Description    : Initializes the Rx ENET descriptor chain. Single Descriptor\r
 288 * Input          : None\r
 289 * Output         : None\r
 290 * Return         : None\r
 291 *******************************************************************************/\r
 292 \r
 293 void ENET_RxDscrInit(void)\r
 294 {\r
 295 int i;\r
 296 \r
 297         for( i = 0; i < ENET_NUM_RX_BUFFERS; i++ )\r
 298         {\r
 299                 /* Assign temp Rx array to the ENET buffer */\r
 300                 dmaRxDscrBase[ i ].dmaAddr = (u32)&(RxBuff[ i ][ 0 ]);\r
 301 \r
 302                 /* Initialize RX ENET Status and control */\r
 303                 dmaRxDscrBase[ i ].dmaStatCntl = 0x4000;\r
 304 \r
 305                 /* Initialize the next descriptor- In our case its single descriptor */\r
 306                 dmaRxDscrBase[ i ].dmaNext = (u32)&(dmaRxDscrBase[i+1]) | 0x01;\r
 307 \r
 308                 /* Set the max packet size  */\r
 309                 dmaRxDscrBase[ i ].dmaStatCntl = ENET_MAX_PACKET_SIZE | ENET_NEXT_ENABLE;\r
 310 \r
 311                 /* Setting the VALID bit */\r
 312                 dmaRxDscrBase[ i ].dmaPackStatus = DMA_DSCR_RX_STATUS_VALID_MSK;\r
 313         }\r
 314 \r
 315         dmaRxDscrBase[ ENET_NUM_RX_BUFFERS - 1 ].dmaNext = (u32)&(dmaRxDscrBase[ 0 ]);\r
 316 \r
 317         /* Setting the RX NEXT Descriptor Register inside the ENET */\r
 318         ENET_DMA->RXNDAR = (u32)&(dmaRxDscrBase) | 0x01;\r
 319 }\r
 320 \r
 321 /*******************************************************************************\r
 322 * Function Name  : ENET_TxDscrInit\r
 323 * Description    : Initializes the Tx ENET descriptor chain with single descriptor\r
 324 * Input          : None\r
 325 * Output         : None\r
 326 * Return         : None\r
 327 *******************************************************************************/\r
 328 \r
 329 void ENET_TxDscrInit(void)\r
 330 {\r
 331 \r
 332   /* ENET Start Address */\r
 333   dmaTxDscrBase.dmaAddr = (u32)TxBuff;\r
 334 \r
 335   /* Next Descriptor Address */\r
 336   dmaTxDscrBase.dmaNext = (u32)&(dmaTxDscrBase);\r
 337 \r
 338   /* Initialize ENET status and control */\r
 339   dmaTxDscrBase.dmaStatCntl = 0;\r
 340 \r
 341   /* Tx next set to Tx decriptor base */\r
 342   ENET_DMA->TXNDAR = (u32)&(dmaTxDscrBase);\r
 343 \r
 344   /* Enable next enable */\r
 345   ENET_DMA->TXNDAR |= DMA_DSCR_NXT_NPOL_EN;\r
 346 \r
 347 }\r
 348 \r
 349 /*******************************************************************************\r
 350 * Function Name  : ENET_Init\r
 351 * Description    : ENET MAC, PHY and DMA initializations\r
 352 * Input          : None\r
 353 * Output         : None\r
 354 * Return         : None\r
 355 *******************************************************************************/\r
 356 void ENET_Init ()\r
 357 {\r
 358 \r
 359   vu32 regValue;\r
 360   ENET_MACConfig *MAC_Config;\r
 361   ENET_MACConfig config;\r
 362 \r
 363   /* De-assert the SRESET bit of ENET + MAC devices */\r
 364   ENET_DMA->SCR &=~DMA_SCR_SRESET;\r
 365   MAC_Config =&config;\r
 366   /* Initialize MAC control register with common values */\r
 367   MAC_Config->ReceiveALL = DISABLE;\r
 368   if (SCU_GetHCLKFreqValue() > 50000)\r
 369   MAC_Config->MIIPrescaler = MIIPrescaler_2;\r
 370   MAC_Config->LoopbackMode = DISABLE;\r
 371   MAC_Config->AddressFilteringMode = MAC_Perfect_Multicast_Perfect;\r
 372         MAC_Config->VLANFilteringMode = VLANfilter_VLTAG;\r
 373   MAC_Config->PassWrongFrame = DISABLE;\r
 374   MAC_Config->LateCollision = DISABLE;\r
 375   MAC_Config->BroadcastFrameReception = ENABLE;\r
 376   MAC_Config->PacketRetry = ENABLE;\r
 377   MAC_Config->RxFrameFiltering = ENABLE;\r
 378   MAC_Config->AutomaticPadRemoval = ENABLE;\r
 379   MAC_Config->DeferralCheck = ENABLE;\r
 380 \r
 381     /* Configure MAC control register */\r
 382   ENET_MACControlConfig(MAC_Config);\r
 383 \r
 384   /* DMA initialization */\r
 385   /* Read the ENET DMA Status and Control Register */\r
 386   regValue = ENET_DMA->SCR;\r
 387 \r
 388   /* Setup Tx Max burst size */\r
 389   regValue &= ~(u32)DMA_SCR_TX_MAX_BURST_SZ;\r
 390   regValue |= (u32)DMA_SCR_TX_MAX_BURST_SZ_VAL;\r
 391 \r
 392   /* Setup Rx Max Burst size */\r
 393   regValue &= ~(u32)DMA_SCR_RX_MAX_BURST_SZ;\r
 394   regValue |= (u32)DMA_SCR_RX_MAX_BURST_SZ_VAL;\r
 395 \r
 396   /* Write Tx & Rx burst size to the ENET status and control register */\r
 397   ENET_DMA->SCR = regValue;\r
 398 \r
 399   /* Put the PHY in reset mode */\r
 400   ENET_MIIWriteReg(0x0,MAC_MII_REG_XCR, 0x8000);\r
 401 \r
 402   /* Delay to assure PHY reset */\r
 403   vTaskDelay( 3000 / portTICK_RATE_MS );\r
 404 \r
 405   /* initialize the opearting mode */\r
 406   while( ENET_SetOperatingMode() == pdFAIL )\r
 407   {\r
 408                 vTaskDelay( 3000 / portTICK_RATE_MS );\r
 409   }\r
 410         \r
 411   /*set MAC physical*/\r
 412         //ENET_MAC->MAH = (MAC_ADDR5<<8) + MAC_ADDR4;\r
 413         //ENET_MAC->MAL = (MAC_ADDR3<<24) + (MAC_ADDR2<<16) + (MAC_ADDR1<<8) + MAC_ADDR0;\r
 414         \r
 415   /* Initialize Rx and Tx descriptors in memory */\r
 416   ENET_TxDscrInit();\r
 417   ENET_RxDscrInit();\r
 418 \r
 419         // What's happening ???\r
 420 #ifdef DEBUG\r
 421         //int pippo = 1; // Do NOT remove!!!\r
 422 #endif\r
 423 }\r
 424 \r
 425 /********************************************************************************\r
 426 * Function Name  : ENET_HandleRxPkt\r
 427 * Description    : receive a packet and copy it to memory pointed by ppkt.\r
 428 * Input          : ppkt: pointer on application receive buffer.\r
 429 * Output         : None\r
 430 * Return         : ENET_NOK - If there is no packet\r
 431 *                : ENET_OK  - If there is a packet\r
 432 *******************************************************************************/\r
 433 u32 ENET_HandleRxPkt ( void *ppkt)\r
 434 {\r
 435 ENET_DMADSCRBase *pDescr;\r
 436 u16 size;\r
 437 static int iNextRx = 0;\r
 438 \r
 439         if( dmaRxDscrBase[ iNextRx ].dmaPackStatus & DMA_DSCR_RX_STATUS_VALID_MSK )\r
 440         {\r
 441                 return 0;\r
 442         }\r
 443 \r
 444         pDescr = &dmaRxDscrBase[ iNextRx ];\r
 445 \r
 446         /*Get the size of the packet*/\r
 447         size = ((pDescr->dmaPackStatus & 0x7ff) - 4);\r
 448 \r
 449         //MEMCOPY_L2S_BY4((u8*)ppkt, RxBuff, size); /*optimized memcopy function*/\r
 450         memcpy(ppkt, RxBuff[iNextRx], size);   //string.h library*/\r
 451 \r
 452         /* Give the buffer back to ENET */\r
 453         pDescr->dmaPackStatus = DMA_DSCR_RX_STATUS_VALID_MSK;\r
 454 \r
 455         iNextRx++;\r
 456 \r
 457         if( iNextRx >= ENET_NUM_RX_BUFFERS )\r
 458         {\r
 459                 iNextRx = 0;\r
 460         }\r
 461 \r
 462         /* Return no error */\r
 463         return size;\r
 464 }\r
 465 \r
 466 /*******************************************************************************\r
 467 * Function Name  : ENET_TxPkt\r
 468 * Description    : Transmit a packet\r
 469 * Input          : ppkt: pointer to application packet Buffer\r
 470 *                : size: Tx Packet size\r
 471 * Output         : None\r
 472 * Return         : None\r
 473 *******************************************************************************/\r
 474 \r
 475 u8 *pcGetNextBuffer( void )\r
 476 {\r
 477         if( dmaTxDscrBase.dmaPackStatus & DMA_DSCR_TX_STATUS_VALID_MSK )\r
 478         {\r
 479                 return NULL;\r
 480         }\r
 481         else\r
 482         {\r
 483                 return ( unsigned char * ) TxBuff;\r
 484         }\r
 485 }\r
 486 \r
 487 void ENET_TxPkt(void *ppkt, u16 size)\r
 488 {\r
 489         /* Setting the Frame Length*/\r
 490         dmaTxDscrBase.dmaStatCntl = (size&0xFFF);\r
 491 \r
 492         /* Start the ENET by setting the VALID bit in dmaPackStatus of current descr*/\r
 493         dmaTxDscrBase.dmaPackStatus = DMA_DSCR_TX_STATUS_VALID_MSK;\r
 494 \r
 495         /* Start the transmit operation */\r
 496         ENET_DMA->TXSTR|= DMA_TX_START_FETCH;\r
 497 }\r
 498 \r
 499 /*******************************************************************************\r
 500 * Function Name  : ENET_Start\r
 501 * Description    : Enables ENET MAC reception / transmission & starts DMA fetch\r
 502 * Input          : None\r
 503 * Output         : None\r
 504 * Return         : None\r
 505 *******************************************************************************/\r
 506 \r
 507 void  ENET_Start ( void)\r
 508 {\r
 509   u32 value;\r
 510 \r
 511   /* Force a ENET abort by software for the receive block */\r
 512    ENET_DMA->RXSTR &=~ DMA_RX_START_DMA_EN;\r
 513 \r
 514   /* Force a ENET abort by software for the transmit block */\r
 515    ENET_DMA->TXSTR &=~DMA_TX_START_DMA_EN;\r
 516 \r
 517   /* Reset all interrupts */\r
 518   ENET_DMA->ISR = 0xFFFFFFFF;\r
 519 \r
 520   /* Setup Descriptor Fetch ENET_PhyDelay for Receive Block */\r
 521   value = ENET_DMA->RXSTR;\r
 522   value &= ~( DMA_RX_START_DFETCH_DLY );\r
 523   value |= DMA_RX_START_DFETCH_DEFAULT;\r
 524   ENET_DMA->RXSTR=  value;\r
 525 \r
 526   /* Setup Descriptor Fetch ENET_PhyDelay for Transmit Block */\r
 527   value = ENET_DMA->TXSTR;\r
 528   value &= ~( DMA_TX_START_DFETCH_DLY );\r
 529   value |= DMA_TX_START_DFETCH_DEFAULT;\r
 530   ENET_DMA->TXSTR= value;\r
 531 \r
 532   /* Set Tx underrun bit */\r
 533   value &= ~( DMA_TX_START_URUN );\r
 534   value |= DMA_TX_START_URUN;\r
 535   ENET_DMA->TXSTR = value;\r
 536 \r
 537   /* Clear the interrupts */\r
 538   ENET_DMA->IER = 0x0;\r
 539 \r
 540   /* MAC TX enable */\r
 541   ENET_MAC->MCR|= MAC_MCR_TE;\r
 542 \r
 543   /* MAC RX enable */\r
 544   ENET_MAC->MCR|= MAC_MCR_RE;\r
 545 \r
 546   /* Start the DMA Fetch */\r
 547   ENET_DMA->RXSTR|= DMA_RX_START_FETCH;\r
 548 }\r
 549 \r
 550 \r
 551 /*******************************************************************************\r
 552 * Function Name  : ENET_InitClocksGPIO\r
 553 * Description    : Reset, clocks & GPIO Ethernet Pin initializations\r
 554 * Input          : None\r
 555 * Output         : None\r
 556 * Return         : None\r
 557 *******************************************************************************/\r
 558 void ENET_InitClocksGPIO(void)\r
 559 {\r
 560 \r
 561   GPIO_InitTypeDef GPIO_Struct;\r
 562 \r
 563   SCU_AHBPeriphClockConfig(__ENET, ENABLE);\r
 564   SCU_AHBPeriphReset(__ENET,DISABLE);\r
 565   SCU_PHYCLKConfig(ENABLE);\r
 566 \r
 567   GPIO_DeInit(GPIO1);\r
 568   GPIO_Struct.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2 |GPIO_Pin_3 |GPIO_Pin_4 |GPIO_Pin_7 ;\r
 569   GPIO_Struct.GPIO_Type = GPIO_Type_PushPull;\r
 570   GPIO_Struct.GPIO_Direction = GPIO_PinOutput;\r
 571   GPIO_Struct.GPIO_IPConnected = GPIO_IPConnected_Disable;\r
 572   GPIO_Struct.GPIO_Alternate=GPIO_OutputAlt2;\r
 573   GPIO_Init(GPIO1, &GPIO_Struct);\r
 574 \r
 575 \r
 576   GPIO_DeInit(GPIO5);\r
 577   GPIO_Struct.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;\r
 578   GPIO_Struct.GPIO_Type = GPIO_Type_PushPull;\r
 579   GPIO_Struct.GPIO_Direction = GPIO_PinOutput;\r
 580   GPIO_Struct.GPIO_IPConnected = GPIO_IPConnected_Disable;\r
 581   GPIO_Struct.GPIO_Alternate=GPIO_OutputAlt2;\r
 582   GPIO_Init(GPIO5, &GPIO_Struct);\r
 583 \r
 584 }\r
 585 \r
 586 /******************** (C) COPYRIGHT 2006 STMicroelectronics *******************/\r
 587 \r
 588 \r