zouhaitao/TAIXIN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e76462eeb7733d4fca46c92e4b9c1b5d99fc049a
TAIXIN/sdk/include/lib/umac/libwnb.h

872 lines
29 KiB
C
Raw Blame History

#ifndef _HGSDK_WNB_H_
#define _HGSDK_WNB_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "sys_config.h"
#include "lib/common/rbuffer.h"
#include "lib/lmac/hgic.h"
#include "lib/skb/skb_list.h"
#define WNB_SSID_LEN (32)
#define ETH_P_NETAT (0x4848)
#define ETH_P_ATDATA (0x4849)
#define ETH_P_RAWDATA (0x4850)
#define ETH_P_M2UCAST (0x4852)
#define ETH_P_WNBROAM (0x4853)
/* WNB protocol defines */
#define IEEE80211_STYPE_WNB 0x00E0
#define WNB_STYPE_ASSOC 0x01
#define WNB_STYPE_PAIR 0x02
#define WNB_STYPE_DISASSOC 0x03
#define WNB_STYPE_CUSTOMER 0x04
#define WNB_STYPE_CONFIG 0x05
#define WNB_STYPE_OTA 0x06
#define WNB_STYPE_STA_HEARTHBEAT 0x07
#define WNB_STYPE_ROAMING 0x08
#define WNB_STYPE_PROBE_REQUEST 0x09
#define WNB_STYPE_PROBE_RESPONSE 0x0A
#define WNB_STYPE_USER_HEARTBEAT 0x0B
#define WNB_STYPE_USER_HEARTBEAT_RESP 0x0C
#define WNB_STYPE_USER_WAKEUP_DATA 0x0D
#define WNB_STYPE_USER_HEARTBEAT_LOST 0x0E
#define WNB_STYPE_BATTERY_SOC 0x0F
#define WNB_STYPE_MGTM_CONFIG 0x11
#define WNB_FOR_ME(h,wnb) (os_memcmp((h)->addr1, (wnb)->cfg->addr, 6)==0)
#define RSSI_CHANGED(r1,r2) ((r1)>(r2)?((r1)-(r2)>8):((r2)-(r1)>8))
#define EVM_CHANGED(r1,r2) ((r1)>(r2)?((r1)-(r2)>3):((r2)-(r1)>3))
//#define WNB_IS_BCAST_ADDR(a) (((a)[0]&(a)[1]&(a)[2]&(a)[3]&(a)[4]&(a)[5]) == 0xff)
//#define WNB_IS_MCAST_ADDR(a) ((a)[0]&0x01)
//#define WNB_IS_ZERO_ADDR(a) (!((a)[0] | (a)[1] | (a)[2] | (a)[3] | (a)[4] | (a)[5]))
#define WNB_PROTO(fc) (ieee80211_is_mgmt(fc) && ((fc) & 0x00f0) == IEEE80211_STYPE_WNB)
//#define MAC_EQU(a1,a2) (os_memcmp((a1), (a2), 6)==0)
#define WNB_TIM_SET(wnb, aid) ((wnb)->ps_data.tim[(aid) / 8] |= (1 << ((aid) % 8)))
#define WNB_TIM_CLR(wnb, aid) ((wnb)->ps_data.tim[(aid) / 8] &= ~(1 << ((aid) % 8)))
#define FROM_AP(wnb, hdr) (MAC_EQU((wnb)->stas[0].sta->addr, (hdr)->addr2))
#define IS_MYAP(wnb, sta) (((wnb)->cfg->role == WNB_STA_ROLE_SLAVE||(wnb)->cfg->role == WNB_STA_ROLE_REPEATER) && (sta) == &(wnb)->stas[0])
#define MY_SSID(wnb) (((wnb)->cfg->role == WNB_STA_ROLE_REPEATER)?(wnb)->cfg->r_ssid:(wnb)->cfg->ssid)
#define MY_KEY(wnb) (((wnb)->cfg->role == WNB_STA_ROLE_REPEATER)?(wnb)->cfg->r_key:(wnb)->cfg->key)
#define MY_ENC(wnb) (((wnb)->cfg->role == WNB_STA_ROLE_REPEATER)?(wnb)->cfg->r_encrypt:(wnb)->cfg->encrypt)
#define IS_UPPER_AP(wnb, sta) (((wnb)->cfg->role == WNB_STA_ROLE_REPEATER) && (sta) == &(wnb)->stas[0])
#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
#define BITS_PER_BYTE (8)
#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
#define WNB_NETLOG_PORT (64320)
enum wnb_frm_type {
WNB_FRM_TYPE_ETHER = 0,
WNB_FRM_TYPE_HGIC,
WNB_FRM_TYPE_RAW,
};
struct wnb_txq_param {
uint8 aifsn : 4,
acm : 1,
aci : 2,
reserved : 1;
uint8 ecwmin : 4,
ecwmax : 4;
uint16 txop_limit;
};
struct wnb_mgmt {
uint8 type: 7, resp: 1;
uint8 cookie;
uint16 center_freq; // current center frequence
};
struct wnb_mgmt_heartbeat {
struct wnb_mgmt hdr;
uint8 aid;
};
struct wnb_mgmt_pair {
struct wnb_mgmt hdr;
uint8 role;
uint8 encrypt;
uint8 key[32];
uint8 dev_id[6];
uint8 ssid[WNB_SSID_LEN];
uint8 aid;
};
struct wnb_mgmt_assoc {
struct wnb_mgmt hdr;
uint8 aid;
uint8 dev_id[6];
uint8 auth[WNB_SSID_LEN];
uint8 ps_mode: 3, roaming:1, newkey:1, p2: 3;
uint8 ssid_set:1, rev:7;
uint8 roam_bssid[6];
uint8 ssid[WNB_SSID_LEN];
};
struct wnb_mgmt_assoc_resp {
struct wnb_mgmt hdr;
uint8 aid;
uint8 dev_id[6];
uint8 assoc_status;
uint16 bss_max_idle;
uint8 wk_reason;
uint8 repeater:1, newkey:1, rev:6;
uint8 p1, p2, p3, p4;
uint8 key[32];
uint16 repeater_level;
};
struct wnb_mgmt_config {
struct wnb_mgmt hdr;
uint16 type, len;
};
enum wnb_mgmt_configtype{
WNB_MGMT_CONFIGTYPE_FREQINFO = 1,
WNB_MGMT_CONFIGTYPE_RESET,
WNB_MGMT_CONFIGTYPE_PSALIVE_CONFIG,
};
struct wnb_mgmt_probe_req {
struct wnb_mgmt hdr;
uint8 ssid[WNB_SSID_LEN];
};
struct wnb_mgmt_probe_resp {
struct wnb_mgmt hdr;
uint8 ssid[WNB_SSID_LEN];
uint8 encrypt: 1;
uint16 repeter;
};
struct wnb_mgmt_disassoc {
struct wnb_mgmt hdr;
uint16 flags;
};
struct wnb_mgmt_roaming {
struct wnb_mgmt hdr;
uint8 request:1, pad:7;
};
struct wnb_bss_info {
struct list_head list;
uint8 ssid[WNB_SSID_LEN + 2];
uint8 bssid[6];
uint8 encrypt: 1, assoc: 1;
int8 signal;
uint16 freq, repeater;
uint32 lifetime;
};
#define WNB_DISASSOC_FLAGS_UNPAIR BIT(0)
/////////////////////////////////////////////////////////////////
/* WNB module defines */
#define WNB_EVTQ_SIZE (32)
#define WNB_NAT_COUNT (256)
#define WNB_CHAN_COUNT (16)
#define WNB_PAIR_DELAY (50)
#define WNB_PAIR_TRY (4)
#define WNB_CONN_DELAY (20)
#define WNB_HEART_INT (500)
#define WNB_CON_CHAN_TRY (2)
#define WNB_SCAN_DELAY (20)
#define WNB_SCAN_TRY (2)
#define WNB_BSS_MAX (32)
#define WNB_PS_BC_SIZE (4)
#define WNB_PS_DATA_SIZE (2)
#define WNB_MAX_IDLE_TU (30*1000) // units: 1.024ms
#define wnb_dbg(fmt, ...) //os_printf(fmt, ##__VA_ARGS__)
#define wnb_err(fmt, ...) os_printf(fmt, ##__VA_ARGS__)
typedef enum{
WNB_FORWARD_TYPE_NONE,
WNB_FORWARD_TYPE_2LOCAL,
WNB_FORWARD_TYPE_2UPPER,
}wnb_forward_type;
typedef enum {
WNB_EVENT_SEND_BEACON = 1,
WNB_EVENT_HEARTBEAT,
WNB_EVENT_PAIR_START,
WNB_EVENT_PAIR_SUCCESS,
WNB_EVENT_PAIR_FAIL,
WNB_EVENT_PAIR_DONE,
WNB_EVENT_CONNECT_START,
WNB_EVENT_CONNECTED,
WNB_EVENT_DISCONNECTED,
WNB_EVENT_RX_DATA,
WNB_EVENT_RSSI,
WNB_EVENT_SCAN_START,
WNB_EVENT_SCAN_DONE,
WNB_EVENT_EVM,
WNB_EVENT_DHCPC_REQ,
WNB_EVENT_DHCPC_DONE,
WNB_EVENT_CONNECT_FAIL,
} wnb_event;
typedef enum {
WNB_STATE_IDLE,
WNB_STATE_PAIR_START,
WNB_STATE_PAIRING,
WNB_STATE_PAIR_DONE,
WNB_STATE_CONNECT_START,
WNB_STATE_CONNECTING,
WNB_STATE_CONNECTED,
WNB_STATE_DISCONNECT,
WNB_STATE_SCAN_START,
WNB_STATE_SCANNING,
WNB_STATE_SCAN_DONE,
WNB_STATE_WAITING_AP,
} wnb_state;
typedef enum {
WNB_STA_ROLE_SLAVE,
WNB_STA_ROLE_MASTER,
WNB_STA_ROLE_GPMEMB,
WNB_STA_ROLE_REPEATER,
WNB_STA_ROLE_MAX,
} wnb_sta_role;
typedef enum {
WNB_ASSOC_SUCCESS = 0,
WNB_ASSOC_REFUSED = 1,
WNB_ASSOC_DENIED_NO_MORE_STAS = 17,
WNB_ASSOC_DENIED_INSUFFICIENT_BANDWIDTH = 33,
WNB_ASSOC_REFUSED_AP_OUT_OF_MEMORY = 93,
WNB_ASSOC_NO_AP = 0xff,
} wnb_assoc_status;
typedef void (*wnb_event_cb)(wnb_event evt, uint32 param1, uint32 param2);
/*saved into flash*/
struct wnb_sta_info {
uint16 paired : 1,
encrypt : 1;
uint8 addr[6];
uint8 key[32];
};
struct wnb_psalive_config{
uint16 wkdata_off;
uint16 wkdata_save:1;
uint8 wkdata_mask[16];
};
struct wnb_sta_psalive {
uint32 ipaddr;
uint16 port;
uint8 hb_period, hb_timeout;
uint8 *heartbeat;
uint8 *heartbeat_resp;
uint8 *wakeup_data;
int16 expired;
uint16 heartbeat_len, heartbeat_resp_len, wakeup_data_len;
uint8 heartbeat_lost, rev;
struct wnb_psalive_config config;
};
/*needn't save*/
struct wnb_sta {
void *wnb;
struct wnb_sta_info *sta;
uint8 id, aid;
uint16 connected : 1,
ps : 1,
ps_poll : 1,
ps_mode : 3,
m2ucast : 1,
roam_out : 2,
roam_in : 1,
rnd_key : 1;
uint32 last_rx;
uint32 last_tx;
uint32 roam_jiff;
int8 rssi, evm, wk_reason, rev;
uint32 ipaddr;
uint16 rxseq_head[4];
uint64 rxseq_bit[4];
uint16 tx_seqno[4];
struct skb_list psdata;
struct skb_list ps_etherdata;
struct wnb_sta_psalive psalive;
uint8 roaming_bssid[6];
uint8 roaming_notify;
uint8 key[32];
};
struct wnb_route_entry {
struct list_head list;
struct wnb_sta *sta;
uint32 lifetime;
uint8 addr[6];
};
struct wnb_route_table {
os_mutex_t lock;
struct list_head list[16];
uint32 count;
};
#define WNB_WKUPHOST_REASONS (32)
struct wnb_config {
uint8 role;
uint8 bss_bw;
uint8 encrypt: 1, forward: 1, key_set: 1, mkey_set: 1, join_group: 1, bssid_set: 1, mcast_filter: 1, reassoc_wkhost: 1;
uint8 chan_cnt;
uint16 freq_start, freq_end;
uint16 chan_list[WNB_CHAN_COUNT];
uint8 ssid[WNB_SSID_LEN];
uint8 key[32];
uint8 addr[6];
uint8 max_sta;
uint8 tx_mcs;
uint8 acs_enable;
uint8 acs_tmo;
uint8 tx_bw;
uint8 tx_power: 5, pri_chan: 3;
uint8 mcast_key[32];
uint8 psconnect_period, psconnect_roundup;
uint8 last_chan, repeater_level;
uint16 wkio_mode: 1, psmode: 3, auto_chsw: 1, auto_role: 1, roaming: 1,
dupfilter: 1, pa_pwrctrl_dis: 1, pair_autostop: 1, supper_pwr_dis: 1,
r_encrypt: 1, not_auto_save: 1, dcdc13: 1, auto_pair:1, dhcpc_en:1;
uint16 bss_max_idle;
uint16 beacon_int, dtim_period;
uint8 group_aid, agg_cnt, wkup_io, wkio_edge;
uint16 aplost_time, auto_sleep_time;
uint16 heartbeat_int, ack_tmo;
int8 roam_rssi_th;
uint8 roam_int, max_txcnt, rev4;
uint8 r_ssid[WNB_SSID_LEN];
uint8 r_key[32];
uint8 dhcpc_hostname[32];
uint8 mcast_txmcs, mcast_txbw, mcast_clearch, mcast_dupcnt;
uint32 dhcpc_update_hbdata:1, wkhost_reasons_set:1, dual_ant:1,ant_auto_dis:1,
ant_sel:1, mac_filter_en:1, roaming_samefreq:1, ap_hide:1, ap_psmode:1,
dis_1v1_m2u:1, psconnect_dis:1, kick_assoc:1;
uint8 wkhost_reasons[WNB_WKUPHOST_REASONS];
//################################################################
uint8 reserve[256]; /*must reduce this array after add new fields */
struct wnb_sta_info stas[WNB_STA_COUNT]; /*keep at bottom*/
};
struct wnb_statistic {
uint32 tot_tx, tot_rx, tot_fw, if_recv, if_write, rx_hook, tx_hook;
uint32 tx_err, rx_err, if_err, fw_err, rx_drop, no_mem, tx_drop, filter;
};
struct wnb_rx_info {
struct wnb_sta *sta;
uint8 *data;
uint16 len;
uint16 fromDS: 1, resv: 15;
};
#define WNB_MAX_TIM_LEN (32)
struct wnb_ps_data {
/* yes, this looks ugly, but guarantees that we can later use bitmap_empty :)
* NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
uint8 tim[WNB_MAX_TIM_LEN];
struct skb_list bc_buf;
uint8 num_sta_ps; /* number of stations in PS mode */
int32 dtim_count;
uint8 dtim_bc_mc;
};
struct wnb_init_param {
uint8 if_type;
uint8 frm_type;
uint8 hook_cnt;
struct lmac_ops *ops;
struct wnb_config *cfg;
wnb_event_cb cb;
};
struct wnb_mgmt_tx {
uint8 *dest;
uint16 len;
uint16 flags;
struct wnb_mgmt *mgmt;
struct hgic_tx_info *txinfo;
};
struct wnb_udp_data{
uint8 *dest;
uint32 dest_ip, dest_port;
uint32 src_ip, src_port;
uint8 *data;
uint32 len;
};
struct wireless_nb;
typedef int32(*wnb_pkt_tx_hdl)(struct wireless_nb *wnb, struct sk_buff *skb);
typedef int32(*wnb_pkt_rx_hdl)(struct wireless_nb *wnb, struct wnb_rx_info *rxinfo);
struct wnb_pkt_hook {
const char *name;
uint16 protocol;
wnb_pkt_tx_hdl tx;
wnb_pkt_rx_hdl rx;
};
typedef enum{
WNB_ROAM_IDLE,
WNB_ROAM_CHECK_RSSI,
WNB_ROAM_REQUEST_BGSCAN,
WNB_ROAM_REQUEST_ROAMING,
WNB_ROAM_REQUEST_CANCLE,
WNB_ROAM_DO_BGSCAN,
WNB_ROAM_DO_ROAMING,
}WNB_ROAM_STATE;
/* WNB sub modules */
struct wnb_module_roam {
WNB_ROAM_STATE state;
uint8 request;
uint8 check;
int16 rssi;
int8 rssi_avg;
uint8 bssid[6];
uint8 ssid[32];
struct wnb_bss_info *newbss;
void (*check_roaming)(struct wireless_nb *wnb, struct hgic_rx_info *rxinfo, uint8 *data, int32 len);
void (*check_scan_result)(struct wireless_nb *wnb);
int32(*forward_data)(struct wireless_nb *wnb, struct wnb_sta *sta, struct sk_buff *skb);
int32(*cache_data)(struct wireless_nb *wnb, struct sk_buff *skb);
void(*roam_in)(struct wireless_nb *wnb, struct wnb_sta *sta, uint8 notify, uint8 *roam_bssid);
void(*proc_mgmt)(struct wireless_nb * wnb, uint8 * data, int32 len);
};
struct wnb_module_ota {
void (*proc_data)(struct wireless_nb *wnb);
};
enum WNB_PSALIVE_ACTION{
WNB_PSALIVE_ACTION_DO_HEARBEAT,
WNB_PSALIVE_ACTION_KEEP_HEARTBEAT,
WNB_PSALIVE_ACTION_SEND_CONFIG,
WNB_PSALIVE_ACTION_UPDATE_HBDATA,
};
struct wnb_module_psalive {
os_timer_t timer;
void (*do_action)(struct wireless_nb *wnb, int32 action);
void (*proc_mgmt)(struct wireless_nb *wnb, uint8 *data, int32 len);
void (*start_sta)(struct wireless_nb *wnb, struct wnb_sta *sta, uint8 start);
};
struct wnb_module_netlog {
uint8 addr[6], cookie[6];
uint32 ip;
uint32 time;
uint16 port;
};
struct wnb_module_netat {
uint8 dest[6];
};
struct wnb_module_dhcpc {
uint32 transID, leasetime;
uint8 svraddr[6], state;
os_timer_t timer;
struct {
uint32 ipaddr, netmask, svrip, router, dns1, dns2;
} result;
void (*reset)(struct wireless_nb *wnb);
void (*request_ip)(struct wireless_nb *wnb);
};
struct wnb_module_atcmd {
struct{
int32 count;
struct hgic_tx_info txinfo;
}txdata_arg;
};
struct wnb_module_drivercmd {
void (*proc_cmd)(struct wireless_nb *wnb);
void (*report_txwnd)(struct wireless_nb *wnb);
};
struct wnb_module_arp {
void (*send_reply)(struct wireless_nb *wnb);
};
struct wireless_nb {
wnb_state state;
struct wnb_config *cfg;
struct wnb_sta *stas;
os_mutex_t lock;
os_semaphore_t sema;
os_semaphore_t sm_sema;
os_semaphore_t cfgsema;
os_task_t task;
os_task_t sm_task;
os_timer_t dly_run;
os_timer_t heart_tm;
os_timer_t beacon_tm;
struct skb_list datalist;
struct skb_list cstlist;
struct skb_list f2upper;
struct skb_list f2local;
struct skb_list cmd_list;
struct skb_list otalist;
struct skb_list loglist;
struct skb_list wkdata_list;
struct list_head bss_list;
os_mutex_t bss_lock;
uint8 bss_cnt;
uint8 waiting_ap;
RBUFFER_DEF(evtq, uint8, WNB_EVTQ_SIZE);
struct mac_bus *bus;
struct lmac_ops *ops;
struct wnb_route_table rt_table;
struct wnb_route_table lp_table;
struct wnb_pkt_hook **hooks;
wnb_event_cb cb;
struct wnb_ps_data ps_data;
struct dsleep_psdata *psalive_data;
uint16 chan_list[WNB_CHAN_COUNT];
uint8 chan_cnt, start_chan, chan_idx;
int8 chan_try;
uint8 assoc_result;
uint8 hooks_cnt;
uint8 sta_num;
uint16 repeater_level;
uint8 mgmt_cookie, last_cookie;
uint16 bus_txcookie;
uint16 bus_rxcookie;
uint16 curr_freq;
uint16 tx_seqno;
uint16 ap_freq;
uint8 frm_type;
uint8 my_aid;
uint8 heartbeat_lost;
int8 rssi, rssi_notify, evm;
uint8 change_sequence, edca_update_cnt;
uint8 conn_fail;
uint16 conn_delay, pair_delay, scan_delay;
uint16 ether_type;
uint8 ps_hb_set: 1, ps_hbresp_set: 1, ps_wkdata_set: 1, ps_config_set:1, sleep_try: 3, detect_ap: 1;
uint8 host_alive, wk_reason;
/*flags*/
uint32 need_save: 1,
ps: 1,
fix_freq: 1,
closed: 1,
testmode: 1,
mcast_copy: 1,
mcu_func: 1,
bg_scan: 1,
repeater_en:1,
req_txwnd:1;
struct {
uint8 role_changed:1, keygen:1, resp_rx:1, resp_tx:1;
uint8 key[32];
uint32 start_jif;
struct wnb_sta *sta;
} pairing;
struct {
uint8 addr[6];
uint8 assoc_status;
uint8 req_param: 1, req_param_dis: 1, req_param_cnt: 6;
} report;
uint32 last_rx, last_tx, last_ps;
struct wnb_statistic statistic;
struct wnb_module_roam roaming;
struct wnb_module_ota ota;
struct wnb_module_netlog netlog;
struct wnb_module_netat netat;
struct wnb_module_dhcpc dhcpc;
struct wnb_module_atcmd atcmd;
struct wnb_module_drivercmd drivercmd;
struct wnb_module_arp arp;
struct wnb_module_psalive psalive;
};
#define WNB_SMRUN(wnb) os_sema_up(&wnb->sm_sema)
#define WNB_SMRUN_DELAY(wnb, tmo) os_timer_start(&wnb->dly_run, tmo)
#define WNB_RUN(wnb) os_sema_up(&wnb->sema)
#define WNB_EVENT(wnb, evt) do{RB_SET(&wnb->evtq, (uint8)evt); WNB_RUN(wnb);}while(0)
#define WNB_CB(evt,p1,p2) if(wnb->cb){ wnb->cb(evt, (uint32)(p1), (uint32)(p2));}
#define WNB_IS_REQ(hdr) (!((hdr)->resp)) /*wnb request packet*/
#define WNB_IS_RESP(hdr) ((hdr)->resp) /*wnb response packet*/
#define WNB_NEXT_CH(wnb, ch) (((ch)+1>=(wnb)->chan_cnt)?(0):((ch)+1))
#define WNB_VALID_BW(bw) ((bw)==1||(bw)==2||(bw)==4||(bw)==8)
#define WNB_VALID_FREQ(f) ((f)>=7300&&(f)<=9300)
#define WNB_VALID_MCS(m) (((m)>=0 && (m)<=7)||((m)==10))
#define WNB_PSDATA_SET2AP(wnb) (wnb->ps_hb_set && wnb->ps_hbresp_set && wnb->ps_wkdata_set && wnb->ps_config_set)
extern const uint8 wnb_bcast_addr[6];
extern const struct wnb_txq_param wnb_edca_params[5][4];
extern uint8 ieee80211_is_data_qos(uint16 frame_control);
int32 wnb_init(struct wnb_init_param *param);
void wnb_open(void);
void wnb_close(void);
void wnb_clear(void);
int32 wnb_cfg_save(void);
void wnb_role(struct wireless_nb *wnb, wnb_sta_role role);
int32 wnb_join_group(struct wireless_nb *wnb, uint8 *group_addr, uint8 aid);
int32 wnb_send_customer_data(struct hgic_tx_info *txinfo, uint8 *dest, uint8 *data, int32 len);
int32 wnb_send_ether_data(struct hgic_tx_info *txinfo, uint8 *data, int32 len);
void wnb_tx_data(struct wireless_nb *wnb, struct sk_buff *skb, wnb_forward_type forward);
int32 wnb_save_cfg(struct wnb_config *cfg, uint8 force);
void wnb_setup_chan_list(struct wireless_nb *wnb);
int32 wnb_freq_to_ch(struct wireless_nb *wnb, uint32 freq);
uint32 wnb_customer_id(void);
int32 wnb_dev_identify(struct wireless_nb *wnb, uint8 *id);
int32 wnb_is_loopback_data(struct wireless_nb *wnb, struct wnb_rx_info *rxinfo);
int32 wnb_ether_filter(struct wireless_nb *wnb, uint8 *data, int32 len);
void wnb_set_edca_param(struct wireless_nb *wnb, struct wnb_txq_param *param);
int32 wnb_macbus_send_data(struct wireless_nb *wnb, uint8 *data, int32 len);
int32 wnb_send_mgmt(struct wireless_nb *wnb, struct wnb_mgmt_tx *tx);
uint8 wnb_cookie(struct wireless_nb *wnb);
uint16 wnb_seqno(struct wireless_nb *wnb, struct wnb_sta *sta, uint8 ac);
int32 wnb_host_notify(void *priv, uint8 event_id, uint8 *args, int32 len);
void wnb_role_changed(struct wireless_nb *wnb);
struct wnb_sta *wnb_get_sta(struct wireless_nb *wnb, uint8 *addr);
struct wnb_sta *wnb_new_sta(struct wireless_nb *wnb);
void wnb_del_sta(struct wireless_nb *wnb, struct wnb_sta *sta);
int32 wnb_get_qos_flags(struct sk_buff *skb, uint8 qos[2]);
void wnb_new_state(struct wireless_nb *wnb, uint8 new_state);
void wnb_statistic_print(void);
void wnb_load_factparam(struct wnb_config *wnbcfg);
void wnb_sta_init(struct wireless_nb *wnb);
void wnb_connect(int32 start);
void wnb_send_assoc_req(struct wireless_nb *wnb);
void wnb_send_disassoc(struct wireless_nb *wnb, uint8 *dest, uint16 flags);
void wnb_rx_assoc(struct wireless_nb *wnb, uint8 *data, int32 len);
void wnb_rx_disassoc(struct wireless_nb *wnb, uint8 *data, int32 len);
void wnb_send_beacon(struct wireless_nb *wnb);
void wnb_send_heartbeat(struct wireless_nb *wnb, uint8 *dest);
void wnb_rx_heartbeat(struct wireless_nb *wnb, uint8 *data, int32 len);
int32 wnb_rx_beacon(struct wireless_nb *wnb, struct hgic_rx_info *rxinfo, uint8 *data, int32 len);
void wnb_delay_next_conn(struct wireless_nb *wnb);
void wnb_pairing(int32 start);
void wnb_rx_pair(struct wireless_nb *wnb, uint8 *data, int len);
void wnb_pairing_hello(struct wireless_nb *wnb);
void wnb_rx_config(struct wireless_nb *wnb, uint8 *data, int32 len);
void wnb_pair_role_changed(struct wireless_nb *wnb);
void wnb_host_event_pair_done(struct wireless_nb *wnb);
void wnb_pairing_prepare(struct wireless_nb *wnb);
void wnb_route_init(struct wireless_nb *wnb);
void wnb_route_update(struct wireless_nb *wnb, uint8 *dest, struct wnb_sta *sta);
struct wnb_sta *wnb_route(struct wireless_nb *wnb, uint8 *dest);
int32 wnb_srcrt_check(struct wireless_nb *wnb, uint8 *src);
void wnb_lptable_update(struct wireless_nb *wnb, uint8 *dest, uint8 *src);
void wnb_route_del(struct wnb_route_table *rt, uint8 *addr);
void wnb_route_print(struct wnb_route_table *rt);
void wnb_scan(struct wireless_nb *wnb, int32 start);
int32 wnb_get_scan_result(struct wireless_nb *wnb, struct sk_buff *skb);
int32 wnb_rx_probe_reponse(struct wireless_nb *wnb, struct hgic_rx_info *rxinfo, uint8 *data, int32 len);
int32 wnb_rx_probe_request(struct wireless_nb *wnb, struct hgic_rx_info *rxinfo, uint8 *data, int32 len);
int32 wnb_tx_probe_request(struct wireless_nb *wnb, uint8 *ssid);
void wnb_bss_flush(struct wireless_nb *wnb);
int32 wnb_bss_info_update(struct wireless_nb *wnb, struct hgic_rx_info *rxinfo, uint8 *data, int32 len);
void wnb_bss_info_update_from_beacon(struct wireless_nb *wnb, struct hgic_rx_info *rxinfo, uint8 *data, int32 len);
struct wnb_bss_info *wnb_roam(struct wireless_nb *wnb, uint8 flags);
uint8 *wnb_get_element(uint8 *ie, int32 ie_len, uint8 id);
int32 wnb_rx(void *priv, struct hgic_rx_info *rxinfo, uint8 *data, int32 len);
int32 wnb_proc_data_rx_hooks(struct wireless_nb *wnb, struct wnb_rx_info *rxinfo);
int32 wnb_proc_data_tx_hooks(struct wireless_nb *wnb, struct sk_buff *skb);
void wnb_sta_ps_end(struct wireless_nb *wnb, struct wnb_sta *sta);
void wnb_sta_ps_start(struct wireless_nb *wnb, struct wnb_sta *sta);
void wnb_free_psdata(struct wireless_nb *wnb, struct wnb_sta *sta);
void wnb_ps_init(struct wireless_nb *wnb);
void wnb_ps_mode(struct wireless_nb *wnb, uint32 start, uint32 time);
int32 wnb_get_sta_list(struct wireless_nb *wnb, struct sk_buff *skb);
int32 wnb_lptable_check(struct wireless_nb *wnb, uint8 *src);
void wnb_reset_beatheart(struct wireless_nb *wnb);
void wnb_disassoc_all(struct wireless_nb *wnb);
void wnb_request_parameter(struct wireless_nb *wnb);
int32 wnb_wakeup_sta(struct wireless_nb *wnb, uint8 *addr);
int8 wnb_get_sta_signal(struct wireless_nb *wnb, int32 index, uint8 *addr);
void wnb_send_nullfunc(struct wireless_nb *wnb, struct wnb_sta *sta, int32 ps);
void wnb_send_pspoll_response(struct wireless_nb *wnb);
struct wnb_sta *wnb_get_sta_ip(struct wireless_nb *wnb, uint32 ipaddr);
void wnb_ps_check_autosleep(struct wireless_nb *wnb);
void wnb_ps_ap_alive(struct wireless_nb *wnb);
void wnb_ps_wakeup_host(struct wireless_nb *wnb);
void wnb_ps_exit(struct wireless_nb *wnb, uint8 wk_reason);
void wnb_ps_check_wkreason(struct wireless_nb *wnb, uint8 wk_reason);
void wnb_opendev(struct wireless_nb *wnb);
void wnb_closedev(struct wireless_nb *wnb);
void wnb_init_lmac(struct wireless_nb *wnb);
int8 wnb_freq_type_match(uint8 ah_module_type, uint32 freq);
int32 wnb_rx_battery_soc(struct wireless_nb *wnb, uint8 *data, int32 len);
int32 mcu_battery_soc_request(struct wireless_nb *wnb);
uint16 wnb_checksum(uint16 initcksum, uint8 *ptr, int32 len);
void wnb_connect_start(struct wireless_nb *wnb);
void wnb_send_data_upper_ap(struct wireless_nb *wnb, uint8 *data, int32 len);
void wnb_check_ps_connect(struct wireless_nb *wnb);
int32 wnb_backgroud_scan(struct wireless_nb *wnb);
void wnb_start_bgscan(struct wireless_nb *wnb);
void wnb_scan_channel(struct wireless_nb *wnb);
void wnb_ps_set_ssid(struct wireless_nb *wnb);
void wnb_ps_get_ssid(struct wireless_nb *wnb);
void wnb_random(uint8 *key, int32 len);
void wnb_auto_pair_check(struct wireless_nb *wnb, int start);
void wnb_scan_dump(struct wireless_nb *wnb);
int32 customer_driver_data_send(uint8 *data, uint32 len);
int32 wnb_config_send_data(struct wireless_nb *wnb, uint8 *dest, uint16 type, uint8 *data, int32 len);
void wnb_config_send(struct wireless_nb *wnb);
void wnb_rx_mgmt_config(struct wireless_nb *wnb, uint8 *data, int32 len);
int32 wnb_set_key(struct wireless_nb *wnb, uint8 cmd, uint8 *addr, uint8 *key, uint8 swap);
int32 wnb_unpair_sta(struct wireless_nb *wnb, uint8 *addr);
int32 wnb_register_hook(struct wnb_pkt_hook *hook);
int32 wnb_ssid_match(struct wireless_nb * wnb, uint8 *ssid, uint8 ssid_len);
void wnb_config_send_psaliveconfig(struct wireless_nb *wnb);
void wnb_check_request_params(struct wireless_nb *wnb);
void wnb_request_params_en(struct wireless_nb *wnb, int32 en);
void wnb_encrypt(uint8 *key, uint8 *in, uint8 *out, uint32 len, uint8 en);
void wnb_module_drivercmd_init(void);
void wnb_module_psalive_init(void);
void wnb_module_ota_init(void);
void wnb_module_dhcpc_init(void);
void wnb_module_netlog_init(void);
void wnb_module_arp_init(void);
void wnb_module_roam_init(void);
void wnb_module_netat_init(void);
void wnb_module_atcmd_init(void);
static inline void wnb_roaming_check(struct wireless_nb *wnb, struct hgic_rx_info *rxinfo, uint8 *data, int32 len)
{
if(wnb->roaming.check_roaming) wnb->roaming.check_roaming(wnb, rxinfo, data, len);
}
static inline void wnb_roaming_check_scan_result(struct wireless_nb *wnb)
{
if(wnb->roaming.check_scan_result) wnb->roaming.check_scan_result(wnb);
}
static inline void wnb_notify_sta_roam_in(struct wireless_nb *wnb, struct wnb_sta *sta, uint8 notify, uint8 *roam_bssid)
{
if(wnb->roaming.roam_in) wnb->roaming.roam_in(wnb, sta, notify, roam_bssid);
}
static inline int32 wnb_roaming_forward(struct wireless_nb *wnb, struct wnb_sta *sta, struct sk_buff *skb)
{
if(wnb->roaming.forward_data)
return wnb->roaming.forward_data(wnb, sta, skb);
return 0;
}
static inline void wnb_rx_roaming_frame(struct wireless_nb * wnb, uint8 * data, int32 len)
{
if(wnb->roaming.proc_mgmt) wnb->roaming.proc_mgmt(wnb, data, len);
}
static inline int32 wnb_roaming_cache_data(struct wireless_nb *wnb, struct sk_buff *skb)
{
if(wnb->roaming.cache_data)
return wnb->roaming.cache_data(wnb, skb);
return 0;
}
static inline void wnb_psalive_action(struct wireless_nb *wnb, int32 action)
{
if(wnb->psalive.do_action) wnb->psalive.do_action(wnb, action);
}
static inline void wnb_psalive_start(struct wireless_nb *wnb, struct wnb_sta *sta, uint8 start)
{
if(wnb->psalive.start_sta) wnb->psalive.start_sta(wnb, sta, start);
}
static inline void wnb_rx_psalive_frame(struct wireless_nb *wnb, uint8 *data, int32 len)
{
if(wnb->psalive.proc_mgmt) wnb->psalive.proc_mgmt(wnb, data, len);
}
static inline void wnb_dhcpc_reset(struct wireless_nb *wnb)
{
if(wnb->dhcpc.reset) wnb->dhcpc.reset(wnb);
}
static inline void wnb_dhcpc_request_ip(struct wireless_nb *wnb)
{
if(wnb->dhcpc.request_ip) wnb->dhcpc.request_ip(wnb);
}
static inline void wnb_proc_driver_cmd(struct wireless_nb *wnb)
{
if(wnb->drivercmd.proc_cmd) wnb->drivercmd.proc_cmd(wnb);
}
static inline void wnb_driver_cmd_report_txwnd(struct wireless_nb *wnb)
{
if(wnb->drivercmd.report_txwnd) wnb->drivercmd.report_txwnd(wnb);
}
static inline void wnb_send_arp_reply(struct wireless_nb *wnb)
{
if(wnb->arp.send_reply) wnb->arp.send_reply(wnb);
}
static inline void wnb_proc_ota_data(struct wireless_nb *wnb)
{
if(wnb->ota.proc_data) wnb->ota.proc_data(wnb);
}
static inline char *WNB_ROLE_STR(int8 role)
{
switch (role) {
case WNB_STA_ROLE_MASTER: return "ap";
case WNB_STA_ROLE_SLAVE: return "sta";
case WNB_STA_ROLE_GPMEMB: return "group";
case WNB_STA_ROLE_REPEATER: return "apsta";
default: return "none";
}
}
#ifdef __cplusplus
}
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink