stm32驱动wifi 88W8686 WM-G-MR-09

#include "wifi.h"

#include

#include

#include

/********************************************************

Local Constants

********************************************************/

//! Approximate amount of data needed to pass a scan result back to iwlist

#define M AX_SCAN_CELL_SIZE (I W_EV_ADDR_LEN \

+ M RVDRV_MAX_SSID_LENGTH \

+ I W_EV_UINT_LEN \

+ I W_EV_FREQ_LEN \

+ I W_EV_QUAL_LEN \

+ M RVDRV_MAX_SSID_LENGTH \

+ I W_EV_PARAM_LEN \

+ 40) /* 40 for WPAIE */

//! Memory needed to store a max sized Channel List TLV for a firmware scan

#define C HAN_TLV_MAX_SIZE (sizeof(M rvlIEtypesHeader_t) \

+ (M RVDRV_MAX_CHANNELS_PER_SCAN \

* sizeof(C hanScanParamSet_t)))

//! Memory needed to store a max number/size SSID TLV for a firmware scan

#define S SID_TLV_MAX_SIZE (1 * sizeof(M rvlIEtypes_SsIdParamSet_t))

//! WPS TLV MAX size is MAX IE size plus 2 bytes for u16 MRVL TLV extension

#define W PS_TLV_MAX_SIZE (sizeof(I EEEtypes_VendorSpecific_t) + 2)

//! Maximum memory needed for a wlan_scan_cmd_config with all TLVs at max

#define M AX_SCAN_CFG_ALLOC (sizeof(w lan_scan_cmd_config) \

+ sizeof(M rvlIEtypes_NumProbes_t) \

+ C HAN_TLV_MAX_SIZE \

+ S SID_TLV_MAX_SIZE \

+ W PS_TLV_MAX_SIZE)

//! The maximum number of channels the firmware can scan per command

#define M RVDRV_MAX_CHANNELS_PER_SCAN 14

/**

* @brief Number of channels to scan per firmware scan command issuance.

*

* Number restricted to prevent hitting the limit on the amount of scan data * returned in a single firmware scan command.

*/

#define M RVDRV_CHANNELS_PER_SCAN_CMD 4

//! Macro to enable/disable SSID checking before storing a scan table

#ifdef D ISCARD_BAD_SSID

#define C HECK_SSID_IS_VALID(x) s sid_valid(&bssidEntry.Ssid)

#else

#define C HECK_SSID_IS_VALID(x) TRUE

#endif

/********************************************************

Local Variables and Types

********************************************************/

/**

* @brief Interally used to send a configured scan cmd between driver routines

*/

typedef union

{

wlan_scan_cmd_config config; //!< Scan configuration (variable length) u8 configAllocBuf[M AX_SCAN_CFG_ALLOC]; //!< Max allocated block

} w lan_scan_cmd_config_tlv;

/**

* @brief Check if a scanned network compatible with the driver settings

*

* WEP WPA WPA2 ad-hoc encrypt Network

* enabled enabled enabled AES mode Privacy WPA WPA2 Compatible

* 0 0 0 0 NONE 0 0 0 yes No security

* 0 1 0 0 x 1x 1 x yes WPA

* 0 0 1 0 x 1x x 1 yes WPA2

* 0 0 0 1 NONE 1 0 0 yes Ad-hoc AES

*

* 1 0 0 0 NONE 1 0 0 yes Static WEP

* 0 0 0 0 !=NONE 1 0 0 yes Dynamic WEP

*

*

* @param Adapter A pointer to wlan_adapter

* @param index Index in ScanTable to check against current driver settings

* @param mode Network mode: Infrastructure or IBSS

*

* @return Index in ScanTable, or error code if negative

*/

static int

IsNetworkCompatible(w lan_adapter * Adapter, int index, int mode)

