developer
/
xiuos
forked from xuos/xiuos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'prepare_for_master' of https://gitlink.org.cn/xuos/xiuos into lorawan_develop

This commit is contained in:
Liu_Weichao 2023-08-04 10:06:26 +08:00
parent 3efe663ee0 62eda1e3fa
commit 27734606f5
38 changed files with 2137 additions and 723 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
APP_Framework/Applications/Makefile
View File

@ -36,5 +36,9 @@ ifeq ($(CONFIG_ADD_XIZI_FEATURES),y)
SRC_DIR += control_app SRC_DIR += control_app
endif endif
ifeq ($(CONFIG_APP_USING_WEBNET),y)
SRC_DIR += webnet
endif
include $(KERNEL_ROOT)/compiler.mk include $(KERNEL_ROOT)/compiler.mk
endif endif

1
APP_Framework/Applications/main.c
View File

@ -15,7 +15,6 @@
// #include <user_api.h> // #include <user_api.h>
#include <transform.h> #include <transform.h>
extern int FrameworkInit(); extern int FrameworkInit();
extern void ApplicationOtaTaskInit(void); extern void ApplicationOtaTaskInit(void);
int main(void) int main(void)

3
APP_Framework/Applications/webnet/Makefile Normal file
View File

@ -0,0 +1,3 @@
SRC_DIR += WebNet_XiUOS
include $(KERNEL_ROOT)/compiler.mk

2
APP_Framework/Applications/webnet/WebNet_XiUOS

@ -1 +1 @@
Subproject commit 956eafa24bb65f5bb84d293ab35bf27084473edf Subproject commit 60a8a500b93b47876c6eaff600e4cf2b8bf7b283

2
APP_Framework/Framework/transform_layer/xizi/transform.c
View File

@ -164,7 +164,7 @@ int PrivTimerModify(timer_t timerid, int flags, const struct itimerspec *restric
/*********************fs**************************/ /*********************fs**************************/
#ifdef FS_VFS #ifdef FS_VFS
/************************Driver Posix Transform***********************/ /************************Driver Posix Transform***********************/
int PrivOpen(const char *path, int flags) int PrivOpen(const char *path, int flags, ...)
{ {
return open(path, flags); return open(path, flags);
} }

2
APP_Framework/Framework/transform_layer/xizi/transform.h
View File

@ -427,7 +427,7 @@ uint32_t PrivGetTickTime();
/*********************driver*************************/ /*********************driver*************************/
int PrivOpen(const char *path, int flags); int PrivOpen(const char *path, int flags, ...);
int PrivRead(int fd, void *buf, size_t len); int PrivRead(int fd, void *buf, size_t len);
int PrivWrite(int fd, const void *buf, size_t len); int PrivWrite(int fd, const void *buf, size_t len);
int PrivClose(int fd); int PrivClose(int fd);

3
APP_Framework/Framework/transform_layer/xizi/user_api/posix_support/include/mqueue.h
View File

@ -40,7 +40,8 @@ struct mq_attr {
long mq_curmsgs; /* number of messages currently queued */ long mq_curmsgs; /* number of messages currently queued */
}; };
mqd_t mq_open(const char *name, int oflag, ...); // mqd_t mq_open(const char *name, int oflag, ...);
mqd_t mq_open(const char *name, int oflag, mode_t mode, struct mq_attr *attr);
int mq_close(mqd_t mqdes); int mq_close(mqd_t mqdes);
ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio); ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio);
int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio); int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio);

7
APP_Framework/Framework/transform_layer/xizi/user_api/posix_support/mqueue.c
View File

@ -21,12 +21,13 @@
#include "include/mqueue.h" #include "include/mqueue.h"
mqd_t mq_open(const char *name, int oflag, ...) mqd_t mq_open(const char* name, int oflag, mode_t mode, struct mq_attr* attr)
{ {
mqd_t mq; mqd_t mq;
mq = UserMsgQueueCreate( DEFAULT_MQUEUE_SIZE, DEFAULT_MAX_MSG_SIZE); // Todo: config mq by mode
mq = UserMsgQueueCreate(attr->mq_msgsize, attr->mq_maxmsg);
if (mq < 0) { if (mq < 0) {
return -1; return -1;
} }
@ -44,7 +45,7 @@ ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_pri
ssize_t ret; ssize_t ret;
*msg_prio = 0; *msg_prio = 0;
ret = UserMsgQueueRecv(mqdes, msg_ptr, (unsigned long)&msg_len, 0); ret = UserMsgQueueRecv(mqdes, (void*)msg_ptr, msg_len, WAITING_FOREVER);
return ret; return ret;
} }

6
Ubiquitous/XiZi_IIoT/board/edu-arm32/config.mk
View File

@ -1,9 +1,11 @@
export CROSS_COMPILE ?=/usr/bin/arm-none-eabi- export CROSS_COMPILE ?=/usr/bin/arm-none-eabi-
export CFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -gdwarf-2 -g -fgnu89-inline -Wa,-mimplicit-it=thumb -Werror export CFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -fgnu89-inline -Wa,-mimplicit-it=thumb -Werror
# export CFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -gdwarf-2 -g -fgnu89-inline -Wa,-mimplicit-it=thumb -Werror
export AFLAGS := -c -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -x assembler-with-cpp -Wa,-mimplicit-it=thumb -gdwarf-2 export AFLAGS := -c -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -x assembler-with-cpp -Wa,-mimplicit-it=thumb -gdwarf-2
export LFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Wl,--gc-sections,-Map=XiZi-edu-arm32.map,-cref,-u,Reset_Handler -T $(BSP_ROOT)/link.lds export LFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Wl,--gc-sections,-Map=XiZi-edu-arm32.map,-cref,-u,Reset_Handler -T $(BSP_ROOT)/link.lds
export CXXFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -gdwarf-2 -g -Werror export CXXFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -Werror
# export CXXFLAGS := -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=softfp -ffunction-sections -fdata-sections -Dgcc -O0 -gdwarf-2 -g -Werror
export APPLFLAGS := export APPLFLAGS :=

2
Ubiquitous/XiZi_IIoT/board/edu-arm32/third_party_driver/ethernet/Makefile
View File

@ -1,3 +1,3 @@
SRC_FILES := ethernetif.c eth_driver.c SRC_FILES := ethernetif.c eth_driver.c eth_netdev.c
include $(KERNEL_ROOT)/compiler.mk include $(KERNEL_ROOT)/compiler.mk

12
Ubiquitous/XiZi_IIoT/board/edu-arm32/third_party_driver/ethernet/eth_driver.c
View File

@ -1,21 +1,22 @@
/** /**
* @file ethernetif.c * @file ethernetif.c
* @brief support edu-arm32-board ethernetif function and register to Lwip * @brief support hc32f4a0-board ethernetif function and register to Lwip
* @version 3.0 * @version 3.0
* @author AIIT XUOS Lab * @author AIIT XUOS Lab
* @date 2022-12-05 * @date 2022-12-05
*/ */
#include <connect_ethernet.h> #include <connect_ethernet.h>
#include <hc32_ll_fcg.h>
#include <hc32_ll_gpio.h> #include <hc32_ll_gpio.h>
#include <hc32_ll_utility.h> #include <hc32_ll_utility.h>
#include <hc32_ll_fcg.h>
#include <lwip/timeouts.h> #include <lwip/timeouts.h>
#include <netif/etharp.h> #include <netif/etharp.h>
#include <sys_arch.h> #include <sys_arch.h>
void eth_irq_handler(void) { void eth_irq_handler(void)
{
static x_base eth_irq_lock; static x_base eth_irq_lock;
eth_irq_lock = DISABLE_INTERRUPT(); eth_irq_lock = DISABLE_INTERRUPT();
@ -278,10 +279,9 @@ struct pbuf *low_level_input(struct netif *netif)
} }
extern void LwipSetIPTest(int argc, char* argv[]); extern void LwipSetIPTest(int argc, char* argv[]);
int HwEthInit(void) { int HwEthInit(void)
{
// lwip_config_tcp(0, lwip_ipaddr, lwip_netmask, lwip_gwaddr); // lwip_config_tcp(0, lwip_ipaddr, lwip_netmask, lwip_gwaddr);
LwipSetIPTest(1, NULL); LwipSetIPTest(1, NULL);
return EOK; return EOK;
} }

162
Ubiquitous/XiZi_IIoT/board/edu-arm32/third_party_driver/ethernet/eth_netdev.c Normal file
View File

@ -0,0 +1,162 @@
#include <connect_ethernet.h>
#include <inet.h>
#include <lwip/dhcp.h>
#include <lwip/netif.h>
#include <netdev.h>
#include <xs_kdbg.h>
static const uint32_t NETIF_NAME_LEN = 2;
static int lwip_netdev_set_up(struct netdev* netdev)
{
netif_set_up((struct netif*)netdev->user_data);
return ERR_OK;
}
static int lwip_netdev_set_down(struct netdev* netif)
{
netif_set_down((struct netif*)netif->user_data);
return ERR_OK;
}
#ifndef ip_2_ip4
#define ip_2_ip4(ipaddr) (ipaddr)
#endif
static int lwip_netdev_set_addr_info(struct netdev* netdev, ip_addr_t* ip_addr, ip_addr_t* netmask, ip_addr_t* gw)
{
if (ip_addr && netmask && gw) {
netif_set_addr((struct netif*)netdev->user_data, ip_2_ip4(ip_addr), ip_2_ip4(netmask), ip_2_ip4(gw));
} else {
if (ip_addr) {
netif_set_ipaddr((struct netif*)netdev->user_data, ip_2_ip4(ip_addr));
}
if (netmask) {
netif_set_netmask((struct netif*)netdev->user_data, ip_2_ip4(netmask));
}
if (gw) {
netif_set_gw((struct netif*)netdev->user_data, ip_2_ip4(gw));
}
}
}
#ifdef LWIP_DNS
static int lwip_netdev_set_dns_server(struct netdev* netdev, uint8_t dns_num, ip_addr_t* dns_server)
{
#if LWIP_VERSION_MAJOR == 1U /* v1.x */
extern void dns_setserver(u8_t numdns, ip_addr_t * dnsserver);
#else /* >=2.x */
extern void dns_setserver(uint8_t dns_num, const ip_addr_t* dns_server);
#endif /* LWIP_VERSION_MAJOR == 1U */
dns_setserver(dns_num, dns_server);
return ERR_OK;
}
#endif
#ifdef LWIP_DHCP
static int lwip_netdev_set_dhcp(struct netdev* netdev, bool is_enabled)
{
netdev_low_level_set_dhcp_status(netdev, is_enabled);
if (true == is_enabled) {
dhcp_start((struct netif*)netdev->user_data);
} else {
dhcp_stop((struct netif*)netdev->user_data);
}
return ERR_OK;
}
#endif
static int lwip_netdev_set_default(struct netdev* netdev)
{
netif_set_default((struct netif*)netdev->user_data);
return ERR_OK;
}
static const struct netdev_ops lwip_netdev_ops = {
.set_up = lwip_netdev_set_up,
.set_down = lwip_netdev_set_down,
.set_addr_info = lwip_netdev_set_addr_info,
#ifdef LWIP_DNS
.set_dns_server = lwip_netdev_set_dns_server,
#endif
#ifdef LWIP_DHCP
.set_dhcp = lwip_netdev_set_dhcp,
#endif
.set_default = lwip_netdev_set_default,
};
static inline int netdev_set_flags(struct netif* lwip_netif)
{
CHECK(lwip_netif);
struct netdev* netdev = netdev_get_by_name(lwip_netif->name);
if (netdev == NULL) {
return -ERR_IF;
}
netdev->mtu = lwip_netif->mtu;
// set flags
if (lwip_netif->flags | NETIF_FLAG_BROADCAST) {
netdev->flags |= NETDEV_FLAG_BROADCAST;
}
if (lwip_netif->flags | NETIF_FLAG_ETHARP) {
netdev->flags |= NETDEV_FLAG_ETHARP;
}
if (lwip_netif->flags | NETIF_FLAG_IGMP) {
netdev->flags |= NETDEV_FLAG_IGMP;
}
#if LWIP_VERSION_MAJOR >= 2U /* >= v2.x */
if (lwip_netif->flags & NETIF_FLAG_MLD6) {
netdev->flags |= NETDEV_FLAG_MLD6;
}
#endif /* LWIP_VERSION_MAJOR >= 2U */
#if LWIP_DHCP
netdev_low_level_set_dhcp_status(netdev, true);
#else
netdev_low_level_set_dhcp_status(netdev, false);
#endif
return ERR_OK;
}
int lwip_netdev_add(struct netif* lwip_netif)
{
CHECK(lwip_netif);
struct netdev* netdev = calloc(1, sizeof(struct netdev));
if (netdev == NULL) {
return -ERR_IF;
}
// init netdev
char netif_name[NETIF_NAME_LEN + 1];
strncpy(netif_name, lwip_netif->name, NETIF_NAME_LEN);
// register netdev
int result = netdev_register(netdev, netif_name, (void*)lwip_netif);
// set values of netdev
netdev_set_flags(lwip_netif);
netdev->ops = &lwip_netdev_ops;
netdev->hwaddr_len = lwip_netif->hwaddr_len;
memcpy(netdev->hwaddr, lwip_netif->hwaddr, lwip_netif->hwaddr_len);
netdev->ip_addr = lwip_netif->ip_addr;
netdev->gw = lwip_netif->gw;
netdev->netmask = lwip_netif->netmask;
return result;
}
void lwip_netdev_del(struct netif* lwip_netif)
{
char name[NETIF_NAME_LEN + 1];
struct netdev* netdev;
CHECK(lwip_netif);
strncpy(name, lwip_netif->name, NETIF_NAME_LEN);
netdev = netdev_get_by_name(name);
netdev_unregister(netdev);
free(netdev);
}

88
Ubiquitous/XiZi_IIoT/board/edu-arm32/third_party_driver/ethernet/ethernetif.c
View File

