EthDev_K64F.c

00001 #include "NyLPC_config.h"
00002 #if NyLPC_MCU==NyLPC_MCU_K64F
00003 #include "NyLPC_stdlib.h"
00004 #include "NyLPC_os.h"
00005 #include "copy_of_ethernet_api.h"
00006 #include "NyLPC_IEthernetDevice.h"
00007 #include "NyLPC_cEthernetMM.h"
00008 //////////
00009 #include "fsl_enet_driver.h"
00010 #include "fsl_enet_hal.h"
00011 #include "fsl_device_registers.h"
00012 #include "fsl_phy_driver.h"
00013 #include "fsl_interrupt_manager.h"
00014 #include "k64f_emac_config.h"
00015 #include <string.h>
00016 #include <stdlib.h>
00017 
00018 /**
00019  */
00020 static NyLPC_TBool start(const struct NyLPC_TEthAddr* i_eth_addr,NyLPC_TiEthernetDevice_onEvent i_handler,void* i_param);
00021 static void stop(void);
00022 static void* getRxEthFrame(unsigned short* o_len_of_data);
00023 static void nextRxEthFrame(void);
00024 static void* allocTxBuf(NyLPC_TUInt16 i_hint,NyLPC_TUInt16* o_size);
00025 static void releaseTxBuf(void* i_buf);
00026 static void sendTxEthFrame(void* i_buf,unsigned short i_size);
00027 
00028 const static struct TiEthernetDevice _interface_KSZ8081RNACA=
00029 {
00030     "KSZ8081RNACA",
00031     start,
00032     stop,
00033     getRxEthFrame,
00034     nextRxEthFrame,
00035     allocTxBuf,
00036     releaseTxBuf,
00037     sendTxEthFrame,
00038     NULL    //deleted API
00039 };
00040 
00041 
00042 
00043 struct TEtherDriver{
00044     int rx_idx;
00045     int tx_idx;
00046     uint8_t *tx_desc_start_addr; /**< TX descriptor start address */
00047     uint8_t *rx_desc_start_addr; /**< RX descriptor start address */
00048 };
00049 
00050 static struct TEtherDriver _driver;
00051 static void* _event_param;
00052 static NyLPC_TiEthernetDevice_onEvent _event_handler;
00053 
00054 ////////////////////////////////////////////////////////////////////////////////
00055 // LANパケットバッファ
00056 ////////////////////////////////////////////////////////////////////////////////
00057 #define NUM_OF_RX_BUF 4
00058 #define SIZE_OF_ETH_PACKET (1536)   //16バイト単位であること
00059 static void* RX_BUF_BASE;           //[NUM_OF_RX_BUF][SIZE_OF_ETH_PACKET]
00060 static unsigned char* RX_BUF;       //[NUM_OF_RX_BUF][SIZE_OF_ETH_PACKET]
00061 static void* TX_BUF_BASE;           //
00062 static unsigned char* TX_BUF;       //sizeof(struct NyLPC_TcEthernetMM_TxMemoryBlock)
00063 
00064 #define NUM_OF_RX_RING NUM_OF_RX_BUF
00065 #define NUM_OF_TX_RING 4
00066 
00067 ////////////////////////////////////////////////////////////////////////////////
00068 //private function
00069 ////////////////////////////////////////////////////////////////////////////////
00070 
00071 
00072 static NyLPC_TBool low_level_init(const unsigned char* i_ethaddr,int i_addr_len);
00073 static void setRxDesc(void* rx_buf, int idx);
00074 static void updateRxDesc(int idx);
00075 static void setTxDesc(int idx);
00076 static void updateTxDesc(int idx, uint8_t *buffer, uint16_t length, bool isLast);
00077 static void eth_arch_enable_interrupts(void);
00078 static void eth_arch_disable_interrupts(void);
00079 static NyLPC_TUInt32 waitForTxEthFrameEmpty(void);
00080 
00081 ////////////////////////////////////////////////////////////////////////////////
00082 //LAN API
00083 ////////////////////////////////////////////////////////////////////////////////
00084 NyLPC_TBool EthDev_K64F_getInterface(
00085     const struct TiEthernetDevice** o_dev)
00086 {
00087     *o_dev=&_interface_KSZ8081RNACA;
00088     RX_BUF_BASE=(unsigned char*)malloc(SIZE_OF_ETH_PACKET*NUM_OF_RX_BUF+RX_BUF_ALIGNMENT);
00089     RX_BUF=(unsigned char*)ENET_ALIGN((NyLPC_TUInt32)RX_BUF_BASE,RX_BUF_ALIGNMENT);
00090     TX_BUF_BASE=malloc(sizeof(struct NyLPC_TcEthernetMM_TxMemoryBlock)+TX_BUF_ALIGNMENT);
00091     TX_BUF=(unsigned char*)ENET_ALIGN((NyLPC_TUInt32)TX_BUF_BASE,TX_BUF_ALIGNMENT);
00092     
00093     return NyLPC_TBool_TRUE;
00094 }
00095 
00096 static NyLPC_TBool start(const struct NyLPC_TEthAddr* i_eth_addr,NyLPC_TiEthernetDevice_onEvent i_handler,void* i_param)
00097 {
00098     _driver.rx_idx=0;
00099     _driver.tx_idx=0;
00100     //ISRw割り込み設定
00101     _event_handler=i_handler;
00102     _event_param=i_param;
00103     
00104     if(!low_level_init((const NyLPC_TUInt8*)(i_eth_addr->addr),6)){
00105         return NyLPC_TBool_FALSE;
00106     }
00107     //TXメモリマネージャの準備(バッファのアライメントは16,パディングも16にしてね。謎バイトが２個いるから。)
00108     NyLPC_cEthernetMM_initialize(TX_BUF);
00109 
00110     //Ethernetの割込み開始設定
00111     NyLPC_cIsr_enterCritical();
00112     //Ethernetの初期化シーケンス。割込みONとか
00113     {
00114         eth_arch_enable_interrupts();
00115     }
00116     NyLPC_cIsr_exitCritical();
00117 
00118     return NyLPC_TBool_TRUE;
00119 }
00120 
00121 static void stop(void)
00122 {
00123     NyLPC_cIsr_enterCritical();
00124     {
00125         eth_arch_disable_interrupts();
00126     }
00127     NyLPC_cIsr_exitCritical();
00128    return;
00129 }
00130 
00131 
00132 #define err_mask (kEnetRxBdTrunc | kEnetRxBdCrc | kEnetRxBdNoOctet | kEnetRxBdLengthViolation)
00133 
00134 static void* getRxEthFrame(unsigned short* o_len_of_data)
00135 {
00136     int idx=_driver.rx_idx;
00137     enet_bd_struct_t * bdPtr = (enet_bd_struct_t*)_driver.rx_desc_start_addr;
00138     if((bdPtr[idx].control & kEnetRxBdEmpty)!=0){
00139         //パケット未着
00140         return NULL;
00141     }
00142     if((bdPtr[idx].control & err_mask) != 0){
00143         //エラー:パケットバッファを再設定して返却
00144         setRxDesc(RX_BUF+(idx*SIZE_OF_ETH_PACKET),idx);        
00145         _driver.rx_idx=(idx+1)%NUM_OF_RX_BUF;
00146         return NULL;
00147     }
00148     *o_len_of_data =(unsigned short)enet_hal_get_bd_length(&(bdPtr[idx]))-2;
00149     return &RX_BUF[idx*SIZE_OF_ETH_PACKET+2];
00150 }
00151 
00152 static void nextRxEthFrame(void)
00153 {
00154     int idx=_driver.rx_idx;
00155     enet_bd_struct_t * bdPtr = (enet_bd_struct_t*)_driver.rx_desc_start_addr;
00156     //現在のRXメモリが有効かを確認
00157     if((bdPtr[idx].control & kEnetRxBdEmpty)==0){
00158         //パケットバッファを復活させる
00159         updateRxDesc(idx);
00160         //キューのエントリを進行
00161         _driver.rx_idx=(idx+1)%NUM_OF_RX_BUF;
00162         return;
00163     }
00164 }
00165 
00166 static void* allocTxBuf(NyLPC_TUInt16 i_hint,NyLPC_TUInt16* o_size)
00167 {
00168     return ((NyLPC_TUInt8*)NyLPC_cEthernetMM_alloc(i_hint,o_size))+2;
00169 }
00170 static void releaseTxBuf(void* i_buf)
00171 {
00172     NyLPC_cEthernetMM_release((NyLPC_TUInt8*)i_buf-2);
00173 }
00174 
00175 
00176 static void sendTxEthFrame(void* i_buf,unsigned short i_size)
00177 {
00178     int Index;
00179     struct NyLPC_TTxBufferHeader* bh=NyLPC_TTxBufferHeader_getBufferHeaderAddr(i_buf-2);
00180     //サイズ0なら送信の必要なし
00181     if(i_size == 0)
00182     {
00183         return;
00184     }
00185     //送信デスクリプタが使えるようになるのを待つよ！
00186     waitForTxEthFrameEmpty();
00187 
00188     //送信対象のメモリブロックを送信中に設定。
00189     if(bh->is_lock){
00190         //送信中のメモリブロックなら無視
00191         return;
00192     }
00193 
00194     //送信中にセット
00195     bh->is_lock=NyLPC_TUInt8_TRUE;
00196 
00197     //最大送信サイズの制限
00198     if (i_size > ETH_FRAG_SIZE){
00199         i_size = ETH_FRAG_SIZE;
00200     }
00201     Index=_driver.tx_idx;
00202 
00203     updateTxDesc(Index,(uint8_t*)((unsigned char*)i_buf-2),i_size+2,Index==(NUM_OF_TX_RING-1));
00204     _driver.tx_idx=(_driver.tx_idx+1)%NUM_OF_TX_RING;
00205     return;
00206 }
00207 
00208 /**
00209  * 送信キューが空くまで待ちます。
00210  * @return
00211  * 次に書き込むことが出来る送信キューのIDだけど使わないで
00212  */
00213 static NyLPC_TUInt32 waitForTxEthFrameEmpty(void)
00214 {
00215     int idx;
00216     int i;
00217     struct NyLPC_TTxBufferHeader *b;
00218     volatile void* p;
00219     volatile enet_bd_struct_t * bdPtr = (enet_bd_struct_t*)_driver.tx_desc_start_addr;
00220 
00221 
00222     //送信キューフルが解除されるまで待ち.現在のTQDescがReady状態の間ループ
00223     
00224     while((bdPtr[_driver.tx_idx].control & kEnetTxBdReady)!=0)
00225     {
00226         NyLPC_cThread_sleep(10);
00227     }
00228     //インデクスを起点にReady状態が0のデスクリプタを全て解放(無駄があるけど無視)
00229     for(i=0;i<NUM_OF_TX_RING;i++){
00230         idx=(_driver.tx_idx+i)%NUM_OF_TX_RING;
00231         if((bdPtr[idx].control & kEnetTxBdReady)!=0){
00232             //if Ready state then break!
00233             break;
00234         }
00235         bdPtr[idx].control=(bdPtr[idx].control)&(~kEnetTxBdReady);
00236         //バッファを参照してたらそいつのロックビットも解放
00237         p=(void*)NTOHL(bdPtr[idx].buffer);
00238         if(p!=NULL){
00239             b=((struct NyLPC_TTxBufferHeader*)p)-1;
00240             b->is_lock=NyLPC_TUInt8_FALSE;
00241             bdPtr[idx].buffer=0;
00242         }
00243     }
00244     return _driver.tx_idx;
00245 }
00246 
00247 ////////////////////////////////////////////////////////////////////////////////
00248 // Ethernet interdface functions
00249 ////////////////////////////////////////////////////////////////////////////////
00250 
00251 
00252 // K64F-specific macros
00253 #define RX_PBUF_AUTO_INDEX    (-1)
00254 extern void k64f_init_eth_hardware(void);
00255 
00256 
00257 //static struct k64f_enetdata k64f_enetdata;
00258 
00259 static enet_dev_if_t enetDevIf[HW_ENET_INSTANCE_COUNT];
00260 static enet_mac_config_t g_enetMacCfg[HW_ENET_INSTANCE_COUNT] = 
00261 {
00262   {
00263     ENET_ETH_MAX_FLEN ,  /*!< enet receive buffer size*/
00264     ENET_RX_LARGE_BUFFER_NUM, /*!< enet large receive buffer number*/
00265     NUM_OF_RX_RING,        /*!< enet receive bd number*/
00266     NUM_OF_TX_RING,        /*!< enet transmit bd number*/
00267     {0},                /*!< enet mac address*/
00268     kEnetCfgRmii,       /*!< enet rmii interface*/
00269     kEnetCfgSpeed100M,  /*!< enet rmii 100M*/
00270     kEnetCfgFullDuplex, /*!< enet rmii Full- duplex*/
00271      /*!< enet mac control flag recommended to use enet_mac_control_flag_t
00272       we send frame with crc so receive crc forward for data length check test*/
00273     kEnetRxCrcFwdEnable | kEnetRxFlowControlEnable,
00274     true,         /*!< enet txaccelerator enabled*/
00275     true,        /*!< enet rxaccelerator enabled*/
00276     false,        /*!< enet store and forward*/
00277     {false, false, true, false, true},  /*!< enet rxaccelerator config*/
00278     {false, false, true},          /*!< enet txaccelerator config*/
00279     true,               /*!< vlan frame support*/
00280     true,               /*!< phy auto discover*/
00281     ENET_MII_CLOCK,     /*!< enet MDC clock*/
00282   },
00283 };
00284 static enet_phy_config_t g_enetPhyCfg[HW_ENET_INSTANCE_COUNT] =
00285 {
00286     {0, false}
00287 };
00288 
00289 static NyLPC_TBool k64f_rx_setup(enet_rxbd_config_t *rxbdCfg);
00290 static NyLPC_TBool k64f_tx_setup(enet_txbd_config_t *txbdCfg);
00291 
00292 
00293 /**
00294  * i_idx番目のデスクリプタにバッファをセット
00295  */
00296 static void setRxDesc(void* rx_buf, int idx)
00297 {
00298     enet_bd_struct_t *start = (enet_bd_struct_t *)_driver.rx_desc_start_addr;
00299     /* Setup descriptor and clear statuses */
00300     enet_hal_init_rxbds(start + idx, (uint8_t*)rx_buf,idx ==(NUM_OF_RX_RING - 1));
00301     enet_hal_active_rxbd(BOARD_DEBUG_ENET_INSTANCE);
00302 }
00303 static void updateRxDesc(int idx)
00304 {
00305     enet_bd_struct_t *start = (enet_bd_struct_t *)_driver.rx_desc_start_addr;
00306     /* Setup descriptor and clear statuses */
00307     enet_hal_update_rxbds(start + idx,NULL,false);
00308     enet_hal_active_rxbd(BOARD_DEBUG_ENET_INSTANCE);
00309 }
00310 static void setTxDesc(int idx)
00311 {
00312     enet_bd_struct_t *start = (enet_bd_struct_t *)_driver.tx_desc_start_addr;
00313     /* Setup descriptor and clear statuses */
00314     enet_hal_init_txbds(start + idx,idx ==(NUM_OF_RX_RING - 1));
00315     enet_hal_active_txbd(BOARD_DEBUG_ENET_INSTANCE);
00316 }
00317 
00318 static void updateTxDesc(int idx, uint8_t *buffer, uint16_t length, bool isLast)
00319 {
00320     volatile enet_bd_struct_t * bdPtr = (enet_bd_struct_t *)(_driver.tx_desc_start_addr + idx * enet_hal_get_bd_size());
00321     
00322     bdPtr->length = HTONS(length); /* Set data length*/
00323     bdPtr->buffer = (uint8_t *)HTONL((uint32_t)buffer); /* Set data buffer*/
00324     bdPtr->control |= kEnetTxBdLast;//最終フラグメントのフラグね
00325     bdPtr->controlExtend1 |= kEnetTxBdTxInterrupt;
00326     bdPtr->controlExtend2 &= ~TX_DESC_UPDATED_MASK; // descriptor not updated by DMA
00327     bdPtr->control |= kEnetTxBdTransmitCrc | kEnetTxBdReady;
00328     if(isLast){
00329         //これはデスクリプタの終了位置のフラグ
00330         bdPtr->control |=kEnetTxBdWrap;
00331     }
00332     enet_hal_active_txbd(BOARD_DEBUG_ENET_INSTANCE);    
00333 }
00334 
00335 static void* ENET_MAC_CONTEXT_BUF=NULL;
00336 
00337 /** \brief  Low level init of the MAC and PHY.
00338  *
00339  *  \param[in]      netif  Pointer to LWIP netif structure
00340  */
00341 NyLPC_TBool low_level_init(const unsigned char* i_ethaddr,int i_addr_len)
00342 {
00343     enet_dev_if_t * enetIfPtr;
00344     uint32_t device = BOARD_DEBUG_ENET_INSTANCE;
00345     enet_rxbd_config_t rxbdCfg;
00346     enet_txbd_config_t txbdCfg;
00347     enet_phy_speed_t phy_speed;
00348     enet_phy_duplex_t phy_duplex;
00349     
00350     //RX/TXメモリはデバイス選択時に確保
00351     k64f_init_eth_hardware();
00352   
00353     /* Initialize device*/
00354     enetIfPtr = (enet_dev_if_t *)&enetDevIf[device];
00355     enetIfPtr->deviceNumber = device;
00356     enetIfPtr->macCfgPtr = &g_enetMacCfg[device];
00357     enetIfPtr->phyCfgPtr = &g_enetPhyCfg[device];
00358     enetIfPtr->macApiPtr = &g_enetMacApi;
00359     enetIfPtr->phyApiPtr = (void *)&g_enetPhyApi;
00360     //macアドレスのコピー
00361     memcpy(enetIfPtr->macCfgPtr->macAddr,(char*)i_ethaddr,i_addr_len);
00362     //enetIfPtr->macContextPtrはgetInterface
00363     if(ENET_MAC_CONTEXT_BUF!=NULL){
00364         free(ENET_MAC_CONTEXT_BUF);
00365         ENET_MAC_CONTEXT_BUF=NULL;
00366     }
00367     ENET_MAC_CONTEXT_BUF=calloc(1, sizeof(enet_mac_context_t));
00368     if(ENET_MAC_CONTEXT_BUF==NULL){
00369         return NyLPC_TBool_FALSE;//ERR_BUF;
00370     }
00371     enetIfPtr->macContextPtr = (enet_mac_context_t *)ENET_MAC_CONTEXT_BUF;
00372 
00373     /* Initialize enet buffers*/
00374     if(!k64f_rx_setup(&rxbdCfg)) {
00375         return NyLPC_TBool_FALSE;//ERR_BUF;
00376     }
00377     /* Initialize enet buffers*/
00378     if(!k64f_tx_setup(&txbdCfg)) {
00379         return NyLPC_TBool_FALSE;//ERR_BUF;
00380     }
00381     /* Initialize enet module*/
00382     if (enet_mac_init(enetIfPtr, &rxbdCfg, &txbdCfg) == kStatus_ENET_Success)
00383     {
00384         /* Initialize PHY*/
00385         if (enetIfPtr->macCfgPtr->isPhyAutoDiscover) {
00386             if (((enet_phy_api_t *)(enetIfPtr->phyApiPtr))->phy_auto_discover(enetIfPtr) != kStatus_PHY_Success)
00387                 return NyLPC_TBool_FALSE;//ERR_IF;
00388         }
00389         if (((enet_phy_api_t *)(enetIfPtr->phyApiPtr))->phy_init(enetIfPtr) != kStatus_PHY_Success)
00390             return NyLPC_TBool_FALSE;//ERR_IF;      
00391         enetIfPtr->isInitialized = true;
00392     }else{
00393         // TODOETH: cleanup memory
00394         return NyLPC_TBool_FALSE;//ERR_IF;
00395     }
00396     
00397     /* Get link information from PHY */
00398     phy_get_link_speed(enetIfPtr, &phy_speed);
00399     phy_get_link_duplex(enetIfPtr, &phy_duplex);
00400     BW_ENET_RCR_RMII_10T(enetIfPtr->deviceNumber, phy_speed == kEnetSpeed10M ? kEnetCfgSpeed10M : kEnetCfgSpeed100M);
00401     BW_ENET_TCR_FDEN(enetIfPtr->deviceNumber, phy_duplex == kEnetFullDuplex ? kEnetCfgFullDuplex : kEnetCfgHalfDuplex);
00402     
00403     /* Enable Ethernet module*/
00404     enet_hal_config_ethernet(device, true, true);
00405     
00406     /* Active Receive buffer descriptor must be done after module enable*/
00407     enet_hal_active_rxbd(enetIfPtr->deviceNumber);
00408     enet_hal_active_txbd(enetIfPtr->deviceNumber);
00409     
00410     return NyLPC_TBool_TRUE;//ERR_OK;
00411 }
00412 
00413 
00414 static void* RX_DESC_BUF_BASE=NULL;
00415 
00416 
00417 /** \brief  Sets up the RX descriptor ring buffers.
00418  *
00419  *  This function sets up the descriptor list used for receive packets.
00420  *
00421  *  \param[in]  netif  Pointer to driver data structure
00422  *  \returns    true/false
00423  */
00424 static NyLPC_TBool k64f_rx_setup(enet_rxbd_config_t *rxbdCfg)
00425 {   
00426 //    struct k64f_enetdata *k64f_enet = &(netif->state);
00427     enet_dev_if_t *enetIfPtr = (enet_dev_if_t *)&enetDevIf[BOARD_DEBUG_ENET_INSTANCE];
00428     uint32_t rxBufferSizeAligned;
00429     int i;
00430 
00431     // Allocate RX descriptors
00432     if(RX_DESC_BUF_BASE!=NULL){
00433         free(RX_DESC_BUF_BASE);
00434         RX_DESC_BUF_BASE=NULL;
00435     }
00436     RX_DESC_BUF_BASE = (void*)calloc(1, enet_hal_get_bd_size() * enetIfPtr->macCfgPtr->rxBdNumber + ENET_BD_ALIGNMENT);
00437     if(RX_DESC_BUF_BASE==NULL){
00438         return NyLPC_TBool_FALSE;
00439     }
00440     //16byteアライメントに修正
00441     _driver.rx_desc_start_addr = (uint8_t *)ENET_ALIGN((NyLPC_TUInt32)RX_DESC_BUF_BASE, ENET_BD_ALIGNMENT);
00442     rxBufferSizeAligned = ENET_ALIGN(enetIfPtr->macCfgPtr->rxBufferSize, ENET_RX_BUFFER_ALIGNMENT);
00443     enetIfPtr->macContextPtr->rxBufferSizeAligned = rxBufferSizeAligned;
00444     rxbdCfg->rxBdPtrAlign = _driver.rx_desc_start_addr;
00445     rxbdCfg->rxBdNum = enetIfPtr->macCfgPtr->rxBdNumber;
00446     rxbdCfg->rxBufferNum = enetIfPtr->macCfgPtr->rxBdNumber;
00447     
00448     //初期化
00449     enet_hal_active_rxbd(BOARD_DEBUG_ENET_INSTANCE);
00450     for(i=0;i<NUM_OF_RX_RING;i++){
00451         setRxDesc(RX_BUF+(i*SIZE_OF_ETH_PACKET),i);
00452     }
00453     //  k64f_rx_queue(netif, RX_PBUF_AUTO_INDEX);
00454     return NyLPC_TBool_TRUE;
00455 }
00456 
00457 
00458 
00459 
00460 static void* TX_DESC_BUF_BASE=NULL;
00461 /** \brief  Sets up the TX descriptor ring buffers.
00462  *
00463  *  This function sets up the descriptor list used for transmit packets.
00464  *
00465  *  \param[in]      netif  Pointer to driver data structure
00466  *  \returns        true/false
00467  */
00468 static NyLPC_TBool k64f_tx_setup(enet_txbd_config_t *txbdCfg)
00469 {
00470     int i;
00471 
00472     enet_dev_if_t *enetIfPtr = (enet_dev_if_t *)&enetDevIf[BOARD_DEBUG_ENET_INSTANCE];
00473     
00474     // Allocate TX descriptors
00475     if(TX_DESC_BUF_BASE!=NULL){
00476         free(TX_DESC_BUF_BASE);
00477         TX_DESC_BUF_BASE=NULL;
00478     }   
00479     TX_DESC_BUF_BASE = (void*)calloc(1, enet_hal_get_bd_size() * enetIfPtr->macCfgPtr->txBdNumber + ENET_BD_ALIGNMENT);
00480     if(TX_DESC_BUF_BASE==NULL){
00481         return NyLPC_TBool_FALSE;
00482     }
00483     
00484     _driver.tx_desc_start_addr = (uint8_t *)ENET_ALIGN((uint32_t)TX_DESC_BUF_BASE, ENET_BD_ALIGNMENT);
00485     
00486     txbdCfg->txBdPtrAlign = _driver.tx_desc_start_addr;
00487     txbdCfg->txBufferNum = enetIfPtr->macCfgPtr->txBdNumber;
00488     txbdCfg->txBufferSizeAlign = ENET_ALIGN(enetIfPtr->maxFrameSize, ENET_TX_BUFFER_ALIGNMENT);
00489     
00490     // Make the TX descriptor ring circular
00491     for(i=0;i<NUM_OF_TX_RING;i++){
00492         setTxDesc(i);
00493     }
00494     return NyLPC_TBool_TRUE;
00495 }
00496 
00497 
00498 //--------------------------------------------------------------------------------
00499 // ISR
00500 //--------------------------------------------------------------------------------
00501 extern IRQn_Type enet_irq_ids[HW_ENET_INSTANCE_COUNT][FSL_FEATURE_ENET_INTERRUPT_COUNT];
00502 extern uint8_t enetIntMap[kEnetIntNum];
00503 extern void *enetIfHandle;
00504 
00505 static void eth_arch_enable_interrupts(void)
00506 {
00507     enet_hal_config_interrupt(BOARD_DEBUG_ENET_INSTANCE, (kEnetTxFrameInterrupt | kEnetRxFrameInterrupt), true);  
00508     interrupt_enable(enet_irq_ids[BOARD_DEBUG_ENET_INSTANCE][enetIntMap[kEnetRxfInt]]);
00509     interrupt_enable(enet_irq_ids[BOARD_DEBUG_ENET_INSTANCE][enetIntMap[kEnetTxfInt]]); 
00510 }
00511 
00512 static void eth_arch_disable_interrupts(void)
00513 {
00514     interrupt_disable(enet_irq_ids[BOARD_DEBUG_ENET_INSTANCE][enetIntMap[kEnetRxfInt]]);
00515     interrupt_disable(enet_irq_ids[BOARD_DEBUG_ENET_INSTANCE][enetIntMap[kEnetTxfInt]]);  
00516 }
00517 void ENET_Transmit_IRQHandler(void)
00518 {
00519 //  led(0,-1);
00520     enet_hal_clear_interrupt(((enet_dev_if_t *)enetIfHandle)->deviceNumber, kEnetTxFrameInterrupt);
00521     _event_handler(_event_param,NyLPC_TiEthernetDevice_EVENT_ON_TX);
00522 }
00523 
00524 void ENET_Receive_IRQHandler(void)
00525 {
00526     enet_hal_clear_interrupt(((enet_dev_if_t *)enetIfHandle)->deviceNumber, kEnetRxFrameInterrupt);
00527     _event_handler(_event_param,NyLPC_TiEthernetDevice_EVENT_ON_RX);
00528 }
00529 
00530 
00531 #endif
00532 
00533 
00534