{

BSSDescriptor_t *pBSSDesc;

ENTER();

pBSSDesc = &Adapter->ScanTable[index];

/* D on't check for compatibility if roaming */

if ((Adapter->MediaConnectStatus == WlanMediaStateConnected)

&& (Adapter->InfrastructureMode == W lan802_11Infrastructure)

&& (pBSSDesc->InfrastructureMode == W lan802_11Infrastructure)) {

LEAVE();

return index;

}

if (Adapter->wps.SessionEnable == TRUE) {

printf("Return success directly in WPS period\n");

LEAVE();

return index;

}

if (pBSSDesc->InfrastructureMode == mode) {

if (Adapter->SecInfo.WEPStatus == W lan802_11WEPDisabled

&& !Adapter->SecInfo.WPAEnabled

&& !Adapter->SecInfo.W PA2Enabled

&& pBSSDesc->wpaIE.VendHdr.ElementId != W PA_IE

&& pBSSDesc->rsnIE.IeeeHdr.ElementId != R SN_IE

&& !Adapter->AdhocAESEnabled

&& Adapter->SecInfo.EncryptionMode == C IPHER_NONE

&& !pBSSDesc->Privacy) {

/* no security */

LEAVE();

return index;

} else if (Adapter->SecInfo.WEPStatus == W lan802_11WEPEnabled

&& !Adapter->SecInfo.WPAEnabled

&& !Adapter->SecInfo.W PA2Enabled

&& !Adapter->AdhocAESEnabled && pBSSDesc->Privacy) {

/* static WEP enabled */

LEAVE();

return index;

} else if (Adapter->SecInfo.WEPStatus == W lan802_11WEPDisabled

&& Adapter->SecInfo.WPAEnabled

&& !Adapter->SecInfo.W PA2Enabled

&& (pBSSDesc->wpaIE.VendHdr.ElementId == W PA_IE)

&& !Adapter->AdhocAESEnabled

/* P rivacy bit may NOT be set in some APs like LinkSys WRT54G && pBSSDesc->Privacy */

) {

/* WPA enabled */

printf("IsNetworkCompatible() WPA: index=%d wpa_ie=%#x "

"wpa2_ie=%#x WEP=%s WPA=%s WPA2=%s EncMode=%#x "

"privacy=%#x\n",

index,

pBSSDesc->wpaIE.VendHdr.ElementId,

pBSSDesc->rsnIE.IeeeHdr.ElementId,

(Adapter->SecInfo.WEPStatus ==

Wlan802_11WEPEnabled) ? "e" : "d",

(Adapter->SecInfo.WPAEnabled) ? "e" : "d",

(Adapter->SecInfo.W PA2Enabled) ? "e" : "d",

Adapter->SecInfo.EncryptionMode, pBSSDesc->Privacy);

LEAVE();

return index;

} else if (Adapter->SecInfo.WEPStatus == W lan802_11WEPDisabled

&& !Adapter->SecInfo.WPAEnabled

&& Adapter->SecInfo.W PA2Enabled

&& (pBSSDesc->rsnIE.IeeeHdr.ElementId == R SN_IE)

&& !Adapter->AdhocAESEnabled

/* P rivacy bit may NOT be set in some APs like LinkSys WRT54G && pBSSDesc->Privacy */

) {

/* W PA2 enabled */

printf( "IsNetworkCompatible() WPA2: index=%d wpa_ie=%#x "

"wpa2_ie=%#x WEP=%s WPA=%s WPA2=%s EncMode=%#x "

"privacy=%#x\n",

index,

pBSSDesc->wpaIE.VendHdr.ElementId,

pBSSDesc->rsnIE.IeeeHdr.ElementId,

(Adapter->SecInfo.WEPStatus ==

Wlan802_11WEPEnabled) ? "e" : "d",

(Adapter->SecInfo.WPAEnabled) ? "e" : "d",

(Adapter->SecInfo.W PA2Enabled) ? "e" : "d",

Adapter->SecInfo.EncryptionMode, pBSSDesc->Privacy);

LEAVE();

return index;

} else if (Adapter->SecInfo.WEPStatus == W lan802_11WEPDisabled

&& !Adapter->SecInfo.WPAEnabled

&& !Adapter->SecInfo.W PA2Enabled

&& (pBSSDesc->wpaIE.VendHdr.ElementId != W PA_IE)

&& (pBSSDesc->rsnIE.IeeeHdr.ElementId != R SN_IE)

&& Adapter->AdhocAESEnabled

&& Adapter->SecInfo.EncryptionMode == C IPHER_NONE

&& pBSSDesc->Privacy) {

/* A d-hoc AES enabled */

LEAVE();

return index;

} else if (Adapter->SecInfo.WEPStatus == W lan802_11WEPDisabled

&& !Adapter->SecInfo.WPAEnabled

&& !Adapter->SecInfo.W PA2Enabled

&& (pBSSDesc->wpaIE.VendHdr.ElementId != W PA_IE)

&& (pBSSDesc->rsnIE.IeeeHdr.ElementId != R SN_IE)

&& !Adapter->AdhocAESEnabled

&& Adapter->SecInfo.EncryptionMode != C IPHER_NONE

&& pBSSDesc->Privacy) {

/* dynamic WEP enabled */

printf( "IsNetworkCompatible() dynamic WEP: index=%d "

"wpa_ie=%#x wpa2_ie=%#x EncMode=%#x privacy=%#x\n",

index,

pBSSDesc->wpaIE.VendHdr.ElementId,

pBSSDesc->rsnIE.IeeeHdr.ElementId,

Adapter->SecInfo.EncryptionMode, pBSSDesc->Privacy);

LEAVE();

return index;

}

/* s ecurity doesn't match */

printf( "IsNetworkCompatible() FAILED: index=%d wpa_ie=%#x "

"wpa2_ie=%#x WEP=%s WPA=%s WPA2=%s EncMode=%#x privacy=%#x\n", index,

pBSSDesc->wpaIE.VendHdr.ElementId,

pBSSDesc->rsnIE.IeeeHdr.ElementId,

(Adapter->SecInfo.WEPStatus ==

Wlan802_11WEPEnabled) ? "e" : "d",

(Adapter->SecInfo.WPAEnabled) ? "e" : "d",

(Adapter->SecInfo.W PA2Enabled) ? "e" : "d",

Adapter->SecInfo.EncryptionMode, pBSSDesc->Privacy);

LEAVE();

return -ECONNREFUSED;

}

/* m ode doesn't match */

LEAVE();

return -ENETUNREACH;

}

/**

* @brief This function validates a SSID as being able to be printed

*

* @param pSsid SSID structure to validate

*

* @return TRUE or FALSE

*/

static BOOLEAN

s sid_valid(W LAN_802_11_SSID * pSsid)

{

int ssidIdx;

for (ssidIdx = 0; ssidIdx < pSsid->SsidLength; ssidIdx++) {

if (!isprint(pSsid->Ssid[ssidIdx])) {

return FALSE;

}

}

return TRUE;

}

/**

* @brief Post process the scan table after a new scan command has completed *

* Inspect each entry of the scan table and try to find an entry that

* matches our current associated/joined network from the scan. If

* one is found, update the stored copy of the BSSDescriptor for our

* current network.

*

* Debug dump the current scan table contents if compiled accordingly.

*

* @param priv A pointer to wlan_private structure

*

* @return void

*/

static void

w lan_scan_process_results(w lan_private * priv)

{

wlan_adapter *Adapter = priv->adapter;

int i;

//int foundCurrent;

//foundCurrent = FALSE;

if (Adapter->MediaConnectStatus == WlanMediaStateConnected) {

Adapter->CurBssParams.BSSDescriptor.pBeaconBuf = NULL;

Adapter->CurBssParams.BSSDescriptor.beaconBufSize = 0;

Adapter->CurBssParams.BSSDescriptor.beaconBufSizeMax = 0;

i = FindSSIDInList(Adapter,

&Adapter->CurBssParams.BSSDescriptor.Ssid,

Adapter->CurBssParams.BSSDescriptor.MacAddress,

Adapter->InfrastructureMode);

if (i >= 0) {

printf("Found current ssid/bssid in list @ index #%d\n", i);

/* Make a copy of current BSSID descriptor */

memcpy(&Adapter->CurBssParams.BSSDescriptor,

&Adapter->ScanTable[i],

sizeof(Adapter->CurBssParams.BSSDescriptor));

}

}

for (i = 0; i < Adapter->NumInScanTable; i++) {

printf( "Scan:(%02d) %02x:%02x:%02x:%02x:%02x:%02x, "

"RSSI[%03d], SSID[%s]\n",

i,

Adapter->ScanTable[i].MacAddress[0],

Adapter->ScanTable[i].MacAddress[1],

Adapter->ScanTable[i].MacAddress[2],

Adapter->ScanTable[i].MacAddress[3],

Adapter->ScanTable[i].MacAddress[4],

Adapter->ScanTable[i].MacAddress[5],

(s32) Adapter->ScanTable[i].Rssi,

Adapter->ScanTable[i].Ssid.Ssid);

}

}

/**

* @brief Create a channel list for the driver to scan based on region info

*

* Use the driver region/band information to construct a comprehensive list

* of channels to scan. This routine is used for any scan that is not

* provided a specific channel list to scan.

*

* @param priv A pointer to wlan_private structure

* @param scanChanList Output parameter: Resulting channel list to scan

* @param filteredScan Flag indicating whether or not a BSSID or SSID filter * is being sent in the command to firmware. Used to

* increase the number of channels sent in a scan

* command and to disable the firmware channel scan

* filter.

*

* @return void

*/

static void

