libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/CME_M7/drivers/emac.c

456 lines
11 KiB
C
Raw Blame History

/*
* File : emac.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006-2021, RT-Thread Develop Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://openlab.rt-thread.com/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2014-08-29 aozima first implementation
*/
#include <rtthread.h>
#include <netif/ethernetif.h>
#include "lwipopts.h"
#include "board.h"
#include "app_phy.h"
/* debug option */
#define ETH_DEBUG
//#define ETH_RX_DUMP
//#define ETH_TX_DUMP
#ifdef ETH_DEBUG
#define CME_ETH_PRINTF rt_kprintf
#else
#define CME_ETH_PRINTF(...)
#endif
#define MAX_ADDR_LEN 6
struct rt_cme_eth
{
/* inherit from ethernet device */
struct eth_device parent;
/* interface address info. */
rt_uint8_t dev_addr[MAX_ADDR_LEN]; /* hw address */
uint32_t ETH_Speed;
uint32_t ETH_Mode;
struct rt_semaphore tx_buf_free;
struct rt_mutex lock;
};
static struct rt_cme_eth cme_eth_device;
#if defined(ETH_RX_DUMP) || defined(ETH_TX_DUMP)
static void packet_dump(const char * msg, const struct pbuf* p)
{
const struct pbuf* q;
rt_uint32_t i,j;
rt_uint8_t *ptr;
rt_kprintf("%s %d byte\n", msg, p->tot_len);
i=0;
for(q=p; q != RT_NULL; q= q->next)
{
ptr = q->payload;
for(j=0; j<q->len; j++)
{
if( (i%8) == 0 )
{
rt_kprintf(" ");
}
if( (i%16) == 0 )
{
rt_kprintf("\r\n");
}
rt_kprintf("%02x ",*ptr);
i++;
ptr++;
}
}
rt_kprintf("\n\n");
}
#else
#define packet_dump(...)
#endif /* dump */
/////////////////////////////////////////////////////////////////
uint32_t rxTotalMemory = 0x2000;
uint32_t rxDescNum = 3;
uint32_t rxBufSize = 0x400;
uint32_t rxBaseAddr = 0x2000C000;// C000-48K
uint32_t txBaseAddr = 0x2000E000;// E000-56K
uint32_t txTotalMemory = 0x2000;
BOOL isRxNoBuf = FALSE;
#define ETH_MAX_PACKET_SIZE 1520 /* ETH_HEADER + ETH_EXTRA + MAX_ETH_PAYLOAD + ETH_CRC */
#define ETH_RXBUFNB 4
#define ETH_TXBUFNB 2
struct eth_rx_buffer
{
ETH_RX_DESC desc;
uint32_t buffer[ETH_MAX_PACKET_SIZE/4];
};
struct eth_tx_buffer
{
ETH_TX_DESC desc;
uint32_t buffer[ETH_MAX_PACKET_SIZE/4];
};
static struct eth_rx_buffer rx_buffer[ETH_RXBUFNB];
static struct eth_tx_buffer tx_buffer[ETH_TXBUFNB];
static void RxDescChainInit(void)
{
uint32_t i;
// initialize rx descriptor
ETH_RX_DESC *desc = &rx_buffer[0].desc;
for (i = 0; i < ETH_RXBUFNB; i++)
{
desc->RX_1.RX1_b.SIZE = ETH_MAX_PACKET_SIZE;
desc->bufAddr = (uint32_t)rx_buffer[i].buffer;
if((i+1) == ETH_RXBUFNB)
desc->nextDescAddr = (uint32_t)&rx_buffer[0].desc;
else
desc->nextDescAddr = (uint32_t)&rx_buffer[i+1].desc;
desc = (ETH_RX_DESC *)desc->nextDescAddr;
}
ETH_SetRxDescRing(&rx_buffer[0].desc);
}
static void TxDescChainInit(void)
{
uint32_t i;
// initialize tx descriptor
ETH_TX_DESC *desc = &tx_buffer[0].desc;
for (i = 0; i < ETH_TXBUFNB; i++)
{
desc->TX_1.TX1_b.SIZE = ETH_MAX_PACKET_SIZE;
desc->bufAddr = (uint32_t)tx_buffer[i].buffer;
if((i+1) == ETH_TXBUFNB)
desc->nextDescAddr = (uint32_t)&tx_buffer[0].desc;
else
desc->nextDescAddr = (uint32_t)&tx_buffer[i+1].desc;
desc = (ETH_TX_DESC *)desc->nextDescAddr;
}
ETH_SetTxDescRing(&tx_buffer[0].desc);
}
/////////////////////////////////////////////////////////////////
/* initialize the interface */
static rt_err_t rt_cme_eth_init(rt_device_t dev)
{
struct rt_cme_eth * cme_eth = (struct rt_cme_eth *)dev;
ETH_InitTypeDef init;
ETH_FrameFilter flt;
init.ETH_Speed = phy_GetSpeed();
init.ETH_Duplex = phy_GetDuplex();
init.ETH_LinkUp = phy_IsLink();
init.ETH_RxEn = TRUE;
init.ETH_TxEn = TRUE;
init.ETH_ChecksumOffload = FALSE;
init.ETH_JumboFrame = FALSE;
memcpy(init.ETH_MacAddr, cme_eth->dev_addr, sizeof(init.ETH_MacAddr));
// Disable broadcast;
// TODO: why?
memset(&flt, 0, sizeof(ETH_FrameFilter));
flt.ETH_BroadcastFilterEnable = FALSE;
flt.ETH_OwnFilterEnable = FALSE;
flt.ETH_SelfDrop = FALSE;
flt.ETH_SourceFilterEnable = FALSE;
flt.ETH_SourceDrop = FALSE;
init.ETH_Filter = &flt;
if (!phy_Init())
{
rt_kprintf("phy_Init failed!\n");
while (1);
}
if (!ETH_Init(&init))
{
rt_kprintf("ETH_Init failed!\n");
while (1);
}
RxDescChainInit();
TxDescChainInit();
ETH_ITConfig(ETH_INT_BUS_FATAL_ERROR, TRUE);
ETH_ITConfig(ETH_INT_RX_COMPLETE_FRAME, TRUE);
ETH_ITConfig(ETH_INT_RX_BUF_UNAVAI, TRUE);
ETH_ITConfig(ETH_INT_RX_STOP, TRUE);
ETH_StartRx();
ETH_ITConfig(ETH_INT_TX_COMPLETE_FRAME, TRUE);
ETH_StartTx();
return RT_EOK;
}
static rt_err_t rt_cme_eth_open(rt_device_t dev, rt_uint16_t oflag)
{
return RT_EOK;
}
static rt_err_t rt_cme_eth_close(rt_device_t dev)
{
return RT_EOK;
}
static rt_size_t rt_cme_eth_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
{
rt_set_errno(-RT_ENOSYS);
return 0;
}
static rt_size_t rt_cme_eth_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
{
rt_set_errno(-RT_ENOSYS);
return 0;
}
static rt_err_t rt_cme_eth_control(rt_device_t dev, int cmd, void *args)
{
switch(cmd)
{
case NIOCTL_GADDR:
/* get mac address */
if(args) rt_memcpy(args, cme_eth_device.dev_addr, 6);
else return -RT_ERROR;
break;
default :
break;
}
return RT_EOK;
}
/* ethernet device interface */
/* transmit packet. */
rt_err_t rt_cme_eth_tx( rt_device_t dev, struct pbuf* p)
{
rt_err_t result = RT_EOK;
ETH_TX_DESC *desc;
struct rt_cme_eth * cme_eth = (struct rt_cme_eth *)dev;
rt_mutex_take(&cme_eth->lock, RT_WAITING_FOREVER);
#ifdef ETH_TX_DUMP
packet_dump("TX dump", p);
#endif /* ETH_TX_DUMP */
/* get free tx buffer */
{
rt_err_t result;
result = rt_sem_take(&cme_eth->tx_buf_free, RT_TICK_PER_SECOND/10);
if (result != RT_EOK)
{
result = -RT_ERROR;
goto _exit;
}
}
desc = ETH_AcquireFreeTxDesc();
if(desc == RT_NULL)
{
CME_ETH_PRINTF("TxDesc not ready!\n");
RT_ASSERT(0);
result = -RT_ERROR;
goto _exit;
}
desc->TX_0.TX0_b.FS = TRUE;
desc->TX_0.TX0_b.LS = TRUE;
desc->TX_1.TX1_b.SIZE = p->tot_len;
pbuf_copy_partial(p, ( void *)(desc->bufAddr), p->tot_len, 0);
ETH_ReleaseTxDesc(desc);
ETH_ResumeTx();
_exit:
rt_mutex_release(&cme_eth->lock);
return result;
}
/* reception packet. */
struct pbuf *rt_cme_eth_rx(rt_device_t dev)
{
struct pbuf* p = RT_NULL;
ETH_RX_DESC *desc;
uint32_t framelength;
struct rt_cme_eth * cme_eth = (struct rt_cme_eth *)dev;
rt_err_t result;
result = rt_mutex_take(&cme_eth->lock, RT_WAITING_FOREVER);
if (result == -RT_ETIMEOUT)
{
rt_kprintf("Take mutex time out.\n");
goto _exit;
}
else if (result == -RT_ERROR)
{
rt_kprintf("Take mutex error.\n");
goto _exit;
}
desc = ETH_AcquireFreeRxDesc();
if(desc == RT_NULL)
{
ETH_ITConfig(ETH_INT_RX_COMPLETE_FRAME, TRUE);
ETH_ITConfig(ETH_INT_RX_BUF_UNAVAI, TRUE);
ETH_ResumeRx();
goto _exit;
}
framelength = desc->RX_0.RX0_b.FL;
/* allocate buffer */
p = pbuf_alloc(PBUF_LINK, framelength, PBUF_RAM);
if (p != RT_NULL)
{
pbuf_take(p, (const void *)(desc->bufAddr), framelength);
#ifdef ETH_RX_DUMP
packet_dump("RX dump", p);
#endif /* ETH_RX_DUMP */
}
ETH_ReleaseRxDesc(desc);
_exit:
rt_mutex_release(&cme_eth->lock);
return p;
}
static void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
/* Enable the USARTy Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = ETH_INT_IRQn;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = TRUE;
NVIC_Init(&NVIC_InitStructure);
}
int cme_m7_eth_init(void)
{
// /* PHY RESET: PA4 */
// {
// GPIO_ResetBits(GPIOA, GPIO_Pin_4);
// rt_thread_delay(2);
// GPIO_SetBits(GPIOA, GPIO_Pin_4);
// rt_thread_delay(2);
// }
// GPIO_Configuration();
NVIC_Configuration();
// cme_eth_device.ETH_Speed = ETH_Speed_100M;
// cme_eth_device.ETH_Mode = ETH_Mode_FullDuplex;
/* OUI 00-80-E1 STMICROELECTRONICS. */
cme_eth_device.dev_addr[0] = 0x00;
cme_eth_device.dev_addr[1] = 0x80;
cme_eth_device.dev_addr[2] = 0xE1;
/* generate MAC addr from 96bit unique ID (only for test). */
// cme_eth_device.dev_addr[3] = *(rt_uint8_t*)(0x1FFF7A10+4);
// cme_eth_device.dev_addr[4] = *(rt_uint8_t*)(0x1FFF7A10+2);
// cme_eth_device.dev_addr[5] = *(rt_uint8_t*)(0x1FFF7A10+0);
cme_eth_device.dev_addr[3] = 12;
cme_eth_device.dev_addr[4] = 34;
cme_eth_device.dev_addr[5] = 56;
cme_eth_device.parent.parent.init = rt_cme_eth_init;
cme_eth_device.parent.parent.open = rt_cme_eth_open;
cme_eth_device.parent.parent.close = rt_cme_eth_close;
cme_eth_device.parent.parent.read = rt_cme_eth_read;
cme_eth_device.parent.parent.write = rt_cme_eth_write;
cme_eth_device.parent.parent.control = rt_cme_eth_control;
cme_eth_device.parent.parent.user_data = RT_NULL;
cme_eth_device.parent.eth_rx = rt_cme_eth_rx;
cme_eth_device.parent.eth_tx = rt_cme_eth_tx;
/* init EMAC lock */
rt_mutex_init(&cme_eth_device.lock, "emac0", RT_IPC_FLAG_PRIO);
/* init tx buffer free semaphore */
rt_sem_init(&cme_eth_device.tx_buf_free,
"tx_buf",
ETH_TXBUFNB,
RT_IPC_FLAG_FIFO);
/* register eth device */
eth_device_init(&(cme_eth_device.parent), "e0");
return RT_EOK;
}
void ETH_IRQHandler(void)
{
/* enter interrupt */
rt_interrupt_enter();
if (ETH_GetITStatus(ETH_INT_TX_COMPLETE_FRAME))
{
rt_sem_release(&cme_eth_device.tx_buf_free);
ETH_ClearITPendingBit(ETH_INT_TX_COMPLETE_FRAME);
}
if (ETH_GetITStatus(ETH_INT_RX_STOP))
{
CME_ETH_PRINTF("ETH_INT_RX_STOP\n");
ETH_ClearITPendingBit(ETH_INT_RX_STOP);
}
if ((ETH_GetITStatus(ETH_INT_RX_BUF_UNAVAI)) ||
(ETH_GetITStatus(ETH_INT_RX_COMPLETE_FRAME)))
{
/* a frame has been received */
eth_device_ready(&(cme_eth_device.parent));
ETH_ITConfig(ETH_INT_RX_COMPLETE_FRAME, FALSE);
ETH_ITConfig(ETH_INT_RX_BUF_UNAVAI, FALSE);
ETH_ClearITPendingBit(ETH_INT_RX_BUF_UNAVAI);
ETH_ClearITPendingBit(ETH_INT_RX_COMPLETE_FRAME);
}
/* leave interrupt */
rt_interrupt_leave();
}
View Git Blame Copy Permalink