zouhaitao/TAIXIN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: TXW82x FPV v2.7.0.7-42229 SDK + project sources

Browse Source
This commit is contained in:
zouhaitao
2026-07-06 11:30:13 +08:00
commit e76462eeb7
3451 changed files with 1415300 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
sdk/lib/common/assert.c Normal file
View File

@@ -0,0 +1,54 @@
#include "basic_include.h"
#ifdef CSKY_OS
#include "csi_core.h"
#include <k_api.h>
#include <csi_kernel.h>
#endif
#ifdef OHOS
#include "los_task.h"
#endif
__bobj uint8_t assert_holdup;
void assert_internal(const char *__function, unsigned int __line, const char *__assertion, void *lr)
{
int print_loop = 0;
uint32_t in_int = __in_interrupt();
#ifdef CSKY_OS
#define OS_TSKNAME task_name
ktask_t *task = (ktask_t *)os_task_current();
#endif
#ifdef OHOS
#define OS_TSKNAME taskName
LosTaskCB *task = (LosTaskCB *)os_task_current();
#endif
disable_print(0);
if (assert_holdup) {
disable_irq();
mcu_watchdog_timeout(0); //disable watchdog
jtag_map_set(1);
}
os_printf(KERN_ERR"[%s:%p]: assertation \"%s\" failed: function: %s, line %d, LR:%p\r\n",
(in_int ? "Interrupt" : task->OS_TSKNAME), (in_int ? 0 : task),
__assertion, __function, __line, lr);
sys_errlog_flush(0xffffffff, 0, 0);
if (!in_int && task) {
os_task_dump(task, 0);
}
do {
os_printf(KERN_ERR"[%s:%p]: assertation \"%s\" failed: function: %s, line %d, LR:%p\r\n",
(in_int ? "Interrupt" : task->OS_TSKNAME), (in_int ? 0 : task),
__assertion, __function, __line, lr);
delay_us(1000 * 1000);
} while (assert_holdup || print_loop++ < 5);
mcu_reset();
}

718
sdk/lib/common/atcmd.c Normal file
View File