w lan_scan_create_channel_list(w lan_private * priv,

ChanScanParamSet_t * scanChanList,

BOOLEAN filteredScan)

{

wlan_adapter *Adapter = priv->adapter;

REGION_CHANNEL *scanRegion;

CHANNEL_FREQ_POWER *cfp;

int rgnIdx;

int chanIdx;

int nextChan;

u8 scanType;

chanIdx = 0;

/* S et the default scan type to the user specified type, will later

* be changed to passive on a per channel basis if restricted by

* regulatory requirements (11d or 11h)

*/

scanType = Adapter->ScanType;

for (rgnIdx = 0; rgnIdx < NELEMENTS(Adapter->r egion_channel); rgnIdx++) { if (w lan_get_state_11d(priv) == E NABLE_11D &&

Adapter->MediaConnectStatus != WlanMediaStateConnected) {

/* Scan all the supported chan for the first scan */

if (!Adapter->u niversal_channel[rgnIdx].Valid)

continue;

scanRegion = &Adapter->u niversal_channel[rgnIdx];

/* c lear the parsed_region_chan for the first scan */

memset(&Adapter->p arsed_region_chan, 0x00,

sizeof(Adapter->p arsed_region_chan));

} else {

if (!Adapter->r egion_channel[rgnIdx].Valid)

continue;

scanRegion = &Adapter->r egion_channel[rgnIdx];

}

for (nextChan = 0;

nextChan < scanRegion->NrCFP; nextChan++, chanIdx++) {

cfp = scanRegion->CFP + nextChan;

if (w lan_get_state_11d(priv) == E NABLE_11D) {

scanType =

wlan_get_scan_type_11d(cfp->Channel,

&Adapter->p arsed_region_chan);

}

switch (scanRegion->Band) {

case B AND_B:

case B AND_G:

default:

scanChanList[chanIdx].RadioType = H ostCmd_SCAN_RADIO_TYPE_BG; break;

}

if (scanType == H ostCmd_SCAN_TYPE_PASSIVE) {

scanChanList[chanIdx].MaxScanTime =

wlan_cpu_to_le16(Adapter->PassiveScanTime);

scanChanList[chanIdx].ChanScanMode.PassiveScan = TRUE;

} else {

scanChanList[chanIdx].MaxScanTime =

wlan_cpu_to_le16(Adapter->ActiveScanTime);

scanChanList[chanIdx].ChanScanMode.PassiveScan = FALSE;

}

scanChanList[chanIdx].ChanNumber = cfp->Channel;

if (filteredScan) {

scanChanList[chanIdx].MaxScanTime =

wlan_cpu_to_le16(Adapter->SpecificScanTime);

scanChanList[chanIdx].ChanScanMode.DisableChanFilt = TRUE;

}

}

}

}

static void

w lan_add_wps_probe_request_ie(w lan_private * priv, u8 ** ppTlvOut)

{

wlan_adapter *Adapter = priv->adapter;

MrvlIEtypesHeader_t *tlv;

if (Adapter->wps.wpsIe.VendHdr.Len) {

tlv = (M rvlIEtypesHeader_t *) * ppTlvOut;

tlv->Type = w lan_cpu_to_le16(T LV_TYPE_WPS_ENROLLEE_PROBE_REQ_TLV);

tlv->Len = w lan_cpu_to_le16(Adapter->wps.wpsIe.VendHdr.Len);

*ppTlvOut += sizeof(M rvlIEtypesHeader_t);

memcpy(*ppTlvOut,

Adapter->wps.wpsIe.VendHdr.Oui,

Adapter->wps.wpsIe.VendHdr.Len);

*ppTlvOut += (Adapter->wps.wpsIe.VendHdr.Len

+ sizeof(M rvlIEtypesHeader_t));

}

}

/**

* @brief Construct a wlan_scan_cmd_config structure to use in issue scan cmds *

* Application layer or other functions can invoke wlan_scan_networks

* with a scan configuration supplied in a wlan_ioctl_user_scan_cfg struct. * This structure is used as the basis of one or many wlan_scan_cmd_config

* commands that are sent to the command processing module and sent to

* firmware.

*

* Create a wlan_scan_cmd_config based on the following user supplied

* parameters (if present):

* - SSID filter

* - BSSID filter

* - Number of Probes to be sent

* - Channel list

*

* If the SSID or BSSID filter is not present, disable/clear the filter.

* If the number of probes is not set, use the adapter default setting

* Qualify the channel

*

* @param priv A pointer to wlan_private structure

* @param pUserScanIn NULL or pointer to scan configuration parameters

* @param pScanCfgOut Output parameter: Resulting scan configuration

* @param ppChanTlvOut Output parameter: Pointer to the start of the

* channel TLV portion of the output scan config

* @param pScanChanList Output parameter: Pointer to the resulting channel * list to scan

* @param pMaxChanPerScan Output parameter: Number of channels to scan for

* each issuance of the firmware scan command

* @param pFilteredScan Output parameter: Flag indicating whether or not

* a BSSID or SSID filter is being sent in the

* command to firmware. Used to increase the number

* of channels sent in a scan command and to

* disable the firmware channel scan filter.

* @param pScanCurrentOnly Output parameter: Flag indicating whether or not

* we are only scanning our current active channel

*

* @return void

*/

static void

w lan_scan_setup_scan_config(w lan_private * priv,

const w lan_ioctl_user_scan_cfg * pUserScanIn,

wlan_scan_cmd_config * pScanCfgOut,

MrvlIEtypes_ChanListParamSet_t ** ppChanTlvOut,

ChanScanParamSet_t * pScanChanList,

int *pMaxChanPerScan,

BOOLEAN * pFilteredScan,

BOOLEAN * pScanCurrentOnly)

