diff options
Diffstat (limited to 'drivers/staging/otus/80211core/struct.h')
| -rw-r--r-- | drivers/staging/otus/80211core/struct.h | 1315 |
1 files changed, 1315 insertions, 0 deletions
diff --git a/drivers/staging/otus/80211core/struct.h b/drivers/staging/otus/80211core/struct.h new file mode 100644 index 000000000000..17b5ce37ebb5 --- /dev/null +++ b/drivers/staging/otus/80211core/struct.h @@ -0,0 +1,1315 @@ +/* + * Copyright (c) 2007-2008 Atheros Communications Inc. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _STRUCT_H +#define _STRUCT_H + +#include "../oal_marc.h" + +#define ZM_SW_LOOP_BACK 0 /* 1=>enable, 0=>disable */ +#define ZM_PCI_LOOP_BACK 0 /* 1=>enable, 0=>disable */ +#define ZM_PROTOCOL_RESPONSE_SIMULATION 0 + +#define ZM_RX_FRAME_SIZE 1600 + +extern const u8_t zg11bRateTbl[4]; +extern const u8_t zg11gRateTbl[8]; + +#define ZM_DRIVER_CORE_MAJOR_VERSION 1 +#define ZM_DRIVER_CORE_MINOR_VERSION 1 +#define ZM_DRIVER_CORE_BRANCH_MAJOR_VERSION 3 +#define ZM_DRIVER_CORE_BRANCH_MINOR_VERSION 39 + +#ifndef ZM_VTXQ_SIZE +#define ZM_VTXQ_SIZE 1024 //2^N +#endif + +#define ZM_VTXQ_SIZE_MASK (ZM_VTXQ_SIZE-1) +#define ZM_VMMQ_SIZE 8 //2^N +#define ZM_VMMQ_SIZE_MASK (ZM_VMMQ_SIZE-1) + +#include "cagg.h" + +#define ZM_AGG_POOL_SIZE 20 +#define ZM_RATE_TABLE_SIZE 32 + +#define ZM_MAX_BUF_DISCRETE_NUMBER 5 + + + + + + + + + +/**********************************************************************************/ +/* IBSS macros */ +/**********************************************************************************/ +#define ZM_IBSS_PEER_ALIVE_COUNTER 4 + +/**********************************************************************************/ +/* BIT mapping related macros */ +/**********************************************************************************/ + +#define ZM_BIT_0 0x1 +#define ZM_BIT_1 0x2 +#define ZM_BIT_2 0x4 +#define ZM_BIT_3 0x8 +#define ZM_BIT_4 0x10 +#define ZM_BIT_5 0x20 +#define ZM_BIT_6 0x40 +#define ZM_BIT_7 0x80 +#define ZM_BIT_8 0x100 +#define ZM_BIT_9 0x200 +#define ZM_BIT_10 0x400 +#define ZM_BIT_11 0x800 +#define ZM_BIT_12 0x1000 +#define ZM_BIT_13 0x2000 +#define ZM_BIT_14 0x4000 +#define ZM_BIT_15 0x8000 +#define ZM_BIT_16 0x10000 +#define ZM_BIT_17 0x20000 +#define ZM_BIT_18 0x40000 +#define ZM_BIT_19 0x80000 +#define ZM_BIT_20 0x100000 +#define ZM_BIT_21 0x200000 +#define ZM_BIT_22 0x400000 +#define ZM_BIT_23 0x800000 +#define ZM_BIT_24 0x1000000 +#define ZM_BIT_25 0x2000000 +#define ZM_BIT_26 0x4000000 +#define ZM_BIT_27 0x8000000 +#define ZM_BIT_28 0x10000000 +#define ZM_BIT_29 0x20000000 //WPA support +#define ZM_BIT_30 0x40000000 +#define ZM_BIT_31 0x80000000 + + +/**********************************************************************************/ +/* MAC address related macros */ +/**********************************************************************************/ +#define ZM_MAC_BYTE_TO_WORD(macb, macw) macw[0] = macb[0] + (macb[1] << 8); \ + macw[1] = macb[2] + (macb[3] << 8); \ + macw[2] = macb[4] + (macb[5] << 8); + +#define ZM_MAC_WORD_TO_BYTE(macw, macb) macb[0] = (u8_t) (macw[0] & 0xff); \ + macb[1] = (u8_t) (macw[0] >> 8); \ + macb[2] = (u8_t) (macw[1] & 0xff); \ + macb[3] = (u8_t) (macw[1] >> 8); \ + macb[4] = (u8_t) (macw[2] & 0xff); \ + macb[5] = (u8_t) (macw[2] >> 8); + +#define ZM_MAC_0(macw) ((u8_t)(macw[0] & 0xff)) +#define ZM_MAC_1(macw) ((u8_t)(macw[0] >> 8)) +#define ZM_MAC_2(macw) ((u8_t)(macw[1] & 0xff)) +#define ZM_MAC_3(macw) ((u8_t)(macw[1] >> 8)) +#define ZM_MAC_4(macw) ((u8_t)(macw[2] & 0xff)) +#define ZM_MAC_5(macw) ((u8_t)(macw[2] >> 8)) + +#define ZM_IS_MULTICAST_OR_BROADCAST(mac) (mac[0] & 0x01) +#define ZM_IS_MULTICAST(mac) ((mac[0] & 0x01) && (((u8_t)mac[0]) != 0xFF)) + +#define ZM_MAC_EQUAL(mac1, mac2) ((mac1[0]==mac2[0])&&(mac1[1]==mac2[1])&&(mac1[2]==mac2[2])) +#define ZM_MAC_NOT_EQUAL(mac1, mac2) ((mac1[0]!=mac2[0])||(mac1[1]!=mac2[1])||(mac1[2]!=mac2[2])) +/**********************************************************************************/ +/* MAC address related mac'ros (end) */ +/**********************************************************************************/ +#define ZM_BYTE_TO_WORD(A, B) ((A<<8)+B) +#define ZM_ROL32( A, n ) \ + ( ((A) << (n)) | ( ((A)>>(32-(n))) & ( (1UL << (n)) - 1 ) ) ) +#define ZM_ROR32( A, n ) ZM_ROL32( (A), 32-(n) ) +#define ZM_LO8(v16) ((u8_t)((v16) & 0xFF)) +#define ZM_HI8(v16) ((u8_t)(((v16)>>8)&0xFF)) + +#ifdef ZM_ENABLE_BUFFER_TRACE +extern void zfwBufTrace(zdev_t* dev, zbuf_t *buf, u8_t *functionName); +#define ZM_BUFFER_TRACE(dev, buf) zfwBufTrace(dev, buf, __func__); +#else +#define ZM_BUFFER_TRACE(dev, buf) +#endif + +/* notification events to heart beat function */ +#define ZM_BSSID_LIST_SCAN 0x01 + +/* CAM mode */ +#define ZM_CAM_AP 0x1 +#define ZM_CAM_STA 0x2 +#define ZM_CAM_HOST 0x4 + +/* finite state machine for adapter */ +#define ZM_STA_STATE_DISCONNECT 1 +#define ZM_STA_STATE_CONNECTING 2 +#define ZM_STA_STATE_CONNECTED 3 + +/* Event definitions for finite state machine */ +#define ZM_EVENT_TIMEOUT_SCAN 0x0000 +#define ZM_EVENT_TIMEOUT_BG_SCAN 0x0001 +#define ZN_EVENT_TIMEOUT_RECONNECT 0x0002 +#define ZM_EVENT_TIMEOUT_INIT_SCAN 0x0003 +#define ZM_EVENT_TIMEOUT_AUTH 0x0004 +#define ZM_EVENT_TIMEOUT_ASSO 0x0005 +#define ZM_EVENT_TIMEOUT_AUTO_SCAN 0x0006 +#define ZM_EVENT_TIMEOUT_MIC_FAIL 0x0007 +#define ZM_EVENT_TIMEOUT_CHECK_AP 0x0008 +#define ZM_EVENT_CONNECT 0x0009 +#define ZM_EVENT_INIT_SCAN 0x000a +#define ZM_EVENT_SCAN 0x000b +#define ZM_EVENT_BG_SCAN 0x000c +#define ZM_EVENT_DISCONNECT 0x000d +#define ZM_EVENT_WPA_MIC_FAIL 0x000e +#define ZM_EVENT_AP_ALIVE 0x000f +#define ZM_EVENT_CHANGE_TO_AP 0x0010 +#define ZM_EVENT_CHANGE_TO_STA 0x0011 +#define ZM_EVENT_IDLE 0x0012 +#define ZM_EVENT_AUTH 0x0013 +#define ZM_EVENT_ASSO_RSP 0x0014 +#define ZM_EVENT_WPA_PK_OK 0x0015 +#define ZM_EVENT_WPA_GK_OK 0x0016 +#define ZM_EVENT_RCV_BEACON 0x0017 +#define ZM_EVENT_RCV_PROBE_RSP 0x0018 +#define ZM_EVENT_SEND_DATA 0x0019 +#define ZM_EVENT_AUTO_SCAN 0x001a +#define ZM_EVENT_MIC_FAIL1 0x001d +#define ZM_EVENT_MIC_FAIL2 0x001e +#define ZM_EVENT_IBSS_MONITOR 0x001f +#define ZM_EVENT_IN_SCAN 0x0020 +#define ZM_EVENT_CM_TIMER 0x0021 +#define ZM_EVENT_CM_DISCONNECT 0x0022 +#define ZM_EVENT_CM_BLOCK_TIMER 0x0023 +#define ZM_EVENT_TIMEOUT_ADDBA 0x0024 +#define ZM_EVENT_TIMEOUT_PERFORMANCE 0x0025 +#define ZM_EVENT_SKIP_COUNTERMEASURE 0x0026 +#define ZM_EVENT_NONE 0xffff + +/* Actions after call finite state machine */ +#define ZM_ACTION_NONE 0x0000 +#define ZM_ACTION_QUEUE_DATA 0x0001 +#define ZM_ACTION_DROP_DATA 0x0002 + +/* Timers for finite state machine */ +#define ZM_TICK_ZERO 0 +#define ZM_TICK_INIT_SCAN_END 8 +#define ZM_TICK_NEXT_BG_SCAN 50 +#define ZM_TICK_BG_SCAN_END 8 +#define ZM_TICK_AUTH_TIMEOUT 4 +#define ZM_TICK_ASSO_TIMEOUT 4 +#define ZM_TICK_AUTO_SCAN 300 +#define ZM_TICK_MIC_FAIL_TIMEOUT 6000 +#define ZM_TICK_CHECK_AP1 150 +#define ZM_TICK_CHECK_AP2 350 +#define ZM_TICK_CHECK_AP3 250 +#define ZM_TICK_IBSS_MONITOR 160 +#define ZM_TICK_IN_SCAN 4 +#define ZM_TICK_CM_TIMEOUT 6000 +#define ZM_TICK_CM_DISCONNECT 200 +#define ZM_TICK_CM_BLOCK_TIMEOUT 6000 + +/* Fix bug#33338 Counter Measure Issur */ +#ifdef NDIS_CM_FOR_XP +#define ZM_TICK_CM_TIMEOUT_OFFSET 2160 +#define ZM_TICK_CM_DISCONNECT_OFFSET 72 +#define ZM_TICK_CM_BLOCK_TIMEOUT_OFFSET 2160 +#else +#define ZM_TICK_CM_TIMEOUT_OFFSET 0 +#define ZM_TICK_CM_DISCONNECT_OFFSET 0 +#define ZM_TICK_CM_BLOCK_TIMEOUT_OFFSET 0 +#endif + +#define ZM_TIME_ACTIVE_SCAN 30 //ms +#define ZM_TIME_PASSIVE_SCAN 110 //ms + +/* finite state machine for BSS connect */ +#define ZM_STA_CONN_STATE_NONE 0 +#define ZM_STA_CONN_STATE_AUTH_OPEN 1 +#define ZM_STA_CONN_STATE_AUTH_SHARE_1 2 +#define ZM_STA_CONN_STATE_AUTH_SHARE_2 3 +#define ZM_STA_CONN_STATE_ASSOCIATE 4 +#define ZM_STA_CONN_STATE_SSID_NOT_FOUND 5 +#define ZM_STA_CONN_STATE_AUTH_COMPLETED 6 + +/* finite state machine for WPA handshaking */ +#define ZM_STA_WPA_STATE_INIT 0 +#define ZM_STA_WPA_STATE_PK_OK 1 +#define ZM_STA_WPA_STATE_GK_OK 2 + +/* various timers */ +#define ZM_INTERVAL_CONNECT_TIMEOUT 20 /* 200 milisecond */ + +/* IBSS definitions */ +#define ZM_IBSS_PARTNER_LOST 0 +#define ZM_IBSS_PARTNER_ALIVE 1 +#define ZM_IBSS_PARTNER_CHECK 2 + +#define ZM_BCMC_ARRAY_SIZE 16 /* Must be 2^N */ +#define ZM_UNI_ARRAY_SIZE 16 /* Must be 2^N */ + +#define ZM_MAX_DEFRAG_ENTRIES 4 /* 2^N */ +#define ZM_DEFRAG_AGING_TIME_SEC 5 /* 5 seconds */ + +#define ZM_MAX_WPAIE_SIZE 128 +/* WEP related definitions */ +#define ZM_USER_KEY_DEFAULT 64 +#define ZM_USER_KEY_PK 0 /* Pairwise Key */ +#define ZM_USER_KEY_GK 1 /* Group Key */ +/* AP WLAN Type */ +#define ZM_WLAN_TYPE_PURE_B 2 +#define ZM_WLAN_TYPE_PURE_G 1 +#define ZM_WLAN_TYPE_MIXED 0 + +/* HAL State */ +#define ZM_HAL_STATE_INIT 0 +#define ZM_HAL_STATE_RUNNING 1 + +/* AP Capability */ +#define ZM_All11N_AP 0x01 +#define ZM_XR_AP 0x02 +#define ZM_SuperG_AP 0x04 + +/* MPDU Density */ +#define ZM_MPDU_DENSITY_NONE 0 +#define ZM_MPDU_DENSITY_1_8US 1 +#define ZM_MPDU_DENSITY_1_4US 2 +#define ZM_MPDU_DENSITY_1_2US 3 +#define ZM_MPDU_DENSITY_1US 4 +#define ZM_MPDU_DENSITY_2US 5 +#define ZM_MPDU_DENSITY_4US 6 +#define ZM_MPDU_DENSITY_8US 7 + +/* Software Encryption */ +#define ZM_SW_TKIP_ENCRY_EN 0x01 +#define ZM_SW_TKIP_DECRY_EN 0x02 +#define ZM_SW_WEP_ENCRY_EN 0x04 +#define ZM_SW_WEP_DECRY_EN 0x08 + +/* Default Support Rate */ +#define ZM_DEFAULT_SUPPORT_RATE_ZERO 0x0 +#define ZM_DEFAULT_SUPPORT_RATE_DISCONNECT 0x1 +#define ZM_DEFAULT_SUPPORT_RATE_IBSS_B 0x2 +#define ZM_DEFAULT_SUPPORT_RATE_IBSS_AG 0x3 + +/* security related definitions */ +struct zsTkipSeed +{ + u8_t tk[32]; /* key */ + u8_t ta[6]; + u16_t ttak[5]; + u16_t ppk[6]; + u16_t iv16,iv16tmp; + u32_t iv32,iv32tmp; +}; + +struct zsMicVar +{ + u32_t k0, k1; // Key + u32_t left, right; // Current state + u32_t m; // Message accumulator (single word) + u16_t nBytes; // # bytes in M +}; + +struct zsDefragEntry +{ + u8_t fragCount; + u8_t addr[6]; + u16_t seqNum; + zbuf_t* fragment[8]; + u32_t tick; +}; + +struct zsDefragList +{ + struct zsDefragEntry defragEntry[ZM_MAX_DEFRAG_ENTRIES]; + u8_t replaceNum; +}; + +#define ZM_MAX_OPPOSITE_COUNT 16 +#define ZM_MAX_TX_SAMPLES 15 +#define ZM_TX_RATE_DOWN_CRITERIA 80 +#define ZM_TX_RATE_UP_CRITERIA 200 + + +#define ZM_MAX_PROBE_HIDDEN_SSID_SIZE 2 +struct zsSsidList +{ + u8_t ssid[32]; + u8_t ssidLen; +}; + +struct zsWrapperSetting +{ + u8_t bDesiredBssid; + u8_t desiredBssid[6]; + u16_t bssid[3]; + u8_t ssid[32]; + u8_t ssidLen; + u8_t authMode; + u8_t wepStatus; + u8_t encryMode; + u8_t wlanMode; + u16_t frequency; + u16_t beaconInterval; + u8_t dtim; + u8_t preambleType; + u16_t atimWindow; + + struct zsSsidList probingSsidList[ZM_MAX_PROBE_HIDDEN_SSID_SIZE]; + + u8_t dropUnencryptedPkts; + u8_t ibssJoinOnly; + u32_t adhocMode; + u8_t countryIsoName[4]; + u16_t autoSetFrequency; + + /* AP */ + u8_t bRateBasic; + u8_t gRateBasic; + u32_t nRateBasic; + u8_t bgMode; + + /* Common */ + u8_t staWmeEnabled; + u8_t staWmeQosInfo; + u8_t apWmeEnabled; + + + /* rate information: added in the future */ +}; + +struct zsWrapperFeatureCtrl +{ + u8_t bIbssGMode; +}; + +#define ZM_MAX_PS_STA 16 +#define ZM_PS_QUEUE_SIZE 32 + +struct zsStaPSEntity +{ + u8_t bUsed; + u8_t macAddr[6]; + u8_t bDataQueued; +}; + +struct zsStaPSList +{ + u8_t count; + struct zsStaPSEntity entity[ZM_MAX_PS_STA]; +}; + +#define ZM_MAX_TIMER_COUNT 32 + +/* double linked list */ +struct zsTimerEntry +{ + u16_t event; + u32_t timer; + struct zsTimerEntry *pre; + struct zsTimerEntry *next; +}; + +struct zsTimerList +{ + u8_t freeCount; + struct zsTimerEntry list[ZM_MAX_TIMER_COUNT]; + struct zsTimerEntry *head; + struct zsTimerEntry *tail; +}; + +/* Multicast list */ +#define ZM_MAX_MULTICAST_LIST_SIZE 64 + +struct zsMulticastAddr +{ + u8_t addr[6]; +}; + +struct zsMulticastList +{ + u8_t size; + struct zsMulticastAddr macAddr[ZM_MAX_MULTICAST_LIST_SIZE]; +}; + +enum ieee80211_cwm_mode { + CWM_MODE20, + CWM_MODE2040, + CWM_MODE40, + CWM_MODEMAX + +}; + +enum ieee80211_cwm_extprotspacing { + CWM_EXTPROTSPACING20, + CWM_EXTPROTSPACING25, + CWM_EXTPROTSPACINGMAX +}; + +enum ieee80211_cwm_width { + CWM_WIDTH20, + CWM_WIDTH40 +}; + +enum ieee80211_cwm_extprotmode { + CWM_EXTPROTNONE, /* no protection */ + CWM_EXTPROTCTSONLY, /* CTS to self */ + CWM_EXTPROTRTSCTS, /* RTS-CTS */ + CWM_EXTPROTMAX +}; + +struct ieee80211_cwm { + + /* Configuration */ + enum ieee80211_cwm_mode cw_mode; /* CWM mode */ + u8_t cw_extoffset; /* CWM Extension Channel Offset */ + enum ieee80211_cwm_extprotmode cw_extprotmode; /* CWM Extension Channel Protection Mode */ + enum ieee80211_cwm_extprotspacing cw_extprotspacing;/* CWM Extension Channel Protection Spacing */ + u32_t cw_enable; /* CWM State Machine Enabled */ + u32_t cw_extbusythreshold;/* CWM Extension Channel Busy Threshold */ + + /* State */ + enum ieee80211_cwm_width cw_width; /* CWM channel width */ +}; + + +/* AP : STA database structure */ +struct zsStaTable +{ + u32_t time; /* tick time */ + //u32_t phyCtrl; /* Tx PHY CTRL */ + u16_t addr[3]; /* STA MAC address */ + u16_t state; /* aut/asoc */ + //u16_t retry; /* Retry count */ + struct zsRcCell rcCell; + + u8_t valid; /* Valid flag : 1=>valid */ + u8_t psMode; /* STA power saving mode */ + u8_t staType; /* 0=>11b, 1=>11g, 2=>11n */ + u8_t qosType; /* 0=>Legacy, 1=>WME */ + u8_t qosInfo; /* WME QoS info */ + u8_t vap; /* Virtual AP ID */ + u8_t encryMode; /* Encryption type for this STA */ + u8_t keyIdx; + struct zsMicVar txMicKey; + struct zsMicVar rxMicKey; + u16_t iv16; + u32_t iv32; +#ifdef ZM_ENABLE_CENC + /* CENC */ + u8_t cencKeyIdx; + u32_t txiv[4]; + u32_t rxiv[4]; +#endif //ZM_ENABLE_CENC +}; + +struct zdStructWds +{ + u8_t wdsBitmap; /* Set bit-N to 1 to enable WDS */ + u8_t encryMode[ZM_MAX_WDS_SUPPORT]; /* WDS encryption mode */ + u16_t macAddr[ZM_MAX_WDS_SUPPORT][3]; /* WDS neighbor MAC address */ +}; + + // htcapinfo 16bits +#define HTCAP_AdvCodingCap 0x0001 +#define HTCAP_SupChannelWidthSet 0x0002 +#define HTCAP_DynamicSMPS 0x0004 +#define HTCAP_SMEnabled 0x000C +#define HTCAP_GreenField 0x0010 +#define HTCAP_ShortGIfor20MHz 0x0020 +#define HTCAP_ShortGIfor40MHz 0x0040 +#define HTCAP_TxSTBC 0x0080 +#define HTCAP_RxOneStream 0x0100 +#define HTCAP_RxTwoStream 0x0200 +#define HTCAP_RxThreeStream 0x0300 +#define HTCAP_DelayedBlockACK 0x0400 +#define HTCAP_MaxAMSDULength 0x0800 +#define HTCAP_DSSSandCCKin40MHz 0x1000 +#define HTCAP_PSMPSup 0x2000 +#define HTCAP_STBCControlFrameSup 0x4000 +#define HTCAP_LSIGTXOPProtectionSUP 0x8000 + // Ampdu HT Parameter Info 8bits +#define HTCAP_MaxRxAMPDU0 0x00 +#define HTCAP_MaxRxAMPDU1 0x01 +#define HTCAP_MaxRxAMPDU2 0x02 +#define HTCAP_MaxRxAMPDU3 0x03 + // PCO 8bits +#define HTCAP_PCO 0x01 +#define HTCAP_TransmissionTime1 0x02 +#define HTCAP_TransmissionTime2 0x04 +#define HTCAP_TransmissionTime3 0x06 + // MCS FeedBack 8bits +#define HTCAP_PlusHTCSupport 0x04 +#define HTCAP_RDResponder 0x08 + // TX Beamforming 0 8bits +#define HTCAP_TxBFCapable 0x01 +#define HTCAP_RxStaggeredSoundCap 0x02 +#define HTCAP_TxStaggeredSoundCap 0x04 +#define HTCAP_RxZLFCapable 0x08 +#define HTCAP_TxZLFCapable 0x10 +#define HTCAP_ImplicitTxBFCapable 0x20 + // Tx Beamforming 1 8bits +#define HTCAP_ExplicitCSITxBFCap 0x01 +#define HTCAP_ExpUncompSteerMatrCap 0x02 + // Antenna Selection Capabilities 8bits +#define HTCAP_AntennaSelectionCap 0x01 +#define HTCAP_ExplicitCSITxASCap 0x02 +#define HTCAP_AntennaIndFeeTxASCap 0x04 +#define HTCAP_ExplicitCSIFeedbackCap 0x08 +#define HTCAP_AntennaIndFeedbackCap 0x10 +#define HTCAP_RxASCap 0x20 +#define HTCAP_TxSoundPPDUsCap 0x40 + + + +struct zsHTCapability +{ + u8_t ElementID; + u8_t Length; + // HT Capability Info + u16_t HtCapInfo; + u8_t AMPDUParam; + u8_t MCSSet[16]; //16 bytes + // Extended HT Capability Info + u8_t PCO; + u8_t MCSFeedBack; + + u8_t TxBFCap[4]; + u8_t AselCap; +}; + +union zuHTCapability +{ + struct zsHTCapability Data; + u8_t Byte[28]; +}; + + //channelinfo 8bits +#define ExtHtCap_ExtChannelOffsetAbove 0x01 +#define ExtHtCap_ExtChannelOffsetBelow 0x03 +#define ExtHtCap_RecomTxWidthSet 0x04 +#define ExtHtCap_RIFSMode 0x08 +#define ExtHtCap_ControlAccessOnly 0x10 + //operatinginfo 16bits +#define ExtHtCap_NonGFDevicePresent 0x0004 + //beaconinfo 16bits +#define ExtHtCap_DualBeacon 0x0040 +#define ExtHtCap_DualSTBCProtection 0x0080 +#define ExtHtCap_SecondaryBeacon 0x0100 +#define ExtHtCap_LSIGTXOPProtectFullSup 0x0200 +#define ExtHtCap_PCOActive 0x0400 +#define ExtHtCap_PCOPhase 0x0800 + + +struct zsExtHTCapability +{ + u8_t ElementID; + u8_t Length; + u8_t ControlChannel; + u8_t ChannelInfo; + u16_t OperatingInfo; + u16_t BeaconInfo; + // Supported MCS Set + u8_t MCSSet[16]; +}; + +union zuExtHTCapability +{ + struct zsExtHTCapability Data; + u8_t Byte[24]; +}; + +struct InformationElementSta { + struct zsHTCapability HtCap; + struct zsExtHTCapability HtInfo; +}; + +struct InformationElementAp { + struct zsHTCapability HtCap; +}; + +#define ZM_MAX_FREQ_REQ_QUEUE 32 +typedef void (*zfpFreqChangeCompleteCb)(zdev_t* dev); + +struct zsWlanDevFreqControl +{ + u16_t freqReqQueue[ZM_MAX_FREQ_REQ_QUEUE]; + u8_t freqReqBw40[ZM_MAX_FREQ_REQ_QUEUE]; + u8_t freqReqExtOffset[ZM_MAX_FREQ_REQ_QUEUE]; + zfpFreqChangeCompleteCb freqChangeCompCb[ZM_MAX_FREQ_REQ_QUEUE]; + u8_t freqReqQueueHead; + u8_t freqReqQueueTail; +}; + +struct zsWlanDevAp +{ + u16_t protectedObss; /* protected overlap BSS */ + u16_t staAgingTimeSec; /* in second, STA will be deathed if it does not */ + /* active for this long time */ + u16_t staProbingTimeSec;/* in second, STA will be probed if it does not */ + /* active for this long time */ + u8_t authSharing; /* authentication on going*/ + u8_t bStaAssociated; /* 11b STA associated */ + u8_t gStaAssociated; /* 11g STA associated */ + u8_t nStaAssociated; /* 11n STA associated */ + u16_t protectionMode; /* AP protection mode flag */ + u16_t staPowerSaving; /* Set associated power saving STA count */ + + + + zbuf_t* uniArray[ZM_UNI_ARRAY_SIZE]; /* array to store unicast frames */ + u16_t uniHead; + u16_t uniTail; + + /* HT Capability Info */ + union zuHTCapability HTCap; //CWYang(+) + + /* Extended HT Capability Info */ + union zuExtHTCapability ExtHTCap; //CWYang(+) + + /* STA table */ + struct zsStaTable staTable[ZM_MAX_STA_SUPPORT]; + + /* WDS */ + struct zdStructWds wds; + /* WPA */ + u8_t wpaIe[ZM_MAX_AP_SUPPORT][ZM_MAX_WPAIE_SIZE]; + u8_t wpaLen[ZM_MAX_AP_SUPPORT]; + u8_t stawpaIe[ZM_MAX_AP_SUPPORT][ZM_MAX_WPAIE_SIZE]; + u8_t stawpaLen[ZM_MAX_AP_SUPPORT]; + u8_t wpaSupport[ZM_MAX_AP_SUPPORT]; + + //struct zsTkipSeed bcSeed; + u8_t bcKeyIndex[ZM_MAX_AP_SUPPORT]; + u8_t bcHalKeyIdx[ZM_MAX_AP_SUPPORT]; + struct zsMicVar bcMicKey[ZM_MAX_AP_SUPPORT]; + u16_t iv16[ZM_MAX_AP_SUPPORT]; + u32_t iv32[ZM_MAX_AP_SUPPORT]; + +#ifdef ZM_ENABLE_CENC + /* CENC */ + u32_t txiv[ZM_MAX_AP_SUPPORT][4]; +#endif //ZM_ENABLE_CENC + + /* Virtual AP */ + u8_t beaconCounter; + u8_t vapNumber; + u8_t apBitmap; /* Set bit-N to 1 to enable VAP */ + u8_t hideSsid[ZM_MAX_AP_SUPPORT]; + u8_t authAlgo[ZM_MAX_AP_SUPPORT]; + u8_t ssid[ZM_MAX_AP_SUPPORT][32]; /* SSID */ + u8_t ssidLen[ZM_MAX_AP_SUPPORT]; /* SSID length */ + u8_t encryMode[ZM_MAX_AP_SUPPORT]; + u8_t wepStatus[ZM_MAX_AP_SUPPORT]; + u16_t capab[ZM_MAX_AP_SUPPORT]; /* Capability */ + u8_t timBcmcBit[ZM_MAX_AP_SUPPORT]; /* BMCM bit of TIM */ + u8_t wlanType[ZM_MAX_AP_SUPPORT]; + + /* Array to store BC or MC frames */ + zbuf_t* bcmcArray[ZM_MAX_AP_SUPPORT][ZM_BCMC_ARRAY_SIZE]; + u16_t bcmcHead[ZM_MAX_AP_SUPPORT]; + u16_t bcmcTail[ZM_MAX_AP_SUPPORT]; + + u8_t qosMode; /* 1=>WME */ + u8_t uapsdEnabled; + struct zsQueue* uapsdQ; + + u8_t challengeText[128]; + + struct InformationElementAp ie[ZM_MAX_STA_SUPPORT]; + + +}; + +#define ZM_MAX_BLOCKING_AP_LIST_SIZE 4 /* 2^N */ +struct zsBlockingAp +{ + u8_t addr[6]; + u8_t weight; +}; + +#define ZM_SCAN_MGR_SCAN_NONE 0 +#define ZM_SCAN_MGR_SCAN_INTERNAL 1 +#define ZM_SCAN_MGR_SCAN_EXTERNAL 2 + +struct zsWlanDevStaScanMgr +{ + u8_t scanReqs[2]; + u8_t currScanType; + u8_t scanStartDelay; +}; + +#define ZM_PS_MSG_STATE_ACTIVE 0 +#define ZM_PS_MSG_STATE_SLEEP 1 +#define ZM_PS_MSG_STATE_T1 2 +#define ZM_PS_MSG_STATE_T2 3 +#define ZM_PS_MSG_STATE_S1 4 + +#define ZM_PS_MAX_SLEEP_PERIODS 3 // The number of beacon periods + +struct zsWlanDevStaPSMgr +{ + u8_t state; + u8_t isSleepAllowed; + u8_t maxSleepPeriods; + u8_t ticks; + u32_t lastTxUnicastFrm; + u32_t lastTxMulticastFrm; + u32_t lastTxBroadcastFrm; + u8_t tempWakeUp; /*enable when wake up but still in ps mode */ + u16_t sleepAllowedtick; +}; + +struct zsWlanDevSta +{ + u32_t beaconTxCnt; /* Transmitted beacon counter (in IBSS) */ + u8_t txBeaconInd; /* In IBSS mode, true means that we just transmit a beacon during + last beacon period. + */ + u16_t beaconCnt; /* receive beacon count, will be perodically reset */ + u16_t bssid[3]; /* BSSID of connected AP */ + u8_t ssid[32]; /* SSID */ + u8_t ssidLen; /* SSID length */ + u8_t mTxRate; /* Tx rate for multicast */ + u8_t uTxRate; /* Tx rate for unicast */ + u8_t mmTxRate; /* Tx rate for management frame */ + u8_t bChannelScan; + u8_t bScheduleScan; + + u8_t InternalScanReq; + u16_t activescanTickPerChannel; + u16_t passiveScanTickPerChannel; + u16_t scanFrequency; + u32_t connPowerInHalfDbm; + + u16_t currentFrequency; + u16_t currentBw40; + u16_t currentExtOffset; + + u8_t bPassiveScan; + + struct zsBlockingAp blockingApList[ZM_MAX_BLOCKING_AP_LIST_SIZE]; + + //struct zsBssInfo bssInfoPool[ZM_MAX_BSS]; + struct zsBssInfo* bssInfoArray[ZM_MAX_BSS]; + struct zsBssList bssList; + u8_t bssInfoArrayHead; + u8_t bssInfoArrayTail; + u8_t bssInfoFreeCount; + + u8_t authMode; + u8_t currentAuthMode; + u8_t wepStatus; + u8_t encryMode; + u8_t keyId; +#ifdef ZM_ENABLE_IBSS_WPA2PSK + u8_t ibssWpa2Psk; +#endif +#ifdef ZM_ENABLE_CENC + u8_t cencKeyId; //CENC +#endif //ZM_ENABLE_CENC + u8_t dropUnencryptedPkts; + u8_t ibssJoinOnly; + u8_t adapterState; + u8_t oldAdapterState; + u8_t connectState; + u8_t connectRetry; + u8_t wpaState; + u8_t wpaIe[ZM_MAX_IE_SIZE + 2]; + u8_t rsnIe[ZM_MAX_IE_SIZE + 2]; + u8_t challengeText[255+2]; + u8_t capability[2]; + //u8_t connectingHiddenAP; + //u8_t scanWithSSID; + u16_t aid; + u32_t mgtFrameCount; + u8_t bProtectionMode; + u32_t NonNAPcount; + u8_t RTSInAGGMode; + u32_t connectTimer; + u16_t atimWindow; + u8_t desiredBssid[6]; + u8_t bDesiredBssid; + struct zsTkipSeed txSeed; + struct zsTkipSeed rxSeed[4]; + struct zsMicVar txMicKey; + struct zsMicVar rxMicKey[4]; + u16_t iv16; + u32_t iv32; + struct zsOppositeInfo oppositeInfo[ZM_MAX_OPPOSITE_COUNT]; + u8_t oppositeCount; + u8_t bssNotFoundCount; /* sitesurvey for search desired ISBB threshold */ + u16_t rxBeaconCount; + u8_t beaconMissState; + u32_t rxBeaconTotal; + u8_t bIsSharedKey; + u8_t connectTimeoutCount; + + u8_t recvAtim; + + /* ScanMgr Control block */ + struct zsWlanDevStaScanMgr scanMgr; + struct zsWlanDevStaPSMgr psMgr; + + // The callback would be called if receiving an unencrypted packets but + // the station is in encrypted mode. The wrapper could decide whether + // to drop the packet by its OS setting. + zfpStaRxSecurityCheckCb pStaRxSecurityCheckCb; + + /* WME */ + u8_t apWmeCapability; //bit-0 => a WME AP + //bit-7 => a UAPSD AP + u8_t wmeParameterSetCount; + + u8_t wmeEnabled; + #define ZM_STA_WME_ENABLE_BIT 0x1 + #define ZM_STA_UAPSD_ENABLE_BIT 0x2 + u8_t wmeQosInfo; + + u8_t wmeConnected; + u8_t qosInfo; + struct zsQueue* uapsdQ; + + /* countermeasures */ + u8_t cmMicFailureCount; + u8_t cmDisallowSsidLength; + u8_t cmDisallowSsid[32]; + + /* power-saving mode */ + u8_t powerSaveMode; + zbuf_t* staPSDataQueue[ZM_PS_QUEUE_SIZE]; + u8_t staPSDataCount; + + /* IBSS power-saving mode */ + /* record the STA which has entered the PS mode */ + struct zsStaPSList staPSList; + /* queue the data of the PS STAs */ + zbuf_t* ibssPSDataQueue[ZM_PS_QUEUE_SIZE]; + u8_t ibssPSDataCount; + u8_t ibssPrevPSDataCount; + u8_t bIbssPSEnable; + /* BIT_15: ON/OFF, BIT_0~14: Atim Timer */ + u16_t ibssAtimTimer; + + /* WPA2 */ + struct zsPmkidInfo pmkidInfo; + + /* Multicast list related objects */ + struct zsMulticastList multicastList; + + /* XP packet filter feature : */ + /* 1=>enable: All multicast address packets, not just the ones enumerated in the multicast address list. */ + /* 0=>disable */ + u8_t bAllMulticast; + + /* reassociation flag */ + u8_t connectByReasso; + u8_t failCntOfReasso; + + /* for HT configure control setting */ + u8_t preambleTypeHT; /* HT: 0 Mixed mode 1 Green field */ + u8_t htCtrlBandwidth; + u8_t htCtrlSTBC; + u8_t htCtrlSG; + u8_t defaultTA; + + u8_t connection_11b; + + u8_t EnableHT; + u8_t SG40; + u8_t HT2040; + /* for WPA setting */ + u8_t wpaSupport; + u8_t wpaLen; + + /* IBSS related objects */ + u8_t ibssDelayedInd; + struct zsPartnerNotifyEvent ibssDelayedIndEvent; + u8_t ibssPartnerStatus; + + u8_t bAutoReconnect; + + u8_t flagFreqChanging; + u8_t flagKeyChanging; + struct zsBssInfo ibssBssDesc; + u8_t ibssBssIsCreator; + u16_t ibssReceiveBeaconCount; + u8_t ibssSiteSurveyStatus; + + u8_t disableProbingWithSsid; +#ifdef ZM_ENABLE_CENC + /* CENC */ + u8_t cencIe[ZM_MAX_IE_SIZE + 2]; +#endif //ZM_ENABLE_CENC + u32_t txiv[4]; //Tx PN Sequence + u32_t rxiv[4]; //Rx PN Sequence + u32_t rxivGK[4];//Broadcast Rx PN Sequence + u8_t wepKey[4][32]; // For Software WEP + u8_t SWEncryMode[4]; + + /* 802.11d */ + u8_t b802_11D; + + /* 802.11h */ + u8_t TPCEnable; + u8_t DFSEnable; + u8_t DFSDisableTx; + + /* Owl AP */ + u8_t athOwlAp; + + /* Enable BA response in driver */ + u8_t enableDrvBA; + + /* HT Capability Info */ + union zuHTCapability HTCap; //CWYang(+) + + /* Extended HT Capability Info */ + union zuExtHTCapability ExtHTCap; //CWYang(+) + + struct InformationElementSta ie; + +#define ZM_CACHED_FRAMEBODY_SIZE 200 + u8_t asocReqFrameBody[ZM_CACHED_FRAMEBODY_SIZE]; + u16_t asocReqFrameBodySize; + u8_t asocRspFrameBody[ZM_CACHED_FRAMEBODY_SIZE]; + u16_t asocRspFrameBodySize; + u8_t beaconFrameBody[ZM_CACHED_FRAMEBODY_SIZE]; + u16_t beaconFrameBodySize; + + u8_t ac0PriorityHigherThanAc2; + u8_t SWEncryptEnable; + + u8_t leapEnabled; + + u32_t TotalNumberOfReceivePackets; + u32_t TotalNumberOfReceiveBytes; + u32_t avgSizeOfReceivePackets; + + u32_t ReceivedPacketRateCounter; + u32_t ReceivedPktRatePerSecond; + + /* #2 Record the sequence number to determine whether the unicast frame is separated by RIFS or not */ +#define ZM_RIFS_STATE_DETECTING 0 +#define ZM_RIFS_STATE_DETECTED 1 +#define ZM_RIFS_TIMER_TIMEOUT 4480 // <Driver time>4480ms <Real time>7s + u8_t rifsState; + u8_t rifsLikeFrameCnt; + u16_t rifsLikeFrameSequence[3]; + u32_t rifsTimer; + u32_t rifsCount; + + /* RX filter desired by upper layers. Note this contains some bits which must be filtered + by sw since the hw supports only a subset of possible filter actions.= */ + u32_t osRxFilter; + + u8_t bSafeMode; + + u32_t ibssAdditionalIESize; + u8_t ibssAdditionalIE[256]; +}; //struct zsWlanDevSta + +#define ZM_CMD_QUEUE_SIZE 256 //Roger Check, test 64 when ready + +#define ZM_OID_READ 1 +#define ZM_OID_WRITE 2 +#define ZM_OID_INTERNAL_WRITE 3 +#define ZM_CMD_SET_FREQUENCY 4 +#define ZM_CMD_SET_KEY 5 +#define ZM_CWM_READ 6 +#define ZM_MAC_READ 7 +#define ZM_ANI_READ 8 +#define ZM_EEPROM_READ 9 +#define ZM_EEPROM_WRITE 0x0A +#define ZM_OID_CHAN 0x30 +#define ZM_OID_SYNTH 0x32 +#define ZM_OID_TALLY 0x81 +#define ZM_OID_TALLY_APD 0x82 + +#define ZM_OID_DKTX_STATUS 0x92 +#define ZM_OID_FLASH_CHKSUM 0xD0 +#define ZM_OID_FLASH_READ 0xD1 +#define ZM_OID_FLASH_PROGRAM 0xD2 +#define ZM_OID_FW_DL_INIT 0xD3 + +/* Driver to Firmware OID */ +#define ZM_CMD_ECHO 0x80 +#define ZM_CMD_TALLY 0x81 +#define ZM_CMD_TALLY_APD 0x82 +#define ZM_CMD_CONFIG 0x83 +#define ZM_CMD_RREG 0x00 +#define ZM_CMD_WREG 0x01 +#define ZM_CMD_RMEM 0x02 +#define ZM_CMD_WMEM 0x03 +#define ZM_CMD_BITAND 0x04 +#define ZM_CMD_BITOR 0x05 +#define ZM_CMD_EKEY 0x28 +#define ZM_CMD_DKEY 0x29 +#define ZM_CMD_FREQUENCY 0x30 +#define ZM_CMD_RF_INIT 0x31 +#define ZM_CMD_SYNTH 0x32 +#define ZM_CMD_FREQ_STRAT 0x33 +#define ZM_CMD_RESET 0x90 +#define ZM_CMD_DKRESET 0x91 +#define ZM_CMD_DKTX_STATUS 0x92 +#define ZM_CMD_FDC 0xA0 +#define ZM_CMD_WREEPROM 0xB0 +#define ZM_CMD_WFLASH 0xB0 +#define ZM_CMD_FLASH_ERASE 0xB1 +#define ZM_CMD_FLASH_PROG 0xB2 +#define ZM_CMD_FLASH_CHKSUM 0xB3 +#define ZM_CMD_FLASH_READ 0xB4 +#define ZM_CMD_FW_DL_INIT 0xB5 +#define ZM_CMD_MEM_WREEPROM 0xBB + + +/* duplicate filter table column */ +#define ZM_FILTER_TABLE_COL 2 /* 2^n */ +/* duplicate filter table Row */ +#define ZM_FILTER_TABLE_ROW 8 /* 2^n */ + +/* duplicate filter table structure */ +struct zsRxFilter +{ + u16_t addr[3]; + u16_t seq; + u8_t up; +}; + +struct zsWlanDev +{ + /* AP global variables */ + struct zsWlanDevAp ap; + /* STA global variables */ + struct zsWlanDevSta sta; + /* save wrapper setting */ + struct zsWrapperSetting ws; + /* features determined by wrapper (vendor) */ + struct zsWrapperFeatureCtrl wfc; + /* Traffic Monitor tally */ + struct zsTrafTally trafTally; + /* Communication tally */ + struct zsCommTally commTally; + /* Duplicate frame filter table */ + struct zsRxFilter rxFilterTbl[ZM_FILTER_TABLE_COL][ZM_FILTER_TABLE_ROW]; + /* Regulatory table */ + struct zsRegulationTable regulationTable; + + /* */ + struct zsWlanDevFreqControl freqCtrl; + + enum devState state; + + u8_t halState; + u8_t wlanMode; /* AP/INFRASTRUCTURE/IBSS/PSEUDO */ + u16_t macAddr[3]; /* MAC address */ + u16_t beaconInterval; /* beacon Interval */ + u8_t dtim; /* DTIM period */ + u8_t CurrentDtimCount; + u8_t preambleType; + u8_t preambleTypeInUsed; + u8_t maxTxPower2; /* 2.4 GHz Max Tx power (Unit: 0.5 dBm) */ + u8_t maxTxPower5; /* 5 GHz Max Tx power (Unit: 0.5 dBm) */ + u8_t connectMode; + u32_t supportMode; + + u8_t bRate; /* 11b Support Rate bit map */ + u8_t bRateBasic; /* 11b Basic Rate bit map */ + u8_t gRate; /* 11g Support Rate bit map */ + u8_t gRateBasic; /* 11g Basic Rate bit map */ + /* channel index point to the item in regulation table */ + u8_t channelIndex; + + /* channel management */ + u8_t BandWidth40; + u8_t ExtOffset; //1 above, 3 below, 0 not present + u16_t frequency; /* operation frequency */ + + u8_t erpElement; /* ERP information element data */ + + u8_t disableSelfCts; /* set to 1 to disable Self-CTS */ + u8_t bgMode; + + /* private test flag */ + u32_t enableProtectionMode; /* force enable/disable self cts */ + u32_t checksumTest; /* OTUS checksum test 1=>zero checksum 0=>normal */ + u32_t rxPacketDump; /* rx packet dump */ + + u8_t enableAggregation; /* force enable/disable A-MSPU */ + u8_t enableWDS; /* force enable/disable WDS testing */ + u8_t enableTxPathMode; /* OTUS special testing mode 1=>diable, 0=>enable: ZM_SYSTEM_TEST_MODE */ + u8_t enableHALDbgInfo; /* */ + + u32_t forceTxTPC; /* force tx packet send TPC */ + + u16_t seq[4]; + u16_t mmseq; + + /* driver core time tick */ + u32_t tick; + u16_t tickIbssSendBeacon; + u16_t tickIbssReceiveBeacon; + + /* RTS threshold */ + u16_t rtsThreshold; + + /* fragmentation threshold, 256 <= value <= 2346, 0=disabled */ + u16_t fragThreshold; + + /* Tx Rate */ + u16_t txMCS; + u16_t txMT; + u32_t CurrentTxRateKbps; //CWYang(+) + /* Rx Rate */ + u32_t CurrentRxRateKbps; //Janet(+) + u8_t CurrentRxRateUpdated; + u8_t modulationType; + u8_t rxInfo; + u16_t rateField; + + /* timer related objects */ + struct zsTimerList timerList; + u8_t bTimerReady; + + /* for defragmentation */ + struct zsDefragList defragTable; + + /* Data struct for Interface Dependent Layer */ + //struct zsIdlStruct idlStruct; + + /* Signal Strength/Quality Related Parameters */ + u8_t SignalStrength; //CWYang(+) + u8_t SignalQuality; //CWYang(+) + + + + /* QoS */ + zbuf_t* vtxq[4][ZM_VTXQ_SIZE]; + u16_t vtxqHead[4]; + u16_t vtxqTail[4]; + u16_t qosDropIpFrag[4]; + + /* Management Tx queue */ + zbuf_t* vmmq[ZM_VMMQ_SIZE]; + u16_t vmmqHead; + u16_t vmmqTail; + + u8_t vtxqPushing; + + /* + * add by honda + * 1. Aggregate queues + * 2. STA's associated information and queue number + * 3. rx aggregation re-ordering queue + */ + struct aggQueue *aggQPool[ZM_AGG_POOL_SIZE]; + u8_t aggInitiated; + u8_t addbaComplete; + u8_t addbaCount; + u8_t aggState; + u8_t destLock; + struct aggSta aggSta[ZM_MAX_STA_SUPPORT]; + struct agg_tid_rx *tid_rx[ZM_AGG_POOL_SIZE]; + struct aggTally agg_tal; + struct destQ destQ; + struct baw_enabler *baw_enabler; + struct ieee80211_cwm cwm; + u16_t reorder; + u16_t seq_debug; + /* rate control */ + u32_t txMPDU[ZM_RATE_TABLE_SIZE]; + u32_t txFail[ZM_RATE_TABLE_SIZE]; + u32_t PER[ZM_RATE_TABLE_SIZE]; + u16_t probeCount; + u16_t probeSuccessCount; + u16_t probeInterval; + u16_t success_probing; + /* + * end of add by honda + */ + + /* airopeek sniffer mode for upper sw */ + u32_t swSniffer; /* window: airoPeek */ + u32_t XLinkMode; + + /* MDK mode */ + /* init by 0=>normal driver 1=>MDK driver */ + u32_t modeMDKEnable; + + u32_t heartBeatNotification; + + /* pointer for HAL Plus private memory */ + void* hpPrivate; + + /* for WPA setting */ + //u8_t wpaSupport[ZM_MAX_AP_SUPPORT]; + //u8_t wpaLen[ZM_MAX_AP_SUPPORT]; + //u8_t wpaIe[ZM_MAX_AP_SUPPORT][ZM_MAX_IE_SIZE]; + + struct zsLedStruct ledStruct; + + /* ani flag */ + u8_t aniEnable; + u16_t txq_threshold; + + //Skip Mic Error Check + u8_t TKIP_Group_KeyChanging; + + u8_t dynamicSIFSEnable; + + u8_t queueFlushed; + + u16_t (*zfcbAuthNotify)(zdev_t* dev, u16_t* macAddr); + u16_t (*zfcbAsocNotify)(zdev_t* dev, u16_t* macAddr, u8_t* body, u16_t bodySize, u16_t port); + u16_t (*zfcbDisAsocNotify)(zdev_t* dev, u8_t* macAddr, u16_t port); + u16_t (*zfcbApConnectNotify)(zdev_t* dev, u8_t* macAddr, u16_t port); + void (*zfcbConnectNotify)(zdev_t* dev, u16_t status, u16_t* bssid); + void (*zfcbScanNotify)(zdev_t* dev, struct zsScanResult* result); + void (*zfcbMicFailureNotify)(zdev_t* dev, u16_t* addr, u16_t status); + void (*zfcbApMicFailureNotify)(zdev_t* dev, u8_t* addr, zbuf_t* buf); + void (*zfcbIbssPartnerNotify)(zdev_t* dev, u16_t status, struct zsPartnerNotifyEvent *event); + void (*zfcbMacAddressNotify)(zdev_t* dev, u8_t* addr); + void (*zfcbSendCompleteIndication)(zdev_t* dev, zbuf_t* buf); + void (*zfcbRecvEth)(zdev_t* dev, zbuf_t* buf, u16_t port); + void (*zfcbRecv80211)(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* addInfo); + void (*zfcbRestoreBufData)(zdev_t* dev, zbuf_t* buf); +#ifdef ZM_ENABLE_CENC + u16_t (*zfcbCencAsocNotify)(zdev_t* dev, u16_t* macAddr, u8_t* body, + u16_t bodySize, u16_t port); +#endif //ZM_ENABLE_CENC + u8_t (*zfcbClassifyTxPacket)(zdev_t* dev, zbuf_t* buf); + void (*zfcbHwWatchDogNotify)(zdev_t* dev); +}; + + +struct zsWlanKey +{ + u8_t key; +}; + + +/* These macros are defined here for backward compatibility */ +/* Please leave them alone */ +/* For Tx packet allocated in upper layer layer */ +#define zmw_tx_buf_readb(dev, buf, offset) zmw_buf_readb(dev, buf, offset) +#define zmw_tx_buf_readh(dev, buf, offset) zmw_buf_readh(dev, buf, offset) +#define zmw_tx_buf_writeb(dev, buf, offset, value) zmw_buf_writeb(dev, buf, offset, value) +#define zmw_tx_buf_writeh(dev, buf, offset, value) zmw_buf_writeh(dev, buf, offset, value) + +/* For Rx packet allocated in driver */ +#define zmw_rx_buf_readb(dev, buf, offset) zmw_buf_readb(dev, buf, offset) +#define zmw_rx_buf_readh(dev, buf, offset) zmw_buf_readh(dev, buf, offset) +#define zmw_rx_buf_writeb(dev, buf, offset, value) zmw_buf_writeb(dev, buf, offset, value) +#define zmw_rx_buf_writeh(dev, buf, offset, value) zmw_buf_writeh(dev, buf, offset, value) + +#endif /* #ifndef _STRUCT_H */ |