@@ -0,0 +1,718 @@
#include "sys_config.h"
#include "basic_include.h"
#include "hal/netdev.h"
#include "hal/gpio.h"
#include "lib/atcmd/libatcmd.h"
#include "lib/bus/xmodem/xmodem.h"
#include "lib/lmac/lmac_def.h"
#include "lib/umac/ieee80211.h"
#include "lib/bluetooth/uble/ble_demo.h"
#if SYS_NETWORK_SUPPORT
#include "lwip/netif.h"
#include "lwip/ip_addr.h"
#include "lwip/icmp.h"
#include "lwip/apps/lwiperf.h"
#endif
#include "syscfg.h"
int32 sys_atcmd_errlog(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 0) {
sys_errlog_dump();
} else {
sys_errlog_init(os_atoi(argv[0]), 0);
}
return 0;
}
int32 sys_atcmd_goto_boot(const char *cmd, char *argv[], uint32 argc)
{
os_printf("system goto boot\r\n");
system_goto_boot();
return 0;
}
int32 sys_atcmd_reset(const char *cmd, char *argv[], uint32 argc)
{
atcmd_ok;
if (argc >= 1) {
uint32 run_addr = 0, reset_usb = 0, param = 0;
sys_errlog_flush(0xffffffff, 0, 0);
disable_irq();
mcu_watchdog_feed();
if (argc >= 1) { run_addr = os_atoh(argv[0]); }
if (argc >= 2) { reset_usb = os_atoh(argv[1]); }
if (argc >= 3) { param = os_atoh(argv[2]); }
mcu_watchdog_feed();
// os_printf("reset addr=%08x, rst_usb=%d, param=%d\r\n", run_addr, reset_usb, param);
if (reset_usb) {
pmu_clr_direct_run_pengding2();
} else {
pmu_set_direct_run_pengding2();
}
((void (*)(uint32))run_addr)(param);
} else {
mcu_reset();
}
return 0;
}
int32 sys_atcmd_reboot_test_mode(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 1 && argv[0][0] == '1') {
system_reboot_test_mode();
atcmd_ok;
mcu_reset();
} else {
system_reboot_normal_mode();
atcmd_ok;
mcu_reset();
}
return 0;
}
int32 sys_atcmd_jtag(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 1) {
jtag_map_set(os_atoi(argv[0]) ? 1 : 0);
}
return 0;
}
int32 sys_atcmd_sysdbg(const char *cmd, char *argv[], uint32 argc)
{
char *arg = argv[0];
if (argc == 2) {
if (os_strcasecmp(arg, "heap") == 0) {
sys_status.dbg_heap = (os_atoi(argv[1]) == 1);
}
if (os_strcasecmp(arg, "top") == 0) {
sys_status.dbg_top = os_atoi(argv[1]);
}
if (os_strcasecmp(arg, "umac") == 0) {
sys_status.dbg_umac = (os_atoi(argv[1]) == 1);
}
if (os_strcasecmp(arg, "irq") == 0) {
sys_status.dbg_irq = (os_atoi(argv[1]) == 1);
}
if (os_strcasecmp(arg, "cache") == 0) {
sys_status.dbg_cache = (os_atoi(argv[1]) == 1);
}
if (os_strcasecmp(arg, "net") == 0) {
sys_status.dbg_net = (os_atoi(argv[1]) == 1);
}
return ATCMD_RESULT_OK;
} else {
return ATCMD_RESULT_ERR;
}
return 0;
}
int32 sys_heap_dump_hdl(const char *cmd, char *argv[], uint32 argc)
{
if(argc == 0){
sysheap_dump(&sram_heap);
}else{
if(os_strcmp(argv[1], "psram") == 0){
#ifdef PSRAM_HEAP
sysheap_dump(&psram_heap);
#endif
}else if(os_strcmp(argv[1], "avheap") == 0){
}else{
sysheap_dump(&sram_heap);
}
}
return ATCMD_RESULT_OK;
}
int32 sys_get_gpio_imap(const char *cmd, char *argv[], uint32 argc)
{
char *ptr = NULL;
unsigned int io;
if (argc >= 1) {
ptr = strstr(argv[0], "P");
} else {
_os_printf("ex: at+inmap=PA1\r\n at+inmap=PB\r\n");
}
if (ptr) {
io = 16*(ptr[1] - 'A');
if (ptr[2] >= '0' && ptr[2] <= '9') {
io += os_atoi(&ptr[2]);
_os_printf("INMAP_%s: %x\r\n",
ptr,
gpio_ioctl(io, GPIO_GET_INMAP, 0, 0));
} else if (ptr[1] >= 'A' && ptr[1] <= 'E') {
for(int i = 0;i<(ptr[1]=='E' ? 4:16);i++)
{
_os_printf("INMAP_P%c%d: %x\r\n",
ptr[1], i,
gpio_ioctl(i+io, GPIO_GET_INMAP, 0, 0));
}
}
}
return ATCMD_RESULT_OK;
}
int32 sys_get_gpio_omap(const char *cmd, char *argv[], uint32 argc)
{
char *ptr = NULL;
unsigned int io = PA_0;
if (argc >= 1) {
ptr = strstr(argv[0], "P");
} else {
_os_printf("ex: at+outmap=PA1\r\n at+outmap=PB\r\n");
}
if (ptr) {
io = 16*(ptr[1] - 'A');
if (ptr[2] >= '0' && ptr[2] <= '9') {
io += os_atoi(&ptr[2]);
_os_printf("OUTMAP_%s: %x\r\n",
ptr,
gpio_ioctl(io, GPIO_GET_OUTMAP, 0, 0));
} else if (ptr[1] >= 'A' && ptr[1] <= 'E') {
for(int i = 0;i<(ptr[1]=='E' ? 4:16);i++)
{
_os_printf("OUTMAP_P%c%d: %x\r\n",
ptr[1],i,
gpio_ioctl(i+io, GPIO_GET_OUTMAP, 0, 0));
}
}
}
return ATCMD_RESULT_OK;
}
int32 sys_atcmd_watchdog(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 1) {
uint8 tmo = os_atoi(argv[0]);
mcu_watchdog_timeout(tmo);
}
return 0;
}
#ifdef SYSCFG_ENABLE
int32 sys_syscfg_dump_hdl(const char *cmd, char *argv[], uint32 argc)
{
void syscfg_dump(void);
syscfg_dump();
return ATCMD_RESULT_DONE;
}
int32 sys_atcmd_loaddef(const char *cmd, char *argv[], uint32 argc)
{
syscfg_loaddef("syscfg");
atcmd_ok;
mcu_reset();
return 0;
}
int32 sys_wifi_atcmd_set_channel(const char *cmd, char *argv[], uint32 argc)
{
int32 chan = 0, chan_max;
if (argc == 1 && argv[0][0] == '?') {
atcmd_resp("%d", ieee80211_conf_get_channel(sys_cfgs.wifi_mode));
} else if (argc == 1) {
chan = os_atoi(argv[0]);
#ifdef TXW4002ACK803
chan_max = 16;
#else
chan_max = 13;
#endif
if ((chan < 1) || (chan > chan_max)) {
atcmd_printf("+CHANNEL: ERROR, INVALID CHANNEL %d\r\n", chan);
return ATCMD_RESULT_DONE;
}
if (sys_cfgs.wifi_mode == WIFI_MODE_AP) {
ieee80211_conf_set_channel(WIFI_MODE_AP, chan);
sys_cfgs.channel = ieee80211_conf_get_channel(WIFI_MODE_AP);
} else if (sys_cfgs.wifi_mode == WIFI_MODE_STA || sys_cfgs.wifi_mode == WIFI_MODE_APSTA) {
ieee80211_conf_set_channel(WIFI_MODE_STA, chan);
sys_cfgs.channel = ieee80211_conf_get_channel(WIFI_MODE_STA);
}
syscfg_save();
}
return ATCMD_RESULT_OK;
}
int32 sys_wifi_atcmd_set_bssid(const char *cmd, char *argv[], uint32 argc)
{
int32 i = 0;
uint8 mac[6];
uint8 ifidx = (sys_cfgs.wifi_mode == WIFI_MODE_APSTA ? WIFI_MODE_STA : sys_cfgs.wifi_mode);
if (argc == 1 && argv[0][0] == '?') {
for (i = 0; i < 6; i++) {
atcmd_printf("%02x", sys_cfgs.bssid[i]);
}
} else if (argc == 1) {
if (ifidx == WIFI_MODE_STA) {
STR2MAC(argv[0], mac);
os_printf("set bssid:"MACSTR"\r\n", MAC2STR(mac));
if (IS_ZERO_ADDR(mac)) {
os_memset(sys_cfgs.bssid, 0, 6);
ieee80211_conf_set_bssid(WIFI_MODE_STA, NULL);
syscfg_save();
} else if (os_memcmp(sys_cfgs.bssid, mac, 6)) {
os_memcpy(sys_cfgs.bssid, mac, 6);
ieee80211_conf_set_bssid(WIFI_MODE_STA, sys_cfgs.bssid);
syscfg_save();
} else {
return ATCMD_RESULT_ERR;
}
}
}
return 0;
}
int32 sys_wifi_atcmd_set_encrypt(const char *cmd, char *argv[], uint32 argc)
{
int32 ret = -1;
if (argc == 1 && argv[0][0] == '?') {
if (sys_cfgs.key_mgmt == WPA_KEY_MGMT_NONE) {
ret = 0;
} else if (sys_cfgs.key_mgmt == WPA_KEY_MGMT_PSK) {
ret = 1;
} else if (sys_cfgs.key_mgmt == WPA_KEY_MGMT_SAE) {
ret = 2;
} else if (sys_cfgs.key_mgmt == WPA_KEY_MGMT_OWE) {
ret = 3;
}
atcmd_resp("%d", ret);
} else if (argc == 1) {
if ('1' == argv[0][0]) {
sys_cfgs.key_mgmt = WPA_KEY_MGMT_PSK;
ieee80211_conf_set_keymgmt(sys_cfgs.wifi_mode, sys_cfgs.key_mgmt);
syscfg_save();
} else if ('2' == argv[0][0]) {
sys_cfgs.key_mgmt = WPA_KEY_MGMT_SAE;
ieee80211_conf_set_keymgmt(sys_cfgs.wifi_mode, sys_cfgs.key_mgmt);
syscfg_save();
} else if ('3' == argv[0][0]) {
sys_cfgs.key_mgmt = WPA_KEY_MGMT_OWE;
ieee80211_conf_set_keymgmt(sys_cfgs.wifi_mode, sys_cfgs.key_mgmt);
syscfg_save();
} else if ('0' == argv[0][0]) {
sys_cfgs.key_mgmt = WPA_KEY_MGMT_NONE;
ieee80211_conf_set_keymgmt(sys_cfgs.wifi_mode, sys_cfgs.key_mgmt);
syscfg_save();
} else {
os_printf("encrypt atcmd err\r\n");
return ATCMD_RESULT_ERR;
}
}
return 0;
}
int32 sys_wifi_atcmd_set_ssid(const char *cmd, char *argv[], uint32 argc)
{
uint8 ifidx = (sys_cfgs.wifi_mode == WIFI_MODE_APSTA ? WIFI_MODE_STA : sys_cfgs.wifi_mode);
if (argc == 1 && argv[0][0] == '?') {
atcmd_resp("%s", sys_cfgs.ssid);
} else if (argc == 1) {
os_memset(sys_cfgs.bssid, 0, 6);
os_strncpy(sys_cfgs.ssid, argv[0], SSID_MAX_LEN);
ieee80211_conf_set_bssid(ifidx, NULL);
if (os_strlen(sys_cfgs.passwd) > 0) {
wpa_passphrase(sys_cfgs.ssid, (char*)sys_cfgs.passwd, sys_cfgs.psk);
}
ieee80211_conf_set_ssid(ifidx, sys_cfgs.ssid);
ieee80211_conf_set_psk(ifidx, sys_cfgs.psk);
os_printf("set new ssid:%s\r\n", sys_cfgs.ssid);
syscfg_save();
}
return 0;
}
int32 sys_wifi_atcmd_set_key(const char *cmd, char *argv[], uint32 argc)
{
uint8 ifidx = (sys_cfgs.wifi_mode == WIFI_MODE_APSTA ? WIFI_MODE_STA : sys_cfgs.wifi_mode);
if (argc == 1 && argv[0][0] == '?') {
atcmd_resp("%s", sys_cfgs.passwd);
} else if (argc == 1) {
// psk need 8 bytes at less
if (os_strlen(argv[0]) < 8) {
os_printf("psk need 8 bytes at less\r\n");
return ATCMD_RESULT_ERR;
} else {
os_strncpy(sys_cfgs.passwd, argv[0], PASSWD_MAX_LEN);
wpa_passphrase(sys_cfgs.ssid, (char*)sys_cfgs.passwd, sys_cfgs.psk);
ieee80211_conf_set_psk(ifidx, sys_cfgs.psk);
ieee80211_conf_set_passwd(ifidx, (char*)sys_cfgs.passwd);
os_printf("set new key:%s\r\n", sys_cfgs.passwd);
syscfg_save();
}
}
return 0;
}
int32 sys_wifi_atcmd_set_wifimode(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 1 && argv[0][0] == '?') {
atcmd_resp("%s", sys_cfgs.wifi_mode == WIFI_MODE_AP ? "ap" : (sys_cfgs.wifi_mode == WIFI_MODE_APSTA ? "apsta" : "sta"));
} else if (argc == 1) {
if (os_strcasecmp(argv[0], "ap") == 0 && sys_cfgs.wifi_mode != WIFI_MODE_AP) {
sys_cfgs.wifi_mode = WIFI_MODE_AP;
ieee80211_iface_stop(WIFI_MODE_AP);
ieee80211_iface_stop(WIFI_MODE_STA);
wificfg_flush(WIFI_MODE_AP);
netdev_set_wifi_mode((struct netdev *)dev_get(HG_WIFI0_DEVID), WIFI_MODE_AP);
ieee80211_iface_start(WIFI_MODE_AP);
} else if (os_strcasecmp(argv[0], "sta") == 0 && sys_cfgs.wifi_mode != WIFI_MODE_STA) {
sys_cfgs.wifi_mode = WIFI_MODE_STA;
ieee80211_iface_stop(WIFI_MODE_AP);
ieee80211_iface_stop(WIFI_MODE_STA);
wificfg_flush(WIFI_MODE_STA);
netdev_set_wifi_mode((struct netdev *)dev_get(HG_WIFI0_DEVID), WIFI_MODE_STA);
ieee80211_iface_start(WIFI_MODE_STA);
} else if (os_strcasecmp(argv[0], "apsta") == 0 && sys_cfgs.wifi_mode != WIFI_MODE_APSTA) {
sys_cfgs.wifi_mode = WIFI_MODE_APSTA;
ieee80211_iface_stop(WIFI_MODE_AP);
ieee80211_iface_stop(WIFI_MODE_STA);
wificfg_flush(WIFI_MODE_AP);
ieee80211_iface_start(WIFI_MODE_AP);
wificfg_flush(WIFI_MODE_STA);
netdev_set_wifi_mode((struct netdev *)dev_get(HG_WIFI0_DEVID), WIFI_MODE_APSTA);
ieee80211_iface_start(WIFI_MODE_STA);
}
os_printf("set wifi mode:%s\r\n", argv[0]);
syscfg_save();
}
return 0;
}
int32 sys_wifi_atcmd_loaddef(const char *cmd, char *argv[], uint32 argc)
{
syscfg_loaddef("syscfg");
mcu_reset();
return 0;
}
int32 sys_wifi_atcmd_scan(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 2) {
struct ieee80211_scandata scan;
os_memset(&scan, 0, sizeof(scan));
scan.chan_bitmap = 0xffff;
scan.scan_cnt = os_atoi(argv[0]);
scan.scan_time = os_atoi(argv[1]);
ieee80211_scan(sys_cfgs.wifi_mode, 1, &scan);
} else {
ieee80211_scan(sys_cfgs.wifi_mode, 1, NULL);
}
return 0;
}
int32 sys_wifi_atcmd_pair(const char *cmd, char *argv[], uint32 argc)
{
uint32 magic = os_atoi(argv[0]);
ieee80211_pairing(sys_cfgs.wifi_mode, magic);
return 0;
}
int32 sys_wifi_atcmd_aphide(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 1 && argv[0][0] == '?') {
atcmd_resp("%d", sys_cfgs.ap_hide);
} else if (argc == 1) {
sys_cfgs.ap_hide = os_atoi(argv[0]);
ieee80211_conf_set_aphide(sys_cfgs.wifi_mode, sys_cfgs.ap_hide);
syscfg_save();
}
return 0;
}
int32 sys_wifi_atcmd_hwmode(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 1 && argv[0][0] == '?') {
atcmd_resp("%d", sys_cfgs.wifi_hwmode);
} else if (argc == 1) {
sys_cfgs.wifi_hwmode = os_atoi(argv[0]);
ieee80211_conf_set_hwmode(sys_cfgs.wifi_mode, sys_cfgs.wifi_hwmode);
syscfg_save();
}
return 0;
}
int32 sys_wifi_atcmd_ft(const char *cmd, char *argv[], uint32 argc)
{
#ifdef CONFIG_IEEE80211R
struct ieee80211_ft_param ft;
uint8 ifidx = (sys_cfgs.wifi_mode == WIFI_MODE_APSTA ? WIFI_MODE_STA : sys_cfgs.wifi_mode);
os_memset(&ft, 0, sizeof(ft));
str2mac(argv[0], ft.bssid_new);
os_printf("FT_start: target_bssid= "MACSTR" argc= %d\r\n", MAC2STR(ft.bssid_new), argc);
ieee80211_conf_set_ft(ifidx, &ft);
#endif
return 0;
}
#endif
#if WIFI_REPEATER_SUPPORT
int32 sys_wifi_atcmd_set_rssid(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 1 && argv[0][0] == '?') {
atcmd_resp("%s", sys_cfgs.r_ssid);
} else if (argc == 1) {
if (sys_cfgs.wifi_mode == WIFI_MODE_APSTA) {
sys_cfgs.cfg_init = 1;
sys_cfgs.r_key_mgmt = sys_cfgs.key_mgmt;
os_strncpy(sys_cfgs.r_ssid, argv[0], SSID_MAX_LEN);
if (os_strlen(sys_cfgs.r_passwd) > 0) {
wpa_passphrase(sys_cfgs.r_ssid, sys_cfgs.r_passwd, sys_cfgs.r_psk);
}
ieee80211_conf_set_ssid(WIFI_MODE_AP, sys_cfgs.r_ssid);
ieee80211_conf_set_psk(WIFI_MODE_AP, sys_cfgs.r_psk);
atcmd_ok;
syscfg_save();
} else {
atcmd_error;
}
}
return 0;
}
int32 sys_wifi_atcmd_set_rkey(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 1 && argv[0][0] == '?') {
atcmd_resp("%s", sys_cfgs.r_passwd);
} else if (argc == 1) {
if (os_strlen(argv[0]) < 8) {
atcmd_error;
atcmd_printf("rkey needs 8 bytes at least\r\n");
} else {
if (sys_cfgs.wifi_mode == WIFI_MODE_APSTA) {
sys_cfgs.cfg_init = 1;
sys_cfgs.r_key_mgmt = sys_cfgs.key_mgmt;
os_strncpy(sys_cfgs.r_passwd, argv[0], PASSWD_MAX_LEN);
wpa_passphrase(sys_cfgs.r_ssid, sys_cfgs.r_passwd, sys_cfgs.r_psk);
ieee80211_conf_set_psk(WIFI_MODE_AP, sys_cfgs.r_psk);
atcmd_ok;
syscfg_save();
} else {
atcmd_error;
}
}
}
return 0;
}
int32 sys_wifi_atcmd_set_rmode(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 1 && argv[0][0] == '?') {
if (sys_cfgs.wifi_mode == WIFI_MODE_APSTA) {
atcmd_resp("EN:%d LEVEL:%d MCAST:%d", sys_cfgs.relay_en, ieee80211_conf_get_relay_level(WIFI_MODE_AP), sys_cfgs.relay_mcast);
}
} else if (argc == 3) {
if (sys_cfgs.wifi_mode == WIFI_MODE_APSTA) {
if (sys_cfgs.relay_en != os_atoi(argv[0]) || sys_cfgs.relay_level != os_atoi(argv[1])) {
ieee80211_iface_stop(WIFI_MODE_AP);
ieee80211_iface_start(WIFI_MODE_AP);
ieee80211_iface_stop(WIFI_MODE_STA);
ieee80211_iface_start(WIFI_MODE_STA);
}
sys_cfgs.relay_en = os_atoi(argv[0]);
sys_cfgs.relay_level = os_atoi(argv[1]);
sys_cfgs.relay_mcast = os_atoi(argv[2]);
ieee80211_conf_set_relay_mode(WIFI_MODE_AP, sys_cfgs.relay_en, sys_cfgs.relay_level, sys_cfgs.relay_mcast);
ieee80211_conf_set_relay_mode(WIFI_MODE_STA, sys_cfgs.relay_en, sys_cfgs.relay_level, sys_cfgs.relay_mcast);
atcmd_ok;
syscfg_save();
} else {
atcmd_error;
}
}
return 0;
}
#endif
#if BLE_SUPPORT
int32 sys_ble_atcmd_blenc(const char *cmd, char *argv[], uint32 argc)
{
uint8 mode = 0;
if (argc == 1) {
mode = os_atoi(argv[0]);
if (ble_set_mode(mode, 38)) {
return ATCMD_RESULT_ERR;
} else {
if (mode == 0) {
os_printf("\n\nble close \r\n\n");
} else {
os_printf("\n\nset ble mode = %d \r\n\n", mode);
}
}
}
return 0;
}
int32 sys_ble_atcmd_set_coexist_en(const char *cmd, char *argv[], uint32 argc)
{
uint8 coexist, dec_duty;
if (argc == 1 && argv[0][0] == '?') {
atcmd_resp("coexist,dec_duty");
} else if (argc == 2) {
coexist = os_atoi(argv[0]);
dec_duty = os_atoi(argv[1]);
if (ble_set_coexist_en(coexist, dec_duty)) {
return ATCMD_RESULT_ERR;
}
}
return 0;
}
#endif
#if SYS_NETWORK_SUPPORT
int32 sys_wifi_atcmd_wificsa(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 4) {
struct ieee80211_csa_param csa;
csa.mode = os_atoi(argv[1]);
csa.chan = os_atoi(argv[2]);
csa.count = os_atoi(argv[3]);
return ieee80211_conf_set_csa(os_atoi(argv[0]), &csa);
}else{
return -1;
}
}
int32 sys_atcmd_ping(const char *cmd, char *argv[], uint32 argc) //need: #define LWIP_RAW 1
{
int32 loop_cnt = 10;
int32 pkt_size = 32;
if (argc > 0) {
if (argc > 1) { loop_cnt = os_atoi(argv[1]); }
if (argc > 2) { pkt_size = os_atoi(argv[2]); }
lwip_ping(argv[0], pkt_size, loop_cnt);
}
return 0;
}
int32 sys_atcmd_icmp_mntr(const char *cmd, char *argv[], uint32 argc)
{
struct netdev *ndev;
if (argc == 2) {
ndev = (struct netdev *)dev_get(HG_WIFI0_DEVID + os_atoi(argv[0]));
if (ndev) {
netdev_ioctl(ndev, NETDEV_IOCTL_ENABLE_ICMPMNTR, os_atoi(argv[1]), 0);
return ATCMD_RESULT_OK;
}
}
return ATCMD_RESULT_ERR;
}
int32 sys_atcmd_iperf2(const char *cmd, char *argv[], uint32 argc)
{
int32 ret = 0;
if (argc == 1 && argv[0][0] == '?') {
os_printf(" *********iperf usage*********\n");
os_printf(" TCP client:at+iperf2=c,ip,port,time\n");
os_printf(" TCP server:at+iperf2=s,port\n");
os_printf(" UDP client:at+iperf2=u,c,ip,port,time,bandwidth,packet_len\n");
os_printf(" UDP server:at+iperf2=u,s,port\n");
os_printf(" *******************************\n");
} else {
if (argc > 0) {
if(os_strlen(argv[0]) != 1) {
os_printf("%s,%d:Invaild param1,must be c or s or u\n");
return -EINVAL;
}
if (argv[0][0] == 'c' || argv[0][0] == 'C') {
if (argc < 4) {
os_printf("TCP client mode requires 4 parameters: mode,ip,port,time\n");
return -EINVAL;
}
os_printf("%s:iperf2 TCP CLIENT mode,remote IP:%s,port:%d,time:%d\n",
__FUNCTION__, argv[1], os_atoi(argv[2]), os_atoi(argv[3]));
ret = sys_lwiperf_tcp_client_start(argv[1], os_atoi(argv[2]), os_atoi(argv[3]));
} else if (argv[0][0] == 's' || argv[0][0] == 'S') {
if (argc < 2) {
os_printf("TCP server mode requires 2 parameters: mode port\n");
return -EINVAL;
}
os_printf("%s:iperf2 TCP Server mode,port:%d\n", __FUNCTION__, os_atoi(argv[1]));
ret = sys_lwiperf_tcp_server_start(os_atoi(argv[1]));
} else if (argv[0][0] == 'u' || argv[0][0] == 'U') {//UDP
if (argc < 2) {
os_printf("UDP mode requires at least 2 arguments.\n");
return -EINVAL;
}
if(os_strlen(argv[1]) != 1) {
os_printf("%s,%d:Invaild param2,must be c or s\n");
return -EINVAL;
}
if (argv[1][0] == 'c' || argv[1][0] == 'C') {
if (argc < 7) {
os_printf("UDP client mode requires 7 parameters: u c ip port time bandwidth packet_len\n");
return -EINVAL;
}
os_printf("%s:iperf2 UDP CLIENT mode,remote IP:%s,port:%d,time:%d,bandwidth:%u,len:%d\n",
__FUNCTION__,
argv[2],//ip
os_atoi(argv[3]), //port
os_atoi(argv[4]), //time
os_atoi(argv[5]),//bandwidth
os_atoi(argv[6]));//packet_len
ret = sys_lwiperf_udp_client_start(argv[2], os_atoi(argv[3]), os_atoi(argv[4]),
os_atoi(argv[5]), os_atoi(argv[6]));//UDP CLIENT
} else if (argv[1][0] == 's' || argv[1][0] == 'S') {
if (argc < 3) {
os_printf("UDP server mode requires 4 parameters: u s port\n");
return -EINVAL;
}
os_printf("%s:iperf2 UDP SERVER mode,port:%d\n",
__FUNCTION__, os_atoi(argv[2])); //port
ret = sys_lwiperf_udp_server_start(os_atoi(argv[2]));//UDP SERVER
} else {
os_printf("Unknow iperf udp mode:%s\n", argv[1]);
return -ENOENT;
}
} else {
os_printf("Unknow iperf mode:%s\n", argv[0]);
return -ENOENT;
}
}
}
return ret;
}
int32 sys_wifi_atcmd_pcap(const char *cmd, char *argv[], uint32 argc)
{
char *file = NULL;
if (argc == 2) {
file = pcap_start(netif_find(argv[0]), argv[1]);
return file ? ATCMD_RESULT_OK : -1;
}else{
pcap_stop(netif_find(argv[0]));
return ATCMD_RESULT_OK;
}
}
int32 sys_wifi_atcmd_dhcpd_lease_time(const char *cmd, char *argv[], uint32 argc)
{
if (argc == 1 && argv[0][0] == '?') {
atcmd_resp("%d", sys_cfgs.dhcpd_lease_time);
} else if (argc == 1) {
sys_cfgs.dhcpd_lease_time = os_atoi(argv[0]);
os_printf("DHCP lease time set to %d\r\n", sys_cfgs.dhcpd_lease_time);
syscfg_save();
}
return 0;
}
#endif

