forked from xuos/xiuos
Merge branch 'prepare_for_master' of https://git.trustie.net/xuos/xiuos into jerryscript
This commit is contained in:
wgzAIIT
commit
e8061577da
|
|
@ -324,7 +324,7 @@ void TestSocket(int argc, char* argv[])
|
|||
return;
|
||||
} else {
|
||||
memset(iperf_param.host, 0, sizeof(iperf_param.host));
|
||||
strncpy(iperf_param.host, ip_ptr, strlen(ip_ptr));
|
||||
strncpy(iperf_param.host, ip_ptr, sizeof(iperf_param.host));
|
||||
}
|
||||
iperf_mode->mode = IPERF_MODE_CLIENT;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -206,7 +206,7 @@ static int PrivLcdIoctl(int fd, int cmd, void *args)
|
|||
|
||||
int PrivIoctl(int fd, int cmd, void *args)
|
||||
{
|
||||
int ret;
|
||||
int ret = -ERROR;
|
||||
struct PrivIoctlCfg *ioctl_cfg = (struct PrivIoctlCfg *)args;
|
||||
switch (ioctl_cfg->ioctl_driver_type)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ int timer_create(clockid_t clockid, struct sigevent * evp, timer_t * timerid)
|
|||
}
|
||||
|
||||
memset(timer_name, 0, sizeof(timer_name));
|
||||
snprintf(timer_name, sizeof(timer_name), "timer_%d", clockid);
|
||||
snprintf(timer_name, sizeof(timer_name), "timer_%ld", clockid);
|
||||
|
||||
sem_init(&timer_sem, 0, 0);
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ menu "lib using MQTT"
|
|||
menu "MQTT connection parameter configuration."
|
||||
config PLATFORM_PRODUCTKEY
|
||||
string "Product Key, used to identify a product."
|
||||
default "iywhcgnuezz"
|
||||
default "iv74vebCdJC"
|
||||
|
||||
config CLIENT_DEVICENAME
|
||||
string "Device name, used to identify a client device."
|
||||
|
|
@ -18,7 +18,7 @@ menu "lib using MQTT"
|
|||
|
||||
config CLIENT_DEVICESECRET
|
||||
string "Device secret, used for device authentication and data encryption."
|
||||
default "c9a4ce03e9382065fc089e9ff54b771d"
|
||||
default "d2e613c4f714b6b0774bd7b68eeceae3"
|
||||
|
||||
config PLATFORM_SERVERIP
|
||||
string "mqtt platform server ip."
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
export CFLAGS := -mcmodel=medany -march=rv64imafdc -mabi=lp64d -fno-common -ffunction-sections -fdata-sections -fstrict-volatile-bitfields -O0 -ggdb -fgnu89-inline -Werror
|
||||
export CFLAGS := -mcmodel=medany -march=rv64imafdc -mabi=lp64d -fno-common -ffunction-sections -fdata-sections -fstrict-volatile-bitfields -O1 -fgnu89-inline -Wformat -Wuninitialized
|
||||
# export CFLAGS := -mcmodel=medany -march=rv64imafdc -mabi=lp64d -fno-common -ffunction-sections -fdata-sections -fstrict-volatile-bitfields -O0 -ggdb -fgnu89-inline -Werror -Wformat -Wuninitialized
|
||||
export AFLAGS := -c -mcmodel=medany -march=rv64imafdc -mabi=lp64d -x assembler-with-cpp -ggdb
|
||||
export LFLAGS := -mcmodel=medany -march=rv64imafdc -mabi=lp64d -nostartfiles -Wl,--gc-sections,-Map=XiZi-edu-riscv64.map,-cref,-u,_start -T $(BSP_ROOT)/link.lds
|
||||
|
||||
|
|
@ -19,7 +20,7 @@ export CXXFLAGS := -mcmodel=medany -march=rv64imafdc -mabi=lp64d -fno-common -ff
|
|||
export CROSS_COMPILE ?=/opt/gnu-mcu-eclipse/riscv-none-gcc/8.2.0-2.1-20190425-1021/bin/riscv-none-embed-
|
||||
|
||||
|
||||
export DEFINES := -DHAVE_CCONFIG_H -DHAVE_SIGINFO
|
||||
export DEFINES := -DHAVE_CCONFIG_H -DHAVE_SIGINFO -DRISCV_LWIP
|
||||
|
||||
export ARCH = risc-v
|
||||
export MCU = k210
|
||||
|
|
|
|||
|
|
@ -25,11 +25,12 @@
|
|||
#ifndef _BSP_ATOMIC_H
|
||||
#define _BSP_ATOMIC_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
#define SPINLOCK_INIT \
|
||||
{ \
|
||||
0 \
|
||||
|
|
@ -63,7 +64,7 @@ extern "C" {
|
|||
|
||||
typedef struct _spinlock
|
||||
{
|
||||
int lock;
|
||||
int32_t lock;
|
||||
} spinlock_t;
|
||||
|
||||
typedef struct _semaphore
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
config BSP_USING_W5500
|
||||
bool "Using w5500"
|
||||
select BSP_USING_LWIP
|
||||
default y
|
||||
|
||||
config BSP_WIZ_RST_PIN
|
||||
|
|
@ -15,3 +16,8 @@ config BSP_WIZ_INT_PIN
|
|||
config BSP_WIZ_USE_IPERF
|
||||
bool "Using iperf"
|
||||
default y
|
||||
|
||||
menuconfig BSP_USING_LWIP
|
||||
bool "Using LwIP device"
|
||||
default n
|
||||
select RESOURCES_LWIP
|
||||
|
|
@ -1,3 +1,4 @@
|
|||
SRC_FILES := socket.c connect_w5500.c w5500.c wizchip_conf.c spi_interface.c wiz_ping.c connect_w5500_test.c wiz_iperf.c
|
||||
# SRC_FILES := socket.c connect_w5500.c w5500.c wizchip_conf.c spi_interface.c wiz_ping.c connect_w5500_test.c wiz_iperf.c
|
||||
SRC_FILES := socket.c connect_w5500.c w5500.c wizchip_conf.c spi_interface.c wiz_ping.c connect_w5500_test.c w5x00_lwip.c wiz_iperf.c
|
||||
|
||||
include $(KERNEL_ROOT)/compiler.mk
|
||||
|
|
@ -5,8 +5,8 @@
|
|||
#include <dev_pin.h>
|
||||
#include <drv_io_config.h>
|
||||
#include <fpioa.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <xs_base.h>
|
||||
|
||||
#include "gpio_common.h"
|
||||
|
|
@ -14,6 +14,10 @@
|
|||
#include "socket.h"
|
||||
#include "w5500.h"
|
||||
|
||||
#include "connect_ethernet.h"
|
||||
|
||||
#include <sys.h>
|
||||
|
||||
#define SPI_LORA_FREQUENCY 10000000
|
||||
|
||||
// spi operations
|
||||
|
|
@ -23,26 +27,29 @@ extern void spi_select_cs(void);
|
|||
extern void spi_deselete_cs(void);
|
||||
|
||||
// global configurations for w5500 tcp connection
|
||||
uint32_t get_gbuf_size() {
|
||||
uint32_t get_gbuf_size()
|
||||
{
|
||||
static const uint32_t g_wiznet_buf_size = 2048;
|
||||
return g_wiznet_buf_size;
|
||||
}
|
||||
|
||||
wiz_NetInfo *get_gnetinfo() {
|
||||
static wiz_NetInfo g_wiz_netinfo = {.mac = {0x00, 0x08, 0xdc, 0x11, 0x11, 0x11},
|
||||
.ip = {192, 168, 130, 77},
|
||||
.sn = {255, 255, 254, 0},
|
||||
.gw = {192, 168, 130, 1},
|
||||
.dns = {0, 0, 0, 0},
|
||||
.dhcp = NETINFO_STATIC};
|
||||
wiz_NetInfo* get_gnetinfo()
|
||||
{
|
||||
static wiz_NetInfo g_wiz_netinfo = { .mac = { 0x00, 0x08, 0xdc, 0x11, 0x11, 0x11 },
|
||||
.ip = { 192, 168, 130, 77 },
|
||||
.sn = { 255, 255, 254, 0 },
|
||||
.gw = { 192, 168, 130, 1 },
|
||||
.dns = { 0, 0, 0, 0 },
|
||||
.dhcp = NETINFO_STATIC };
|
||||
return &g_wiz_netinfo;
|
||||
}
|
||||
|
||||
int network_init() {
|
||||
int network_init()
|
||||
{
|
||||
wiz_NetInfo check_wiz_netinfo;
|
||||
check_wiz_netinfo.dhcp = NETINFO_STATIC;
|
||||
ctlnetwork(CN_SET_NETINFO, (void *)get_gnetinfo());
|
||||
ctlnetwork(CN_GET_NETINFO, (void *)&check_wiz_netinfo);
|
||||
ctlnetwork(CN_SET_NETINFO, (void*)get_gnetinfo());
|
||||
ctlnetwork(CN_GET_NETINFO, (void*)&check_wiz_netinfo);
|
||||
|
||||
if (memcmp(get_gnetinfo(), &check_wiz_netinfo, sizeof(wiz_NetInfo)) != 0) {
|
||||
KPrintf(
|
||||
|
|
@ -57,8 +64,8 @@ int network_init() {
|
|||
return ERROR;
|
||||
}
|
||||
uint8_t tmpstr[6];
|
||||
ctlwizchip(CW_GET_ID, (void *)tmpstr);
|
||||
KPrintf("=== %s NET CONF ===\r\n", (char *)tmpstr);
|
||||
ctlwizchip(CW_GET_ID, (void*)tmpstr);
|
||||
KPrintf("=== %s NET CONF ===\r\n", (char*)tmpstr);
|
||||
KPrintf("MAC: %02X:%02X:%02X:%02X:%02X:%02X\r\n", get_gnetinfo()->mac[0],
|
||||
get_gnetinfo()->mac[1], get_gnetinfo()->mac[2], get_gnetinfo()->mac[3],
|
||||
get_gnetinfo()->mac[4], get_gnetinfo()->mac[5]);
|
||||
|
|
@ -76,13 +83,13 @@ int network_init() {
|
|||
}
|
||||
|
||||
/****************** spi init ******************/
|
||||
static struct Bus *w5500_spi_bus;
|
||||
int w5500_spi_init() {
|
||||
static struct Bus* w5500_spi_bus;
|
||||
int w5500_spi_init()
|
||||
{
|
||||
x_err_t ret = EOK;
|
||||
|
||||
w5500_spi_bus = BusFind(SPI_BUS_NAME_1);
|
||||
w5500_spi_bus->owner_haldev =
|
||||
BusFindDevice(w5500_spi_bus, SPI_1_DEVICE_NAME_0);
|
||||
w5500_spi_bus->owner_haldev = BusFindDevice(w5500_spi_bus, SPI_1_DEVICE_NAME_0);
|
||||
w5500_spi_bus->owner_driver = BusFindDriver(w5500_spi_bus, SPI_1_DRV_NAME);
|
||||
|
||||
w5500_spi_bus->match(w5500_spi_bus->owner_driver,
|
||||
|
|
@ -96,7 +103,7 @@ int w5500_spi_init() {
|
|||
spi_master_param.spi_data_endian = 0;
|
||||
|
||||
configure_info.configure_cmd = OPE_CFG;
|
||||
configure_info.private_data = (void *)&spi_master_param;
|
||||
configure_info.private_data = (void*)&spi_master_param;
|
||||
ret = BusDrvConfigure(w5500_spi_bus->owner_driver, &configure_info);
|
||||
if (ret) {
|
||||
KPrintf("spi drv OPE_CFG error drv %8p cfg %8p\n",
|
||||
|
|
@ -114,13 +121,16 @@ int w5500_spi_init() {
|
|||
return EOK;
|
||||
}
|
||||
|
||||
void spi_write_byte(uint8_t tx_data) {
|
||||
void spi_write_byte(uint8_t tx_data)
|
||||
{
|
||||
struct BusBlockWriteParam write_param;
|
||||
write_param.buffer = &tx_data;
|
||||
uint8_t data = tx_data;
|
||||
write_param.buffer = &data;
|
||||
write_param.size = 1;
|
||||
BusDevWriteData(w5500_spi_bus->owner_haldev, &write_param);
|
||||
}
|
||||
uint8_t spi_read_byte(void) {
|
||||
uint8_t spi_read_byte(void)
|
||||
{
|
||||
uint8_t result = 0;
|
||||
struct BusBlockReadParam read_param;
|
||||
read_param.buffer = &result;
|
||||
|
|
@ -128,13 +138,15 @@ uint8_t spi_read_byte(void) {
|
|||
BusDevReadData(w5500_spi_bus->owner_haldev, &read_param);
|
||||
return result;
|
||||
}
|
||||
void spi_write_burst(uint8_t *tx_buf, uint16_t len) {
|
||||
void spi_write_burst(uint8_t* tx_buf, uint16_t len)
|
||||
{
|
||||
struct BusBlockWriteParam write_param;
|
||||
write_param.buffer = tx_buf;
|
||||
write_param.size = len;
|
||||
BusDevWriteData(w5500_spi_bus->owner_haldev, &write_param);
|
||||
}
|
||||
void spi_read_burst(uint8_t *rx_buf, uint16_t len) {
|
||||
void spi_read_burst(uint8_t* rx_buf, uint16_t len)
|
||||
{
|
||||
struct BusBlockReadParam read_param;
|
||||
read_param.buffer = rx_buf;
|
||||
read_param.size = len;
|
||||
|
|
@ -143,7 +155,8 @@ void spi_read_burst(uint8_t *rx_buf, uint16_t len) {
|
|||
|
||||
/****************** chip init ******************/
|
||||
|
||||
void wiz_reset() {
|
||||
void wiz_reset()
|
||||
{
|
||||
gpiohs_set_drive_mode(WIZ_RST_PIN, GPIO_DM_OUTPUT);
|
||||
gpiohs_set_pin(WIZ_RST_PIN, GPIO_PV_LOW);
|
||||
MdelayKTask(20);
|
||||
|
|
@ -152,10 +165,10 @@ void wiz_reset() {
|
|||
MdelayKTask(20);
|
||||
}
|
||||
|
||||
void wiz_spi_handler_reg() {
|
||||
void wiz_spi_handler_reg()
|
||||
{
|
||||
// spi ops registration
|
||||
#if (_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_VDM_) || \
|
||||
(_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_FDM_)
|
||||
#if (_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_VDM_) || (_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_FDM_)
|
||||
/* register SPI device CS select callback function */
|
||||
gpiohs_set_drive_mode(SPI1_CS0_PIN, GPIO_DM_OUTPUT);
|
||||
reg_wizchip_cs_cbfunc(spi_select_cs, spi_deselete_cs);
|
||||
|
|
@ -172,11 +185,12 @@ void wiz_spi_handler_reg() {
|
|||
reg_wizchip_spiburst_cbfunc(spi_read_burst, spi_write_burst);
|
||||
}
|
||||
|
||||
int wiz_chip_cfg_init() {
|
||||
uint8_t mem_size[2][8] = {{2, 2, 2, 2, 2, 2, 2, 2}, {2, 2, 2, 2, 2, 2, 2, 2}};
|
||||
int wiz_chip_cfg_init()
|
||||
{
|
||||
uint8_t mem_size[2][8] = { { 2, 2, 2, 2, 2, 2, 2, 2 }, { 2, 2, 2, 2, 2, 2, 2, 2 } };
|
||||
|
||||
/* reset WIZnet chip internal PHY, configures PHY mode. */
|
||||
if (ctlwizchip(CW_INIT_WIZCHIP, (void *)mem_size) == -1) {
|
||||
if (ctlwizchip(CW_INIT_WIZCHIP, (void*)mem_size) == -1) {
|
||||
KPrintf("WIZCHIP initialize failed.");
|
||||
return ERROR;
|
||||
}
|
||||
|
|
@ -184,24 +198,77 @@ int wiz_chip_cfg_init() {
|
|||
struct wiz_NetTimeout_t net_timeout;
|
||||
net_timeout.retry_cnt = 5;
|
||||
net_timeout.time_100us = 20000;
|
||||
ctlnetwork(CN_SET_TIMEOUT, (void *)&net_timeout);
|
||||
ctlnetwork(CN_SET_TIMEOUT, (void*)&net_timeout);
|
||||
|
||||
return EOK;
|
||||
}
|
||||
|
||||
/****************** interrupt handle ******************/
|
||||
void wiz_irq_handler() {}
|
||||
#ifdef BSP_USING_LWIP
|
||||
#include <sys.h>
|
||||
static inline void spi_if_clr(void)
|
||||
{
|
||||
setSn_IR(0, 0x1F);
|
||||
setSIR(0);
|
||||
}
|
||||
|
||||
int wiz_interrupt_init() {
|
||||
void wiz_irq_handler()
|
||||
{
|
||||
static x_base eth_irq_lock;
|
||||
eth_irq_lock = DISABLE_INTERRUPT();
|
||||
|
||||
if (*get_eth_recv_sem() > 0) {
|
||||
sys_sem_signal(get_eth_recv_sem());
|
||||
}
|
||||
|
||||
ENABLE_INTERRUPT(eth_irq_lock);
|
||||
}
|
||||
#else
|
||||
void wiz_irq_handler()
|
||||
{
|
||||
static x_base eth_irq_lock;
|
||||
eth_irq_lock = DISABLE_INTERRUPT();
|
||||
|
||||
printf("=");
|
||||
uint8_t ir = getIR();
|
||||
setSIR(0x00);
|
||||
setIR(0x00);
|
||||
|
||||
ENABLE_INTERRUPT(eth_irq_lock);
|
||||
}
|
||||
#endif
|
||||
|
||||
void wizchip_interrupt_init(uint8_t socket, void (*callback)(void*))
|
||||
{
|
||||
int ret_val;
|
||||
|
||||
uint8_t reg_val1;
|
||||
reg_val1 = (SIK_CONNECTED | SIK_DISCONNECTED | SIK_RECEIVED | SIK_TIMEOUT); // except SendOK
|
||||
ret_val = wiz_ctlsocket(socket, CS_SET_INTMASK, (void*)®_val1);
|
||||
|
||||
#if (_WIZCHIP_ == W5100S)
|
||||
reg_val = (1 << socket);
|
||||
#elif (_WIZCHIP_ == W5500)
|
||||
uint16_t reg_val2 = ((1 << socket) << 8);
|
||||
#endif
|
||||
ret_val = ctlwizchip(CW_SET_INTRMASK, (void*)®_val2);
|
||||
|
||||
(void)ret_val;
|
||||
}
|
||||
|
||||
int wiz_interrupt_init()
|
||||
{
|
||||
int32_t ret = -ERROR;
|
||||
|
||||
struct Bus *pin_bus = PinBusInitGet();
|
||||
wizchip_interrupt_init(0, wiz_irq_handler);
|
||||
|
||||
struct Bus* pin_bus = PinBusInitGet();
|
||||
|
||||
struct PinParam pin_param;
|
||||
struct BusConfigureInfo pin_configure_info;
|
||||
|
||||
pin_configure_info.configure_cmd = OPE_CFG;
|
||||
pin_configure_info.private_data = (void *)&pin_param;
|
||||
pin_configure_info.private_data = (void*)&pin_param;
|
||||
|
||||
pin_param.cmd = GPIO_CONFIG_MODE;
|
||||
pin_param.pin = BSP_WIZ_INT_PIN;
|
||||
|
|
@ -241,11 +308,10 @@ int wiz_interrupt_init() {
|
|||
}
|
||||
|
||||
return EOK;
|
||||
|
||||
return EOK;
|
||||
}
|
||||
|
||||
int HwWiznetInit(void) {
|
||||
int HwWiznetInit(void)
|
||||
{
|
||||
wiz_reset();
|
||||
|
||||
if (EOK != w5500_spi_init()) {
|
||||
|
|
@ -258,6 +324,31 @@ int HwWiznetInit(void) {
|
|||
return ERROR;
|
||||
}
|
||||
|
||||
extern uint8_t wiz_mac[6];
|
||||
setSHAR(wiz_mac);
|
||||
ctlwizchip(CW_RESET_PHY, 0);
|
||||
|
||||
wiz_interrupt_init(0, wiz_irq_handler);
|
||||
|
||||
setSn_RXBUF_SIZE(0, 16);
|
||||
setSn_TXBUF_SIZE(0, 16);
|
||||
#define SOCK_ANY_PORT_NUM 0xC000
|
||||
setSn_MR(0, Sn_MR_MFEN | Sn_MR_MACRAW | Sn_MR_MIP6B | Sn_MR_MMB);
|
||||
wiz_socket(0, Sn_MR_MACRAW, SOCK_ANY_PORT_NUM, SOCK_IO_NONBLOCK);
|
||||
|
||||
uint8_t sock_iomode = SOCK_IO_NONBLOCK;
|
||||
wiz_ctlsocket(0, CS_SET_IOMODE, &sock_iomode);
|
||||
|
||||
uint8_t sock_sr = 0;
|
||||
while (1) {
|
||||
sock_sr = getSn_SR(0);
|
||||
SYS_KDEBUG_LOG(WIZNET_DEBUG, ("[%s] sock_sr: %x, MACRAW: %x\n", __func__, sock_sr, SOCK_MACRAW));
|
||||
if (sock_sr == SOCK_MACRAW) {
|
||||
SYS_KDEBUG_LOG(WIZNET_DEBUG, ("Socket 0 MACRAW mode established\r\n"));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
network_init();
|
||||
|
||||
return EOK;
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@
|
|||
#include "wizchip_conf.h"
|
||||
|
||||
// M20150401 : Typing Error
|
||||
//#define SOCK_ANY_PORT_NUM 0xC000;
|
||||
// #define SOCK_ANY_PORT_NUM 0xC000;
|
||||
#define SOCK_ANY_PORT_NUM 0xC000
|
||||
|
||||
static uint16_t sock_any_port = SOCK_ANY_PORT_NUM;
|
||||
|
|
@ -96,25 +96,30 @@ uint8_t sock_remained_byte[_WIZCHIP_SOCK_NUM_] = {
|
|||
|
||||
#define CHECK_SOCKNUM() \
|
||||
do { \
|
||||
if (sn > _WIZCHIP_SOCK_NUM_) return SOCKERR_SOCKNUM; \
|
||||
if (sn > _WIZCHIP_SOCK_NUM_) \
|
||||
return SOCKERR_SOCKNUM; \
|
||||
} while (0);
|
||||
|
||||
#define CHECK_SOCKMODE(mode) \
|
||||
do { \
|
||||
if ((getSn_MR(sn) & 0x0F) != mode) return SOCKERR_SOCKMODE; \
|
||||
if ((getSn_MR(sn) & 0x0F) != mode) \
|
||||
return SOCKERR_SOCKMODE; \
|
||||
} while (0);
|
||||
|
||||
#define CHECK_SOCKINIT() \
|
||||
do { \
|
||||
if ((getSn_SR(sn) != SOCK_INIT)) return SOCKERR_SOCKINIT; \
|
||||
if ((getSn_SR(sn) != SOCK_INIT)) \
|
||||
return SOCKERR_SOCKINIT; \
|
||||
} while (0);
|
||||
|
||||
#define CHECK_SOCKDATA() \
|
||||
do { \
|
||||
if (len == 0) return SOCKERR_DATALEN; \
|
||||
if (len == 0) \
|
||||
return SOCKERR_DATALEN; \
|
||||
} while (0);
|
||||
|
||||
int8_t wiz_socket(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag) {
|
||||
int8_t wiz_socket(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag)
|
||||
{
|
||||
CHECK_SOCKNUM();
|
||||
switch (protocol) {
|
||||
case Sn_MR_TCP: {
|
||||
|
|
@ -124,8 +129,9 @@ int8_t wiz_socket(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag) {
|
|||
getSIPR(taddr);
|
||||
*/
|
||||
uint32_t taddr;
|
||||
getSIPR((uint8_t *)&taddr);
|
||||
if (taddr == 0) return SOCKERR_SOCKINIT;
|
||||
getSIPR((uint8_t*)&taddr);
|
||||
if (taddr == 0)
|
||||
return SOCKERR_SOCKINIT;
|
||||
break;
|
||||
}
|
||||
case Sn_MR_UDP:
|
||||
|
|
@ -141,9 +147,11 @@ int8_t wiz_socket(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag) {
|
|||
}
|
||||
// M20150601 : For SF_TCP_ALIGN & W5300
|
||||
// if((flag & 0x06) != 0) return SOCKERR_SOCKFLAG;
|
||||
if ((flag & 0x04) != 0) return SOCKERR_SOCKFLAG;
|
||||
if ((flag & 0x04) != 0)
|
||||
return SOCKERR_SOCKFLAG;
|
||||
#if _WIZCHIP_ == 5200
|
||||
if (flag & 0x10) return SOCKERR_SOCKFLAG;
|
||||
if (flag & 0x10)
|
||||
return SOCKERR_SOCKFLAG;
|
||||
#endif
|
||||
|
||||
if (flag != 0) {
|
||||
|
|
@ -161,11 +169,13 @@ int8_t wiz_socket(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag) {
|
|||
break;
|
||||
case Sn_MR_UDP:
|
||||
if (flag & SF_IGMP_VER2) {
|
||||
if ((flag & SF_MULTI_ENABLE) == 0) return SOCKERR_SOCKFLAG;
|
||||
if ((flag & SF_MULTI_ENABLE) == 0)
|
||||
return SOCKERR_SOCKFLAG;
|
||||
}
|
||||
#if _WIZCHIP_ == 5500
|
||||
if (flag & SF_UNI_BLOCK) {
|
||||
if ((flag & SF_MULTI_ENABLE) == 0) return SOCKERR_SOCKFLAG;
|
||||
if ((flag & SF_MULTI_ENABLE) == 0)
|
||||
return SOCKERR_SOCKFLAG;
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
|
|
@ -176,14 +186,14 @@ int8_t wiz_socket(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag) {
|
|||
wiz_sock_close(sn);
|
||||
// M20150601
|
||||
#if _WIZCHIP_ == 5300
|
||||
setSn_MR(sn, ((uint16_t)(protocol | (flag & 0xF0))) |
|
||||
(((uint16_t)(flag & 0x02)) << 7));
|
||||
setSn_MR(sn, ((uint16_t)(protocol | (flag & 0xF0))) | (((uint16_t)(flag & 0x02)) << 7));
|
||||
#else
|
||||
setSn_MR(sn, (protocol | (flag & 0xF0)));
|
||||
#endif
|
||||
if (!port) {
|
||||
port = sock_any_port++;
|
||||
if (sock_any_port == 0xFFF0) sock_any_port = SOCK_ANY_PORT_NUM;
|
||||
if (sock_any_port == 0xFFF0)
|
||||
sock_any_port = SOCK_ANY_PORT_NUM;
|
||||
}
|
||||
setSn_PORT(sn, port);
|
||||
setSn_CR(sn, Sn_CR_OPEN);
|
||||
|
|
@ -204,16 +214,16 @@ int8_t wiz_socket(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag) {
|
|||
return (int8_t)sn;
|
||||
}
|
||||
|
||||
int8_t wiz_sock_close(uint8_t sn) {
|
||||
int8_t wiz_sock_close(uint8_t sn)
|
||||
{
|
||||
CHECK_SOCKNUM();
|
||||
// A20160426 : Applied the erratum 1 of W5300
|
||||
#if (_WIZCHIP_ == 5300)
|
||||
// M20160503 : Wrong socket parameter. s -> sn
|
||||
// if( ((getSn_MR(s)& 0x0F) == Sn_MR_TCP) && (getSn_TX_FSR(s) !=
|
||||
// getSn_TxMAX(s)) )
|
||||
if (((getSn_MR(sn) & 0x0F) == Sn_MR_TCP) &&
|
||||
(getSn_TX_FSR(sn) != getSn_TxMAX(sn))) {
|
||||
uint8_t destip[4] = {0, 0, 0, 1};
|
||||
if (((getSn_MR(sn) & 0x0F) == Sn_MR_TCP) && (getSn_TX_FSR(sn) != getSn_TxMAX(sn))) {
|
||||
uint8_t destip[4] = { 0, 0, 0, 1 };
|
||||
// TODO
|
||||
// You can wait for completing to sending data;
|
||||
// wait about 1 second;
|
||||
|
|
@ -255,7 +265,8 @@ int8_t wiz_sock_close(uint8_t sn) {
|
|||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int8_t wiz_sock_listen(uint8_t sn) {
|
||||
int8_t wiz_sock_listen(uint8_t sn)
|
||||
{
|
||||
CHECK_SOCKNUM();
|
||||
CHECK_SOCKMODE(Sn_MR_TCP);
|
||||
CHECK_SOCKINIT();
|
||||
|
|
@ -269,7 +280,8 @@ int8_t wiz_sock_listen(uint8_t sn) {
|
|||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int8_t wiz_sock_connect(uint8_t sn, uint8_t *addr, uint16_t port) {
|
||||
int8_t wiz_sock_connect(uint8_t sn, uint8_t* addr, uint16_t port)
|
||||
{
|
||||
CHECK_SOCKNUM();
|
||||
CHECK_SOCKMODE(Sn_MR_TCP);
|
||||
CHECK_SOCKINIT();
|
||||
|
|
@ -282,17 +294,20 @@ int8_t wiz_sock_connect(uint8_t sn, uint8_t *addr, uint16_t port) {
|
|||
taddr = (taddr << 8) + ((uint32_t)addr[1] & 0x000000FF);
|
||||
taddr = (taddr << 8) + ((uint32_t)addr[2] & 0x000000FF);
|
||||
taddr = (taddr << 8) + ((uint32_t)addr[3] & 0x000000FF);
|
||||
if (taddr == 0xFFFFFFFF || taddr == 0) return SOCKERR_IPINVALID;
|
||||
if (taddr == 0xFFFFFFFF || taddr == 0)
|
||||
return SOCKERR_IPINVALID;
|
||||
}
|
||||
//
|
||||
|
||||
if (port == 0) return SOCKERR_PORTZERO;
|
||||
if (port == 0)
|
||||
return SOCKERR_PORTZERO;
|
||||
setSn_DIPR(sn, addr);
|
||||
setSn_DPORT(sn, port);
|
||||
setSn_CR(sn, Sn_CR_CONNECT);
|
||||
while (getSn_CR(sn))
|
||||
;
|
||||
if (sock_io_mode & (1 << sn)) return SOCK_BUSY;
|
||||
if (sock_io_mode & (1 << sn))
|
||||
return SOCK_BUSY;
|
||||
while (getSn_SR(sn) != SOCK_ESTABLISHED) {
|
||||
if (getSn_IR(sn) & Sn_IR_TIMEOUT) {
|
||||
setSn_IR(sn, Sn_IR_TIMEOUT);
|
||||
|
|
@ -307,7 +322,8 @@ int8_t wiz_sock_connect(uint8_t sn, uint8_t *addr, uint16_t port) {
|
|||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int8_t wiz_sock_disconnect(uint8_t sn) {
|
||||
int8_t wiz_sock_disconnect(uint8_t sn)
|
||||
{
|
||||
CHECK_SOCKNUM();
|
||||
CHECK_SOCKMODE(Sn_MR_TCP);
|
||||
setSn_CR(sn, Sn_CR_DISCON);
|
||||
|
|
@ -315,7 +331,8 @@ int8_t wiz_sock_disconnect(uint8_t sn) {
|
|||
while (getSn_CR(sn))
|
||||
;
|
||||
sock_is_sending &= ~(1 << sn);
|
||||
if (sock_io_mode & (1 << sn)) return SOCK_BUSY;
|
||||
if (sock_io_mode & (1 << sn))
|
||||
return SOCK_BUSY;
|
||||
while (getSn_SR(sn) != SOCK_CLOSED) {
|
||||
if (getSn_IR(sn) & Sn_IR_TIMEOUT) {
|
||||
wiz_sock_close(sn);
|
||||
|
|
@ -325,7 +342,8 @@ int8_t wiz_sock_disconnect(uint8_t sn) {
|
|||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int32_t wiz_sock_send(uint8_t sn, uint8_t *buf, uint16_t len) {
|
||||
int32_t wiz_sock_send(uint8_t sn, uint8_t* buf, uint16_t len)
|
||||
{
|
||||
uint8_t tmp = 0;
|
||||
uint16_t freesize = 0;
|
||||
|
||||
|
|
@ -340,7 +358,7 @@ int32_t wiz_sock_send(uint8_t sn, uint8_t *buf, uint16_t len) {
|
|||
if (tmp & Sn_IR_SENDOK) {
|
||||
setSn_IR(sn, Sn_IR_SENDOK);
|
||||
// M20150401 : Typing Error
|
||||
//#if _WZICHIP_ == 5200
|
||||
// #if _WZICHIP_ == 5200
|
||||
#if _WIZCHIP_ == 5200
|
||||
if (getSn_TX_RD(sn) != sock_next_rd[sn]) {
|
||||
setSn_CR(sn, Sn_CR_SEND);
|
||||
|
|
@ -357,7 +375,9 @@ int32_t wiz_sock_send(uint8_t sn, uint8_t *buf, uint16_t len) {
|
|||
return SOCK_BUSY;
|
||||
}
|
||||
freesize = getSn_TxMAX(sn);
|
||||
if (len > freesize) len = freesize; // check size not to exceed MAX size.
|
||||
if (len > freesize)
|
||||
len = freesize; // check size not to exceed MAX size.
|
||||
|
||||
while (1) {
|
||||
freesize = getSn_TX_FSR(sn);
|
||||
tmp = getSn_SR(sn);
|
||||
|
|
@ -365,8 +385,10 @@ int32_t wiz_sock_send(uint8_t sn, uint8_t *buf, uint16_t len) {
|
|||
wiz_sock_close(sn);
|
||||
return SOCKERR_SOCKSTATUS;
|
||||
}
|
||||
if ((sock_io_mode & (1 << sn)) && (len > freesize)) return SOCK_BUSY;
|
||||
if (len <= freesize) break;
|
||||
if ((sock_io_mode & (1 << sn)) && (len > freesize))
|
||||
return SOCK_BUSY;
|
||||
if (len <= freesize)
|
||||
break;
|
||||
}
|
||||
wiz_send_data(sn, buf, len);
|
||||
#if _WIZCHIP_ == 5200
|
||||
|
|
@ -387,7 +409,8 @@ int32_t wiz_sock_send(uint8_t sn, uint8_t *buf, uint16_t len) {
|
|||
return (int32_t)len;
|
||||
}
|
||||
|
||||
int32_t wiz_sock_recv(uint8_t sn, uint8_t *buf, uint16_t len) {
|
||||
int32_t wiz_sock_recv(uint8_t sn, uint8_t* buf, uint16_t len)
|
||||
{
|
||||
uint8_t tmp = 0;
|
||||
uint16_t recvsize = 0;
|
||||
// A20150601 : For integarating with W5300
|
||||
|
|
@ -401,7 +424,8 @@ int32_t wiz_sock_recv(uint8_t sn, uint8_t *buf, uint16_t len) {
|
|||
CHECK_SOCKDATA();
|
||||
|
||||
recvsize = getSn_RxMAX(sn);
|
||||
if (recvsize < len) len = recvsize;
|
||||
if (recvsize < len)
|
||||
len = recvsize;
|
||||
|
||||
// A20150601 : For Integrating with W5300
|
||||
#if _WIZCHIP_ == 5300
|
||||
|
|
@ -425,8 +449,10 @@ int32_t wiz_sock_recv(uint8_t sn, uint8_t *buf, uint16_t len) {
|
|||
return SOCKERR_SOCKSTATUS;
|
||||
}
|
||||
}
|
||||
if ((sock_io_mode & (1 << sn)) && (recvsize == 0)) return SOCK_BUSY;
|
||||
if (recvsize != 0) break;
|
||||
if ((sock_io_mode & (1 << sn)) && (recvsize == 0))
|
||||
return SOCK_BUSY;
|
||||
if (recvsize != 0)
|
||||
break;
|
||||
};
|
||||
#if _WIZCHIP_ == 5300
|
||||
}
|
||||
|
|
@ -446,7 +472,8 @@ int32_t wiz_sock_recv(uint8_t sn, uint8_t *buf, uint16_t len) {
|
|||
}
|
||||
sock_remained_size[sn] = recvsize;
|
||||
}
|
||||
if (len > sock_remained_size[sn]) len = sock_remained_size[sn];
|
||||
if (len > sock_remained_size[sn])
|
||||
len = sock_remained_size[sn];
|
||||
recvsize = len;
|
||||
if (sock_pack_info[sn] & PACK_FIFOBYTE) {
|
||||
*buf = sock_remained_byte[sn];
|
||||
|
|
@ -464,13 +491,16 @@ int32_t wiz_sock_recv(uint8_t sn, uint8_t *buf, uint16_t len) {
|
|||
sock_remained_size[sn] -= recvsize;
|
||||
if (sock_remained_size[sn] != 0) {
|
||||
sock_pack_info[sn] |= PACK_REMAINED;
|
||||
if (recvsize & 0x1) sock_pack_info[sn] |= PACK_FIFOBYTE;
|
||||
if (recvsize & 0x1)
|
||||
sock_pack_info[sn] |= PACK_FIFOBYTE;
|
||||
} else
|
||||
sock_pack_info[sn] = PACK_COMPLETED;
|
||||
if (getSn_MR(sn) & Sn_MR_ALIGN) sock_remained_size[sn] = 0;
|
||||
if (getSn_MR(sn) & Sn_MR_ALIGN)
|
||||
sock_remained_size[sn] = 0;
|
||||
// len = recvsize;
|
||||
#else
|
||||
if (recvsize < len) len = recvsize;
|
||||
if (recvsize < len)
|
||||
len = recvsize;
|
||||
wiz_recv_data(sn, buf, len);
|
||||
setSn_CR(sn, Sn_CR_RECV);
|
||||
while (getSn_CR(sn))
|
||||
|
|
@ -482,8 +512,11 @@ int32_t wiz_sock_recv(uint8_t sn, uint8_t *buf, uint16_t len) {
|
|||
return (int32_t)len;
|
||||
}
|
||||
|
||||
int32_t wiz_sock_sendto(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr,
|
||||
uint16_t port) {
|
||||
#include <xizi.h>
|
||||
#include <xs_kdbg.h>
|
||||
int32_t wiz_sock_sendto(uint8_t sn, uint8_t* buf, uint16_t len, uint8_t* addr,
|
||||
uint16_t port)
|
||||
{
|
||||
uint8_t tmp = 0;
|
||||
uint16_t freesize = 0;
|
||||
uint32_t taddr;
|
||||
|
|
@ -517,30 +550,34 @@ int32_t wiz_sock_sendto(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr,
|
|||
if ((port == 0) && ((getSn_MR(sn) & Sn_MR_MACRAW) != Sn_MR_MACRAW))
|
||||
return SOCKERR_PORTZERO;
|
||||
tmp = getSn_SR(sn);
|
||||
//#if ( _WIZCHIP_ < 5200 )
|
||||
// #if ( _WIZCHIP_ < 5200 )
|
||||
if ((tmp != SOCK_MACRAW) && (tmp != SOCK_UDP) && (tmp != SOCK_IPRAW))
|
||||
return SOCKERR_SOCKSTATUS;
|
||||
//#else
|
||||
// #else
|
||||
// if(tmp != SOCK_MACRAW && tmp != SOCK_UDP) return SOCKERR_SOCKSTATUS;
|
||||
//#endif
|
||||
// #endif
|
||||
|
||||
setSn_DIPR(sn, addr);
|
||||
setSn_DPORT(sn, port);
|
||||
freesize = getSn_TxMAX(sn);
|
||||
if (len > freesize) len = freesize; // check size not to exceed MAX size.
|
||||
if (len > freesize)
|
||||
len = freesize; // check size not to exceed MAX size.
|
||||
while (1) {
|
||||
freesize = getSn_TX_FSR(sn);
|
||||
if (getSn_SR(sn) == SOCK_CLOSED) return SOCKERR_SOCKCLOSED;
|
||||
if ((sock_io_mode & (1 << sn)) && (len > freesize)) return SOCK_BUSY;
|
||||
if (len <= freesize) break;
|
||||
if (getSn_SR(sn) == SOCK_CLOSED)
|
||||
return SOCKERR_SOCKCLOSED;
|
||||
if ((sock_io_mode & (1 << sn)) && (len > freesize))
|
||||
return SOCK_BUSY;
|
||||
if (len <= freesize)
|
||||
break;
|
||||
};
|
||||
wiz_send_data(sn, buf, len);
|
||||
|
||||
#if _WIZCHIP_ < 5500 // M20150401 : for WIZCHIP Errata #4, #5 (ARP errata)
|
||||
getSIPR((uint8_t *)&taddr);
|
||||
getSIPR((uint8_t*)&taddr);
|
||||
if (taddr == 0) {
|
||||
getSUBR((uint8_t *)&taddr);
|
||||
setSUBR((uint8_t *)"\x00\x00\x00\x00");
|
||||
getSUBR((uint8_t*)&taddr);
|
||||
setSUBR((uint8_t*)"\x00\x00\x00\x00");
|
||||
} else
|
||||
taddr = 0;
|
||||
#endif
|
||||
|
|
@ -556,6 +593,7 @@ int32_t wiz_sock_sendto(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr,
|
|||
;
|
||||
while (1) {
|
||||
tmp = getSn_IR(sn);
|
||||
// SYS_KDEBUG_LOG(WIZNET_DEBUG, ("[%s] %d, tmp: %x\n", __func__, __LINE__, tmp));
|
||||
if (tmp & Sn_IR_SENDOK) {
|
||||
setSn_IR(sn, Sn_IR_SENDOK);
|
||||
break;
|
||||
|
|
@ -568,22 +606,25 @@ int32_t wiz_sock_sendto(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr,
|
|||
// len = (uint16_t)SOCKERR_TIMEOUT;
|
||||
// break;
|
||||
#if _WIZCHIP_ < 5500 // M20150401 : for WIZCHIP Errata #4, #5 (ARP errata)
|
||||
if (taddr) setSUBR((uint8_t *)&taddr);
|
||||
if (taddr)
|
||||
setSUBR((uint8_t*)&taddr);
|
||||
#endif
|
||||
return SOCKERR_TIMEOUT;
|
||||
}
|
||||
////////////
|
||||
}
|
||||
#if _WIZCHIP_ < 5500 // M20150401 : for WIZCHIP Errata #4, #5 (ARP errata)
|
||||
if (taddr) setSUBR((uint8_t *)&taddr);
|
||||
if (taddr)
|
||||
setSUBR((uint8_t*)&taddr);
|
||||
#endif
|
||||
// M20150409 : Explicit Type Casting
|
||||
// return len;
|
||||
return (int32_t)len;
|
||||
}
|
||||
|
||||
int32_t wiz_sock_recvfrom(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr,
|
||||
uint16_t *port) {
|
||||
int32_t wiz_sock_recvfrom(uint8_t sn, uint8_t* buf, uint16_t len, uint8_t* addr,
|
||||
uint16_t* port)
|
||||
{
|
||||
// M20150601 : For W5300
|
||||
#if _WIZCHIP_ == 5300
|
||||
uint16_t mr;
|
||||
|
|
@ -618,9 +659,12 @@ int32_t wiz_sock_recvfrom(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr,
|
|||
if (sock_remained_size[sn] == 0) {
|
||||
while (1) {
|
||||
pack_len = getSn_RX_RSR(sn);
|
||||
if (getSn_SR(sn) == SOCK_CLOSED) return SOCKERR_SOCKCLOSED;
|
||||
if ((sock_io_mode & (1 << sn)) && (pack_len == 0)) return SOCK_BUSY;
|
||||
if (pack_len != 0) break;
|
||||
if (getSn_SR(sn) == SOCK_CLOSED)
|
||||
return SOCKERR_SOCKCLOSED;
|
||||
if ((sock_io_mode & (1 << sn)) && (pack_len == 0))
|
||||
return SOCK_BUSY;
|
||||
if (pack_len != 0)
|
||||
break;
|
||||
};
|
||||
}
|
||||
// D20150601 : Move it to bottom
|
||||
|
|
@ -705,7 +749,7 @@ int32_t wiz_sock_recvfrom(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr,
|
|||
pack_len = sock_remained_size[sn];
|
||||
wiz_recv_data(sn, buf, pack_len);
|
||||
break;
|
||||
//#if ( _WIZCHIP_ < 5200 )
|
||||
// #if ( _WIZCHIP_ < 5200 )
|
||||
case Sn_MR_IPRAW:
|
||||
if (sock_remained_size[sn] == 0) {
|
||||
wiz_recv_data(sn, head, 6);
|
||||
|
|
@ -731,7 +775,7 @@ int32_t wiz_sock_recvfrom(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr,
|
|||
pack_len = sock_remained_size[sn];
|
||||
wiz_recv_data(sn, buf, pack_len); // data copy.
|
||||
break;
|
||||
//#endif
|
||||
// #endif
|
||||
default:
|
||||
wiz_recv_ignore(sn, pack_len); // data copy.
|
||||
sock_remained_size[sn] = pack_len;
|
||||
|
|
@ -747,7 +791,8 @@ int32_t wiz_sock_recvfrom(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr,
|
|||
if (sock_remained_size[sn] != 0) {
|
||||
sock_pack_info[sn] |= PACK_REMAINED;
|
||||
#if _WIZCHIP_ == 5300
|
||||
if (pack_len & 0x01) sock_pack_info[sn] |= PACK_FIFOBYTE;
|
||||
if (pack_len & 0x01)
|
||||
sock_pack_info[sn] |= PACK_FIFOBYTE;
|
||||
#endif
|
||||
} else
|
||||
sock_pack_info[sn] = PACK_COMPLETED;
|
||||
|
|
@ -760,12 +805,13 @@ int32_t wiz_sock_recvfrom(uint8_t sn, uint8_t *buf, uint16_t len, uint8_t *addr,
|
|||
return (int32_t)pack_len;
|
||||
}
|
||||
|
||||
int8_t wiz_ctlsocket(uint8_t sn, ctlsock_type cstype, void *arg) {
|
||||
int8_t wiz_ctlsocket(uint8_t sn, ctlsock_type cstype, void* arg)
|
||||
{
|
||||
uint8_t tmp = 0;
|
||||
CHECK_SOCKNUM();
|
||||
switch (cstype) {
|
||||
case CS_SET_IOMODE:
|
||||
tmp = *((uint8_t *)arg);
|
||||
tmp = *((uint8_t*)arg);
|
||||
if (tmp == SOCK_IO_NONBLOCK)
|
||||
sock_io_mode |= (1 << sn);
|
||||
else if (tmp == SOCK_IO_BLOCK)
|
||||
|
|
@ -776,29 +822,31 @@ int8_t wiz_ctlsocket(uint8_t sn, ctlsock_type cstype, void *arg) {
|
|||
case CS_GET_IOMODE:
|
||||
// M20140501 : implict type casting -> explict type casting
|
||||
//*((uint8_t*)arg) = (sock_io_mode >> sn) & 0x0001;
|
||||
*((uint8_t *)arg) = (uint8_t)((sock_io_mode >> sn) & 0x0001);
|
||||
*((uint8_t*)arg) = (uint8_t)((sock_io_mode >> sn) & 0x0001);
|
||||
//
|
||||
break;
|
||||
case CS_GET_MAXTXBUF:
|
||||
*((uint16_t *)arg) = getSn_TxMAX(sn);
|
||||
*((uint16_t*)arg) = getSn_TxMAX(sn);
|
||||
break;
|
||||
case CS_GET_MAXRXBUF:
|
||||
*((uint16_t *)arg) = getSn_RxMAX(sn);
|
||||
*((uint16_t*)arg) = getSn_RxMAX(sn);
|
||||
break;
|
||||
case CS_CLR_INTERRUPT:
|
||||
if ((*(uint8_t *)arg) > SIK_ALL) return SOCKERR_ARG;
|
||||
setSn_IR(sn, *(uint8_t *)arg);
|
||||
if ((*(uint8_t*)arg) > SIK_ALL)
|
||||
return SOCKERR_ARG;
|
||||
setSn_IR(sn, *(uint8_t*)arg);
|
||||
break;
|
||||
case CS_GET_INTERRUPT:
|
||||
*((uint8_t *)arg) = getSn_IR(sn);
|
||||
*((uint8_t*)arg) = getSn_IR(sn);
|
||||
break;
|
||||
#if _WIZCHIP_ != 5100
|
||||
case CS_SET_INTMASK:
|
||||
if ((*(uint8_t *)arg) > SIK_ALL) return SOCKERR_ARG;
|
||||
setSn_IMR(sn, *(uint8_t *)arg);
|
||||
if ((*(uint8_t*)arg) > SIK_ALL)
|
||||
return SOCKERR_ARG;
|
||||
setSn_IMR(sn, *(uint8_t*)arg);
|
||||
break;
|
||||
case CS_GET_INTMASK:
|
||||
*((uint8_t *)arg) = getSn_IMR(sn);
|
||||
*((uint8_t*)arg) = getSn_IMR(sn);
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
|
|
@ -807,31 +855,33 @@ int8_t wiz_ctlsocket(uint8_t sn, ctlsock_type cstype, void *arg) {
|
|||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int8_t wiz_setsockopt(uint8_t sn, sockopt_type sotype, void *arg) {
|
||||
int8_t wiz_setsockopt(uint8_t sn, sockopt_type sotype, void* arg)
|
||||
{
|
||||
// M20131220 : Remove warning
|
||||
// uint8_t tmp;
|
||||
CHECK_SOCKNUM();
|
||||
switch (sotype) {
|
||||
case SO_TTL:
|
||||
setSn_TTL(sn, *(uint8_t *)arg);
|
||||
setSn_TTL(sn, *(uint8_t*)arg);
|
||||
break;
|
||||
case SO_TOS:
|
||||
setSn_TOS(sn, *(uint8_t *)arg);
|
||||
setSn_TOS(sn, *(uint8_t*)arg);
|
||||
break;
|
||||
case SO_MSS:
|
||||
setSn_MSSR(sn, *(uint16_t *)arg);
|
||||
setSn_MSSR(sn, *(uint16_t*)arg);
|
||||
break;
|
||||
case SO_DESTIP:
|
||||
setSn_DIPR(sn, (uint8_t *)arg);
|
||||
setSn_DIPR(sn, (uint8_t*)arg);
|
||||
break;
|
||||
case SO_DESTPORT:
|
||||
setSn_DPORT(sn, *(uint16_t *)arg);
|
||||
setSn_DPORT(sn, *(uint16_t*)arg);
|
||||
break;
|
||||
#if _WIZCHIP_ != 5100
|
||||
case SO_KEEPALIVESEND:
|
||||
CHECK_SOCKMODE(Sn_MR_TCP);
|
||||
#if _WIZCHIP_ > 5200
|
||||
if (getSn_KPALVTR(sn) != 0) return SOCKERR_SOCKOPT;
|
||||
if (getSn_KPALVTR(sn) != 0)
|
||||
return SOCKERR_SOCKOPT;
|
||||
#endif
|
||||
setSn_CR(sn, Sn_CR_SEND_KEEP);
|
||||
while (getSn_CR(sn) != 0) {
|
||||
|
|
@ -846,7 +896,7 @@ int8_t wiz_setsockopt(uint8_t sn, sockopt_type sotype, void *arg) {
|
|||
#if !((_WIZCHIP_ == 5100) || (_WIZCHIP_ == 5200))
|
||||
case SO_KEEPALIVEAUTO:
|
||||
CHECK_SOCKMODE(Sn_MR_TCP);
|
||||
setSn_KPALVTR(sn, *(uint8_t *)arg);
|
||||
setSn_KPALVTR(sn, *(uint8_t*)arg);
|
||||
break;
|
||||
#endif
|
||||
#endif
|
||||
|
|
@ -856,54 +906,56 @@ int8_t wiz_setsockopt(uint8_t sn, sockopt_type sotype, void *arg) {
|
|||
return SOCK_OK;
|
||||
}
|
||||
|
||||
int8_t wiz_getsockopt(uint8_t sn, sockopt_type sotype, void *arg) {
|
||||
int8_t wiz_getsockopt(uint8_t sn, sockopt_type sotype, void* arg)
|
||||
{
|
||||
CHECK_SOCKNUM();
|
||||
switch (sotype) {
|
||||
case SO_FLAG:
|
||||
*(uint8_t *)arg = getSn_MR(sn) & 0xF0;
|
||||
*(uint8_t*)arg = getSn_MR(sn) & 0xF0;
|
||||
break;
|
||||
case SO_TTL:
|
||||
*(uint8_t *)arg = getSn_TTL(sn);
|
||||
*(uint8_t*)arg = getSn_TTL(sn);
|
||||
break;
|
||||
case SO_TOS:
|
||||
*(uint8_t *)arg = getSn_TOS(sn);
|
||||
*(uint8_t*)arg = getSn_TOS(sn);
|
||||
break;
|
||||
case SO_MSS:
|
||||
*(uint16_t *)arg = getSn_MSSR(sn);
|
||||
*(uint16_t*)arg = getSn_MSSR(sn);
|
||||
break;
|
||||
case SO_DESTIP:
|
||||
getSn_DIPR(sn, (uint8_t *)arg);
|
||||
getSn_DIPR(sn, (uint8_t*)arg);
|
||||
break;
|
||||
case SO_DESTPORT:
|
||||
*(uint16_t *)arg = getSn_DPORT(sn);
|
||||
*(uint16_t*)arg = getSn_DPORT(sn);
|
||||
break;
|
||||
#if _WIZCHIP_ > 5200
|
||||
case SO_KEEPALIVEAUTO:
|
||||
CHECK_SOCKMODE(Sn_MR_TCP);
|
||||
*(uint16_t *)arg = getSn_KPALVTR(sn);
|
||||
*(uint16_t*)arg = getSn_KPALVTR(sn);
|
||||
break;
|
||||
#endif
|
||||
case SO_SENDBUF:
|
||||
*(uint16_t *)arg = getSn_TX_FSR(sn);
|
||||
*(uint16_t*)arg = getSn_TX_FSR(sn);
|
||||
break;
|
||||
case SO_RECVBUF:
|
||||
*(uint16_t *)arg = getSn_RX_RSR(sn);
|
||||
*(uint16_t*)arg = getSn_RX_RSR(sn);
|
||||
break;
|
||||
case SO_STATUS:
|
||||
*(uint8_t *)arg = getSn_SR(sn);
|
||||
*(uint8_t*)arg = getSn_SR(sn);
|
||||
break;
|
||||
case SO_REMAINSIZE:
|
||||
if (getSn_MR(sn) & Sn_MR_TCP)
|
||||
*(uint16_t *)arg = getSn_RX_RSR(sn);
|
||||
*(uint16_t*)arg = getSn_RX_RSR(sn);
|
||||
else
|
||||
*(uint16_t *)arg = sock_remained_size[sn];
|
||||
*(uint16_t*)arg = sock_remained_size[sn];
|
||||
break;
|
||||
case SO_PACKINFO:
|
||||
// CHECK_SOCKMODE(Sn_MR_TCP);
|
||||
#if _WIZCHIP_ != 5300
|
||||
if ((getSn_MR(sn) == Sn_MR_TCP)) return SOCKERR_SOCKMODE;
|
||||
if ((getSn_MR(sn) == Sn_MR_TCP))
|
||||
return SOCKERR_SOCKMODE;
|
||||
#endif
|
||||
*(uint8_t *)arg = sock_pack_info[sn];
|
||||
*(uint8_t*)arg = sock_pack_info[sn];
|
||||
break;
|
||||
default:
|
||||
return SOCKERR_SOCKOPT;
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@
|
|||
//! THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
//*****************************************************************************
|
||||
//#include <stdio.h>
|
||||
// #include <stdio.h>
|
||||
#include "w5500.h"
|
||||
|
||||
#define _W5500_SPI_VDM_OP_ 0x00
|
||||
|
|
@ -65,8 +65,9 @@
|
|||
#if (_WIZCHIP_ == 5500)
|
||||
////////////////////////////////////////////////////
|
||||
|
||||
uint8_t WIZCHIP_READ(uint32_t AddrSel) {
|
||||
uint8_t ret;
|
||||
uint8_t WIZCHIP_READ(uint32_t AddrSel)
|
||||
{
|
||||
uint8_t ret = 0;
|
||||
uint8_t spi_data[3];
|
||||
|
||||
WIZCHIP_CRITICAL_ENTER();
|
||||
|
|
@ -74,8 +75,7 @@ uint8_t WIZCHIP_READ(uint32_t AddrSel) {
|
|||
|
||||
AddrSel |= (_W5500_SPI_READ_ | _W5500_SPI_VDM_OP_);
|
||||
|
||||
if (!WIZCHIP.IF.SPI._read_burst ||
|
||||
!WIZCHIP.IF.SPI._write_burst) // byte operation
|
||||
if (!WIZCHIP.IF.SPI._read_burst || !WIZCHIP.IF.SPI._write_burst) // byte operation
|
||||
{
|
||||
WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
|
||||
WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
|
||||
|
|
@ -94,7 +94,8 @@ uint8_t WIZCHIP_READ(uint32_t AddrSel) {
|
|||
return ret;
|
||||
}
|
||||
|
||||
void WIZCHIP_WRITE(uint32_t AddrSel, uint8_t wb) {
|
||||
void WIZCHIP_WRITE(uint32_t AddrSel, uint8_t wb)
|
||||
{
|
||||
uint8_t spi_data[4];
|
||||
|
||||
WIZCHIP_CRITICAL_ENTER();
|
||||
|
|
@ -123,7 +124,8 @@ void WIZCHIP_WRITE(uint32_t AddrSel, uint8_t wb) {
|
|||
WIZCHIP_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void WIZCHIP_READ_BUF(uint32_t AddrSel, uint8_t *pBuf, uint16_t len) {
|
||||
void WIZCHIP_READ_BUF(uint32_t AddrSel, uint8_t* pBuf, uint16_t len)
|
||||
{
|
||||
uint8_t spi_data[3];
|
||||
uint16_t i;
|
||||
|
||||
|
|
@ -132,8 +134,7 @@ void WIZCHIP_READ_BUF(uint32_t AddrSel, uint8_t *pBuf, uint16_t len) {
|
|||
|
||||
AddrSel |= (_W5500_SPI_READ_ | _W5500_SPI_VDM_OP_);
|
||||
|
||||
if (!WIZCHIP.IF.SPI._read_burst ||
|
||||
!WIZCHIP.IF.SPI._write_burst) // byte operation
|
||||
if (!WIZCHIP.IF.SPI._read_burst || !WIZCHIP.IF.SPI._write_burst) // byte operation
|
||||
{
|
||||
WIZCHIP.IF.SPI._write_byte((AddrSel & 0x00FF0000) >> 16);
|
||||
WIZCHIP.IF.SPI._write_byte((AddrSel & 0x0000FF00) >> 8);
|
||||
|
|
@ -153,7 +154,8 @@ void WIZCHIP_READ_BUF(uint32_t AddrSel, uint8_t *pBuf, uint16_t len) {
|
|||
WIZCHIP_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void WIZCHIP_WRITE_BUF(uint32_t AddrSel, uint8_t *pBuf, uint16_t len) {
|
||||
void WIZCHIP_WRITE_BUF(uint32_t AddrSel, uint8_t* pBuf, uint16_t len)
|
||||
{
|
||||
uint8_t spi_data[3];
|
||||
uint16_t i;
|
||||
|
||||
|
|
@ -182,7 +184,8 @@ void WIZCHIP_WRITE_BUF(uint32_t AddrSel, uint8_t *pBuf, uint16_t len) {
|
|||
WIZCHIP_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
uint16_t getSn_TX_FSR(uint8_t sn) {
|
||||
uint16_t getSn_TX_FSR(uint8_t sn)
|
||||
{
|
||||
uint16_t val = 0, val1 = 0;
|
||||
|
||||
do {
|
||||
|
|
@ -196,7 +199,8 @@ uint16_t getSn_TX_FSR(uint8_t sn) {
|
|||
return val;
|
||||
}
|
||||
|
||||
uint16_t getSn_RX_RSR(uint8_t sn) {
|
||||
uint16_t getSn_RX_RSR(uint8_t sn)
|
||||
{
|
||||
uint16_t val = 0, val1 = 0;
|
||||
|
||||
do {
|
||||
|
|
@ -210,7 +214,8 @@ uint16_t getSn_RX_RSR(uint8_t sn) {
|
|||
return val;
|
||||
}
|
||||
|
||||
void wiz_send_data(uint8_t sn, uint8_t *wizdata, uint16_t len) {
|
||||
void wiz_send_data(uint8_t sn, uint8_t* wizdata, uint16_t len)
|
||||
{
|
||||
uint16_t ptr = 0;
|
||||
uint32_t addrsel = 0;
|
||||
|
||||
|
|
@ -227,7 +232,8 @@ void wiz_send_data(uint8_t sn, uint8_t *wizdata, uint16_t len) {
|
|||
setSn_TX_WR(sn, ptr);
|
||||
}
|
||||
|
||||
void wiz_recv_data(uint8_t sn, uint8_t *wizdata, uint16_t len) {
|
||||
void wiz_recv_data(uint8_t sn, uint8_t* wizdata, uint16_t len)
|
||||
{
|
||||
uint16_t ptr = 0;
|
||||
uint32_t addrsel = 0;
|
||||
|
||||
|
|
@ -244,7 +250,8 @@ void wiz_recv_data(uint8_t sn, uint8_t *wizdata, uint16_t len) {
|
|||
setSn_RX_RD(sn, ptr);
|
||||
}
|
||||
|
||||
void wiz_recv_ignore(uint8_t sn, uint16_t len) {
|
||||
void wiz_recv_ignore(uint8_t sn, uint16_t len)
|
||||
{
|
||||
uint16_t ptr = 0;
|
||||
|
||||
ptr = getSn_RX_RD(sn);
|
||||
|
|
|
|||
|
|
@ -0,0 +1,248 @@
|
|||
/**
|
||||
* Copyright (c) 2022 WIZnet Co.,Ltd
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/**
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
* Includes
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
*/
|
||||
#include <stdio.h>
|
||||
|
||||
#include "connect_ethernet.h"
|
||||
|
||||
#include "socket.h"
|
||||
|
||||
#include "netif/etharp.h"
|
||||
#include <sys.h>
|
||||
|
||||
#include <xs_kdbg.h>
|
||||
|
||||
#include <xizi.h>
|
||||
/**
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
* Macros
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/**
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
* Variables
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
*/
|
||||
uint8_t wiz_mac[6] = { 0x00, 0x08, 0xDC, 0x12, 0x34, 0x56 };
|
||||
|
||||
static const uint32_t ethernet_polynomial_le = 0xedb88320U;
|
||||
|
||||
static sys_mutex_t wiz_trans_mtx;
|
||||
|
||||
/**
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
* Functions
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
*/
|
||||
void* ethernetif_config_enet_set(uint8_t enet_port)
|
||||
{
|
||||
return NONE;
|
||||
}
|
||||
|
||||
void Time_Update_LwIP(void)
|
||||
{
|
||||
// no need to do
|
||||
}
|
||||
|
||||
static inline void spi_if_clr(void)
|
||||
{
|
||||
setSn_IR(0, 0x1F);
|
||||
setSIR(0);
|
||||
}
|
||||
|
||||
// macraw func
|
||||
uint16_t macraw_send(const uint8_t* buf, uint16_t len)
|
||||
{
|
||||
uint8_t sock_num = 0;
|
||||
uint16_t ret = 0;
|
||||
|
||||
if (len > getSn_TxMAX(sock_num)) {
|
||||
ret = getSn_TxMAX(sock_num);
|
||||
} else {
|
||||
ret = len;
|
||||
}
|
||||
|
||||
wiz_send_data(sock_num, (uint8_t*)buf, len);
|
||||
|
||||
WIZCHIP_WRITE(Sn_CR(sock_num), Sn_CR_SEND);
|
||||
while (WIZCHIP_READ(Sn_CR(sock_num))) {
|
||||
}
|
||||
while (WIZCHIP_READ(Sn_IR(sock_num)) & Sn_IR_SENDOK != Sn_IR_SENDOK) {
|
||||
}
|
||||
WIZCHIP_WRITE(Sn_IR(sock_num), Sn_IR_SENDOK);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint16_t macraw_recv(uint8_t* buf, uint16_t len)
|
||||
{
|
||||
uint8_t sock_num = 0;
|
||||
|
||||
uint16_t lowlevel_len = getSn_RX_RSR(sock_num);
|
||||
if (lowlevel_len <= 0 || len <= 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint16_t data_len = 0;
|
||||
uint8_t macraw_head[2];
|
||||
|
||||
uint16_t ptr = getSn_RX_RD(sock_num);
|
||||
uint32_t addrsel = ((uint32_t)ptr << 8) + (WIZCHIP_RXBUF_BLOCK(sock_num) << 3);
|
||||
|
||||
WIZCHIP_READ_BUF(addrsel, macraw_head, 2);
|
||||
ptr += 2;
|
||||
|
||||
data_len = (macraw_head[0] << 8) + macraw_head[1] - 2;
|
||||
if (data_len > 1514) {
|
||||
KPrintf("[%s:%d] Info: data recved oversize: %d\n", __func__, __LINE__, data_len);
|
||||
wiz_recv_ignore(sock_num, data_len);
|
||||
// wiz_sock_close(sock_num);
|
||||
// wiz_socket(sock_num, Sn_MR_MACRAW, 0xC000, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
addrsel = ((uint32_t)ptr << 8) + (WIZCHIP_RXBUF_BLOCK(sock_num) << 3);
|
||||
WIZCHIP_READ_BUF(addrsel, buf, data_len);
|
||||
ptr += data_len;
|
||||
|
||||
setSn_RX_RD(sock_num, ptr);
|
||||
WIZCHIP_WRITE(Sn_CR(sock_num), Sn_CR_RECV);
|
||||
while (WIZCHIP_READ(Sn_CR(sock_num)))
|
||||
;
|
||||
|
||||
return data_len;
|
||||
}
|
||||
|
||||
void netif_link_callback(struct netif* netif)
|
||||
{
|
||||
printf("netif link status changed %s\n", netif_is_link_up(netif) ? "up" : "down");
|
||||
}
|
||||
|
||||
void netif_status_callback(struct netif* netif)
|
||||
{
|
||||
printf("netif status changed %s\n", ip4addr_ntoa(netif_ip4_addr(netif)));
|
||||
}
|
||||
|
||||
static int32_t wiz_transmit_pbuf(struct pbuf* p)
|
||||
{
|
||||
static uint8_t addr[4] = { 0xFF, 0xFF, 0xFF, 0xFF };
|
||||
int32_t send_ret = 0;
|
||||
|
||||
while (1) {
|
||||
spi_if_clr();
|
||||
if ((send_ret = wiz_sock_sendto(0, (uint8_t*)p->payload, p->len, addr, 0)) <= 0) {
|
||||
SYS_KDEBUG_LOG(WIZNET_DEBUG, ("[%s] data send failed: %d, sock: %x\n", __func__, send_ret, getSn_SR(0)));
|
||||
return -ERROR;
|
||||
}
|
||||
if (p->len == p->tot_len) {
|
||||
break;
|
||||
}
|
||||
|
||||
p = p->next;
|
||||
}
|
||||
|
||||
return EOK;
|
||||
}
|
||||
|
||||
static struct pbuf* wiz_read_receive_pbuf(struct pbuf* buf)
|
||||
{
|
||||
#define RX_FRAME_SIZE 1542
|
||||
static uint8_t rx_frame[RX_FRAME_SIZE];
|
||||
static uint8_t addr[4] = { 0xFF, 0xFF, 0xFF, 0xFF };
|
||||
uint16_t port = 0;
|
||||
|
||||
uint16_t lowlevel_len = getSn_RX_RSR(0);
|
||||
if (lowlevel_len <= 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int32_t data_len = wiz_sock_recvfrom(0, rx_frame, RX_FRAME_SIZE, addr, &port);
|
||||
if (data_len > 0 && data_len <= RX_FRAME_SIZE) {
|
||||
buf = pbuf_alloc(PBUF_RAW, data_len, PBUF_POOL);
|
||||
if (buf == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
memcpy(buf->payload, rx_frame, data_len);
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
void ethernetif_input(void* netif_arg)
|
||||
{
|
||||
struct netif* netif = (struct netif*)netif_arg;
|
||||
struct pbuf* p = NULL;
|
||||
for (;;) {
|
||||
sys_arch_sem_wait(get_eth_recv_sem(), WAITING_FOREVER);
|
||||
while (1) {
|
||||
sys_mutex_lock(&wiz_trans_mtx);
|
||||
|
||||
spi_if_clr();
|
||||
p = NULL;
|
||||
p = wiz_read_receive_pbuf(p);
|
||||
|
||||
sys_mutex_unlock(&wiz_trans_mtx);
|
||||
|
||||
if (p != NULL) {
|
||||
// SYS_KDEBUG_LOG(WIZNET_DEBUG, ("[%s:%d] Info Recved package with size %d\n", __func__, __LINE__, p->len));
|
||||
if (ERR_OK != netif->input(p, netif)) {
|
||||
pbuf_free(p);
|
||||
}
|
||||
p = NULL;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static err_t spi_if_linkoutput(struct netif* netif, struct pbuf* p)
|
||||
{
|
||||
sys_mutex_lock(&wiz_trans_mtx);
|
||||
|
||||
if (!(getSn_SR(0) & SOCK_MACRAW)) {
|
||||
SYS_KDEBUG_LOG(WIZNET_DEBUG, ("[%s:%d] err socket state %d\n", __func__, __LINE__, p->len));
|
||||
wiz_sock_close(0);
|
||||
setSn_MR(0, Sn_MR_MFEN | Sn_MR_MACRAW | Sn_MR_MIP6B | Sn_MR_MMB);
|
||||
wiz_socket(0, Sn_MR_MACRAW, 0, SOCK_IO_NONBLOCK);
|
||||
}
|
||||
|
||||
int32_t ret = wiz_transmit_pbuf(p);
|
||||
|
||||
sys_mutex_unlock(&wiz_trans_mtx);
|
||||
|
||||
if (ret != EOK) {
|
||||
return ERR_USE;
|
||||
}
|
||||
|
||||
/* TODO: Set up result value */
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
err_t netif_initialize(struct netif* netif)
|
||||
{
|
||||
sys_mutex_new(&wiz_trans_mtx);
|
||||
|
||||
netif->linkoutput = spi_if_linkoutput;
|
||||
// netif->linkoutput = netif_output;
|
||||
netif->output = etharp_output;
|
||||
netif->mtu = ETHERNET_MTU;
|
||||
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET | NETIF_FLAG_IGMP | NETIF_FLAG_MLD6;
|
||||
netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
|
||||
SMEMCPY(netif->hwaddr, wiz_mac, sizeof(netif->hwaddr));
|
||||
netif->hwaddr_len = sizeof(netif->hwaddr);
|
||||
netif->name[0] = 'e';
|
||||
netif->name[1] = '0';
|
||||
return ERR_OK;
|
||||
}
|
||||
|
|
@ -304,7 +304,7 @@ __exit:
|
|||
if (recv_data) free(recv_data);
|
||||
}
|
||||
|
||||
void iperf_usage(void)
|
||||
static void iperf_usage(void)
|
||||
{
|
||||
KPrintf("Usage: iperf [-s|-c host] [options] [multi-threaded]\n");
|
||||
KPrintf(" iperf [-h|--stop]\n");
|
||||
|
|
@ -326,7 +326,7 @@ void iperf_usage(void)
|
|||
return;
|
||||
}
|
||||
|
||||
int iperf(int argc, char **argv)
|
||||
int wiz_iperf(int argc, char** argv)
|
||||
{
|
||||
int mode = 0; /* server mode */
|
||||
char *host = NULL;
|
||||
|
|
@ -460,6 +460,6 @@ __usage:
|
|||
return 0;
|
||||
}
|
||||
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN),
|
||||
iperf, iperf,
|
||||
wiz_iperf, wiz_iperf,
|
||||
iperf throughput test);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@
|
|||
|
||||
#define PING_BIND_PORT 3000
|
||||
|
||||
PINGMSGR PingRequest = {0};
|
||||
PINGMSGR PingReply = {0};
|
||||
PINGMSGR PingRequest = { 0 };
|
||||
PINGMSGR PingReply = { 0 };
|
||||
|
||||
static uint16_t ping_RandomID = 0x1234;
|
||||
static uint16_t ping_RandomSeqNum = 0x4321;
|
||||
|
|
@ -21,7 +21,7 @@ uint8_t ping_reply_received = 0;
|
|||
uint8_t ping_req = 0;
|
||||
uint8_t ping_rep = 0;
|
||||
uint8_t ping_cnt = 0;
|
||||
uint8_t ping_rep_buf[150] = {0};
|
||||
uint8_t ping_rep_buf[150] = { 0 };
|
||||
|
||||
// ping状态机
|
||||
#define PING_STA_FREE 0
|
||||
|
|
@ -32,20 +32,22 @@ uint8_t ping_rep_buf[150] = {0};
|
|||
|
||||
uint8_t ping_sta = PING_STA_FREE;
|
||||
|
||||
//当前ping的设备的序号
|
||||
// 当前ping的设备的序号
|
||||
uint8_t ping_socket = 0;
|
||||
|
||||
#define bswap_16(A) ((((uint16)(A)&0xff00) >> 8) | (((uint16)(A)&0x00ff) << 8))
|
||||
#define bswap_16(A) ((((uint16)(A) & 0xff00) >> 8) | (((uint16)(A) & 0x00ff) << 8))
|
||||
|
||||
uint16_t htons(uint16_t n) {
|
||||
uint16_t htons(uint16_t n)
|
||||
{
|
||||
union {
|
||||
int i;
|
||||
char c;
|
||||
} u = {1};
|
||||
} u = { 1 };
|
||||
return u.c ? bswap_16(n) : n;
|
||||
}
|
||||
|
||||
uint16_t checksum(uint8_t *src, uint32_t len) {
|
||||
uint16_t checksum(uint8_t* src, uint32_t len)
|
||||
{
|
||||
uint16_t sum, tsum, i, j;
|
||||
uint32_t lsum;
|
||||
|
||||
|
|
@ -76,13 +78,14 @@ uint16_t checksum(uint8_t *src, uint32_t len) {
|
|||
*@param pCount- ping的次数
|
||||
*@return ping成功次数
|
||||
*/
|
||||
uint8_t ping_count(uint8_t sn, uint16_t pCount, uint8_t *addr) {
|
||||
uint8_t ping_count(uint8_t sn, uint16_t pCount, uint8_t* addr)
|
||||
{
|
||||
uint16_t rlen, cnt, i;
|
||||
|
||||
ping_reply_received = 0;
|
||||
ping_req = 0;
|
||||
ping_rep = 0;
|
||||
KPrintf("Ping:%d.%d.%d.%d\r\n", (addr[0]), (addr[1]), (addr[2]), (addr[3]));
|
||||
KPrintf("Ping:%d.%d.%d.%d, socket state: %x\r\n", (addr[0]), (addr[1]), (addr[2]), (addr[3]), getSn_SR(sn));
|
||||
|
||||
for (i = 0; i < pCount + 1; i++) /*循环ping pCount次*/
|
||||
{
|
||||
|
|
@ -93,8 +96,7 @@ uint8_t ping_count(uint8_t sn, uint16_t pCount, uint8_t *addr) {
|
|||
wiz_sock_close(sn);
|
||||
/* Create Socket */
|
||||
IINCHIP_WRITE(Sn_PROTO(sn), IPPROTO_ICMP); /*设置ICMP 协议*/
|
||||
if (wiz_socket(sn, Sn_MR_IPRAW, PING_BIND_PORT, 0) !=
|
||||
0) /*判断ip raw模式socket是否开启*/
|
||||
if (wiz_socket(sn, Sn_MR_IPRAW, PING_BIND_PORT, 0) != 0) /*判断ip raw模式socket是否开启*/
|
||||
{
|
||||
}
|
||||
/* Check socket register */
|
||||
|
|
@ -142,26 +144,25 @@ uint8_t ping_count(uint8_t sn, uint16_t pCount, uint8_t *addr) {
|
|||
*@param addr- P地址
|
||||
*@return 无
|
||||
*/
|
||||
uint8_t ping_request(uint8_t sn, uint8_t *addr) {
|
||||
uint8_t *buffer;
|
||||
uint8_t ping_request(uint8_t sn, uint8_t* addr)
|
||||
{
|
||||
uint8_t* buffer;
|
||||
|
||||
uint16_t i, temp_len = 0;
|
||||
ping_reply_received = 0; /*ping 回复初始化标志位*/
|
||||
PingRequest.Type = PING_REQUEST; /*Ping-Request*/
|
||||
PingRequest.Code = CODE_ZERO; /*总是 '0'*/
|
||||
PingRequest.ID = htons(ping_RandomID++); /*设置ping响应ID为随机的整型变量*/
|
||||
PingRequest.SeqNum =
|
||||
htons(ping_RandomSeqNum++); /*设置ping响应的序列号为随机整形变量*/
|
||||
PingRequest.SeqNum = htons(ping_RandomSeqNum++); /*设置ping响应的序列号为随机整形变量*/
|
||||
for (i = 0; i < PING_BUF_LEN; i++) {
|
||||
PingRequest.Data[i] = (i) % 8; /*ping相应的数在'0'~'8‘*/
|
||||
}
|
||||
PingRequest.CheckSum = 0;
|
||||
/* 计算响应次数*/
|
||||
PingRequest.CheckSum =
|
||||
htons(checksum((uint8_t *)&PingRequest, sizeof(PingRequest)));
|
||||
PingRequest.CheckSum = htons(checksum((uint8_t*)&PingRequest, sizeof(PingRequest)));
|
||||
|
||||
/*发送ping响应到目的方 */
|
||||
if (wiz_sock_sendto(sn, (uint8_t *)&PingRequest, sizeof(PingRequest), addr,
|
||||
PING_BIND_PORT) == 0) {
|
||||
if (wiz_sock_sendto(sn, (uint8_t*)&PingRequest, sizeof(PingRequest), addr, PING_BIND_PORT) == 0) {
|
||||
KPrintf("Fail to send ping-reply packet\r\n");
|
||||
} else {
|
||||
KPrintf("ping send\n");
|
||||
|
|
@ -175,7 +176,8 @@ uint8_t ping_request(uint8_t sn, uint8_t *addr) {
|
|||
*@param addr- Ping地址
|
||||
*@return 无
|
||||
*/
|
||||
uint8_t ping_reply(uint8_t sn, uint8_t *addr, uint16_t rlen) {
|
||||
uint8_t ping_reply(uint8_t sn, uint8_t* addr, uint16_t rlen)
|
||||
{
|
||||
uint16_t tmp_checksum;
|
||||
uint16_t len;
|
||||
uint16_t i;
|
||||
|
|
@ -233,10 +235,11 @@ uint8_t ping_reply(uint8_t sn, uint8_t *addr, uint16_t rlen) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
void wiz_ping_test(int argc, char *argv[]) {
|
||||
void wiz_ping_test(int argc, char* argv[])
|
||||
{
|
||||
uint32_t tmp_ip[4];
|
||||
uint8_t target_ip[4];
|
||||
uint16_t pCount = 5; //默认ping 5次
|
||||
uint16_t pCount = 5; // 默认ping 5次
|
||||
|
||||
if (argc >= 2) {
|
||||
KPrintf("This is a Ping test: %s\n", argv[1]);
|
||||
|
|
@ -246,11 +249,11 @@ void wiz_ping_test(int argc, char *argv[]) {
|
|||
target_ip[1] = (uint8_t)tmp_ip[1];
|
||||
target_ip[2] = (uint8_t)tmp_ip[2];
|
||||
target_ip[3] = (uint8_t)tmp_ip[3];
|
||||
if (argc >= 3){
|
||||
pCount = atoi(argv[2]); //如果ip后面跟具体的数字,代表ping的次数
|
||||
if (argc >= 3) {
|
||||
pCount = atoi(argv[2]); // 如果ip后面跟具体的数字,代表ping的次数
|
||||
}
|
||||
ping_count(ping_socket, pCount, target_ip);
|
||||
}
|
||||
}
|
||||
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN),
|
||||
ping, wiz_ping_test, ping to given addr);
|
||||
wiz_ping, wiz_ping_test, ping to given addr);
|
||||
|
|
@ -0,0 +1,118 @@
|
|||
/**
|
||||
* Copyright (c) 2022 WIZnet Co.,Ltd
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
#ifndef _W5x00_LWIP_H_
|
||||
#define _W5x00_LWIP_H_
|
||||
|
||||
/**
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
* Includes
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
*/
|
||||
#include "lwip/netif.h"
|
||||
|
||||
/**
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
* Macros
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
*/
|
||||
/* LWIP */
|
||||
#define ETHERNET_MTU 1500
|
||||
#define SOCKET_MACRAW 0
|
||||
|
||||
/**
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
* Variables
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/**
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
* Functions
|
||||
* ----------------------------------------------------------------------------------------------------
|
||||
*/
|
||||
/*! \brief send an ethernet packet
|
||||
* \ingroup w5x00_lwip
|
||||
*
|
||||
* It is used to send outgoing data to the socket.
|
||||
*
|
||||
* \param sn socket number
|
||||
* \param buf a pointer to the data to send
|
||||
* \param len the length of data in packet
|
||||
* \return he sent data size
|
||||
*/
|
||||
int32_t send_lwip(uint8_t sn, uint8_t* buf, uint16_t len);
|
||||
|
||||
/*! \brief read an ethernet packet
|
||||
* \ingroup w5x00_lwip
|
||||
*
|
||||
* It is used to read incoming data from the socket.
|
||||
*
|
||||
* \param sn socket number
|
||||
* \param buf a pointer buffer to read incoming data
|
||||
* \param len the length of the data in the packet
|
||||
* \return the real received data size
|
||||
*/
|
||||
int32_t recv_lwip(uint8_t sn, uint8_t* buf, uint16_t len);
|
||||
|
||||
/*! \brief callback function
|
||||
* \ingroup w5x00_lwip
|
||||
*
|
||||
* This function is called by ethernet_output() when it wants
|
||||
* to send a packet on the interface. This function outputs
|
||||
* the pbuf as-is on the link medium.
|
||||
*
|
||||
* \param netif a pre-allocated netif structure
|
||||
* \param p main packet buffer struct
|
||||
* \return ERR_OK if data was sent.
|
||||
*/
|
||||
err_t netif_output(struct netif* netif, struct pbuf* p);
|
||||
|
||||
/*! \brief callback function
|
||||
* \ingroup w5x00_lwip
|
||||
*
|
||||
* Callback function for link.
|
||||
*
|
||||
* \param netif a pre-allocated netif structure
|
||||
*/
|
||||
void netif_link_callback(struct netif* netif);
|
||||
|
||||
/*! \brief callback function
|
||||
* \ingroup w5x00_lwip
|
||||
*
|
||||
* Callback function for status.
|
||||
*
|
||||
* \param netif a pre-allocated netif structure
|
||||
*/
|
||||
void netif_status_callback(struct netif* netif);
|
||||
|
||||
/*! \brief callback function
|
||||
* \ingroup w5x00_lwip
|
||||
*
|
||||
* Callback function that initializes the interface.
|
||||
*
|
||||
* \param netif a pre-allocated netif structure
|
||||
* \return ERR_OK if Network interface initialized
|
||||
*/
|
||||
err_t netif_initialize(struct netif* netif);
|
||||
|
||||
/*! \brief ethernet frame cyclic redundancy check
|
||||
* \ingroup w5x00_lwip
|
||||
*
|
||||
* Perform cyclic redundancy check on ethernet frame
|
||||
*
|
||||
* \param data a pointer to the ethernet frame
|
||||
* \param length the total length of ethernet frame
|
||||
* \return an ethernet frame cyclic redundancy check result value
|
||||
*/
|
||||
static uint32_t ethernet_frame_crc(const uint8_t* data, int length);
|
||||
|
||||
void ethernetif_input(void* netif_arg);
|
||||
void* ethernetif_config_enet_set(uint8_t enet_port);
|
||||
void Time_Update_LwIP(void);
|
||||
#define NETIF_ENET0_INIT_FUNC netif_initialize
|
||||
|
||||
#endif /* _W5x00_LWIP_H_ */
|
||||
|
|
@ -191,7 +191,7 @@ static uint32 SpiWriteData(struct SpiHardwareDevice *spi_dev, struct SpiDataStan
|
|||
for (i = 0; i < spi_datacfg->length; i++) {
|
||||
tx_buff[i] = ((uint8_t *)spi_datacfg->tx_buff)[i];
|
||||
}
|
||||
dmac_set_single_mode(dev_param->spi_dma_param->spi_dmac_txchannel, tx_buff, (void *)(&spi_instance[device_master_id]->dr[0]), DMAC_ADDR_INCREMENT, DMAC_ADDR_NOCHANGE,
|
||||
dmac_set_single_mode(dev_param->spi_dma_param->spi_dmac_txchannel, tx_buff, (void*)(&spi_instance[device_master_id]->dr[0]), DMAC_ADDR_INCREMENT, DMAC_ADDR_NOCHANGE,
|
||||
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, spi_datacfg->length);
|
||||
}
|
||||
|
||||
|
|
@ -202,7 +202,7 @@ static uint32 SpiWriteData(struct SpiHardwareDevice *spi_dev, struct SpiDataStan
|
|||
spi_instance[device_master_id]->ssienr = 0x00;
|
||||
|
||||
transfer_done:
|
||||
if (tx_buff) {
|
||||
if (tx_buff != NULL) {
|
||||
x_free(tx_buff);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -231,9 +231,9 @@ int MountFilesystem(const char *bus_name,
|
|||
enum FilesystemType fs_type, const char *path)
|
||||
{
|
||||
struct MountPoint *mp = NULL, *itr;
|
||||
struct Bus *bus;
|
||||
struct Bus* bus = NULL;
|
||||
HardwareDevType dev;
|
||||
DriverType drv;
|
||||
DriverType drv = NULL;
|
||||
struct SysDoubleLinklistNode *node;
|
||||
int ret = -EINVAL;
|
||||
|
||||
|
|
|
|||
|
|
@ -46,6 +46,7 @@ extern "C" {
|
|||
#define FILESYS_DEBUG 0
|
||||
#define NETDEV_DEBUG 0
|
||||
#define WEBNET_DEBUG 0
|
||||
#define WIZNET_DEBUG 0
|
||||
|
||||
#define SYS_KDEBUG_LOG(section, information) \
|
||||
do { \
|
||||
|
|
|
|||
|
|
@ -61,6 +61,9 @@ enum SmallSizeAllocSize {
|
|||
#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 FREE_LIST_LOCK() DISABLE_INTERRUPT()
|
||||
#define FREE_LIST_UNLOCK(lock) ENABLE_INTERRUPT(lock)
|
||||
|
||||
/**
|
||||
* The structure describes an allocated memory block from dynamic buddy memory.
|
||||
*/
|
||||
|
|
@ -632,7 +635,7 @@ void *x_malloc(x_size_t size)
|
|||
register x_base lock = 0;
|
||||
|
||||
/* hold lock before allocation */
|
||||
lock = CriticalAreaLock();
|
||||
lock = FREE_LIST_LOCK();
|
||||
|
||||
/* alignment */
|
||||
size = ALIGN_MEN_UP(size, MEM_ALIGN_SIZE);
|
||||
|
|
@ -640,26 +643,26 @@ void *x_malloc(x_size_t size)
|
|||
/* parameter detection */
|
||||
#ifdef MEM_EXTERN_SRAM
|
||||
/* parameter detection */
|
||||
if(size == 0 ){
|
||||
CriticalAreaUnLock(lock);
|
||||
if (size == 0) {
|
||||
FREE_LIST_UNLOCK(lock);
|
||||
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)) {
|
||||
/* alignment */
|
||||
size = ALIGN_MEN_UP(size, MEM_ALIGN_SIZE);
|
||||
goto try_extmem;
|
||||
}
|
||||
#else
|
||||
/* 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)) {
|
||||
CriticalAreaUnLock(lock);
|
||||
if ((size == 0) || (size > ByteManager.dynamic_buddy_manager.dynamic_buddy_end - ByteManager.dynamic_buddy_manager.dynamic_buddy_start - ByteManager.dynamic_buddy_manager.active_memory)) {
|
||||
FREE_LIST_UNLOCK(lock);
|
||||
return NONE;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* determine allocation operation from static segments or dynamic buddy memory */
|
||||
#ifdef KERNEL_SMALL_MEM_ALLOC
|
||||
if(size <= SIZEOF_32B) {
|
||||
if (size <= SIZEOF_32B) {
|
||||
ret = ByteManager.static_manager[0].done->malloc(&ByteManager, SIZEOF_32B);
|
||||
} else if (size <= SIZEOF_64B) {
|
||||
ret = ByteManager.static_manager[1].done->malloc(&ByteManager, SIZEOF_64B);
|
||||
|
|
@ -673,16 +676,15 @@ void *x_malloc(x_size_t size)
|
|||
}
|
||||
|
||||
#ifdef MEM_EXTERN_SRAM
|
||||
try_extmem:
|
||||
if(NONE == ret) {
|
||||
for(i = 0; i < EXTSRAM_MAX_NUM; i++) {
|
||||
if(NONE != ExtByteManager[i].done) {
|
||||
try_extmem:
|
||||
if (NONE == ret) {
|
||||
for (i = 0; i < EXTSRAM_MAX_NUM; i++) {
|
||||
if (NONE != ExtByteManager[i].done) {
|
||||
ret = ExtByteManager[i].dynamic_buddy_manager.done->malloc(&ExtByteManager[i].dynamic_buddy_manager, size, DYNAMIC_BLOCK_EXTMEMn_MASK(i + 1));
|
||||
if (ret){
|
||||
if (ret) {
|
||||
CHECK(ExtByteManager[i].dynamic_buddy_manager.done->JudgeLegal(&ExtByteManager[i].dynamic_buddy_manager, ret - SIZEOF_DYNAMICALLOCNODE_MEM));
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -690,7 +692,7 @@ try_extmem:
|
|||
}
|
||||
|
||||
/* release lock */
|
||||
CriticalAreaUnLock(lock);
|
||||
FREE_LIST_UNLOCK(lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -702,12 +704,12 @@ try_extmem:
|
|||
*
|
||||
* @return pointer on success; NULL on failure
|
||||
*/
|
||||
void *x_realloc(void *pointer, x_size_t size)
|
||||
void* x_realloc(void* pointer, x_size_t size)
|
||||
{
|
||||
x_size_t newsize = 0;
|
||||
x_size_t oldsize = 0;
|
||||
void *newmem = NONE;
|
||||
struct DynamicAllocNode *oldnode = NONE;
|
||||
void* newmem = NONE;
|
||||
struct DynamicAllocNode* oldnode = NONE;
|
||||
|
||||
/* the given pointer is NULL */
|
||||
if (pointer == NONE)
|
||||
|
|
@ -718,17 +720,17 @@ void *x_realloc(void *pointer, x_size_t size)
|
|||
x_free(pointer);
|
||||
return NONE;
|
||||
}
|
||||
CHECK(ByteManager.dynamic_buddy_manager.done->JudgeLegal(&ByteManager.dynamic_buddy_manager,pointer));
|
||||
CHECK(ByteManager.dynamic_buddy_manager.done->JudgeLegal(&ByteManager.dynamic_buddy_manager, pointer));
|
||||
|
||||
/* alignment and calculate the real size */
|
||||
newsize = ALIGN_MEN_UP(size, MEM_ALIGN_SIZE);
|
||||
newsize += SIZEOF_DYNAMICALLOCNODE_MEM;
|
||||
|
||||
oldnode= PTR2ALLOCNODE((char*)pointer - SIZEOF_DYNAMICALLOCNODE_MEM);
|
||||
oldnode = PTR2ALLOCNODE((char*)pointer - SIZEOF_DYNAMICALLOCNODE_MEM);
|
||||
CHECK(ByteManager.done->JudgeAllocated(oldnode));
|
||||
|
||||
/* achieve the old memory size */
|
||||
if(ByteManager.done->JudgeStaticOrDynamic(oldnode)) {
|
||||
if (ByteManager.done->JudgeStaticOrDynamic(oldnode)) {
|
||||
oldsize = ((struct segment*)(long)(oldnode->size))->block_size;
|
||||
} else {
|
||||
oldsize = oldnode->size - SIZEOF_DYNAMICALLOCNODE_MEM;
|
||||
|
|
@ -736,12 +738,12 @@ void *x_realloc(void *pointer, x_size_t size)
|
|||
|
||||
/* allocate new memory */
|
||||
newmem = x_malloc(size);
|
||||
if(newmem == NONE) {
|
||||
if (newmem == NONE) {
|
||||
return NONE;
|
||||
}
|
||||
|
||||
/* copy the old memory and then release old memory pointer */
|
||||
memcpy((char*)newmem, (char*) pointer,size > oldsize ? oldsize : size);
|
||||
memcpy((char*)newmem, (char*)pointer, size > oldsize ? oldsize : size);
|
||||
x_free(pointer);
|
||||
|
||||
return newmem;
|
||||
|
|
@ -755,12 +757,12 @@ void *x_realloc(void *pointer, x_size_t size)
|
|||
*
|
||||
* @return pointer on success; NULL on failure
|
||||
*/
|
||||
void *x_calloc(x_size_t count, x_size_t size)
|
||||
void* x_calloc(x_size_t count, x_size_t size)
|
||||
{
|
||||
void *p = NONE;
|
||||
void* p = NONE;
|
||||
|
||||
/* parameter detection */
|
||||
if(count * size > ByteManager.dynamic_buddy_manager.dynamic_buddy_end - ByteManager.dynamic_buddy_manager.dynamic_buddy_start - ByteManager.dynamic_buddy_manager.active_memory)
|
||||
if (count * size > ByteManager.dynamic_buddy_manager.dynamic_buddy_end - ByteManager.dynamic_buddy_manager.dynamic_buddy_start - ByteManager.dynamic_buddy_manager.active_memory)
|
||||
return NONE;
|
||||
|
||||
/* calls x_malloc to allocate count * size memory */
|
||||
|
|
@ -778,10 +780,10 @@ void *x_calloc(x_size_t count, x_size_t size)
|
|||
*
|
||||
* @param pointer the memory to be released
|
||||
*/
|
||||
void x_free(void *pointer)
|
||||
void x_free(void* pointer)
|
||||
{
|
||||
x_base lock = 0;
|
||||
struct DynamicAllocNode *node = NONE;
|
||||
struct DynamicAllocNode* node = NONE;
|
||||
|
||||
/* parameter detection */
|
||||
if (pointer == NONE) {
|
||||
|
|
@ -789,10 +791,10 @@ void x_free(void *pointer)
|
|||
}
|
||||
|
||||
/* hold lock before release */
|
||||
lock = CriticalAreaLock();
|
||||
lock = FREE_LIST_LOCK();
|
||||
|
||||
if (!ByteManager.dynamic_buddy_manager.done->JudgeLegal(&ByteManager.dynamic_buddy_manager, pointer)) {
|
||||
CriticalAreaUnLock(lock);
|
||||
FREE_LIST_UNLOCK(lock);
|
||||
SYS_ERR("[%s] Freeing a unallocated address.\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
|
@ -802,20 +804,20 @@ void x_free(void *pointer)
|
|||
|
||||
/* judge release the memory block ro static_segment or dynamic buddy memory */
|
||||
#ifdef KERNEL_SMALL_MEM_ALLOC
|
||||
if(node->flag & STATIC_BLOCK_MASK) {
|
||||
if (node->flag & STATIC_BLOCK_MASK) {
|
||||
ByteManager.static_manager->done->release(pointer);
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
#ifdef MEM_EXTERN_SRAM
|
||||
/* judge the pointer is not malloced from extern memory*/
|
||||
if(0 == (node->flag & 0xFF0000)) {
|
||||
ByteManager.dynamic_buddy_manager.done->release(&ByteManager,pointer);
|
||||
if (0 == (node->flag & 0xFF0000)) {
|
||||
ByteManager.dynamic_buddy_manager.done->release(&ByteManager, pointer);
|
||||
}
|
||||
|
||||
/* judge the pointer is malloced from extern memory*/
|
||||
if(0 != (node->flag & 0xFF0000)) {
|
||||
ExtByteManager[((node->flag & 0xFF0000) >> 16) - 1].dynamic_buddy_manager.done->release(&ExtByteManager[((node->flag & 0xFF0000) >> 16) - 1],pointer);
|
||||
if (0 != (node->flag & 0xFF0000)) {
|
||||
ExtByteManager[((node->flag & 0xFF0000) >> 16) - 1].dynamic_buddy_manager.done->release(&ExtByteManager[((node->flag & 0xFF0000) >> 16) - 1], pointer);
|
||||
}
|
||||
#else
|
||||
ByteManager.dynamic_buddy_manager.done->release(&ByteManager, pointer);
|
||||
|
|
@ -823,7 +825,7 @@ void x_free(void *pointer)
|
|||
}
|
||||
|
||||
/* release the lock */
|
||||
CriticalAreaUnLock(lock);
|
||||
FREE_LIST_UNLOCK(lock);
|
||||
}
|
||||
|
||||
#ifdef MEM_EXTERN_SRAM
|
||||
|
|
@ -834,7 +836,7 @@ void x_free(void *pointer)
|
|||
* @param end_phy_address the end physical address for static and dynamic memory
|
||||
* @param extsram_idx the idx of extsram chip
|
||||
*/
|
||||
void ExtSramInitBoardMemory(void *start_phy_address, void *end_phy_address, uint8 extsram_idx)
|
||||
void ExtSramInitBoardMemory(void* start_phy_address, void* end_phy_address, uint8 extsram_idx)
|
||||
{
|
||||
register x_size_t offset = 0;
|
||||
|
||||
|
|
@ -842,12 +844,12 @@ void ExtSramInitBoardMemory(void *start_phy_address, void *end_phy_address, uint
|
|||
NULL_PARAM_CHECK(end_phy_address);
|
||||
|
||||
KDEBUG_NOT_IN_INTERRUPT;
|
||||
struct DynamicBuddyMemory *uheap = &ExtByteManager[extsram_idx].dynamic_buddy_manager;
|
||||
struct DynamicBuddyMemory* uheap = &ExtByteManager[extsram_idx].dynamic_buddy_manager;
|
||||
|
||||
/* align begin and end addr to page */
|
||||
ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_start = ALIGN_MEN_UP((x_ubase)start_phy_address, MM_PAGE_SIZE);
|
||||
ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_end = ALIGN_MEN_DOWN((x_ubase)end_phy_address, MM_PAGE_SIZE);
|
||||
KPrintf("%s: 0x%x-0x%x extsram_idx = %d\n",__func__,ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_start,ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_end, extsram_idx);
|
||||
KPrintf("%s: 0x%x-0x%x extsram_idx = %d\n", __func__, ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_start, ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_end, extsram_idx);
|
||||
|
||||
/* parameter detection */
|
||||
if (ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_start >= ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_end) {
|
||||
|
|
@ -868,7 +870,6 @@ void ExtSramInitBoardMemory(void *start_phy_address, void *end_phy_address, uint
|
|||
ExtByteManager[extsram_idx].dynamic_buddy_manager.done = &DynamicDone;
|
||||
ExtByteManager[extsram_idx].done = &NodeDone;
|
||||
|
||||
|
||||
/* dynamic buddy memory initialization */
|
||||
ExtByteManager[extsram_idx].dynamic_buddy_manager.done->init(&ExtByteManager[extsram_idx].dynamic_buddy_manager, ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_start, ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_end - ExtByteManager[extsram_idx].dynamic_buddy_manager.dynamic_buddy_start);
|
||||
}
|
||||
|
|
@ -880,7 +881,7 @@ void ExtSramInitBoardMemory(void *start_phy_address, void *end_phy_address, uint
|
|||
* @param start_phy_address the start physical address for static and dynamic memory
|
||||
* @param end_phy_address the end physical address for static and dynamic memory
|
||||
*/
|
||||
void InitBoardMemory(void *start_phy_address, void *end_phy_address)
|
||||
void InitBoardMemory(void* start_phy_address, void* end_phy_address)
|
||||
{
|
||||
register x_size_t offset = 0;
|
||||
|
||||
|
|
@ -888,16 +889,16 @@ void InitBoardMemory(void *start_phy_address, void *end_phy_address)
|
|||
NULL_PARAM_CHECK(end_phy_address);
|
||||
|
||||
KDEBUG_NOT_IN_INTERRUPT;
|
||||
struct DynamicBuddyMemory *mheap = &ByteManager.dynamic_buddy_manager;
|
||||
struct DynamicBuddyMemory* mheap = &ByteManager.dynamic_buddy_manager;
|
||||
|
||||
/* align begin and end addr to page */
|
||||
ByteManager.dynamic_buddy_manager.dynamic_buddy_start = ALIGN_MEN_UP((x_ubase)start_phy_address, MM_PAGE_SIZE);
|
||||
ByteManager.dynamic_buddy_manager.dynamic_buddy_end = ALIGN_MEN_DOWN((x_ubase)end_phy_address, MM_PAGE_SIZE);
|
||||
//KPrintf("%s: 0x%x-0x%x \n",__func__,ByteManager.dynamic_buddy_manager.dynamic_buddy_start,ByteManager.dynamic_buddy_manager.dynamic_buddy_end);
|
||||
// KPrintf("%s: 0x%x-0x%x \n",__func__,ByteManager.dynamic_buddy_manager.dynamic_buddy_start,ByteManager.dynamic_buddy_manager.dynamic_buddy_end);
|
||||
|
||||
/* parameter detection */
|
||||
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;
|
||||
}
|
||||
|
|
@ -916,7 +917,6 @@ void InitBoardMemory(void *start_phy_address, void *end_phy_address)
|
|||
ByteManager.static_manager[MM_SEGMENT_64B].done = &StaticDone;
|
||||
ByteManager.done = &NodeDone;
|
||||
|
||||
|
||||
/* dynamic buddy memory initialization */
|
||||
ByteManager.dynamic_buddy_manager.done->init(&ByteManager.dynamic_buddy_manager, ByteManager.dynamic_buddy_manager.dynamic_buddy_start, ByteManager.dynamic_buddy_manager.dynamic_buddy_end - ByteManager.dynamic_buddy_manager.dynamic_buddy_start);
|
||||
|
||||
|
|
@ -935,20 +935,19 @@ void InitBoardMemory(void *start_phy_address, void *end_phy_address)
|
|||
*
|
||||
* @return pointer on success; NULL on failure
|
||||
*/
|
||||
void *x_umalloc(x_size_t size)
|
||||
void* x_umalloc(x_size_t size)
|
||||
{
|
||||
uint8 i = 0;
|
||||
void *ret = NONE;
|
||||
void* ret = NONE;
|
||||
register x_base lock = 0;
|
||||
|
||||
|
||||
#ifdef MEM_EXTERN_SRAM
|
||||
/* parameter detection */
|
||||
if(size == 0 ){
|
||||
if (size == 0) {
|
||||
return NONE;
|
||||
}
|
||||
if((size > ByteManager.dynamic_buddy_manager.dynamic_buddy_end - ByteManager.dynamic_buddy_manager.dynamic_buddy_start - ByteManager.dynamic_buddy_manager.active_memory)){
|
||||
lock = CriticalAreaLock();
|
||||
if ((size > ByteManager.dynamic_buddy_manager.dynamic_buddy_end - ByteManager.dynamic_buddy_manager.dynamic_buddy_start - ByteManager.dynamic_buddy_manager.active_memory)) {
|
||||
lock = FREE_LIST_LOCK();
|
||||
/* alignment */
|
||||
size = ALIGN_MEN_UP(size, MEM_ALIGN_SIZE);
|
||||
goto try_extmem;
|
||||
|
|
@ -956,24 +955,23 @@ void *x_umalloc(x_size_t size)
|
|||
|
||||
#else
|
||||
/* parameter detection */
|
||||
if((size == 0) || (size > UserByteManager.dynamic_buddy_manager.dynamic_buddy_end - UserByteManager.dynamic_buddy_manager.dynamic_buddy_start - UserByteManager.dynamic_buddy_manager.active_memory))
|
||||
if ((size == 0) || (size > UserByteManager.dynamic_buddy_manager.dynamic_buddy_end - UserByteManager.dynamic_buddy_manager.dynamic_buddy_start - UserByteManager.dynamic_buddy_manager.active_memory))
|
||||
return NONE;
|
||||
#endif
|
||||
|
||||
/* hold lock before allocation */
|
||||
lock = CriticalAreaLock();
|
||||
lock = FREE_LIST_LOCK();
|
||||
/* alignment */
|
||||
size = ALIGN_MEN_UP(size, MEM_ALIGN_SIZE);
|
||||
ret = UserByteManager.dynamic_buddy_manager.done->malloc(&UserByteManager.dynamic_buddy_manager,size,DYNAMIC_BLOCK_NO_EXTMEM_MASK);
|
||||
if(ret != NONE)
|
||||
ret = UserByteManager.dynamic_buddy_manager.done->malloc(&UserByteManager.dynamic_buddy_manager, size, DYNAMIC_BLOCK_NO_EXTMEM_MASK);
|
||||
if (ret != NONE)
|
||||
CHECK(UserByteManager.dynamic_buddy_manager.done->JudgeLegal(&UserByteManager.dynamic_buddy_manager, ret - SIZEOF_DYNAMICALLOCNODE_MEM));
|
||||
|
||||
|
||||
#ifdef MEM_EXTERN_SRAM
|
||||
try_extmem:
|
||||
if(NONE == ret) {
|
||||
for(i = 0; i < EXTSRAM_MAX_NUM; i++) {
|
||||
if(NONE != ExtByteManager[i].done) {
|
||||
if (NONE == ret) {
|
||||
for (i = 0; i < EXTSRAM_MAX_NUM; i++) {
|
||||
if (NONE != ExtByteManager[i].done) {
|
||||
ret = ExtByteManager[i].dynamic_buddy_manager.done->malloc(&ExtByteManager[i].dynamic_buddy_manager, size, DYNAMIC_BLOCK_EXTMEMn_MASK(i + 1));
|
||||
if (ret) {
|
||||
CHECK(ExtByteManager[i].dynamic_buddy_manager.done->JudgeLegal(&ExtByteManager[i].dynamic_buddy_manager, ret - SIZEOF_DYNAMICALLOCNODE_MEM));
|
||||
|
|
@ -984,7 +982,7 @@ try_extmem:
|
|||
}
|
||||
#endif
|
||||
/* release lock */
|
||||
CriticalAreaUnLock(lock);
|
||||
FREE_LIST_UNLOCK(lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -996,12 +994,12 @@ try_extmem:
|
|||
*
|
||||
* @return pointer on success; NULL on failure
|
||||
*/
|
||||
void *x_urealloc(void *pointer, x_size_t size)
|
||||
void* x_urealloc(void* pointer, x_size_t size)
|
||||
{
|
||||
x_size_t newsize = 0;
|
||||
x_size_t oldsize = 0;
|
||||
void *newmem = NONE;
|
||||
struct DynamicAllocNode *oldnode = NONE;
|
||||
void* newmem = NONE;
|
||||
struct DynamicAllocNode* oldnode = NONE;
|
||||
|
||||
/* the given pointer is NULL */
|
||||
if (pointer == NONE)
|
||||
|
|
@ -1012,17 +1010,17 @@ void *x_urealloc(void *pointer, x_size_t size)
|
|||
x_ufree(pointer);
|
||||
return NONE;
|
||||
}
|
||||
CHECK(UserByteManager.dynamic_buddy_manager.done->JudgeLegal(&UserByteManager.dynamic_buddy_manager,pointer));
|
||||
CHECK(UserByteManager.dynamic_buddy_manager.done->JudgeLegal(&UserByteManager.dynamic_buddy_manager, pointer));
|
||||
|
||||
/* alignment and calculate the real size */
|
||||
newsize = ALIGN_MEN_UP(size, MEM_ALIGN_SIZE);
|
||||
newsize += SIZEOF_DYNAMICALLOCNODE_MEM;
|
||||
|
||||
oldnode= PTR2ALLOCNODE((char*)pointer - SIZEOF_DYNAMICALLOCNODE_MEM);
|
||||
oldnode = PTR2ALLOCNODE((char*)pointer - SIZEOF_DYNAMICALLOCNODE_MEM);
|
||||
CHECK(UserByteManager.done->JudgeAllocated(oldnode));
|
||||
|
||||
/* achieve the old memory size */
|
||||
if(UserByteManager.done->JudgeStaticOrDynamic(oldnode)) {
|
||||
if (UserByteManager.done->JudgeStaticOrDynamic(oldnode)) {
|
||||
oldsize = ((struct segment*)(oldnode->size))->block_size;
|
||||
} else {
|
||||
oldsize = oldnode->size - SIZEOF_DYNAMICALLOCNODE_MEM;
|
||||
|
|
@ -1030,12 +1028,12 @@ void *x_urealloc(void *pointer, x_size_t size)
|
|||
|
||||
/* allocate new memory */
|
||||
newmem = x_umalloc(size);
|
||||
if(newmem == NONE) {
|
||||
if (newmem == NONE) {
|
||||
return NONE;
|
||||
}
|
||||
|
||||
/* copy the old memory and then release old memory pointer */
|
||||
memcpy((char*)newmem, (char*) pointer,size > oldsize ? oldsize : size);
|
||||
memcpy((char*)newmem, (char*)pointer, size > oldsize ? oldsize : size);
|
||||
x_ufree(pointer);
|
||||
|
||||
return newmem;
|
||||
|
|
@ -1049,12 +1047,12 @@ void *x_urealloc(void *pointer, x_size_t size)
|
|||
*
|
||||
* @return pointer on success; NULL on failure
|
||||
*/
|
||||
void *x_ucalloc(x_size_t count, x_size_t size)
|
||||
void* x_ucalloc(x_size_t count, x_size_t size)
|
||||
{
|
||||
void *p = NONE;
|
||||
void* p = NONE;
|
||||
|
||||
/* parameter detection */
|
||||
if(count * size > UserByteManager.dynamic_buddy_manager.dynamic_buddy_end - UserByteManager.dynamic_buddy_manager.dynamic_buddy_start - UserByteManager.dynamic_buddy_manager.active_memory)
|
||||
if (count * size > UserByteManager.dynamic_buddy_manager.dynamic_buddy_end - UserByteManager.dynamic_buddy_manager.dynamic_buddy_start - UserByteManager.dynamic_buddy_manager.active_memory)
|
||||
return NONE;
|
||||
|
||||
/* calls x_malloc to allocate count * size memory */
|
||||
|
|
@ -1072,37 +1070,37 @@ void *x_ucalloc(x_size_t count, x_size_t size)
|
|||
*
|
||||
* @param pointer the memory to be released
|
||||
*/
|
||||
void x_ufree(void *pointer)
|
||||
void x_ufree(void* pointer)
|
||||
{
|
||||
x_base lock = 0;
|
||||
struct DynamicAllocNode *node = NONE;
|
||||
struct DynamicAllocNode* node = NONE;
|
||||
|
||||
/* parameter detection */
|
||||
if (pointer == NONE)
|
||||
return ;
|
||||
CHECK(UserByteManager.dynamic_buddy_manager.done->JudgeLegal(&UserByteManager.dynamic_buddy_manager,pointer));
|
||||
return;
|
||||
CHECK(UserByteManager.dynamic_buddy_manager.done->JudgeLegal(&UserByteManager.dynamic_buddy_manager, pointer));
|
||||
|
||||
/* hold lock before release */
|
||||
lock = CriticalAreaLock();
|
||||
node = PTR2ALLOCNODE((char*)pointer-SIZEOF_DYNAMICALLOCNODE_MEM);
|
||||
lock = FREE_LIST_LOCK();
|
||||
node = PTR2ALLOCNODE((char*)pointer - SIZEOF_DYNAMICALLOCNODE_MEM);
|
||||
CHECK(UserByteManager.done->JudgeAllocated(node));
|
||||
|
||||
#ifdef MEM_EXTERN_SRAM
|
||||
/* judge the pointer is not malloced from extern memory*/
|
||||
if(0 == (node->flag & 0xFF0000)) {
|
||||
UserByteManager.dynamic_buddy_manager.done->release(&ByteManager,pointer);
|
||||
if (0 == (node->flag & 0xFF0000)) {
|
||||
UserByteManager.dynamic_buddy_manager.done->release(&ByteManager, pointer);
|
||||
}
|
||||
|
||||
/* judge the pointer is malloced from extern memory*/
|
||||
if(0 != (node->flag & 0xFF0000)) {
|
||||
ExtByteManager[((node->flag & 0xFF0000) >> 16) - 1].dynamic_buddy_manager.done->release(&ExtByteManager[((node->flag & 0xFF0000) >> 16) - 1],pointer);
|
||||
if (0 != (node->flag & 0xFF0000)) {
|
||||
ExtByteManager[((node->flag & 0xFF0000) >> 16) - 1].dynamic_buddy_manager.done->release(&ExtByteManager[((node->flag & 0xFF0000) >> 16) - 1], pointer);
|
||||
}
|
||||
|
||||
#else
|
||||
UserByteManager.dynamic_buddy_manager.done->release(&UserByteManager,pointer);
|
||||
UserByteManager.dynamic_buddy_manager.done->release(&UserByteManager, pointer);
|
||||
#endif
|
||||
/* release the lock */
|
||||
CriticalAreaUnLock(lock);
|
||||
FREE_LIST_UNLOCK(lock);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1213,7 +1211,7 @@ void ShowBuddy(void)
|
|||
int lock = 0;
|
||||
struct DynamicFreeNode *debug = NONE;
|
||||
|
||||
lock = CriticalAreaLock();
|
||||
lock = FREE_LIST_LOCK();
|
||||
KPrintf("\n\033[41;1mlist memory information\033[0m\n", __func__);
|
||||
for(int level = 0; level < MEM_LINKNRS; level++) {
|
||||
KPrintf("%s level [%d],memory size[2^%d] \n",__func__, level,level +6);
|
||||
|
|
@ -1258,7 +1256,7 @@ void ShowBuddy(void)
|
|||
}
|
||||
|
||||
#endif
|
||||
CriticalAreaUnLock(lock);
|
||||
FREE_LIST_UNLOCK(lock);
|
||||
}
|
||||
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0),
|
||||
ShowBuddy,ShowBuddy,list memory usage information);
|
||||
|
|
|
|||
|
|
@ -94,7 +94,7 @@ static x_err_t _MsgQueueSend(struct MsgQueue* mq,
|
|||
NULL_PARAM_CHECK(mq);
|
||||
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));
|
||||
SYS_KDEBUG_LOG(MSGQUEUE_DEBUG, ("[%s] mq_num_msgs: %d, block size: %d, needed size: %lu\n", __func__, mq->num_msgs, mq->each_len, size));
|
||||
|
||||
if (size > mq->each_len)
|
||||
return -ERROR;
|
||||
|
|
|
|||
|
|
@ -175,9 +175,9 @@ SWITCH:
|
|||
HOOK(hook.assign.hook_Assign,(runningtask, new_task));
|
||||
|
||||
SYS_KDEBUG_LOG(KDBG_SCHED,
|
||||
("[%d]switch to priority#%d "
|
||||
"task:%.*s(sp:0x%08x), "
|
||||
"from task:%.*s(sp: 0x%08x)\n",
|
||||
("[%d]switch to priority#%ld "
|
||||
"task:%.*s(sp:0x%8p), "
|
||||
"from task:%.*s(sp: 0x%8p)\n",
|
||||
isrManager.done->getCounter(), highest_prio,
|
||||
NAME_NUM_MAX, new_task->task_base_info.name, new_task->stack_point,
|
||||
NAME_NUM_MAX, runningtask->task_base_info.name, runningtask->stack_point));
|
||||
|
|
@ -442,9 +442,9 @@ x_err_t YieldOsAssign(void)
|
|||
HOOK(hook.assign.hook_Assign,(runningtask, new_task));
|
||||
|
||||
SYS_KDEBUG_LOG(KDBG_SCHED,
|
||||
("[%d]switch to priority#%d "
|
||||
"task:%.*s(sp:0x%08x), "
|
||||
"from task:%.*s(sp: 0x%08x)\n",
|
||||
("[%d]switch to priority#%ld "
|
||||
"task:%.*s(sp:0x%8p), "
|
||||
"from task:%.*s(sp: 0x%8p)\n",
|
||||
isrManager.done->getCounter(), highest_prio,
|
||||
NAME_NUM_MAX, new_task->task_base_info.name, new_task->stack_point,
|
||||
NAME_NUM_MAX, runningtask->task_base_info.name, runningtask->stack_point));
|
||||
|
|
|
|||
|
|
@ -112,6 +112,21 @@ KERNELPATHS += \
|
|||
-I$(BSP_ROOT)/third_party_driver/drivers \
|
||||
-I$(BSP_ROOT)/third_party_driver/lcd \
|
||||
-I$(KERNEL_ROOT)/include #
|
||||
|
||||
ifeq ($(CONFIG_RESOURCES_LWIP),y)
|
||||
KERNELPATHS += \
|
||||
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include \
|
||||
-I$(KERNEL_ROOT)/resources/ethernet/LwIP \
|
||||
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/compat \
|
||||
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip \
|
||||
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/netif \
|
||||
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/apps \
|
||||
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/priv \
|
||||
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/prot \
|
||||
-I$(KERNEL_ROOT)/resources/ethernet/LwIP/arch
|
||||
|
||||
KERNELPATHS += -I$(KERNEL_ROOT)/resources/include/netdev
|
||||
endif
|
||||
endif
|
||||
|
||||
ifeq ($(BSP_ROOT),$(KERNEL_ROOT)/board/kd233)
|
||||
|
|
|
|||
|
|
@ -35,6 +35,15 @@
|
|||
/* ---------- Debug options ---------- */
|
||||
#ifndef LWIP_DEBUG
|
||||
#define LWIP_DEBUG 1
|
||||
// #define LWIP_SOCKET_DEBUG
|
||||
// #define LWIP_TCPIP_DEBUG
|
||||
// #define LWIP_MEMP_DEBUG
|
||||
// #define LWIP_PBUF_DEBUG
|
||||
// #define LWIP_TCP_INPUT_DEBUG
|
||||
// #define LWIP_TCP_OUTPUT_DEBUG
|
||||
// #define LWIP_NETIF_DEBUG
|
||||
// #define LWIP_ETHARP_DEBUG
|
||||
// #define LWIP_API_MSG_DEBUG
|
||||
#endif
|
||||
|
||||
#ifdef LWIP_DEBUG
|
||||
|
|
@ -208,7 +217,6 @@
|
|||
|
||||
#endif /* LWIP_DEBUG */
|
||||
|
||||
|
||||
#define LWIP_TIMEVAL_PRIVATE 0
|
||||
#define LWIP_NO_UNISTD_H 0
|
||||
#define LWIP_NO_STDDEF_H 0
|
||||
|
|
@ -219,6 +227,7 @@
|
|||
#define LWIP_SOCKET_SELECT 1
|
||||
#define LWIP_SOCKET_POLL 1
|
||||
|
||||
#define LWIP_DHCP_DOES_ACD_CHECK 0
|
||||
/**
|
||||
* SYS_LIGHTWEIGHT_PROT==1: if you want inter-task protection for certain
|
||||
* critical regions during buffer allocation, deallocation and memory
|
||||
|
|
@ -242,11 +251,19 @@
|
|||
/* MEM_ALIGNMENT: should be set to the alignment of the CPU for which
|
||||
lwIP is compiled. 4 byte alignment -> define MEM_ALIGNMENT to 4, 2
|
||||
byte alignment -> define MEM_ALIGNMENT to 2. */
|
||||
#ifndef RISCV_LWIP
|
||||
#define MEM_ALIGNMENT 4
|
||||
#else
|
||||
#define MEM_ALIGNMENT 8
|
||||
#endif
|
||||
|
||||
/* MEM_SIZE: the size of the heap memory. If the application will send
|
||||
a lot of data that needs to be copied, this should be set high. */
|
||||
#define MEM_SIZE (64*1024)
|
||||
#ifndef RISCV_LWIP
|
||||
#define MEM_SIZE (64 * 1024)
|
||||
#else
|
||||
#define MEM_SIZE (32 * 1024)
|
||||
#endif
|
||||
|
||||
/* MEMP_NUM_PBUF: the number of memp struct pbufs. If the application
|
||||
sends a lot of data out of ROM (or other static memory), this
|
||||
|
|
@ -267,14 +284,14 @@ a lot of data that needs to be copied, this should be set high. */
|
|||
/* MEMP_NUM_SYS_TIMEOUT: the number of simulateously active
|
||||
timeouts. */
|
||||
// #define MEMP_NUM_SYS_TIMEOUT 6
|
||||
#define MEMP_NUM_SYS_TIMEOUT (LWIP_TCP + IP_REASSEMBLY + LWIP_ARP + (2*LWIP_DHCP) + LWIP_AUTOIP + LWIP_IGMP + LWIP_DNS + PPP_SUPPORT + (LWIP_IPV6 ? (1 + (2*LWIP_IPV6)) : 0))
|
||||
#define MEMP_NUM_SYS_TIMEOUT (LWIP_TCP + IP_REASSEMBLY + LWIP_ARP + (2 * LWIP_DHCP) + LWIP_AUTOIP + LWIP_IGMP + LWIP_DNS + PPP_SUPPORT + (LWIP_IPV6 ? (1 + (2 * LWIP_IPV6)) : 0))
|
||||
|
||||
/* ---------- Pbuf options ---------- */
|
||||
/* PBUF_POOL_SIZE: the number of buffers in the pbuf pool. */
|
||||
#define PBUF_POOL_SIZE 255
|
||||
/* PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. */
|
||||
// #define PBUF_POOL_BUFSIZE 1024
|
||||
#define PBUF_POOL_BUFSIZE LWIP_MEM_ALIGN_SIZE(TCP_MSS+40+PBUF_LINK_ENCAPSULATION_HLEN+PBUF_LINK_HLEN)
|
||||
#define PBUF_POOL_BUFSIZE LWIP_MEM_ALIGN_SIZE(TCP_MSS + 40 + PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN)
|
||||
|
||||
/* ---------- ARP options ---------- */
|
||||
#define LWIP_ARP 1
|
||||
|
|
@ -287,24 +304,23 @@ a lot of data that needs to be copied, this should be set high. */
|
|||
|
||||
/* Controls if TCP should queue segments that arrive out of
|
||||
order. Define to 0 if your device is low on memory. */
|
||||
#define TCP_QUEUE_OOSEQ 1
|
||||
#define TCP_QUEUE_OOSEQ 0
|
||||
|
||||
/* TCP Maximum segment size. */
|
||||
#define TCP_MSS (1500 - 40) /* TCP_MSS = (Ethernet MTU - IP header size - TCP header size) */
|
||||
|
||||
/* TCP sender buffer space (bytes). */
|
||||
#define TCP_SND_BUF (11*TCP_MSS)
|
||||
#define TCP_SND_BUF (11 * TCP_MSS)
|
||||
|
||||
/* TCP_SND_QUEUELEN: TCP sender buffer space (pbufs). This must be at least
|
||||
as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work. */
|
||||
|
||||
#define TCP_SND_QUEUELEN (8* TCP_SND_BUF/TCP_MSS)
|
||||
#define TCP_SND_QUEUELEN (8 * TCP_SND_BUF / TCP_MSS)
|
||||
|
||||
/* TCP receive window. */
|
||||
#define TCP_WND 8192
|
||||
// #define TCP_WND (12 * TCP_MSS)
|
||||
|
||||
|
||||
/* Maximum number of retransmissions of data segments. */
|
||||
#define TCP_MAXRTX 12
|
||||
|
||||
|
|
@ -367,19 +383,16 @@ a lot of data that needs to be copied, this should be set high. */
|
|||
/* ---------- ICMP options ---------- */
|
||||
#define LWIP_ICMP 1
|
||||
|
||||
|
||||
/* ---------- DHCP options ---------- */
|
||||
/* Define LWIP_DHCP to 1 if you want DHCP configuration of
|
||||
interfaces. DHCP is not implemented in lwIP 0.5.1, however, so
|
||||
turning this on does currently not work. */
|
||||
#define LWIP_DHCP 1
|
||||
|
||||
|
||||
/* ---------- UDP options ---------- */
|
||||
#define LWIP_UDP 1
|
||||
#define UDP_TTL 255
|
||||
|
||||
|
||||
/* ---------- Statistics options ---------- */
|
||||
#define LWIP_PROVIDE_ERRNO 1
|
||||
|
||||
|
|
@ -399,41 +412,40 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums
|
|||
- To use this feature let the following define uncommented.
|
||||
- To disable it and process by CPU comment the the checksum.
|
||||
*/
|
||||
#define CHECKSUM_BY_HARDWARE
|
||||
// #define CHECKSUM_BY_HARDWARE
|
||||
|
||||
#ifdef CHECKSUM_BY_HARDWARE
|
||||
/* CHECKSUM_GEN_IP==0: Generate checksums by hardware for outgoing IP packets.*/
|
||||
#define CHECKSUM_GEN_IP 0
|
||||
/* CHECKSUM_GEN_UDP==0: Generate checksums by hardware for outgoing UDP packets.*/
|
||||
#define CHECKSUM_GEN_UDP 0
|
||||
/* CHECKSUM_GEN_TCP==0: Generate checksums by hardware for outgoing TCP packets.*/
|
||||
#define CHECKSUM_GEN_TCP 0
|
||||
/* CHECKSUM_CHECK_IP==0: Check checksums by hardware for incoming IP packets.*/
|
||||
#define CHECKSUM_CHECK_IP 0
|
||||
/* CHECKSUM_CHECK_UDP==0: Check checksums by hardware for incoming UDP packets.*/
|
||||
#define CHECKSUM_CHECK_UDP 0
|
||||
/* CHECKSUM_CHECK_TCP==0: Check checksums by hardware for incoming TCP packets.*/
|
||||
#define CHECKSUM_CHECK_TCP 0
|
||||
/* CHECKSUM_CHECK_ICMP==0: Check checksums by hardware for incoming ICMP packets.*/
|
||||
#define CHECKSUM_GEN_ICMP 0
|
||||
/* CHECKSUM_GEN_IP==0: Generate checksums by hardware for outgoing IP packets.*/
|
||||
#define CHECKSUM_GEN_IP 0
|
||||
/* CHECKSUM_GEN_UDP==0: Generate checksums by hardware for outgoing UDP packets.*/
|
||||
#define CHECKSUM_GEN_UDP 0
|
||||
/* CHECKSUM_GEN_TCP==0: Generate checksums by hardware for outgoing TCP packets.*/
|
||||
#define CHECKSUM_GEN_TCP 0
|
||||
/* CHECKSUM_CHECK_IP==0: Check checksums by hardware for incoming IP packets.*/
|
||||
#define CHECKSUM_CHECK_IP 0
|
||||
/* CHECKSUM_CHECK_UDP==0: Check checksums by hardware for incoming UDP packets.*/
|
||||
#define CHECKSUM_CHECK_UDP 0
|
||||
/* CHECKSUM_CHECK_TCP==0: Check checksums by hardware for incoming TCP packets.*/
|
||||
#define CHECKSUM_CHECK_TCP 0
|
||||
/* CHECKSUM_CHECK_ICMP==0: Check checksums by hardware for incoming ICMP packets.*/
|
||||
#define CHECKSUM_GEN_ICMP 0
|
||||
#else
|
||||
/* CHECKSUM_GEN_IP==1: Generate checksums in software for outgoing IP packets.*/
|
||||
#define CHECKSUM_GEN_IP 1
|
||||
/* CHECKSUM_GEN_UDP==1: Generate checksums in software for outgoing UDP packets.*/
|
||||
#define CHECKSUM_GEN_UDP 1
|
||||
/* CHECKSUM_GEN_TCP==1: Generate checksums in software for outgoing TCP packets.*/
|
||||
#define CHECKSUM_GEN_TCP 1
|
||||
/* CHECKSUM_CHECK_IP==1: Check checksums in software for incoming IP packets.*/
|
||||
#define CHECKSUM_CHECK_IP 1
|
||||
/* CHECKSUM_CHECK_UDP==1: Check checksums in software for incoming UDP packets.*/
|
||||
#define CHECKSUM_CHECK_UDP 1
|
||||
/* CHECKSUM_CHECK_TCP==1: Check checksums in software for incoming TCP packets.*/
|
||||
#define CHECKSUM_CHECK_TCP 1
|
||||
/* CHECKSUM_CHECK_ICMP==1: Check checksums by software for incoming ICMP packets.*/
|
||||
#define CHECKSUM_GEN_ICMP 1
|
||||
/* CHECKSUM_GEN_IP==1: Generate checksums in software for outgoing IP packets.*/
|
||||
#define CHECKSUM_GEN_IP 1
|
||||
/* CHECKSUM_GEN_UDP==1: Generate checksums in software for outgoing UDP packets.*/
|
||||
#define CHECKSUM_GEN_UDP 1
|
||||
/* CHECKSUM_GEN_TCP==1: Generate checksums in software for outgoing TCP packets.*/
|
||||
#define CHECKSUM_GEN_TCP 1
|
||||
/* CHECKSUM_CHECK_IP==1: Check checksums in software for incoming IP packets.*/
|
||||
#define CHECKSUM_CHECK_IP 1
|
||||
/* CHECKSUM_CHECK_UDP==1: Check checksums in software for incoming UDP packets.*/
|
||||
#define CHECKSUM_CHECK_UDP 1
|
||||
/* CHECKSUM_CHECK_TCP==1: Check checksums in software for incoming TCP packets.*/
|
||||
#define CHECKSUM_CHECK_TCP 1
|
||||
/* CHECKSUM_CHECK_ICMP==1: Check checksums by software for incoming ICMP packets.*/
|
||||
#define CHECKSUM_GEN_ICMP 1
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
----------------------------------------------
|
||||
---------- Sequential layer options ----------
|
||||
|
|
@ -442,7 +454,11 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums
|
|||
/**
|
||||
* LWIP_NETCONN==1: Enable Netconn API (require to use api_lib.c)
|
||||
*/
|
||||
// #ifndef RISCV_LWIP
|
||||
// #define LWIP_NETCONN 1
|
||||
// #else
|
||||
#define LWIP_NETCONN 1
|
||||
// #endif
|
||||
|
||||
/*
|
||||
------------------------------------
|
||||
|
|
@ -459,7 +475,7 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums
|
|||
*/
|
||||
#define LWIP_SO_RCVBUF 1
|
||||
|
||||
/**
|
||||
/**
|
||||
* LWIP_SO_SNDTIMEO==1: Enable send timeout for sockets/netconns and
|
||||
* SO_SNDTIMEO processing.
|
||||
*/
|
||||
|
|
@ -467,7 +483,7 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums
|
|||
#define LWIP_SO_SNDTIMEO 1
|
||||
#endif
|
||||
|
||||
/**
|
||||
/**
|
||||
* LWIP_SO_RCVTIMEO==1: Enable receive timeout for sockets/netconns and
|
||||
* SO_RCVTIMEO processing.
|
||||
*/
|
||||
|
|
@ -475,7 +491,7 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums
|
|||
#define LWIP_SO_RCVTIMEO 1
|
||||
#endif
|
||||
|
||||
/**
|
||||
/**
|
||||
* LWIP_SO_LINGER==1: Enable SO_LINGER processing.
|
||||
*/
|
||||
// #define LWIP_SO_LINGER 1
|
||||
|
|
@ -514,11 +530,9 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums
|
|||
#define LWIP_AUTOIP 0
|
||||
#define LWIP_DHCP_AUTOIP_COOP (LWIP_DHCP && LWIP_AUTOIP)
|
||||
|
||||
|
||||
#define LWIP_UDPLITE 0
|
||||
#define UDP_TTL 255
|
||||
|
||||
|
||||
/* ---------- Statistics options ---------- */
|
||||
#define LWIP_STATS 1
|
||||
#define LWIP_STATS_DISPLAY 1
|
||||
|
|
@ -532,13 +546,13 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums
|
|||
#define DEFAULT_RAW_RECVMBOX_SIZE 8
|
||||
#define DEFAULT_UDP_RECVMBOX_SIZE 8
|
||||
#define DEFAULT_TCP_RECVMBOX_SIZE 8
|
||||
#define DEFAULT_ACCEPTMBOX_SIZE 10
|
||||
#define DEFAULT_ACCEPTMBOX_SIZE 12
|
||||
|
||||
#define DEFAULT_THREAD_PRIO 20
|
||||
#define DEFAULT_THREAD_STACKSIZE 2048
|
||||
|
||||
#define TCPIP_THREAD_NAME "tcp"
|
||||
#define TCPIP_THREAD_STACKSIZE 2048
|
||||
#define TCPIP_THREAD_STACKSIZE 4096
|
||||
#define TCPIP_MBOX_SIZE 16
|
||||
#define TCPIP_THREAD_PRIO 30
|
||||
|
||||
|
|
@ -559,7 +573,6 @@ The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums
|
|||
typedef unsigned int nfds_t;
|
||||
#endif
|
||||
|
||||
|
||||
#define MEMP_LIB_MALLOC 1
|
||||
#define MEMP_MEM_MALLOC 1
|
||||
|
||||
|
|
@ -570,4 +583,3 @@ typedef unsigned int nfds_t;
|
|||
#endif /* __LWIPOPTS_H__ */
|
||||
|
||||
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
||||
|
||||
|
|
|
|||
|
|
@ -338,11 +338,11 @@ void lwip_config_input(struct netif* net)
|
|||
|
||||
th_id = sys_thread_new("eth_input", ethernetif_input, net, LWIP_TASK_STACK_SIZE, 30);
|
||||
|
||||
if (th_id >= 0) {
|
||||
lw_print("%s %d successfully!\n", __func__, th_id);
|
||||
} else {
|
||||
lw_print("%s failed!\n", __func__);
|
||||
}
|
||||
// if (th_id >= 0) {
|
||||
// lw_print("%s %d successfully!\n", __func__, th_id);
|
||||
// } else {
|
||||
// lw_print("%s failed!\n", __func__);
|
||||
// }
|
||||
}
|
||||
|
||||
void lwip_config_tcp(uint8_t enet_port, char* ip, char* mask, char* gw)
|
||||
|
|
@ -387,7 +387,7 @@ void lwip_config_tcp(uint8_t enet_port, char* ip, char* mask, char* gw)
|
|||
#endif
|
||||
}
|
||||
|
||||
netif_set_default(&gnetif);
|
||||
// netif_set_default(&gnetif);
|
||||
netif_set_up(&gnetif);
|
||||
|
||||
lw_print("\r\n************************************************\r\n");
|
||||
|
|
|
|||
|
|
@ -200,7 +200,9 @@ typedef uintptr_t mem_ptr_t;
|
|||
#include <unistd.h>
|
||||
#endif
|
||||
#else /* SSIZE_MAX */
|
||||
#ifndef RISCV_LWIP
|
||||
typedef int ssize_t;
|
||||
#endif
|
||||
#define SSIZE_MAX INT_MAX
|
||||
#endif /* SSIZE_MAX */
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
SRC_FILES := ping.c lwip_ping_demo.c lwip_tcp_demo.c lwip_udp_demo.c tcpecho_raw.c lwip_config_demo.c lwip_dhcp_demo.c iperf.c http_test.c
|
||||
# SRC_FILES := ping.c lwip_ping_demo.c lwip_tcp_demo.c lwip_udp_demo.c tcpecho_raw.c lwip_config_demo.c lwip_dhcp_demo.c iperf.c
|
||||
# SRC_FILES := ping.c lwip_ping_demo.c lwip_config_demo.c lwip_dhcp_demo.c iperf.c http_test.c
|
||||
SRC_FILES := ping.c lwip_ping_demo.c lwip_tcp_demo.c lwip_udp_demo.c tcpecho_raw.c lwip_config_demo.c lwip_dhcp_demo.c iperf.c
|
||||
|
||||
include $(KERNEL_ROOT)/compiler.mk
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ void httpc_app_recv_end(void *arg, httpc_result_t httpc_result, u32_t rx_content
|
|||
httpc_state_t **req = (httpc_state_t**)arg;
|
||||
|
||||
LWIP_DEBUGF(LWIP_DEBUG, ("[HTTPC] Transfer finished. rx_content_len is %lu\r\n", rx_content_len));
|
||||
printf("[HTTPC] Transfer finished. rx_content_len is %lu\r\n", rx_content_len);
|
||||
printf("[HTTPC] Transfer finished. rx_content_len is %u\r\n", rx_content_len);
|
||||
*req = NULL;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -266,6 +266,8 @@ void iperf_server_worker(void* arg) {
|
|||
struct sock_conn_cb *sccb = (struct sock_conn_cb *)arg;
|
||||
x_ticks_t tick1, tick2;
|
||||
|
||||
int cur_tid = GetKTaskDescriptor()->id.id;
|
||||
|
||||
uint8_t *recv_data = (uint8_t *)malloc(IPERF_BUFSZ);
|
||||
if(recv_data == NULL) {
|
||||
KPrintf("[%s] No Memory.\n", __func__);
|
||||
|
|
@ -282,8 +284,6 @@ void iperf_server_worker(void* arg) {
|
|||
(void *) &flag, /* the cast is historical cruft */
|
||||
sizeof(int)); /* length of option value */
|
||||
|
||||
int cur_tid = GetKTaskDescriptor()->id.id;
|
||||
|
||||
tick1 = CurrentTicksGain();
|
||||
while (param.mode != IPERF_MODE_STOP) {
|
||||
bytes_received = recv(sccb->connected, recv_data, IPERF_BUFSZ, 0);
|
||||
|
|
@ -393,7 +393,7 @@ __exit:
|
|||
|
||||
void iperf_server(void *thread_param)
|
||||
{
|
||||
uint8_t *recv_data;
|
||||
uint8_t* recv_data = NULL;
|
||||
socklen_t sin_size;
|
||||
x_ticks_t tick1, tick2;
|
||||
int sock = -1, connected, bytes_received;
|
||||
|
|
|
|||
|
|
@ -41,10 +41,10 @@ void LwipSetIPTest(int argc, char* argv[])
|
|||
{
|
||||
if (argc >= 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[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[4], "%d", &enet_id);
|
||||
sscanf(argv[1], "%hhd.%hhd.%hhd.%hhd", &lwip_ipaddr[0], &lwip_ipaddr[1], &lwip_ipaddr[2], &lwip_ipaddr[3]);
|
||||
sscanf(argv[2], "%hhd.%hhd.%hhd.%hhd", &lwip_netmask[0], &lwip_netmask[1], &lwip_netmask[2], &lwip_netmask[3]);
|
||||
sscanf(argv[3], "%hhd.%hhd.%hhd.%hhd", &lwip_gwaddr[0], &lwip_gwaddr[1], &lwip_gwaddr[2], &lwip_gwaddr[3]);
|
||||
sscanf(argv[4], "%hhd", &enet_id);
|
||||
|
||||
if (0 == enet_id) {
|
||||
printf("save eth0 info\n");
|
||||
|
|
@ -59,7 +59,7 @@ void LwipSetIPTest(int argc, char* argv[])
|
|||
}
|
||||
} else if (argc == 2) {
|
||||
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], "%hhd.%hhd.%hhd.%hhd", &lwip_ipaddr[0], &lwip_ipaddr[1], &lwip_ipaddr[2], &lwip_ipaddr[3]);
|
||||
memcpy(lwip_eth0_ipaddr, lwip_ipaddr, strlen(lwip_ipaddr));
|
||||
}
|
||||
// sys_thread_new("SET ip address", LwipSetIPTask, &enet_id, LWIP_TASK_STACK_SIZE, LWIP_DEMO_TASK_PRIO);
|
||||
|
|
|
|||
|
|
@ -144,13 +144,13 @@ void LwipDHCPTest(void)
|
|||
/* Print DHCP progress */
|
||||
if(LwipPrintDHCP(&gnetif))
|
||||
{
|
||||
sscanf(ipaddr_ntoa(&gnetif.ip_addr), "%d.%d.%d.%d", &lwip_ipaddr[0], &lwip_ipaddr[1],
|
||||
sscanf(ipaddr_ntoa(&gnetif.ip_addr), "%hhd.%hhd.%hhd.%hhd", &lwip_ipaddr[0], &lwip_ipaddr[1],
|
||||
&lwip_ipaddr[2], &lwip_ipaddr[3]);
|
||||
|
||||
sscanf(ipaddr_ntoa(&gnetif.netmask), "%d.%d.%d.%d", &lwip_netmask[0], &lwip_netmask[1],
|
||||
sscanf(ipaddr_ntoa(&gnetif.netmask), "%hhd.%hhd.%hhd.%hhd", &lwip_netmask[0], &lwip_netmask[1],
|
||||
&lwip_netmask[2], &lwip_netmask[3]);
|
||||
|
||||
sscanf(ipaddr_ntoa(&gnetif.gw), "%d.%d.%d.%d", &lwip_gwaddr[0], &lwip_gwaddr[1],
|
||||
sscanf(ipaddr_ntoa(&gnetif.gw), "%hhd.%hhd.%hhd.%hhd", &lwip_gwaddr[0], &lwip_gwaddr[1],
|
||||
&lwip_gwaddr[2], &lwip_gwaddr[3]);
|
||||
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -47,8 +47,7 @@ void LwipPingTest(int argc, char *argv[])
|
|||
printf("lw: [%s] ping %s\n", __func__, argv[1]);
|
||||
if(isdigit(argv[1][0]))
|
||||
{
|
||||
if(sscanf(argv[1], "%d.%d.%d.%d", &arg_ip[0], &arg_ip[1], &arg_ip[2], &arg_ip[3]) == EOF)
|
||||
{
|
||||
if (sscanf(argv[1], "%hhd.%hhd.%hhd.%hhd", &arg_ip[0], &arg_ip[1], &arg_ip[2], &arg_ip[3]) == EOF) {
|
||||
lw_notice("input wrong ip\n");
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@
|
|||
#include "tcpecho_raw.h"
|
||||
char tcp_demo_msg[LWIP_TEST_MSG_SIZE] = { 0 };
|
||||
char tcp_server_ip[] = {192, 168, 130, 2};
|
||||
u16_t tcp_server_port = 80;
|
||||
u32_t tcp_server_port = 80;
|
||||
int tcp_send_num = 0;
|
||||
int tcp_send_task_on = 0;
|
||||
uint32 tcp_interval = 50;
|
||||
|
|
@ -101,14 +101,13 @@ void LwipTcpSendTest(int argc, char *argv[])
|
|||
strcat(tcp_demo_msg, "\r\n");
|
||||
|
||||
if(argc >= 3) {
|
||||
if(sscanf(argv[2], "%d.%d.%d.%d:%d", &tcp_server_ip[0], &tcp_server_ip[1], &tcp_server_ip[2], &tcp_server_ip[3], &tcp_server_port) == EOK)
|
||||
{
|
||||
sscanf(argv[2], "%d.%d.%d.%d", &tcp_server_ip[0], &tcp_server_ip[1], &tcp_server_ip[2], &tcp_server_ip[3]);
|
||||
if (sscanf(argv[2], "%hhd.%hhd.%hhd.%hhd:%d", &tcp_server_ip[0], &tcp_server_ip[1], &tcp_server_ip[2], &tcp_server_ip[3], &tcp_server_port) == EOK) {
|
||||
sscanf(argv[2], "%hhd.%hhd.%hhd.%hhd", &tcp_server_ip[0], &tcp_server_ip[1], &tcp_server_ip[2], &tcp_server_ip[3]);
|
||||
}
|
||||
sscanf(argv[3], "%d", &tcp_send_num);
|
||||
sscanf(argv[4], "%d", &tcp_interval);
|
||||
}
|
||||
KPrintf("connect ipaddr %d.%d.%d.%d:%d send msg %d times\n", tcp_server_ip[0], tcp_server_ip[1], tcp_server_ip[2], tcp_server_ip[3], tcp_server_port, tcp_send_num);
|
||||
KPrintf("connect ipaddr %hhd.%hhd.%hhd.%hhd:%hhd send msg %d times\n", tcp_server_ip[0], tcp_server_ip[1], tcp_server_ip[2], tcp_server_ip[3], tcp_server_port, tcp_send_num);
|
||||
lwip_config_tcp(enet_port, lwip_ipaddr, lwip_netmask, lwip_gwaddr);
|
||||
|
||||
memcpy(param.ip, tcp_server_ip, 4);
|
||||
|
|
@ -128,7 +127,7 @@ void LwipTcpRecvTest(void)
|
|||
|
||||
lwip_config_tcp(enet_port, lwip_ipaddr, lwip_netmask, lwip_gwaddr);
|
||||
|
||||
uint8_t *recv_data;
|
||||
uint8_t* recv_data = NULL;
|
||||
socklen_t sin_size;
|
||||
int sock = -1, connected, bytes_received, i;
|
||||
struct sockaddr_in server_addr, client_addr;
|
||||
|
|
|
|||
|
|
@ -165,12 +165,12 @@ static int LwipUdpSend(int argc, char* argv[])
|
|||
}
|
||||
|
||||
// translate string to array
|
||||
sscanf(ip_ptr, "%d.%d.%d.%d", &get_udp_test_info()->ip[0], &get_udp_test_info()->ip[1], &get_udp_test_info()->ip[2], &get_udp_test_info()->ip[3]);
|
||||
sscanf(ip_ptr, "%hhd.%hhd.%hhd.%hhd", &get_udp_test_info()->ip[0], &get_udp_test_info()->ip[1], &get_udp_test_info()->ip[2], &get_udp_test_info()->ip[3]);
|
||||
int msg_len = strlen(msg_ptr);
|
||||
strncpy(udp_demo_buffer, msg_ptr, msg_len < UDP_BUFFER_SIZE ? msg_len : UDP_BUFFER_SIZE);
|
||||
|
||||
/* start task */
|
||||
KPrintf("[%s] gw %d.%d.%d.%d:%d send time %d udp_interval %d\n", __func__,
|
||||
KPrintf("[%s] gw %hhd.%hhd.%hhd.%hhd:%d send time %d udp_interval %d\n", __func__,
|
||||
get_udp_test_info()->ip[0], get_udp_test_info()->ip[1], get_udp_test_info()->ip[2], get_udp_test_info()->ip[3],
|
||||
get_udp_test_info()->port,
|
||||
get_udp_test_info()->num,
|
||||
|
|
@ -191,7 +191,7 @@ void LwipUdpRecvTest(void)
|
|||
//init lwip and net dirver
|
||||
lwip_config_net(enet_port, lwip_ipaddr, lwip_netmask, lwip_gwaddr);
|
||||
|
||||
uint8_t *recv_data;
|
||||
uint8_t* recv_data = NULL;
|
||||
socklen_t sin_size;
|
||||
int sock = -1, connected, bytes_received, i;
|
||||
struct sockaddr_in server_addr, client_addr;
|
||||
|
|
|
|||
|
|
@ -119,7 +119,7 @@ tcpecho_raw_ack_size(struct tcp_pcb *tpcb, int ack_len)
|
|||
|
||||
// ack message
|
||||
ack_buf = pbuf_alloc(PBUF_TRANSPORT, TCP_ACK_MSG_SIZE, PBUF_RAM);
|
||||
snprintf(ack_buf->payload, TCP_ACK_MSG_SIZE, "%d\n\0", ack_len);
|
||||
snprintf(ack_buf->payload, TCP_ACK_MSG_SIZE, "%d\n", ack_len);
|
||||
ack_buf->len = strlen(ack_buf->payload);
|
||||
ack_buf->tot_len = strlen(ack_buf->payload);
|
||||
ack_buf->next = NULL;
|
||||
|
|
|
|||
|
|
@ -788,7 +788,7 @@ void OTA_Download(int size, int offset)
|
|||
|
||||
/*******************************************************************************
|
||||
* 函 数 名: app_ota_by_platform
|
||||
* 功能描述: 通过命令来进行ota升级,该函数与升级的命令关联,通过云平台MQTT进行升级
|
||||
* 功能描述: 通过云平台MQTT进行升级
|
||||
* 形 参: 无
|
||||
* 返 回 值: 无
|
||||
*******************************************************************************/
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ static int CopyRecursive(const char *from, const char *to, char *buf,
|
|||
|
||||
DIR *dirp;
|
||||
struct dirent *dirent;
|
||||
char *sub_from, *sub_to;
|
||||
char *sub_from = NULL, *sub_to = NULL;
|
||||
|
||||
ret = mkdir(to, 0777);
|
||||
if (ret < 0) {
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ static void PrintOctal(char *str, int len, uint64_t value)
|
|||
char *cp;
|
||||
int written_len;
|
||||
|
||||
written_len = sprintf(buf, "%0*llo", len, value);
|
||||
written_len = sprintf(buf, "%0*lo", len, value);
|
||||
cp = buf + written_len - len;
|
||||
|
||||
if (*cp == '0')
|
||||
|
|
|
|||
Loading…
Reference in New Issue