@ -20,7 +20,7 @@
/** /**
* @file ethernetif.c * @file ethernetif.c
* @brief support edu-arm32-board ethernetif function and register to Lwip * @brief support hc32f4a0-board ethernetif function and register to Lwip
* @version 3.0 * @version 3.0
* @author AIIT XUOS Lab * @author AIIT XUOS Lab
* @date 2022-12-05 * @date 2022-12-05
@ -47,13 +47,15 @@ Modification:
* Include files * Include files
******************************************************************************/ ******************************************************************************/
#include <connect_ethernet.h> #include <connect_ethernet.h>
#include <hc32_ll_fcg.h>
#include <hc32_ll_gpio.h> #include <hc32_ll_gpio.h>
#include <hc32_ll_utility.h> #include <hc32_ll_utility.h>
#include <hc32_ll_fcg.h>
#include <lwip/timeouts.h> #include <lwip/timeouts.h>
#include <netif/etharp.h> #include <netif/etharp.h>
#include <netdev.h>
#include <xs_isr.h> #include <xs_isr.h>
#include <xs_kdbg.h>
/** /**
* @addtogroup HC32F4A0_DDL_Examples * @addtogroup HC32F4A0_DDL_Examples
@ -73,7 +75,6 @@ Modification:
* Local pre-processor symbols/macros ('#define') * Local pre-processor symbols/macros ('#define')
******************************************************************************/ ******************************************************************************/
/******************************************************************************* /*******************************************************************************
* Global variable definitions (declared in header file with 'extern') * Global variable definitions (declared in header file with 'extern')
******************************************************************************/ ******************************************************************************/
@ -86,7 +87,6 @@ Modification:
* Local variable definitions ('static') * Local variable definitions ('static')
******************************************************************************/ ******************************************************************************/
/******************************************************************************* /*******************************************************************************
* Function implementation - global ('extern') and local ('static') * Function implementation - global ('extern') and local ('static')
******************************************************************************/ ******************************************************************************/
@ -180,41 +180,14 @@ void Ethernet_GpioInit(void)
#endif #endif
} }
void *ethernetif_config_enet_set(uint8_t enet_port) { void* ethernetif_config_enet_set(uint8_t enet_port)
{
return NONE; return NONE;
} }
void Time_Update_LwIP(void) { void Time_Update_LwIP(void)
//no need to do
}
/**
* @brief Should be called at the beginning of the program to set up the network interface.
* @param netif The network interface structure for this ethernetif.
* @retval err_t:
* - LL_OK: The IF is initialized
* - LL_ERR: The IF is uninitialized
*/
err_t ethernetif_init(struct netif *netif)
{ {
#if LWIP_NETIF_HOSTNAME // no need to do
/* Initialize interface hostname */
netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
#ifndef ETHERNET_LOOPBACK_TEST
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
netif->output = etharp_output;
netif->linkoutput = low_level_output;
#endif
/* initialize the hardware */
return low_level_init(netif);
} }
/** /**
@ -256,6 +229,45 @@ void ethernetif_input(void *netif_arg)
} }
} }
/**
* @brief Should be called at the beginning of the program to set up the network interface.
* @param netif The network interface structure for this ethernetif.
* @retval err_t:
* - LL_OK: The IF is initialized
* - LL_ERR: The IF is uninitialized
*/
err_t ethernetif_init(struct netif* netif)
{
#if LWIP_NETIF_HOSTNAME
/* Initialize interface hostname */
netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
#ifndef ETHERNET_LOOPBACK_TEST
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
netif->output = etharp_output;
netif->linkoutput = low_level_output;
// netif->linkoutput = ethernetif_linkoutput;
#endif
/* initialize the hardware */
if (LL_OK != low_level_init(netif)) {
return LL_ERR;
}
if (EOK != lwip_netdev_add(netif)) {
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("[%s] LWIP add netdev failed.\n", __func__));
} else {
printf("[%s] Add Netdev successful\n", __func__);
}
return LL_OK;
}
/** /**
* @brief Check the netif link status. * @brief Check the netif link status.
* @param netif the network interface * @param netif the network interface
@ -405,8 +417,7 @@ void EthernetIF_LinkCallback(struct netif *netif)
CLR_REG16_BIT(u16RegVal, PHY_FULLDUPLEX_100M); CLR_REG16_BIT(u16RegVal, PHY_FULLDUPLEX_100M);
/* Set MAC Speed and Duplex Mode to PHY */ /* Set MAC Speed and Duplex Mode to PHY */
(void)ETH_PHY_WriteReg(&EthHandle, PHY_BCR, (void)ETH_PHY_WriteReg(&EthHandle, PHY_BCR,
((uint16_t)((EthHandle.stcCommInit).u32DuplexMode >> 3U) | ((uint16_t)((EthHandle.stcCommInit).u32DuplexMode >> 3U) | (uint16_t)((EthHandle.stcCommInit).u32Speed >> 1U) | u16RegVal));
(uint16_t)((EthHandle.stcCommInit).u32Speed >> 1U) | u16RegVal));
} }
/* ETH MAC Re-Configuration */ /* ETH MAC Re-Configuration */
ETH_MAC_SetDuplexSpeed((EthHandle.stcCommInit).u32DuplexMode, (EthHandle.stcCommInit).u32Speed); ETH_MAC_SetDuplexSpeed((EthHandle.stcCommInit).u32DuplexMode, (EthHandle.stcCommInit).u32Speed);
@ -453,7 +464,8 @@ __WEAKDEF void EthernetIF_NotifyLinkChange(struct netif *netif)
* @param p The MAC packet to receive * @param p The MAC packet to receive
* @retval None * @retval None
*/ */
__WEAKDEF void EthernetIF_InputCallback(struct netif *netif, struct pbuf *p) { __WEAKDEF void EthernetIF_InputCallback(struct netif* netif, struct pbuf* p)
{
/* This is function could be implemented in user file when the callback is needed */ /* This is function could be implemented in user file when the callback is needed */
#ifdef ETHERNET_LOOPBACK_TEST #ifdef ETHERNET_LOOPBACK_TEST
if ((0 == (memcmp(p->payload, txPbuf.payload, p->len))) && (p->len == txPbuf.len)) { if ((0 == (memcmp(p->payload, txPbuf.payload, p->len))) && (p->len == txPbuf.len)) {

9
Ubiquitous/XiZi_IIoT/board/edu-arm32/third_party_driver/include/connect_ethernet.h
View File

@ -22,16 +22,15 @@
#define CONNECT_ETHERNET_H #define CONNECT_ETHERNET_H
#include "hardware_ethernetif.h" #include "hardware_ethernetif.h"
#include <sys_arch.h>
#include <hc32_ll_eth.h>
#include <hardware_irq.h> #include <hardware_irq.h>
#include <hc32_ll_eth.h>
#include <sys_arch.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
struct hc32_irq_config struct hc32_irq_config {
{
IRQn_Type irq_num; IRQn_Type irq_num;
uint32_t irq_prio; uint32_t irq_prio;
en_int_src_t int_src; en_int_src_t int_src;
@ -64,10 +63,8 @@ struct pbuf *low_level_input(struct netif *netif);
int HwEthInit(void); int HwEthInit(void);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif

2
Ubiquitous/XiZi_IIoT/board/xidatong-arm32/third_party_driver/ethernet/Makefile
View File

@ -1,3 +1,3 @@
SRC_FILES := enet_ethernetif.c enet_ethernetif_kinetis.c fsl_enet.c SRC_FILES := enet_ethernetif.c enet_ethernetif_kinetis.c fsl_enet.c eth_netdev.c
SRC_DIR := lan8720 SRC_DIR := lan8720
include $(KERNEL_ROOT)/compiler.mk include $(KERNEL_ROOT)/compiler.mk

7
Ubiquitous/XiZi_IIoT/board/xidatong-arm32/third_party_driver/ethernet/enet_ethernetif.c
View File

@ -68,6 +68,7 @@
#include "fsl_gpio.h" #include "fsl_gpio.h"
#include "fsl_iomuxc.h" #include "fsl_iomuxc.h"
#include "netdev.h"
#include "sys_arch.h" #include "sys_arch.h"
/******************************************************************************* /*******************************************************************************
@ -319,6 +320,12 @@ err_t ethernetif_init(struct netif *netif, struct ethernetif *ethernetif,
} }
#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ #endif /* LWIP_IPV6 && LWIP_IPV6_MLD */
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("[%s] Adding netdev.\n", __func__));
if (EOK != lwip_netdev_add(netif)) {
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("[%s] LWIP add netdev failed.\n", __func__));
} else {
printf("[%s] Add Netdev successful\n", __func__);
}
return ERR_OK; return ERR_OK;
} }

163
Ubiquitous/XiZi_IIoT/board/xidatong-arm32/third_party_driver/ethernet/eth_netdev.c Normal file
View File

@ -0,0 +1,163 @@
#include <connect_ethernet.h>
#include <inet.h>
#include <lwip/dhcp.h>
#include <lwip/netif.h>
#include <netdev.h>
#include <xs_kdbg.h>
static const uint32_t NETIF_NAME_LEN = 2;
static int lwip_netdev_set_up(struct netdev* netdev)
{
netif_set_up((struct netif*)netdev->user_data);
return ERR_OK;
}
static int lwip_netdev_set_down(struct netdev* netif)
{
netif_set_down((struct netif*)netif->user_data);
return ERR_OK;
}
#ifndef ip_2_ip4
#define ip_2_ip4(ipaddr) (ipaddr)
#endif
static int lwip_netdev_set_addr_info(struct netdev* netdev, ip_addr_t* ip_addr, ip_addr_t* netmask, ip_addr_t* gw)
{
if (ip_addr && netmask && gw) {
netif_set_addr((struct netif*)netdev->user_data, ip_2_ip4(ip_addr), ip_2_ip4(netmask), ip_2_ip4(gw));
} else {
if (ip_addr) {
netif_set_ipaddr((struct netif*)netdev->user_data, ip_2_ip4(ip_addr));
}
if (netmask) {
netif_set_netmask((struct netif*)netdev->user_data, ip_2_ip4(netmask));
}
if (gw) {
netif_set_gw((struct netif*)netdev->user_data, ip_2_ip4(gw));
}
}
}
#ifdef LWIP_DNS
static int lwip_netdev_set_dns_server(struct netdev* netdev, uint8_t dns_num, ip_addr_t* dns_server)
{
#if LWIP_VERSION_MAJOR == 1U /* v1.x */
extern void dns_setserver(u8_t numdns, ip_addr_t * dnsserver);
#else /* >=2.x */
extern void dns_setserver(uint8_t dns_num, const ip_addr_t* dns_server);
#endif /* LWIP_VERSION_MAJOR == 1U */
dns_setserver(dns_num, dns_server);
return ERR_OK;
}
#endif
#ifdef LWIP_DHCP
static int lwip_netdev_set_dhcp(struct netdev* netdev, bool is_enabled)
{
netdev_low_level_set_dhcp_status(netdev, is_enabled);
if (true == is_enabled) {
dhcp_start((struct netif*)netdev->user_data);
} else {
dhcp_stop((struct netif*)netdev->user_data);
}
return ERR_OK;
}
#endif
static int lwip_netdev_set_default(struct netdev* netdev)
{
netif_set_default((struct netif*)netdev->user_data);
return ERR_OK;
}
static const struct netdev_ops lwip_netdev_ops = {
.set_up = lwip_netdev_set_up,
.set_down = lwip_netdev_set_down,
.set_addr_info = lwip_netdev_set_addr_info,
#ifdef LWIP_DNS
.set_dns_server = lwip_netdev_set_dns_server,
#endif
#ifdef LWIP_DHCP
.set_dhcp = lwip_netdev_set_dhcp,
#endif
.set_default = lwip_netdev_set_default,
};
static inline int netdev_set_flags(struct netif* lwip_netif)
{
CHECK(lwip_netif);
struct netdev* netdev = netdev_get_by_name(lwip_netif->name);
if (netdev == NULL) {
return -ERR_IF;
}
netdev->mtu = lwip_netif->mtu;
// set flags
if (lwip_netif->flags | NETIF_FLAG_BROADCAST) {
netdev->flags |= NETDEV_FLAG_BROADCAST;
}
if (lwip_netif->flags | NETIF_FLAG_ETHARP) {
netdev->flags |= NETDEV_FLAG_ETHARP;
}
if (lwip_netif->flags | NETIF_FLAG_IGMP) {
netdev->flags |= NETDEV_FLAG_IGMP;
}
#if LWIP_VERSION_MAJOR >= 2U /* >= v2.x */
if (lwip_netif->flags & NETIF_FLAG_MLD6) {
netdev->flags |= NETDEV_FLAG_MLD6;
}
#endif /* LWIP_VERSION_MAJOR >= 2U */
#if LWIP_DHCP
netdev_low_level_set_dhcp_status(netdev, true);
#else
netdev_low_level_set_dhcp_status(netdev, false);
#endif
return ERR_OK;
}
int lwip_netdev_add(struct netif* lwip_netif)
{
CHECK(lwip_netif);
struct netdev* netdev = calloc(1, sizeof(struct netdev));
if (netdev == NULL) {
return -ERR_IF;
}
// init netdev
char netif_name[NETIF_NAME_LEN + 1];
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("[%s] Lwip netif name: %s\n", __func__, lwip_netif->name));
strncpy(netif_name, lwip_netif->name, NETIF_NAME_LEN);
// register netdev
int result = netdev_register(netdev, netif_name, (void*)lwip_netif);
// set values of netdev
netdev_set_flags(lwip_netif);
netdev->ops = &lwip_netdev_ops;
netdev->hwaddr_len = lwip_netif->hwaddr_len;
memcpy(netdev->hwaddr, lwip_netif->hwaddr, lwip_netif->hwaddr_len);
netdev->ip_addr = lwip_netif->ip_addr;
netdev->gw = lwip_netif->gw;
netdev->netmask = lwip_netif->netmask;
return result;
}
void lwip_netdev_del(struct netif* lwip_netif)
{
char name[NETIF_NAME_LEN + 1];
struct netdev* netdev;
CHECK(lwip_netif);
strncpy(name, lwip_netif->name, NETIF_NAME_LEN);
netdev = netdev_get_by_name(name);
netdev_unregister(netdev);
free(netdev);
}

2
Ubiquitous/XiZi_IIoT/board/xidatong-arm32/third_party_driver/include/connect_ethernet.h
View File

@ -33,6 +33,8 @@
#define sourceClock CLOCK_GetFreq(kCLOCK_CoreSysClk) #define sourceClock CLOCK_GetFreq(kCLOCK_CoreSysClk)
#endif #endif
int lwip_netdev_add(struct netif* lwip_netif);
void lwip_netdev_del(struct netif* lwip_netif);
#ifdef __cplusplus #ifdef __cplusplus
} }

3
Ubiquitous/XiZi_IIoT/board/xidatong-arm32/third_party_driver/include/enet_ethernetif.h
View File

@ -185,6 +185,9 @@ int ETH_BSP_Config(void);
void *ethernetif_config_enet_set(uint8_t enet_port); void *ethernetif_config_enet_set(uint8_t enet_port);
int32 lwip_obtain_semaphore(struct netif *netif); int32 lwip_obtain_semaphore(struct netif *netif);
int lwip_netdev_add(struct netif* lwip_netif);
void lwip_netdev_del(struct netif* lwip_netif);
#define NETIF_ENET0_INIT_FUNC ethernetif0_init #define NETIF_ENET0_INIT_FUNC ethernetif0_init
#if defined(__cplusplus) #if defined(__cplusplus)