{

wlan_adapter *Adapter = priv->adapter;

const u8 zeroMac[E TH_ALEN] = { 0, 0, 0, 0, 0, 0 };

MrvlIEtypes_NumProbes_t *pNumProbesTlv;

u8 *pTlvPos;

u16 numProbes;

u16 ssidLen;

int chanIdx;

int scanType;

int scanDur;

int channel;

int radioType;

int ssidIdx;

BOOLEAN ssidFilter;

MrvlIEtypes_WildCardSsIdParamSet_t *pWildCardSsidTlv;

/* T he tlvBufferLen is calculated for each scan command. The TLVs added

* in this routine will be preserved since the routine that sends

* the command will append channelTLVs at *ppChanTlvOut. The difference * between the *ppChanTlvOut and the tlvBuffer start will be used

* to calculate the size of anything we add in this routine.

*/

pScanCfgOut->tlvBufferLen = 0;

/* R unning tlv pointer. Assigned to ppChanTlvOut at end of function

* so later routines know where channels can be added to the command buf */

pTlvPos = pScanCfgOut->tlvBuffer;

/*

* Set the initial scan paramters for progressive scanning. If a specific * BSSID or SSID is used, the number of channels in the scan command

* will be increased to the absolute maximum

*/

*pMaxChanPerScan = M RVDRV_MAX_CHANNELS_PER_SCAN;

/* I nitialize the scan as un-filtered; the flag is later set to

* TRUE below if a SSID or BSSID filter is sent in the command

*/

*pFilteredScan = FALSE;

/* I nitialize the scan as not being only on the current channel. If

* the channel list is customized, only contains one channel, and

* is the active channel, this is set true and data flow is not halted. */

*pScanCurrentOnly = FALSE;

if (pUserScanIn) {

/* D efault the ssidFilter flag to TRUE, set false under certain

* wildcard conditions and qualified by the existence of an SSID

* list before marking the scan as filtered

*/

ssidFilter = TRUE;

/* S et the bss type scan filter, use Adapter setting if unset */

pScanCfgOut->bssType = (pUserScanIn->bssType ? pUserScanIn->bssType : Adapter->ScanMode);

/* S et the number of probes to send, use Adapter setting if unset */

numProbes = (pUserScanIn->numProbes ? pUserScanIn->numProbes :

Adapter->ScanProbes);

/*

* Set the BSSID filter to the incoming configuration,

* if non-zero. If not set, it will remain disabled (all zeros).

*/

memcpy(pScanCfgOut->specificBSSID,

pUserScanIn->specificBSSID,

sizeof(pScanCfgOut->specificBSSID));

for (ssidIdx = 0; ((ssidIdx < NELEMENTS(pUserScanIn->ssidList))

&& (*pUserScanIn->ssidList[ssidIdx].ssid

|| pUserScanIn->ssidList[ssidIdx].maxLen));

ssidIdx++) {

ssidLen = strlen(pUserScanIn->ssidList[ssidIdx].ssid) + 1;

pWildCardSsidTlv = (M rvlIEtypes_WildCardSsIdParamSet_t *) pTlvPos; pWildCardSsidTlv->Header.Type

= w lan_cpu_to_le16(T LV_TYPE_WILDCARDSSID);

pWildCardSsidTlv->Header.Len

= ssidLen + sizeof(pWildCardSsidTlv->MaxSsidLength);

pWildCardSsidTlv->MaxSsidLength

= pUserScanIn->ssidList[ssidIdx].maxLen;

memcpy(pWildCardSsidTlv->SsId,

pUserScanIn->ssidList[ssidIdx].ssid, ssidLen);

pTlvPos += (sizeof(pWildCardSsidTlv->Header)

+ pWildCardSsidTlv->Header.Len);

pWildCardSsidTlv->Header.Len

= w lan_cpu_to_le16(pWildCardSsidTlv->Header.Len);

printf( "Scan: ssidList[%d]: %s, %d\n",

ssidIdx,

pWildCardSsidTlv->SsId, pWildCardSsidTlv->MaxSsidLength);

/* Empty wildcard ssid with a maxlen will match many or potentially * all SSIDs (maxlen == 32), therefore do not treat the scan

* as filtered.

*/

if ((ssidLen == 0) && pWildCardSsidTlv->MaxSsidLength) {

ssidFilter = FALSE;

}

}

/*

* The default number of channels sent in the command is low to

* ensure the response buffer from the firmware does not truncate

* scan results. That is not an issue with an SSID or BSSID

* filter applied to the scan results in the firmware.

*/

if ((ssidIdx && ssidFilter)

|| memcmp(pScanCfgOut->specificBSSID, &zeroMac, sizeof(zeroMac))) { *pFilteredScan = TRUE;

}

} else {

pScanCfgOut->bssType = Adapter->ScanMode;

numProbes = Adapter->ScanProbes;

}

/* I f the input config or adapter has the number of Probes set, add tlv */ if (numProbes) {

printf( "Scan: numProbes = %d\n", numProbes);

pNumProbesTlv = (M rvlIEtypes_NumProbes_t *) pTlvPos;

pNumProbesTlv->Header.Type = w lan_cpu_to_le16(T LV_TYPE_NUMPROBES);

pNumProbesTlv->Header.Len = sizeof(pNumProbesTlv->NumProbes);

pNumProbesTlv->NumProbes = w lan_cpu_to_le16(numProbes);

pTlvPos += sizeof(pNumProbesTlv->Header) + pNumProbesTlv->Header.Len;

pNumProbesTlv->Header.Len =

wlan_cpu_to_le16(pNumProbesTlv->Header.Len);

}

wlan_add_wps_probe_request_ie(priv, &pTlvPos);

/*

* Set the output for the channel TLV to the address in the tlv buffer

* past any TLVs that were added in this fuction (SSID, numProbes).

* Channel TLVs will be added past this for each scan command, preserving * the TLVs that were previously added.

*/

*ppChanTlvOut = (M rvlIEtypes_ChanListParamSet_t *) pTlvPos;

if (pUserScanIn && pUserScanIn->chanList[0].chanNumber) {

printf( "Scan: Using supplied channel list\n");

for (chanIdx = 0;

chanIdx < W LAN_IOCTL_USER_SCAN_CHAN_MAX

&& pUserScanIn->chanList[chanIdx].chanNumber; chanIdx++) {

channel = pUserScanIn->chanList[chanIdx].chanNumber;

(pScanChanList + chanIdx) ->ChanNumber = channel;

radioType = pUserScanIn->chanList[chanIdx].radioType;

(pScanChanList + chanIdx) ->RadioType = radioType;

scanType = pUserScanIn->chanList[chanIdx].scanType;

if (scanType == H ostCmd_SCAN_TYPE_PASSIVE) {

(pScanChanList + chanIdx) ->ChanScanMode.PassiveScan = TRUE;

} else {

(pScanChanList + chanIdx) ->ChanScanMode.PassiveScan = FALSE;

}

if (pUserScanIn->chanList[chanIdx].scanTime) {

scanDur = pUserScanIn->chanList[chanIdx].scanTime;

} else {

if (scanType == H ostCmd_SCAN_TYPE_PASSIVE) {

scanDur = Adapter->PassiveScanTime;

} else if (*pFilteredScan) {

scanDur = Adapter->SpecificScanTime;

} else {

scanDur = Adapter->ActiveScanTime;

}

}

(pScanChanList + chanIdx) ->MinScanTime =

wlan_cpu_to_le16(scanDur);

(pScanChanList + chanIdx) ->MaxScanTime =

wlan_cpu_to_le16(scanDur);

}

/* Check if we are only scanning the current channel */

if ((chanIdx == 1)

&& (pUserScanIn->chanList[0].chanNumber

== priv->adapter->CurBssParams.BSSDescriptor.Channel)) {

*pScanCurrentOnly = TRUE;

printf( "Scan: Scanning current channel only");

}

} else {

printf( "Scan: Creating full region channel list\n");

wlan_scan_create_channel_list(priv, pScanChanList, *pFilteredScan);

}

}

