7847c5e98d
* Microchip SAM MCU BSP update and add ethernet driver 1. Update Microchip SAM MCU BSP, add I2C, GMAC, ADC driver support. 2. Add ethernet driver support of SAM MCU for RT-Thread. * Add GMAC and I2C driver support 1. Update MCU BSP to support I2C/ADC/GMAC peripherals. 2. Add I2C and ethernet driver and LWIP support. 3. Update serial driver. * Add I2C driver and move some files to the common folder 1. Add I2C driver. 2. Move the same drivers and demo code to same folder to reduce duplicated code.
429 lines
10 KiB
C
429 lines
10 KiB
C
/*
|
|
* Copyright (c)
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Change Logs:
|
|
* Date Author Email Notes
|
|
* 2022-04-06 Kevin.Liu kevin.liu.mchp@gmail.com First Release
|
|
*/
|
|
|
|
#include <rtthread.h>
|
|
#include <rtdevice.h>
|
|
#include <rtdbg.h>
|
|
|
|
#include <netif/ethernetif.h>
|
|
#include <lwipopts.h>
|
|
|
|
#include <atmel_start.h>
|
|
#include <peripheral_clk_config.h>
|
|
#include <ieee8023_mii_standard_config.h>
|
|
|
|
#include "board.h"
|
|
#include "sam_gmac.h"
|
|
|
|
#ifdef RT_USING_LWIP
|
|
|
|
struct rt_sam_eth
|
|
{
|
|
/* inherit from ethernet device */
|
|
struct eth_device parent;
|
|
|
|
struct mac_async_descriptor *macif;
|
|
struct ethernet_phy_descriptor *phyif;
|
|
|
|
#ifdef RT_USING_TIMER_SOFT
|
|
rt_timer_t phy_monitor_timer;
|
|
#else
|
|
rt_thread_t phy_monitor_tid;
|
|
#endif
|
|
|
|
/* ethernet MAC address */
|
|
rt_uint8_t mac_addr[NETIF_MAX_HWADDR_LEN];
|
|
|
|
/* GMAC Link Speed */
|
|
gmac_speed_type link_speed;
|
|
/* GMAC Link Mode */
|
|
gmac_duplex_type link_mode;
|
|
};
|
|
|
|
static struct rt_sam_eth sam_eth_device;
|
|
|
|
/**
|
|
* @brief Called by GMAC RX interrupt, will notify RX task
|
|
*
|
|
* @note Will call eth_device_ready to notify RX task.
|
|
*
|
|
* @param
|
|
*
|
|
* @return
|
|
*/
|
|
static void rt_sam_gmac_rxcb(void)
|
|
{
|
|
rt_err_t result;
|
|
|
|
/* enter interrupt */
|
|
rt_interrupt_enter();
|
|
|
|
result = eth_device_ready(&sam_eth_device.parent);
|
|
if (result != RT_EOK)
|
|
LOG_E("rt_sam_gmac_rxcb error");
|
|
|
|
/* leave interrupt */
|
|
rt_interrupt_leave();
|
|
}
|
|
|
|
/**
|
|
* @brief Initialize the MAC hardware
|
|
*
|
|
* @note Will set MAC filter by using input MAC address.
|
|
*
|
|
* @param gmac_dev GMAC device description.
|
|
*
|
|
* @return
|
|
*/
|
|
static inline void rt_sam_gmac_init(struct rt_sam_eth *gmac_dev)
|
|
{
|
|
struct mac_async_filter filter;
|
|
|
|
/* set MAC hardware address */
|
|
rt_memcpy(filter.mac, sam_eth_device.mac_addr, NETIF_MAX_HWADDR_LEN);
|
|
filter.tid_enable = false;
|
|
mac_async_set_filter(gmac_dev->macif, 0, &filter);
|
|
mac_async_register_callback(gmac_dev->macif, MAC_ASYNC_RECEIVE_CB, (FUNC_PTR)rt_sam_gmac_rxcb);
|
|
}
|
|
|
|
static rt_err_t rt_sam_eth_init(rt_device_t dev)
|
|
{
|
|
LOG_D("gmac init");
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_err_t rt_sam_eth_open(rt_device_t dev, rt_uint16_t oflag)
|
|
{
|
|
LOG_D("gmac open");
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_err_t rt_sam_eth_close(rt_device_t dev)
|
|
{
|
|
LOG_D("gmac close");
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_size_t rt_sam_eth_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
|
|
{
|
|
LOG_D("gmac read");
|
|
rt_set_errno(-RT_ENOSYS);
|
|
return 0;
|
|
}
|
|
|
|
static rt_size_t rt_sam_eth_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
|
|
{
|
|
LOG_D("gmac write");
|
|
rt_set_errno(-RT_ENOSYS);
|
|
return 0;
|
|
}
|
|
|
|
static rt_err_t rt_sam_eth_control(rt_device_t dev, int cmd, void *args)
|
|
{
|
|
rt_err_t ret = RT_EOK;
|
|
|
|
switch (cmd)
|
|
{
|
|
case NIOCTL_GADDR:
|
|
/* get mac address */
|
|
if (args)
|
|
rt_memcpy(args, sam_eth_device.mac_addr, 6);
|
|
break;
|
|
|
|
default :
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Transmission packet though the MAC hardware
|
|
*
|
|
* @note Send package to MAC.
|
|
*
|
|
* @param dev the RT net device input.
|
|
*
|
|
* @param p stored message will be sent to MAC.
|
|
*
|
|
* @return RT_EOK.
|
|
*/
|
|
rt_err_t rt_sam_eth_tx(rt_device_t dev, struct pbuf *p)
|
|
{
|
|
struct rt_sam_eth *gmac_dev = (struct rt_sam_eth *)dev->user_data;
|
|
struct pbuf * q;
|
|
void * tbuf;
|
|
uint8_t * pos;
|
|
|
|
#if ETH_PAD_SIZE
|
|
pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
|
|
#endif
|
|
|
|
if (p->tot_len == p->len)
|
|
{
|
|
mac_async_write(gmac_dev->macif, p->payload, p->tot_len);
|
|
}
|
|
else
|
|
{
|
|
tbuf = mem_malloc(LWIP_MEM_ALIGN_SIZE(p->tot_len));
|
|
pos = tbuf;
|
|
if (tbuf == NULL)
|
|
{
|
|
return ERR_MEM;
|
|
}
|
|
for (q = p; q != NULL; q = q->next)
|
|
{
|
|
rt_memcpy(pos, q->payload, q->len);
|
|
pos += q->len;
|
|
}
|
|
mac_async_write(gmac_dev->macif, tbuf, p->tot_len);
|
|
mem_free(tbuf);
|
|
}
|
|
|
|
#if ETH_PAD_SIZE
|
|
pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
|
|
#endif
|
|
|
|
LINK_STATS_INC(link.xmit);
|
|
|
|
return ERR_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief Receive packet from the MAC hardware
|
|
*
|
|
* @note Returned pbuf filled with the received packet (including MAC header)
|
|
*
|
|
* @param dev the RT net device input.
|
|
*
|
|
* @return NULL on memory error
|
|
*/
|
|
struct pbuf *rt_sam_eth_rx(rt_device_t dev)
|
|
{
|
|
struct rt_sam_eth *gmac_dev = (struct rt_sam_eth *)dev->user_data;
|
|
struct pbuf * p;
|
|
u16_t len;
|
|
|
|
len = mac_async_read_len(gmac_dev->macif); /* Obtain the size of the packet */
|
|
if (len == 0)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
#if ETH_PAD_SIZE
|
|
len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
|
|
#endif
|
|
|
|
/* Allocate a pbuf as one large chunk, This include protocol header */
|
|
p = pbuf_alloc(PBUF_RAW, len, PBUF_RAM);
|
|
|
|
if (p != NULL)
|
|
{
|
|
#if ETH_PAD_SIZE
|
|
pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
|
|
#endif
|
|
|
|
/* Read the entire packet into the pbuf. */
|
|
mac_async_read(gmac_dev->macif, p->payload, p->len);
|
|
|
|
#if ETH_PAD_SIZE
|
|
pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
|
|
#endif
|
|
|
|
LINK_STATS_INC(link.recv);
|
|
}
|
|
else
|
|
{
|
|
mac_async_read(gmac_dev->macif, NULL, 0);
|
|
LINK_STATS_INC(link.memerr);
|
|
LINK_STATS_INC(link.drop);
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* @brief PHY link status monitor task - timer task or thread
|
|
*
|
|
* @note Will check link status, link mode and link speed
|
|
*
|
|
* @param parameter input parameter passing to the function.
|
|
*
|
|
* @return
|
|
*/
|
|
static void rt_sam_eth_monitor(void *parameter)
|
|
{
|
|
struct rt_sam_eth *sam_eth = (struct rt_sam_eth *)parameter;
|
|
bool link_up;
|
|
int32_t ret;
|
|
uint16_t val;
|
|
static rt_uint8_t link_count = 0;
|
|
|
|
#ifndef RT_USING_TIMER_SOFT
|
|
while (1)
|
|
{
|
|
#endif
|
|
ret = ethernet_phy_get_link_status(sam_eth->phyif, &link_up);
|
|
if (ERR_NONE == ret)
|
|
{
|
|
if (link_up)
|
|
{
|
|
/* send link up. */
|
|
eth_device_linkchange(&sam_eth->parent, RT_TRUE);
|
|
}
|
|
else
|
|
{
|
|
/* send link down. */
|
|
eth_device_linkchange(&sam_eth->parent, RT_FALSE);;
|
|
}
|
|
}
|
|
|
|
ret = ethernet_phy_read_reg(sam_eth->phyif, MDIO_REG1_BMSR, &val);
|
|
if (ERR_NONE == ret)
|
|
{
|
|
if (val & (MDIO_REG1_BIT_100BASE_TX_FD | MDIO_REG1_BIT_100BASE_TX_HD))
|
|
{
|
|
LOG_D("100Mbps");
|
|
sam_eth_device.link_speed = GMAC_SPEED_100MBPS;
|
|
}
|
|
else
|
|
{
|
|
LOG_D("10Mbps");
|
|
sam_eth_device.link_speed = GMAC_SPEED_10MBPS;
|
|
}
|
|
|
|
if (val & (MDIO_REG1_BIT_100BASE_TX_FD | MDIO_REG1_BIT_10BASE_T_FD))
|
|
{
|
|
LOG_D("100Mbps");
|
|
sam_eth_device.link_mode = GMAC_FULL_DUPLEX;
|
|
}
|
|
else
|
|
{
|
|
LOG_D("10Mbps");
|
|
sam_eth_device.link_mode = GMAC_HALF_DUPLEX;
|
|
}
|
|
}
|
|
|
|
if (link_count >= 10)
|
|
{
|
|
link_count = 0;
|
|
|
|
/* Restart an auto-negotiation */
|
|
ethernet_phy_restart_autoneg(sam_eth->phyif);
|
|
}
|
|
|
|
#ifndef RT_USING_TIMER_SOFT
|
|
rt_thread_mdelay(1000);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* @brief Register the GMAC Ethernet device.
|
|
*
|
|
* @note
|
|
*
|
|
* @param
|
|
*
|
|
* @return RT_OK or RT_ERROR.
|
|
*/
|
|
|
|
static int rt_hw_sam_eth_init(void)
|
|
{
|
|
rt_err_t state = RT_EOK;
|
|
#if CONF_AT24MAC_ADDRESS != 0
|
|
rt_uint8_t addr = 0x9A;
|
|
#endif
|
|
|
|
sam_eth_device.macif = &MACIF;
|
|
sam_eth_device.phyif = &MACIF_PHY_desc;
|
|
|
|
sam_eth_device.link_speed = GMAC_SPEED_100MBPS;
|
|
sam_eth_device.link_mode = GMAC_FULL_DUPLEX;
|
|
|
|
#if CONF_AT24MAC_ADDRESS != 0
|
|
i2c_m_sync_enable(&I2C_0);
|
|
i2c_m_sync_set_slaveaddr(&I2C_0, CONF_AT24MAC_ADDRESS, I2C_M_SEVEN);
|
|
io_write(&(I2C_0.io), &addr, 1);
|
|
io_read(&(I2C_0.io), sam_eth_device.mac_addr, 6);
|
|
#else
|
|
/* set mac to 0x11 if no EEPROM mounted */
|
|
memset(sam_eth_device.mac_addr, 0x11, 6);
|
|
#endif
|
|
|
|
sam_eth_device.parent.parent.init = rt_sam_eth_init;
|
|
sam_eth_device.parent.parent.open = rt_sam_eth_open;
|
|
sam_eth_device.parent.parent.close = rt_sam_eth_close;
|
|
sam_eth_device.parent.parent.read = rt_sam_eth_read;
|
|
sam_eth_device.parent.parent.write = rt_sam_eth_write;
|
|
sam_eth_device.parent.parent.control = rt_sam_eth_control;
|
|
sam_eth_device.parent.parent.user_data = (void *)&sam_eth_device;
|
|
|
|
sam_eth_device.parent.eth_rx = rt_sam_eth_rx;
|
|
sam_eth_device.parent.eth_tx = rt_sam_eth_tx;
|
|
|
|
rt_sam_gmac_init(&sam_eth_device);
|
|
|
|
/* register eth device */
|
|
state = eth_device_init(&(sam_eth_device.parent), "e0");
|
|
|
|
if (RT_EOK == state)
|
|
{
|
|
LOG_D("gmac device init success");
|
|
}
|
|
else
|
|
{
|
|
LOG_E("gmac device init faild: %d", state);
|
|
state = -RT_ERROR;
|
|
goto outs;
|
|
}
|
|
|
|
/* start SAM PHY monitor */
|
|
#ifdef RT_USING_TIMER_SOFT
|
|
sam_eth_device.phy_monitor_timer = rt_timer_create("phylnk",
|
|
rt_sam_eth_monitor,
|
|
(void *)&sam_eth_device,
|
|
10*RT_TICK_PER_SECOND,
|
|
RT_TIMER_FLAG_PERIODIC);
|
|
|
|
if (RT_NULL != sam_eth_device.phy_monitor_timer)
|
|
{
|
|
rt_timer_start(sam_eth_device.phy_monitor_timer);
|
|
}
|
|
else
|
|
{
|
|
state = -RT_ERROR;
|
|
LOG_E("gmac rt_timer_create faild: %d", state);
|
|
}
|
|
#else
|
|
sam_eth_device.phy_monitor_tid = rt_thread_create("phy",
|
|
rt_sam_eth_monitor,
|
|
(void *)&sam_eth_device,
|
|
1024,
|
|
RT_THREAD_PRIORITY_MAX - 2,
|
|
2);
|
|
if (sam_eth_device.phy_monitor_tid != RT_NULL)
|
|
{
|
|
rt_thread_startup(sam_eth_device.phy_monitor_tid);
|
|
}
|
|
else
|
|
{
|
|
state = -RT_ERROR;
|
|
LOG_E("gmac rt_thread_create faild: %d", state);
|
|
}
|
|
#endif
|
|
|
|
outs:
|
|
return state;
|
|
}
|
|
INIT_DEVICE_EXPORT(rt_hw_sam_eth_init);
|
|
|
|
#endif /* BSP_USING_ETH_ARTPI */
|