542
sdk/lib/common/common.c Normal file
View File

@@ -0,0 +1,542 @@
#include "sys_config.h"
#include "typesdef.h"
#include "errno.h"
#include "list.h"
#include "dev.h"
#include "devid.h"
#include "osal/task.h"
#include "osal/sleep.h"
#include "osal/string.h"
#include "osal/irq.h"
#include "hal/dma.h"
#include "hal/crc.h"
#include "lib/common/common.h"
#include "lib/heap/sysheap.h"
const uint32 sdk_version = SDK_VERSION;
const uint32 svn_version = SVN_VERSION;
const uint32 app_version = APP_VERSION;
__bobj uint64 cpu_loading_tick;
uint32 m2mdam_time = 0;
__bobj struct dma_device *m2mdma;
extern void cpu_loading_api_time(char *api, uint32 time, uint32 diff_tick);
#define CPU_TIME_API(api) extern uint32 api##_time(void); \
_time_ = api##_time(); \
cpu_loading_api_time(#api, _time_, diff_tick);
void cpu_loading_api_time(char *api, uint32 time, uint32 diff_tick)
{
if (time > 0) {
uint32 count = 100 * os_msecs_to_jiffies(time / 1000);
os_printf(KERN_ALERT"[%s time: %dms, %d%%]\r\n", api, (time / 1000), (count / diff_tick));
}
}
void module_version_show(void)
{
extern uint32 __modver_start;
extern uint32 __modver_end;
uint32 *start = (uint32 *)&__modver_start;
uint32 *end = (uint32 *)&__modver_end;
while (start < end) {
_os_printf("** lib%s\r\n", (char *)*start++);
}
_os_printf("------------------------------------------------------------------\r\n");
}
typedef void (*__ctor_func_)(void);
extern __ctor_func_ __CTOR_LIST__[];
extern __ctor_func_ __DTOR_LIST__[];
void do_global_ctors(void)
{
ulong i;
ulong nptrs = (ulong)__CTOR_LIST__[0];
if (nptrs == (ulong) - 1) {
for (nptrs = 0; __CTOR_LIST__[nptrs + 1] != 0; nptrs++) ;
}
for (i = nptrs; i >= 1; i--) {
__CTOR_LIST__[i]();
}
}
void do_global_dtors(void)
{
ulong i;
ulong nptrs = (ulong)__DTOR_LIST__[0];
if (nptrs == (ulong) - 1) {
for (nptrs = 0; __DTOR_LIST__[nptrs + 1] != 0; nptrs++) ;
}
for (i = 1; i <= nptrs; i++) {
__DTOR_LIST__[i]();
}
}
void cpu_loading_print(uint8 all, struct os_task_info *tsk_info, uint32 size)
{
uint32 i = 0;
uint32 diff_tick = 0;
uint32 _time_ = 0;
uint32 count;
uint64 jiff = os_jiffies();
uint32 total_time = 0;
if(tsk_info == NULL) return;
diff_tick = DIFF_JIFFIES(cpu_loading_tick, jiff);
cpu_loading_tick = jiff;
os_printf(KERN_ALERT"----------------------------------------------------------------------------------\r\n");
os_printf(KERN_ALERT"Task Runtime Statistic, interval:%dms\r\n", (uint32)os_jiffies_to_msecs(diff_tick));
os_printf(KERN_ALERT"PID Name %%CPU(Time) Stack Prio Status\r\n");
os_printf(KERN_ALERT"----------------------------------------------------------------------------------\r\n");
cpu_loading_api_time("sram_heap", sysheap_time(&sram_heap), diff_tick);
#ifdef PSRAM_HEAP
cpu_loading_api_time("sram_heap", sysheap_time(&psram_heap), diff_tick);
#endif
CPU_TIME_API(sysirq);
#ifdef SKB_POOL_ENABLE
CPU_TIME_API(skbpool);
#endif
//CPU_TIME_API(hw_memcpy);
os_printf(KERN_ALERT"----------------------------------------------------------------------------------\r\n");
count = os_task_runtime(tsk_info, size);
for (i = 0; i < count; i++) {
if (tsk_info[i].time > 0 || all) {
total_time += tsk_info[i].time;
os_printf(KERN_ALERT"%2d %-28s\t%2d%%(%6d) %4d %2d (%08x) %s\r\n",
tsk_info[i].id,
tsk_info[i].name ? tsk_info[i].name : "----",
#ifdef CSKY_OS
(tsk_info[i].time * 100) / diff_tick,
#elif defined(OHOS)
tsk_info[i].time,
#endif
tsk_info[i].time,
tsk_info[i].stack * 4,
tsk_info[i].prio,
tsk_info[i].arg,
tsk_info[i].status);
}
}
#ifdef CSKY_OS
os_printf(KERN_ALERT"--------------------------- CPU Loading: %d%% [%dms] -------------------------\r\n",
(total_time*100)/diff_tick, (uint32)os_jiffies_to_msecs(total_time));
#elif defined(OHOS)
os_printf(KERN_ALERT"--------------------------- CPU Loading: %d%% -------------------------------\r\n", total_time);
#endif
}
int strncasecmp(const char *s1, const char *s2, size_t n)
{
size_t i = 0;
for (i = 0; i < n && s1[i] && s2[i]; i++) {
if (s1[i] == s2[i] || s1[i] + 32 == s2[i] || s1[i] - 32 == s2[i]) {
} else {
break;
}
}
return (i != n);
}
int strcasecmp(const char *s1, const char *s2)
{
while (*s1 || *s2) {
if (*s1 == *s2 || *s1 + 32 == *s2 || *s1 - 32 == *s2) {
s1++; s2++;
} else {
return -1;
}
}
return 0;
}
void hw_memcpy(void *dest, const void *src, uint32 size)
{
if (dest && src) {
if (m2mdma && size > 45) {
#ifdef MEM_TRACE
#ifdef PSRAM_HEAP
void *heap = (IS_PSRAM_ADDR(dest)) ? ((void *)&psram_heap) : ((void *)&sram_heap);
#else
void *heap = (void *)&sram_heap;
#endif
int32 ret = sysheap_of_check(heap, dest, size);
if (ret == 0) {
os_printf(KERN_WARNING"check addr fail: %x, size:%d \r\n", dest, size);
}
#endif
uint64 __t__ = os_useconds();
dma_memcpy(m2mdma, dest, src, size);
m2mdam_time += os_useconds() - __t__;
} else {
os_memcpy(dest, src, size);
}
}
}
void hw_memcpy0(void *dest, const void *src, uint32 size)
{
if (m2mdma && size > 45) {
#ifdef MEM_TRACE
#ifdef PSRAM_HEAP
void *heap = (IS_PSRAM_ADDR(dest)) ? ((void *)&psram_heap) : ((void *)&sram_heap);
#else
void *heap = (void *)&sram_heap;
#endif
int32 ret = sysheap_of_check(heap, dest, size);
if (ret == 0) {
os_printf(KERN_WARNING"check addr fail: %x, size:%d \r\n", dest, size);
}
#endif
uint64 __t__ = os_useconds();
dma_memcpy(m2mdma, dest, src, size);
m2mdam_time += os_useconds() - __t__;
} else {
os_memcpy(dest, src, size);
}
}
void hw_memcpy_no_cache(void *dest, const void *src, uint32 size)
{
if (dest && src) {
#ifdef MEM_TRACE
#ifdef PSRAM_HEAP
void *heap = (IS_PSRAM_ADDR(dest)) ? ((void *)&psram_heap) : ((void *)&sram_heap);
#else
void *heap = (void *)&sram_heap;
#endif
int32 ret = sysheap_of_check(heap, dest, size);
if (ret == 0) {
os_printf(KERN_WARNING"check addr fail: %x, size:%d \r\n", dest, size);
}
#endif
uint64 __t__ = os_useconds();
dma_memcpy_no_cache(m2mdma, dest, src, size);
m2mdam_time += os_useconds() - __t__;
}
}
void hw_memset(void *dest, uint8 val, uint32 n)
{
if (dest) {
if (m2mdma && n > 12) {
#ifdef MEM_TRACE
#ifdef PSRAM_HEAP
void *heap = (IS_PSRAM_ADDR(dest)) ? ((void *)&psram_heap) : ((void *)&sram_heap);
#else
void *heap = (void *)&sram_heap;
#endif
int32 ret = sysheap_of_check(heap, dest, n);
if (ret == 0) {
os_printf(KERN_WARNING"check addr fail: %x, size:%d \r\n", dest, n);
}
#endif
uint64 __t__ = os_useconds();
dma_memset(m2mdma, dest, val, n);
m2mdam_time += os_useconds() - __t__;
} else {
os_memset(dest, val, n);
}
}
}
uint32 hw_memcpy_time(void)
{
uint32 v = m2mdam_time;
m2mdam_time = 0;
return v / 1000;
}
void *os_memdup(const void *ptr, uint32 len)
{
void *p;
if (!ptr || len == 0) {
return NULL;
}
p = os_malloc(len);
if (p) {
hw_memcpy(p, ptr, len);
}
return p;
}
int32 os_random_bytes(uint8 *data, int32 len)
{
int32 i = 0;
int32 seed, seed_uuid, rand_val = 0;
uint8 uuid[6];
sysctrl_get_chip_uuid((uint8 *)&uuid[0], 6);
memcpy((void *)&seed_uuid, &uuid[2], 4);
#ifdef TXW4002ACK803
seed = CPU_CYCLE_VALUE() ^ (CPU_CYCLE_VALUE() << 8) ^ (CPU_CYCLE_VALUE() >> 8);
#else
seed = CPU_CYCLE_VALUE() ^ sysctrl_get_trng() ^ (seed_uuid);
#endif
for (i = 0; i < len; i++) {
if (i & 1) {
rand_val = rand_val >> 8;
} else {
seed = (seed * 214013L + 2531011L) >> 16;
rand_val = seed;
}
data[i] = (uint8)(rand_val & 0xFF);
}
return 0;
}
uint32 hw_crc(enum CRC_DEV_TYPE type, uint8 *data, uint32 len)
{
uint32 crc = 0xffff;
struct crc_dev_req req;
struct crc_dev *crcdev = (struct crc_dev *)dev_get(HG_CRC_DEVID);
if (!crcdev) {
os_printf("no crc dev\r\n");
return RET_ERR;
}
req.flag = 0;
req.type = type;
req.data = data;
req.len = 0x40000;
if (len <= 0x40000) {
req.len = len;
crc_dev_calc(crcdev, &req, &crc, 0);
return crc;
}
crc_dev_calc(crcdev, &req, &crc, 0);
req.data += req.len;
len -= req.len;
while(len >= 0x40000) {
req.crc_last = crc;
crc_dev_calc(crcdev, &req, &crc, CRC_DEV_FLAGS_CONTINUE_CALC);
req.data += req.len;
len -= req.len;
}
if (len) {
req.crc_last = crc;
req.len = len;
crc_dev_calc(crcdev, &req, &crc, CRC_DEV_FLAGS_CONTINUE_CALC);
}
return crc;
}
uint32 hw_crc_no_cache(enum CRC_DEV_TYPE type, uint8 *data, uint32 len)
{
uint32 crc = 0xffff;
struct crc_dev_req req;
struct crc_dev *crcdev = (struct crc_dev *)dev_get(HG_CRC_DEVID);
if (!crcdev) {
os_printf("no crc dev\r\n");
return RET_ERR;
}
req.flag = 1;
req.type = type;
req.data = data;
req.len = 0x40000;
if (len <= 0x40000) {
req.len = len;
crc_dev_calc(crcdev, &req, &crc, 0);
return crc;
}
crc_dev_calc(crcdev, &req, &crc, 0);
req.data += req.len;
len -= req.len;
while(len >= 0x40000) {
req.crc_last = crc;
crc_dev_calc(crcdev, &req, &crc, CRC_DEV_FLAGS_CONTINUE_CALC);
req.data += req.len;
len -= req.len;
}
if (len) {
req.crc_last = crc;
req.len = len;
crc_dev_calc(crcdev, &req, &crc, CRC_DEV_FLAGS_CONTINUE_CALC);
}
return crc;
}
int ffs(int x)
{
int r = 1;
if (!x) {
return 0;
}
if (!(x & 0xffff)) {
x >>= 16;
r += 16;
}
if (!(x & 0xff)) {
x >>= 8;
r += 8;
}
if (!(x & 0xf)) {
x >>= 4;
r += 4;
}
if (!(x & 3)) {
x >>= 2;
r += 2;
}
if (!(x & 1)) {
x >>= 1;
r += 1;
}
return r;
}
int fls(int x)
{
int r = 32;
if (!x) {
return 0;
}
if (!(x & 0xffff0000u)) {
x <<= 16;
r -= 16;
}
if (!(x & 0xff000000u)) {
x <<= 8;
r -= 8;
}
if (!(x & 0xf0000000u)) {
x <<= 4;
r -= 4;
}
if (!(x & 0xc0000000u)) {
x <<= 2;
r -= 2;
}
if (!(x & 0x80000000u)) {
x <<= 1;
r -= 1;
}
return r;
}
uint32 scatter_size(scatter_data *data, uint32 count)
{
uint32 size = 0;
uint32 i = 0;
for (i = 0; i < count; i++) {
size += data[i].size;
}
return size;
}
uint8 *scatter_offset(scatter_data *data, uint32 count, uint32 off)
{
uint8 i;
for (i = 0; i < count; i++) {
if (off < data[i].size) {
return data[i].addr + off;
}
off -= data[i].size;
}
return NULL;
}
/////////////////////////////////////////////////////////////////////////////////////////
//系统崩溃产生异常时会执行 trap_data_dump 和 trap_hdl_run
// trap_data_dump: 崩溃时dump指定的数据，可以通过 trap_data_set 添加多个观察数据
// trap_hdl_run : 崩溃时执行指定的函数，通过 trap_hdl_set API设置系统崩溃时需要执行的函数。注意：添加的函数不能再次崩溃
/////////////////////////////////////////////////////////////////////////////////////////
enum TRAP_DATA {
//TRAP_DATA_ID_1,
TRAP_DATA_MAX,
};
enum TRAP_HDL {
//TRAP_HDL_ID_1,
TRAP_HDL_MAX,
};
struct {
void *addr;
uint32 len;
} trap_c_data[TRAP_DATA_MAX];
struct {
void (*hdl)(void *arg);
void *arg;
} trap_c_hdl[TRAP_HDL_MAX];
void trap_data_set(int8 id, void *addr, uint32 len)
{
if (id < TRAP_DATA_MAX) {
trap_c_data[id].addr = addr;
trap_c_data[id].len = len;
} else {
os_printf(KERN_ERR"trap_data_set: invalid id %d, max %d\r\n", id, TRAP_DATA_MAX);
}
}
void trap_hdl_set(int8 id, void (*hdl)(void *), void *arg)
{
if (id < TRAP_HDL_MAX) {
trap_c_hdl[id].hdl = hdl;
trap_c_hdl[id].arg = arg;
} else {
os_printf(KERN_ERR"trap_hdl_set: invalid id %d, max %d\r\n", id, TRAP_HDL_MAX);
}
}
void trap_data_dump(void)
{
int8 i;
char name[32];
for (i = 0; i < TRAP_DATA_MAX; i++) {
if (trap_c_data[i].addr && trap_c_data[i].len) {
os_printf(KERN_ERR"---------------------------------------------------------------\r\n");
os_snprintf(name, 31, "dump data %d:\r\n", i);
dump_hex(name, trap_c_data[i].addr, trap_c_data[i].len, 1);
}
}
}
void trap_hdl_run(void)
{
int8 i;
for (i = 0; i < TRAP_HDL_MAX; i++) {
if (trap_c_hdl[i].hdl) {
os_printf(KERN_ERR"---------------------------------------------------------------\r\n");
os_printf(KERN_ERR"trap hdl: %p, arg:%p\r\n", trap_c_hdl[i].hdl, trap_c_hdl[i].arg);
trap_c_hdl[i].hdl(trap_c_hdl[i].arg);
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////
extern int *__errno_location(void);
void set_errno(int32 err)
{
*__errno_location() = err;
}
int32 get_errno(void)
{
return *__errno_location();
}

132
sdk/lib/common/dsleepdata.c Normal file
View File

@@ -0,0 +1,132 @@
#include "typesdef.h"
#include "osal/irq.h"
#include "osal/string.h"
#include "lib/common/dsleepdata.h"
struct dsleeplog {
uint16 size;
uint16 off;
};
struct system_sleepdata {
uint32 magic1;
uint32 cur_addr;
uint32 regions[SYSTEM_SLEEPDATA_ID_MAX];
uint32 magic2;
};
extern size_t __sleep_data_start;
extern size_t __sleep_data_stop;
__init void sys_sleepdata_init(void)
{
uint32 flags;
uint32 start = (uint32)&__sleep_data_start;
//uint32 end = (uint32)&__sleep_data_stop;
struct system_sleepdata *sdata = (struct system_sleepdata *)start;
flags = disable_irq();
if (sdata->magic1 != 0x1A2B3C4D || sdata->magic2 != 0xD4C3B2A1) {
os_printf("sleepdata_init\r\n");
os_memset(sdata, 0, sizeof(struct system_sleepdata));
sdata->magic1 = 0x1A2B3C4D;
sdata->magic2 = 0xD4C3B2A1;
sdata->cur_addr = start + sizeof(struct system_sleepdata);
}
enable_irq(flags);
}
void *sys_sleepdata_request(uint8 id, uint32 size)
{
void *ptr = NULL;
uint32 flags;
uint32 start = (uint32)&__sleep_data_start;
uint32 end = (uint32)&__sleep_data_stop;
struct system_sleepdata *sdata = (struct system_sleepdata *)start;
size = ALIGN(size, 4);
flags = disable_irq();
if (id < SYSTEM_SLEEPDATA_ID_MAX) {
os_printf("regions(%d)=0x%x cur_addr=0x%x size=%d end=0x%x\r\n",
id, sdata->regions[id], sdata->cur_addr, size, end);
if (sdata->regions[id] == 0) {
if (sdata->cur_addr + size < end) {
os_memset(sdata->cur_addr, 0, size);
sdata->regions[id] = sdata->cur_addr;
sdata->cur_addr += size;
}
}
ptr = (void *)sdata->regions[id];
}
enable_irq(flags);
return ptr;
}
void sys_sleepdata_reset(void)
{
uint32 flags;
uint32 *start = (uint32 *)&__sleep_data_start;
flags = disable_irq();
*start = 0;
enable_irq(flags);
}
uint32 sys_sleepdata_freesize(void)
{
uint32 flags;
uint32 fsize = 0;
uint32 start = (uint32)&__sleep_data_start;
uint32 end = (uint32)&__sleep_data_stop;
struct system_sleepdata *sdata = (struct system_sleepdata *)start;
flags = disable_irq();
fsize = end - sdata->cur_addr;
enable_irq(flags);
return fsize;
}
void *sys_sleepdata_get(uint8 id)
{
uint32 start = (uint32)&__sleep_data_start;
struct system_sleepdata *sdata = (struct system_sleepdata *)start;
if (id < SYSTEM_SLEEPDATA_ID_MAX) {
return (void *)sdata->regions[id];
}
return NULL;
}
int32 dsleeplog_int(uint32 size)
{
struct dsleeplog *log = (struct dsleeplog *)sys_sleepdata_request(SYSTEM_SLEEPDATA_ID_SLEEPLOG, size + sizeof(struct dsleeplog));
if (log) {
if (log->size == 0) log->size = size;
return RET_OK;
} else {
os_printf(KERN_EMERG"dsleeplog_int fail, size:%d! freesize:%d\r\n", size, sys_sleepdata_freesize());
return -ENOMEM;
}
}
void dsleeplog_print(void)
{
struct dsleeplog *log = (struct dsleeplog *)sys_sleepdata_get(SYSTEM_SLEEPDATA_ID_SLEEPLOG);
if (log) {
char *buff = (char *)(log + 1);
hgprintf_out(buff + log->off, log->size - log->off, 1);
hgprintf_out(buff, log->off, 1);
}
}
__dsleep_text void dsleeplog_save(char c)
{
uint32 start = (uint32)&__sleep_data_start;
struct system_sleepdata *sdata = (struct system_sleepdata *)start;
struct dsleeplog *log = (struct dsleeplog *)sdata->regions[SYSTEM_SLEEPDATA_ID_SLEEPLOG];
if (log && c && c != 0x0d) {
char *buff = (char *)(log + 1);
buff[log->off] = c;
log->off++;
log->off &= (log->size - 1);
}
}

172
sdk/lib/common/rbuffer.c Normal file
View File

@@ -0,0 +1,172 @@
#include "typesdef.h"
#include "list.h"
#include "dev.h"
#include "devid.h"
#include "errno.h"
#include "osal/irq.h"
#include "osal/string.h"
#include "lib/common/rbuffer.h"
int32 rbuffer_init(struct rbuffer *rb, uint32 size, void *buff)
{
ASSERT(buff && size > 1);
os_memset(rb, 0, sizeof(struct rbuffer));
rb->qsize = size;
rb->rbq = buff;
rb->bpos = -1;
return RET_OK;
}
void rbuffer_destroy(struct rbuffer *rb)
{
rbuffer_reset(rb);
rb->qsize = 0;
}
void rbuffer_reset(struct rbuffer *rb)
{
uint32 flag = disable_irq();
rb->wpos = 0;
rb->rpos = 0;
enable_irq(flag);
}
int32 rbuffer_set(struct rbuffer *rb, void *data, uint32 length)
{
uint32 len;
uint32 rpos, wpos;
uint32 flag;
if (rb->rbq == NULL) {
return -ENOBUFS;
}
flag = disable_irq();
rpos = rb->rpos;
wpos = rb->wpos;
enable_irq(flag);
len = ((wpos < rpos) ? (rpos - wpos - 1) : ((rb)->qsize - wpos + rpos - 1));
if (len < length) {
return -ENOBUFS;
}
if (wpos < rpos) {
os_memcpy(rb->rbq + wpos, data, length);
} else {
len = rb->qsize - wpos;
if (len < length) { //rewind
os_memcpy(rb->rbq + wpos, data, len);
os_memcpy(rb->rbq, data + len, length - len);
} else {
os_memcpy(rb->rbq + wpos, data, length);
}
}
wpos += length;
if (wpos >= rb->qsize) {
wpos -= rb->qsize;
}
flag = disable_irq();
rb->wpos = wpos;
enable_irq(flag);
return length;
}
int32 rbuffer_set_force(struct rbuffer *rb, void *data, uint32 length)
{
uint32 flag;
uint32 len;
if (rb->rbq == NULL || (rb->qsize - 1) < length) {
return -ENOBUFS;
}
flag = disable_irq();
len = RB_IDLE(rb);
if (len < length) {
rb->rpos = RB_NPOS(rb, rpos, length - len);
}
enable_irq(flag);
return rbuffer_set(rb, data, length);
}
int32 rbuffer_get(struct rbuffer *rb, void *buff, uint32 size)
{
int32 len = 0; // right length
int32 count = 0;
uint32 rpos, wpos;
uint32 flag;
flag = disable_irq();
rpos = rb->rpos;
wpos = rb->wpos;
enable_irq(flag);
if (rb->rbq == NULL || rpos == wpos) {
return 0;
}
count = ((rpos <= wpos) ? (wpos - rpos) : ((rb)->qsize - rpos + wpos));
if (count > size) {
count = size;
}
if (rpos <= wpos) {
os_memcpy(buff, rb->rbq + rpos, count);
} else {
len = rb->qsize - rpos;
if (len >= count) {
os_memcpy(buff, rb->rbq + rpos, count);
} else {
os_memcpy(buff, rb->rbq + rpos, len);
os_memcpy(buff + len, rb->rbq, count - len);
}
}
rpos += count;
if (rpos >= rb->qsize) {
rpos -= rb->qsize;
}
flag = disable_irq();
rb->rpos = rpos;
enable_irq(flag);
return count;
}
int32 rbuffer_set_block(struct rbuffer *rb, void *data, uint32 length, uint8 block)
{
uint32 bpos = rb->wpos;
int32 ret = rbuffer_set(rb, data, length);
if (ret == length && block) {
rb->bpos = bpos;
}
return ret;
}
int32 rbuffer_get_block(struct rbuffer *rb, void *buff, uint32 size, uint8 *block)
{
if (rb->rpos == rb->bpos) {
*block = 1;
rb->bpos = -1;
} else {
*block = 0;
}
return rbuffer_get(rb, buff, size);
}
int32 rbuffer_alloc(struct rbuffer *rb, uint32 size)
{
void *buff = os_malloc(size);
ASSERT(buff);
return rbuffer_init(rb, size, buff);
}
void rbuffer_free(struct rbuffer *rb)
{
rb->qsize = 0;
os_free(rb->rbq);
}

637
sdk/lib/common/string.c Normal file
View File

@@ -0,0 +1,637 @@
#include "basic_include.h"
#include "lib/heap/sysheap.h"
#ifndef PRINT_LEVEL_DEFAULT
#define PRINT_LEVEL_DEFAULT (6)
#endif
#ifndef PRINT_BUFF_SIZE
#define PRINT_BUFF_SIZE (256)
#endif
#define LOWCASE(c) (((c)>='A'&&(c) <= 'Z')?(c)+32:(c))
#define _PRINT_DISABLED_ (BIT(0))
#define _PRINT_COLOR_DISABLED_ (BIT(1))
#define _PRINT_TIME_DISABLED_ (BIT(2))
#define _PRINT_TIME_NTP_ (BIT(3))
#define _PRINT_REDIRECT_DUAL_ (BIT(4))
__bobj static osprint_hook __print_hook;
__bobj static void *__print_hook_priv;
__bobj void *console_handle;
__bobj int8 __print_level__;
__bobj uint8 __print_ctrl__;
__bobj char _print_buff_p[PRINT_BUFF_SIZE];
static const char *__print_color__[] = {
"\e[40;35;7m", //KERN_EMERG : Red
"\e[40;35;7m", //KERN_ALERT : Red
"\e[40;35;7m", //KERN_CRIT : Red
"\e[40;31m", //KERN_ERR : Red
"\e[40;33m", //KERN_WARNING: Yellow
"\e[40;32m", //KERN_NOTICE : Green
"\e[40;34m", //KERN_INFO : Blue
"\e[40;30m", //KERN_DEBUG : Black/Default
"\e[0m", //END
};
int printf(const char *format, ...) __alias(hgprintf);
int puts(const char *s) __alias(hgputs);
int __wrap_printf(const char *format, ...) __alias(hgprintf);
int __cskyvprintfprintf(const char *format, ...) __alias(hgprintf);
////////////////////////////////////////////////////////////////////////
int32 hexchr2int(char c)
{
if (c >= '0' && c <= '9') {
return c - '0';
}
if (c >= 'a' && c <= 'f') {
return c - 'a' + 10;
}
if (c >= 'A' && c <= 'F') {
return c - 'A' + 10;
}
return -1;
}
int32 hex2char(char *hex_str)
{
int a, b;
a = hexchr2int(*hex_str++);
if (a < 0) {
return -1;
}
b = hexchr2int(*hex_str++);
if (b < 0) {
return -1;
}
return (a << 4) | b;
}
int32 hex2bin(char *hex_str, uint8 *bin, uint32 len)
{
uint32 i = 0;
uint32 str_len = 0;
int32 a;
char *ipos = hex_str;
uint8 *opos = bin;
if (!hex_str || !bin) {
return i;
}
str_len = os_strlen(hex_str);
for (i = 0; i < len && (i * 2) + 2 <= str_len; i++) {
a = hex2char(ipos);
if (a < 0) {
return i;
}
*opos++ = (uint8)a;
ipos += 2;
}
return i;
}
void str2mac(char *macstr, uint8 *mac)
{
mac[0] = hex2char(macstr);
mac[1] = hex2char(macstr + 3);
mac[2] = hex2char(macstr + 6);
mac[3] = hex2char(macstr + 9);
mac[4] = hex2char(macstr + 12);
mac[5] = hex2char(macstr + 15);
}
uint32 str2ip(char *ipstr)
{
char *ptr = ipstr;
uint32 ip = os_atoi(ipstr);
do {
if (*ptr == '.') {
ptr++;
ip = (ip << 8 | os_atoi(ptr));
}
ptr++;
} while (*ptr);
return os_htonl(ip);
}
uint64 _os_atoh(char *str, int8 count)
{
uint64 val = 0;
int32 s = 0;
int8 cnt = 1;
if (os_strlen(str) > 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
str += 2;
}
while (*str && cnt++ <= count) {
s = hexchr2int(*str);
if (s == -1) {
break;
}
val = (val << 4) + s;
str++;
}
return val;
}
uint32 os_atoh(char *str)
{
return (uint32)_os_atoh(str, 8);
}
uint64 os_atohl(char *str)
{
return _os_atoh(str, 16);
}
char *os_strdup(const char *s)
{
size_t len;
char *d;
if (s == NULL) {
return NULL;
}
len = strlen(s);
d = os_malloc(len + 1);
if (d == NULL) {
return NULL;
}
os_memcpy(d, s, len);
d[len] = '\0';
return d;
}
void print_redirect(osprint_hook print, void *priv, uint8 dual_out)
{
uint32 flag = disable_irq();
__print_hook = print;
__print_hook_priv = priv;
if(dual_out){
__print_ctrl__ |= _PRINT_REDIRECT_DUAL_;
} else {
__print_ctrl__ &= ~ _PRINT_REDIRECT_DUAL_;
}
enable_irq(flag);
}
void print_level(int8 level)
{
__print_level__ = level;
}
void disable_print(int8_t dis)
{
if(dis){
__print_ctrl__ |= _PRINT_DISABLED_;
}else{
__print_ctrl__ &= ~ _PRINT_DISABLED_;
}
}
void disable_print_color(int8_t dis)
{
if(dis){
__print_ctrl__ |= _PRINT_COLOR_DISABLED_;
}else{
__print_ctrl__ &= ~ _PRINT_COLOR_DISABLED_;
}
}
void disable_print_time(int8_t dis)
{
if(dis){
__print_ctrl__ |= _PRINT_TIME_DISABLED_;
}else{
__print_ctrl__ &= ~ _PRINT_TIME_DISABLED_;
}
}
void print_with_ntp(uint8 en)
{
if(en){
__print_ctrl__ |= _PRINT_TIME_NTP_;
}else{
__print_ctrl__ &= ~ _PRINT_TIME_NTP_;
}
}
static void hgprintf_uart(char *str, int32 len)
{
int32 off = 0;
if (len == 0) { len = os_strlen(str); }
while (off < len) {
uart_putc((struct uart_device *)console_handle, str[off++]);
}
}
void hgprintf_out(char *str, int32 len, uint8 level)
{
osprint_hook _print;
void *_print_priv;
uint8 color = 0;
uint32 flag = disable_irq();
_print_priv = __print_hook_priv;
_print = __print_hook;
enable_irq(flag);
if (__print_level__ && level > __print_level__) {
return;
}
if (level > 7)
level = 7;
if(level < 7 && !(__print_ctrl__ & _PRINT_COLOR_DISABLED_))
color = level;
if (_print) {
if (color) _print(_print_priv, (char *)__print_color__[color], 0);
_print(_print_priv, str, len);
if (color) _print(_print_priv, (char *)__print_color__[8], 0);
}
if(_print == NULL || (__print_ctrl__ & _PRINT_REDIRECT_DUAL_)){
if (color) hgprintf_uart((char *)__print_color__[color], 0);
hgprintf_uart(str, len);
if (color) hgprintf_uart((char *)__print_color__[8], 0);
}
if (color) sys_errlog_save((char *)__print_color__[color], 0, level);
sys_errlog_save(str, len, level);
if (color) sys_errlog_save((char *)__print_color__[8], 0, level);
}
void hgvprintf(const char *fmt, va_list ap)
{
int32 ret = 0;
int32 len = 0;
uint8 level = 7;
uint8 tick = 0;
struct timeval tv;
struct tm *tm_t;
if (__print_ctrl__ & _PRINT_DISABLED_) {
return;
}
if (fmt[0] == 2) {
tick = !(__print_ctrl__ & _PRINT_TIME_DISABLED_);
fmt++;
}
if (fmt[0] == 1) {
level = fmt[1] - '0';
fmt += 2;
}
if (__print_level__ && level > __print_level__) {
return;
}
if (tick) {
len = sprintf(_print_buff_p, "[%llu]", os_jiffies_to_msecs(os_jiffies()));
if (__print_ctrl__ & _PRINT_TIME_NTP_) {
gettimeofday(&tv, NULL);
if(tv.tv_sec > 1704038400){
tm_t = localtime((const time_t *)&tv.tv_sec);
len += sprintf(_print_buff_p + len, "[%02d/%02d %02d:%02d:%02d-%03llu]",
tm_t->tm_mon + 1, tm_t->tm_mday, tm_t->tm_hour,
tm_t->tm_min, tm_t->tm_sec, tv.tv_usec / 1000);
}
}
}
ret = vsnprintf(_print_buff_p + len, (PRINT_BUFF_SIZE - 2 - len), fmt, ap);
if (ret < 0 || ret > (PRINT_BUFF_SIZE - 2 - len)) {
len = PRINT_BUFF_SIZE - 1;
_print_buff_p[len - 1] = '\n';
_print_buff_p[len - 2] = '\r';
} else {
len += ret;
}
if (len > 0) {
if (_print_buff_p[len - 1] == '\n' && _print_buff_p[len - 2] != '\r') {
_print_buff_p[len - 1] = '\r';
_print_buff_p[len++] = '\n';
}
_print_buff_p[len] = 0;
hgprintf_out(_print_buff_p, len, level);
}
}
void hgprintf(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
hgvprintf(fmt, ap);
va_end(ap);
}
int hgputs(const char *s)
{
hgprintf("%s", s);
return os_strlen(s) + 1;
}
void dump_hex(char *title, uint8 *data, uint32 len, int32 newline)
{
int i = 0;
if (data && len) {
_os_printf("[dump address: %p]\r\n", data);
if (title) _os_printf("%s", title);
for (i = 0; i < len; i++) {
if (i > 0 && newline) {
if ((i & 0x7) == 0) _os_printf(" ");
if ((i & 0xf) == 0) _os_printf("\r\n");
}
_os_printf("%02x ", data[i] & 0xFF);
}
_os_printf("\r\n");
}
}
void dump_memory(char *title, uint32 *data, uint32 len)
{
int i = 0;
if (data && len) {
if (title) _os_printf("%s", title);
for (i = 0; i < len; i++) {
if ((i & 0x7) == 0) _os_printf("0x%x: ", data+i);
if ((i & 0x7) == 7) _os_printf("\r\n");
_os_printf("%x ", data[i]);
}
_os_printf("\r\n");
}
}
void dump_key(char *str, uint8 *key, uint32 len, uint32 sp)
{
int32 i = 0;
if (key && len) {
if (str) _os_printf("%s", str);
for (i = 0; i < len; i++) {
if (sp) {
_os_printf("%02x ", key[i]);
} else {
_os_printf("%02x", key[i]);
}
}
_os_printf("\r\n");
}
}
// str_buf申请的空间需要比key_len多1byte，sprintf会额外在字符串结束添加0
void key_str(uint8 *key, uint32 key_len, char *str_buf)
{
int32 i = 0;
for (i = 0; i < key_len; i++) {
os_sprintf(str_buf + i * 2, "%02x", key[i]);
}
}
void *_os_memcpy(void *str1, const void *str2, int32 n)
{
#ifdef MEM_TRACE
#ifdef PSRAM_HEAP
void *heap = IS_PSRAM_ADDR(str1) ? (void *)(&psram_heap) : (void *)(&sram_heap);
#else
void *heap = &sram_heap;
#endif
int32 ret = sysheap_of_check(heap, str1, n);
if (ret == 0) {
os_printf(KERN_WARNING"%s: memroy %p maybe overflow!!\r\n", __FUNCTION__, str1);
}
#endif
return memcpy(str1, str2, n);
}
char *_os_strcpy(char *dest, const char *src)
{
#ifdef MEM_TRACE
#ifdef PSRAM_HEAP
void *heap = IS_PSRAM_ADDR(dest) ? (void *)(&psram_heap) : (void *)(&sram_heap);
#else
void *heap = &sram_heap;
#endif
int32 n = strlen(src) + 1; // +'\0'
int32 ret = sysheap_of_check(heap, dest, n);
if (ret == 0) {
os_printf(KERN_WARNING"%s: memroy %p maybe overflow!!\r\n", __FUNCTION__, dest);
}
#endif
return strcpy(dest, src);
}
void *_os_memset(void *str, int c, int32 n)
{
#ifdef MEM_TRACE
#ifdef PSRAM_HEAP
void *heap = IS_PSRAM_ADDR(str) ? (void *)(&psram_heap) : (void *)(&sram_heap);
#else
void *heap = &sram_heap;
#endif
int32 ret = sysheap_of_check(heap, str, n);
if (ret == 0) {
os_printf(KERN_WARNING"%s: memroy %p maybe overflow!!\r\n", __FUNCTION__, str);
}
#endif
return memset(str, c, n);
}
void *_os_memmove(void *str1, const void *str2, size_t n)
{
#ifdef MEM_TRACE
#ifdef PSRAM_HEAP
void *heap = IS_PSRAM_ADDR(str1) ? (void *)(&psram_heap) : (void *)(&sram_heap);
#else
void *heap = &sram_heap;
#endif
int32 ret = sysheap_of_check(heap, str1, n);
if (ret == 0) {
os_printf(KERN_WARNING"%s: memroy %p maybe overflow!!\r\n", __FUNCTION__, str1);
}
#endif
return memmove(str1, str2, n);
}
char *_os_strncpy(char *dest, const char *src, int32 n)
{
#ifdef MEM_TRACE
#ifdef PSRAM_HEAP
void *heap = IS_PSRAM_ADDR(dest) ? (void *)(&psram_heap) : (void *)(&sram_heap);
#else
void *heap = &sram_heap;
#endif
int32 ret = sysheap_of_check(heap, dest, n);
if (ret == 0) {
os_printf(KERN_WARNING"%s: memroy %p maybe overflow!!\r\n", __FUNCTION__, dest);
}
#endif
return strncpy(dest, src, n);
}
int _os_sprintf(char *str, const char *format, ...)
{
#ifdef MEM_TRACE
int ret;
#ifdef PSRAM_HEAP
void *heap = IS_PSRAM_ADDR(str) ? (void *)(&psram_heap) : (void *)(&sram_heap);
#else
void *heap = &sram_heap;
#endif
#endif
int len;
va_list ap;
va_start(ap, format);
len = vsprintf(str, format, ap);
va_end(ap);
#ifdef MEM_TRACE
ret = sysheap_of_check(heap, str, len+1);
if (ret == 0) {
os_printf(KERN_WARNING"%s: memroy %p maybe overflow!!\r\n", __FUNCTION__, str);
}
#endif
return len;
}
int _os_vsnprintf(char *s, size_t n, const char *format, va_list arg)
{
#ifdef MEM_TRACE
#ifdef PSRAM_HEAP
void *heap = IS_PSRAM_ADDR(s) ? (void *)(&psram_heap) : (void *)(&sram_heap);
#else
void *heap = &sram_heap;
#endif
#endif
int len = vsnprintf(s, n, format, arg);
#ifdef MEM_TRACE
int check_len = (len < n) ? len + 1 : n;
int ret = sysheap_of_check(heap, s, check_len);
if (ret == 0) {
os_printf(KERN_WARNING"%s: memroy %p maybe overflow!!\r\n", __FUNCTION__, s);
}
#endif
return len;
}
int _os_snprintf(char *str, size_t size, const char *format, ...)
{
#ifdef MEM_TRACE
int ret;
#ifdef PSRAM_HEAP
void *heap = IS_PSRAM_ADDR(str) ? (void *)(&psram_heap) : (void *)(&sram_heap);
#else
void *heap = &sram_heap;
#endif
#endif
int len;
va_list ap;
va_start(ap, format);
len = vsnprintf(str, size, format, ap);
va_end(ap);
#ifdef MEM_TRACE
int check_len = (len < size) ? len + 1 : size;
ret = sysheap_of_check(heap, str, check_len);
if (ret == 0) {
os_printf(KERN_WARNING"%s: memroy %p maybe overflow!!\r\n", __FUNCTION__, str);
}
#endif
return len;
}
int32 os_strtok(char *str, char *separator, char *argv[], int argv_size)
{
int32 cnt = 0;
char *ptr = str;
if (str == NULL || separator == NULL || argv == NULL || argv_size <= 0) {
return 0;
}
argv[cnt++] = ptr;
ptr = os_strstr(ptr, separator);
while (ptr && cnt < argv_size) {
*ptr = 0;
ptr += os_strlen(separator);
if (os_strlen(ptr) == 0) {
break;
}
argv[cnt++] = ptr;
ptr = os_strstr(ptr, separator);
}
return cnt;
}
const char *os_strncasechr(const char *s, char c, int32 n)
{
if (!s) return NULL;
c = LOWCASE(c);
// strcasechr
if (n < 0) {
while (*s) {
if (LOWCASE(*s) == c) {
return s;
}
s++;
}
return NULL;
} else {
for (int32 i = 0; i < n; i++) {
if (s[i] == '\0') break;
if (LOWCASE(s[i]) == c) {
return &s[i];
}
}
return NULL;
}
}
const char *os_strncasestr(const char *str1, const char *str2, int32 n)
{
if (!str1 || !str2) return NULL;
if (str2[0] == '\0') return str1;
int32 len2 = 0;
while (str2[len2]) len2++;
int32 len1 = n;
if (n < 0) {
len1 = 0x7FFFFFFF;
}
if (len2 > len1) return NULL;
const char *p = str1;
while (*p && (p - str1) <= len1 - len2) {
if (LOWCASE(p[0]) == LOWCASE(str2[0])) {
if (os_strncasecmp(p, str2, len2) == 0) {
return p;
}
}
p++;
}
return NULL;
}

16
sdk/lib/common/us_ticker.c Normal file
View File

@@ -0,0 +1,16 @@
#include "typesdef.h"
#include "list.h"
#include "dev.h"
#include "devid.h"
#include "osal/sleep.h"
void os_sleep_us(int us)
{
uint32 ms = us / 1000;
us = us % 1000;
if (ms > 0) {
os_sleep_ms(ms);
}
delay_us(us);
}

100
sdk/lib/common/weak.c Normal file
View File

@@ -0,0 +1,100 @@
#include "basic_include.h"
#include "hal/netdev.h"
#include "lib/net/utils.h"
__weak void sys_wakeup_host(void)
{
}
/*
wkq : 当前运行work的workqueue
work: 当前被执行的work
start: [1: work即将开始运行 ]
[0：work运行结束 ]
runtime： work的运行时间
*/
__weak void os_work_schedule_hook(struct os_workqueue *wkq, struct os_work *work, uint8 start, uint32 runtime)
{
}
/*************** Some Weak Functions ***************************/
///////////////////////////////////////////////////////////////////////////////////
__weak int32 sys_register_sleepcb(sys_sleepcb cb, void *priv)
{
return RET_OK;
}
__weak int32 wifi_proc_drvcmd_cust(uint16 cmd_id, uint8 *data, uint32 len, void *hdr)
{
/*
cmd_id: driver cmd id (from host driver).
data : cmd data.
len : cmd data length.
hdr : cmd info, just used to call host_cmd_resp API.
1. parse cmd data, do some thing if you need.
2. send cmd response to host:
// has no additional response data.
host_cmd_resp(cmd_return_value, NULL, 0, hdr);
// has some additional response data.
host_cmd_resp(cmd_return_value, reponse_data, response_data_length, hdr);
3. return RET_OK if the driver cmd has been processed, else return -ENOTSUPP.
you can process any driver cmd in this function.
*/
return -ENOTSUPP;
}
__weak int32 sswitch_dev_rule_check(SSWITCH_RULE_CHECK type, uint8 *data, uint32 len, uint32 port)
{
#if 0
/*
* ——————————————————————
* | local system(lwip) |
* ——————————————————————
* ↑ ↓
* <local_input> <local_output>
* ↑ |
* <port_input> ——> <forward> |
* ↑ ↓ ↓
* ————> [port dev] [port dev] ————>
*
*/
scatter_data *sdata;
switch (type) {
case SSWITCH_RULE_CHECK_PORT_INPUT: //从某个端口接收数据
os_printf("Port_%d input data ["MACSTR"<->"MACSTR", proto:%x], len=%d\r\n",
(port & 0xff), MAC2STR(data), MAC2STR(data + 6), get_unaligned_be16(data + 12), len);
break;
case SSWITCH_RULE_CHECK_LOCAL_INPUT: //接收的数据被输入到本地
os_printf("Local input data ["MACSTR"<->"MACSTR", proto:%x] len=%d, source port:%d\r\n",
MAC2STR(data), MAC2STR(data + 6), get_unaligned_be16(data + 12), len, (port & 0xff));
break;
case SSWITCH_RULE_CHECK_FORWARD: //接收的数据数据被转发
os_printf("Forward input data ["MACSTR"<->"MACSTR", proto:%, len=%d] Port_%d -> Port_%d\r\n",
MAC2STR(data), MAC2STR(data + 6), get_unaligned_be16(data + 12), len,
(port & 0xff)/*source port dev*/, (port >> 8) & 0xff /*dest port dev*/);
break;
case SSWITCH_RULE_CHECK_LOCAL_OUTPUT: //本地输出数据
os_printf("Local output data ["MACSTR"<->"MACSTR", proto:%x, len=%d] To Port_%d\r\n",
MAC2STR(data), MAC2STR(data + 6), get_unaligned_be16(data + 12), len, (port >> 8) & 0xff);
break;
case SSWITCH_RULE_CHECK_LOCAL_OUTPUT_SCATTER: //本地输出数据(scatter类型)
sdata = (scatter_data *)data;
os_printf("Local output scatter data ["MACSTR"<->"MACSTR", proto:%x, len=%d] To Port_%d\r\n",
MAC2STR(sdata[0].addr), MAC2STR(sdata[0].addr + 6),
get_unaligned_be16(sdata[0].addr + 12), scatter_size(sdata, len), (port >> 8) & 0xff);
break;
}
#endif
return 1; //1:pass, 0:drop
}