/**

* @brief Construct and send multiple scan config commands to the firmware

*

* Previous routines have created a wlan_scan_cmd_config with any requested

* TLVs. This function splits the channel TLV into maxChanPerScan lists

* and sends the portion of the channel TLV along with the other TLVs

* to the wlan_cmd routines for execution in the firmware.

*

* @param priv A pointer to wlan_private structure

* @param maxChanPerScan Maximum number channels to be included in each

* scan command sent to firmware

* @param filteredScan Flag indicating whether or not a BSSID or SSID

* filter is being used for the firmware command

* scan command sent to firmware

* @param pScanCfgOut Scan configuration used for this scan.

* @param pChanTlvOut Pointer in the pScanCfgOut where the channel TLV

* should start. This is past any other TLVs that

* must be sent down in each firmware command.

* @param pScanChanList List of channels to scan in maxChanPerScan segments *

* @return WLAN_STATUS_SUCCESS or error return otherwise

*/

static int

w lan_scan_channel_list(w lan_private * priv,

int maxChanPerScan,

BOOLEAN filteredScan,

wlan_scan_cmd_config * pScanCfgOut,

MrvlIEtypes_ChanListParamSet_t * pChanTlvOut,

ChanScanParamSet_t * pScanChanList)

{

ChanScanParamSet_t *pTmpChan;

//ChanScanParamSet_t *pStartChan;

//u8 scanBand;

int doneEarly;

int tlvIdx;

int totalscantime;

int ret;

ENTER();

if (pScanCfgOut == 0 || pChanTlvOut == 0 || pScanChanList == 0) {

printf( "Scan: Null detect: %p, %p, %p\n",

pScanCfgOut, pChanTlvOut, pScanChanList);

return W LAN_STATUS_FAILURE;

}

ret = W LAN_STATUS_SUCCESS;

pChanTlvOut->Header.Type = w lan_cpu_to_le16(T LV_TYPE_CHANLIST);

/* Set the temp channel struct pointer to the start of the desired list */ pTmpChan = pScanChanList;

/* L oop through the desired channel list, sending a new firmware scan

* commands for each maxChanPerScan channels (or for 1,6,11 individually * if configured accordingly)

*/

while (pTmpChan->ChanNumber) {

tlvIdx = 0;

totalscantime = 0;

pChanTlvOut->Header.Len = 0;

// scanBand = pTmpChan->RadioType;

// pStartChan = pTmpChan;

doneEarly = FALSE;

/* C onstruct the Channel TLV for the scan command. Continue to

* insert channel TLVs until:

* - the tlvIdx hits the maximum configured per scan command

* - the next channel to insert is 0 (end of desired channel list)

* - doneEarly is set (controlling individual scanning of 1,6,11)

*/

while (tlvIdx < maxChanPerScan && pTmpChan->ChanNumber && !doneEarly) { printf( "Scan: Chan(%3d), Radio(%d), Mode(%d,%d), Dur(%d)\n",

pTmpChan->ChanNumber,

pTmpChan->RadioType,

pTmpChan->ChanScanMode.PassiveScan,

pTmpChan->ChanScanMode.DisableChanFilt,

pTmpChan->MaxScanTime);

/* Copy the current channel TLV to the command being prepared */

memcpy(pChanTlvOut->ChanScanParam + tlvIdx,

pTmpChan, sizeof(pChanTlvOut->ChanScanParam));

/* Increment the TLV header length by the size appended */

pChanTlvOut->Header.Len += sizeof(pChanTlvOut->ChanScanParam);

/*

* The tlv buffer length is set to the number of bytes of the

* between the channel tlv pointer and the start of the

* tlv buffer. This compensates for any TLVs that were appended * before the channel list.

*/

pScanCfgOut->tlvBufferLen = ((u8 *) pChanTlvOut

- pScanCfgOut->tlvBuffer);

/* Add the size of the channel tlv header and the data length */

pScanCfgOut->tlvBufferLen += (sizeof(pChanTlvOut->Header)

+ pChanTlvOut->Header.Len);

/* Increment the index to the channel tlv we are constructing */

tlvIdx++;

/* Count the total scan time per command */

totalscantime += pTmpChan->MaxScanTime;

doneEarly = FALSE;

/* S top the loop if the *current* channel is in the 1,6,11 set

* and we are not filtering on a BSSID or SSID.

*/

if (!filteredScan && (pTmpChan->ChanNumber == 1

|| pTmpChan->ChanNumber == 6

|| pTmpChan->ChanNumber == 11)) {

doneEarly = TRUE;

}

/* Increment the tmp pointer to the next channel to be scanned */

pTmpChan++;

/* S top the loop if the *next* channel is in the 1,6,11 set.

* This will cause it to be the only channel scanned on the next

* interation

*/

if (!filteredScan && (pTmpChan->ChanNumber == 1

|| pTmpChan->ChanNumber == 6

|| pTmpChan->ChanNumber == 11)) {

doneEarly = TRUE;

}

}

/* The total scan time should be less than scan command timeout value */ if (totalscantime > M RVDRV_MAX_TOTAL_SCAN_TIME) {

printf(

"Total scan time %d ms is over limit (%d ms), scan skipped\n", totalscantime, M RVDRV_MAX_TOTAL_SCAN_TIME);

ret = W LAN_STATUS_FAILURE;

break;

}

pChanTlvOut->Header.Len = w lan_cpu_to_le16(pChanTlvOut->Header.Len);

/* Send the scan command to the firmware with the specified cfg */

ret = PrepareAndSendCommand(priv, H ostCmd_CMD_802_11_SCAN, 0,

HostCmd_OPTION_WAITFORRSP, 0,

pScanCfgOut);

}

LEAVE();

if (ret) {

return W LAN_STATUS_FAILURE;

}

return W LAN_STATUS_SUCCESS;

}

/**

* @brief Internal function used to start a scan based on an input config

*

* Use the input user scan configuration information when provided in

* order to send the appropriate scan commands to firmware to populate or

* update the internal driver scan table

*

* @param priv A pointer to wlan_private structure

* @param pUserScanIn Pointer to the input configuration for the requested

* scan.

*

* @return WLAN_STATUS_SUCCESS or < 0 if error

*/

static int

w lan_scan_networks(w lan_private * priv,

const w lan_ioctl_user_scan_cfg * pUserScanIn)

