Dewant Katare
lab 3
Diff: arch/TARGET_K64F/k64f_emac.c
- Revision:
- 10:ab9330955226
- Child:
- 11:fd39ffab9527
diff -r 4694f865720b -r ab9330955226 arch/TARGET_K64F/k64f_emac.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/arch/TARGET_K64F/k64f_emac.c Thu Apr 24 10:45:51 2014 +0100
@@ -0,0 +1,864 @@
+#include "lwip/opt.h"
+#include "lwip/sys.h"
+#include "lwip/def.h"
+#include "lwip/mem.h"
+#include "lwip/pbuf.h"
+#include "lwip/stats.h"
+#include "lwip/snmp.h"
+#include "lwip/tcpip.h"
+#include "netif/etharp.h"
+#include "netif/ppp_oe.h"
+
+#include "eth_arch.h"
+#include "sys_arch.h"
+
+#include "fsl_enet_driver.h"
+#include "fsl_enet_hal.h"
+#include "fsl_device_registers.h"
+#include "fsl_phy_driver.h"
+#include "fsl_interrupt_manager.h"
+#include "k64f_emac_config.h"
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "mbed_interface.h"
+
+extern IRQn_Type enet_irq_ids[HW_ENET_INSTANCE_COUNT][FSL_FEATURE_ENET_INTERRUPT_COUNT];
+extern uint8_t enetIntMap[kEnetIntNum];
+
+/********************************************************************************
+ * Internal data
+ ********************************************************************************/
+
+extern void k64f_init_eth_hardware(void);
+
+/* K64F EMAC driver data structure */
+struct k64f_enetdata {
+ struct netif *netif; /**< Reference back to LWIP parent netif */
+ sys_sem_t RxReadySem; /**< RX packet ready semaphore */
+ sys_sem_t TxCleanSem; /**< TX cleanup thread wakeup semaphore */
+ sys_mutex_t TXLockMutex; /**< TX critical section mutex */
+ sys_sem_t xTXDCountSem; /**< TX free buffer counting semaphore */
+ volatile u32_t rx_free_descs; /**< Count of free RX descriptors */
+ struct pbuf *rxb[ENET_RX_RING_LEN]; /**< RX pbuf pointer list, zero-copy mode */
+ uint8_t *rx_desc_start_addr; /**< RX descriptor start address */
+ uint8_t *tx_desc_start_addr; /**< TX descriptor start address */
+ uint8_t tx_consume_index, tx_produce_index; /**< TX buffers ring */
+ uint8_t rx_fill_index; /**< RX ring fill index */
+ struct pbuf *txb[ENET_TX_RING_LEN]; /**< TX pbuf pointer list, zero-copy mode */
+ void *txb_aligned[ENET_TX_RING_LEN]; /**< TX aligned buffers (if needed) */
+};
+
+static struct k64f_enetdata k64f_enetdata;
+
+static enet_dev_if_t enetDevIf[HW_ENET_INSTANCE_COUNT];
+static enet_mac_config_t g_enetMacCfg[HW_ENET_INSTANCE_COUNT] =
+{
+ {
+ ENET_ETH_MAX_FLEN , /*!< enet receive buffer size*/
+ ENET_RX_LARGE_BUFFER_NUM, /*!< enet large receive buffer number*/
+ ENET_RX_RING_LEN, /*!< enet receive bd number*/
+ ENET_TX_RING_LEN, /*!< enet transmit bd number*/
+ {0}, /*!< enet mac address*/
+ kEnetCfgRmii, /*!< enet rmii interface*/
+ kEnetCfgSpeed100M, /*!< enet rmii 100M*/
+ kEnetCfgFullDuplex, /*!< enet rmii Full- duplex*/
+ /*!< enet mac control flag recommended to use enet_mac_control_flag_t
+ we send frame with crc so receive crc forward for data length check test*/
+ kEnetRxCrcFwdEnable | kEnetRxFlowControlEnable,
+ true, /*!< enet txaccelerator enabled*/
+ true, /*!< enet rxaccelerator enabled*/
+ false, /*!< enet store and forward*/
+ {false, false, true, false, true}, /*!< enet rxaccelerator config*/
+ {false, false, true}, /*!< enet txaccelerator config*/
+ true, /*!< vlan frame support*/
+ true, /*!< phy auto discover*/
+ ENET_MII_CLOCK, /*!< enet MDC clock*/
+ },
+};
+
+static enet_phy_config_t g_enetPhyCfg[HW_ENET_INSTANCE_COUNT] =
+{
+ {0, false}
+};
+
+/** \brief Driver transmit and receive thread priorities
+ *
+ * Thread priorities for receive thread and TX cleanup thread. Alter
+ * to prioritize receive or transmit bandwidth. In a heavily loaded
+ * system or with LEIP_DEBUG enabled, the priorities might be better
+ * the same. */
+#define RX_PRIORITY (osPriorityNormal)
+#define TX_PRIORITY (osPriorityNormal)
+#define PHY_PRIORITY (osPriorityNormal)
+
+/** \brief Debug output formatter lock define
+ *
+ * When using FreeRTOS and with LWIP_DEBUG enabled, enabling this
+ * define will allow RX debug messages to not interleave with the
+ * TX messages (so they are actually readable). Not enabling this
+ * define when the system is under load will cause the output to
+ * be unreadable. There is a small tradeoff in performance for this
+ * so use it only for debug. */
+//#define LOCK_RX_THREAD
+
+/** \brief Signal used for ethernet ISR to signal packet_rx() thread.
+ */
+#define RX_SIGNAL 1
+
+// K64F-specific macros
+#define RX_PBUF_AUTO_INDEX (-1)
+#define TX_DESC_UPDATED_MASK (0x8000)
+
+/********************************************************************************
+ * Buffer management
+ ********************************************************************************/
+
+/** \brief Queues a pbuf into the RX descriptor list
+ *
+ * \param[in] k64f_enet Pointer to the drvier data structure
+ * \param[in] p Pointer to pbuf to queue
+ * \param[in] bidx Index to queue into
+ */
+static void k64f_rxqueue_pbuf(struct k64f_enetdata *k64f_enet, struct pbuf *p, int bidx)
+{
+ enet_bd_struct_t *start = (enet_bd_struct_t *)k64f_enet->rx_desc_start_addr;
+ int idx;
+
+ /* Get next free descriptor index */
+ if (bidx == RX_PBUF_AUTO_INDEX)
+ idx = k64f_enet->rx_fill_index;
+ else
+ idx = bidx;
+
+ /* Setup descriptor and clear statuses */
+ enet_hal_init_rxbds(start + idx, (uint8_t*)p->payload, idx == ENET_RX_RING_LEN - 1);
+
+ /* Save pbuf pointer for push to network layer later */
+ k64f_enet->rxb[idx] = p;
+
+ /* Wrap at end of descriptor list */
+ idx = (idx + 1) % ENET_RX_RING_LEN;
+
+ /* Queue descriptor(s) */
+ k64f_enet->rx_free_descs -= 1;
+
+ if (bidx == RX_PBUF_AUTO_INDEX)
+ k64f_enet->rx_fill_index = idx;
+
+ enet_hal_active_rxbd(BOARD_DEBUG_ENET_INSTANCE);
+
+ LWIP_DEBUGF(UDP_LPC_EMAC | LWIP_DBG_TRACE,
+ ("k64f_rxqueue_pbuf: pbuf packet queued: %p (free desc=%d)\n", p,
+ k64f_enet->rx_free_descs));
+}
+
+/** \brief Attempt to allocate and requeue a new pbuf for RX
+ *
+ * \param[in] netif Pointer to the netif structure
+ * \returns number of queued packets
+ */
+s32_t k64f_rx_queue(struct netif *netif, int idx)
+{
+ struct k64f_enetdata *k64f_enet = netif->state;
+ enet_dev_if_t *enetIfPtr = (enet_dev_if_t *)&enetDevIf[BOARD_DEBUG_ENET_INSTANCE];
+ struct pbuf *p;
+ int queued = 0;
+
+ /* Attempt to requeue as many packets as possible */
+ while (k64f_enet->rx_free_descs > 0) {
+ /* Allocate a pbuf from the pool. We need to allocate at the
+ maximum size as we don't know the size of the yet to be
+ received packet. */
+ p = pbuf_alloc(PBUF_RAW, enetIfPtr->macCfgPtr->rxBufferSize + RX_BUF_ALIGNMENT, PBUF_RAM);
+ if (p == NULL) {
+ LWIP_DEBUGF(UDP_LPC_EMAC | LWIP_DBG_TRACE,
+ ("k64_rx_queue: could not allocate RX pbuf (free desc=%d)\n",
+ k64f_enet->rx_free_descs));
+ return queued;
+ }
+ /* K64F note: the next line ensures that the RX buffer is properly aligned for the K64F
+ RX descriptors (16 bytes alignment). However, by doing so, we're effectively changing
+ a data structure which is internal to lwIP. This might not prove to be a good idea
+ in the long run, but a better fix would probably involve modifying lwIP itself */
+ p->payload = (void*)ENET_ALIGN((uint32_t)p->payload, RX_BUF_ALIGNMENT);
+
+ /* pbufs allocated from the RAM pool should be non-chained. */
+ LWIP_ASSERT("k64f_rx_queue: pbuf is not contiguous (chained)", pbuf_clen(p) <= 1);
+
+ /* Queue packet */
+ k64f_rxqueue_pbuf(k64f_enet, p, idx);
+ queued++;
+ }
+
+ return queued;
+}
+
+/** \brief Sets up the RX descriptor ring buffers.
+ *
+ * This function sets up the descriptor list used for receive packets.
+ *
+ * \param[in] netif Pointer to driver data structure
+ * \returns ERR_MEM if out of memory, ERR_OK otherwise
+ */
+static err_t k64f_rx_setup(struct netif *netif, enet_rxbd_config_t *rxbdCfg) {
+ struct k64f_enetdata *k64f_enet = netif->state;
+ enet_dev_if_t *enetIfPtr = (enet_dev_if_t *)&enetDevIf[BOARD_DEBUG_ENET_INSTANCE];
+ uint8_t *rxBdPtr;
+ uint32_t rxBufferSizeAligned;
+
+ // Allocate RX descriptors
+ rxBdPtr = (uint8_t *)calloc(1, enet_hal_get_bd_size() * enetIfPtr->macCfgPtr->rxBdNumber + ENET_BD_ALIGNMENT);
+ if(!rxBdPtr)
+ return ERR_MEM;
+ k64f_enet->rx_desc_start_addr = (uint8_t *)ENET_ALIGN((uint32_t)rxBdPtr, ENET_BD_ALIGNMENT);
+ k64f_enet->rx_free_descs = enetIfPtr->macCfgPtr->rxBdNumber;
+ k64f_enet->rx_fill_index = 0;
+
+ rxBufferSizeAligned = ENET_ALIGN(enetIfPtr->macCfgPtr->rxBufferSize, ENET_RX_BUFFER_ALIGNMENT);
+ enetIfPtr->macContextPtr->rxBufferSizeAligned = rxBufferSizeAligned;
+ rxbdCfg->rxBdPtrAlign = k64f_enet->rx_desc_start_addr;
+ rxbdCfg->rxBdNum = enetIfPtr->macCfgPtr->rxBdNumber;
+ rxbdCfg->rxBufferNum = enetIfPtr->macCfgPtr->rxBdNumber;
+
+ k64f_rx_queue(netif, RX_PBUF_AUTO_INDEX);
+ return ERR_OK;
+}
+
+/** \brief Sets up the TX descriptor ring buffers.
+ *
+ * This function sets up the descriptor list used for transmit packets.
+ *
+ * \param[in] netif Pointer to driver data structure
+ * \returns ERR_MEM if out of memory, ERR_OK otherwise
+ */
+static err_t k64f_tx_setup(struct netif *netif, enet_txbd_config_t *txbdCfg) {
+ struct k64f_enetdata *k64f_enet = netif->state;
+ enet_dev_if_t *enetIfPtr = (enet_dev_if_t *)&enetDevIf[BOARD_DEBUG_ENET_INSTANCE];
+ uint8_t *txBdPtr;
+
+ // Allocate TX descriptors
+ txBdPtr = (uint8_t *)calloc(1, enet_hal_get_bd_size() * enetIfPtr->macCfgPtr->txBdNumber + ENET_BD_ALIGNMENT);
+ if(!txBdPtr)
+ return ERR_MEM;
+
+ k64f_enet->tx_desc_start_addr = (uint8_t *)ENET_ALIGN((uint32_t)txBdPtr, ENET_BD_ALIGNMENT);
+ k64f_enet->tx_consume_index = k64f_enet->tx_produce_index = 0;
+
+ txbdCfg->txBdPtrAlign = k64f_enet->tx_desc_start_addr;
+ txbdCfg->txBufferNum = enetIfPtr->macCfgPtr->txBdNumber;
+ txbdCfg->txBufferSizeAlign = ENET_ALIGN(enetIfPtr->maxFrameSize, ENET_TX_BUFFER_ALIGNMENT);
+
+ // Make the TX descriptor ring circular
+ enet_hal_init_txbds(k64f_enet->tx_desc_start_addr + enet_hal_get_bd_size() * (ENET_TX_RING_LEN - 1), 1);
+
+ return ERR_OK;
+}
+
+/** \brief Free TX buffers that are complete
+ *
+ * \param[in] k64f_enet Pointer to driver data structure
+ */
+static void k64f_tx_reclaim(struct k64f_enetdata *k64f_enet)
+{
+ uint8_t i;
+ volatile enet_bd_struct_t * bdPtr = (enet_bd_struct_t *)k64f_enet->tx_desc_start_addr;
+
+ /* Get exclusive access */
+ sys_mutex_lock(&k64f_enet->TXLockMutex);
+
+ // Traverse all descriptors, looking for the ones modified by the uDMA
+ i = k64f_enet->tx_consume_index;
+ while(i != k64f_enet->tx_produce_index) {
+ if (bdPtr[i].controlExtend2 & TX_DESC_UPDATED_MASK) { // descriptor updated by uDMA
+ if (k64f_enet->txb_aligned[i]) {
+ free(k64f_enet->txb_aligned[i]);
+ k64f_enet->txb_aligned[i] = NULL;
+ } else if (k64f_enet->txb[i]) {
+ pbuf_free(k64f_enet->txb[i]);
+ k64f_enet->txb[i] = NULL;
+ }
+ osSemaphoreRelease(k64f_enet->xTXDCountSem.id);
+ bdPtr[i].controlExtend2 &= ~TX_DESC_UPDATED_MASK;
+ }
+ i = (i + 1) % ENET_TX_RING_LEN;
+ }
+ k64f_enet->tx_consume_index = i;
+
+ /* Restore access */
+ sys_mutex_unlock(&k64f_enet->TXLockMutex);
+}
+
+/** \brief Low level init of the MAC and PHY.
+ *
+ * \param[in] netif Pointer to LWIP netif structure
+ */
+static err_t low_level_init(struct netif *netif)
+{
+ enet_dev_if_t * enetIfPtr;
+ uint32_t device = BOARD_DEBUG_ENET_INSTANCE;
+ enet_rxbd_config_t rxbdCfg;
+ enet_txbd_config_t txbdCfg;
+ enet_phy_speed_t phy_speed;
+ enet_phy_duplex_t phy_duplex;
+
+ k64f_init_eth_hardware();
+
+ /* Initialize device*/
+ enetIfPtr = (enet_dev_if_t *)&enetDevIf[device];
+ enetIfPtr->deviceNumber = device;
+ enetIfPtr->macCfgPtr = &g_enetMacCfg[device];
+ enetIfPtr->phyCfgPtr = &g_enetPhyCfg[device];
+ enetIfPtr->macApiPtr = &g_enetMacApi;
+ enetIfPtr->phyApiPtr = (void *)&g_enetPhyApi;
+ memcpy(enetIfPtr->macCfgPtr->macAddr, (char*)netif->hwaddr, kEnetMacAddrLen);
+
+ /* Allocate buffer for ENET mac context*/
+ enetIfPtr->macContextPtr = (enet_mac_context_t *)calloc(1, sizeof(enet_mac_context_t));
+ if (!enetIfPtr->macContextPtr) {
+ return ERR_BUF;
+ }
+
+ /* Initialize enet buffers*/
+ if(k64f_rx_setup(netif, &rxbdCfg) != ERR_OK) {
+ return ERR_BUF;
+ }
+ /* Initialize enet buffers*/
+ if(k64f_tx_setup(netif, &txbdCfg) != ERR_OK) {
+ return ERR_BUF;
+ }
+ /* Initialize enet module*/
+ if (enet_mac_init(enetIfPtr, &rxbdCfg, &txbdCfg) == kStatus_ENET_Success)
+ {
+ /* Initialize PHY*/
+ if (enetIfPtr->macCfgPtr->isPhyAutoDiscover) {
+ if (((enet_phy_api_t *)(enetIfPtr->phyApiPtr))->phy_auto_discover(enetIfPtr) != kStatus_PHY_Success)
+ return ERR_IF;
+ }
+ if (((enet_phy_api_t *)(enetIfPtr->phyApiPtr))->phy_init(enetIfPtr) != kStatus_PHY_Success)
+ return ERR_IF;
+
+ enetIfPtr->isInitialized = true;
+ }
+ else
+ {
+ // TODOETH: cleanup memory
+ return ERR_IF;
+ }
+
+ /* Get link information from PHY */
+ phy_get_link_speed(enetIfPtr, &phy_speed);
+ phy_get_link_duplex(enetIfPtr, &phy_duplex);
+ BW_ENET_RCR_RMII_10T(enetIfPtr->deviceNumber, phy_speed == kEnetSpeed10M ? kEnetCfgSpeed10M : kEnetCfgSpeed100M);
+ BW_ENET_TCR_FDEN(enetIfPtr->deviceNumber, phy_duplex == kEnetFullDuplex ? kEnetCfgFullDuplex : kEnetCfgHalfDuplex);
+
+ /* Enable Ethernet module*/
+ enet_hal_config_ethernet(device, true, true);
+
+ /* Active Receive buffer descriptor must be done after module enable*/
+ enet_hal_active_rxbd(enetIfPtr->deviceNumber);
+
+ return ERR_OK;
+}
+
+/********************************************************************************
+ * LWIP port
+ ********************************************************************************/
+
+/** \brief Ethernet receive interrupt handler
+ *
+ * This function handles the receive interrupt of K64F.
+ */
+void enet_mac_rx_isr(void *enetIfPtr)
+{
+ /* Clear interrupt */
+ enet_hal_clear_interrupt(((enet_dev_if_t *)enetIfPtr)->deviceNumber, kEnetRxFrameInterrupt);
+ sys_sem_signal(&k64f_enetdata.RxReadySem);
+}
+
+void enet_mac_tx_isr(void *enetIfPtr)
+{
+ /*Clear interrupt*/
+ enet_hal_clear_interrupt(((enet_dev_if_t *)enetIfPtr)->deviceNumber, kEnetTxFrameInterrupt);
+ sys_sem_signal(&k64f_enetdata.TxCleanSem);
+}
+
+/**
+ * This function is the ethernet packet send function. It calls
+ * etharp_output after checking link status.
+ *
+ * \param[in] netif the lwip network interface structure for this enetif
+ * \param[in] q Pointer to pbug to send
+ * \param[in] ipaddr IP address
+ * \return ERR_OK or error code
+ */
+err_t k64f_etharp_output(struct netif *netif, struct pbuf *q, ip_addr_t *ipaddr)
+{
+ /* Only send packet is link is up */
+ if (netif->flags & NETIF_FLAG_LINK_UP)
+ return etharp_output(netif, q, ipaddr);
+
+ return ERR_CONN;
+}
+
+/** \brief Allocates a pbuf and returns the data from the incoming packet.
+ *
+ * \param[in] netif the lwip network interface structure
+ * \param[in] idx index of packet to be read
+ * \return a pbuf filled with the received packet (including MAC header)
+ */
+static struct pbuf *k64f_low_level_input(struct netif *netif, int idx)
+{
+ struct k64f_enetdata *k64f_enet = netif->state;
+ enet_bd_struct_t * bdPtr = (enet_bd_struct_t*)k64f_enet->rx_desc_start_addr;
+ struct pbuf *p = NULL;
+ u32_t length = 0, orig_length;
+ const u16_t err_mask = kEnetRxBdTrunc | kEnetRxBdCrc | kEnetRxBdNoOctet | kEnetRxBdLengthViolation;
+
+#ifdef LOCK_RX_THREAD
+ /* Get exclusive access */
+ sys_mutex_lock(&k64f_enet->TXLockMutex);
+#endif
+
+ /* Determine if a frame has been received */
+ if ((bdPtr[idx].control & err_mask) != 0) {
+#if LINK_STATS
+ if ((bdPtr[idx].control & kEnetRxBdLengthViolation) != 0)
+ LINK_STATS_INC(link.lenerr);
+ else
+ LINK_STATS_INC(link.chkerr);
+#endif
+ LINK_STATS_INC(link.drop);
+
+ /* Re-queue the same buffer */
+ k64f_enet->rx_free_descs++;
+ p = k64f_enet->rxb[idx];
+ k64f_enet->rxb[idx] = NULL;
+ k64f_rxqueue_pbuf(k64f_enet, p, idx);
+ p = NULL;
+ } else {
+ /* A packet is waiting, get length */
+ length = enet_hal_get_bd_length(bdPtr + idx);
+
+ /* Zero-copy */
+ p = k64f_enet->rxb[idx];
+ orig_length = p->len;
+ p->len = (u16_t) length;
+
+ /* Free pbuf from descriptor */
+ k64f_enet->rxb[idx] = NULL;
+ k64f_enet->rx_free_descs++;
+
+ /* Attempt to queue new buffer */
+ if (k64f_rx_queue(netif, idx) == 0) {
+ /* Drop frame (out of memory) */
+ LINK_STATS_INC(link.drop);
+
+ /* Re-queue the same buffer */
+ p->len = orig_length;
+ k64f_rxqueue_pbuf(k64f_enet, p, idx);
+
+ LWIP_DEBUGF(UDP_LPC_EMAC | LWIP_DBG_TRACE,
+ ("k64f_low_level_input: Packet index %d dropped for OOM\n",
+ idx));
+#ifdef LOCK_RX_THREAD
+ sys_mutex_unlock(&k64f_enet->TXLockMutex);
+#endif
+
+ return NULL;
+ }
+
+ LWIP_DEBUGF(UDP_LPC_EMAC | LWIP_DBG_TRACE,
+ ("k64f_low_level_input: Packet received: %p, size %d (index=%d)\n",
+ p, length, idx));
+
+ /* Save size */
+ p->tot_len = (u16_t) length;
+ LINK_STATS_INC(link.recv);
+ }
+
+#ifdef LOCK_RX_THREAD
+ sys_mutex_unlock(&k64f_enet->TXLockMutex);
+#endif
+
+ return p;
+}
+
+/** \brief Attempt to read a packet from the EMAC interface.
+ *
+ * \param[in] netif the lwip network interface structure
+ * \param[in] idx index of packet to be read
+ */
+void k64f_enetif_input(struct netif *netif, int idx)
+{
+ struct eth_hdr *ethhdr;
+ struct pbuf *p;
+
+ /* move received packet into a new pbuf */
+ p = k64f_low_level_input(netif, idx);
+ if (p == NULL)
+ return;
+
+ /* points to packet payload, which starts with an Ethernet header */
+ ethhdr = (struct eth_hdr*)p->payload;
+
+ switch (htons(ethhdr->type)) {
+ case ETHTYPE_IP:
+ case ETHTYPE_ARP:
+#if PPPOE_SUPPORT
+ case ETHTYPE_PPPOEDISC:
+ case ETHTYPE_PPPOE:
+#endif /* PPPOE_SUPPORT */
+ /* full packet send to tcpip_thread to process */
+ if (netif->input(p, netif) != ERR_OK) {
+ LWIP_DEBUGF(NETIF_DEBUG, ("k64f_enetif_input: IP input error\n"));
+ /* Free buffer */
+ pbuf_free(p);
+ }
+ break;
+
+ default:
+ /* Return buffer */
+ pbuf_free(p);
+ break;
+ }
+}
+
+/** \brief Packet reception task
+ *
+ * This task is called when a packet is received. It will
+ * pass the packet to the LWIP core.
+ *
+ * \param[in] pvParameters pointer to the interface data
+ */
+static void packet_rx(void* pvParameters) {
+ struct k64f_enetdata *k64f_enet = pvParameters;
+ volatile enet_bd_struct_t * bdPtr = (enet_bd_struct_t*)k64f_enet->rx_desc_start_addr;
+ int idx = 0;
+
+ while (1) {
+ /* Wait for receive task to wakeup */
+ sys_arch_sem_wait(&k64f_enet->RxReadySem, 0);
+
+ if ((bdPtr[idx].control & kEnetRxBdEmpty) == 0) {
+ k64f_enetif_input(k64f_enet->netif, idx);
+ idx = (idx + 1) % ENET_RX_RING_LEN;
+ }
+ }
+}
+
+/** \brief Transmit cleanup task
+ *
+ * This task is called when a transmit interrupt occurs and
+ * reclaims the pbuf and descriptor used for the packet once
+ * the packet has been transferred.
+ *
+ * \param[in] pvParameters pointer to the interface data
+ */
+static void packet_tx(void* pvParameters) {
+ struct k64f_enetdata *k64f_enet = pvParameters;
+
+ while (1) {
+ /* Wait for transmit cleanup task to wakeup */
+ sys_arch_sem_wait(&k64f_enet->TxCleanSem, 0);
+ // TODOETH: handle TX underrun?
+ k64f_tx_reclaim(k64f_enet);
+ }
+}
+
+ /** \brief Polls if an available TX descriptor is ready. Can be used to
+ * determine if the low level transmit function will block.
+ *
+ * \param[in] netif the lwip network interface structure
+ * \return 0 if no descriptors are read, or >0
+ */
+s32_t k64f_tx_ready(struct netif *netif)
+{
+ struct k64f_enetdata *k64f_enet = netif->state;
+ s32_t fb;
+ u32_t idx, cidx;
+
+ cidx = k64f_enet->tx_consume_index;
+ idx = k64f_enet->tx_produce_index;
+
+ /* Determine number of free buffers */
+ if (idx == cidx)
+ fb = ENET_TX_RING_LEN;
+ else if (cidx > idx)
+ fb = (ENET_TX_RING_LEN - 1) -
+ ((idx + ENET_TX_RING_LEN) - cidx);
+ else
+ fb = (ENET_TX_RING_LEN - 1) - (cidx - idx);
+
+ return fb;
+}
+
+/*FUNCTION****************************************************************
+ *
+ * Function Name: enet_hal_update_txbds
+ * Description: Update ENET transmit buffer descriptors.
+ *END*********************************************************************/
+void k64f_update_txbds(struct k64f_enetdata *k64f_enet, int idx, uint8_t *buffer, uint16_t length, bool isLast)
+{
+ volatile enet_bd_struct_t * bdPtr = (enet_bd_struct_t *)(k64f_enet->tx_desc_start_addr + idx * enet_hal_get_bd_size());
+
+ bdPtr->length = HTONS(length); /* Set data length*/
+ bdPtr->buffer = (uint8_t *)HTONL((uint32_t)buffer); /* Set data buffer*/
+ if (isLast)
+ bdPtr->control |= kEnetTxBdLast;
+ else
+ bdPtr->control &= ~kEnetTxBdLast;
+ bdPtr->controlExtend1 |= kEnetTxBdTxInterrupt;
+ bdPtr->controlExtend2 &= ~TX_DESC_UPDATED_MASK; // descriptor not updated by DMA
+ bdPtr->control |= kEnetTxBdTransmitCrc | kEnetTxBdReady;
+}
+
+/** \brief Low level output of a packet. Never call this from an
+ * interrupt context, as it may block until TX descriptors
+ * become available.
+ *
+ * \param[in] netif the lwip network interface structure for this netif
+ * \param[in] p the MAC packet to send (e.g. IP packet including MAC addresses and type)
+ * \return ERR_OK if the packet could be sent or an err_t value if the packet couldn't be sent
+ */
+static err_t k64f_low_level_output(struct netif *netif, struct pbuf *p)
+{
+ struct k64f_enetdata *k64f_enet = netif->state;
+ struct pbuf *q;
+ u32_t idx;
+ s32_t dn;
+ uint8_t *psend = NULL, *dst;
+
+ /* Get free TX buffer index */
+ idx = k64f_enet->tx_produce_index;
+
+ /* Check the pbuf chain for payloads that are not 8-byte aligned.
+ If found, a new properly aligned buffer needs to be allocated
+ and the data copied there */
+ for (q = p; q != NULL; q = q->next)
+ if (((u32_t)q->payload & (TX_BUF_ALIGNMENT - 1)) != 0)
+ break;
+ if (q != NULL) {
+ // Allocate properly aligned buffer
+ psend = (uint8_t*)malloc(p->tot_len);
+ if (NULL == psend)
+ return ERR_MEM;
+ LWIP_ASSERT("k64f_low_level_output: buffer not properly aligned", ((u32_t)psend & (TX_BUF_ALIGNMENT - 1)) == 0);
+ for (q = p, dst = psend; q != NULL; q = q->next) {
+ MEMCPY(dst, q->payload, q->len);
+ dst += q->len;
+ }
+ k64f_enet->txb_aligned[idx] = psend;
+ dn = 1;
+ } else {
+ k64f_enet->txb_aligned[idx] = NULL;
+ dn = (s32_t) pbuf_clen(p);
+ pbuf_ref(p);
+ }
+
+ /* Wait until enough descriptors are available for the transfer. */
+ /* THIS WILL BLOCK UNTIL THERE ARE ENOUGH DESCRIPTORS AVAILABLE */
+ while (dn > k64f_tx_ready(netif))
+ osSemaphoreWait(k64f_enet->xTXDCountSem.id, osWaitForever);
+
+ /* Get exclusive access */
+ sys_mutex_lock(&k64f_enet->TXLockMutex);
+
+ /* Setup transfers */
+ q = p;
+ while (dn > 0) {
+ dn--;
+ if (psend != NULL) {
+ k64f_update_txbds(k64f_enet, idx, psend, p->tot_len, 1);
+ k64f_enet->txb[idx] = NULL;
+
+ LWIP_DEBUGF(UDP_LPC_EMAC | LWIP_DBG_TRACE,
+ ("k64f_low_level_output: aligned packet(%p) sent"
+ " size = %d (index=%d)\n", psend, p->tot_len, idx));
+ } else {
+ LWIP_ASSERT("k64f_low_level_output: buffer not properly aligned", ((u32_t)q->payload & 0x07) == 0);
+
+ /* Only save pointer to free on last descriptor */
+ if (dn == 0) {
+ /* Save size of packet and signal it's ready */
+ k64f_update_txbds(k64f_enet, idx, q->payload, q->len, 1);
+ k64f_enet->txb[idx] = p;
+ }
+ else {
+ /* Save size of packet, descriptor is not last */
+ k64f_update_txbds(k64f_enet, idx, q->payload, q->len, 0);
+ k64f_enet->txb[idx] = NULL;
+ }
+
+ LWIP_DEBUGF(UDP_LPC_EMAC | LWIP_DBG_TRACE,
+ ("k64f_low_level_output: pbuf packet(%p) sent, chain#=%d,"
+ " size = %d (index=%d)\n", q->payload, dn, q->len, idx));
+ }
+
+ q = q->next;
+
+ idx = (idx + 1) % ENET_TX_RING_LEN;
+ }
+
+ k64f_enet->tx_produce_index = idx;
+ enet_hal_active_txbd(BOARD_DEBUG_ENET_INSTANCE);
+ LINK_STATS_INC(link.xmit);
+
+ /* Restore access */
+ sys_mutex_unlock(&k64f_enet->TXLockMutex);
+
+ return ERR_OK;
+}
+
+/*******************************************************************************
+ * PHY task: monitor link
+*******************************************************************************/
+
+#define PHY_TASK_PERIOD_MS 200
+#define STATE_UNKNOWN (-1)
+
+typedef struct {
+ int connected;
+ enet_phy_speed_t speed;
+ enet_phy_duplex_t duplex;
+} PHY_STATE;
+
+static void k64f_phy_task(void *data) {
+ struct netif *netif = (struct netif*)data;
+ bool connection_status;
+ enet_dev_if_t * enetIfPtr = (enet_dev_if_t*)&enetDevIf[BOARD_DEBUG_ENET_INSTANCE];
+ PHY_STATE crt_state = {STATE_UNKNOWN, (enet_phy_speed_t)STATE_UNKNOWN, (enet_phy_duplex_t)STATE_UNKNOWN};
+ PHY_STATE prev_state;
+
+ prev_state = crt_state;
+ while (true) {
+ // Get current status
+ phy_get_link_status(enetIfPtr, &connection_status);
+ crt_state.connected = connection_status ? 1 : 0;
+ phy_get_link_speed(enetIfPtr, &crt_state.speed);
+ phy_get_link_duplex(enetIfPtr, &crt_state.duplex);
+
+ // Compare with previous state
+ if (crt_state.connected != prev_state.connected) {
+ if (crt_state.connected)
+ tcpip_callback_with_block((tcpip_callback_fn)netif_set_link_up, (void*) netif, 1);
+ else
+ tcpip_callback_with_block((tcpip_callback_fn)netif_set_link_down, (void*) netif, 1);
+ }
+
+ if (crt_state.speed != prev_state.speed)
+ BW_ENET_RCR_RMII_10T(enetIfPtr->deviceNumber, crt_state.speed == kEnetSpeed10M ? kEnetCfgSpeed10M : kEnetCfgSpeed100M);
+
+ // TODO: duplex change requires disable/enable of Ethernet interface, to be implemented
+
+ prev_state = crt_state;
+ osDelay(PHY_TASK_PERIOD_MS);
+ }
+}
+
+/**
+ * Should be called at the beginning of the program to set up the
+ * network interface.
+ *
+ * This function should be passed as a parameter to netif_add().
+ *
+ * @param[in] netif the lwip network interface structure for this netif
+ * @return ERR_OK if the loopif is initialized
+ * ERR_MEM if private data couldn't be allocated
+ * any other err_t on error
+ */
+err_t eth_arch_enetif_init(struct netif *netif)
+{
+ err_t err;
+
+ LWIP_ASSERT("netif != NULL", (netif != NULL));
+
+ k64f_enetdata.netif = netif;
+
+ /* set MAC hardware address */
+#if (MBED_MAC_ADDRESS_SUM != MBED_MAC_ADDR_INTERFACE)
+ netif->hwaddr[0] = MBED_MAC_ADDR_0;
+ netif->hwaddr[1] = MBED_MAC_ADDR_1;
+ netif->hwaddr[2] = MBED_MAC_ADDR_2;
+ netif->hwaddr[3] = MBED_MAC_ADDR_3;
+ netif->hwaddr[4] = MBED_MAC_ADDR_4;
+ netif->hwaddr[5] = MBED_MAC_ADDR_5;
+#else
+ mbed_mac_address((char *)netif->hwaddr);
+#endif
+ netif->hwaddr_len = ETHARP_HWADDR_LEN;
+
+ /* maximum transfer unit */
+ netif->mtu = 1500;
+
+ /* device capabilities */
+ // TODOETH: check if the flags are correct below
+ netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET | NETIF_FLAG_IGMP;
+
+ /* Initialize the hardware */
+ netif->state = &k64f_enetdata;
+ err = low_level_init(netif);
+ if (err != ERR_OK)
+ return err;
+
+#if LWIP_NETIF_HOSTNAME
+ /* Initialize interface hostname */
+ netif->hostname = "lwipk64f";
+#endif /* LWIP_NETIF_HOSTNAME */
+
+ netif->name[0] = 'e';
+ netif->name[1] = 'n';
+
+ netif->output = k64f_etharp_output;
+ netif->linkoutput = k64f_low_level_output;
+
+ /* CMSIS-RTOS, start tasks */
+#ifdef CMSIS_OS_RTX
+ memset(k64f_enetdata.xTXDCountSem.data, 0, sizeof(k64f_enetdata.xTXDCountSem.data));
+ k64f_enetdata.xTXDCountSem.def.semaphore = k64f_enetdata.xTXDCountSem.data;
+#endif
+ k64f_enetdata.xTXDCountSem.id = osSemaphoreCreate(&k64f_enetdata.xTXDCountSem.def, ENET_TX_RING_LEN);
+
+ LWIP_ASSERT("xTXDCountSem creation error", (k64f_enetdata.xTXDCountSem.id != NULL));
+
+ err = sys_mutex_new(&k64f_enetdata.TXLockMutex);
+ LWIP_ASSERT("TXLockMutex creation error", (err == ERR_OK));
+
+ /* Packet receive task */
+ err = sys_sem_new(&k64f_enetdata.RxReadySem, 0);
+ LWIP_ASSERT("RxReadySem creation error", (err == ERR_OK));
+ sys_thread_new("receive_thread", packet_rx, netif->state, DEFAULT_THREAD_STACKSIZE, RX_PRIORITY);
+
+ /* Transmit cleanup task */
+ err = sys_sem_new(&k64f_enetdata.TxCleanSem, 0);
+ LWIP_ASSERT("TxCleanSem creation error", (err == ERR_OK));
+ sys_thread_new("txclean_thread", packet_tx, netif->state, DEFAULT_THREAD_STACKSIZE, TX_PRIORITY);
+
+ /* PHY monitoring task */
+ sys_thread_new("phy_thread", k64f_phy_task, netif, DEFAULT_THREAD_STACKSIZE, PHY_PRIORITY);
+
+ /* Allow the PHY task to detect the initial link state and set up the proper flags */
+ osDelay(10);
+
+ return ERR_OK;
+}
+
+void eth_arch_enable_interrupts(void) {
+ enet_hal_config_interrupt(BOARD_DEBUG_ENET_INSTANCE, (kEnetTxFrameInterrupt | kEnetRxFrameInterrupt), true);
+ interrupt_enable(enet_irq_ids[BOARD_DEBUG_ENET_INSTANCE][enetIntMap[kEnetRxfInt]]);
+ interrupt_enable(enet_irq_ids[BOARD_DEBUG_ENET_INSTANCE][enetIntMap[kEnetTxfInt]]);
+}
+
+void eth_arch_disable_interrupts(void) {
+ interrupt_disable(enet_irq_ids[BOARD_DEBUG_ENET_INSTANCE][enetIntMap[kEnetRxfInt]]);
+ interrupt_disable(enet_irq_ids[BOARD_DEBUG_ENET_INSTANCE][enetIntMap[kEnetTxfInt]]);
+}
+
+/**
+ * @}
+ */
+
+/* --------------------------------- End Of File ------------------------------ */
+