2
Ubiquitous/XiZi_IIoT/board/xiwangtong-arm32/third_party_driver/include/connect_ethernet.h
View File

@ -32,10 +32,8 @@
#define sourceClock CLOCK_GetFreq(kCLOCK_CoreSysClk) #define sourceClock CLOCK_GetFreq(kCLOCK_CoreSysClk)
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif

4
Ubiquitous/XiZi_IIoT/fs/shared/src/iot-vfs.c
View File

@ -772,7 +772,8 @@ int stat(const char *path, struct stat *buf)
ret = mp->fs->stat(mp, relpath, &vfs_statbuf); ret = mp->fs->stat(mp, relpath, &vfs_statbuf);
if (ret < 0) { if (ret < 0) {
SYS_ERR("%s: stat file failed\n", __func__); // stat() is absolutely fine to check if a file exists
// SYS_ERR("%s: stat file failed\n", __func__);
goto err; goto err;
} }
@ -790,7 +791,6 @@ err:
free(abspath); free(abspath);
if (ret < 0) { if (ret < 0) {
KUpdateExstatus(ret);
return -1; return -1;
} }
return 0; return 0;

41
Ubiquitous/XiZi_IIoT/kernel/include/xs_kdbg.h
View File

@ -28,6 +28,8 @@
extern "C" { extern "C" {
#endif #endif
#define KERNEL_DEBUG
#ifdef KERNEL_DEBUG #ifdef KERNEL_DEBUG
/*Kernel Section Debug Define*/ /*Kernel Section Debug Define*/
@ -40,9 +42,13 @@ extern "C" {
#define KDBG_IPC 0 #define KDBG_IPC 0
#define KDBG_HOOK 0 #define KDBG_HOOK 0
#define MSGQUEUE_DEBUG 0
#define FILESYS_DEBUG 0
#define NETDEV_DEBUG 0
#define WEBNET_DEBUG 0
#define SYS_KDEBUG_LOG(section, information) \ #define SYS_KDEBUG_LOG(section, information) \
do \ do { \
{ \
if (section) { \ if (section) { \
KPrintf information; \ KPrintf information; \
} \ } \
@ -64,10 +70,8 @@ extern "C" {
#endif #endif
#define KDYNAMIC_LOG(level, args, ...) \ #define KDYNAMIC_LOG(level, args, ...) \
do \ do { \
{ \ switch (level) { \
switch(level) \
{ \
case KDYN_NONE: \ case KDYN_NONE: \
break; \ break; \
case KDYN_DBG: \ case KDYN_DBG: \
@ -88,31 +92,28 @@ extern "C" {
} while (0) } while (0)
#define NULL_PARAM_CHECK(param) \ #define NULL_PARAM_CHECK(param) \
do \ do { \
{ \
if (param == NONE) { \ if (param == NONE) { \
KPrintf("PARAM CHECK FAILED ...%s %d %s is NULL.\n", __FUNCTION__, __LINE__, #param); \ KPrintf("PARAM CHECK FAILED ...%s %d %s is NULL.\n", __FUNCTION__, __LINE__, #param); \
while(RET_TRUE); \ while (RET_TRUE) \
; \
} \ } \
} while (0) } while (0)
#define CHECK(TRUE_CONDITION) \ #define CHECK(TRUE_CONDITION) \
do \ do { \
{ \
if (!(TRUE_CONDITION)) { \ if (!(TRUE_CONDITION)) { \
KPrintf("%s CHECK condition is false at line[%d] of [%s] func.\n", #TRUE_CONDITION, __LINE__, __FUNCTION__); \ KPrintf("%s CHECK condition is false at line[%d] of [%s] func.\n", #TRUE_CONDITION, __LINE__, __FUNCTION__); \
while(RET_TRUE); \ while (RET_TRUE) \
; \
} \ } \
} while (0) } while (0)
#define KDEBUG_NOT_IN_INTERRUPT \ #define KDEBUG_NOT_IN_INTERRUPT \
do \ do { \
{ \
x_base level; \ x_base level; \
level = DISABLE_INTERRUPT(); \ level = DISABLE_INTERRUPT(); \
if (isrManager.done->getCounter() != 0) \ if (isrManager.done->getCounter() != 0) { \
{ \
KPrintf("Function[%s] is not supported in ISR\n", __FUNCTION__); \ KPrintf("Function[%s] is not supported in ISR\n", __FUNCTION__); \
CHECK(0); \ CHECK(0); \
} \ } \
@ -120,12 +121,10 @@ extern "C" {
} while (0) } while (0)
#define KDEBUG_IN_KTASK_CONTEXT \ #define KDEBUG_IN_KTASK_CONTEXT \
do \ do { \
{ \
x_base level; \ x_base level; \
level = DISABLE_INTERRUPT(); \ level = DISABLE_INTERRUPT(); \
if (GetKTaskDescriptor() == NONE) \ if (GetKTaskDescriptor() == NONE) { \
{ \
KPrintf("Function[%s] is not supported before task assign\n", __FUNCTION__); \ KPrintf("Function[%s] is not supported before task assign\n", __FUNCTION__); \
CHECK(0); \ CHECK(0); \
} \ } \

89
Ubiquitous/XiZi_IIoT/kernel/memory/byte_manage.c
View File

@ -53,8 +53,10 @@
#define ALLOC_BLOCK_MASK 0xc0000000 #define ALLOC_BLOCK_MASK 0xc0000000
#define DYNAMIC_REMAINING_MASK 0x3fffffff #define DYNAMIC_REMAINING_MASK 0x3fffffff
#define SIZEOF_32B (32) enum SmallSizeAllocSize {
#define SIZEOF_64B (64) SIZEOF_32B = 32,
SIZEOF_64B = 64,
};
#define SMALL_SIZE_32B(ITEMSIZE) ((ITEMSIZE + SIZEOF_DYNAMICALLOCNODE_MEM) * SMALL_NUMBER_32B) /* Calculate the total size for SIZEOF_32B blocks*/ #define SMALL_SIZE_32B(ITEMSIZE) ((ITEMSIZE + SIZEOF_DYNAMICALLOCNODE_MEM) * SMALL_NUMBER_32B) /* Calculate the total size for SIZEOF_32B blocks*/
#define SMALL_SIZE_64B(ITEMSIZE) ((ITEMSIZE + SIZEOF_DYNAMICALLOCNODE_MEM) * SMALL_NUMBER_64B) /* Calculate the total size for SIZEOF_64B blocks*/ #define SMALL_SIZE_64B(ITEMSIZE) ((ITEMSIZE + SIZEOF_DYNAMICALLOCNODE_MEM) * SMALL_NUMBER_64B) /* Calculate the total size for SIZEOF_64B blocks*/
@ -143,7 +145,7 @@ struct ByteMemory
struct StaticMemoryDone struct StaticMemoryDone
{ {
void (*init)(struct ByteMemory *byte_memory); void (*init)(struct ByteMemory *byte_memory);
void* (*malloc)(struct ByteMemory *byte_memory, x_size_t size); void* (*malloc)(struct ByteMemory *byte_memory, enum SmallSizeAllocSize size);
void (*release)(void *pointer); void (*release)(void *pointer);
}; };
@ -349,11 +351,18 @@ static void* BigMemMalloc(struct DynamicBuddyMemory *dynamic_buddy, x_size_t siz
} }
/* best-fit method */ /* best-fit method */
for (node = dynamic_buddy->mm_freenode_list[ndx].next; node = dynamic_buddy->mm_freenode_list[ndx].next;
(ndx < MEM_LINKNRS ) && (node->size < allocsize); while(ndx < MEM_LINKNRS && (NONE == node || node->size < allocsize)) {
node = node->next) { if (NONE == node) {
ndx++; ndx++;
}; if (ndx == MEM_LINKNRS) { // no space to allocate
return NONE;
}
node = dynamic_buddy->mm_freenode_list[ndx].next;
} else {
node = node->next;
}
}
/* get the best-fit freeNode */ /* get the best-fit freeNode */
if (node && (node->size >= allocsize)) { if (node && (node->size >= allocsize)) {
struct DynamicFreeNode *remainder; struct DynamicFreeNode *remainder;
@ -385,7 +394,6 @@ static void* BigMemMalloc(struct DynamicBuddyMemory *dynamic_buddy, x_size_t siz
} }
/* handle the case of an exact size match */ /* handle the case of an exact size match */
node->flag = extsram_mask; node->flag = extsram_mask;
result = (void *)((char *)node + SIZEOF_DYNAMICALLOCNODE_MEM); result = (void *)((char *)node + SIZEOF_DYNAMICALLOCNODE_MEM);
} }
@ -551,6 +559,8 @@ static void SmallMemFree(void *pointer)
/* update the statistic information of static_segment */ /* update the statistic information of static_segment */
node->size = (x_size_t)static_segment->freelist; node->size = (x_size_t)static_segment->freelist;
static_segment->freelist = (uint8 *)node; static_segment->freelist = (uint8 *)node;
node->flag = 0; // it's unnecessary, actually
static_segment->block_free_count++; static_segment->block_free_count++;
/* parameter detection */ /* parameter detection */
@ -565,7 +575,7 @@ static void SmallMemFree(void *pointer)
* *
* @return pointer address on success; NULL on failure * @return pointer address on success; NULL on failure
*/ */
static void *SmallMemMalloc(struct ByteMemory *byte_memory, x_size_t size) static void *SmallMemMalloc(struct ByteMemory *byte_memory, enum SmallSizeAllocSize size)
{ {
uint8 i = 0; uint8 i = 0;
void *result = NONE; void *result = NONE;
@ -592,27 +602,14 @@ static void *SmallMemMalloc(struct ByteMemory *byte_memory, x_size_t size)
node->size = (long)static_segment; node->size = (long)static_segment;
} }
if(result) { if (NONE != result) {
/* return static memory block */ /* return static memory block */
return (char*)result + SIZEOF_DYNAMICALLOCNODE_MEM; return (char*)result + SIZEOF_DYNAMICALLOCNODE_MEM;
} }
/* the static memory block is exhausted, now turn to dynamic buddy memory for allocation. */ /* the static memory block is exhausted, now turn to dynamic buddy memory for allocation. */
result = byte_memory->dynamic_buddy_manager.done->malloc(&byte_memory->dynamic_buddy_manager, size, DYNAMIC_BLOCK_NO_EXTMEM_MASK); // fall to dynamic allocation
#ifdef MEM_EXTERN_SRAM return NONE;
if(NONE == result) {
for(i = 0; i < EXTSRAM_MAX_NUM; i++) {
if(NONE != ExtByteManager[i].done) {
result = ExtByteManager[i].dynamic_buddy_manager.done->malloc(&ExtByteManager[i].dynamic_buddy_manager, size, DYNAMIC_BLOCK_EXTMEMn_MASK(i + 1));
if (result){
CHECK(ExtByteManager[i].dynamic_buddy_manager.done->JudgeLegal(&ExtByteManager[i].dynamic_buddy_manager, ret - SIZEOF_DYNAMICALLOCNODE_MEM));
break;
}
}
}
}
#endif
return result;
} }
static struct StaticMemoryDone StaticDone = { static struct StaticMemoryDone StaticDone = {
@ -634,41 +631,46 @@ void *x_malloc(x_size_t size)
void *ret = NONE; void *ret = NONE;
register x_base lock = 0; register x_base lock = 0;
/* parameter detection */ /* hold lock before allocation */
lock = CriticalAreaLock();
/* alignment */
size = ALIGN_MEN_UP(size, MEM_ALIGN_SIZE);
/* parameter detection */
#ifdef MEM_EXTERN_SRAM #ifdef MEM_EXTERN_SRAM
/* parameter detection */ /* parameter detection */
if(size == 0 ){ if(size == 0 ){
CriticalAreaUnLock(lock);
return NONE; return NONE;
} }
if((size > ByteManager.dynamic_buddy_manager.dynamic_buddy_end - ByteManager.dynamic_buddy_manager.dynamic_buddy_start - ByteManager.dynamic_buddy_manager.active_memory)){ if((size > ByteManager.dynamic_buddy_manager.dynamic_buddy_end - ByteManager.dynamic_buddy_manager.dynamic_buddy_start - ByteManager.dynamic_buddy_manager.active_memory)){
lock = CriticalAreaLock();
/* alignment */ /* alignment */
size = ALIGN_MEN_UP(size, MEM_ALIGN_SIZE); size = ALIGN_MEN_UP(size, MEM_ALIGN_SIZE);
goto try_extmem; goto try_extmem;
} }
#else #else
/* parameter detection */ /* parameter detection */
if((size == 0) || (size > ByteManager.dynamic_buddy_manager.dynamic_buddy_end - ByteManager.dynamic_buddy_manager.dynamic_buddy_start - ByteManager.dynamic_buddy_manager.active_memory)) if((size == 0) || (size > ByteManager.dynamic_buddy_manager.dynamic_buddy_end - ByteManager.dynamic_buddy_manager.dynamic_buddy_start - ByteManager.dynamic_buddy_manager.active_memory)) {
CriticalAreaUnLock(lock);
return NONE; return NONE;
}
#endif #endif
/* hold lock before allocation */
lock = CriticalAreaLock();
/* alignment */
size = ALIGN_MEN_UP(size, MEM_ALIGN_SIZE);
/* determine allocation operation from static segments or dynamic buddy memory */ /* determine allocation operation from static segments or dynamic buddy memory */
#ifdef KERNEL_SMALL_MEM_ALLOC #ifdef KERNEL_SMALL_MEM_ALLOC
if(size <= SIZEOF_32B) { if(size <= SIZEOF_32B) {
ret = ByteManager.static_manager[0].done->malloc(&ByteManager, SIZEOF_32B); ret = ByteManager.static_manager[0].done->malloc(&ByteManager, SIZEOF_32B);
} else if (size <= SIZEOF_64B) { } else if (size <= SIZEOF_64B) {
ret = ByteManager.static_manager[1].done->malloc(&ByteManager, SIZEOF_64B); ret = ByteManager.static_manager[1].done->malloc(&ByteManager, SIZEOF_64B);
} else }
#endif #endif
{
if (ret == NONE) {
ret = ByteManager.dynamic_buddy_manager.done->malloc(&ByteManager.dynamic_buddy_manager, size, DYNAMIC_BLOCK_NO_EXTMEM_MASK); ret = ByteManager.dynamic_buddy_manager.done->malloc(&ByteManager.dynamic_buddy_manager, size, DYNAMIC_BLOCK_NO_EXTMEM_MASK);
if(ret != NONE) if (ret != NONE) {
CHECK(ByteManager.dynamic_buddy_manager.done->JudgeLegal(&ByteManager.dynamic_buddy_manager, ret - SIZEOF_DYNAMICALLOCNODE_MEM)); CHECK(ByteManager.dynamic_buddy_manager.done->JudgeLegal(&ByteManager.dynamic_buddy_manager, ret - SIZEOF_DYNAMICALLOCNODE_MEM));
}
#ifdef MEM_EXTERN_SRAM #ifdef MEM_EXTERN_SRAM
try_extmem: try_extmem:
@ -686,6 +688,7 @@ try_extmem:
} }
#endif #endif
} }
/* release lock */ /* release lock */
CriticalAreaUnLock(lock); CriticalAreaUnLock(lock);
return ret; return ret;
@ -781,13 +784,19 @@ void x_free(void *pointer)
struct DynamicAllocNode *node = NONE; struct DynamicAllocNode *node = NONE;
/* parameter detection */ /* parameter detection */
if (pointer == NONE) if (pointer == NONE) {
return; return;
}
CHECK(ByteManager.dynamic_buddy_manager.done->JudgeLegal(&ByteManager.dynamic_buddy_manager,pointer));
/* hold lock before release */ /* hold lock before release */
lock = CriticalAreaLock(); lock = CriticalAreaLock();
if (!ByteManager.dynamic_buddy_manager.done->JudgeLegal(&ByteManager.dynamic_buddy_manager, pointer)) {
CriticalAreaUnLock(lock);
SYS_ERR("[%s] Freeing a unallocated address.\n", __func__);
return;
}
node = PTR2ALLOCNODE((char*)pointer - SIZEOF_DYNAMICALLOCNODE_MEM); node = PTR2ALLOCNODE((char*)pointer - SIZEOF_DYNAMICALLOCNODE_MEM);
CHECK(ByteManager.done->JudgeAllocated(node)); CHECK(ByteManager.done->JudgeAllocated(node));
@ -812,6 +821,7 @@ void x_free(void *pointer)
ByteManager.dynamic_buddy_manager.done->release(&ByteManager, pointer); ByteManager.dynamic_buddy_manager.done->release(&ByteManager, pointer);
#endif #endif
} }
/* release the lock */ /* release the lock */
CriticalAreaUnLock(lock); CriticalAreaUnLock(lock);
} }
@ -888,6 +898,7 @@ void InitBoardMemory(void *start_phy_address, void *end_phy_address)
/* parameter detection */ /* parameter detection */
if (ByteManager.dynamic_buddy_manager.dynamic_buddy_start >= ByteManager.dynamic_buddy_manager.dynamic_buddy_end) { if (ByteManager.dynamic_buddy_manager.dynamic_buddy_start >= ByteManager.dynamic_buddy_manager.dynamic_buddy_end) {
//KPrintf("InitBoardMemory, wrong address[0x%x - 0x%x]\n", (x_ubase)start_phy_address, (x_ubase)end_phy_address); //KPrintf("InitBoardMemory, wrong address[0x%x - 0x%x]\n", (x_ubase)start_phy_address, (x_ubase)end_phy_address);
SYS_KDEBUG_LOG(KDBG_MEM, ("InitBoardMemory, wrong address[0x%x - 0x%x]\n", (x_ubase)start_phy_address, (x_ubase)end_phy_address));
return; return;
} }

2
Ubiquitous/XiZi_IIoT/kernel/thread/delay.c
View File

@ -30,7 +30,7 @@
DoubleLinklistType xiaoshan_delay_head = {&xiaoshan_delay_head, &xiaoshan_delay_head}; DoubleLinklistType xiaoshan_delay_head = {&xiaoshan_delay_head, &xiaoshan_delay_head};
/** /**
* This function will delay a task with sone ticks. * This function will delay a task with some ticks.
* *
* @param task the task needed to be delayed * @param task the task needed to be delayed
* @param ticks delay timeout * @param ticks delay timeout

33
Ubiquitous/XiZi_IIoT/kernel/thread/msgqueue.c
View File

@ -21,6 +21,7 @@
#include <xizi.h> #include <xizi.h>
#include <xs_delay.h> #include <xs_delay.h>
#include <xs_kdbg.h>
DECLARE_ID_MANAGER(k_mq_id_manager, ID_NUM_MAX); DECLARE_ID_MANAGER(k_mq_id_manager, ID_NUM_MAX);
DoubleLinklistType k_mq_list = {&k_mq_list, &k_mq_list}; DoubleLinklistType k_mq_list = {&k_mq_list, &k_mq_list};
@ -47,11 +48,11 @@ static struct MsgQueue *GetMsgQueueById(int32 id)
} }
mq = CONTAINER_OF(idnode, struct MsgQueue, id); mq = CONTAINER_OF(idnode, struct MsgQueue, id);
CriticalAreaUnLock(lock); CriticalAreaUnLock(lock);
return mq; return mq;
} }
static x_err_t _InitMsgQueue( struct MsgQueue *mq ,x_size_t msg_size, static x_err_t _InitMsgQueue(struct MsgQueue* mq, x_size_t msg_size, x_size_t max_msgs)
x_size_t max_msgs )
{ {
x_base lock = 0; x_base lock = 0;
@ -62,6 +63,8 @@ static x_err_t _InitMsgQueue( struct MsgQueue *mq ,x_size_t msg_size,
mq->each_len = ALIGN_MEN_UP(msg_size, MEM_ALIGN_SIZE); mq->each_len = ALIGN_MEN_UP(msg_size, MEM_ALIGN_SIZE);
mq->index = 0; mq->index = 0;
SYS_KDEBUG_LOG(MSGQUEUE_DEBUG, ("[%s] Msg attr, max_msg_num: %d, block size: %d\n", __func__, mq->max_msgs, mq->each_len));
InitDoubleLinkList(&mq->send_pend_list); InitDoubleLinkList(&mq->send_pend_list);
InitDoubleLinkList(&(mq->recv_pend_list)); InitDoubleLinkList(&(mq->recv_pend_list));
@ -91,6 +94,8 @@ static x_err_t _MsgQueueSend(struct MsgQueue *mq,
NULL_PARAM_CHECK(mq); NULL_PARAM_CHECK(mq);
NULL_PARAM_CHECK(buffer); NULL_PARAM_CHECK(buffer);
SYS_KDEBUG_LOG(MSGQUEUE_DEBUG, ("[%s] mq_num_msgs: %d, block size: %d, needed size: %d\n", __func__, mq->num_msgs, mq->each_len, size));
if (size > mq->each_len) if (size > mq->each_len)
return -ERROR; return -ERROR;
@ -108,7 +113,6 @@ static x_err_t _MsgQueueSend(struct MsgQueue *mq,
} }
while (mq->num_msgs >= mq->max_msgs) { while (mq->num_msgs >= mq->max_msgs) {
task->exstatus = EOK; task->exstatus = EOK;
if (timeout == 0) { if (timeout == 0) {
CriticalAreaUnLock(lock); CriticalAreaUnLock(lock);
@ -139,7 +143,7 @@ static x_err_t _MsgQueueSend(struct MsgQueue *mq,
if (timeout < 0) if (timeout < 0)
timeout = 0; timeout = 0;
} }
} } // end with lock here
msg = mq->msg_buf + ((mq->index + mq->num_msgs) % mq->max_msgs) * mq->each_len; msg = mq->msg_buf + ((mq->index + mq->num_msgs) % mq->max_msgs) * mq->each_len;
memcpy(msg, buffer, size); memcpy(msg, buffer, size);
@ -150,8 +154,8 @@ static x_err_t _MsgQueueSend(struct MsgQueue *mq,
DO_KTASK_ASSIGN; DO_KTASK_ASSIGN;
return EOK; return EOK;
} }
CriticalAreaUnLock(lock); CriticalAreaUnLock(lock);
return EOK; return EOK;
} }
@ -199,7 +203,7 @@ static x_err_t _MsgQueueRecv(struct MsgQueue *mq,
x_ubase lock = 0; x_ubase lock = 0;
uint32 tick_delta = 0; uint32 tick_delta = 0;
int32 timeout = 0; int32 timeout = 0;
struct MqMessage *msg = NONE; uint8* msg = NONE;
struct TaskDescriptor *task = NONE; struct TaskDescriptor *task = NONE;
NULL_PARAM_CHECK(mq); NULL_PARAM_CHECK(mq);
@ -208,14 +212,14 @@ static x_err_t _MsgQueueRecv(struct MsgQueue *mq,
tick_delta = 0; tick_delta = 0;
task = GetKTaskDescriptor(); task = GetKTaskDescriptor();
timeout = CalculateTickFromTimeMs(msec); timeout = CalculateTickFromTimeMs(msec);
lock = CriticalAreaLock();
lock = CriticalAreaLock();
if (mq->index == 0 && timeout == 0) { if (mq->index == 0 && timeout == 0) {
CriticalAreaUnLock(lock); CriticalAreaUnLock(lock);
return -ETIMEOUT; return -ETIMEOUT;
} }
for( ; mq->num_msgs <= 0 ; ) { while (mq->num_msgs <= 0) {
KDEBUG_IN_KTASK_CONTEXT; KDEBUG_IN_KTASK_CONTEXT;
task->exstatus = EOK; task->exstatus = EOK;
@ -225,9 +229,7 @@ static x_err_t _MsgQueueRecv(struct MsgQueue *mq,
return -ETIMEOUT; return -ETIMEOUT;
} }
LinklistSuspend(&(mq->recv_pend_list), LinklistSuspend(&(mq->recv_pend_list), task, LINKLIST_FLAG_FIFO);
task,
LINKLIST_FLAG_FIFO);
if (timeout > 0) { if (timeout > 0) {
tick_delta = CurrentTicksGain(); tick_delta = CurrentTicksGain();
@ -237,7 +239,6 @@ static x_err_t _MsgQueueRecv(struct MsgQueue *mq,
} }
CriticalAreaUnLock(lock); CriticalAreaUnLock(lock);
DO_KTASK_ASSIGN; DO_KTASK_ASSIGN;
if (task->exstatus != EOK) { if (task->exstatus != EOK) {
@ -326,8 +327,7 @@ static struct MsgQueueDone Done = {
* *
* @return id on success;ENOMEMORY/ERROR on failure * @return id on success;ENOMEMORY/ERROR on failure
*/ */
int32 KCreateMsgQueue(x_size_t msg_size, int32 KCreateMsgQueue(x_size_t msg_size, x_size_t max_msgs)
x_size_t max_msgs)
{ {
int32 id = 0; int32 id = 0;
x_base temp = 0; x_base temp = 0;
@ -342,6 +342,7 @@ int32 KCreateMsgQueue(x_size_t msg_size,
lock = CriticalAreaLock(); lock = CriticalAreaLock();
id = IdInsertObj(&k_mq_id_manager, &mq->id); id = IdInsertObj(&k_mq_id_manager, &mq->id);
CriticalAreaUnLock(lock); CriticalAreaUnLock(lock);
if (id < 0) { if (id < 0) {
x_free(mq); x_free(mq);
return -ENOMEMORY; return -ENOMEMORY;
@ -350,6 +351,7 @@ int32 KCreateMsgQueue(x_size_t msg_size,
lock = CriticalAreaLock(); lock = CriticalAreaLock();
DoubleLinkListInsertNodeAfter(&k_mq_list, &mq->link); DoubleLinkListInsertNodeAfter(&k_mq_list, &mq->link);
CriticalAreaUnLock(lock); CriticalAreaUnLock(lock);
mq->Done = &Done; mq->Done = &Done;
if (mq->Done->init(mq, msg_size, max_msgs) == EOK) if (mq->Done->init(mq, msg_size, max_msgs) == EOK)
return mq->id.id; return mq->id.id;
@ -471,10 +473,11 @@ x_err_t KMsgQueueSend(int32 id, const void *buffer, x_size_t size)
mq = GetMsgQueueById(id); mq = GetMsgQueueById(id);
if (mq != NONE) if (mq != NONE)
return mq->Done->send(mq,buffer,size,0); return mq->Done->send(mq, buffer, size, WAITING_FOREVER);
else else
return -EINVALED; return -EINVALED;
} }
/** /**
* send message with waiting time,current suspend task will be resumed * send message with waiting time,current suspend task will be resumed
* *

4
Ubiquitous/XiZi_IIoT/path_app.mk
View File

@ -8,6 +8,9 @@ ifeq ($(CONFIG_APP_SELECT_NEWLIB), y)
APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/lib/app_newlib/include # APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/lib/app_newlib/include #
endif endif
ifeq ($(CONFIG_APP_USING_WEBNET),y)
APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Applications/webnet/WebNet_XiUOS/inc #
endif
ifeq ($(CONFIG_ADD_XIZI_FEATURES), y) ifeq ($(CONFIG_ADD_XIZI_FEATURES), y)
APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/transform_layer/xizi \ APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/transform_layer/xizi \
@ -36,6 +39,7 @@ ifeq ($(CONFIG_CRYPTO), y)
APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/security/crypto/include # APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/security/crypto/include #
endif endif
# COMPILE_APP: # COMPILE_APP:
# @$(eval CPPPATHS=$(APPPATHS)) # @$(eval CPPPATHS=$(APPPATHS))
# @echo $(SRC_APP_DIR) # @echo $(SRC_APP_DIR)

10
Ubiquitous/XiZi_IIoT/path_kernel.mk
View File

@ -52,6 +52,8 @@ KERNELPATHS += \
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/priv \ -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/priv \
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/prot \ -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/prot \
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/arch -I$(KERNEL_ROOT)/resources/ethernet/LwIP/arch
KERNELPATHS += -I$(KERNEL_ROOT)/resources/include/netdev
endif endif
endif endif
@ -419,6 +421,8 @@ KERNELPATHS += \
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/priv \ -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/priv \
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/prot \ -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/prot \
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/arch -I$(KERNEL_ROOT)/resources/ethernet/LwIP/arch
KERNELPATHS += -I$(KERNEL_ROOT)/resources/include/netdev
endif endif
endif endif
@ -554,6 +558,12 @@ endif
endif endif
ifeq ($(CONFIG_APP_USING_WEBNET),y)
KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Applications/webnet/WebNet_XiUOS/inc \
-I$(KERNEL_ROOT)/../../APP_Framework/Applications/webnet/WebNet_XiUOS/samples #
endif
ifeq ($(CONFIG_TOOL_SHELL), y) ifeq ($(CONFIG_TOOL_SHELL), y)
KERNELPATHS +=-I$(KERNEL_ROOT)/tool/shell/letter-shell \ KERNELPATHS +=-I$(KERNEL_ROOT)/tool/shell/letter-shell \
-I$(KERNEL_ROOT)/tool/shell/letter-shell/file_ext # -I$(KERNEL_ROOT)/tool/shell/letter-shell/file_ext #

124
Ubiquitous/XiZi_IIoT/resources/ethernet/LwIP/arch/sys_arch.c
View File

@ -39,35 +39,34 @@
*/ */
#include "debug.h" #include "debug.h"
#include <lwip/opt.h>
#include <lwip/arch.h> #include <lwip/arch.h>
#include <lwip/opt.h>
#include "tcpip.h" #include "lwip/dhcp.h"
#include "lwip/init.h" #include "lwip/init.h"
#include "lwip/netif.h" #include "lwip/netif.h"
#include "lwip/sio.h" #include "lwip/sio.h"
#include <lwip/stats.h> #include "tcpip.h"
#include <lwip/debug.h>
#include <lwip/sys.h>
#include "lwip/dhcp.h"
#include "tcpip_priv.h" #include "tcpip_priv.h"
#include <lwip/debug.h>
#include <lwip/stats.h>
#include <lwip/sys.h>
#if !NO_SYS #if !NO_SYS
#include "sys_arch.h" #include "sys_arch.h"
#endif #endif
#include <string.h> #include <string.h>
#include <xs_assign.h>
#include <xs_ktask.h> #include <xs_ktask.h>
#include <xs_ktick.h> #include <xs_ktick.h>
#include <xs_assign.h>
#include <xs_sem.h>
#include <xs_mutex.h>
#include <xs_ktask.h>
#include <xs_msg.h> #include <xs_msg.h>
#include <xs_mutex.h>
#include <xs_sem.h>
#include "board.h" #include "board.h"
#include "ethernet.h"
#include "connect_ethernet.h" #include "connect_ethernet.h"
#include "ethernet.h"
char lwip_ipaddr[20] = { 192, 168, 130, 77 }; char lwip_ipaddr[20] = { 192, 168, 130, 77 };
char lwip_netmask[20] = { 255, 255, 254, 0 }; char lwip_netmask[20] = { 255, 255, 254, 0 };
@ -88,39 +87,43 @@ x_ticks_t lwip_sys_now;
#define SYS_THREAD_MAX 4 #define SYS_THREAD_MAX 4
struct netif gnetif; struct netif gnetif;
sys_sem_t* get_eth_recv_sem() { sys_sem_t* get_eth_recv_sem()
{
static sys_sem_t g_recv_sem = 0; static sys_sem_t g_recv_sem = 0;
return &g_recv_sem; return &g_recv_sem;
} }
void sys_init(void) { void sys_init(void)
{
// do nothing // do nothing
} }
u32_t u32_t sys_jiffies(void)
sys_jiffies(void) { {
lwip_sys_now = CurrentTicksGain(); lwip_sys_now = CurrentTicksGain();
return lwip_sys_now; return lwip_sys_now;
} }
u32_t u32_t sys_now(void)
sys_now(void) { {
lwip_sys_now = CurrentTicksGain(); lwip_sys_now = CurrentTicksGain();
return CalculateTimeMsFromTick(lwip_sys_now); return CalculateTimeMsFromTick(lwip_sys_now);
} }
sys_prot_t sys_arch_protect(void) { sys_prot_t sys_arch_protect(void)
{
return CriticalAreaLock(); return CriticalAreaLock();
} }
void sys_arch_unprotect(sys_prot_t pval) { void sys_arch_unprotect(sys_prot_t pval)
{
CriticalAreaUnLock(pval); CriticalAreaUnLock(pval);
} }
#if !NO_SYS #if !NO_SYS
err_t err_t sys_sem_new(sys_sem_t* sem, u8_t count)
sys_sem_new(sys_sem_t *sem, u8_t count) { {
*sem = KSemaphoreCreate((uint16)count); *sem = KSemaphoreCreate((uint16)count);
#if SYS_STATS #if SYS_STATS
@ -141,8 +144,8 @@ sys_sem_new(sys_sem_t *sem, u8_t count) {
} }
} }
void void sys_sem_free(sys_sem_t* sem)
sys_sem_free(sys_sem_t *sem) { {
#if SYS_STATS #if SYS_STATS
--lwip_stats.sys.sem.used; --lwip_stats.sys.sem.used;
#endif /* SYS_STATS */ #endif /* SYS_STATS */
@ -150,24 +153,24 @@ sys_sem_free(sys_sem_t *sem) {
*sem = SYS_SEM_NULL; *sem = SYS_SEM_NULL;
} }
int sys_sem_valid(sys_sem_t *sem) { int sys_sem_valid(sys_sem_t* sem)
{
return (*sem > SYS_SEM_NULL); return (*sem > SYS_SEM_NULL);
} }
void void sys_sem_set_invalid(sys_sem_t* sem)
sys_sem_set_invalid(sys_sem_t *sem) { {
*sem = SYS_SEM_NULL; *sem = SYS_SEM_NULL;
} }
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) { u32_t sys_arch_sem_wait(sys_sem_t* sem, u32_t timeout)
{
x_ticks_t start_tick = 0; x_ticks_t start_tick = 0;
int32 wait_time = 0; int32 wait_time = 0;
if (*sem == SYS_SEM_NULL) if (*sem == SYS_SEM_NULL)
return SYS_ARCH_TIMEOUT; return SYS_ARCH_TIMEOUT;
start_tick = CurrentTicksGain(); start_tick = CurrentTicksGain();
if (0 == timeout) if (0 == timeout)
@ -175,19 +178,20 @@ u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) {
else else
wait_time = timeout; wait_time = timeout;
if (KSemaphoreObtain(*sem, wait_time) == EOK) if (KSemaphoreObtain(*sem, wait_time) == EOK)
return CalculateTimeMsFromTick(CurrentTicksGain() - start_tick); return CalculateTimeMsFromTick(CurrentTicksGain() - start_tick);
else else
return SYS_ARCH_TIMEOUT; return SYS_ARCH_TIMEOUT;
} }
void sys_sem_signal(sys_sem_t *sem) { void sys_sem_signal(sys_sem_t* sem)
{
if (KSemaphoreAbandon(*sem) != EOK) if (KSemaphoreAbandon(*sem) != EOK)
KPrintf("[sys_arch]:sem signal fail!\n"); KPrintf("[sys_arch]:sem signal fail!\n");
} }
err_t sys_mutex_new(sys_mutex_t *mutex) { err_t sys_mutex_new(sys_mutex_t* mutex)
{
*mutex = KMutexCreate(); *mutex = KMutexCreate();
if (*mutex > SYS_MRTEX_NULL) if (*mutex > SYS_MRTEX_NULL)
return ERR_OK; return ERR_OK;
@ -197,24 +201,28 @@ err_t sys_mutex_new(sys_mutex_t *mutex) {
} }
} }
void sys_mutex_free(sys_mutex_t *mutex) { void sys_mutex_free(sys_mutex_t* mutex)
{
KMutexDelete(*mutex); KMutexDelete(*mutex);
} }
void sys_mutex_set_invalid(sys_mutex_t *mutex) { void sys_mutex_set_invalid(sys_mutex_t* mutex)
{
*mutex = SYS_MRTEX_NULL; *mutex = SYS_MRTEX_NULL;
} }
void sys_mutex_lock(sys_mutex_t *mutex) { void sys_mutex_lock(sys_mutex_t* mutex)
{
KMutexObtain(*mutex, WAITING_FOREVER); KMutexObtain(*mutex, WAITING_FOREVER);
} }
void sys_mutex_unlock(sys_mutex_t *mutex) { void sys_mutex_unlock(sys_mutex_t* mutex)
{
KMutexAbandon(*mutex); KMutexAbandon(*mutex);
} }
sys_thread_t sys_thread_new(const char* name, lwip_thread_fn function, void* arg, int stacksize, int prio)
sys_thread_t sys_thread_new(const char *name, lwip_thread_fn function, void *arg, int stacksize, int prio) { {
sys_thread_t handle = -1; sys_thread_t handle = -1;
handle = KTaskCreate(name, handle = KTaskCreate(name,
function, function,
@ -230,7 +238,8 @@ sys_thread_t sys_thread_new(const char *name, lwip_thread_fn function, void *arg
return -ERROR; return -ERROR;
} }
err_t sys_mbox_new(sys_mbox_t *mbox, int size) { err_t sys_mbox_new(sys_mbox_t* mbox, int size)
{
*mbox = KCreateMsgQueue(sizeof(void*), size); *mbox = KCreateMsgQueue(sizeof(void*), size);
#if SYS_STATS #if SYS_STATS
@ -248,26 +257,31 @@ err_t sys_mbox_new(sys_mbox_t *mbox, int size) {
return ERR_OK; return ERR_OK;
} }
void sys_mbox_free(sys_mbox_t *mbox) { void sys_mbox_free(sys_mbox_t* mbox)
{
KDeleteMsgQueue(*mbox); KDeleteMsgQueue(*mbox);
} }
int sys_mbox_valid(sys_mbox_t *mbox) { int sys_mbox_valid(sys_mbox_t* mbox)
{
if (*mbox <= SYS_MBOX_NULL) if (*mbox <= SYS_MBOX_NULL)
return 0; return 0;
else else
return 1; return 1;
} }
void sys_mbox_set_invalid(sys_mbox_t *mbox) { void sys_mbox_set_invalid(sys_mbox_t* mbox)
{
*mbox = SYS_MBOX_NULL; *mbox = SYS_MBOX_NULL;
} }
void sys_mbox_post(sys_mbox_t *q, void *msg) { void sys_mbox_post(sys_mbox_t* q, void* msg)
{
KMsgQueueSendwait(*q, &msg, sizeof(void*), WAITING_FOREVER); KMsgQueueSendwait(*q, &msg, sizeof(void*), WAITING_FOREVER);
} }
err_t sys_mbox_trypost(sys_mbox_t *q, void *msg) { err_t sys_mbox_trypost(sys_mbox_t* q, void* msg)
{
// if(KMsgQueueSend(*q, &msg, sizeof(void *)) == EOK) // if(KMsgQueueSend(*q, &msg, sizeof(void *)) == EOK)
if (KMsgQueueSend(*q, &msg, sizeof(void*)) == EOK) if (KMsgQueueSend(*q, &msg, sizeof(void*)) == EOK)
return ERR_OK; return ERR_OK;
@ -275,11 +289,13 @@ err_t sys_mbox_trypost(sys_mbox_t *q, void *msg) {
return ERR_MEM; return ERR_MEM;
} }
err_t sys_mbox_trypost_fromisr(sys_mbox_t *q, void *msg) { err_t sys_mbox_trypost_fromisr(sys_mbox_t* q, void* msg)
{
return sys_mbox_trypost(q, msg); return sys_mbox_trypost(q, msg);
} }
u32_t sys_arch_mbox_fetch(sys_mbox_t *q, void **msg, u32_t timeout) { u32_t sys_arch_mbox_fetch(sys_mbox_t* q, void** msg, u32_t timeout)
{
x_ticks_t start_tick = 0; x_ticks_t start_tick = 0;
int32 wait_time = 0; int32 wait_time = 0;
@ -297,7 +313,8 @@ u32_t sys_arch_mbox_fetch(sys_mbox_t *q, void **msg, u32_t timeout) {
} }
} }
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *q, void **msg) { u32_t sys_arch_mbox_tryfetch(sys_mbox_t* q, void** msg)
{
if (KMsgQueueRecv(*q, &(*msg), sizeof(void*), 0) == EOK) if (KMsgQueueRecv(*q, &(*msg), sizeof(void*), 0) == EOK)
return ERR_OK; return ERR_OK;
else else
@ -315,7 +332,8 @@ ip4_addr_t ipaddr;
ip4_addr_t netmask; ip4_addr_t netmask;
ip4_addr_t gw; ip4_addr_t gw;
void lwip_config_input(struct netif *net) { void lwip_config_input(struct netif* net)
{
sys_thread_t th_id = 0; sys_thread_t th_id = 0;
th_id = sys_thread_new("eth_input", ethernetif_input, net, LWIP_TASK_STACK_SIZE, 20); th_id = sys_thread_new("eth_input", ethernetif_input, net, LWIP_TASK_STACK_SIZE, 20);
@ -327,7 +345,10 @@ void lwip_config_input(struct netif *net) {
} }
} }
void lwip_config_tcp(uint8_t enet_port, char *ip, char *mask, char *gw) { void lwip_config_tcp(uint8_t enet_port, char* ip, char* mask, char* gw)
{
sys_sem_new(get_eth_recv_sem(), 0);
ip4_addr_t net_ipaddr, net_netmask, net_gw; ip4_addr_t net_ipaddr, net_netmask, net_gw;
char* eth_cfg; char* eth_cfg;
@ -378,8 +399,8 @@ void lwip_config_tcp(uint8_t enet_port, char *ip, char *mask, char *gw) {
lwip_config_input(&gnetif); lwip_config_input(&gnetif);
} }
void lwip_config_net(uint8_t enet_port, char* ip, char* mask, char* gw)
void lwip_config_net(uint8_t enet_port, char *ip, char *mask, char *gw) { {
ip4_addr_t net_ipaddr, net_netmask, net_gw; ip4_addr_t net_ipaddr, net_netmask, net_gw;
char* eth_cfg; char* eth_cfg;
@ -439,4 +460,3 @@ void lwip_config_net(uint8_t enet_port, char *ip, char *mask, char *gw) {
} }
lwip_config_input(&gnetif); lwip_config_input(&gnetif);
} }

2
Ubiquitous/XiZi_IIoT/resources/ethernet/LwIP/core/ipv4/ip4_addr.c
View File

@ -314,7 +314,7 @@ ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen)
*rp++ = '.'; *rp++ = '.';
ap++; ap++;
} }
*--rp = 0; *--rp = '\0';
return buf; return buf;
} }

2
Ubiquitous/XiZi_IIoT/resources/ethernet/Makefile
View File

@ -1,4 +1,4 @@
SRC_DIR += cmd_lwip SRC_DIR += cmd_lwip netdev
LWIP_DIR := LwIP LWIP_DIR := LwIP
include $(KERNEL_ROOT)/compiler.mk include $(KERNEL_ROOT)/compiler.mk

45
Ubiquitous/XiZi_IIoT/resources/ethernet/cmd_lwip/lwip_config_demo.c
View File

@ -19,10 +19,13 @@
*/ */
#include <board.h> #include <board.h>
#include <sys_arch.h>
#include <shell.h> #include <shell.h>
#include <sys.h>
#include <string.h> #include <string.h>
#include <sys.h>
#include <sys_arch.h>
#include <xs_kdbg.h>
#include <netdev.h>
/******************************************************************************/ /******************************************************************************/
uint8_t enet_id = 0; uint8_t enet_id = 0;
@ -36,31 +39,25 @@ static void LwipSetIPTask(void *param)
void LwipSetIPTest(int argc, char* argv[]) void LwipSetIPTest(int argc, char* argv[])
{ {
if(argc >= 4) if (argc >= 4) {
{
printf("lw: [%s] ip %s mask %s gw %s netport %s\n", __func__, argv[1], argv[2], argv[3], argv[4]); printf("lw: [%s] ip %s mask %s gw %s netport %s\n", __func__, argv[1], argv[2], argv[3], argv[4]);
sscanf(argv[1], "%d.%d.%d.%d", &lwip_ipaddr[0], &lwip_ipaddr[1], &lwip_ipaddr[2], &lwip_ipaddr[3]); sscanf(argv[1], "%d.%d.%d.%d", &lwip_ipaddr[0], &lwip_ipaddr[1], &lwip_ipaddr[2], &lwip_ipaddr[3]);
sscanf(argv[2], "%d.%d.%d.%d", &lwip_netmask[0], &lwip_netmask[1], &lwip_netmask[2], &lwip_netmask[3]); sscanf(argv[2], "%d.%d.%d.%d", &lwip_netmask[0], &lwip_netmask[1], &lwip_netmask[2], &lwip_netmask[3]);
sscanf(argv[3], "%d.%d.%d.%d", &lwip_gwaddr[0], &lwip_gwaddr[1], &lwip_gwaddr[2], &lwip_gwaddr[3]); sscanf(argv[3], "%d.%d.%d.%d", &lwip_gwaddr[0], &lwip_gwaddr[1], &lwip_gwaddr[2], &lwip_gwaddr[3]);
sscanf(argv[4], "%d", &enet_id); sscanf(argv[4], "%d", &enet_id);
if(0 == enet_id) if (0 == enet_id) {
{
printf("save eth0 info\n"); printf("save eth0 info\n");
memcpy(lwip_eth0_ipaddr, lwip_ipaddr, 20); memcpy(lwip_eth0_ipaddr, lwip_ipaddr, 20);
memcpy(lwip_eth0_netmask, lwip_netmask, 20); memcpy(lwip_eth0_netmask, lwip_netmask, 20);
memcpy(lwip_eth0_gwaddr, lwip_gwaddr, 20); memcpy(lwip_eth0_gwaddr, lwip_gwaddr, 20);
} } else if (1 == enet_id) {
else if(1 == enet_id)
{
printf("save eth1 info\n"); printf("save eth1 info\n");
memcpy(lwip_eth1_ipaddr, lwip_ipaddr, 20); memcpy(lwip_eth1_ipaddr, lwip_ipaddr, 20);
memcpy(lwip_eth1_netmask, lwip_netmask, 20); memcpy(lwip_eth1_netmask, lwip_netmask, 20);
memcpy(lwip_eth1_gwaddr, lwip_gwaddr, 20); memcpy(lwip_eth1_gwaddr, lwip_gwaddr, 20);
} }
} } else if (argc == 2) {
else if(argc == 2)
{
printf("lw: [%s] set eth0 ipaddr %s \n", __func__, argv[1]); printf("lw: [%s] set eth0 ipaddr %s \n", __func__, argv[1]);
sscanf(argv[1], "%d.%d.%d.%d", &lwip_ipaddr[0], &lwip_ipaddr[1], &lwip_ipaddr[2], &lwip_ipaddr[3]); sscanf(argv[1], "%d.%d.%d.%d", &lwip_ipaddr[0], &lwip_ipaddr[1], &lwip_ipaddr[2], &lwip_ipaddr[3]);
memcpy(lwip_eth0_ipaddr, lwip_ipaddr, strlen(lwip_ipaddr)); memcpy(lwip_eth0_ipaddr, lwip_ipaddr, strlen(lwip_ipaddr));
@ -72,16 +69,33 @@ void LwipSetIPTest(int argc, char *argv[])
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(5), SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(5),
setip, LwipSetIPTest, setip[IP][Netmask][Gateway][port]); setip, LwipSetIPTest, setip[IP][Netmask][Gateway][port]);
void LwipShowIPTask(int argc, char* argv[]) void LwipShowIPTask(int argc, char* argv[])
{ {
#ifdef configMAC_ADDR #ifdef configMAC_ADDR
char mac_addr0[] = configMAC_ADDR; char mac_addr0[] = configMAC_ADDR;
#endif #endif
// find default netdev
struct netdev* netdev = netdev_get_by_name("en\0");
if (netdev == NULL) {
lw_notice("[%s] Netdev not found by name en\n");
struct netdev* default_netdev = NETDEV_DEFAULT;
}
lw_notice("\r\n************************************************\r\n"); lw_notice("\r\n************************************************\r\n");
lw_notice(" Network Configuration\r\n"); lw_notice(" Network Configuration\r\n");
lw_notice("************************************************\r\n"); lw_notice("************************************************\r\n");
// lw_notice(" ETH0 IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t*)&lwip_eth0_ipaddr)[0], ((u8_t*)&lwip_eth0_ipaddr)[1],
// ((u8_t*)&lwip_eth0_ipaddr)[2], ((u8_t*)&lwip_eth0_ipaddr)[3]);
// lw_notice(" ETH0 IPv4 Subnet mask : %u.%u.%u.%u\r\n", ((u8_t*)&lwip_eth0_netmask)[0], ((u8_t*)&lwip_eth0_netmask)[1],
// ((u8_t*)&lwip_eth0_netmask)[2], ((u8_t*)&lwip_eth0_netmask)[3]);
// lw_notice(" ETH0 IPv4 Gateway : %u.%u.%u.%u\r\n", ((u8_t*)&lwip_gwaddr)[0], ((u8_t*)&lwip_eth0_gwaddr)[1],
// ((u8_t*)&lwip_eth0_gwaddr)[2], ((u8_t*)&lwip_eth0_gwaddr)[3]);
// #ifdef configMAC_ADDR
// lw_notice(" ETH0 MAC Address : %x:%x:%x:%x:%x:%x\r\n", mac_addr0[0], mac_addr0[1], mac_addr0[2],
// mac_addr0[3], mac_addr0[4], mac_addr0[5]);
// #endif
lw_notice(" ETH0 IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t*)&lwip_eth0_ipaddr)[0], ((u8_t*)&lwip_eth0_ipaddr)[1], lw_notice(" ETH0 IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t*)&lwip_eth0_ipaddr)[0], ((u8_t*)&lwip_eth0_ipaddr)[1],
((u8_t*)&lwip_eth0_ipaddr)[2], ((u8_t*)&lwip_eth0_ipaddr)[3]); ((u8_t*)&lwip_eth0_ipaddr)[2], ((u8_t*)&lwip_eth0_ipaddr)[3]);
lw_notice(" ETH0 IPv4 Subnet mask : %u.%u.%u.%u\r\n", ((u8_t*)&lwip_eth0_netmask)[0], ((u8_t*)&lwip_eth0_netmask)[1], lw_notice(" ETH0 IPv4 Subnet mask : %u.%u.%u.%u\r\n", ((u8_t*)&lwip_eth0_netmask)[0], ((u8_t*)&lwip_eth0_netmask)[1],
@ -92,9 +106,9 @@ void LwipShowIPTask(int argc, char *argv[])
lw_notice(" ETH0 MAC Address : %x:%x:%x:%x:%x:%x\r\n", mac_addr0[0], mac_addr0[1], mac_addr0[2], lw_notice(" ETH0 MAC Address : %x:%x:%x:%x:%x:%x\r\n", mac_addr0[0], mac_addr0[1], mac_addr0[2],
mac_addr0[3], mac_addr0[4], mac_addr0[5]); mac_addr0[3], mac_addr0[4], mac_addr0[5]);
#endif #endif
#ifdef BOARD_NET_COUNT #ifdef BOARD_NET_COUNT
if(BOARD_NET_COUNT > 1) if (BOARD_NET_COUNT > 1) {
{
char mac_addr1[] = configMAC_ADDR_ETH1; char mac_addr1[] = configMAC_ADDR_ETH1;
lw_notice("\r\n"); lw_notice("\r\n");
lw_notice(" ETH1 IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t*)&lwip_eth1_ipaddr)[0], ((u8_t*)&lwip_eth1_ipaddr)[1], lw_notice(" ETH1 IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t*)&lwip_eth1_ipaddr)[0], ((u8_t*)&lwip_eth1_ipaddr)[1],
@ -112,4 +126,3 @@ void LwipShowIPTask(int argc, char *argv[])
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(0), SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(0),
showip, LwipShowIPTask, GetIp[IP][Netmask][Gateway]); showip, LwipShowIPTask, GetIp[IP][Netmask][Gateway]);

4
Ubiquitous/XiZi_IIoT/resources/ethernet/netdev/Makefile Normal file
View File

@ -0,0 +1,4 @@
SRC_FILES += netdev_register.c netdev_manipulate.c netdev_lowlevel.c
include $(KERNEL_ROOT)/compiler.mk

0
Ubiquitous/XiZi_IIoT/resources/ethernet/netdev/netdev_ipaddr_util.c Normal file
View File

220
Ubiquitous/XiZi_IIoT/resources/ethernet/netdev/netdev_lowlevel.c Normal file
View File

@ -0,0 +1,220 @@
#include <netdev.h>
#include <string.h>
#include <xs_kdbg.h>
/**
* This function will set network interface device IP address.
* @NOTE it can only be called in the network interface device driver.
*
* @param netdev the network interface device to change
* @param ip_addr the new IP address
*/
void netdev_low_level_set_ipaddr(struct netdev* netdev, const ip_addr_t* ip_addr)
{
CHECK(ip_addr);
if (netdev && ip_addr_cmp(&(netdev->ip_addr), ip_addr) == 0) {
ip_addr_copy(netdev->ip_addr, *ip_addr);
/* execute IP address change callback function */
if (netdev->addr_callback) {
netdev->addr_callback(netdev, NETDEV_CB_ADDR_IP);
}
}
}
/**
* This function will set network interface device netmask address.
* @NOTE it can only be called in the network interface device driver.
*
* @param netdev the network interface device to change
* @param netmask the new netmask address
*/
void netdev_low_level_set_netmask(struct netdev* netdev, const ip_addr_t* netmask)
{
CHECK(netmask);
if (netdev && ip_addr_cmp(&(netdev->netmask), netmask) == 0) {
ip_addr_copy(netdev->netmask, *netmask);
/* execute netmask address change callback function */
if (netdev->addr_callback) {
netdev->addr_callback(netdev, NETDEV_CB_ADDR_NETMASK);
}
}
}
/**
* This function will set network interface device gateway address.
* @NOTE it can only be called in the network interface device driver.
*
* @param netdev the network interface device to change
* @param gw the new gateway address
*/
void netdev_low_level_set_gw(struct netdev* netdev, const ip_addr_t* gw)
{
CHECK(gw);
if (netdev && ip_addr_cmp(&(netdev->gw), gw) == 0) {
ip_addr_copy(netdev->gw, *gw);
/* execute gateway address change callback function */
if (netdev->addr_callback) {
netdev->addr_callback(netdev, NETDEV_CB_ADDR_GATEWAY);
}
}
}
/**
* This function will set network interface device DNS server address.
* @NOTE it can only be called in the network interface device driver.
*
* @param netdev the network interface device to change
* @param dns_num the number of the DNS server
* @param dns_server the new DNS server address
*
*/
void netdev_low_level_set_dns_server(struct netdev* netdev, uint8_t dns_num, const ip_addr_t* dns_server)
{
unsigned int index;
CHECK(dns_server);
if (netdev == NULL) {
return;
}
/* check DNS servers is exist */
for (index = 0; index < NETDEV_DNS_SERVERS_NUM; index++) {
if (ip_addr_cmp(&(netdev->dns_servers[index]), dns_server)) {
return;
}
}
if (dns_num < NETDEV_DNS_SERVERS_NUM) {
ip_addr_copy(netdev->dns_servers[dns_num], *dns_server);
/* execute DNS servers address change callback function */
if (netdev->addr_callback) {
netdev->addr_callback(netdev, NETDEV_CB_ADDR_DNS_SERVER);
}
}
}
/* Change to the first link_up network interface device automatically */
static void netdev_auto_change_default(struct netdev* netdev)
{
struct netdev* new_netdev = NULL;
if (netdev->flags & NETDEV_FLAG_LINK_UP) {
if (!(NETDEV_DEFAULT->flags & NETDEV_FLAG_LINK_UP)) {
netdev_set_default(netdev);
}
return;
}
if (memcmp(netdev, NETDEV_DEFAULT, sizeof(struct netdev)) == 0) {
new_netdev = netdev_get_first_by_flags(NETDEV_FLAG_LINK_UP);
if (new_netdev) {
netdev_set_default(new_netdev);
}
}
}
/**
* This function will set network interface device status.
* @NOTE it can only be called in the network interface device driver.
*
* @param netdev the network interface device to change
* @param is_up the new status
*/
void netdev_low_level_set_status(struct netdev* netdev, bool is_up)
{
if (netdev && netdev_is_up(netdev) != is_up) {
if (is_up) {
netdev->flags |= NETDEV_FLAG_UP;
} else {
netdev->flags &= ~NETDEV_FLAG_UP;
/* change to the first link_up network interface device automatically */
netdev_auto_change_default(netdev);
}
/* execute network interface device status change callback function */
if (netdev->status_callback) {
netdev->status_callback(netdev, is_up ? NETDEV_CB_STATUS_UP : NETDEV_CB_STATUS_DOWN);
}
}
}
/**
* This function will set network interface device active link status.
* @NOTE it can only be called in the network interface device driver.
*
* @param netdev the network interface device to change
* @param is_up the new link status
*/
void netdev_low_level_set_link_status(struct netdev* netdev, bool is_up)
{
if (netdev && netdev_is_link_up(netdev) != is_up) {
if (is_up) {
netdev->flags |= NETDEV_FLAG_LINK_UP;
} else {
netdev->flags &= ~NETDEV_FLAG_LINK_UP;
/* set network interface device flags to internet down */
netdev->flags &= ~NETDEV_FLAG_INTERNET_UP;
netdev_auto_change_default(netdev);
}
/* execute link status change callback function */
if (netdev->status_callback) {
netdev->status_callback(netdev, is_up ? NETDEV_CB_STATUS_LINK_UP : NETDEV_CB_STATUS_LINK_DOWN);
}
}
}
/**
* This function will set network interface device active internet status.
* @NOTE it can only be called in the network interface device driver.
*
* @param netdev the network interface device to change
* @param is_up the new internet status
*/
void netdev_low_level_set_internet_status(struct netdev* netdev, bool is_up)
{
if (netdev && netdev_is_internet_up(netdev) != is_up) {
if (is_up) {
netdev->flags |= NETDEV_FLAG_INTERNET_UP;
} else {
netdev->flags &= ~NETDEV_FLAG_INTERNET_UP;
}
/* execute network interface device status change callback function */
if (netdev->status_callback) {
netdev->status_callback(netdev, is_up ? NETDEV_CB_STATUS_INTERNET_UP : NETDEV_CB_STATUS_INTERNET_DOWN);
}
}
}
/**
* This function will set network interface device DHCP status.
* @NOTE it can only be called in the network interface device driver.
*
* @param netdev the network interface device to change
* @param is_up the new DHCP status
*/
void netdev_low_level_set_dhcp_status(struct netdev* netdev, bool is_enable)
{
if (netdev && netdev_is_dhcp_enabled(netdev) != is_enable) {
if (is_enable) {
netdev->flags |= NETDEV_FLAG_DHCP;
} else {
netdev->flags &= ~NETDEV_FLAG_DHCP;
}
/* execute DHCP status change callback function */
if (netdev->status_callback) {
netdev->status_callback(netdev, is_enable ? NETDEV_CB_STATUS_DHCP_ENABLE : NETDEV_CB_STATUS_DHCP_DISABLE);
}
}
}

288
Ubiquitous/XiZi_IIoT/resources/ethernet/netdev/netdev_manipulate.c Normal file
View File

@ -0,0 +1,288 @@
#include <netdev.h>
#include <string.h>
#include <xs_isr.h>
#include <xs_kdbg.h>
inline int netdev_check_set_addr_condition(struct netdev* netdev)
{
if (NULL == netdev->ops || NULL == netdev->ops->set_addr_info) {
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("The network interface device(%s) not support to set IP address.\n", netdev->name));
return -ERROR;
}
// check whether dhcp enabled
if (netdev_is_dhcp_enabled(netdev)) {
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("The network interface device(%s) DHCP capability is enable, not support set IP address.\n", netdev->name));
return -ERROR;
}
return EOK;
}
/**
* This function will set network interface device IP address.
*
* @param netdev the network interface device to change
* @param ip_addr the new IP address
*
* @return 0: set IP address successfully
* -1: set IP address failed
*/
int netdev_set_ipaddr(struct netdev* netdev, const ip_addr_t* ipaddr)
{
CHECK(netdev);
CHECK(ipaddr);
if (EOK != netdev_check_set_addr_condition(netdev)) {
return -ERROR;
}
return netdev->ops->set_addr_info(netdev, (ip_addr_t*)ipaddr, NULL, NULL);
}
/**
* This function will set network interface device netmask address.
*
* @param netdev the network interface device to change
* @param netmask the new netmask address
*
* @return 0: set netmask address successfully
* -1: set netmask address failed
*/
int netdev_set_netmask(struct netdev* netdev, const ip_addr_t* netmask)
{
CHECK(netdev);
CHECK(netmask);
if (EOK != netdev_check_set_addr_condition(netdev)) {
return -ERROR;
}
return netdev->ops->set_addr_info(netdev, NULL, (ip_addr_t*)netmask, NULL);
}
/**
* This function will set network interface device gateway address.
*
* @param netdev the network interface device to change
* @param gw the new gateway address
*
* @return 0: set gateway address successfully
* -1: set gateway address failed
*/
int netdev_set_gw(struct netdev* netdev, const ip_addr_t* gw)
{
CHECK(netdev);
CHECK(gw);
if (EOK != netdev_check_set_addr_condition(netdev)) {
return -ERROR;
}
/* execute network interface device set gateway address operations */
return netdev->ops->set_addr_info(netdev, NULL, NULL, (ip_addr_t*)gw);
}
/**
* This function will set network interface device DNS server address.
*
* @param netdev the network interface device to change
* @param dns_num the number of the DNS server
* @param dns_server the new DNS server address
*
* @return 0: set netmask address successfully
* -1: set netmask address failed
*/
int netdev_set_dns_server(struct netdev* netdev, uint8_t dns_num, const ip_addr_t* dns_server)
{
CHECK(netdev);
CHECK(dns_server);
// check dns server number
if (dns_num >= NETDEV_DNS_SERVERS_NUM) {
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("The number of DNS servers(%d) set exceeds the maximum number(%d).\n", dns_num + 1, NETDEV_DNS_SERVERS_NUM));
return -ERROR;
}
// check dns set function existence
if (NULL == netdev->ops || NULL == netdev->ops->set_dns_server) {
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("The network interface device(%s) not support to set DNS server address.\n", netdev->name));
return -ERROR;
}
return netdev->ops->set_dns_server(netdev, dns_num, (ip_addr_t*)dns_server);
}
/**
* This function will set callback to be called when the network interface device status has been changed.
*
* @param netdev the network interface device to change
* @param status_callback the callback be called when the status has been changed.
*/
void netdev_set_status_callback(struct netdev* netdev, netdev_callback_fn status_callback)
{
CHECK(netdev);
CHECK(status_callback);
netdev->status_callback = status_callback;
}
/**
* This function will set callback to be called when the network interface device address has been changed.
*
* @param netdev the network interface device to change
* @param addr_callback the callback be called when the address has been changed.
*/
void netdev_set_addr_callback(struct netdev* netdev, netdev_callback_fn addr_callback)
{
CHECK(netdev);
CHECK(addr_callback);
netdev->addr_callback = addr_callback;
}
/**
* This function will enable network interface device .
*
* @param netdev the network interface device to change
*
* @return 0: set status successfully
* -1: set status failed
*/
int netdev_set_up(struct netdev* netdev)
{
CHECK(netdev);
if (!netdev->ops || !netdev->ops->set_up) {
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("The network interface device(%s) not support to set status.\n", netdev->name));
return -ERROR;
}
/* network interface device status flags check */
if (netdev_is_up(netdev)) {
return EOK;
}
/* execute enable network interface device operations by network interface device driver */
return netdev->ops->set_up(netdev);
}
/**
* This function will disable network interface device.
*
* @param netdev the network interface device to change
*
* @return 0: set status successfully
* -1: set sttaus failed
*/
int netdev_set_down(struct netdev* netdev)
{
CHECK(netdev);
if (!netdev->ops || !netdev->ops->set_down) {
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("The network interface device(%s) not support to set status.\n", netdev->name));
return -ERROR;
}
/* network interface device status flags check */
if (!netdev_is_up(netdev)) {
return EOK;
}
/* execute disable network interface device operations by network interface driver */
return netdev->ops->set_down(netdev);
}
/**
* This function will get the first network interface device
* with the flags in network interface device list.
*
* @param flags the network interface device flags
*
* @return != NULL: network interface device object
* NULL: get failed
*/
struct netdev* netdev_get_first_by_flags(uint16_t flags)
{
if (NETDEV_LISTHEAD == NULL) {
return NULL;
}
// get netdev from list
x_base lock = DISABLE_INTERRUPT();
struct netdev* current_dev = NETDEV_LISTHEAD;
SINGLE_LINKLIST_FOR_EACH_ENTRY(current_dev, &(NETDEV_LISTHEAD->list), list)
{
if (NULL != current_dev && 0 != (current_dev->flags & flags)) {
ENABLE_INTERRUPT(lock);
return current_dev;
}
}
ENABLE_INTERRUPT(lock);
return NULL;
}
/**
* This function will get the first network interface device
* in network interface device list by IP address.
*
* @param ip_addr the network interface device IP address
*
* @return != NULL: network interface device object
* NULL: get failed
*/
struct netdev* netdev_get_by_ipaddr(ip_addr_t* ip_addr)
{
if (NETDEV_LISTHEAD == NULL) {
return NULL;
}
// get netdev from list
x_base lock = DISABLE_INTERRUPT();
struct netdev* current_dev = NETDEV_LISTHEAD;
SINGLE_LINKLIST_FOR_EACH_ENTRY(current_dev, &(NETDEV_LISTHEAD->list), list)
{
if (NULL != current_dev && ip_addr_cmp(&(current_dev->ip_addr), ip_addr)) {
ENABLE_INTERRUPT(lock);
return current_dev;
}
}
ENABLE_INTERRUPT(lock);
return NULL;
}
/**
* This function will get network interface device
* in network interface device list by netdev name.
*
* @param name the network interface device name
*
* @return != NULL: network interface device object
* NULL: get failed
*/
struct netdev* netdev_get_by_name(const char* name)
{
if (NETDEV_LISTHEAD == NULL) {
return NULL;
}
// get netdev from list
x_base lock = DISABLE_INTERRUPT();
struct netdev* current_dev = NETDEV_LISTHEAD;
SINGLE_LINKLIST_FOR_EACH_ENTRY(current_dev, &(NETDEV_LISTHEAD->list), list)
{
if (NULL == current_dev) {
continue;
}
uint32_t name_len = strlen(current_dev->name);
if (NULL != current_dev && (strncmp(current_dev->name, name, strlen(current_dev->name) < NAME_NUM_MAX ? strlen(current_dev->name) : NAME_NUM_MAX) == 0)) {
ENABLE_INTERRUPT(lock);
return current_dev;
}
}
ENABLE_INTERRUPT(lock);
return NULL;
}

184
Ubiquitous/XiZi_IIoT/resources/ethernet/netdev/netdev_register.c Normal file
View File

@ -0,0 +1,184 @@
#include <assert.h>
#include <def.h>
#include <netdev.h>
#include <netdev_ipaddr.h>
#include <string.h>
#include <xs_isr.h>
#include <xs_kdbg.h>
struct netdev** get_netdev_listhead()
{
static struct netdev* netdev_listhead = NULL;
return &netdev_listhead;
}
struct netdev** get_default_netdev()
{
static struct netdev* netdev_default = NULL;
return &netdev_default;
}
static netdev_callback_fn g_netdev_register_callback = NULL;
static netdev_callback_fn g_netdev_default_change_callback = NULL;
int netdev_register(struct netdev* netdev, const char* name, void* user_data)
{
CHECK(netdev != NULL);
CHECK(name != NULL);
// set flag mask, assert network is down
uint16_t flag_mask = 0;
flag_mask = NETDEV_FLAG_UP | NETDEV_FLAG_LINK_UP | NETDEV_FLAG_INTERNET_UP | NETDEV_FLAG_DHCP;
netdev->flags &= ~flag_mask;
// clear dev setting
ip_addr_set_zero(&(netdev->ip_addr));
ip_addr_set_zero(&(netdev->netmask));
ip_addr_set_zero(&(netdev->gw));
IP_SET_TYPE_VAL(netdev->ip_addr, IPADDR_TYPE_V4);
IP_SET_TYPE_VAL(netdev->netmask, IPADDR_TYPE_V4);
IP_SET_TYPE_VAL(netdev->gw, IPADDR_TYPE_V4);
#if NETDEV_IPV6
for (index = 0; index < NETDEV_IPV6_NUM_ADDRESSES; index++) {
ip_addr_set_zero(&(netdev->ip6_addr[index]));
IP_SET_TYPE_VAL(netdev->ip_addr, IPADDR_TYPE_V6);
}
#endif /* NETDEV_IPV6 */
// clear DNS servers
for (uint16_t idx = 0; idx < NETDEV_DNS_SERVERS_NUM; idx++) {
ip_addr_set_zero(&(netdev->dns_servers[idx]));
IP_SET_TYPE_VAL(netdev->ip_addr, IPADDR_TYPE_V4);
}
// clear callback fn
netdev->addr_callback = NULL;
netdev->status_callback = NULL;
// validate name
uint32_t name_len = strlen(name);
if (name_len < NAME_NUM_MAX) {
strncpy(netdev->name, name, name_len);
netdev->name[name_len] = '\0';
} else {
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("[%s] name too long.\n", __func__));
strncpy(netdev->name, name, NAME_NUM_MAX - 1);
netdev->name[NAME_NUM_MAX - 1] = '\0';
}
netdev->user_data = user_data;
InitSingleLinkList(&(netdev->list));
// insert netdev to global list
x_base lock = DISABLE_INTERRUPT();
if (NETDEV_LISTHEAD == NULL) {
NETDEV_LISTHEAD = netdev;
} else {
SingleLinkListNodeInsert(&(NETDEV_LISTHEAD->list), &(netdev->list));
}
ENABLE_INTERRUPT(lock);
if (NETDEV_DEFAULT == NULL) {
// set first met netdev to default netdev
netdev_set_default(NETDEV_LISTHEAD);
}
if (g_netdev_register_callback) {
g_netdev_register_callback(netdev, NETDEV_CB_REGISTER);
}
return EOK;
}
/**
* This function will unregister network interface device and
* delete it from network interface device list.
*
* @param netdev the network interface device object
*
* @return 0: unregistered successfully
* -1: unregistered failed
*/
int netdev_unregister(struct netdev* netdev)
{
CHECK(netdev);
if (NETDEV_LISTHEAD == NULL) {
return -ERROR;
}
// remove netdev from netdev list
x_base lock = DISABLE_INTERRUPT();
struct netdev* current_dev = NETDEV_LISTHEAD;
SINGLE_LINKLIST_FOR_EACH_ENTRY(current_dev, &(NETDEV_LISTHEAD->list), list)
{
// found netdev in list
if (current_dev == netdev) {
if (NETDEV_LISTHEAD == current_dev && NULL == SingleLinkListGetNextNode(&(current_dev->list))) {
// netdev is the only one in list
NETDEV_LISTHEAD = NULL;
} else {
SingleLinkListRmNode(&(NETDEV_LISTHEAD->list), &(current_dev->list));
}
// deal default netdev
if (current_dev == NETDEV_DEFAULT) {
NETDEV_DEFAULT = NULL;
}
break;
}
}
ENABLE_INTERRUPT(lock);
if (NETDEV_DEFAULT == NULL) {
netdev_set_default(NETDEV_LISTHEAD);
}
// clean netdev if found one
if (current_dev == netdev) {
memset(netdev, 0, sizeof(*netdev));
}
return EOK;
}
/**
* This function will set default network interface device.
*
* @param netdev the network interface device to change
*/
void netdev_set_default(struct netdev* netdev)
{
if (netdev && (netdev != NETDEV_DEFAULT)) {
NETDEV_DEFAULT = netdev;
// set default function
if (netdev->ops && netdev->ops->set_default) {
netdev->ops->set_default(netdev);
}
// default change callback
if (g_netdev_default_change_callback) {
g_netdev_default_change_callback(netdev, NETDEV_CB_DEFAULT_CHANGE);
}
SYS_KDEBUG_LOG(NETDEV_DEBUG, ("Setting default network interface device name(%s) successfully.\n", netdev->name));
}
}
/**
* This function will set register callback
*
* @param register_callback the network register callback
*
*/
void netdev_set_register_callback(netdev_callback_fn register_callback)
{
g_netdev_register_callback = register_callback;
}
void netdev_set_default_change_callback(netdev_callback_fn default_change_cb)
{
g_netdev_default_change_callback = default_change_cb;
}

180
Ubiquitous/XiZi_IIoT/resources/include/netdev/netdev.h Normal file
View File

@ -0,0 +1,180 @@
#ifndef __NETDEV_H__
#define __NETDEV_H__
#include <netdev_ipaddr.h>
#include <stdbool.h>
#include <xs_klist.h>
#include <xsconfig.h>
#ifdef __cplusplus
extern "C" {
#endif
#define NETDEV_DEBUG_PRINT_IP_INFO(ip, netmask, gw) \
("[%s %d]ip: %u.%u.%u.%u, netmask: %u.%u.%u.%u, gw: %u.%u.%u.%u\n", \
__func__, __LINE__, \
((u8_t*)&ip)[0], ((u8_t*)&ip)[1], ((u8_t*)&ip)[2], ((u8_t*)&ip)[3], \
((u8_t*)&netmask)[0], ((u8_t*)&netmask)[1], ((u8_t*)&netmask)[2], ((u8_t*)&netmask)[3], \
((u8_t*)&gw)[0], ((u8_t*)&gw)[1], ((u8_t*)&gw)[2], ((u8_t*)&gw)[3])
/* the maximum of all used hardware address lengths */
#ifndef NETDEV_HWADDR_MAX_LEN
#define NETDEV_HWADDR_MAX_LEN 8U
#endif
/* the maximum of dns server number supported */
#ifndef NETDEV_DNS_SERVERS_NUM
#define NETDEV_DNS_SERVERS_NUM 2U
#endif
/* whether the network interface device is 'up' (set by the network interface driver or application) */
#define NETDEV_FLAG_UP 0x01U
/* if set, the network interface device has broadcast capability, only supported in the 'lwIP' stack */
#define NETDEV_FLAG_BROADCAST 0x02U
/* if set, the network interface device has an active link (set by the network interface driver) */
#define NETDEV_FLAG_LINK_UP 0x04U
/* if set, the network interface device is an ethernet device using ARP, only supported in the 'lwIP' stack */
#define NETDEV_FLAG_ETHARP 0x08U
/* if set, the network interface device is an ethernet device, only supported in the 'lwIP' stack */
#define NETDEV_FLAG_ETHERNET 0x10U
/* if set, the network interface device has IGMP capability, only supported in the 'lwIP' stack */
#define NETDEV_FLAG_IGMP 0x20U
/* if set, the network interface device has MLD6 capability, only supported in the 'lwIP' stack */
#define NETDEV_FLAG_MLD6 0x40U
/* if set, the network interface device connected to internet successfully (set by the network interface driver) */
#define NETDEV_FLAG_INTERNET_UP 0x80U
/* if set, the network interface device has DHCP capability (set by the network interface device driver or application) */
#define NETDEV_FLAG_DHCP 0x100U
enum netdev_cb_type {
NETDEV_CB_ADDR_IP, /* IP address */
NETDEV_CB_ADDR_NETMASK, /* subnet mask */
NETDEV_CB_ADDR_GATEWAY, /* netmask */
NETDEV_CB_ADDR_DNS_SERVER, /* dns server */
NETDEV_CB_STATUS_UP, /* changed to 'up' */
NETDEV_CB_STATUS_DOWN, /* changed to 'down' */
NETDEV_CB_STATUS_LINK_UP, /* changed to 'link up' */
NETDEV_CB_STATUS_LINK_DOWN, /* changed to 'link down' */
NETDEV_CB_STATUS_INTERNET_UP, /* changed to 'internet up' */
NETDEV_CB_STATUS_INTERNET_DOWN, /* changed to 'internet down' */
NETDEV_CB_STATUS_DHCP_ENABLE, /* enable DHCP capability */
NETDEV_CB_STATUS_DHCP_DISABLE, /* disable DHCP capability */
NETDEV_CB_REGISTER, /* netdev register */
NETDEV_CB_DEFAULT_CHANGE, /* netdev default change */
};
struct netdev;
typedef void (*netdev_callback_fn)(struct netdev* netdev, enum netdev_cb_type type);
struct netdev_ops {
/* set network interface device hardware status operations */
int (*set_up)(struct netdev* netdev);
int (*set_down)(struct netdev* netdev);
/* set network interface device address information operations */
int (*set_addr_info)(struct netdev* netdev, ip_addr_t* ip_addr, ip_addr_t* netmask, ip_addr_t* gw);
int (*set_dns_server)(struct netdev* netdev, uint8_t dns_num, ip_addr_t* dns_server);
int (*set_dhcp)(struct netdev* netdev, bool is_enabled);
#ifdef RT_USING_FINSH
/* set network interface device common network interface device operations */
int (*ping)(struct netdev* netdev, const char* host, size_t data_len, uint32_t timeout, struct netdev_ping_resp* ping_resp);
void (*netstat)(struct netdev* netdev);
#endif
/* set default network interface device in current network stack*/
int (*set_default)(struct netdev* netdev);
};
/* network interface device object */
struct netdev {
SysSingleLinklistType list;
char name[NAME_NUM_MAX]; /* network interface device name */
ip_addr_t ip_addr; /* IP address */
ip_addr_t netmask; /* subnet mask */
ip_addr_t gw; /* gateway */
#if NETDEV_IPV6
ip_addr_t ip6_addr[NETDEV_IPV6_NUM_ADDRESSES]; /* array of IPv6 addresses */
#endif /* NETDEV_IPV6 */
ip_addr_t dns_servers[NETDEV_DNS_SERVERS_NUM]; /* DNS server */
uint8_t hwaddr_len; /* hardware address length */
uint8_t hwaddr[NETDEV_HWADDR_MAX_LEN]; /* hardware address */
uint16_t flags; /* network interface device status flag */
uint16_t mtu; /* maximum transfer unit (in bytes) */
const struct netdev_ops* ops; /* network interface device operations */
netdev_callback_fn status_callback; /* network interface device flags change callback */
netdev_callback_fn addr_callback; /* network interface device address information change callback */
#ifdef RT_USING_SAL
void* sal_user_data; /* user-specific data for SAL */
#endif /* RT_USING_SAL */
void* user_data; /* user-specific data */
};
// netdev global list
#define NETDEV_LISTHEAD (*get_netdev_listhead())
#define NETDEV_DEFAULT (*get_default_netdev())
extern struct netdev** get_netdev_listhead();
extern struct netdev** get_default_netdev();
// netdev register functions: netdev_register.c
int netdev_register(struct netdev* netdev, const char* name, void* user_data);
int netdev_unregister(struct netdev* netdev);
void netdev_set_default(struct netdev* netdev);
void netdev_set_register_callback(netdev_callback_fn status_callback);
void netdev_set_default_change_callback(netdev_callback_fn default_change_cb);
// netdev manipulate functions: netdev_manipulate.c
struct netdev* netdev_get_first_by_flags(uint16_t flags);
struct netdev* netdev_get_by_ipaddr(ip_addr_t* ip_addr);
struct netdev* netdev_get_by_name(const char* name);
int netdev_set_ipaddr(struct netdev* netdev, const ip_addr_t* ipaddr);
int netdev_set_netmask(struct netdev* netdev, const ip_addr_t* netmask);
int netdev_set_gw(struct netdev* netdev, const ip_addr_t* gw);
int netdev_set_dns_server(struct netdev* netdev, uint8_t dns_num, const ip_addr_t* dns_server);
void netdev_set_status_callback(struct netdev* netdev, netdev_callback_fn status_callback);
void netdev_set_addr_callback(struct netdev* netdev, netdev_callback_fn addr_callback);
/* Set network interface device status */
int netdev_set_up(struct netdev* netdev);
int netdev_set_down(struct netdev* netdev);
int netdev_dhcp_enabled(struct netdev* netdev, bool is_enabled);
// low level functions which should only be called by net drivers
void netdev_low_level_set_ipaddr(struct netdev* netdev, const ip_addr_t* ipaddr);
void netdev_low_level_set_netmask(struct netdev* netdev, const ip_addr_t* netmask);
void netdev_low_level_set_gw(struct netdev* netdev, const ip_addr_t* gw);
void netdev_low_level_set_dns_server(struct netdev* netdev, uint8_t dns_num, const ip_addr_t* dns_server);
void netdev_low_level_set_status(struct netdev* netdev, bool is_up);
void netdev_low_level_set_link_status(struct netdev* netdev, bool is_up);
void netdev_low_level_set_internet_status(struct netdev* netdev, bool is_up);
void netdev_low_level_set_dhcp_status(struct netdev* netdev, bool is_enable);
static inline bool netdev_is_dhcp_enabled(struct netdev* netdev)
{
return (netdev->flags & NETDEV_FLAG_DHCP) ? true : false;
}
static inline bool netdev_is_up(struct netdev* netdev)
{
return (netdev->flags & NETDEV_FLAG_UP) ? true : false;
}
static inline bool netdev_is_internet_up(struct netdev* netdev)
{
return (netdev->flags & NETDEV_FLAG_INTERNET_UP) ? true : false;
}
static inline bool netdev_is_link_up(struct netdev* netdev)
{
return (netdev->flags & NETDEV_FLAG_LINK_UP) ? true : false;
}
#ifdef __cplusplus
}
#endif
#endif

124
Ubiquitous/XiZi_IIoT/resources/include/netdev/netdev_ipaddr.h Normal file
View File

@ -0,0 +1,124 @@
#ifndef LWIP_HDR_IP4_ADDR_H
#ifndef __NETDEV_IPADDR_H__
#define __NETDEV_IPADDR_H__
#include <def.h>
#include <stdbool.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
// Currently using netdev ipv4
#define NETDEV_IPV4 1
/* IP address types for use in ip_addr_t.type member */
enum netdev_ip_addr_type {
/** IPv4 */
IPADDR_TYPE_V4 = 0U,
/** IPv6 */
IPADDR_TYPE_V6 = 6U,
/** IPv4+IPv6 ("dual-stack") */
IPADDR_TYPE_ANY = 46U
};
#if (NETDEV_IPV4 && NETDEV_IPV6) /* Both IPV4 and IPV6 */
// Todo
#elif NETDEV_IPV4 /* NETDEV_IPV4 */
#define IP_SET_TYPE_VAL(ipaddr, iptype)
#define IP_SET_TYPE(ipaddr, iptype)
#define IP_GET_TYPE(ipaddr) IPADDR_TYPE_V4
#define ip_addr_copy(dest, src) ip4_addr_copy(dest, src)
#define ip_addr_cmp(addr1, addr2) ip4_addr_cmp(addr1, addr2)
#define ip_addr_set(dest, src) ip4_addr_set(dest, src)
#define ip_addr_set_zero(ipaddr) ip4_addr_set_zero(ipaddr)
#define ip_addr_set_any(is_ipv6, ipaddr) ip4_addr_set_any(ipaddr)
#define ip_addr_isany_val(ipaddr) ip4_addr_isany_val(ipaddr)
#define ip_addr_isany(ipaddr) ip4_addr_isany(ipaddr)
/* directly map this to the lwip internal functions */
#define inet_addr(cp) netdev_ipaddr_addr(cp)
#define inet_aton(cp, addr) netdev_ip4addr_aton(cp, (ip4_addr_t*)addr)
#define inet_ntoa(addr) netdev_ip4addr_ntoa((const ip4_addr_t*)&(addr))
#define inet_ntoa_r(addr, buf, buflen) netdev_ip4addr_ntoa_r((const ip4_addr_t*)&(addr), buf, buflen)
#else /* NETDEV_IPV6 */
// Todo
#endif /* NTDEV_IPV4 && NTDEV_IPV6 */
#ifdef NETDEV_IPV4
/** IPv4 only: set the IP address given as an u32_t */
#define ip4_addr_set_u32(dest_ipaddr, src_u32) ((dest_ipaddr)->addr = (src_u32))
/** IPv4 only: get the IP address as an u32_t */
#define ip4_addr_get_u32(src_ipaddr) ((src_ipaddr)->addr)
/** 255.255.255.255 */
#define IPADDR_NONE ((uint32_t)0xffffffffUL)
/** 127.0.0.1 */
#define IPADDR_LOOPBACK ((uint32_t)0x7f000001UL)
/** 0.0.0.0 */
#define IPADDR_ANY ((uint32_t)0x00000000UL)
/** 255.255.255.255 */
#define IPADDR_BROADCAST ((uint32_t)0xffffffffUL)
#define IP4ADDR_STRLEN_MAX 16
#if !defined(in_addr_t) && !defined(IN_ADDR_T_DEFINED)
typedef uint32_t in_addr_t;
#endif
struct in_addr {
in_addr_t s_addr;
};
typedef struct ip4_addr {
uint32_t addr;
} ip4_addr_t;
typedef ip4_addr_t ip_addr_t;
/** Copy IP address - faster than ip4_addr_set: no NULL check */
static inline void ip4_addr_copy(ip4_addr_t dest_addr, const ip4_addr_t src_addr)
{
dest_addr.addr = src_addr.addr;
}
static inline bool ip4_addr_cmp(const ip4_addr_t* left_addr, const ip4_addr_t* right_addr)
{
return left_addr->addr == right_addr->addr;
}
/** Safely copy one IP address to another (src may be NULL) */
static inline void ip4_addr_set(ip4_addr_t* dest_addr, const ip4_addr_t* src_addr)
{
dest_addr->addr = (src_addr == NULL) ? 0 : src_addr->addr;
}
/** Set complete address to zero */
static inline void ip4_addr_set_zero(ip4_addr_t* ip4_addr)
{
ip4_addr->addr = 0;
}
/** Set address to IPADDR_ANY (no need for htonl()) */
static inline void ip4_addr_set_any(ip4_addr_t* ipaddr)
{
ipaddr->addr = IPADDR_ANY;
}
static inline bool ip4_addr_isany_val(const ip4_addr_t ipaddr)
{
return ipaddr.addr == IPADDR_ANY;
}
static inline bool ip4_addr_isany(const ip4_addr_t* ipaddr)
{
return ipaddr == NULL || ip4_addr_isany_val(*ipaddr);
}
#endif
#ifdef __cplusplus
}
#endif
#endif
#endif