{

wlan_adapter *Adapter = priv->adapter;

MrvlIEtypes_ChanListParamSet_t *pChanTlvOut;

ChanScanParamSet_t scanChanList[W LAN_IOCTL_USER_SCAN_CHAN_MAX];

wlan_scan_cmd_config_tlv scanCfgOut;

BOOLEAN keepPreviousScan;

BOOLEAN filteredScan;

BOOLEAN scanCurrentChanOnly;

int maxChanPerScan;

int ret;

BOOLEAN bBgScan;

ENTER();

memset(scanChanList, 0x00, sizeof(scanChanList));

memset(&scanCfgOut, 0x00, sizeof(scanCfgOut));

keepPreviousScan = FALSE;

wlan_scan_setup_scan_config(priv,

pUserScanIn,

&scanCfgOut.config,

&pChanTlvOut,

scanChanList,

&maxChanPerScan,

&filteredScan, &scanCurrentChanOnly);

if (pUserScanIn) {

keepPreviousScan = pUserScanIn->keepPreviousScan;

}

if (keepPreviousScan == FALSE) {

memset(Adapter->ScanTable, 0x00,

sizeof(B SSDescriptor_t) * M RVDRV_MAX_BSSID_LIST);

Adapter->NumInScanTable = 0;

Adapter->pBeaconBufEnd = Adapter->beaconBuffer;

}

/* Keep the data path active if we are only scanning our current channel */

if (!scanCurrentChanOnly) {

// printf( "Scan: WMM Queue stop\n");

// priv->wlan_https://www.360docs.net/doc/2615204388.html,dev->watchdog_timeo = MRVDRV_SCAN_WATCHDOG_TIMEOUT;

/* I f WMM queues are in use, only stop the internal data queues */

wmm_stop_queue(priv);

}

bBgScan = priv->adapter->bgScanConfig->Enable;

if (priv->adapter->bgScanConfig->Enable == TRUE) {

wlan_bg_scan_enable(priv, FALSE);

}

ret = w lan_scan_channel_list(priv,

maxChanPerScan,

filteredScan,

&scanCfgOut.config,

pChanTlvOut, scanChanList);

/* P rocess the resulting scan table:

* - Remove any bad ssids

* - Update our current BSS information from scan data

*/

wlan_scan_process_results(priv);

if (bBgScan == TRUE) {

wlan_bg_scan_enable(priv, TRUE);

}

printf( "Scan: WMM Queue start\n");

//priv->wlan_https://www.360docs.net/doc/2615204388.html,dev->watchdog_timeo = MRVDRV_DEFAULT_WATCHDOG_TIMEOUT; xzw1234 if (Adapter->MediaConnectStatus == WlanMediaStateConnected) {

wmm_start_queue(priv);

}

os_carrier_on(priv);

os_start_queue(priv);

LEAVE();

return ret;

}

/**

* @brief Create a brief scan resp to relay basic BSS info to the app layer

*

* When the beacon/probe response has not been buffered, use the saved BSS

* information available to provide a minimum response for the application

* ioctl retrieval routines. Include:

* - Timestamp

* - Beacon Period

* - Capabilities (including WMM Element if available)

* - SSID

*

* @param ppBuffer Output parameter: Buffer used to create basic scan rsp

* @param pBSSDesc Pointer to a BSS entry in the scan table to create

* scan response from for delivery to the application layer

*

* @return void

*/

static void

w lan_scan_create_brief_table_entry(u8 ** ppBuffer, B SSDescriptor_t * pBSSDesc)

{

u8 *pTmpBuf = *ppBuffer;

u8 tmpSSIDHdr[2];

u8 ieLen;

if (c opy_to_user(pTmpBuf, pBSSDesc->TimeStamp,

sizeof(pBSSDesc->TimeStamp))) {

PRINTM(INFO, "Copy to user failed\n");

return;

}

pTmpBuf += sizeof(pBSSDesc->TimeStamp);

if (c opy_to_user(pTmpBuf, &pBSSDesc->BeaconPeriod,

sizeof(pBSSDesc->BeaconPeriod))) {

PRINTM(INFO, "Copy to user failed\n");

return;

}

pTmpBuf += sizeof(pBSSDesc->BeaconPeriod);

if (c opy_to_user(pTmpBuf, &pBSSDesc->Cap, sizeof(pBSSDesc->Cap))) {

PRINTM(INFO, "Copy to user failed\n");

return;

}

pTmpBuf += sizeof(pBSSDesc->Cap);

tmpSSIDHdr[0] = 0; /* Element ID for SSID is zero */

tmpSSIDHdr[1] = pBSSDesc->Ssid.SsidLength;

if (c opy_to_user(pTmpBuf, tmpSSIDHdr, sizeof(tmpSSIDHdr))) {

PRINTM(INFO, "Copy to user failed\n");

return;

}

pTmpBuf += sizeof(tmpSSIDHdr);

if (c opy_to_user(pTmpBuf, pBSSDesc->Ssid.Ssid, pBSSDesc->Ssid.SsidLength)) { PRINTM(INFO, "Copy to user failed\n");

return;

}

pTmpBuf += pBSSDesc->Ssid.SsidLength;

if (pBSSDesc->wmmIE.VendHdr.ElementId == W MM_IE) {

ieLen = sizeof(I EEEtypes_Header_t) + pBSSDesc->wmmIE.VendHdr.Len;

if (c opy_to_user(pTmpBuf, &pBSSDesc->wmmIE, ieLen)) {

PRINTM(INFO, "Copy to user failed\n");

return;

}

pTmpBuf += ieLen;

}

if (pBSSDesc->wpaIE.VendHdr.ElementId == W PA_IE) {

ieLen = sizeof(I EEEtypes_Header_t) + pBSSDesc->wpaIE.VendHdr.Len;

if (c opy_to_user(pTmpBuf, &pBSSDesc->wpaIE, ieLen)) {

PRINTM(INFO, "Copy to user failed\n");

return;

}

pTmpBuf += ieLen;

}

if (pBSSDesc->rsnIE.IeeeHdr.ElementId == R SN_IE) {

ieLen = sizeof(I EEEtypes_Header_t) + pBSSDesc->rsnIE.IeeeHdr.Len;

if (c opy_to_user(pTmpBuf, &pBSSDesc->rsnIE, ieLen)) {

PRINTM(INFO, "Copy to user failed\n");

return;

}

pTmpBuf += ieLen;

}

*ppBuffer = pTmpBuf;

}

/**

* @brief Inspect the scan response buffer for pointers to expected TLVs

*

* TLVs can be included at the end of the scan response BSS information.

* Parse the data in the buffer for pointers to TLVs that can potentially * be passed back in the response

*

* @param pTlv Pointer to the start of the TLV buffer to parse

* @param tlvBufSize Size of the TLV buffer

* @param ppTsfTlv Output parameter: Pointer to the TSF TLV if found

*

* @return void

*/

static void

