RTL00_WEB_VS/RTLGDB/USDK/component/common/api/wifi_api.c
ADElectronics 764b020238 update
2017-11-28 22:31:40 +03:00

924 lines
No EOL
27 KiB
C
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* wifi_api.c
*
* Created on: 01/11/2017
* Author: pvvx
*/
#include <platform_opts.h>
#include "rtl8195a.h"
#include "drv_types.h"
#include <autoconf.h>
#include "FreeRTOS.h"
#if 1
#include "drv_types.h" // or #include "wlan_lib.h"
#else
#include "wifi_constants.h"
#include "wifi_structures.h"
//#include "wlan_lib.h" // or #include "drv_types.h"
#endif
#if CONFIG_EXAMPLE_WLAN_FAST_CONNECT
#error "Udnef CONFIG_EXAMPLE_WLAN_FAST_CONNECT!"
#endif
#ifndef USE_FLASH_EEP
#error "Define USE_FLASH_EEP!"
#endif
#include "task.h"
#include <platform/platform_stdlib.h>
#include <wifi/wifi_conf.h>
#include "flash_api.h"
#include <lwip_netconf.h>
#include "dhcp/dhcps.h"
#include "ethernetif.h"
#if CONFIG_ETHERNET
#include "ethernet_mii/ethernet_mii.h"
#endif
#include "flash_eep.h"
#include "feep_config.h"
#include "wifi_api.h"
#include "main.h"
#include "wifi_user_set.h"
#if 0
#undef debug_printf
#define debug_printf(fmt, ...) rtl_printf(fmt, ##__VA_ARGS__)
#undef info_printf
#define info_printf(fmt, ...) rtl_printf(fmt, ##__VA_ARGS__)
#undef warning_printf
#define warning_printf(fmt, ...) rtl_printf(fmt, ##__VA_ARGS__)
#undef error_printf
#define error_printf(fmt, ...) rtl_printf(fmt, ##__VA_ARGS__)
#endif
#if defined(CONFIG_ENABLE_WPS_AP) && CONFIG_ENABLE_WPS_AP
extern void cmd_ap_wps(int argc, char **argv);
extern int wpas_wps_dev_config(uint8_t *dev_addr, uint8_t bregistrar);
#endif //CONFIG_WPS_AP
//=========================================
//--- Wlan Config Init-------------------
WIFI_CONFIG wifi_cfg = {
.mode = DEF_WIFI_MODE, // rtw_mode_t
.adaptivity = DEF_WIFI_ADAPTIVITY, // rtw_adaptivity_mode_t
.country_code = DEF_WIFI_COUNTRY,// rtw_country_code_t
.tx_pwr = DEF_WIFI_TX_PWR, // rtw_tx_pwr_percentage_t
.bgn = DEF_WIFI_BGN, // rtw_network_mode_t
.load_flg = DEF_LOAD_CFG,
.save_flg = DEF_SAVE_CFG
};
//---- Interface 0 - wlan0 - AP - init ---
SOFTAP_CONFIG wifi_ap_cfg = {
.ssid = DEF_AP_SSID,
.password = DEF_AP_PASSWORD,
.security = (unsigned char)DEF_AP_SECURITY, // RTW_SECURITY_WPA2_AES_PSK or RTW_SECURITY_OPEN
.beacon_interval = DEF_AP_BEACON,
.channel = DEF_AP_CHANNEL,
.ssid_hidden = 0,
.max_sta = DEF_WIFI_AP_STATIONS // Max number of STAs, should be 1..3, default is 3
};
DHCP_CONFIG wifi_ap_dhcp = {
.ip = DEF_AP_IP,
.mask = DEF_AP_MSK,
.gw = DEF_AP_GW,
.mode = 2
};
//---- Interface 1 - wlan1 - ST - init ---
STATION_CONFIG wifi_st_cfg = {
.ssid = DEF_ST_SSID,
.password = DEF_ST_PASSWORD,
.bssid = DEF_ST_BSSID,
.flg = DEF_ST_USE_BSSID,
.security = DEF_ST_SECURITY,
.autoreconnect = DEF_ST_AUTORECONNECT,
.reconnect_pause = DEF_ST_RECONNECT_PAUSE,
.sleep = DEF_ST_SLEEP,
.dtim = DEF_ST_LPS_DTIM
};
DHCP_CONFIG wifi_st_dhcp = {
.ip = DEF_ST_IP,
.mask = DEF_ST_MSK,
.gw = DEF_ST_GW,
.mode = 1
};
unsigned char wifi_run_mode = RTW_MODE_NONE; // rtw_mode_t
unsigned char wifi_st_status;
typedef int (*wlan_init_done_ptr)(void);
typedef int (*write_reconnect_ptr)(uint8_t *data, uint32_t len);
//Function
#if CONFIG_AUTO_RECONNECT
extern void (*p_wlan_autoreconnect_hdl)(rtw_security_t, char*, int, char*, int, int);
#endif
extern wlan_init_done_ptr p_wlan_init_done_callback;
//extern write_reconnect_ptr p_write_reconnect_ptr;
extern struct netif xnetif[NET_IF_NUM];
extern uint8_t rtw_power_percentage_idx;
extern Rltk_wlan_t rltk_wlan_info[2]; // in wrapper.h
#define PARM_RECONNECT 1
struct wifi_autoreconnect_param {
#if PARM_RECONNECT
rtw_security_t security_type;
int key_id;
#else
rtw_security_t security_type;
char *ssid;
int ssid_len;
char *password;
int password_len;
int key_id;
#endif
};
struct wifi_autoreconnect_param wifi_autoreconnect;
typedef struct _feep_element {
uint16 id;
uint16 size;
void * obj;
} FEEP_ELEMENT, *PFEEP_ELEMENT;
FEEP_ELEMENT feep_tab[] = {
{ FEEP_ID_WIFI_AP_CFG, sizeof(wifi_ap_cfg), &wifi_ap_cfg }, // Bit0 BID_WIFI_AP_CFG
{ FEEP_ID_WIFI_ST_CFG, sizeof(wifi_st_cfg), &wifi_st_cfg }, // Bit1 BID_WIFI_ST_CFG
{ FEEP_ID_AP_DHCP_CFG, sizeof(wifi_ap_dhcp), &wifi_ap_dhcp }, // Bit2 BID_AP_DHCP_CFG
{ FEEP_ID_ST_DHCP_CFG, sizeof(wifi_st_dhcp), &wifi_st_dhcp }, // Bit3 BID_ST_DHCP_CFG
{ FEEP_ID_WIFI_CFG, sizeof(wifi_cfg), &wifi_cfg }, // Bit4 BID_WIFI_CFG
{ FEEP_ID_AP_HOSTNAME, LWIP_NETIF_HOSTNAME_SIZE, &lwip_host_name[1] }, // Bit5 BID_AP_HOSTNAME
{ FEEP_ID_ST_HOSTNAME, LWIP_NETIF_HOSTNAME_SIZE, &lwip_host_name[0] }, // Bit5 BID_ST_HOSTNAME
{ 0, 0, NULL }
};
uint32 read_wifi_cfg(uint32 flg)
{
uint32 ret = 0;
PFEEP_ELEMENT p = feep_tab;
for(int m = 1; m && p->id != 0; m <<= 1, p++) {
if((flg & m)
&& flash_read_cfg(p->obj, p->id, p->size) < p->size) {
ret |= m;
};
};
return ret;
}
uint32 write_wifi_cfg(uint32 flg)
{
uint32 ret = 0;
PFEEP_ELEMENT p = feep_tab;
for(int m = 1; m && p->id != 0; m <<= 1, p++) {
if(flg & m) {
if(!flash_write_cfg(p->obj, p->id, p->size)) {
ret |= m;
};
};
};
return ret;
}
#if CONFIG_WLAN_CONNECT_CB
_WEAK void connect_start(void)
{
info_printf("%s: Time at start %d ms.\n", __func__, xTaskGetTickCount());
}
_WEAK void connect_close(void)
{
info_printf("%s: Time at start %d ms.\n", __func__, xTaskGetTickCount());
}
#endif
#ifdef NOT_USE_CALLS
static int wlan_init_done_callback(void) {
printf("WiFi Init after %d ms\n", xTaskGetTickCount());
return 0;
}
#endif // #ifdef NOT_USE_CALLS
//char wlan_st_name[] = WLAN0_NAME;
char wlan_st_name[] = WLAN0_NAME;
char wlan_ap_name[] = WLAN1_NAME;
unsigned char wlan_st_netifn = 0;
unsigned char wlan_ap_netifn = 1;
uint32 get_new_ip(void)
{
if(!(wifi_cfg.mode ^ wifi_run_mode)) {
return current_netif->ip_addr.addr;
} else if(wifi_cfg.mode == RTW_MODE_AP) {
return wifi_ap_dhcp.ip;
} else if(wifi_st_dhcp.mode == 2) {
return wifi_st_dhcp.ip;
}
return 0;
}
uint8 * get_new_hostname(void)
{
if(!(wifi_cfg.mode ^ wifi_run_mode)) {
return current_netif->hostname;
} else if(wifi_cfg.mode == RTW_MODE_AP) {
return lwip_host_name[1];
};
return lwip_host_name[0];
}
static uint8 chk_ap_netif_num(void)
{
if (wifi_mode == RTW_MODE_AP) {
wlan_st_name[4] = '1';
wlan_ap_name[4] = '0';
wlan_st_netifn = 1;
wlan_ap_netifn = 0;
}
else { // if (wifi_mode == RTW_MODE_STA) {
wlan_st_name[4] = '0';
wlan_ap_name[4] = '1';
wlan_st_netifn = 0;
wlan_ap_netifn = 1;
}
return wlan_ap_netifn;
}
extern Rltk_wlan_t rltk_wlan_info[2]; // in wrapper.h
/*static _adapter * get_padaptern(int num) {
if(rltk_wlan_info[num].enable) {
return *(_adapter **)((rltk_wlan_info[0].dev)->priv);
}
return NULL;
};*/
#define get_padaptern(num) (*(_adapter **)((rltk_wlan_info[num].dev)->priv));
rtw_result_t _wext_set_lps_dtim(int adapter_num, uint8 lps_dtim ) {
_adapter * pad = get_padaptern(adapter_num);
rtw_result_t ret = RTW_ERROR;
if(pad) {
ret = rtw_pm_set_lps_dtim(pad, lps_dtim);
}
return ret;
}
int _wext_get_lps_dtim(int adapter_num) {
_adapter * pad = get_padaptern(adapter_num);
return rtw_pm_get_lps_dtim(pad);
}
rtw_result_t _wext_enable_powersave(int adapter_num, uint8 ips_mode, uint8 lps_mode) {
_adapter * pad = get_padaptern(adapter_num);
rtw_result_t ret = RTW_ERROR;
if(pad) {
ret = rtw_pm_set_ips(pad, ips_mode); // 2 режима 1,2 ?
if(ret == RTW_SUCCESS) {
LeaveAllPowerSaveMode(pad);
ret = rtw_pm_set_lps(pad, lps_mode);
}
}
return ret;
}
static int _wext_cmp_ssid(int adapter_num, unsigned char *ssid)
{
_adapter * pad = get_padaptern(adapter_num);
int ret = 0;
if((pad != NULL) && (pad->mlmepriv.fw_state & 0x41) != 0) {
int len = pad->mlmepriv.cur_network.network.Ssid.SsidLength;
if(len < 32) len++;
else len = 32;
ret = (rtl_memcmp(ssid, &pad->mlmepriv.cur_network.network.Ssid.Ssid, len) == 0);
debug_printf("%d s[%d]'%s'\n", pad->mlmepriv.fw_state, len, ssid);
}
return ret;
}
#ifdef NOT_USE_CALLS
static rtw_result_t _wext_get_mode(int adapter_num, int *mode) {
_adapter * pad = get_padaptern(adapter_num);
rtw_result_t ret = RTW_ERROR;
if(pad) {
uint16 f = pad->mlmepriv.fw_state;
if(f & 8) *mode = 2;
else if(f & 0x60) *mode = 1;
else if(!(f & 0x10)) *mode = 0;
else *mode = 3;
ret = RTW_SUCCESS;
}
return ret;
}
static rtw_result_t _wext_get_channel(int adapter_num, uint8 *ch)
{
_adapter * pad = get_padaptern(adapter_num);
rtw_result_t ret = RTW_ERROR;
if(pad) {
if(pad->mlmepriv.fw_state & 1) {
*ch = pad->mlmepriv.htpriv.ch_offset;
}
else {
*ch = pad->mlmeextpriv.cur_channel;
}
ret = RTW_SUCCESS;
}
return ret;
}
#endif // #ifdef NOT_USE_CALLS
static rtw_result_t wifi_run_ap(void) {
rtw_result_t ret = RTW_NOTAP;
if( (wifi_mode == RTW_MODE_AP) || (wifi_mode == RTW_MODE_STA_AP) ){
info_printf("Starting AP (%s, netif%d)...\n", wlan_ap_name, wlan_ap_netifn);
/*
netif_set_addr(&xnetif[WLAN_AP_NETIF_NUM], &wifi_ap_dhcp.ip,
&wifi_ap_dhcp.mask, &wifi_ap_dhcp.gw);
*/
if(wext_set_sta_num(wifi_ap_cfg.max_sta) != 0) { // Max number of STAs, should be 1..3, default is 3
error_printf("AP not set max connections %d!\n", wifi_ap_cfg.max_sta);
};
#if defined(CONFIG_ENABLE_WPS_AP) && CONFIG_ENABLE_WPS_AP
// todo: ветка не доделана
wpas_wps_dev_config(xnetif[WLAN_AP_NETIF_NUM].hwaddr, 1);
#endif //CONFIG_WPS_AP
if(wifi_ap_cfg.channel == 0 || wifi_ap_cfg.channel > 14) {
wifi_ap_cfg.channel = 1;
}
ret = wifi_start_ap(wifi_ap_cfg.ssid, //char *ssid,
wifi_ap_cfg.security, //rtw_security_t ecurity_type,
wifi_ap_cfg.password, //char *password,
wifi_ap_cfg.channel, //int channel
wifi_ap_cfg.ssid_hidden); //
// wifi_run_mode |= RTW_MODE_AP;
if (ret != RTW_SUCCESS) {
error_printf("Error(%d): Start AP failed!\n\n", ret);;
} else {
int timeout = wifi_test_timeout_ms / wifi_test_timeout_step_ms;
while (1) {
#if 1
if (_wext_cmp_ssid(WLAN_AP_NETIF_NUM, wifi_ap_cfg.ssid )) {
#else
char essid[33];
if ((wext_get_ssid(wlan_ap_name, (unsigned char *) essid) > 0)
&&(strcmp((const char * ) essid, (const char * )wifi_ap_cfg.ssid) == 0)) {
#endif
#ifdef CONFIG_DONT_CARE_TP
pnetiff->flags |= NETIF_FLAG_IPSWITCH;
#endif
if(wifi_ap_dhcp.mode) {
#if defined(DEF_AP_DHCP_START) && defined(DEF_AP_DHCP_STOP)
dhcps_ip4addr_pool_start = DEF_AP_DHCP_START;
dhcps_ip4addr_pool_end = DEF_AP_DHCP_STOP;
#endif
dhcps_init(&xnetif[WLAN_AP_NETIF_NUM]);
};
info_printf("AP '%s' started after %d ms\n",
wifi_ap_cfg.ssid, xTaskGetTickCount());
show_wifi_ap_ip();
if(wifi_cfg.save_flg & (BID_WIFI_AP_CFG | BID_AP_DHCP_CFG))
write_wifi_cfg(wifi_cfg.save_flg & (BID_WIFI_AP_CFG | BID_AP_DHCP_CFG));
ret = RTW_SUCCESS;
#if CONFIG_WLAN_CONNECT_CB
// extern void connect_start(void);
connect_start();
#endif
break;
}
if (timeout == 0) {
error_printf("Start AP timeout!\n");
ret = RTW_TIMEOUT;
break;
}
vTaskDelay(wifi_test_timeout_step_ms / portTICK_RATE_MS);
timeout--;
}
}
}
return ret;
}
static rtw_result_t StartStDHCPClient(void)
{
debug_printf("Start DHCPClient...\n");
int ret = RTW_SUCCESS;
struct netif * pnetif = &xnetif[WLAN_ST_NETIF_NUM];
DHCP_CONFIG *p = (DHCP_CONFIG *)&wifi_st_dhcp;
unsigned char mode = p->mode;
if(mode == 2 && p->ip != IP4ADDR(255,255,255,255) && p->ip != IP4ADDR(0,0,0,0)) { // fixed ip
netif_set_addr(pnetif, (ip_addr_t *)&p->ip, (ip_addr_t *)&p->mask, (ip_addr_t *)&p->gw);
}
else if(mode) { // DHCP On
UBaseType_t savePriority = uxTaskPriorityGet(NULL);
/* If not rise priority, LwIP DHCP may timeout */
vTaskPrioritySet(NULL, tskIDLE_PRIORITY + 3);
/* Start DHCP Client */
ret = LwIP_DHCP(WLAN_ST_NETIF_NUM, DHCP_START);
vTaskPrioritySet(NULL, savePriority);
if (ret == DHCP_ADDRESS_ASSIGNED) {
p->ip = pnetif->ip_addr.addr;
p->gw = pnetif->gw.addr;
p->mask = pnetif->netmask.addr;
if(mode > 2) { // 3+ Auto fix
p->mode = 2; // fixed ip
write_wifi_cfg(BID_ST_DHCP_CFG);
}
ret = RTW_SUCCESS;
}
else {
debug_printf("LwIP_DHCP ret=%d\n", ret);
ret = RTW_ERROR;
}
}
if(ret == RTW_SUCCESS) {
show_wifi_st_ip();
wifi_st_status = WIFI_STA_CONNECTED;
#if CONFIG_WLAN_CONNECT_CB
// extern void connect_start(void);
connect_start();
#endif
}
return ret;
}
static void wifi_autoreconnect_thread_(void *param) {
int ret = RTW_ERROR;
struct wifi_autoreconnect_param *reconnect_param =
(struct wifi_autoreconnect_param *) param;
printf("auto reconnect ...\n");
wifi_st_status = WIFI_STA_RECONNECT;
ret = wifi_connect(
wifi_st_cfg.bssid,
wifi_st_cfg.flg,
#if PARM_RECONNECT
wifi_st_cfg.ssid,
reconnect_param->security_type,
wifi_st_cfg.password,
#else
reconnect_param->ssid,
reconnect_param->security_type,
reconnect_param->password,
#endif
reconnect_param->key_id,
NULL);
if (ret == RTW_SUCCESS) {
if(wifi_cfg.save_flg & BID_WIFI_ST_CFG)
write_wifi_cfg(BID_WIFI_ST_CFG);
// Start DHCPClient
StartStDHCPClient();
}
vTaskDelete(NULL);
}
static void wifi_autoreconnect_hdl_(rtw_security_t security_type, char *ssid,
int ssid_len, char *password, int password_len, int key_id) {
wifi_autoreconnect.security_type = security_type;
wifi_autoreconnect.key_id = key_id;
#if PARM_RECONNECT==0
wifi_autoreconnect.ssid = ssid;
wifi_autoreconnect.password = password;
#endif
_adapter * ad = *(_adapter **)((rltk_wlan_info[0].dev)->priv);
if(ad->mlmeextpriv.reconnect_cnt == 255) {
ad->mlmeextpriv.reconnect_cnt = 0;
};
xTaskCreate(wifi_autoreconnect_thread_, (const char * )"st_recon", 400,
&wifi_autoreconnect, tskIDLE_PRIORITY + 1, NULL);
}
static void st_set_autoreconnect(uint8 mode, uint8 count, uint16 timeout) {
p_wlan_autoreconnect_hdl = wifi_autoreconnect_hdl_;
_adapter * ad = *(_adapter **)((rltk_wlan_info[0].dev)->priv);
ad->mlmeextpriv.reconnect_times = count;
ad->mlmeextpriv.reconnect_timeout = timeout;
ad->mlmeextpriv.reconnect_cnt = 0;
ad->mlmeextpriv.auto_reconnect = (mode != 0);
}
static rtw_result_t wifi_run_st(void) {
rtw_result_t ret = RTW_SUCCESS;
// chk_ap_netif_num();
if((wifi_mode == RTW_MODE_STA) || (wifi_mode == RTW_MODE_STA_AP)) {
#if CONFIG_AUTO_RECONNECT
// p_wlan_autoreconnect_hdl = NULL;
if (wifi_st_cfg.autoreconnect) {
st_set_autoreconnect(1, wifi_st_cfg.autoreconnect, wifi_st_cfg.reconnect_pause);
ret = wext_set_autoreconnect(WLAN0_NAME, 1, wifi_st_cfg.autoreconnect, wifi_st_cfg.reconnect_pause);
if (ret != RTW_SUCCESS)
warning_printf("ERROR: Operation failed! Error=%d\n", ret);
}
#endif
info_printf("Connected to AP (%s, netif%d)...\n", wlan_st_name, wlan_st_netifn);
ret = wifi_connect(
wifi_st_cfg.bssid,
wifi_st_cfg.flg,
wifi_st_cfg.ssid,
idx_to_rtw_security(wifi_st_cfg.security),
wifi_st_cfg.password,
-1,
NULL);
wifi_st_status = WIFI_STA_START;
// wifi_run_mode |= RTW_MODE_STA;
if (ret != RTW_SUCCESS) {
error_printf("%s: Operation failed! Error(%d)\n", __func__, ret);
} else {
if(wifi_cfg.save_flg & BID_WIFI_ST_CFG)
write_wifi_cfg(BID_WIFI_ST_CFG);
// Start DHCPClient
StartStDHCPClient();
}
};
return ret;
}
static int _wifi_on(rtw_mode_t mode) {
int ret = 0;
/*
if (!((rltk_wlan_running(WLAN0_IDX) == 0) && (rltk_wlan_running(WLAN1_IDX) == 0))) {
warning_printf("WIFI is already running\n");
return 0;
}
*/
info_printf("Initializing WIFI...\n");
uint8 devnum = (mode == RTW_MODE_STA_AP); // flag = 1 -> 2 netif
wifi_mode = mode;
chk_ap_netif_num();
// set wifi mib
// extern uint8_t rtw_adaptivity_en;
// rtw_adaptivity_en = 0;
// wext_set_adaptivity(RTW_ADAPTIVITY_DISABLE); // rtw_adaptivity_mode_t
wext_set_adaptivity(wifi_cfg.adaptivity & 3);
debug_printf("Wlan0 init...\n");
ret = rltk_wlan_init(WLAN0_IDX, mode); // rtw_mode_t
debug_printf("netif_set_up 0...\n");
netif_set_up(&xnetif[0]);
if (ret < 0) return ret;
if(devnum) {
debug_printf("Wlan1 init...\n");
ret = rltk_wlan_init(WLAN1_IDX, mode);
if (ret < 0) return ret;
netif_set_up(&xnetif[1]);
}
else {
netif_set_down(&xnetif[1]);
}
debug_printf("Wlan start...\n");
uint32 timeout = xTaskGetTickCount();
rltk_wlan_start(WLAN0_IDX);
if(devnum) rltk_wlan_start(WLAN1_IDX);
while (1) {
if (rltk_wlan_running(WLAN0_IDX)
&& rltk_wlan_running(devnum) ) {
//#if CONFIG_DEBUG_LOG > 2
debug_printf("WIFI initialized (%d ms)\n", xTaskGetTickCount() - timeout);
//#endif
break;
}
if(xTaskGetTickCount() - timeout > wifi_test_timeout_ms/portTICK_RATE_MS) {
error_printf("WIFI init timeout!\n");
break;
}
vTaskDelay(wifi_test_timeout_step_ms / portTICK_RATE_MS);
}
return ret;
}
extern int lwip_init_done;
static void _LwIP_Init(void)
{
if(!lwip_init_done) {
int idx;
debug_printf("LwIP Init (%d)\n", wifi_mode);
/* Create tcp_ip stack thread */
tcpip_init( NULL, NULL );
// chk_ap_netif_num(); // Исполняется после _wifi_on()
for(idx = 0; idx < NET_IF_NUM; idx++) {
xnetif[idx].name[0] = 'r';
xnetif[idx].name[1] = '0' + idx;
}
netif_add(&xnetif[WLAN_ST_NETIF_NUM], (ip_addr_t *)&wifi_st_dhcp.ip, (ip_addr_t *)&wifi_st_dhcp.mask, (ip_addr_t *)&wifi_st_dhcp.gw, NULL, &ethernetif_init, &tcpip_input);
netif_add(&xnetif[WLAN_AP_NETIF_NUM], (ip_addr_t *)&wifi_ap_dhcp.ip, (ip_addr_t *)&wifi_ap_dhcp.mask, (ip_addr_t *)&wifi_ap_dhcp.gw, NULL, &ethernetif_init, &tcpip_input);
#if CONFIG_ETHERNET // && NET_IF_NUM > 2
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
ipaddr.addr = DEF_EH_IP;
netmask.addr = DEF_EH_MSK;
gw.addr = DEF_EH_GW;
netif_add(&xnetif[2], &ipaddr, &netmask, &gw, NULL, &ethernetif_mii_init, &tcpip_input);
}
#endif
/* Registers the default network interface. */
netif_set_default(&xnetif[0]);
/* When the netif is fully configured this function must be called.*/
for(idx = 0; idx < NET_IF_NUM; idx++) {
netif_set_up(&xnetif[idx]);
}
info_printf("interface %d is initialized\n", idx);
lwip_init_done = 1;
init_event_callback_list();
}
}
extern int rltk_set_tx_power_percentage(rtw_tx_pwr_percentage_t power_percentage_idx);
int wifi_run(rtw_mode_t mode) {
int ret = 0;
#if CONFIG_DEBUG_LOG > 4
debug_printf("\n%s(%d), %d\n", __func__, mode, wifi_run_mode);
debug_printf("old mode = %d, new mode = %d\n", wifi_run_mode, mode);
#endif
if(wifi_mode) { // != mode) {
info_printf("Deinitializing WIFI ...\n");
wifi_off();
wifi_st_status = WIFI_STA_OFF;
// wifi_run_mode = RTW_MODE_NONE;
vTaskDelay(30);
}
if (mode != RTW_MODE_NONE) {
if (_wifi_on(mode) < 0) {
error_printf("Wifi On failed!\n");
goto error_end;
};
/*
if(wifi_cfg.adaptivity)
wext_set_adaptivity(wifi_cfg.adaptivity & 3);
*/
if(wifi_set_country(wifi_cfg.country_code) != RTW_SUCCESS) {
error_printf("WiFi: Error set tx country_code (%d)!", wifi_cfg.country_code);
};
if(rtw_power_percentage_idx != wifi_cfg.tx_pwr) {
if(rltk_set_tx_power_percentage(wifi_cfg.tx_pwr) != RTW_SUCCESS) {
error_printf("WiFi: Error set tx power (%d)!", wifi_cfg.tx_pwr);
};
}
if(wifi_set_network_mode(wifi_cfg.bgn) != RTW_SUCCESS) {
error_printf("WiFi: Error set network mode (%d)!", wifi_cfg.bgn);
}
debug_printf("mode=%d, wifi_mode=%d, old_mоde=%d\n", mode, wifi_mode, wifi_run_mode);
if(mode <= RTW_MODE_STA_AP) {
struct netif * pnif = &xnetif[WLAN_ST_NETIF_NUM];
#if LWIP_NETIF_HOSTNAME
// @todo ethernetif_init()...
pnif->hostname = lwip_host_name[0];
#ifdef USE_NETBIOS
netbios_set_name(WLAN_ST_NETIF_NUM, lwip_host_name[0]);
#endif
#endif
netif_set_addr(&xnetif[WLAN_ST_NETIF_NUM], (ip_addr_t *) &wifi_st_dhcp.ip,
(ip_addr_t *) &wifi_st_dhcp.mask, (ip_addr_t *) &wifi_st_dhcp.gw);
pnif = &xnetif[WLAN_AP_NETIF_NUM];
#if LWIP_NETIF_HOSTNAME
// @todo ethernetif_init()...
pnif->hostname = lwip_host_name[1];
#ifdef USE_NETBIOS
netbios_set_name(WLAN_AP_NETIF_NUM, lwip_host_name[1]);
#endif
#endif
netif_set_addr(&xnetif[WLAN_AP_NETIF_NUM], (ip_addr_t *) &wifi_ap_dhcp.ip,
(ip_addr_t *) &wifi_ap_dhcp.mask, (ip_addr_t *) &wifi_ap_dhcp.gw);
}
switch(mode) {
case RTW_MODE_STA_AP:
ret = wifi_run_ap() | wifi_run_st();
// _wext_enable_powersave(0, 0, 0);
break;
case RTW_MODE_STA:
ret = wifi_run_st();
if(_wext_set_lps_dtim(0, wifi_st_cfg.dtim)!= RTW_SUCCESS) {
error_printf("WiFi: Error set DTIM(%d)!", wifi_st_cfg.dtim);
};
if(_wext_enable_powersave(0, wifi_st_cfg.sleep & 1, (wifi_st_cfg.sleep >> 1) & 1) != RTW_SUCCESS) {
// rtw_pm_set_ips(get_padaptern(0), wifi_st_cfg.sleep & 1 );
// rtw_pm_set_lps(get_padaptern(0), (wifi_st_cfg.sleep >> 1) & 1 );
error_printf("WiFi: Error set powersave mode!");
};
break;
case RTW_MODE_AP:
ret = wifi_run_ap();
// _wext_enable_powersave(WLAN0_NAME, 0, 0);
break;
#if 0// CONFIG_ENABLE_??
case RTW_MODE_PROMISC:
// @todo
break;
#endif
#if CONFIG_ENABLE_P2P
case RTW_MODE_P2P:
// @todo
break;
#endif
default:
ret = 1;
error_printf("WiFi: Error mode(%d)\n", wifi_mode);
};
wifi_run_mode = mode;
if(ret == 0 && (wifi_cfg.save_flg & BID_WIFI_CFG)) {
wifi_cfg.mode = mode;
write_wifi_cfg(BID_WIFI_CFG);
};
} else {
ret = 0;
error_end:
#if CONFIG_WLAN_CONNECT_CB
connect_close();
#endif
if(wifi_run_mode) {
wifi_disconnect();
};
wifi_off();
wifi_st_status = WIFI_STA_OFF;
wifi_run_mode = RTW_MODE_NONE;
chk_ap_netif_num();
};
return ret;
}
/* Load cfg, init WiFi + LwIP init, WiFi start if wifi_cfg.mode != RTW_MODE_NONE */
void wifi_init(void) {
debug_printf("\nLoad Config\n");
read_wifi_cfg(wifi_cfg.load_flg); // DEF_LOAD_CFG
// Call back from wlan driver after wlan init done
// p_wlan_init_done_callback = wlan_init_done_callback;
// Call back from application layer after wifi_connection success
// p_write_reconnect_ptr = wlan_write_reconnect_data_to_flash;
p_wlan_autoreconnect_hdl = NULL;
_LwIP_Init();
#if CONFIG_WIFI_IND_USE_THREAD
wifi_manager_init();
#endif
// wifi_cfg.mode = RTW_MODE_PROMISC; //RTW_MODE_P2P;
wifi_run(wifi_cfg.mode);
}
unsigned char *tab_txt_rtw_secyrity[] = {
"OPEN", //0 Open security
"WEP", //1 WEP Security with open authentication
"WEP SHARED", //2 WEP Security with shared authentication
"WPA TKIP", //3 WPA Security with TKIP
"WPA AES", //4 WPA Security with AES
"WPA2 TKIP", //5 WPA2 Security with TKIP
"WPA2 AES", //6 WPA2 Security with AES
"WPA2 Mixed", //7 WPA2 Security with AES & TKIP
"WPA/WPA2 AES", //8 WPA/WPA2 Security
"Unknown" //9
};
unsigned int tab_code_rtw_secyrity[] = {
RTW_SECURITY_OPEN, //0 Open security
RTW_SECURITY_WEP_PSK, //1 WEP Security with open authentication
RTW_SECURITY_WEP_SHARED, //2 WEP Security with shared authentication
RTW_SECURITY_WPA_TKIP_PSK, //3 WPA Security with TKIP
RTW_SECURITY_WPA_AES_PSK, //4 WPA Security with AES
RTW_SECURITY_WPA2_TKIP_PSK, //5 WPA2 Security with TKIP
RTW_SECURITY_WPA2_AES_PSK, //6 WPA2 Security with AES
RTW_SECURITY_WPA2_MIXED_PSK, //7 WPA2 Security with AES & TKIP
RTW_SECURITY_WPA_WPA2_MIXED, //8 WPA/WPA2 Security
RTW_SECURITY_UNKNOWN //9
};
/*
unsigned char *tab_txt_rtw_eccryption[] = {
"Unknown",
"OPEN",
"WEP40",
"WPA_TKIP",
"WPA_AES",
"WPA2_TKIP",
"WPA2_AES",
"WPA2_MIXED",
"???",
"WEP104",
"Udef" // 0xff
};
*/
rtw_security_t idx_to_rtw_security(unsigned char idx)
{
if(idx > IDX_SECURITY_UNKNOWN - 1) idx = IDX_SECURITY_WPA2_AES_PSK;
return (rtw_security_t)tab_code_rtw_secyrity[idx];
}
unsigned char rtw_security_to_idx(rtw_security_t rtw_sec_type)
{
unsigned char i = 0;
while(rtw_sec_type != tab_code_rtw_secyrity[i] && tab_code_rtw_secyrity[i] != RTW_SECURITY_UNKNOWN) i++;
return i;
}
unsigned char * idx_security_to_str(unsigned char idx)
{
if(idx > IDX_SECURITY_UNKNOWN) idx = IDX_SECURITY_UNKNOWN;
return tab_txt_rtw_secyrity[idx];
}
unsigned char * rtw_security_to_str(rtw_security_t rtw_sec_type)
{
return tab_txt_rtw_secyrity[rtw_security_to_idx(rtw_sec_type)];
}
void show_wifi_ap_ip(void) {
printf("SoftAP ip: " IPSTR "\n", IP2STR(&xnetif[WLAN_AP_NETIF_NUM].ip_addr));
}
void show_wifi_st_ip(void) {
printf("Station ip: " IPSTR "\n", IP2STR(&xnetif[WLAN_ST_NETIF_NUM].ip_addr));
}
void show_wifi_MAC(void) {
printf("MAC: " IPSTR "\n", IP2STR(&xnetif[WLAN_ST_NETIF_NUM].ip_addr));
}
void show_wifi_st_cfg(void) {
printf("\tSSID: '%s'\n", wifi_st_cfg.ssid);
printf("\tPassword: '%s'\n", wifi_st_cfg.password);
printf("\tSecurity type: %s\n", idx_security_to_str(wifi_st_cfg.security));
printf("\tAuto-reconnect: %d\n", wifi_st_cfg.autoreconnect);
printf("\tReconnect pause: %d\n", wifi_st_cfg.reconnect_pause);
printf("\tSleep mode: %p\n", wifi_st_cfg.sleep);
printf("\tDTIM: %d\n", wifi_st_cfg.dtim);
}
void show_wifi_ap_cfg(void) {
printf("\tSSID: '%s'\n", wifi_ap_cfg.ssid);
printf("\tSSID hidden: %d\n", wifi_ap_cfg.ssid_hidden);
printf("\tPassword: '%s'\n", wifi_ap_cfg.password);
printf("\tSecurity type: %s\n", (wifi_ap_cfg.security)? tab_txt_rtw_secyrity[IDX_SECURITY_WPA2_AES_PSK] : tab_txt_rtw_secyrity[IDX_SECURITY_OPEN]);
printf("\tChannel: %d\n", wifi_ap_cfg.channel);
printf("\tBeacon interval: %d ms\n", wifi_ap_cfg.beacon_interval);
printf("\tMax connections: %d\n", wifi_ap_cfg.max_sta);
}
void show_wifi_cfg(void) {
printf("\tStart mode: %p\n", wifi_cfg.mode);
printf("\tCountry code: %d\n", wifi_cfg.country_code);
printf("\tNetwork mode: %d\n", wifi_cfg.bgn);
printf("\tTx power: %d\n", wifi_cfg.tx_pwr);
printf("\tAdaptivity: %d\n", wifi_cfg.adaptivity);
printf("\tLoad flags: %p\n", wifi_cfg.load_flg);
printf("\tSave flags: %p\n", wifi_cfg.save_flg);
}
int show_wifi_ap_clients(void) {
if((wifi_mode == RTW_MODE_AP) || (wifi_mode == RTW_MODE_STA_AP)) {
struct {
int count;
rtw_mac_t mac_list[AP_STA_NUM];
} client_info;
client_info.count = AP_STA_NUM;
if(wext_get_associated_client_list(wlan_ap_name, &client_info, sizeof(client_info)) >= 0) {
if(client_info.count) {
printf("\tAP %u clients:\n", client_info.count);
int client_idx = 0;
while(client_idx++ < client_info.count) {
unsigned char *pmac = client_info.mac_list[client_idx].octet;
printf("\tsta[%u]: %02x:%02x:%02x:%02x:%02x:%02x\n", client_idx,
pmac[0],pmac[1],pmac[2],pmac[3],pmac[4],pmac[5]);
}
} else {
printf("\tAP clients none\n");
}
return client_info.count;
};
};
printf("Get AP clients error!\n");
return -1;
}
extern int max_skbbuf_used_num, skbbuf_used_num, max_skbdata_used_num, skbdata_used_num, max_timer_used_num;
void show_wlan_info(int idx)
{
if(rltk_wlan_info[idx].enable) {
struct net_device_stats * stats = rltk_wlan_info[idx].dev->get_stats(rltk_wlan_info[idx].dev);
if(stats) {
printf("\tTotal %d packets received (%d bytes), dropped %d\n", stats->rx_packets, stats->rx_bytes, stats->rx_dropped);
printf("\tTotal %d packets transmitted (%d bytes), dropped %d\n", stats->tx_packets, stats->tx_bytes, stats->tx_dropped);
printf("\tRX fifo overflow count %d\n", stats->rx_overflow);
printf("\tMax skb %d bufers used, buffers %d\n", max_skbbuf_used_num, skbbuf_used_num);
printf("\tMax skb %d data used, data %d\n", max_skbdata_used_num, skbdata_used_num);
printf("\tMax %d timers used\n", max_timer_used_num);
// printf("\tMax %d timers used, timers %d\n", max_timer_used_num, timer_used_num);
}
}
}