w lan_ret_802_11_scan_get_tlv_ptrs(M rvlIEtypes_Data_t * pTlv,

int tlvBufSize,

MrvlIEtypes_TsfTimestamp_t ** ppTsfTlv)

{

MrvlIEtypes_Data_t *pCurrentTlv;

int tlvBufLeft;

u16 tlvType;

u16 tlvLen;

pCurrentTlv = pTlv;

tlvBufLeft = tlvBufSize;

*ppTsfTlv = NULL;

PRINTM(INFO, "SCAN_RESP: tlvBufSize = %d\n", tlvBufSize);

HEXDUMP("SCAN_RESP: TLV Buf", (u8 *) pTlv, tlvBufSize);

while (tlvBufLeft >= sizeof(M rvlIEtypesHeader_t)) {

tlvType = w lan_le16_to_cpu(pCurrentTlv->Header.Type);

tlvLen = w lan_le16_to_cpu(pCurrentTlv->Header.Len);

switch (tlvType) {

case T LV_TYPE_TSFTIMESTAMP:

PRINTM(INFO, "SCAN_RESP: TSF Timestamp TLV, len = %d\n", tlvLen); *ppTsfTlv = (M rvlIEtypes_TsfTimestamp_t *) pCurrentTlv;

break;

default:

PRINTM(INFO, "SCAN_RESP: Unhandled TLV = %d\n", tlvType);

/* G ive up, this seems corrupted */

return;

} /* switch */

tlvBufLeft -= (sizeof(pTlv->Header) + tlvLen);

pCurrentTlv = (M rvlIEtypes_Data_t *) (pCurrentTlv->Data + tlvLen);

} /* while */

}

/**

* @brief Interpret a BSS scan response returned from the firmware

*

* Parse the various fixed fields and IEs passed back for a a BSS probe

* response or beacon from the scan command. Record information as needed

* in the scan table BSSDescriptor_t for that entry.

*

* @param pBSSIDEntry Output parameter: Pointer to the BSS Entry

*

* @return WLAN_STATUS_SUCCESS or WLAN_STATUS_FAILURE

*/

static int

InterpretBSSDescriptionWithIE(B SSDescriptor_t * pBSSEntry,

u8 ** pBeaconInfo, int *bytesLeft)

{

IEEEtypes_ElementId_e elemID;

IEEEtypes_FhParamSet_t *pFH;

IEEEtypes_DsParamSet_t *pDS;

IEEEtypes_CfParamSet_t *pCF;

IEEEtypes_IbssParamSet_t *pIbss;

IEEEtypes_CapInfo_t *pCap;

WLAN_802_11_FIXED_IEs fixedIE;

u8 *pCurrentPtr;

u8 *pRate;

u8 elemLen;

u16 totalIeLen;

u8 bytesToCopy;

u8 rateSize;

u16 beaconSize;

BOOLEAN foundDataRateIE;

int bytesLeftForCurrentBeacon;

IEEEtypes_ERPInfo_t *pERPInfo;

IEEEtypes_VendorSpecific_t *pVendorIe;

const u8 w pa_oui[4] = { 0x00, 0x50, 0xf2, 0x01 };

const u8 w mm_oui[4] = { 0x00, 0x50, 0xf2, 0x02 };

const u8 w ps_oui[4] = { 0x00, 0x50, 0xf2, 0x04 };

IEEEtypes_CountryInfoSet_t *pcountryinfo;

ENTER();

foundDataRateIE = FALSE;

rateSize = 0;

beaconSize = 0;

if (*bytesLeft >= sizeof(beaconSize)) {

/* E xtract & convert beacon size from the command buffer */

memcpy(&beaconSize, *pBeaconInfo, sizeof(beaconSize));

beaconSize = w lan_le16_to_cpu(beaconSize);

*bytesLeft -= sizeof(beaconSize);

*pBeaconInfo += sizeof(beaconSize);

}

if (beaconSize == 0 || beaconSize > *bytesLeft) {

*pBeaconInfo += *bytesLeft;

*bytesLeft = 0;

return W LAN_STATUS_FAILURE;

}

/* Initialize the current working beacon pointer for this BSS iteration */ pCurrentPtr = *pBeaconInfo;

/* Advance the return beacon pointer past the current beacon */

*pBeaconInfo += beaconSize;

*bytesLeft -= beaconSize;

bytesLeftForCurrentBeacon = beaconSize;

memcpy(pBSSEntry->MacAddress, pCurrentPtr, M RVDRV_ETH_ADDR_LEN);

PRINTM(INFO, "InterpretIE: AP MAC Addr-%02x:%02x:%02x:%02x:%02x:%02x\n", pBSSEntry->MacAddress[0], pBSSEntry->MacAddress[1],

pBSSEntry->MacAddress[2], pBSSEntry->MacAddress[3],

pBSSEntry->MacAddress[4], pBSSEntry->MacAddress[5]);

pCurrentPtr += M RVDRV_ETH_ADDR_LEN;

bytesLeftForCurrentBeacon -= M RVDRV_ETH_ADDR_LEN;

if (bytesLeftForCurrentBeacon < 12) {

PRINTM(INFO, "InterpretIE: Not enough bytes left\n");

return W LAN_STATUS_FAILURE;

}

/*

* next 4 fields are RSSI, time stamp, beacon interval,

* and capability information

*/

/* R SSI is 1 byte long */

pBSSEntry->Rssi = w lan_le32_to_cpu((LONG) (*pCurrentPtr));

PRINTM(INFO, "InterpretIE: RSSI=%02X\n", *pCurrentPtr);

pCurrentPtr += 1;

bytesLeftForCurrentBeacon -= 1;

/*

* The RSSI is not part of the beacon/probe response. After we have

* advanced pCurrentPtr past the RSSI field, save the remaining

* data for use at the application layer

*/

pBSSEntry->pBeaconBuf = pCurrentPtr;

pBSSEntry->beaconBufSize = bytesLeftForCurrentBeacon;

/* t ime stamp is 8 bytes long */

memcpy(fixedIE.Timestamp, pCurrentPtr, 8);

memcpy(pBSSEntry->TimeStamp, pCurrentPtr, 8);

pCurrentPtr += 8;

bytesLeftForCurrentBeacon -= 8;

/* b eacon interval is 2 bytes long */

memcpy(&fixedIE.BeaconInterval, pCurrentPtr, 2);

pBSSEntry->BeaconPeriod = w lan_le16_to_cpu(fixedIE.BeaconInterval);

pCurrentPtr += 2;

bytesLeftForCurrentBeacon -= 2;

/* c apability information is 2 bytes long */

memcpy(&fixedIE.Capabilities, pCurrentPtr, 2);

PRINTM(INFO, "InterpretIE: fixedIE.Capabilities=0x%X\n",

fixedIE.Capabilities);

fixedIE.Capabilities = w lan_le16_to_cpu(fixedIE.Capabilities);

pCap = (I EEEtypes_CapInfo_t *) & fixedIE.Capabilities;

memcpy(&pBSSEntry->Cap, pCap, sizeof(I EEEtypes_CapInfo_t));

pCurrentPtr += 2;

bytesLeftForCurrentBeacon -= 2;

/* r est of the current buffer are IE's */

PRINTM(INFO, "InterpretIE: IELength for this AP = %d\n",

bytesLeftForCurrentBeacon);

HEXDUMP("InterpretIE: IE info", (u8 *) pCurrentPtr,

bytesLeftForCurrentBeacon);

if (pCap->Privacy) {

PRINTM(INFO, "InterpretIE: AP WEP enabled\n");

pBSSEntry->Privacy = W lan802_11PrivFilter8021xWEP;

} else {

pBSSEntry->Privacy = W lan802_11PrivFilterAcceptAll;

}

if (pCap->Ibss == 1) {

pBSSEntry->InfrastructureMode = W lan802_11IBSS;

} else {

pBSSEntry->InfrastructureMode = W lan802_11Infrastructure;

}

/* process variable IE */

while (bytesLeftForCurrentBeacon >= 2) {

elemID = (I EEEtypes_ElementId_e) (*((u8 *) pCurrentPtr));

elemLen = *((u8 *) pCurrentPtr + 1);

totalIeLen = elemLen + sizeof(I EEEtypes_Header_t);

if (bytesLeftForCurrentBeacon < elemLen) {

PRINTM(INFO, "InterpretIE: Error in processing IE, "

"bytes left < IE length\n");

bytesLeftForCurrentBeacon = 0;

continue;

}

switch (elemID) {

case SSID:

pBSSEntry->Ssid.SsidLength = elemLen;

memcpy(pBSSEntry->Ssid.Ssid, (pCurrentPtr + 2), elemLen);

PRINTM(INFO, "InterpretIE: Ssid: %-32s\n", pBSSEntry->Ssid.Ssid); break;

case S UPPORTED_RATES:

memcpy(pBSSEntry->DataRates, pCurrentPtr + 2, elemLen);

memcpy(pBSSEntry->SupportedRates, pCurrentPtr + 2, elemLen);

HEXDUMP("InterpretIE: SupportedRates:",

pBSSEntry->SupportedRates, elemLen);

rateSize = elemLen;

foundDataRateIE = TRUE;

break;

case E XTRA_IE:

PRINTM(INFO, "InterpretIE: EXTRA_IE Found!\n");

pBSSEntry->e xtra_ie = 1;

break;

case F H_PARAM_SET:

pFH = (I EEEtypes_FhParamSet_t *) pCurrentPtr;

pBSSEntry->NetworkTypeInUse = W lan802_11FH;

memcpy(&pBSSEntry->PhyParamSet.FhParamSet, pFH,

sizeof(I EEEtypes_FhParamSet_t));

pBSSEntry->PhyParamSet.FhParamSet.DwellTime

=

wlan_le16_to_cpu(pBSSEntry->PhyParamSet.FhParamSet.DwellTime); break;

case D S_PARAM_SET:

pDS = (I EEEtypes_DsParamSet_t *) pCurrentPtr;

pBSSEntry->NetworkTypeInUse = W lan802_11DS;

pBSSEntry->Channel = pDS->CurrentChan;

memcpy(&pBSSEntry->PhyParamSet.DsParamSet, pDS,

sizeof(I EEEtypes_DsParamSet_t));

break;

case C F_PARAM_SET:

pCF = (I EEEtypes_CfParamSet_t *) pCurrentPtr;

memcpy(&pBSSEntry->SsParamSet.CfParamSet, pCF,

sizeof(I EEEtypes_CfParamSet_t));

break;

case I BSS_PARAM_SET:

pIbss = (I EEEtypes_IbssParamSet_t *) pCurrentPtr;

pBSSEntry->ATIMWindow = w lan_le32_to_cpu(pIbss->AtimWindow);

memcpy(&pBSSEntry->SsParamSet.IbssParamSet, pIbss,

sizeof(I EEEtypes_IbssParamSet_t));

break;

/* Handle Country Info IE */

case C OUNTRY_INFO:

pcountryinfo = (I EEEtypes_CountryInfoSet_t *) pCurrentPtr;

if (pcountryinfo->Len < sizeof(pcountryinfo->CountryCode) ||

pcountryinfo->Len + 2 >

sizeof(I EEEtypes_CountryInfoFullSet_t)) {

PRINTM(INFO,

"InterpretIE: 11D- Err "

"CountryInfo len =%d min=%d max=%d\n",

pcountryinfo->Len, sizeof(pcountryinfo->CountryCode), sizeof(I EEEtypes_CountryInfoFullSet_t));

LEAVE();

return W LAN_STATUS_FAILURE;

}

memcpy(&pBSSEntry->CountryInfo,

pcountryinfo, pcountryinfo->Len + 2);

HEXDUMP("InterpretIE: 11D- CountryInfo:",

(u8 *) pcountryinfo, (u32) (pcountryinfo->Len + 2));

break;

case E RP_INFO:

pERPInfo = (I EEEtypes_ERPInfo_t *) pCurrentPtr;

pBSSEntry->ERPFlags = pERPInfo->ERPFlags;

break;

case E XTENDED_SUPPORTED_RATES:

/*

* only process extended supported rate

* if data rate is already found.

* data rate IE should come before

* extended supported rate IE

*/

if (foundDataRateIE) {

if ((elemLen + rateSize) > W LAN_SUPPORTED_RATES) {

bytesToCopy = (W LAN_SUPPORTED_RATES - rateSize);

} else {

bytesToCopy = elemLen;

}

pRate = (u8 *) pBSSEntry->DataRates;

pRate += rateSize;

memcpy(pRate, pCurrentPtr + 2, bytesToCopy);

pRate = (u8 *) pBSSEntry->SupportedRates;

pRate += rateSize;

memcpy(pRate, pCurrentPtr + 2, bytesToCopy);

}

HEXDUMP("InterpretIE: ExtSupportedRates:",

pBSSEntry->SupportedRates, elemLen + rateSize);

break;

case V ENDOR_SPECIFIC_221:

pVendorIe = (I EEEtypes_VendorSpecific_t *) pCurrentPtr;

if ((!memcmp

(pVendorIe->VendHdr.Oui, w pa_oui,

sizeof(pVendorIe->VendHdr.Oui)))

&& (pVendorIe->VendHdr.OuiType == w pa_oui[3])) {

pBSSEntry->wpaIE.VendHdr.Len

= (MIN(totalIeLen, sizeof(pBSSEntry->wpaIE))

- sizeof(I EEEtypes_Header_t));